git-gui/git-gui.sh

   1 #!/bin/sh
   2 # Tcl ignores the next line -*- tcl -*- \
   3 exec wish "$0" -- "$@"
   4
   5 set appvers {@@GITGUI_VERSION@@}
   6 set copyright {
   7 Copyright © 2006, 2007 Shawn Pearce, et. al.
   8
   9 This program is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2 of the License, or
  12 (at your option) any later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with this program; if not, write to the Free Software
  21 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA}
  22
  23 ######################################################################
  24 ##
  25 ## read only globals
  26
  27 set _appname [lindex [file split $argv0] end]
  28 set _gitdir {}
  29 set _gitexec {}
  30 set _reponame {}
  31 set _iscygwin {}
  32
  33 proc appname {} {
  34         global _appname
  35         return $_appname
  36 }
  37
  38 proc gitdir {args} {
  39         global _gitdir
  40         if {$args eq {}} {
  41                 return $_gitdir
  42         }
  43         return [eval [concat [list file join $_gitdir] $args]]
  44 }
  45
  46 proc gitexec {args} {
  47         global _gitexec
  48         if {$_gitexec eq {}} {
  49                 if {[catch {set _gitexec [git --exec-path]} err]} {
  50                         error "Git not installed?\n\n$err"
  51                 }
  52         }
  53         if {$args eq {}} {
  54                 return $_gitexec
  55         }
  56         return [eval [concat [list file join $_gitexec] $args]]
  57 }
  58
  59 proc reponame {} {
  60         global _reponame
  61         return $_reponame
  62 }
  63
  64 proc is_MacOSX {} {
  65         global tcl_platform tk_library
  66         if {[tk windowingsystem] eq {aqua}} {
  67                 return 1
  68         }
  69         return 0
  70 }
  71
  72 proc is_Windows {} {
  73         global tcl_platform
  74         if {$tcl_platform(platform) eq {windows}} {
  75                 return 1
  76         }
  77         return 0
  78 }
  79
  80 proc is_Cygwin {} {
  81         global tcl_platform _iscygwin
  82         if {$_iscygwin eq {}} {
  83                 if {$tcl_platform(platform) eq {windows}} {
  84                         if {[catch {set p [exec cygpath --windir]} err]} {
  85                                 set _iscygwin 0
  86                         } else {
  87                                 set _iscygwin 1
  88                         }
  89                 } else {
  90                         set _iscygwin 0
  91                 }
  92         }
  93         return $_iscygwin
  94 }
  95
  96 proc is_enabled {option} {
  97         global enabled_options
  98         if {[catch {set on $enabled_options($option)}]} {return 0}
  99         return $on
 100 }
 101
 102 proc enable_option {option} {
 103         global enabled_options
 104         set enabled_options($option) 1
 105 }
 106
 107 proc disable_option {option} {
 108         global enabled_options
 109         set enabled_options($option) 0
 110 }
 111
 112 ######################################################################
 113 ##
 114 ## config
 115
 116 proc is_many_config {name} {
 117         switch -glob -- $name {
 118         remote.*.fetch -
 119         remote.*.push
 120                 {return 1}
 121         *
 122                 {return 0}
 123         }
 124 }
 125
 126 proc is_config_true {name} {
 127         global repo_config
 128         if {[catch {set v $repo_config($name)}]} {
 129                 return 0
 130         } elseif {$v eq {true} || $v eq {1} || $v eq {yes}} {
 131                 return 1
 132         } else {
 133                 return 0
 134         }
 135 }
 136
 137 proc load_config {include_global} {
 138         global repo_config global_config default_config
 139
 140         array unset global_config
 141         if {$include_global} {
 142                 catch {
 143                         set fd_rc [open "| git config --global --list" r]
 144                         while {[gets $fd_rc line] >= 0} {
 145                                 if {[regexp {^([^=]+)=(.*)$} $line line name value]} {
 146                                         if {[is_many_config $name]} {
 147                                                 lappend global_config($name) $value
 148                                         } else {
 149                                                 set global_config($name) $value
 150                                         }
 151                                 }
 152                         }
 153                         close $fd_rc
 154                 }
 155         }
 156
 157         array unset repo_config
 158         catch {
 159                 set fd_rc [open "| git config --list" r]
 160                 while {[gets $fd_rc line] >= 0} {
 161                         if {[regexp {^([^=]+)=(.*)$} $line line name value]} {
 162                                 if {[is_many_config $name]} {
 163                                         lappend repo_config($name) $value
 164                                 } else {
 165                                         set repo_config($name) $value
 166                                 }
 167                         }
 168                 }
 169                 close $fd_rc
 170         }
 171
 172         foreach name [array names default_config] {
 173                 if {[catch {set v $global_config($name)}]} {
 174                         set global_config($name) $default_config($name)
 175                 }
 176                 if {[catch {set v $repo_config($name)}]} {
 177                         set repo_config($name) $default_config($name)
 178                 }
 179         }
 180 }
 181
 182 proc save_config {} {
 183         global default_config font_descs
 184         global repo_config global_config
 185         global repo_config_new global_config_new
 186
 187         foreach option $font_descs {
 188                 set name [lindex $option 0]
 189                 set font [lindex $option 1]
 190                 font configure $font \
 191                         -family $global_config_new(gui.$font^^family) \
 192                         -size $global_config_new(gui.$font^^size)
 193                 font configure ${font}bold \
 194                         -family $global_config_new(gui.$font^^family) \
 195                         -size $global_config_new(gui.$font^^size)
 196                 set global_config_new(gui.$name) [font configure $font]
 197                 unset global_config_new(gui.$font^^family)
 198                 unset global_config_new(gui.$font^^size)
 199         }
 200
 201         foreach name [array names default_config] {
 202                 set value $global_config_new($name)
 203                 if {$value ne $global_config($name)} {
 204                         if {$value eq $default_config($name)} {
 205                                 catch {git config --global --unset $name}
 206                         } else {
 207                                 regsub -all "\[{}\]" $value {"} value
 208                                 git config --global $name $value
 209                         }
 210                         set global_config($name) $value
 211                         if {$value eq $repo_config($name)} {
 212                                 catch {git config --unset $name}
 213                                 set repo_config($name) $value
 214                         }
 215                 }
 216         }
 217
 218         foreach name [array names default_config] {
 219                 set value $repo_config_new($name)
 220                 if {$value ne $repo_config($name)} {
 221                         if {$value eq $global_config($name)} {
 222                                 catch {git config --unset $name}
 223                         } else {
 224                                 regsub -all "\[{}\]" $value {"} value
 225                                 git config $name $value
 226                         }
 227                         set repo_config($name) $value
 228                 }
 229         }
 230 }
 231
 232 ######################################################################
 233 ##
 234 ## handy utils
 235
 236 proc git {args} {
 237         return [eval exec git $args]
 238 }
 239
 240 proc error_popup {msg} {
 241         set title [appname]
 242         if {[reponame] ne {}} {
 243                 append title " ([reponame])"
 244         }
 245         set cmd [list tk_messageBox \
 246                 -icon error \
 247                 -type ok \
 248                 -title "$title: error" \
 249                 -message $msg]
 250         if {[winfo ismapped .]} {
 251                 lappend cmd -parent .
 252         }
 253         eval $cmd
 254 }
 255
 256 proc warn_popup {msg} {
 257         set title [appname]
 258         if {[reponame] ne {}} {
 259                 append title " ([reponame])"
 260         }
 261         set cmd [list tk_messageBox \
 262                 -icon warning \
 263                 -type ok \
 264                 -title "$title: warning" \
 265                 -message $msg]
 266         if {[winfo ismapped .]} {
 267                 lappend cmd -parent .
 268         }
 269         eval $cmd
 270 }
 271
 272 proc info_popup {msg {parent .}} {
 273         set title [appname]
 274         if {[reponame] ne {}} {
 275                 append title " ([reponame])"
 276         }
 277         tk_messageBox \
 278                 -parent $parent \
 279                 -icon info \
 280                 -type ok \
 281                 -title $title \
 282                 -message $msg
 283 }
 284
 285 proc ask_popup {msg} {
 286         set title [appname]
 287         if {[reponame] ne {}} {
 288                 append title " ([reponame])"
 289         }
 290         return [tk_messageBox \
 291                 -parent . \
 292                 -icon question \
 293                 -type yesno \
 294                 -title $title \
 295                 -message $msg]
 296 }
 297
 298 ######################################################################
 299 ##
 300 ## version check
 301
 302 if {{--version} eq $argv || {version} eq $argv} {
 303         puts "git-gui version $appvers"
 304         exit
 305 }
 306
 307 set req_maj 1
 308 set req_min 5
 309
 310 if {[catch {set v [git --version]} err]} {
 311         catch {wm withdraw .}
 312         error_popup "Cannot determine Git version:
 313
 314 $err
 315
 316 [appname] requires Git $req_maj.$req_min or later."
 317         exit 1
 318 }
 319 if {[regexp {^git version (\d+)\.(\d+)} $v _junk act_maj act_min]} {
 320         if {$act_maj < $req_maj
 321                 || ($act_maj == $req_maj && $act_min < $req_min)} {
 322                 catch {wm withdraw .}
 323                 error_popup "[appname] requires Git $req_maj.$req_min or later.
 324
 325 You are using $v."
 326                 exit 1
 327         }
 328 } else {
 329         catch {wm withdraw .}
 330         error_popup "Cannot parse Git version string:\n\n$v"
 331         exit 1
 332 }
 333 unset -nocomplain v _junk act_maj act_min req_maj req_min
 334
 335 ######################################################################
 336 ##
 337 ## repository setup
 338
 339 if {   [catch {set _gitdir $env(GIT_DIR)}]
 340         && [catch {set _gitdir [git rev-parse --git-dir]} err]} {
 341         catch {wm withdraw .}
 342         error_popup "Cannot find the git directory:\n\n$err"
 343         exit 1
 344 }
 345 if {![file isdirectory $_gitdir] && [is_Cygwin]} {
 346         catch {set _gitdir [exec cygpath --unix $_gitdir]}
 347 }
 348 if {![file isdirectory $_gitdir]} {
 349         catch {wm withdraw .}
 350         error_popup "Git directory not found:\n\n$_gitdir"
 351         exit 1
 352 }
 353 if {[lindex [file split $_gitdir] end] ne {.git}} {
 354         catch {wm withdraw .}
 355         error_popup "Cannot use funny .git directory:\n\n$_gitdir"
 356         exit 1
 357 }
 358 if {[catch {cd [file dirname $_gitdir]} err]} {
 359         catch {wm withdraw .}
 360         error_popup "No working directory [file dirname $_gitdir]:\n\n$err"
 361         exit 1
 362 }
 363 set _reponame [lindex [file split \
 364         [file normalize [file dirname $_gitdir]]] \
 365         end]
 366
 367 ######################################################################
 368 ##
 369 ## global init
 370
 371 set current_diff_path {}
 372 set current_diff_side {}
 373 set diff_actions [list]
 374 set ui_status_value {Initializing...}
 375
 376 set HEAD {}
 377 set PARENT {}
 378 set MERGE_HEAD [list]
 379 set commit_type {}
 380 set empty_tree {}
 381 set current_branch {}
 382 set current_diff_path {}
 383 set selected_commit_type new
 384
 385 ######################################################################
 386 ##
 387 ## task management
 388
 389 set rescan_active 0
 390 set diff_active 0
 391 set last_clicked {}
 392
 393 set disable_on_lock [list]
 394 set index_lock_type none
 395
 396 proc lock_index {type} {
 397         global index_lock_type disable_on_lock
 398
 399         if {$index_lock_type eq {none}} {
 400                 set index_lock_type $type
 401                 foreach w $disable_on_lock {
 402                         uplevel #0 $w disabled
 403                 }
 404                 return 1
 405         } elseif {$index_lock_type eq "begin-$type"} {
 406                 set index_lock_type $type
 407                 return 1
 408         }
 409         return 0
 410 }
 411
 412 proc unlock_index {} {
 413         global index_lock_type disable_on_lock
 414
 415         set index_lock_type none
 416         foreach w $disable_on_lock {
 417                 uplevel #0 $w normal
 418         }
 419 }
 420
 421 ######################################################################
 422 ##
 423 ## status
 424
 425 proc repository_state {ctvar hdvar mhvar} {
 426         global current_branch
 427         upvar $ctvar ct $hdvar hd $mhvar mh
 428
 429         set mh [list]
 430
 431         if {[catch {set current_branch [git symbolic-ref HEAD]}]} {
 432                 set current_branch {}
 433         } else {
 434                 regsub ^refs/((heads|tags|remotes)/)? \
 435                         $current_branch \
 436                         {} \
 437                         current_branch
 438         }
 439
 440         if {[catch {set hd [git rev-parse --verify HEAD]}]} {
 441                 set hd {}
 442                 set ct initial
 443                 return
 444         }
 445
 446         set merge_head [gitdir MERGE_HEAD]
 447         if {[file exists $merge_head]} {
 448                 set ct merge
 449                 set fd_mh [open $merge_head r]
 450                 while {[gets $fd_mh line] >= 0} {
 451                         lappend mh $line
 452                 }
 453                 close $fd_mh
 454                 return
 455         }
 456
 457         set ct normal
 458 }
 459
 460 proc PARENT {} {
 461         global PARENT empty_tree
 462
 463         set p [lindex $PARENT 0]
 464         if {$p ne {}} {
 465                 return $p
 466         }
 467         if {$empty_tree eq {}} {
 468                 set empty_tree [git mktree << {}]
 469         }
 470         return $empty_tree
 471 }
 472
 473 proc rescan {after {honor_trustmtime 1}} {
 474         global HEAD PARENT MERGE_HEAD commit_type
 475         global ui_index ui_workdir ui_status_value ui_comm
 476         global rescan_active file_states
 477         global repo_config
 478
 479         if {$rescan_active > 0 || ![lock_index read]} return
 480
 481         repository_state newType newHEAD newMERGE_HEAD
 482         if {[string match amend* $commit_type]
 483                 && $newType eq {normal}
 484                 && $newHEAD eq $HEAD} {
 485         } else {
 486                 set HEAD $newHEAD
 487                 set PARENT $newHEAD
 488                 set MERGE_HEAD $newMERGE_HEAD
 489                 set commit_type $newType
 490         }
 491
 492         array unset file_states
 493
 494         if {![$ui_comm edit modified]
 495                 || [string trim [$ui_comm get 0.0 end]] eq {}} {
 496                 if {[load_message GITGUI_MSG]} {
 497                 } elseif {[load_message MERGE_MSG]} {
 498                 } elseif {[load_message SQUASH_MSG]} {
 499                 }
 500                 $ui_comm edit reset
 501                 $ui_comm edit modified false
 502         }
 503
 504         if {[is_enabled branch]} {
 505                 load_all_heads
 506                 populate_branch_menu
 507         }
 508
 509         if {$honor_trustmtime && $repo_config(gui.trustmtime) eq {true}} {
 510                 rescan_stage2 {} $after
 511         } else {
 512                 set rescan_active 1
 513                 set ui_status_value {Refreshing file status...}
 514                 set cmd [list git update-index]
 515                 lappend cmd -q
 516                 lappend cmd --unmerged
 517                 lappend cmd --ignore-missing
 518                 lappend cmd --refresh
 519                 set fd_rf [open "| $cmd" r]
 520                 fconfigure $fd_rf -blocking 0 -translation binary
 521                 fileevent $fd_rf readable \
 522                         [list rescan_stage2 $fd_rf $after]
 523         }
 524 }
 525
 526 proc rescan_stage2 {fd after} {
 527         global ui_status_value
 528         global rescan_active buf_rdi buf_rdf buf_rlo
 529
 530         if {$fd ne {}} {
 531                 read $fd
 532                 if {![eof $fd]} return
 533                 close $fd
 534         }
 535
 536         set ls_others [list | git ls-files --others -z \
 537                 --exclude-per-directory=.gitignore]
 538         set info_exclude [gitdir info exclude]
 539         if {[file readable $info_exclude]} {
 540                 lappend ls_others "--exclude-from=$info_exclude"
 541         }
 542
 543         set buf_rdi {}
 544         set buf_rdf {}
 545         set buf_rlo {}
 546
 547         set rescan_active 3
 548         set ui_status_value {Scanning for modified files ...}
 549         set fd_di [open "| git diff-index --cached -z [PARENT]" r]
 550         set fd_df [open "| git diff-files -z" r]
 551         set fd_lo [open $ls_others r]
 552
 553         fconfigure $fd_di -blocking 0 -translation binary -encoding binary
 554         fconfigure $fd_df -blocking 0 -translation binary -encoding binary
 555         fconfigure $fd_lo -blocking 0 -translation binary -encoding binary
 556         fileevent $fd_di readable [list read_diff_index $fd_di $after]
 557         fileevent $fd_df readable [list read_diff_files $fd_df $after]
 558         fileevent $fd_lo readable [list read_ls_others $fd_lo $after]
 559 }
 560
 561 proc load_message {file} {
 562         global ui_comm
 563
 564         set f [gitdir $file]
 565         if {[file isfile $f]} {
 566                 if {[catch {set fd [open $f r]}]} {
 567                         return 0
 568                 }
 569                 set content [string trim [read $fd]]
 570                 close $fd
 571                 regsub -all -line {[ \r\t]+$} $content {} content
 572                 $ui_comm delete 0.0 end
 573                 $ui_comm insert end $content
 574                 return 1
 575         }
 576         return 0
 577 }
 578
 579 proc read_diff_index {fd after} {
 580         global buf_rdi
 581
 582         append buf_rdi [read $fd]
 583         set c 0
 584         set n [string length $buf_rdi]
 585         while {$c < $n} {
 586                 set z1 [string first "\0" $buf_rdi $c]
 587                 if {$z1 == -1} break
 588                 incr z1
 589                 set z2 [string first "\0" $buf_rdi $z1]
 590                 if {$z2 == -1} break
 591
 592                 incr c
 593                 set i [split [string range $buf_rdi $c [expr {$z1 - 2}]] { }]
 594                 set p [string range $buf_rdi $z1 [expr {$z2 - 1}]]
 595                 merge_state \
 596                         [encoding convertfrom $p] \
 597                         [lindex $i 4]? \
 598                         [list [lindex $i 0] [lindex $i 2]] \
 599                         [list]
 600                 set c $z2
 601                 incr c
 602         }
 603         if {$c < $n} {
 604                 set buf_rdi [string range $buf_rdi $c end]
 605         } else {
 606                 set buf_rdi {}
 607         }
 608
 609         rescan_done $fd buf_rdi $after
 610 }
 611
 612 proc read_diff_files {fd after} {
 613         global buf_rdf
 614
 615         append buf_rdf [read $fd]
 616         set c 0
 617         set n [string length $buf_rdf]
 618         while {$c < $n} {
 619                 set z1 [string first "\0" $buf_rdf $c]
 620                 if {$z1 == -1} break
 621                 incr z1
 622                 set z2 [string first "\0" $buf_rdf $z1]
 623                 if {$z2 == -1} break
 624
 625                 incr c
 626                 set i [split [string range $buf_rdf $c [expr {$z1 - 2}]] { }]
 627                 set p [string range $buf_rdf $z1 [expr {$z2 - 1}]]
 628                 merge_state \
 629                         [encoding convertfrom $p] \
 630                         ?[lindex $i 4] \
 631                         [list] \
 632                         [list [lindex $i 0] [lindex $i 2]]
 633                 set c $z2
 634                 incr c
 635         }
 636         if {$c < $n} {
 637                 set buf_rdf [string range $buf_rdf $c end]
 638         } else {
 639                 set buf_rdf {}
 640         }
 641
 642         rescan_done $fd buf_rdf $after
 643 }
 644
 645 proc read_ls_others {fd after} {
 646         global buf_rlo
 647
 648         append buf_rlo [read $fd]
 649         set pck [split $buf_rlo "\0"]
 650         set buf_rlo [lindex $pck end]
 651         foreach p [lrange $pck 0 end-1] {
 652                 merge_state [encoding convertfrom $p] ?O
 653         }
 654         rescan_done $fd buf_rlo $after
 655 }
 656
 657 proc rescan_done {fd buf after} {
 658         global rescan_active
 659         global file_states repo_config
 660         upvar $buf to_clear
 661
 662         if {![eof $fd]} return
 663         set to_clear {}
 664         close $fd
 665         if {[incr rescan_active -1] > 0} return
 666
 667         prune_selection
 668         unlock_index
 669         display_all_files
 670         reshow_diff
 671         uplevel #0 $after
 672 }
 673
 674 proc prune_selection {} {
 675         global file_states selected_paths
 676
 677         foreach path [array names selected_paths] {
 678                 if {[catch {set still_here $file_states($path)}]} {
 679                         unset selected_paths($path)
 680                 }
 681         }
 682 }
 683
 684 ######################################################################
 685 ##
 686 ## diff
 687
 688 proc clear_diff {} {
 689         global ui_diff current_diff_path current_diff_header
 690         global ui_index ui_workdir
 691
 692         $ui_diff conf -state normal
 693         $ui_diff delete 0.0 end
 694         $ui_diff conf -state disabled
 695
 696         set current_diff_path {}
 697         set current_diff_header {}
 698
 699         $ui_index tag remove in_diff 0.0 end
 700         $ui_workdir tag remove in_diff 0.0 end
 701 }
 702
 703 proc reshow_diff {} {
 704         global ui_status_value file_states file_lists
 705         global current_diff_path current_diff_side
 706
 707         set p $current_diff_path
 708         if {$p eq {}} {
 709                 # No diff is being shown.
 710         } elseif {$current_diff_side eq {}
 711                 || [catch {set s $file_states($p)}]
 712                 || [lsearch -sorted -exact $file_lists($current_diff_side) $p] == -1} {
 713                 clear_diff
 714         } else {
 715                 show_diff $p $current_diff_side
 716         }
 717 }
 718
 719 proc handle_empty_diff {} {
 720         global current_diff_path file_states file_lists
 721
 722         set path $current_diff_path
 723         set s $file_states($path)
 724         if {[lindex $s 0] ne {_M}} return
 725
 726         info_popup "No differences detected.
 727
 728 [short_path $path] has no changes.
 729
 730 The modification date of this file was updated
 731 by another application, but the content within
 732 the file was not changed.
 733
 734 A rescan will be automatically started to find
 735 other files which may have the same state."
 736
 737         clear_diff
 738         display_file $path __
 739         rescan {set ui_status_value {Ready.}} 0
 740 }
 741
 742 proc show_diff {path w {lno {}}} {
 743         global file_states file_lists
 744         global is_3way_diff diff_active repo_config
 745         global ui_diff ui_status_value ui_index ui_workdir
 746         global current_diff_path current_diff_side current_diff_header
 747
 748         if {$diff_active || ![lock_index read]} return
 749
 750         clear_diff
 751         if {$lno == {}} {
 752                 set lno [lsearch -sorted -exact $file_lists($w) $path]
 753                 if {$lno >= 0} {
 754                         incr lno
 755                 }
 756         }
 757         if {$lno >= 1} {
 758                 $w tag add in_diff $lno.0 [expr {$lno + 1}].0
 759         }
 760
 761         set s $file_states($path)
 762         set m [lindex $s 0]
 763         set is_3way_diff 0
 764         set diff_active 1
 765         set current_diff_path $path
 766         set current_diff_side $w
 767         set current_diff_header {}
 768         set ui_status_value "Loading diff of [escape_path $path]..."
 769
 770         # - Git won't give us the diff, there's nothing to compare to!
 771         #
 772         if {$m eq {_O}} {
 773                 set max_sz [expr {128 * 1024}]
 774                 if {[catch {
 775                                 set fd [open $path r]
 776                                 set content [read $fd $max_sz]
 777                                 close $fd
 778                                 set sz [file size $path]
 779                         } err ]} {
 780                         set diff_active 0
 781                         unlock_index
 782                         set ui_status_value "Unable to display [escape_path $path]"
 783                         error_popup "Error loading file:\n\n$err"
 784                         return
 785                 }
 786                 $ui_diff conf -state normal
 787                 if {![catch {set type [exec file $path]}]} {
 788                         set n [string length $path]
 789                         if {[string equal -length $n $path $type]} {
 790                                 set type [string range $type $n end]
 791                                 regsub {^:?\s*} $type {} type
 792                         }
 793                         $ui_diff insert end "* $type\n" d_@
 794                 }
 795                 if {[string first "\0" $content] != -1} {
 796                         $ui_diff insert end \
 797                                 "* Binary file (not showing content)." \
 798                                 d_@
 799                 } else {
 800                         if {$sz > $max_sz} {
 801                                 $ui_diff insert end \
 802 "* Untracked file is $sz bytes.
 803 * Showing only first $max_sz bytes.
 804 " d_@
 805                         }
 806                         $ui_diff insert end $content
 807                         if {$sz > $max_sz} {
 808                                 $ui_diff insert end "
 809 * Untracked file clipped here by [appname].
 810 * To see the entire file, use an external editor.
 811 " d_@
 812                         }
 813                 }
 814                 $ui_diff conf -state disabled
 815                 set diff_active 0
 816                 unlock_index
 817                 set ui_status_value {Ready.}
 818                 return
 819         }
 820
 821         set cmd [list | git]
 822         if {$w eq $ui_index} {
 823                 lappend cmd diff-index
 824                 lappend cmd --cached
 825         } elseif {$w eq $ui_workdir} {
 826                 if {[string index $m 0] eq {U}} {
 827                         lappend cmd diff
 828                 } else {
 829                         lappend cmd diff-files
 830                 }
 831         }
 832
 833         lappend cmd -p
 834         lappend cmd --no-color
 835         if {$repo_config(gui.diffcontext) > 0} {
 836                 lappend cmd "-U$repo_config(gui.diffcontext)"
 837         }
 838         if {$w eq $ui_index} {
 839                 lappend cmd [PARENT]
 840         }
 841         lappend cmd --
 842         lappend cmd $path
 843
 844         if {[catch {set fd [open $cmd r]} err]} {
 845                 set diff_active 0
 846                 unlock_index
 847                 set ui_status_value "Unable to display [escape_path $path]"
 848                 error_popup "Error loading diff:\n\n$err"
 849                 return
 850         }
 851
 852         fconfigure $fd \
 853                 -blocking 0 \
 854                 -encoding binary \
 855                 -translation binary
 856         fileevent $fd readable [list read_diff $fd]
 857 }
 858
 859 proc read_diff {fd} {
 860         global ui_diff ui_status_value diff_active
 861         global is_3way_diff current_diff_header
 862
 863         $ui_diff conf -state normal
 864         while {[gets $fd line] >= 0} {
 865                 # -- Cleanup uninteresting diff header lines.
 866                 #
 867                 if {   [string match {diff --git *}      $line]
 868                         || [string match {diff --cc *}       $line]
 869                         || [string match {diff --combined *} $line]
 870                         || [string match {--- *}             $line]
 871                         || [string match {+++ *}             $line]} {
 872                         append current_diff_header $line "\n"
 873                         continue
 874                 }
 875                 if {[string match {index *} $line]} continue
 876                 if {$line eq {deleted file mode 120000}} {
 877                         set line "deleted symlink"
 878                 }
 879
 880                 # -- Automatically detect if this is a 3 way diff.
 881                 #
 882                 if {[string match {@@@ *} $line]} {set is_3way_diff 1}
 883
 884                 if {[string match {mode *} $line]
 885                         || [string match {new file *} $line]
 886                         || [string match {deleted file *} $line]
 887                         || [string match {Binary files * and * differ} $line]
 888                         || $line eq {\ No newline at end of file}
 889                         || [regexp {^\* Unmerged path } $line]} {
 890                         set tags {}
 891                 } elseif {$is_3way_diff} {
 892                         set op [string range $line 0 1]
 893                         switch -- $op {
 894                         {  } {set tags {}}
 895                         {@@} {set tags d_@}
 896                         { +} {set tags d_s+}
 897                         { -} {set tags d_s-}
 898                         {+ } {set tags d_+s}
 899                         {- } {set tags d_-s}
 900                         {--} {set tags d_--}
 901                         {++} {
 902                                 if {[regexp {^\+\+([<>]{7} |={7})} $line _g op]} {
 903                                         set line [string replace $line 0 1 {  }]
 904                                         set tags d$op
 905                                 } else {
 906                                         set tags d_++
 907                                 }
 908                         }
 909                         default {
 910                                 puts "error: Unhandled 3 way diff marker: {$op}"
 911                                 set tags {}
 912                         }
 913                         }
 914                 } else {
 915                         set op [string index $line 0]
 916                         switch -- $op {
 917                         { } {set tags {}}
 918                         {@} {set tags d_@}
 919                         {-} {set tags d_-}
 920                         {+} {
 921                                 if {[regexp {^\+([<>]{7} |={7})} $line _g op]} {
 922                                         set line [string replace $line 0 0 { }]
 923                                         set tags d$op
 924                                 } else {
 925                                         set tags d_+
 926                                 }
 927                         }
 928                         default {
 929                                 puts "error: Unhandled 2 way diff marker: {$op}"
 930                                 set tags {}
 931                         }
 932                         }
 933                 }
 934                 $ui_diff insert end $line $tags
 935                 if {[string index $line end] eq "\r"} {
 936                         $ui_diff tag add d_cr {end - 2c}
 937                 }
 938                 $ui_diff insert end "\n" $tags
 939         }
 940         $ui_diff conf -state disabled
 941
 942         if {[eof $fd]} {
 943                 close $fd
 944                 set diff_active 0
 945                 unlock_index
 946                 set ui_status_value {Ready.}
 947
 948                 if {[$ui_diff index end] eq {2.0}} {
 949                         handle_empty_diff
 950                 }
 951         }
 952 }
 953
 954 proc apply_hunk {x y} {
 955         global current_diff_path current_diff_header current_diff_side
 956         global ui_diff ui_index file_states
 957
 958         if {$current_diff_path eq {} || $current_diff_header eq {}} return
 959         if {![lock_index apply_hunk]} return
 960
 961         set apply_cmd {git apply --cached --whitespace=nowarn}
 962         set mi [lindex $file_states($current_diff_path) 0]
 963         if {$current_diff_side eq $ui_index} {
 964                 set mode unstage
 965                 lappend apply_cmd --reverse
 966                 if {[string index $mi 0] ne {M}} {
 967                         unlock_index
 968                         return
 969                 }
 970         } else {
 971                 set mode stage
 972                 if {[string index $mi 1] ne {M}} {
 973                         unlock_index
 974                         return
 975                 }
 976         }
 977
 978         set s_lno [lindex [split [$ui_diff index @$x,$y] .] 0]
 979         set s_lno [$ui_diff search -backwards -regexp ^@@ $s_lno.0 0.0]
 980         if {$s_lno eq {}} {
 981                 unlock_index
 982                 return
 983         }
 984
 985         set e_lno [$ui_diff search -forwards -regexp ^@@ "$s_lno + 1 lines" end]
 986         if {$e_lno eq {}} {
 987                 set e_lno end
 988         }
 989
 990         if {[catch {
 991                 set p [open "| $apply_cmd" w]
 992                 fconfigure $p -translation binary -encoding binary
 993                 puts -nonewline $p $current_diff_header
 994                 puts -nonewline $p [$ui_diff get $s_lno $e_lno]
 995                 close $p} err]} {
 996                 error_popup "Failed to $mode selected hunk.\n\n$err"
 997                 unlock_index
 998                 return
 999         }
1000
1001         $ui_diff conf -state normal
1002         $ui_diff delete $s_lno $e_lno
1003         $ui_diff conf -state disabled
1004
1005         if {[$ui_diff get 1.0 end] eq "\n"} {
1006                 set o _
1007         } else {
1008                 set o ?
1009         }
1010
1011         if {$current_diff_side eq $ui_index} {
1012                 set mi ${o}M
1013         } elseif {[string index $mi 0] eq {_}} {
1014                 set mi M$o
1015         } else {
1016                 set mi ?$o
1017         }
1018         unlock_index
1019         display_file $current_diff_path $mi
1020         if {$o eq {_}} {
1021                 clear_diff
1022         }
1023 }
1024
1025 ######################################################################
1026 ##
1027 ## commit
1028
1029 proc load_last_commit {} {
1030         global HEAD PARENT MERGE_HEAD commit_type ui_comm
1031         global repo_config
1032
1033         if {[llength $PARENT] == 0} {
1034                 error_popup {There is nothing to amend.
1035
1036 You are about to create the initial commit.
1037 There is no commit before this to amend.
1038 }
1039                 return
1040         }
1041
1042         repository_state curType curHEAD curMERGE_HEAD
1043         if {$curType eq {merge}} {
1044                 error_popup {Cannot amend while merging.
1045
1046 You are currently in the middle of a merge that
1047 has not been fully completed.  You cannot amend
1048 the prior commit unless you first abort the
1049 current merge activity.
1050 }
1051                 return
1052         }
1053
1054         set msg {}
1055         set parents [list]
1056         if {[catch {
1057                         set fd [open "| git cat-file commit $curHEAD" r]
1058                         fconfigure $fd -encoding binary -translation lf
1059                         if {[catch {set enc $repo_config(i18n.commitencoding)}]} {
1060                                 set enc utf-8
1061                         }
1062                         while {[gets $fd line] > 0} {
1063                                 if {[string match {parent *} $line]} {
1064                                         lappend parents [string range $line 7 end]
1065                                 } elseif {[string match {encoding *} $line]} {
1066                                         set enc [string tolower [string range $line 9 end]]
1067                                 }
1068                         }
1069                         fconfigure $fd -encoding $enc
1070                         set msg [string trim [read $fd]]
1071                         close $fd
1072                 } err]} {
1073                 error_popup "Error loading commit data for amend:\n\n$err"
1074                 return
1075         }
1076
1077         set HEAD $curHEAD
1078         set PARENT $parents
1079         set MERGE_HEAD [list]
1080         switch -- [llength $parents] {
1081         0       {set commit_type amend-initial}
1082         1       {set commit_type amend}
1083         default {set commit_type amend-merge}
1084         }
1085
1086         $ui_comm delete 0.0 end
1087         $ui_comm insert end $msg
1088         $ui_comm edit reset
1089         $ui_comm edit modified false
1090         rescan {set ui_status_value {Ready.}}
1091 }
1092
1093 proc create_new_commit {} {
1094         global commit_type ui_comm
1095
1096         set commit_type normal
1097         $ui_comm delete 0.0 end
1098         $ui_comm edit reset
1099         $ui_comm edit modified false
1100         rescan {set ui_status_value {Ready.}}
1101 }
1102
1103 set GIT_COMMITTER_IDENT {}
1104
1105 proc committer_ident {} {
1106         global GIT_COMMITTER_IDENT
1107
1108         if {$GIT_COMMITTER_IDENT eq {}} {
1109                 if {[catch {set me [git var GIT_COMMITTER_IDENT]} err]} {
1110                         error_popup "Unable to obtain your identity:\n\n$err"
1111                         return {}
1112                 }
1113                 if {![regexp {^(.*) [0-9]+ [-+0-9]+$} \
1114                         $me me GIT_COMMITTER_IDENT]} {
1115                         error_popup "Invalid GIT_COMMITTER_IDENT:\n\n$me"
1116                         return {}
1117                 }
1118         }
1119
1120         return $GIT_COMMITTER_IDENT
1121 }
1122
1123 proc commit_tree {} {
1124         global HEAD commit_type file_states ui_comm repo_config
1125         global ui_status_value pch_error
1126
1127         if {[committer_ident] eq {}} return
1128         if {![lock_index update]} return
1129
1130         # -- Our in memory state should match the repository.
1131         #
1132         repository_state curType curHEAD curMERGE_HEAD
1133         if {[string match amend* $commit_type]
1134                 && $curType eq {normal}
1135                 && $curHEAD eq $HEAD} {
1136         } elseif {$commit_type ne $curType || $HEAD ne $curHEAD} {
1137                 info_popup {Last scanned state does not match repository state.
1138
1139 Another Git program has modified this repository
1140 since the last scan.  A rescan must be performed
1141 before another commit can be created.
1142
1143 The rescan will be automatically started now.
1144 }
1145                 unlock_index
1146                 rescan {set ui_status_value {Ready.}}
1147                 return
1148         }
1149
1150         # -- At least one file should differ in the index.
1151         #
1152         set files_ready 0
1153         foreach path [array names file_states] {
1154                 switch -glob -- [lindex $file_states($path) 0] {
1155                 _? {continue}
1156                 A? -
1157                 D? -
1158                 M? {set files_ready 1}
1159                 U? {
1160                         error_popup "Unmerged files cannot be committed.
1161
1162 File [short_path $path] has merge conflicts.
1163 You must resolve them and add the file before committing.
1164 "
1165                         unlock_index
1166                         return
1167                 }
1168                 default {
1169                         error_popup "Unknown file state [lindex $s 0] detected.
1170
1171 File [short_path $path] cannot be committed by this program.
1172 "
1173                 }
1174                 }
1175         }
1176         if {!$files_ready && ![string match *merge $curType]} {
1177                 info_popup {No changes to commit.
1178
1179 You must add at least 1 file before you can commit.
1180 }
1181                 unlock_index
1182                 return
1183         }
1184
1185         # -- A message is required.
1186         #
1187         set msg [string trim [$ui_comm get 1.0 end]]
1188         regsub -all -line {[ \t\r]+$} $msg {} msg
1189         if {$msg eq {}} {
1190                 error_popup {Please supply a commit message.
1191
1192 A good commit message has the following format:
1193
1194 - First line: Describe in one sentance what you did.
1195 - Second line: Blank
1196 - Remaining lines: Describe why this change is good.
1197 }
1198                 unlock_index
1199                 return
1200         }
1201
1202         # -- Run the pre-commit hook.
1203         #
1204         set pchook [gitdir hooks pre-commit]
1205
1206         # On Cygwin [file executable] might lie so we need to ask
1207         # the shell if the hook is executable.  Yes that's annoying.
1208         #
1209         if {[is_Cygwin] && [file isfile $pchook]} {
1210                 set pchook [list sh -c [concat \
1211                         "if test -x \"$pchook\";" \
1212                         "then exec \"$pchook\" 2>&1;" \
1213                         "fi"]]
1214         } elseif {[file executable $pchook]} {
1215                 set pchook [list $pchook |& cat]
1216         } else {
1217                 commit_writetree $curHEAD $msg
1218                 return
1219         }
1220
1221         set ui_status_value {Calling pre-commit hook...}
1222         set pch_error {}
1223         set fd_ph [open "| $pchook" r]
1224         fconfigure $fd_ph -blocking 0 -translation binary
1225         fileevent $fd_ph readable \
1226                 [list commit_prehook_wait $fd_ph $curHEAD $msg]
1227 }
1228
1229 proc commit_prehook_wait {fd_ph curHEAD msg} {
1230         global pch_error ui_status_value
1231
1232         append pch_error [read $fd_ph]
1233         fconfigure $fd_ph -blocking 1
1234         if {[eof $fd_ph]} {
1235                 if {[catch {close $fd_ph}]} {
1236                         set ui_status_value {Commit declined by pre-commit hook.}
1237                         hook_failed_popup pre-commit $pch_error
1238                         unlock_index
1239                 } else {
1240                         commit_writetree $curHEAD $msg
1241                 }
1242                 set pch_error {}
1243                 return
1244         }
1245         fconfigure $fd_ph -blocking 0
1246 }
1247
1248 proc commit_writetree {curHEAD msg} {
1249         global ui_status_value
1250
1251         set ui_status_value {Committing changes...}
1252         set fd_wt [open "| git write-tree" r]
1253         fileevent $fd_wt readable \
1254                 [list commit_committree $fd_wt $curHEAD $msg]
1255 }
1256
1257 proc commit_committree {fd_wt curHEAD msg} {
1258         global HEAD PARENT MERGE_HEAD commit_type
1259         global all_heads current_branch
1260         global ui_status_value ui_comm selected_commit_type
1261         global file_states selected_paths rescan_active
1262         global repo_config
1263
1264         gets $fd_wt tree_id
1265         if {$tree_id eq {} || [catch {close $fd_wt} err]} {
1266                 error_popup "write-tree failed:\n\n$err"
1267                 set ui_status_value {Commit failed.}
1268                 unlock_index
1269                 return
1270         }
1271
1272         # -- Verify this wasn't an empty change.
1273         #
1274         if {$commit_type eq {normal}} {
1275                 set old_tree [git rev-parse "$PARENT^{tree}"]
1276                 if {$tree_id eq $old_tree} {
1277                         info_popup {No changes to commit.
1278
1279 No files were modified by this commit and it
1280 was not a merge commit.
1281
1282 A rescan will be automatically started now.
1283 }
1284                         unlock_index
1285                         rescan {set ui_status_value {No changes to commit.}}
1286                         return
1287                 }
1288         }
1289
1290         # -- Build the message.
1291         #
1292         set msg_p [gitdir COMMIT_EDITMSG]
1293         set msg_wt [open $msg_p w]
1294         if {[catch {set enc $repo_config(i18n.commitencoding)}]} {
1295                 set enc utf-8
1296         }
1297         fconfigure $msg_wt -encoding $enc -translation binary
1298         puts -nonewline $msg_wt $msg
1299         close $msg_wt
1300
1301         # -- Create the commit.
1302         #
1303         set cmd [list git commit-tree $tree_id]
1304         foreach p [concat $PARENT $MERGE_HEAD] {
1305                 lappend cmd -p $p
1306         }
1307         lappend cmd <$msg_p
1308         if {[catch {set cmt_id [eval exec $cmd]} err]} {
1309                 error_popup "commit-tree failed:\n\n$err"
1310                 set ui_status_value {Commit failed.}
1311                 unlock_index
1312                 return
1313         }
1314
1315         # -- Update the HEAD ref.
1316         #
1317         set reflogm commit
1318         if {$commit_type ne {normal}} {
1319                 append reflogm " ($commit_type)"
1320         }
1321         set i [string first "\n" $msg]
1322         if {$i >= 0} {
1323                 append reflogm {: } [string range $msg 0 [expr {$i - 1}]]
1324         } else {
1325                 append reflogm {: } $msg
1326         }
1327         set cmd [list git update-ref -m $reflogm HEAD $cmt_id $curHEAD]
1328         if {[catch {eval exec $cmd} err]} {
1329                 error_popup "update-ref failed:\n\n$err"
1330                 set ui_status_value {Commit failed.}
1331                 unlock_index
1332                 return
1333         }
1334
1335         # -- Cleanup after ourselves.
1336         #
1337         catch {file delete $msg_p}
1338         catch {file delete [gitdir MERGE_HEAD]}
1339         catch {file delete [gitdir MERGE_MSG]}
1340         catch {file delete [gitdir SQUASH_MSG]}
1341         catch {file delete [gitdir GITGUI_MSG]}
1342
1343         # -- Let rerere do its thing.
1344         #
1345         if {[file isdirectory [gitdir rr-cache]]} {
1346                 catch {git rerere}
1347         }
1348
1349         # -- Run the post-commit hook.
1350         #
1351         set pchook [gitdir hooks post-commit]
1352         if {[is_Cygwin] && [file isfile $pchook]} {
1353                 set pchook [list sh -c [concat \
1354                         "if test -x \"$pchook\";" \
1355                         "then exec \"$pchook\";" \
1356                         "fi"]]
1357         } elseif {![file executable $pchook]} {
1358                 set pchook {}
1359         }
1360         if {$pchook ne {}} {
1361                 catch {exec $pchook &}
1362         }
1363
1364         $ui_comm delete 0.0 end
1365         $ui_comm edit reset
1366         $ui_comm edit modified false
1367
1368         if {[is_enabled singlecommit]} do_quit
1369
1370         # -- Make sure our current branch exists.
1371         #
1372         if {$commit_type eq {initial}} {
1373                 lappend all_heads $current_branch
1374                 set all_heads [lsort -unique $all_heads]
1375                 populate_branch_menu
1376         }
1377
1378         # -- Update in memory status
1379         #
1380         set selected_commit_type new
1381         set commit_type normal
1382         set HEAD $cmt_id
1383         set PARENT $cmt_id
1384         set MERGE_HEAD [list]
1385
1386         foreach path [array names file_states] {
1387                 set s $file_states($path)
1388                 set m [lindex $s 0]
1389                 switch -glob -- $m {
1390                 _O -
1391                 _M -
1392                 _D {continue}
1393                 __ -
1394                 A_ -
1395                 M_ -
1396                 D_ {
1397                         unset file_states($path)
1398                         catch {unset selected_paths($path)}
1399                 }
1400                 DO {
1401                         set file_states($path) [list _O [lindex $s 1] {} {}]
1402                 }
1403                 AM -
1404                 AD -
1405                 MM -
1406                 MD {
1407                         set file_states($path) [list \
1408                                 _[string index $m 1] \
1409                                 [lindex $s 1] \
1410                                 [lindex $s 3] \
1411                                 {}]
1412                 }
1413                 }
1414         }
1415
1416         display_all_files
1417         unlock_index
1418         reshow_diff
1419         set ui_status_value \
1420                 "Changes committed as [string range $cmt_id 0 7]."
1421 }
1422
1423 ######################################################################
1424 ##
1425 ## fetch push
1426
1427 proc fetch_from {remote} {
1428         set w [new_console \
1429                 "fetch $remote" \
1430                 "Fetching new changes from $remote"]
1431         set cmd [list git fetch]
1432         lappend cmd $remote
1433         console_exec $w $cmd console_done
1434 }
1435
1436 proc push_to {remote} {
1437         set w [new_console \
1438                 "push $remote" \
1439                 "Pushing changes to $remote"]
1440         set cmd [list git push]
1441         lappend cmd -v
1442         lappend cmd $remote
1443         console_exec $w $cmd console_done
1444 }
1445
1446 ######################################################################
1447 ##
1448 ## ui helpers
1449
1450 proc mapicon {w state path} {
1451         global all_icons
1452
1453         if {[catch {set r $all_icons($state$w)}]} {
1454                 puts "error: no icon for $w state={$state} $path"
1455                 return file_plain
1456         }
1457         return $r
1458 }
1459
1460 proc mapdesc {state path} {
1461         global all_descs
1462
1463         if {[catch {set r $all_descs($state)}]} {
1464                 puts "error: no desc for state={$state} $path"
1465                 return $state
1466         }
1467         return $r
1468 }
1469
1470 proc escape_path {path} {
1471         regsub -all {\\} $path "\\\\" path
1472         regsub -all "\n" $path "\\n" path
1473         return $path
1474 }
1475
1476 proc short_path {path} {
1477         return [escape_path [lindex [file split $path] end]]
1478 }
1479
1480 set next_icon_id 0
1481 set null_sha1 [string repeat 0 40]
1482
1483 proc merge_state {path new_state {head_info {}} {index_info {}}} {
1484         global file_states next_icon_id null_sha1
1485
1486         set s0 [string index $new_state 0]
1487         set s1 [string index $new_state 1]
1488
1489         if {[catch {set info $file_states($path)}]} {
1490                 set state __
1491                 set icon n[incr next_icon_id]
1492         } else {
1493                 set state [lindex $info 0]
1494                 set icon [lindex $info 1]
1495                 if {$head_info eq {}}  {set head_info  [lindex $info 2]}
1496                 if {$index_info eq {}} {set index_info [lindex $info 3]}
1497         }
1498
1499         if     {$s0 eq {?}} {set s0 [string index $state 0]} \
1500         elseif {$s0 eq {_}} {set s0 _}
1501
1502         if     {$s1 eq {?}} {set s1 [string index $state 1]} \
1503         elseif {$s1 eq {_}} {set s1 _}
1504
1505         if {$s0 eq {A} && $s1 eq {_} && $head_info eq {}} {
1506                 set head_info [list 0 $null_sha1]
1507         } elseif {$s0 ne {_} && [string index $state 0] eq {_}
1508                 && $head_info eq {}} {
1509                 set head_info $index_info
1510         }
1511
1512         set file_states($path) [list $s0$s1 $icon \
1513                 $head_info $index_info \
1514                 ]
1515         return $state
1516 }
1517
1518 proc display_file_helper {w path icon_name old_m new_m} {
1519         global file_lists
1520
1521         if {$new_m eq {_}} {
1522                 set lno [lsearch -sorted -exact $file_lists($w) $path]
1523                 if {$lno >= 0} {
1524                         set file_lists($w) [lreplace $file_lists($w) $lno $lno]
1525                         incr lno
1526                         $w conf -state normal
1527                         $w delete $lno.0 [expr {$lno + 1}].0
1528                         $w conf -state disabled
1529                 }
1530         } elseif {$old_m eq {_} && $new_m ne {_}} {
1531                 lappend file_lists($w) $path
1532                 set file_lists($w) [lsort -unique $file_lists($w)]
1533                 set lno [lsearch -sorted -exact $file_lists($w) $path]
1534                 incr lno
1535                 $w conf -state normal
1536                 $w image create $lno.0 \
1537                         -align center -padx 5 -pady 1 \
1538                         -name $icon_name \
1539                         -image [mapicon $w $new_m $path]
1540                 $w insert $lno.1 "[escape_path $path]\n"
1541                 $w conf -state disabled
1542         } elseif {$old_m ne $new_m} {
1543                 $w conf -state normal
1544                 $w image conf $icon_name -image [mapicon $w $new_m $path]
1545                 $w conf -state disabled
1546         }
1547 }
1548
1549 proc display_file {path state} {
1550         global file_states selected_paths
1551         global ui_index ui_workdir
1552
1553         set old_m [merge_state $path $state]
1554         set s $file_states($path)
1555         set new_m [lindex $s 0]
1556         set icon_name [lindex $s 1]
1557
1558         set o [string index $old_m 0]
1559         set n [string index $new_m 0]
1560         if {$o eq {U}} {
1561                 set o _
1562         }
1563         if {$n eq {U}} {
1564                 set n _
1565         }
1566         display_file_helper     $ui_index $path $icon_name $o $n
1567
1568         if {[string index $old_m 0] eq {U}} {
1569                 set o U
1570         } else {
1571                 set o [string index $old_m 1]
1572         }
1573         if {[string index $new_m 0] eq {U}} {
1574                 set n U
1575         } else {
1576                 set n [string index $new_m 1]
1577         }
1578         display_file_helper     $ui_workdir $path $icon_name $o $n
1579
1580         if {$new_m eq {__}} {
1581                 unset file_states($path)
1582                 catch {unset selected_paths($path)}
1583         }
1584 }
1585
1586 proc display_all_files_helper {w path icon_name m} {
1587         global file_lists
1588
1589         lappend file_lists($w) $path
1590         set lno [expr {[lindex [split [$w index end] .] 0] - 1}]
1591         $w image create end \
1592                 -align center -padx 5 -pady 1 \
1593                 -name $icon_name \
1594                 -image [mapicon $w $m $path]
1595         $w insert end "[escape_path $path]\n"
1596 }
1597
1598 proc display_all_files {} {
1599         global ui_index ui_workdir
1600         global file_states file_lists
1601         global last_clicked
1602
1603         $ui_index conf -state normal
1604         $ui_workdir conf -state normal
1605
1606         $ui_index delete 0.0 end
1607         $ui_workdir delete 0.0 end
1608         set last_clicked {}
1609
1610         set file_lists($ui_index) [list]
1611         set file_lists($ui_workdir) [list]
1612
1613         foreach path [lsort [array names file_states]] {
1614                 set s $file_states($path)
1615                 set m [lindex $s 0]
1616                 set icon_name [lindex $s 1]
1617
1618                 set s [string index $m 0]
1619                 if {$s ne {U} && $s ne {_}} {
1620                         display_all_files_helper $ui_index $path \
1621                                 $icon_name $s
1622                 }
1623
1624                 if {[string index $m 0] eq {U}} {
1625                         set s U
1626                 } else {
1627                         set s [string index $m 1]
1628                 }
1629                 if {$s ne {_}} {
1630                         display_all_files_helper $ui_workdir $path \
1631                                 $icon_name $s
1632                 }
1633         }
1634
1635         $ui_index conf -state disabled
1636         $ui_workdir conf -state disabled
1637 }
1638
1639 proc update_indexinfo {msg pathList after} {
1640         global update_index_cp ui_status_value
1641
1642         if {![lock_index update]} return
1643
1644         set update_index_cp 0
1645         set pathList [lsort $pathList]
1646         set totalCnt [llength $pathList]
1647         set batch [expr {int($totalCnt * .01) + 1}]
1648         if {$batch > 25} {set batch 25}
1649
1650         set ui_status_value [format \
1651                 "$msg... %i/%i files (%.2f%%)" \
1652                 $update_index_cp \
1653                 $totalCnt \
1654                 0.0]
1655         set fd [open "| git update-index -z --index-info" w]
1656         fconfigure $fd \
1657                 -blocking 0 \
1658                 -buffering full \
1659                 -buffersize 512 \
1660                 -encoding binary \
1661                 -translation binary
1662         fileevent $fd writable [list \
1663                 write_update_indexinfo \
1664                 $fd \
1665                 $pathList \
1666                 $totalCnt \
1667                 $batch \
1668                 $msg \
1669                 $after \
1670                 ]
1671 }
1672
1673 proc write_update_indexinfo {fd pathList totalCnt batch msg after} {
1674         global update_index_cp ui_status_value
1675         global file_states current_diff_path
1676
1677         if {$update_index_cp >= $totalCnt} {
1678                 close $fd
1679                 unlock_index
1680                 uplevel #0 $after
1681                 return
1682         }
1683
1684         for {set i $batch} \
1685                 {$update_index_cp < $totalCnt && $i > 0} \
1686                 {incr i -1} {
1687                 set path [lindex $pathList $update_index_cp]
1688                 incr update_index_cp
1689
1690                 set s $file_states($path)
1691                 switch -glob -- [lindex $s 0] {
1692                 A? {set new _O}
1693                 M? {set new _M}
1694                 D_ {set new _D}
1695                 D? {set new _?}
1696                 ?? {continue}
1697                 }
1698                 set info [lindex $s 2]
1699                 if {$info eq {}} continue
1700
1701                 puts -nonewline $fd "$info\t[encoding convertto $path]\0"
1702                 display_file $path $new
1703         }
1704
1705         set ui_status_value [format \
1706                 "$msg... %i/%i files (%.2f%%)" \
1707                 $update_index_cp \
1708                 $totalCnt \
1709                 [expr {100.0 * $update_index_cp / $totalCnt}]]
1710 }
1711
1712 proc update_index {msg pathList after} {
1713         global update_index_cp ui_status_value
1714
1715         if {![lock_index update]} return
1716
1717         set update_index_cp 0
1718         set pathList [lsort $pathList]
1719         set totalCnt [llength $pathList]
1720         set batch [expr {int($totalCnt * .01) + 1}]
1721         if {$batch > 25} {set batch 25}
1722
1723         set ui_status_value [format \
1724                 "$msg... %i/%i files (%.2f%%)" \
1725                 $update_index_cp \
1726                 $totalCnt \
1727                 0.0]
1728         set fd [open "| git update-index --add --remove -z --stdin" w]
1729         fconfigure $fd \
1730                 -blocking 0 \
1731                 -buffering full \
1732                 -buffersize 512 \
1733                 -encoding binary \
1734                 -translation binary
1735         fileevent $fd writable [list \
1736                 write_update_index \
1737                 $fd \
1738                 $pathList \
1739                 $totalCnt \
1740                 $batch \
1741                 $msg \
1742                 $after \
1743                 ]
1744 }
1745
1746 proc write_update_index {fd pathList totalCnt batch msg after} {
1747         global update_index_cp ui_status_value
1748         global file_states current_diff_path
1749
1750         if {$update_index_cp >= $totalCnt} {
1751                 close $fd
1752                 unlock_index
1753                 uplevel #0 $after
1754                 return
1755         }
1756
1757         for {set i $batch} \
1758                 {$update_index_cp < $totalCnt && $i > 0} \
1759                 {incr i -1} {
1760                 set path [lindex $pathList $update_index_cp]
1761                 incr update_index_cp
1762
1763                 switch -glob -- [lindex $file_states($path) 0] {
1764                 AD {set new __}
1765                 ?D {set new D_}
1766                 _O -
1767                 AM {set new A_}
1768                 U? {
1769                         if {[file exists $path]} {
1770                                 set new M_
1771                         } else {
1772                                 set new D_
1773                         }
1774                 }
1775                 ?M {set new M_}
1776                 ?? {continue}
1777                 }
1778                 puts -nonewline $fd "[encoding convertto $path]\0"
1779                 display_file $path $new
1780         }
1781
1782         set ui_status_value [format \
1783                 "$msg... %i/%i files (%.2f%%)" \
1784                 $update_index_cp \
1785                 $totalCnt \
1786                 [expr {100.0 * $update_index_cp / $totalCnt}]]
1787 }
1788
1789 proc checkout_index {msg pathList after} {
1790         global update_index_cp ui_status_value
1791
1792         if {![lock_index update]} return
1793
1794         set update_index_cp 0
1795         set pathList [lsort $pathList]
1796         set totalCnt [llength $pathList]
1797         set batch [expr {int($totalCnt * .01) + 1}]
1798         if {$batch > 25} {set batch 25}
1799
1800         set ui_status_value [format \
1801                 "$msg... %i/%i files (%.2f%%)" \
1802                 $update_index_cp \
1803                 $totalCnt \
1804                 0.0]
1805         set cmd [list git checkout-index]
1806         lappend cmd --index
1807         lappend cmd --quiet
1808         lappend cmd --force
1809         lappend cmd -z
1810         lappend cmd --stdin
1811         set fd [open "| $cmd " w]
1812         fconfigure $fd \
1813                 -blocking 0 \
1814                 -buffering full \
1815                 -buffersize 512 \
1816                 -encoding binary \
1817                 -translation binary
1818         fileevent $fd writable [list \
1819                 write_checkout_index \
1820                 $fd \
1821                 $pathList \
1822                 $totalCnt \
1823                 $batch \
1824                 $msg \
1825                 $after \
1826                 ]
1827 }
1828
1829 proc write_checkout_index {fd pathList totalCnt batch msg after} {
1830         global update_index_cp ui_status_value
1831         global file_states current_diff_path
1832
1833         if {$update_index_cp >= $totalCnt} {
1834                 close $fd
1835                 unlock_index
1836                 uplevel #0 $after
1837                 return
1838         }
1839
1840         for {set i $batch} \
1841                 {$update_index_cp < $totalCnt && $i > 0} \
1842                 {incr i -1} {
1843                 set path [lindex $pathList $update_index_cp]
1844                 incr update_index_cp
1845                 switch -glob -- [lindex $file_states($path) 0] {
1846                 U? {continue}
1847                 ?M -
1848                 ?D {
1849                         puts -nonewline $fd "[encoding convertto $path]\0"
1850                         display_file $path ?_
1851                 }
1852                 }
1853         }
1854
1855         set ui_status_value [format \
1856                 "$msg... %i/%i files (%.2f%%)" \
1857                 $update_index_cp \
1858                 $totalCnt \
1859                 [expr {100.0 * $update_index_cp / $totalCnt}]]
1860 }
1861
1862 ######################################################################
1863 ##
1864 ## branch management
1865
1866 proc is_tracking_branch {name} {
1867         global tracking_branches
1868
1869         if {![catch {set info $tracking_branches($name)}]} {
1870                 return 1
1871         }
1872         foreach t [array names tracking_branches] {
1873                 if {[string match {*/\*} $t] && [string match $t $name]} {
1874                         return 1
1875                 }
1876         }
1877         return 0
1878 }
1879
1880 proc load_all_heads {} {
1881         global all_heads
1882
1883         set all_heads [list]
1884         set fd [open "| git for-each-ref --format=%(refname) refs/heads" r]
1885         while {[gets $fd line] > 0} {
1886                 if {[is_tracking_branch $line]} continue
1887                 if {![regsub ^refs/heads/ $line {} name]} continue
1888                 lappend all_heads $name
1889         }
1890         close $fd
1891
1892         set all_heads [lsort $all_heads]
1893 }
1894
1895 proc populate_branch_menu {} {
1896         global all_heads disable_on_lock
1897
1898         set m .mbar.branch
1899         set last [$m index last]
1900         for {set i 0} {$i <= $last} {incr i} {
1901                 if {[$m type $i] eq {separator}} {
1902                         $m delete $i last
1903                         set new_dol [list]
1904                         foreach a $disable_on_lock {
1905                                 if {[lindex $a 0] ne $m || [lindex $a 2] < $i} {
1906                                         lappend new_dol $a
1907                                 }
1908                         }
1909                         set disable_on_lock $new_dol
1910                         break
1911                 }
1912         }
1913
1914         if {$all_heads ne {}} {
1915                 $m add separator
1916         }
1917         foreach b $all_heads {
1918                 $m add radiobutton \
1919                         -label $b \
1920                         -command [list switch_branch $b] \
1921                         -variable current_branch \
1922                         -value $b \
1923                         -font font_ui
1924                 lappend disable_on_lock \
1925                         [list $m entryconf [$m index last] -state]
1926         }
1927 }
1928
1929 proc all_tracking_branches {} {
1930         global tracking_branches
1931
1932         set all_trackings {}
1933         set cmd {}
1934         foreach name [array names tracking_branches] {
1935                 if {[regsub {/\*$} $name {} name]} {
1936                         lappend cmd $name
1937                 } else {
1938                         regsub ^refs/(heads|remotes)/ $name {} name
1939                         lappend all_trackings $name
1940                 }
1941         }
1942
1943         if {$cmd ne {}} {
1944                 set fd [open "| git for-each-ref --format=%(refname) $cmd" r]
1945                 while {[gets $fd name] > 0} {
1946                         regsub ^refs/(heads|remotes)/ $name {} name
1947                         lappend all_trackings $name
1948                 }
1949                 close $fd
1950         }
1951
1952         return [lsort -unique $all_trackings]
1953 }
1954
1955 proc load_all_tags {} {
1956         set all_tags [list]
1957         set fd [open "| git for-each-ref --format=%(refname) refs/tags" r]
1958         while {[gets $fd line] > 0} {
1959                 if {![regsub ^refs/tags/ $line {} name]} continue
1960                 lappend all_tags $name
1961         }
1962         close $fd
1963
1964         return [lsort $all_tags]
1965 }
1966
1967 proc do_create_branch_action {w} {
1968         global all_heads null_sha1 repo_config
1969         global create_branch_checkout create_branch_revtype
1970         global create_branch_head create_branch_trackinghead
1971         global create_branch_name create_branch_revexp
1972         global create_branch_tag
1973
1974         set newbranch $create_branch_name
1975         if {$newbranch eq {}
1976                 || $newbranch eq $repo_config(gui.newbranchtemplate)} {
1977                 tk_messageBox \
1978                         -icon error \
1979                         -type ok \
1980                         -title [wm title $w] \
1981                         -parent $w \
1982                         -message "Please supply a branch name."
1983                 focus $w.desc.name_t
1984                 return
1985         }
1986         if {![catch {git show-ref --verify -- "refs/heads/$newbranch"}]} {
1987                 tk_messageBox \
1988                         -icon error \
1989                         -type ok \
1990                         -title [wm title $w] \
1991                         -parent $w \
1992                         -message "Branch '$newbranch' already exists."
1993                 focus $w.desc.name_t
1994                 return
1995         }
1996         if {[catch {git check-ref-format "heads/$newbranch"}]} {
1997                 tk_messageBox \
1998                         -icon error \
1999                         -type ok \
2000                         -title [wm title $w] \
2001                         -parent $w \
2002                         -message "We do not like '$newbranch' as a branch name."
2003                 focus $w.desc.name_t
2004                 return
2005         }
2006
2007         set rev {}
2008         switch -- $create_branch_revtype {
2009         head {set rev $create_branch_head}
2010         tracking {set rev $create_branch_trackinghead}
2011         tag {set rev $create_branch_tag}
2012         expression {set rev $create_branch_revexp}
2013         }
2014         if {[catch {set cmt [git rev-parse --verify "${rev}^0"]}]} {
2015                 tk_messageBox \
2016                         -icon error \
2017                         -type ok \
2018                         -title [wm title $w] \
2019                         -parent $w \
2020                         -message "Invalid starting revision: $rev"
2021                 return
2022         }
2023         set cmd [list git update-ref]
2024         lappend cmd -m
2025         lappend cmd "branch: Created from $rev"
2026         lappend cmd "refs/heads/$newbranch"
2027         lappend cmd $cmt
2028         lappend cmd $null_sha1
2029         if {[catch {eval exec $cmd} err]} {
2030                 tk_messageBox \
2031                         -icon error \
2032                         -type ok \
2033                         -title [wm title $w] \
2034                         -parent $w \
2035                         -message "Failed to create '$newbranch'.\n\n$err"
2036                 return
2037         }
2038
2039         lappend all_heads $newbranch
2040         set all_heads [lsort $all_heads]
2041         populate_branch_menu
2042         destroy $w
2043         if {$create_branch_checkout} {
2044                 switch_branch $newbranch
2045         }
2046 }
2047
2048 proc radio_selector {varname value args} {
2049         upvar #0 $varname var
2050         set var $value
2051 }
2052
2053 trace add variable create_branch_head write \
2054         [list radio_selector create_branch_revtype head]
2055 trace add variable create_branch_trackinghead write \
2056         [list radio_selector create_branch_revtype tracking]
2057 trace add variable create_branch_tag write \
2058         [list radio_selector create_branch_revtype tag]
2059
2060 trace add variable delete_branch_head write \
2061         [list radio_selector delete_branch_checktype head]
2062 trace add variable delete_branch_trackinghead write \
2063         [list radio_selector delete_branch_checktype tracking]
2064
2065 proc do_create_branch {} {
2066         global all_heads current_branch repo_config
2067         global create_branch_checkout create_branch_revtype
2068         global create_branch_head create_branch_trackinghead
2069         global create_branch_name create_branch_revexp
2070         global create_branch_tag
2071
2072         set w .branch_editor
2073         toplevel $w
2074         wm geometry $w "+[winfo rootx .]+[winfo rooty .]"
2075
2076         label $w.header -text {Create New Branch} \
2077                 -font font_uibold
2078         pack $w.header -side top -fill x
2079
2080         frame $w.buttons
2081         button $w.buttons.create -text Create \
2082                 -font font_ui \
2083                 -default active \
2084                 -command [list do_create_branch_action $w]
2085         pack $w.buttons.create -side right
2086         button $w.buttons.cancel -text {Cancel} \
2087                 -font font_ui \
2088                 -command [list destroy $w]
2089         pack $w.buttons.cancel -side right -padx 5
2090         pack $w.buttons -side bottom -fill x -pady 10 -padx 10
2091
2092         labelframe $w.desc \
2093                 -text {Branch Description} \
2094                 -font font_ui
2095         label $w.desc.name_l -text {Name:} -font font_ui
2096         entry $w.desc.name_t \
2097                 -borderwidth 1 \
2098                 -relief sunken \
2099                 -width 40 \
2100                 -textvariable create_branch_name \
2101                 -font font_ui \
2102                 -validate key \
2103                 -validatecommand {
2104                         if {%d == 1 && [regexp {[~^:?*\[\0- ]} %S]} {return 0}
2105                         return 1
2106                 }
2107         grid $w.desc.name_l $w.desc.name_t -sticky we -padx {0 5}
2108         grid columnconfigure $w.desc 1 -weight 1
2109         pack $w.desc -anchor nw -fill x -pady 5 -padx 5
2110
2111         labelframe $w.from \
2112                 -text {Starting Revision} \
2113                 -font font_ui
2114         radiobutton $w.from.head_r \
2115                 -text {Local Branch:} \
2116                 -value head \
2117                 -variable create_branch_revtype \
2118                 -font font_ui
2119         eval tk_optionMenu $w.from.head_m create_branch_head $all_heads
2120         grid $w.from.head_r $w.from.head_m -sticky w
2121         set all_trackings [all_tracking_branches]
2122         if {$all_trackings ne {}} {
2123                 set create_branch_trackinghead [lindex $all_trackings 0]
2124                 radiobutton $w.from.tracking_r \
2125                         -text {Tracking Branch:} \
2126                         -value tracking \
2127                         -variable create_branch_revtype \
2128                         -font font_ui
2129                 eval tk_optionMenu $w.from.tracking_m \
2130                         create_branch_trackinghead \
2131                         $all_trackings
2132                 grid $w.from.tracking_r $w.from.tracking_m -sticky w
2133         }
2134         set all_tags [load_all_tags]
2135         if {$all_tags ne {}} {
2136                 set create_branch_tag [lindex $all_tags 0]
2137                 radiobutton $w.from.tag_r \
2138                         -text {Tag:} \
2139                         -value tag \
2140                         -variable create_branch_revtype \
2141                         -font font_ui
2142                 eval tk_optionMenu $w.from.tag_m \
2143                         create_branch_tag \
2144                         $all_tags
2145                 grid $w.from.tag_r $w.from.tag_m -sticky w
2146         }
2147         radiobutton $w.from.exp_r \
2148                 -text {Revision Expression:} \
2149                 -value expression \
2150                 -variable create_branch_revtype \
2151                 -font font_ui
2152         entry $w.from.exp_t \
2153                 -borderwidth 1 \
2154                 -relief sunken \
2155                 -width 50 \
2156                 -textvariable create_branch_revexp \
2157                 -font font_ui \
2158                 -validate key \
2159                 -validatecommand {
2160                         if {%d == 1 && [regexp {\s} %S]} {return 0}
2161                         if {%d == 1 && [string length %S] > 0} {
2162                                 set create_branch_revtype expression
2163                         }
2164                         return 1
2165                 }
2166         grid $w.from.exp_r $w.from.exp_t -sticky we -padx {0 5}
2167         grid columnconfigure $w.from 1 -weight 1
2168         pack $w.from -anchor nw -fill x -pady 5 -padx 5
2169
2170         labelframe $w.postActions \
2171                 -text {Post Creation Actions} \
2172                 -font font_ui
2173         checkbutton $w.postActions.checkout \
2174                 -text {Checkout after creation} \
2175                 -variable create_branch_checkout \
2176                 -font font_ui
2177         pack $w.postActions.checkout -anchor nw
2178         pack $w.postActions -anchor nw -fill x -pady 5 -padx 5
2179
2180         set create_branch_checkout 1
2181         set create_branch_head $current_branch
2182         set create_branch_revtype head
2183         set create_branch_name $repo_config(gui.newbranchtemplate)
2184         set create_branch_revexp {}
2185
2186         bind $w <Visibility> "
2187                 grab $w
2188                 $w.desc.name_t icursor end
2189                 focus $w.desc.name_t
2190         "
2191         bind $w <Key-Escape> "destroy $w"
2192         bind $w <Key-Return> "do_create_branch_action $w;break"
2193         wm title $w "[appname] ([reponame]): Create Branch"
2194         tkwait window $w
2195 }
2196
2197 proc do_delete_branch_action {w} {
2198         global all_heads
2199         global delete_branch_checktype delete_branch_head delete_branch_trackinghead
2200
2201         set check_rev {}
2202         switch -- $delete_branch_checktype {
2203         head {set check_rev $delete_branch_head}
2204         tracking {set check_rev $delete_branch_trackinghead}
2205         always {set check_rev {:none}}
2206         }
2207         if {$check_rev eq {:none}} {
2208                 set check_cmt {}
2209         } elseif {[catch {set check_cmt [git rev-parse --verify "${check_rev}^0"]}]} {
2210                 tk_messageBox \
2211                         -icon error \
2212                         -type ok \
2213                         -title [wm title $w] \
2214                         -parent $w \
2215                         -message "Invalid check revision: $check_rev"
2216                 return
2217         }
2218
2219         set to_delete [list]
2220         set not_merged [list]
2221         foreach i [$w.list.l curselection] {
2222                 set b [$w.list.l get $i]
2223                 if {[catch {set o [git rev-parse --verify $b]}]} continue
2224                 if {$check_cmt ne {}} {
2225                         if {$b eq $check_rev} continue
2226                         if {[catch {set m [git merge-base $o $check_cmt]}]} continue
2227                         if {$o ne $m} {
2228                                 lappend not_merged $b
2229                                 continue
2230                         }
2231                 }
2232                 lappend to_delete [list $b $o]
2233         }
2234         if {$not_merged ne {}} {
2235                 set msg "The following branches are not completely merged into $check_rev:
2236
2237  - [join $not_merged "\n - "]"
2238                 tk_messageBox \
2239                         -icon info \
2240                         -type ok \
2241                         -title [wm title $w] \
2242                         -parent $w \
2243                         -message $msg
2244         }
2245         if {$to_delete eq {}} return
2246         if {$delete_branch_checktype eq {always}} {
2247                 set msg {Recovering deleted branches is difficult.
2248
2249 Delete the selected branches?}
2250                 if {[tk_messageBox \
2251                         -icon warning \
2252                         -type yesno \
2253                         -title [wm title $w] \
2254                         -parent $w \
2255                         -message $msg] ne yes} {
2256                         return
2257                 }
2258         }
2259
2260         set failed {}
2261         foreach i $to_delete {
2262                 set b [lindex $i 0]
2263                 set o [lindex $i 1]
2264                 if {[catch {git update-ref -d "refs/heads/$b" $o} err]} {
2265                         append failed " - $b: $err\n"
2266                 } else {
2267                         set x [lsearch -sorted -exact $all_heads $b]
2268                         if {$x >= 0} {
2269                                 set all_heads [lreplace $all_heads $x $x]
2270                         }
2271                 }
2272         }
2273
2274         if {$failed ne {}} {
2275                 tk_messageBox \
2276                         -icon error \
2277                         -type ok \
2278                         -title [wm title $w] \
2279                         -parent $w \
2280                         -message "Failed to delete branches:\n$failed"
2281         }
2282
2283         set all_heads [lsort $all_heads]
2284         populate_branch_menu
2285         destroy $w
2286 }
2287
2288 proc do_delete_branch {} {
2289         global all_heads tracking_branches current_branch
2290         global delete_branch_checktype delete_branch_head delete_branch_trackinghead
2291
2292         set w .branch_editor
2293         toplevel $w
2294         wm geometry $w "+[winfo rootx .]+[winfo rooty .]"
2295
2296         label $w.header -text {Delete Local Branch} \
2297                 -font font_uibold
2298         pack $w.header -side top -fill x
2299
2300         frame $w.buttons
2301         button $w.buttons.create -text Delete \
2302                 -font font_ui \
2303                 -command [list do_delete_branch_action $w]
2304         pack $w.buttons.create -side right
2305         button $w.buttons.cancel -text {Cancel} \
2306                 -font font_ui \
2307                 -command [list destroy $w]
2308         pack $w.buttons.cancel -side right -padx 5
2309         pack $w.buttons -side bottom -fill x -pady 10 -padx 10
2310
2311         labelframe $w.list \
2312                 -text {Local Branches} \
2313                 -font font_ui
2314         listbox $w.list.l \
2315                 -height 10 \
2316                 -width 70 \
2317                 -selectmode extended \
2318                 -yscrollcommand [list $w.list.sby set] \
2319                 -font font_ui
2320         foreach h $all_heads {
2321                 if {$h ne $current_branch} {
2322                         $w.list.l insert end $h
2323                 }
2324         }
2325         scrollbar $w.list.sby -command [list $w.list.l yview]
2326         pack $w.list.sby -side right -fill y
2327         pack $w.list.l -side left -fill both -expand 1
2328         pack $w.list -fill both -expand 1 -pady 5 -padx 5
2329
2330         labelframe $w.validate \
2331                 -text {Delete Only If} \
2332                 -font font_ui
2333         radiobutton $w.validate.head_r \
2334                 -text {Merged Into Local Branch:} \
2335                 -value head \
2336                 -variable delete_branch_checktype \
2337                 -font font_ui
2338         eval tk_optionMenu $w.validate.head_m delete_branch_head $all_heads
2339         grid $w.validate.head_r $w.validate.head_m -sticky w
2340         set all_trackings [all_tracking_branches]
2341         if {$all_trackings ne {}} {
2342                 set delete_branch_trackinghead [lindex $all_trackings 0]
2343                 radiobutton $w.validate.tracking_r \
2344                         -text {Merged Into Tracking Branch:} \
2345                         -value tracking \
2346                         -variable delete_branch_checktype \
2347                         -font font_ui
2348                 eval tk_optionMenu $w.validate.tracking_m \
2349                         delete_branch_trackinghead \
2350                         $all_trackings
2351                 grid $w.validate.tracking_r $w.validate.tracking_m -sticky w
2352         }
2353         radiobutton $w.validate.always_r \
2354                 -text {Always (Do not perform merge checks)} \
2355                 -value always \
2356                 -variable delete_branch_checktype \
2357                 -font font_ui
2358         grid $w.validate.always_r -columnspan 2 -sticky w
2359         grid columnconfigure $w.validate 1 -weight 1
2360         pack $w.validate -anchor nw -fill x -pady 5 -padx 5
2361
2362         set delete_branch_head $current_branch
2363         set delete_branch_checktype head
2364
2365         bind $w <Visibility> "grab $w; focus $w"
2366         bind $w <Key-Escape> "destroy $w"
2367         wm title $w "[appname] ([reponame]): Delete Branch"
2368         tkwait window $w
2369 }
2370
2371 proc switch_branch {new_branch} {
2372         global HEAD commit_type current_branch repo_config
2373
2374         if {![lock_index switch]} return
2375
2376         # -- Our in memory state should match the repository.
2377         #
2378         repository_state curType curHEAD curMERGE_HEAD
2379         if {[string match amend* $commit_type]
2380                 && $curType eq {normal}
2381                 && $curHEAD eq $HEAD} {
2382         } elseif {$commit_type ne $curType || $HEAD ne $curHEAD} {
2383                 info_popup {Last scanned state does not match repository state.
2384
2385 Another Git program has modified this repository
2386 since the last scan.  A rescan must be performed
2387 before the current branch can be changed.
2388
2389 The rescan will be automatically started now.
2390 }
2391                 unlock_index
2392                 rescan {set ui_status_value {Ready.}}
2393                 return
2394         }
2395
2396         # -- Don't do a pointless switch.
2397         #
2398         if {$current_branch eq $new_branch} {
2399                 unlock_index
2400                 return
2401         }
2402
2403         if {$repo_config(gui.trustmtime) eq {true}} {
2404                 switch_branch_stage2 {} $new_branch
2405         } else {
2406                 set ui_status_value {Refreshing file status...}
2407                 set cmd [list git update-index]
2408                 lappend cmd -q
2409                 lappend cmd --unmerged
2410                 lappend cmd --ignore-missing
2411                 lappend cmd --refresh
2412                 set fd_rf [open "| $cmd" r]
2413                 fconfigure $fd_rf -blocking 0 -translation binary
2414                 fileevent $fd_rf readable \
2415                         [list switch_branch_stage2 $fd_rf $new_branch]
2416         }
2417 }
2418
2419 proc switch_branch_stage2 {fd_rf new_branch} {
2420         global ui_status_value HEAD
2421
2422         if {$fd_rf ne {}} {
2423                 read $fd_rf
2424                 if {![eof $fd_rf]} return
2425                 close $fd_rf
2426         }
2427
2428         set ui_status_value "Updating working directory to '$new_branch'..."
2429         set cmd [list git read-tree]
2430         lappend cmd -m
2431         lappend cmd -u
2432         lappend cmd --exclude-per-directory=.gitignore
2433         lappend cmd $HEAD
2434         lappend cmd $new_branch
2435         set fd_rt [open "| $cmd" r]
2436         fconfigure $fd_rt -blocking 0 -translation binary
2437         fileevent $fd_rt readable \
2438                 [list switch_branch_readtree_wait $fd_rt $new_branch]
2439 }
2440
2441 proc switch_branch_readtree_wait {fd_rt new_branch} {
2442         global selected_commit_type commit_type HEAD MERGE_HEAD PARENT
2443         global current_branch
2444         global ui_comm ui_status_value
2445
2446         # -- We never get interesting output on stdout; only stderr.
2447         #
2448         read $fd_rt
2449         fconfigure $fd_rt -blocking 1
2450         if {![eof $fd_rt]} {
2451                 fconfigure $fd_rt -blocking 0
2452                 return
2453         }
2454
2455         # -- The working directory wasn't in sync with the index and
2456         #    we'd have to overwrite something to make the switch. A
2457         #    merge is required.
2458         #
2459         if {[catch {close $fd_rt} err]} {
2460                 regsub {^fatal: } $err {} err
2461                 warn_popup "File level merge required.
2462
2463 $err
2464
2465 Staying on branch '$current_branch'."
2466                 set ui_status_value "Aborted checkout of '$new_branch' (file level merging is required)."
2467                 unlock_index
2468                 return
2469         }
2470
2471         # -- Update the symbolic ref.  Core git doesn't even check for failure
2472         #    here, it Just Works(tm).  If it doesn't we are in some really ugly
2473         #    state that is difficult to recover from within git-gui.
2474         #
2475         if {[catch {git symbolic-ref HEAD "refs/heads/$new_branch"} err]} {
2476                 error_popup "Failed to set current branch.
2477
2478 This working directory is only partially switched.
2479 We successfully updated your files, but failed to
2480 update an internal Git file.
2481
2482 This should not have occurred.  [appname] will now
2483 close and give up.
2484
2485 $err"
2486                 do_quit
2487                 return
2488         }
2489
2490         # -- Update our repository state.  If we were previously in amend mode
2491         #    we need to toss the current buffer and do a full rescan to update
2492         #    our file lists.  If we weren't in amend mode our file lists are
2493         #    accurate and we can avoid the rescan.
2494         #
2495         unlock_index
2496         set selected_commit_type new
2497         if {[string match amend* $commit_type]} {
2498                 $ui_comm delete 0.0 end
2499                 $ui_comm edit reset
2500                 $ui_comm edit modified false
2501                 rescan {set ui_status_value "Checked out branch '$current_branch'."}
2502         } else {
2503                 repository_state commit_type HEAD MERGE_HEAD
2504                 set PARENT $HEAD
2505                 set ui_status_value "Checked out branch '$current_branch'."
2506         }
2507 }
2508
2509 ######################################################################
2510 ##
2511 ## remote management
2512
2513 proc load_all_remotes {} {
2514         global repo_config
2515         global all_remotes tracking_branches
2516
2517         set all_remotes [list]
2518         array unset tracking_branches
2519
2520         set rm_dir [gitdir remotes]
2521         if {[file isdirectory $rm_dir]} {
2522                 set all_remotes [glob \
2523                         -types f \
2524                         -tails \
2525                         -nocomplain \
2526                         -directory $rm_dir *]
2527
2528                 foreach name $all_remotes {
2529                         catch {
2530                                 set fd [open [file join $rm_dir $name] r]
2531                                 while {[gets $fd line] >= 0} {
2532                                         if {![regexp {^Pull:[   ]*([^:]+):(.+)$} \
2533                                                 $line line src dst]} continue
2534                                         if {![regexp ^refs/ $dst]} {
2535                                                 set dst "refs/heads/$dst"
2536                                         }
2537                                         set tracking_branches($dst) [list $name $src]
2538                                 }
2539                                 close $fd
2540                         }
2541                 }
2542         }
2543
2544         foreach line [array names repo_config remote.*.url] {
2545                 if {![regexp ^remote\.(.*)\.url\$ $line line name]} continue
2546                 lappend all_remotes $name
2547
2548                 if {[catch {set fl $repo_config(remote.$name.fetch)}]} {
2549                         set fl {}
2550                 }
2551                 foreach line $fl {
2552                         if {![regexp {^([^:]+):(.+)$} $line line src dst]} continue
2553                         if {![regexp ^refs/ $dst]} {
2554                                 set dst "refs/heads/$dst"
2555                         }
2556                         set tracking_branches($dst) [list $name $src]
2557                 }
2558         }
2559
2560         set all_remotes [lsort -unique $all_remotes]
2561 }
2562
2563 proc populate_fetch_menu {} {
2564         global all_remotes repo_config
2565
2566         set m .mbar.fetch
2567         foreach r $all_remotes {
2568                 set enable 0
2569                 if {![catch {set a $repo_config(remote.$r.url)}]} {
2570                         if {![catch {set a $repo_config(remote.$r.fetch)}]} {
2571                                 set enable 1
2572                         }
2573                 } else {
2574                         catch {
2575                                 set fd [open [gitdir remotes $r] r]
2576                                 while {[gets $fd n] >= 0} {
2577                                         if {[regexp {^Pull:[ \t]*([^:]+):} $n]} {
2578                                                 set enable 1
2579                                                 break
2580                                         }
2581                                 }
2582                                 close $fd
2583                         }
2584                 }
2585
2586                 if {$enable} {
2587                         $m add command \
2588                                 -label "Fetch from $r..." \
2589                                 -command [list fetch_from $r] \
2590                                 -font font_ui
2591                 }
2592         }
2593 }
2594
2595 proc populate_push_menu {} {
2596         global all_remotes repo_config
2597
2598         set m .mbar.push
2599         set fast_count 0
2600         foreach r $all_remotes {
2601                 set enable 0
2602                 if {![catch {set a $repo_config(remote.$r.url)}]} {
2603                         if {![catch {set a $repo_config(remote.$r.push)}]} {
2604                                 set enable 1
2605                         }
2606                 } else {
2607                         catch {
2608                                 set fd [open [gitdir remotes $r] r]
2609                                 while {[gets $fd n] >= 0} {
2610                                         if {[regexp {^Push:[ \t]*([^:]+):} $n]} {
2611                                                 set enable 1
2612                                                 break
2613                                         }
2614                                 }
2615                                 close $fd
2616                         }
2617                 }
2618
2619                 if {$enable} {
2620                         if {!$fast_count} {
2621                                 $m add separator
2622                         }
2623                         $m add command \
2624                                 -label "Push to $r..." \
2625                                 -command [list push_to $r] \
2626                                 -font font_ui
2627                         incr fast_count
2628                 }
2629         }
2630 }
2631
2632 proc start_push_anywhere_action {w} {
2633         global push_urltype push_remote push_url push_thin push_tags
2634
2635         set r_url {}
2636         switch -- $push_urltype {
2637         remote {set r_url $push_remote}
2638         url {set r_url $push_url}
2639         }
2640         if {$r_url eq {}} return
2641
2642         set cmd [list git push]
2643         lappend cmd -v
2644         if {$push_thin} {
2645                 lappend cmd --thin
2646         }
2647         if {$push_tags} {
2648                 lappend cmd --tags
2649         }
2650         lappend cmd $r_url
2651         set cnt 0
2652         foreach i [$w.source.l curselection] {
2653                 set b [$w.source.l get $i]
2654                 lappend cmd "refs/heads/$b:refs/heads/$b"
2655                 incr cnt
2656         }
2657         if {$cnt == 0} {
2658                 return
2659         } elseif {$cnt == 1} {
2660                 set unit branch
2661         } else {
2662                 set unit branches
2663         }
2664
2665         set cons [new_console "push $r_url" "Pushing $cnt $unit to $r_url"]
2666         console_exec $cons $cmd console_done
2667         destroy $w
2668 }
2669
2670 trace add variable push_remote write \
2671         [list radio_selector push_urltype remote]
2672
2673 proc do_push_anywhere {} {
2674         global all_heads all_remotes current_branch
2675         global push_urltype push_remote push_url push_thin push_tags
2676
2677         set w .push_setup
2678         toplevel $w
2679         wm geometry $w "+[winfo rootx .]+[winfo rooty .]"
2680
2681         label $w.header -text {Push Branches} -font font_uibold
2682         pack $w.header -side top -fill x
2683
2684         frame $w.buttons
2685         button $w.buttons.create -text Push \
2686                 -font font_ui \
2687                 -command [list start_push_anywhere_action $w]
2688         pack $w.buttons.create -side right
2689         button $w.buttons.cancel -text {Cancel} \
2690                 -font font_ui \
2691                 -command [list destroy $w]
2692         pack $w.buttons.cancel -side right -padx 5
2693         pack $w.buttons -side bottom -fill x -pady 10 -padx 10
2694
2695         labelframe $w.source \
2696                 -text {Source Branches} \
2697                 -font font_ui
2698         listbox $w.source.l \
2699                 -height 10 \
2700                 -width 70 \
2701                 -selectmode extended \
2702                 -yscrollcommand [list $w.source.sby set] \
2703                 -font font_ui
2704         foreach h $all_heads {
2705                 $w.source.l insert end $h
2706                 if {$h eq $current_branch} {
2707                         $w.source.l select set end
2708                 }
2709         }
2710         scrollbar $w.source.sby -command [list $w.source.l yview]
2711         pack $w.source.sby -side right -fill y
2712         pack $w.source.l -side left -fill both -expand 1
2713         pack $w.source -fill both -expand 1 -pady 5 -padx 5
2714
2715         labelframe $w.dest \
2716                 -text {Destination Repository} \
2717                 -font font_ui
2718         if {$all_remotes ne {}} {
2719                 radiobutton $w.dest.remote_r \
2720                         -text {Remote:} \
2721                         -value remote \
2722                         -variable push_urltype \
2723                         -font font_ui
2724                 eval tk_optionMenu $w.dest.remote_m push_remote $all_remotes
2725                 grid $w.dest.remote_r $w.dest.remote_m -sticky w
2726                 if {[lsearch -sorted -exact $all_remotes origin] != -1} {
2727                         set push_remote origin
2728                 } else {
2729                         set push_remote [lindex $all_remotes 0]
2730                 }
2731                 set push_urltype remote
2732         } else {
2733                 set push_urltype url
2734         }
2735         radiobutton $w.dest.url_r \
2736                 -text {Arbitrary URL:} \
2737                 -value url \
2738                 -variable push_urltype \
2739                 -font font_ui
2740         entry $w.dest.url_t \
2741                 -borderwidth 1 \
2742                 -relief sunken \
2743                 -width 50 \
2744                 -textvariable push_url \
2745                 -font font_ui \
2746                 -validate key \
2747                 -validatecommand {
2748                         if {%d == 1 && [regexp {\s} %S]} {return 0}
2749                         if {%d == 1 && [string length %S] > 0} {
2750                                 set push_urltype url
2751                         }
2752                         return 1
2753                 }
2754         grid $w.dest.url_r $w.dest.url_t -sticky we -padx {0 5}
2755         grid columnconfigure $w.dest 1 -weight 1
2756         pack $w.dest -anchor nw -fill x -pady 5 -padx 5
2757
2758         labelframe $w.options \
2759                 -text {Transfer Options} \
2760                 -font font_ui
2761         checkbutton $w.options.thin \
2762                 -text {Use thin pack (for slow network connections)} \
2763                 -variable push_thin \
2764                 -font font_ui
2765         grid $w.options.thin -columnspan 2 -sticky w
2766         checkbutton $w.options.tags \
2767                 -text {Include tags} \
2768                 -variable push_tags \
2769                 -font font_ui
2770         grid $w.options.tags -columnspan 2 -sticky w
2771         grid columnconfigure $w.options 1 -weight 1
2772         pack $w.options -anchor nw -fill x -pady 5 -padx 5
2773
2774         set push_url {}
2775         set push_thin 0
2776         set push_tags 0
2777
2778         bind $w <Visibility> "grab $w"
2779         bind $w <Key-Escape> "destroy $w"
2780         wm title $w "[appname] ([reponame]): Push"
2781         tkwait window $w
2782 }
2783
2784 ######################################################################
2785 ##
2786 ## merge
2787
2788 proc can_merge {} {
2789         global HEAD commit_type file_states
2790
2791         if {[string match amend* $commit_type]} {
2792                 info_popup {Cannot merge while amending.
2793
2794 You must finish amending this commit before
2795 starting any type of merge.
2796 }
2797                 return 0
2798         }
2799
2800         if {[committer_ident] eq {}} {return 0}
2801         if {![lock_index merge]} {return 0}
2802
2803         # -- Our in memory state should match the repository.
2804         #
2805         repository_state curType curHEAD curMERGE_HEAD
2806         if {$commit_type ne $curType || $HEAD ne $curHEAD} {
2807                 info_popup {Last scanned state does not match repository state.
2808
2809 Another Git program has modified this repository
2810 since the last scan.  A rescan must be performed
2811 before a merge can be performed.
2812
2813 The rescan will be automatically started now.
2814 }
2815                 unlock_index
2816                 rescan {set ui_status_value {Ready.}}
2817                 return 0
2818         }
2819
2820         foreach path [array names file_states] {
2821                 switch -glob -- [lindex $file_states($path) 0] {
2822                 _O {
2823                         continue; # and pray it works!
2824                 }
2825                 U? {
2826                         error_popup "You are in the middle of a conflicted merge.
2827
2828 File [short_path $path] has merge conflicts.
2829
2830 You must resolve them, add the file, and commit to
2831 complete the current merge.  Only then can you
2832 begin another merge.
2833 "
2834                         unlock_index
2835                         return 0
2836                 }
2837                 ?? {
2838                         error_popup "You are in the middle of a change.
2839
2840 File [short_path $path] is modified.
2841
2842 You should complete the current commit before
2843 starting a merge.  Doing so will help you abort
2844 a failed merge, should the need arise.
2845 "
2846                         unlock_index
2847                         return 0
2848                 }
2849                 }
2850         }
2851
2852         return 1
2853 }
2854
2855 proc visualize_local_merge {w} {
2856         set revs {}
2857         foreach i [$w.source.l curselection] {
2858                 lappend revs [$w.source.l get $i]
2859         }
2860         if {$revs eq {}} return
2861         lappend revs --not HEAD
2862         do_gitk $revs
2863 }
2864
2865 proc start_local_merge_action {w} {
2866         global HEAD ui_status_value current_branch
2867
2868         set cmd [list git merge]
2869         set names {}
2870         set revcnt 0
2871         foreach i [$w.source.l curselection] {
2872                 set b [$w.source.l get $i]
2873                 lappend cmd $b
2874                 lappend names $b
2875                 incr revcnt
2876         }
2877
2878         if {$revcnt == 0} {
2879                 return
2880         } elseif {$revcnt == 1} {
2881                 set unit branch
2882         } elseif {$revcnt <= 15} {
2883                 set unit branches
2884         } else {
2885                 tk_messageBox \
2886                         -icon error \
2887                         -type ok \
2888                         -title [wm title $w] \
2889                         -parent $w \
2890                         -message "Too many branches selected.
2891
2892 You have requested to merge $revcnt branches
2893 in an octopus merge.  This exceeds Git's
2894 internal limit of 15 branches per merge.
2895
2896 Please select fewer branches.  To merge more
2897 than 15 branches, merge the branches in batches.
2898 "
2899                 return
2900         }
2901
2902         set msg "Merging $current_branch, [join $names {, }]"
2903         set ui_status_value "$msg..."
2904         set cons [new_console "Merge" $msg]
2905         console_exec $cons $cmd [list finish_merge $revcnt]
2906         bind $w <Destroy> {}
2907         destroy $w
2908 }
2909
2910 proc finish_merge {revcnt w ok} {
2911         console_done $w $ok
2912         if {$ok} {
2913                 set msg {Merge completed successfully.}
2914         } else {
2915                 if {$revcnt != 1} {
2916                         info_popup "Octopus merge failed.
2917
2918 Your merge of $revcnt branches has failed.
2919
2920 There are file-level conflicts between the
2921 branches which must be resolved manually.
2922
2923 The working directory will now be reset.
2924
2925 You can attempt this merge again
2926 by merging only one branch at a time." $w
2927
2928                         set fd [open "| git read-tree --reset -u HEAD" r]
2929                         fconfigure $fd -blocking 0 -translation binary
2930                         fileevent $fd readable [list reset_hard_wait $fd]
2931                         set ui_status_value {Aborting... please wait...}
2932                         return
2933                 }
2934
2935                 set msg {Merge failed.  Conflict resolution is required.}
2936         }
2937         unlock_index
2938         rescan [list set ui_status_value $msg]
2939 }
2940
2941 proc do_local_merge {} {
2942         global current_branch
2943
2944         if {![can_merge]} return
2945
2946         set w .merge_setup
2947         toplevel $w
2948         wm geometry $w "+[winfo rootx .]+[winfo rooty .]"
2949
2950         label $w.header \
2951                 -text "Merge Into $current_branch" \
2952                 -font font_uibold
2953         pack $w.header -side top -fill x
2954
2955         frame $w.buttons
2956         button $w.buttons.visualize -text Visualize \
2957                 -font font_ui \
2958                 -command [list visualize_local_merge $w]
2959         pack $w.buttons.visualize -side left
2960         button $w.buttons.create -text Merge \
2961                 -font font_ui \
2962                 -command [list start_local_merge_action $w]
2963         pack $w.buttons.create -side right
2964         button $w.buttons.cancel -text {Cancel} \
2965                 -font font_ui \
2966                 -command [list destroy $w]
2967         pack $w.buttons.cancel -side right -padx 5
2968         pack $w.buttons -side bottom -fill x -pady 10 -padx 10
2969
2970         labelframe $w.source \
2971                 -text {Source Branches} \
2972                 -font font_ui
2973         listbox $w.source.l \
2974                 -height 10 \
2975                 -width 70 \
2976                 -selectmode extended \
2977                 -yscrollcommand [list $w.source.sby set] \
2978                 -font font_ui
2979         scrollbar $w.source.sby -command [list $w.source.l yview]
2980         pack $w.source.sby -side right -fill y
2981         pack $w.source.l -side left -fill both -expand 1
2982         pack $w.source -fill both -expand 1 -pady 5 -padx 5
2983
2984         set cmd [list git for-each-ref]
2985         lappend cmd {--format=%(objectname) %(*objectname) %(refname)}
2986         lappend cmd refs/heads
2987         lappend cmd refs/remotes
2988         lappend cmd refs/tags
2989         set fr_fd [open "| $cmd" r]
2990         fconfigure $fr_fd -translation binary
2991         while {[gets $fr_fd line] > 0} {
2992                 set line [split $line { }]
2993                 set sha1([lindex $line 0]) [lindex $line 2]
2994                 set sha1([lindex $line 1]) [lindex $line 2]
2995         }
2996         close $fr_fd
2997
2998         set to_show {}
2999         set fr_fd [open "| git rev-list --all --not HEAD"]
3000         while {[gets $fr_fd line] > 0} {
3001                 if {[catch {set ref $sha1($line)}]} continue
3002                 regsub ^refs/(heads|remotes|tags)/ $ref {} ref
3003                 lappend to_show $ref
3004         }
3005         close $fr_fd
3006
3007         foreach ref [lsort -unique $to_show] {
3008                 $w.source.l insert end $ref
3009         }
3010
3011         bind $w <Visibility> "grab $w"
3012         bind $w <Key-Escape> "unlock_index;destroy $w"
3013         bind $w <Destroy> unlock_index
3014         wm title $w "[appname] ([reponame]): Merge"
3015         tkwait window $w
3016 }
3017
3018 proc do_reset_hard {} {
3019         global HEAD commit_type file_states
3020
3021         if {[string match amend* $commit_type]} {
3022                 info_popup {Cannot abort while amending.
3023
3024 You must finish amending this commit.
3025 }
3026                 return
3027         }
3028
3029         if {![lock_index abort]} return
3030
3031         if {[string match *merge* $commit_type]} {
3032                 set op merge
3033         } else {
3034                 set op commit
3035         }
3036
3037         if {[ask_popup "Abort $op?
3038
3039 Aborting the current $op will cause
3040 *ALL* uncommitted changes to be lost.
3041
3042 Continue with aborting the current $op?"] eq {yes}} {
3043                 set fd [open "| git read-tree --reset -u HEAD" r]
3044                 fconfigure $fd -blocking 0 -translation binary
3045                 fileevent $fd readable [list reset_hard_wait $fd]
3046                 set ui_status_value {Aborting... please wait...}
3047         } else {
3048                 unlock_index
3049         }
3050 }
3051
3052 proc reset_hard_wait {fd} {
3053         global ui_comm
3054
3055         read $fd
3056         if {[eof $fd]} {
3057                 close $fd
3058                 unlock_index
3059
3060                 $ui_comm delete 0.0 end
3061                 $ui_comm edit modified false
3062
3063                 catch {file delete [gitdir MERGE_HEAD]}
3064                 catch {file delete [gitdir rr-cache MERGE_RR]}
3065                 catch {file delete [gitdir SQUASH_MSG]}
3066                 catch {file delete [gitdir MERGE_MSG]}
3067                 catch {file delete [gitdir GITGUI_MSG]}
3068
3069                 rescan {set ui_status_value {Abort completed.  Ready.}}
3070         }
3071 }
3072
3073 ######################################################################
3074 ##
3075 ## browser
3076
3077 set next_browser_id 0
3078
3079 proc new_browser {commit} {
3080         global next_browser_id cursor_ptr M1B
3081         global browser_commit browser_status browser_stack browser_path browser_busy
3082
3083         if {[winfo ismapped .]} {
3084                 set w .browser[incr next_browser_id]
3085                 set tl $w
3086                 toplevel $w
3087         } else {
3088                 set w {}
3089                 set tl .
3090         }
3091         set w_list $w.list.l
3092         set browser_commit($w_list) $commit
3093         set browser_status($w_list) {Starting...}
3094         set browser_stack($w_list) {}
3095         set browser_path($w_list) $browser_commit($w_list):
3096         set browser_busy($w_list) 1
3097
3098         label $w.path -textvariable browser_path($w_list) \
3099                 -anchor w \
3100                 -justify left \
3101                 -borderwidth 1 \
3102                 -relief sunken \
3103                 -font font_uibold
3104         pack $w.path -anchor w -side top -fill x
3105
3106         frame $w.list
3107         text $w_list -background white -borderwidth 0 \
3108                 -cursor $cursor_ptr \
3109                 -state disabled \
3110                 -wrap none \
3111                 -height 20 \
3112                 -width 70 \
3113                 -xscrollcommand [list $w.list.sbx set] \
3114                 -yscrollcommand [list $w.list.sby set] \
3115                 -font font_ui
3116         $w_list tag conf in_sel \
3117                 -background [$w_list cget -foreground] \
3118                 -foreground [$w_list cget -background]
3119         scrollbar $w.list.sbx -orient h -command [list $w_list xview]
3120         scrollbar $w.list.sby -orient v -command [list $w_list yview]
3121         pack $w.list.sbx -side bottom -fill x
3122         pack $w.list.sby -side right -fill y
3123         pack $w_list -side left -fill both -expand 1
3124         pack $w.list -side top -fill both -expand 1
3125
3126         label $w.status -textvariable browser_status($w_list) \
3127                 -anchor w \
3128                 -justify left \
3129                 -borderwidth 1 \
3130                 -relief sunken \
3131                 -font font_ui
3132         pack $w.status -anchor w -side bottom -fill x
3133
3134         bind $w_list <Button-1>        "browser_click 0 $w_list @%x,%y;break"
3135         bind $w_list <Double-Button-1> "browser_click 1 $w_list @%x,%y;break"
3136         bind $w_list <$M1B-Up>         "browser_parent $w_list;break"
3137         bind $w_list <$M1B-Left>       "browser_parent $w_list;break"
3138         bind $w_list <Up>              "browser_move -1 $w_list;break"
3139         bind $w_list <Down>            "browser_move 1 $w_list;break"
3140         bind $w_list <$M1B-Right>      "browser_enter $w_list;break"
3141         bind $w_list <Return>          "browser_enter $w_list;break"
3142         bind $w_list <Prior>           "browser_page -1 $w_list;break"
3143         bind $w_list <Next>            "browser_page 1 $w_list;break"
3144         bind $w_list <Left>            break
3145         bind $w_list <Right>           break
3146
3147         bind $tl <Visibility> "focus $w"
3148         bind $tl <Destroy> "
3149                 array unset browser_buffer $w_list
3150                 array unset browser_files $w_list
3151                 array unset browser_status $w_list
3152                 array unset browser_stack $w_list
3153                 array unset browser_path $w_list
3154                 array unset browser_commit $w_list
3155                 array unset browser_busy $w_list
3156         "
3157         wm title $tl "[appname] ([reponame]): File Browser"
3158         ls_tree $w_list $browser_commit($w_list) {}
3159 }
3160
3161 proc browser_move {dir w} {
3162         global browser_files browser_busy
3163
3164         if {$browser_busy($w)} return
3165         set lno [lindex [split [$w index in_sel.first] .] 0]
3166         incr lno $dir
3167         if {[lindex $browser_files($w) [expr {$lno - 1}]] ne {}} {
3168                 $w tag remove in_sel 0.0 end
3169                 $w tag add in_sel $lno.0 [expr {$lno + 1}].0
3170                 $w see $lno.0
3171         }
3172 }
3173
3174 proc browser_page {dir w} {
3175         global browser_files browser_busy
3176
3177         if {$browser_busy($w)} return
3178         $w yview scroll $dir pages
3179         set lno [expr {int(
3180                   [lindex [$w yview] 0]
3181                 * [llength $browser_files($w)]
3182                 + 1)}]
3183         if {[lindex $browser_files($w) [expr {$lno - 1}]] ne {}} {
3184                 $w tag remove in_sel 0.0 end
3185                 $w tag add in_sel $lno.0 [expr {$lno + 1}].0
3186                 $w see $lno.0
3187         }
3188 }
3189
3190 proc browser_parent {w} {
3191         global browser_files browser_status browser_path
3192         global browser_stack browser_busy
3193
3194         if {$browser_busy($w)} return
3195         set info [lindex $browser_files($w) 0]
3196         if {[lindex $info 0] eq {parent}} {
3197                 set parent [lindex $browser_stack($w) end-1]
3198                 set browser_stack($w) [lrange $browser_stack($w) 0 end-2]
3199                 if {$browser_stack($w) eq {}} {
3200                         regsub {:.*$} $browser_path($w) {:} browser_path($w)
3201                 } else {
3202                         regsub {/[^/]+$} $browser_path($w) {} browser_path($w)
3203                 }
3204                 set browser_status($w) "Loading $browser_path($w)..."
3205                 ls_tree $w [lindex $parent 0] [lindex $parent 1]
3206         }
3207 }
3208
3209 proc browser_enter {w} {
3210         global browser_files browser_status browser_path
3211         global browser_commit browser_stack browser_busy
3212
3213         if {$browser_busy($w)} return
3214         set lno [lindex [split [$w index in_sel.first] .] 0]
3215         set info [lindex $browser_files($w) [expr {$lno - 1}]]
3216         if {$info ne {}} {
3217                 switch -- [lindex $info 0] {
3218                 parent {
3219                         browser_parent $w
3220                 }
3221                 tree {
3222                         set name [lindex $info 2]
3223                         set escn [escape_path $name]
3224                         set browser_status($w) "Loading $escn..."
3225                         append browser_path($w) $escn
3226                         ls_tree $w [lindex $info 1] $name
3227                 }
3228                 blob {
3229                         set name [lindex $info 2]
3230                         set p {}
3231                         foreach n $browser_stack($w) {
3232                                 append p [lindex $n 1]
3233                         }
3234                         append p $name
3235                         show_blame $browser_commit($w) $p
3236                 }
3237                 }
3238         }
3239 }
3240
3241 proc browser_click {was_double_click w pos} {
3242         global browser_files browser_busy
3243
3244         if {$browser_busy($w)} return
3245         set lno [lindex [split [$w index $pos] .] 0]
3246         focus $w
3247
3248         if {[lindex $browser_files($w) [expr {$lno - 1}]] ne {}} {
3249                 $w tag remove in_sel 0.0 end
3250                 $w tag add in_sel $lno.0 [expr {$lno + 1}].0
3251                 if {$was_double_click} {
3252                         browser_enter $w
3253                 }
3254         }
3255 }
3256
3257 proc ls_tree {w tree_id name} {
3258         global browser_buffer browser_files browser_stack browser_busy
3259
3260         set browser_buffer($w) {}
3261         set browser_files($w) {}
3262         set browser_busy($w) 1
3263
3264         $w conf -state normal
3265         $w tag remove in_sel 0.0 end
3266         $w delete 0.0 end
3267         if {$browser_stack($w) ne {}} {
3268                 $w image create end \
3269                         -align center -padx 5 -pady 1 \
3270                         -name icon0 \
3271                         -image file_uplevel
3272                 $w insert end {[Up To Parent]}
3273                 lappend browser_files($w) parent
3274         }
3275         lappend browser_stack($w) [list $tree_id $name]
3276         $w conf -state disabled
3277
3278         set cmd [list git ls-tree -z $tree_id]
3279         set fd [open "| $cmd" r]
3280         fconfigure $fd -blocking 0 -translation binary -encoding binary
3281         fileevent $fd readable [list read_ls_tree $fd $w]
3282 }
3283
3284 proc read_ls_tree {fd w} {
3285         global browser_buffer browser_files browser_status browser_busy
3286
3287         if {![winfo exists $w]} {
3288                 catch {close $fd}
3289                 return
3290         }
3291
3292         append browser_buffer($w) [read $fd]
3293         set pck [split $browser_buffer($w) "\0"]
3294         set browser_buffer($w) [lindex $pck end]
3295
3296         set n [llength $browser_files($w)]
3297         $w conf -state normal
3298         foreach p [lrange $pck 0 end-1] {
3299                 set info [split $p "\t"]
3300                 set path [lindex $info 1]
3301                 set info [split [lindex $info 0] { }]
3302                 set type [lindex $info 1]
3303                 set object [lindex $info 2]
3304
3305                 switch -- $type {
3306                 blob {
3307                         set image file_mod
3308                 }
3309                 tree {
3310                         set image file_dir
3311                         append path /
3312                 }
3313                 default {
3314                         set image file_question
3315                 }
3316                 }
3317
3318                 if {$n > 0} {$w insert end "\n"}
3319                 $w image create end \
3320                         -align center -padx 5 -pady 1 \
3321                         -name icon[incr n] \
3322                         -image $image
3323                 $w insert end [escape_path $path]
3324                 lappend browser_files($w) [list $type $object $path]
3325         }
3326         $w conf -state disabled
3327
3328         if {[eof $fd]} {
3329                 close $fd
3330                 set browser_status($w) Ready.
3331                 set browser_busy($w) 0
3332                 array unset browser_buffer $w
3333                 if {$n > 0} {
3334                         $w tag add in_sel 1.0 2.0
3335                         focus -force $w
3336                 }
3337         }
3338 }
3339
3340 proc show_blame {commit path} {
3341         global next_browser_id blame_status blame_data
3342
3343         if {[winfo ismapped .]} {
3344                 set w .browser[incr next_browser_id]
3345                 set tl $w
3346                 toplevel $w
3347         } else {
3348                 set w {}
3349                 set tl .
3350         }
3351         set blame_status($w) {Loading current file content...}
3352
3353         label $w.path -text "$commit:$path" \
3354                 -anchor w \
3355                 -justify left \
3356                 -borderwidth 1 \
3357                 -relief sunken \
3358                 -font font_uibold
3359         pack $w.path -side top -fill x
3360
3361         frame $w.out
3362         text $w.out.loaded_t \
3363                 -background white -borderwidth 0 \
3364                 -state disabled \
3365                 -wrap none \
3366                 -height 40 \
3367                 -width 1 \
3368                 -font font_diff
3369         $w.out.loaded_t tag conf annotated -background grey
3370
3371         text $w.out.linenumber_t \
3372                 -background white -borderwidth 0 \
3373                 -state disabled \
3374                 -wrap none \
3375                 -height 40 \
3376                 -width 5 \
3377                 -font font_diff
3378         $w.out.linenumber_t tag conf linenumber -justify right
3379
3380         text $w.out.file_t \
3381                 -background white -borderwidth 0 \
3382                 -state disabled \
3383                 -wrap none \
3384                 -height 40 \
3385                 -width 80 \
3386                 -xscrollcommand [list $w.out.sbx set] \
3387                 -font font_diff
3388
3389         scrollbar $w.out.sbx -orient h -command [list $w.out.file_t xview]
3390         scrollbar $w.out.sby -orient v \
3391                 -command [list scrollbar2many [list \
3392                 $w.out.loaded_t \
3393                 $w.out.linenumber_t \
3394                 $w.out.file_t \
3395                 ] yview]
3396         grid \
3397                 $w.out.linenumber_t \
3398                 $w.out.loaded_t \
3399                 $w.out.file_t \
3400                 $w.out.sby \
3401                 -sticky nsew
3402         grid conf $w.out.sbx -column 2 -sticky we
3403         grid columnconfigure $w.out 2 -weight 1
3404         grid rowconfigure $w.out 0 -weight 1
3405         pack $w.out -fill both -expand 1
3406
3407         label $w.status -textvariable blame_status($w) \
3408                 -anchor w \
3409                 -justify left \
3410                 -borderwidth 1 \
3411                 -relief sunken \
3412                 -font font_ui
3413         pack $w.status -side bottom -fill x
3414
3415         frame $w.cm
3416         text $w.cm.t \
3417                 -background white -borderwidth 0 \
3418                 -state disabled \
3419                 -wrap none \
3420                 -height 10 \
3421                 -width 80 \
3422                 -xscrollcommand [list $w.cm.sbx set] \
3423                 -yscrollcommand [list $w.cm.sby set] \
3424                 -font font_diff
3425         scrollbar $w.cm.sbx -orient h -command [list $w.cm.t xview]
3426         scrollbar $w.cm.sby -orient v -command [list $w.cm.t yview]
3427         pack $w.cm.sby -side right -fill y
3428         pack $w.cm.sbx -side bottom -fill x
3429         pack $w.cm.t -expand 1 -fill both
3430         pack $w.cm -side bottom -fill x
3431
3432         menu $w.ctxm -tearoff 0
3433         $w.ctxm add command -label "Copy Commit" \
3434                 -font font_ui \
3435                 -command "blame_copycommit $w \$cursorW @\$cursorX,\$cursorY"
3436
3437         foreach i [list \
3438                 $w.out.loaded_t \
3439                 $w.out.linenumber_t \
3440                 $w.out.file_t] {
3441                 $i tag conf in_sel \
3442                         -background [$i cget -foreground] \
3443                         -foreground [$i cget -background]
3444                 $i conf -yscrollcommand \
3445                         [list many2scrollbar [list \
3446                         $w.out.loaded_t \
3447                         $w.out.linenumber_t \
3448                         $w.out.file_t \
3449                         ] yview $w.out.sby]
3450                 bind $i <Button-1> "
3451                         blame_click {$w} \\
3452                                 $w.cm.t \\
3453                                 $w.out.linenumber_t \\
3454                                 $w.out.file_t \\
3455                                 $i @%x,%y
3456                         focus $i
3457                 "
3458                 bind_button3 $i "
3459                         set cursorX %x
3460                         set cursorY %y
3461                         set cursorW %W
3462                         tk_popup $w.ctxm %X %Y
3463                 "
3464         }
3465
3466         bind $w.cm.t <Button-1> "focus $w.cm.t"
3467         bind $tl <Visibility> "focus $tl"
3468         bind $tl <Destroy> "
3469                 array unset blame_status {$w}
3470                 array unset blame_data $w,*
3471         "
3472         wm title $tl "[appname] ([reponame]): File Viewer"
3473
3474         set blame_data($w,commit_count) 0
3475         set blame_data($w,commit_list) {}
3476         set blame_data($w,total_lines) 0
3477         set blame_data($w,blame_lines) 0
3478         set blame_data($w,highlight_commit) {}
3479         set blame_data($w,highlight_line) -1
3480
3481         set cmd [list git cat-file blob "$commit:$path"]
3482         set fd [open "| $cmd" r]
3483         fconfigure $fd -blocking 0 -translation lf -encoding binary
3484         fileevent $fd readable [list read_blame_catfile \
3485                 $fd $w $commit $path \
3486                 $w.cm.t $w.out.loaded_t $w.out.linenumber_t $w.out.file_t]
3487 }
3488
3489 proc read_blame_catfile {fd w commit path w_cmit w_load w_line w_file} {
3490         global blame_status blame_data
3491
3492         if {![winfo exists $w_file]} {
3493                 catch {close $fd}
3494                 return
3495         }
3496
3497         set n $blame_data($w,total_lines)
3498         $w_load conf -state normal
3499         $w_line conf -state normal
3500         $w_file conf -state normal
3501         while {[gets $fd line] >= 0} {
3502                 regsub "\r\$" $line {} line
3503                 incr n
3504                 $w_load insert end "\n"
3505                 $w_line insert end "$n\n" linenumber
3506                 $w_file insert end "$line\n"
3507         }
3508         $w_load conf -state disabled
3509         $w_line conf -state disabled
3510         $w_file conf -state disabled
3511         set blame_data($w,total_lines) $n
3512
3513         if {[eof $fd]} {
3514                 close $fd
3515                 blame_incremental_status $w
3516                 set cmd [list git blame -M -C --incremental]
3517                 lappend cmd $commit -- $path
3518                 set fd [open "| $cmd" r]
3519                 fconfigure $fd -blocking 0 -translation lf -encoding binary
3520                 fileevent $fd readable [list read_blame_incremental $fd $w \
3521                         $w_load $w_cmit $w_line $w_file]
3522         }
3523 }
3524
3525 proc read_blame_incremental {fd w w_load w_cmit w_line w_file} {
3526         global blame_status blame_data
3527
3528         if {![winfo exists $w_file]} {
3529                 catch {close $fd}
3530                 return
3531         }
3532
3533         while {[gets $fd line] >= 0} {
3534                 if {[regexp {^([a-z0-9]{40}) (\d+) (\d+) (\d+)$} $line line \
3535                         cmit original_line final_line line_count]} {
3536                         set blame_data($w,commit) $cmit
3537                         set blame_data($w,original_line) $original_line
3538                         set blame_data($w,final_line) $final_line
3539                         set blame_data($w,line_count) $line_count
3540
3541                         if {[catch {set g $blame_data($w,$cmit,order)}]} {
3542                                 $w_line tag conf g$cmit
3543                                 $w_file tag conf g$cmit
3544                                 $w_line tag raise in_sel
3545                                 $w_file tag raise in_sel
3546                                 $w_file tag raise sel
3547                                 set blame_data($w,$cmit,order) $blame_data($w,commit_count)
3548                                 incr blame_data($w,commit_count)
3549                                 lappend blame_data($w,commit_list) $cmit
3550                         }
3551                 } elseif {[string match {filename *} $line]} {
3552                         set file [string range $line 9 end]
3553                         set n $blame_data($w,line_count)
3554                         set lno $blame_data($w,final_line)
3555                         set cmit $blame_data($w,commit)
3556
3557                         while {$n > 0} {
3558                                 if {[catch {set g g$blame_data($w,line$lno,commit)}]} {
3559                                         $w_load tag add annotated $lno.0 "$lno.0 lineend + 1c"
3560                                 } else {
3561                                         $w_line tag remove g$g $lno.0 "$lno.0 lineend + 1c"
3562                                         $w_file tag remove g$g $lno.0 "$lno.0 lineend + 1c"
3563                                 }
3564
3565                                 set blame_data($w,line$lno,commit) $cmit
3566                                 set blame_data($w,line$lno,file) $file
3567                                 $w_line tag add g$cmit $lno.0 "$lno.0 lineend + 1c"
3568                                 $w_file tag add g$cmit $lno.0 "$lno.0 lineend + 1c"
3569
3570                                 if {$blame_data($w,highlight_line) == -1} {
3571                                         if {[lindex [$w_file yview] 0] == 0} {
3572                                                 $w_file see $lno.0
3573                                                 blame_showcommit $w $w_cmit $w_line $w_file $lno
3574                                         }
3575                                 } elseif {$blame_data($w,highlight_line) == $lno} {
3576                                         blame_showcommit $w $w_cmit $w_line $w_file $lno
3577                                 }
3578
3579                                 incr n -1
3580                                 incr lno
3581                                 incr blame_data($w,blame_lines)
3582                         }
3583
3584                         set hc $blame_data($w,highlight_commit)
3585                         if {$hc ne {}
3586                                 && [expr {$blame_data($w,$hc,order) + 1}]
3587                                         == $blame_data($w,$cmit,order)} {
3588                                 blame_showcommit $w $w_cmit $w_line $w_file \
3589                                         $blame_data($w,highlight_line)
3590                         }
3591                 } elseif {[regexp {^([a-z-]+) (.*)$} $line line header data]} {
3592                         set blame_data($w,$blame_data($w,commit),$header) $data
3593                 }
3594         }
3595
3596         if {[eof $fd]} {
3597                 close $fd
3598                 set blame_status($w) {Annotation complete.}
3599         } else {
3600                 blame_incremental_status $w
3601         }
3602 }
3603
3604 proc blame_incremental_status {w} {
3605         global blame_status blame_data
3606
3607         set blame_status($w) [format \
3608                 "Loading annotations... %i of %i lines annotated (%2i%%)" \
3609                 $blame_data($w,blame_lines) \
3610                 $blame_data($w,total_lines) \
3611                 [expr {100 * $blame_data($w,blame_lines)
3612                         / $blame_data($w,total_lines)}]]
3613 }
3614
3615 proc blame_click {w w_cmit w_line w_file cur_w pos} {
3616         set lno [lindex [split [$cur_w index $pos] .] 0]
3617         if {$lno eq {}} return
3618
3619         $w_line tag remove in_sel 0.0 end
3620         $w_file tag remove in_sel 0.0 end
3621         $w_line tag add in_sel $lno.0 "$lno.0 + 1 line"
3622         $w_file tag add in_sel $lno.0 "$lno.0 + 1 line"
3623
3624         blame_showcommit $w $w_cmit $w_line $w_file $lno
3625 }
3626
3627 set blame_colors {
3628         #ff4040
3629         #ff40ff
3630         #4040ff
3631 }
3632
3633 proc blame_showcommit {w w_cmit w_line w_file lno} {
3634         global blame_colors blame_data repo_config
3635
3636         set cmit $blame_data($w,highlight_commit)
3637         if {$cmit ne {}} {
3638                 set idx $blame_data($w,$cmit,order)
3639                 set i 0
3640                 foreach c $blame_colors {
3641                         set h [lindex $blame_data($w,commit_list) [expr {$idx - 1 + $i}]]
3642                         $w_line tag conf g$h -background white
3643                         $w_file tag conf g$h -background white
3644                         incr i
3645                 }
3646         }
3647
3648         $w_cmit conf -state normal
3649         $w_cmit delete 0.0 end
3650         if {[catch {set cmit $blame_data($w,line$lno,commit)}]} {
3651                 set cmit {}
3652                 $w_cmit insert end "Loading annotation..."
3653         } else {
3654                 set idx $blame_data($w,$cmit,order)
3655                 set i 0
3656                 foreach c $blame_colors {
3657                         set h [lindex $blame_data($w,commit_list) [expr {$idx - 1 + $i}]]
3658                         $w_line tag conf g$h -background $c
3659                         $w_file tag conf g$h -background $c
3660                         incr i
3661                 }
3662
3663                 if {[catch {set msg $blame_data($w,$cmit,message)}]} {
3664                         set msg {}
3665                         catch {
3666                                 set fd [open "| git cat-file commit $cmit" r]
3667                                 fconfigure $fd -encoding binary -translation lf
3668                                 if {[catch {set enc $repo_config(i18n.commitencoding)}]} {
3669                                         set enc utf-8
3670                                 }
3671                                 while {[gets $fd line] > 0} {
3672                                         if {[string match {encoding *} $line]} {
3673                                                 set enc [string tolower [string range $line 9 end]]
3674                                         }
3675                                 }
3676                                 fconfigure $fd -encoding $enc
3677                                 set msg [string trim [read $fd]]
3678                                 close $fd
3679                         }
3680                         set blame_data($w,$cmit,message) $msg
3681                 }
3682
3683                 set author_name {}
3684                 set author_email {}
3685                 set author_time {}
3686                 catch {set author_name $blame_data($w,$cmit,author)}
3687                 catch {set author_email $blame_data($w,$cmit,author-mail)}
3688                 catch {set author_time [clock format $blame_data($w,$cmit,author-time)]}
3689
3690                 set committer_name {}
3691                 set committer_email {}
3692                 set committer_time {}
3693                 catch {set committer_name $blame_data($w,$cmit,committer)}
3694                 catch {set committer_email $blame_data($w,$cmit,committer-mail)}
3695                 catch {set committer_time [clock format $blame_data($w,$cmit,committer-time)]}
3696
3697                 $w_cmit insert end "commit $cmit\n"
3698                 $w_cmit insert end "Author: $author_name $author_email $author_time\n"
3699                 $w_cmit insert end "Committer: $committer_name $committer_email $committer_time\n"
3700                 $w_cmit insert end "Original File: [escape_path $blame_data($w,line$lno,file)]\n"
3701                 $w_cmit insert end "\n"
3702                 $w_cmit insert end $msg
3703         }
3704         $w_cmit conf -state disabled
3705
3706         set blame_data($w,highlight_line) $lno
3707         set blame_data($w,highlight_commit) $cmit
3708 }
3709
3710 proc blame_copycommit {w i pos} {
3711         global blame_data
3712         set lno [lindex [split [$i index $pos] .] 0]
3713         if {![catch {set commit $blame_data($w,line$lno,commit)}]} {
3714                 clipboard clear
3715                 clipboard append \
3716                         -format STRING \
3717                         -type STRING \
3718                         -- $commit
3719         }
3720 }
3721
3722 ######################################################################
3723 ##
3724 ## icons
3725
3726 set filemask {
3727 #define mask_width 14
3728 #define mask_height 15
3729 static unsigned char mask_bits[] = {
3730    0xfe, 0x1f, 0xfe, 0x1f, 0xfe, 0x1f, 0xfe, 0x1f, 0xfe, 0x1f, 0xfe, 0x1f,
3731    0xfe, 0x1f, 0xfe, 0x1f, 0xfe, 0x1f, 0xfe, 0x1f, 0xfe, 0x1f, 0xfe, 0x1f,
3732    0xfe, 0x1f, 0xfe, 0x1f, 0xfe, 0x1f};
3733 }
3734
3735 image create bitmap file_plain -background white -foreground black -data {
3736 #define plain_width 14
3737 #define plain_height 15
3738 static unsigned char plain_bits[] = {
3739    0xfe, 0x01, 0x02, 0x03, 0x02, 0x05, 0x02, 0x09, 0x02, 0x1f, 0x02, 0x10,
3740    0x02, 0x10, 0x02, 0x10, 0x02, 0x10, 0x02, 0x10, 0x02, 0x10, 0x02, 0x10,
3741    0x02, 0x10, 0x02, 0x10, 0xfe, 0x1f};
3742 } -maskdata $filemask
3743
3744 image create bitmap file_mod -background white -foreground blue -data {
3745 #define mod_width 14
3746 #define mod_height 15
3747 static unsigned char mod_bits[] = {
3748    0xfe, 0x01, 0x02, 0x03, 0x7a, 0x05, 0x02, 0x09, 0x7a, 0x1f, 0x02, 0x10,
3749    0xfa, 0x17, 0x02, 0x10, 0xfa, 0x17, 0x02, 0x10, 0xfa, 0x17, 0x02, 0x10,
3750    0xfa, 0x17, 0x02, 0x10, 0xfe, 0x1f};
3751 } -maskdata $filemask
3752
3753 image create bitmap file_fulltick -background white -foreground "#007000" -data {
3754 #define file_fulltick_width 14
3755 #define file_fulltick_height 15
3756 static unsigned char file_fulltick_bits[] = {
3757    0xfe, 0x01, 0x02, 0x1a, 0x02, 0x0c, 0x02, 0x0c, 0x02, 0x16, 0x02, 0x16,
3758    0x02, 0x13, 0x00, 0x13, 0x86, 0x11, 0x8c, 0x11, 0xd8, 0x10, 0xf2, 0x10,
3759    0x62, 0x10, 0x02, 0x10, 0xfe, 0x1f};
3760 } -maskdata $filemask
3761
3762 image create bitmap file_parttick -background white -foreground "#005050" -data {
3763 #define parttick_width 14
3764 #define parttick_height 15
3765 static unsigned char parttick_bits[] = {
3766    0xfe, 0x01, 0x02, 0x03, 0x7a, 0x05, 0x02, 0x09, 0x7a, 0x1f, 0x02, 0x10,
3767    0x7a, 0x14, 0x02, 0x16, 0x02, 0x13, 0x8a, 0x11, 0xda, 0x10, 0x72, 0x10,
3768    0x22, 0x10, 0x02, 0x10, 0xfe, 0x1f};
3769 } -maskdata $filemask
3770
3771 image create bitmap file_question -background white -foreground black -data {
3772 #define file_question_width 14
3773 #define file_question_height 15
3774 static unsigned char file_question_bits[] = {
3775    0xfe, 0x01, 0x02, 0x02, 0xe2, 0x04, 0xf2, 0x09, 0x1a, 0x1b, 0x0a, 0x13,
3776    0x82, 0x11, 0xc2, 0x10, 0x62, 0x10, 0x62, 0x10, 0x02, 0x10, 0x62, 0x10,
3777    0x62, 0x10, 0x02, 0x10, 0xfe, 0x1f};
3778 } -maskdata $filemask
3779
3780 image create bitmap file_removed -background white -foreground red -data {
3781 #define file_removed_width 14
3782 #define file_removed_height 15
3783 static unsigned char file_removed_bits[] = {
3784    0xfe, 0x01, 0x02, 0x03, 0x02, 0x05, 0x02, 0x09, 0x02, 0x1f, 0x02, 0x10,
3785    0x1a, 0x16, 0x32, 0x13, 0xe2, 0x11, 0xc2, 0x10, 0xe2, 0x11, 0x32, 0x13,
3786    0x1a, 0x16, 0x02, 0x10, 0xfe, 0x1f};
3787 } -maskdata $filemask
3788
3789 image create bitmap file_merge -background white -foreground blue -data {
3790 #define file_merge_width 14
3791 #define file_merge_height 15
3792 static unsigned char file_merge_bits[] = {
3793    0xfe, 0x01, 0x02, 0x03, 0x62, 0x05, 0x62, 0x09, 0x62, 0x1f, 0x62, 0x10,
3794    0xfa, 0x11, 0xf2, 0x10, 0x62, 0x10, 0x02, 0x10, 0xfa, 0x17, 0x02, 0x10,
3795    0xfa, 0x17, 0x02, 0x10, 0xfe, 0x1f};
3796 } -maskdata $filemask
3797
3798 set file_dir_data {
3799 #define file_width 18
3800 #define file_height 18
3801 static unsigned char file_bits[] = {
3802   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x03, 0x00,
3803   0x0c, 0x03, 0x00, 0x04, 0xfe, 0x00, 0x06, 0x80, 0x00, 0xff, 0x9f, 0x00,
3804   0x03, 0x98, 0x00, 0x02, 0x90, 0x00, 0x06, 0xb0, 0x00, 0x04, 0xa0, 0x00,
3805   0x0c, 0xe0, 0x00, 0x08, 0xc0, 0x00, 0xf8, 0xff, 0x00, 0x00, 0x00, 0x00,
3806   0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
3807 }
3808 image create bitmap file_dir -background white -foreground blue \
3809         -data $file_dir_data -maskdata $file_dir_data
3810 unset file_dir_data
3811
3812 set file_uplevel_data {
3813 #define up_width 15
3814 #define up_height 15
3815 static unsigned char up_bits[] = {
3816   0x80, 0x00, 0xc0, 0x01, 0xe0, 0x03, 0xf0, 0x07, 0xf8, 0x0f, 0xfc, 0x1f,
3817   0xfe, 0x3f, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01,
3818   0xc0, 0x01, 0xc0, 0x01, 0x00, 0x00};
3819 }
3820 image create bitmap file_uplevel -background white -foreground red \
3821         -data $file_uplevel_data -maskdata $file_uplevel_data
3822 unset file_uplevel_data
3823
3824 set ui_index .vpane.files.index.list
3825 set ui_workdir .vpane.files.workdir.list
3826
3827 set all_icons(_$ui_index)   file_plain
3828 set all_icons(A$ui_index)   file_fulltick
3829 set all_icons(M$ui_index)   file_fulltick
3830 set all_icons(D$ui_index)   file_removed
3831 set all_icons(U$ui_index)   file_merge
3832
3833 set all_icons(_$ui_workdir) file_plain
3834 set all_icons(M$ui_workdir) file_mod
3835 set all_icons(D$ui_workdir) file_question
3836 set all_icons(U$ui_workdir) file_merge
3837 set all_icons(O$ui_workdir) file_plain
3838
3839 set max_status_desc 0
3840 foreach i {
3841                 {__ "Unmodified"}
3842
3843                 {_M "Modified, not staged"}
3844                 {M_ "Staged for commit"}
3845                 {MM "Portions staged for commit"}
3846                 {MD "Staged for commit, missing"}
3847
3848                 {_O "Untracked, not staged"}
3849                 {A_ "Staged for commit"}
3850                 {AM "Portions staged for commit"}
3851                 {AD "Staged for commit, missing"}
3852
3853                 {_D "Missing"}
3854                 {D_ "Staged for removal"}
3855                 {DO "Staged for removal, still present"}
3856
3857                 {U_ "Requires merge resolution"}
3858                 {UU "Requires merge resolution"}
3859                 {UM "Requires merge resolution"}
3860                 {UD "Requires merge resolution"}
3861         } {
3862         if {$max_status_desc < [string length [lindex $i 1]]} {
3863                 set max_status_desc [string length [lindex $i 1]]
3864         }
3865         set all_descs([lindex $i 0]) [lindex $i 1]
3866 }
3867 unset i
3868
3869 ######################################################################
3870 ##
3871 ## util
3872
3873 proc bind_button3 {w cmd} {
3874         bind $w <Any-Button-3> $cmd
3875         if {[is_MacOSX]} {
3876                 bind $w <Control-Button-1> $cmd
3877         }
3878 }
3879
3880 proc scrollbar2many {list mode args} {
3881         foreach w $list {eval $w $mode $args}
3882 }
3883
3884 proc many2scrollbar {list mode sb top bottom} {
3885         $sb set $top $bottom
3886         foreach w $list {$w $mode moveto $top}
3887 }
3888
3889 proc incr_font_size {font {amt 1}} {
3890         set sz [font configure $font -size]
3891         incr sz $amt
3892         font configure $font -size $sz
3893         font configure ${font}bold -size $sz
3894 }
3895
3896 proc hook_failed_popup {hook msg} {
3897         set w .hookfail
3898         toplevel $w
3899
3900         frame $w.m
3901         label $w.m.l1 -text "$hook hook failed:" \
3902                 -anchor w \
3903                 -justify left \
3904                 -font font_uibold
3905         text $w.m.t \
3906                 -background white -borderwidth 1 \
3907                 -relief sunken \
3908                 -width 80 -height 10 \
3909                 -font font_diff \
3910                 -yscrollcommand [list $w.m.sby set]
3911         label $w.m.l2 \
3912                 -text {You must correct the above errors before committing.} \
3913                 -anchor w \
3914                 -justify left \
3915                 -font font_uibold
3916         scrollbar $w.m.sby -command [list $w.m.t yview]
3917         pack $w.m.l1 -side top -fill x
3918         pack $w.m.l2 -side bottom -fill x
3919         pack $w.m.sby -side right -fill y
3920         pack $w.m.t -side left -fill both -expand 1
3921         pack $w.m -side top -fill both -expand 1 -padx 5 -pady 10
3922
3923         $w.m.t insert 1.0 $msg
3924         $w.m.t conf -state disabled
3925
3926         button $w.ok -text OK \
3927                 -width 15 \
3928                 -font font_ui \
3929                 -command "destroy $w"
3930         pack $w.ok -side bottom -anchor e -pady 10 -padx 10
3931
3932         bind $w <Visibility> "grab $w; focus $w"
3933         bind $w <Key-Return> "destroy $w"
3934         wm title $w "[appname] ([reponame]): error"
3935         tkwait window $w
3936 }
3937
3938 set next_console_id 0
3939
3940 proc new_console {short_title long_title} {
3941         global next_console_id console_data
3942         set w .console[incr next_console_id]
3943         set console_data($w) [list $short_title $long_title]
3944         return [console_init $w]
3945 }
3946
3947 proc console_init {w} {
3948         global console_cr console_data M1B
3949
3950         set console_cr($w) 1.0
3951         toplevel $w
3952         frame $w.m
3953         label $w.m.l1 -text "[lindex $console_data($w) 1]:" \
3954                 -anchor w \
3955                 -justify left \
3956                 -font font_uibold
3957         text $w.m.t \
3958                 -background white -borderwidth 1 \
3959                 -relief sunken \
3960                 -width 80 -height 10 \
3961                 -font font_diff \
3962                 -state disabled \
3963                 -yscrollcommand [list $w.m.sby set]
3964         label $w.m.s -text {Working... please wait...} \
3965                 -anchor w \
3966                 -justify left \
3967                 -font font_uibold
3968         scrollbar $w.m.sby -command [list $w.m.t yview]
3969         pack $w.m.l1 -side top -fill x
3970         pack $w.m.s -side bottom -fill x
3971         pack $w.m.sby -side right -fill y
3972         pack $w.m.t -side left -fill both -expand 1
3973         pack $w.m -side top -fill both -expand 1 -padx 5 -pady 10
3974
3975         menu $w.ctxm -tearoff 0
3976         $w.ctxm add command -label "Copy" \
3977                 -font font_ui \
3978                 -command "tk_textCopy $w.m.t"
3979         $w.ctxm add command -label "Select All" \
3980                 -font font_ui \
3981                 -command "focus $w.m.t;$w.m.t tag add sel 0.0 end"
3982         $w.ctxm add command -label "Copy All" \
3983                 -font font_ui \
3984                 -command "
3985                         $w.m.t tag add sel 0.0 end
3986                         tk_textCopy $w.m.t
3987                         $w.m.t tag remove sel 0.0 end
3988                 "
3989
3990         button $w.ok -text {Close} \
3991                 -font font_ui \
3992                 -state disabled \
3993                 -command "destroy $w"
3994         pack $w.ok -side bottom -anchor e -pady 10 -padx 10
3995
3996         bind_button3 $w.m.t "tk_popup $w.ctxm %X %Y"
3997         bind $w.m.t <$M1B-Key-a> "$w.m.t tag add sel 0.0 end;break"
3998         bind $w.m.t <$M1B-Key-A> "$w.m.t tag add sel 0.0 end;break"
3999         bind $w <Visibility> "focus $w"
4000         wm title $w "[appname] ([reponame]): [lindex $console_data($w) 0]"
4001         return $w
4002 }
4003
4004 proc console_exec {w cmd after} {
4005         # -- Cygwin's Tcl tosses the enviroment when we exec our child.
4006         #    But most users need that so we have to relogin. :-(
4007         #
4008         if {[is_Cygwin]} {
4009                 set cmd [list sh --login -c "cd \"[pwd]\" && [join $cmd { }]"]
4010         }
4011
4012         # -- Tcl won't let us redirect both stdout and stderr to
4013         #    the same pipe.  So pass it through cat...
4014         #
4015         set cmd [concat | $cmd |& cat]
4016
4017         set fd_f [open $cmd r]
4018         fconfigure $fd_f -blocking 0 -translation binary
4019         fileevent $fd_f readable [list console_read $w $fd_f $after]
4020 }
4021
4022 proc console_read {w fd after} {
4023         global console_cr
4024
4025         set buf [read $fd]
4026         if {$buf ne {}} {
4027                 if {![winfo exists $w]} {console_init $w}
4028                 $w.m.t conf -state normal
4029                 set c 0
4030                 set n [string length $buf]
4031                 while {$c < $n} {
4032                         set cr [string first "\r" $buf $c]
4033                         set lf [string first "\n" $buf $c]
4034                         if {$cr < 0} {set cr [expr {$n + 1}]}
4035                         if {$lf < 0} {set lf [expr {$n + 1}]}
4036
4037                         if {$lf < $cr} {
4038                                 $w.m.t insert end [string range $buf $c $lf]
4039                                 set console_cr($w) [$w.m.t index {end -1c}]
4040                                 set c $lf
4041                                 incr c
4042                         } else {
4043                                 $w.m.t delete $console_cr($w) end
4044                                 $w.m.t insert end "\n"
4045                                 $w.m.t insert end [string range $buf $c $cr]
4046                                 set c $cr
4047                                 incr c
4048                         }
4049                 }
4050                 $w.m.t conf -state disabled
4051                 $w.m.t see end
4052         }
4053
4054         fconfigure $fd -blocking 1
4055         if {[eof $fd]} {
4056                 if {[catch {close $fd}]} {
4057                         set ok 0
4058                 } else {
4059                         set ok 1
4060                 }
4061                 uplevel #0 $after $w $ok
4062                 return
4063         }
4064         fconfigure $fd -blocking 0
4065 }
4066
4067 proc console_chain {cmdlist w {ok 1}} {
4068         if {$ok} {
4069                 if {[llength $cmdlist] == 0} {
4070                         console_done $w $ok
4071                         return
4072                 }
4073
4074                 set cmd [lindex $cmdlist 0]
4075                 set cmdlist [lrange $cmdlist 1 end]
4076
4077                 if {[lindex $cmd 0] eq {console_exec}} {
4078                         console_exec $w \
4079                                 [lindex $cmd 1] \
4080                                 [list console_chain $cmdlist]
4081                 } else {
4082                         uplevel #0 $cmd $cmdlist $w $ok
4083                 }
4084         } else {
4085                 console_done $w $ok
4086         }
4087 }
4088
4089 proc console_done {args} {
4090         global console_cr console_data
4091
4092         switch -- [llength $args] {
4093         2 {
4094                 set w [lindex $args 0]
4095                 set ok [lindex $args 1]
4096         }
4097         3 {
4098                 set w [lindex $args 1]
4099                 set ok [lindex $args 2]
4100         }
4101         default {
4102                 error "wrong number of args: console_done ?ignored? w ok"
4103         }
4104         }
4105
4106         if {$ok} {
4107                 if {[winfo exists $w]} {
4108                         $w.m.s conf -background green -text {Success}
4109                         $w.ok conf -state normal
4110                 }
4111         } else {
4112                 if {![winfo exists $w]} {
4113                         console_init $w
4114                 }
4115                 $w.m.s conf -background red -text {Error: Command Failed}
4116                 $w.ok conf -state normal
4117         }
4118
4119         array unset console_cr $w
4120         array unset console_data $w
4121 }
4122
4123 ######################################################################
4124 ##
4125 ## ui commands
4126
4127 set starting_gitk_msg {Starting gitk... please wait...}
4128
4129 proc do_gitk {revs} {
4130         global env ui_status_value starting_gitk_msg
4131
4132         # -- Always start gitk through whatever we were loaded with.  This
4133         #    lets us bypass using shell process on Windows systems.
4134         #
4135         set cmd [info nameofexecutable]
4136         lappend cmd [gitexec gitk]
4137         if {$revs ne {}} {
4138                 append cmd { }
4139                 append cmd $revs
4140         }
4141
4142         if {[catch {eval exec $cmd &} err]} {
4143                 error_popup "Failed to start gitk:\n\n$err"
4144         } else {
4145                 set ui_status_value $starting_gitk_msg
4146                 after 10000 {
4147                         if {$ui_status_value eq $starting_gitk_msg} {
4148                                 set ui_status_value {Ready.}
4149                         }
4150                 }
4151         }
4152 }
4153
4154 proc do_stats {} {
4155         set fd [open "| git count-objects -v" r]
4156         while {[gets $fd line] > 0} {
4157                 if {[regexp {^([^:]+): (\d+)$} $line _ name value]} {
4158                         set stats($name) $value
4159                 }
4160         }
4161         close $fd
4162
4163         set packed_sz 0
4164         foreach p [glob -directory [gitdir objects pack] \
4165                 -type f \
4166                 -nocomplain -- *] {
4167                 incr packed_sz [file size $p]
4168         }
4169         if {$packed_sz > 0} {
4170                 set stats(size-pack) [expr {$packed_sz / 1024}]
4171         }
4172
4173         set w .stats_view
4174         toplevel $w
4175         wm geometry $w "+[winfo rootx .]+[winfo rooty .]"
4176
4177         label $w.header -text {Database Statistics} \
4178                 -font font_uibold
4179         pack $w.header -side top -fill x
4180
4181         frame $w.buttons -border 1
4182         button $w.buttons.close -text Close \
4183                 -font font_ui \
4184                 -command [list destroy $w]
4185         button $w.buttons.gc -text {Compress Database} \
4186                 -font font_ui \
4187                 -command "destroy $w;do_gc"
4188         pack $w.buttons.close -side right
4189         pack $w.buttons.gc -side left
4190         pack $w.buttons -side bottom -fill x -pady 10 -padx 10
4191
4192         frame $w.stat -borderwidth 1 -relief solid
4193         foreach s {
4194                 {count           {Number of loose objects}}
4195                 {size            {Disk space used by loose objects} { KiB}}
4196                 {in-pack         {Number of packed objects}}
4197                 {packs           {Number of packs}}
4198                 {size-pack       {Disk space used by packed objects} { KiB}}
4199                 {prune-packable  {Packed objects waiting for pruning}}
4200                 {garbage         {Garbage files}}
4201                 } {
4202                 set name [lindex $s 0]
4203                 set label [lindex $s 1]
4204                 if {[catch {set value $stats($name)}]} continue
4205                 if {[llength $s] > 2} {
4206                         set value "$value[lindex $s 2]"
4207                 }
4208
4209                 label $w.stat.l_$name -text "$label:" -anchor w -font font_ui
4210                 label $w.stat.v_$name -text $value -anchor w -font font_ui
4211                 grid $w.stat.l_$name $w.stat.v_$name -sticky we -padx {0 5}
4212         }
4213         pack $w.stat -pady 10 -padx 10
4214
4215         bind $w <Visibility> "grab $w; focus $w"
4216         bind $w <Key-Escape> [list destroy $w]
4217         bind $w <Key-Return> [list destroy $w]
4218         wm title $w "[appname] ([reponame]): Database Statistics"
4219         tkwait window $w
4220 }
4221
4222 proc do_gc {} {
4223         set w [new_console {gc} {Compressing the object database}]
4224         console_chain {
4225                 {console_exec {git pack-refs --prune}}
4226                 {console_exec {git reflog expire --all}}
4227                 {console_exec {git repack -a -d -l}}
4228                 {console_exec {git rerere gc}}
4229         } $w
4230 }
4231
4232 proc do_fsck_objects {} {
4233         set w [new_console {fsck-objects} \
4234                 {Verifying the object database with fsck-objects}]
4235         set cmd [list git fsck-objects]
4236         lappend cmd --full
4237         lappend cmd --cache
4238         lappend cmd --strict
4239         console_exec $w $cmd console_done
4240 }
4241
4242 set is_quitting 0
4243
4244 proc do_quit {} {
4245         global ui_comm is_quitting repo_config commit_type
4246
4247         if {$is_quitting} return
4248         set is_quitting 1
4249
4250         if {[winfo exists $ui_comm]} {
4251                 # -- Stash our current commit buffer.
4252                 #
4253                 set save [gitdir GITGUI_MSG]
4254                 set msg [string trim [$ui_comm get 0.0 end]]
4255                 regsub -all -line {[ \r\t]+$} $msg {} msg
4256                 if {(![string match amend* $commit_type]
4257                         || [$ui_comm edit modified])
4258                         && $msg ne {}} {
4259                         catch {
4260                                 set fd [open $save w]
4261                                 puts -nonewline $fd $msg
4262                                 close $fd
4263                         }
4264                 } else {
4265                         catch {file delete $save}
4266                 }
4267
4268                 # -- Stash our current window geometry into this repository.
4269                 #
4270                 set cfg_geometry [list]
4271                 lappend cfg_geometry [wm geometry .]
4272                 lappend cfg_geometry [lindex [.vpane sash coord 0] 1]
4273                 lappend cfg_geometry [lindex [.vpane.files sash coord 0] 0]
4274                 if {[catch {set rc_geometry $repo_config(gui.geometry)}]} {
4275                         set rc_geometry {}
4276                 }
4277                 if {$cfg_geometry ne $rc_geometry} {
4278                         catch {git config gui.geometry $cfg_geometry}
4279                 }
4280         }
4281
4282         destroy .
4283 }
4284
4285 proc do_rescan {} {
4286         rescan {set ui_status_value {Ready.}}
4287 }
4288
4289 proc unstage_helper {txt paths} {
4290         global file_states current_diff_path
4291
4292         if {![lock_index begin-update]} return
4293
4294         set pathList [list]
4295         set after {}
4296         foreach path $paths {
4297                 switch -glob -- [lindex $file_states($path) 0] {
4298                 A? -
4299                 M? -
4300                 D? {
4301                         lappend pathList $path
4302                         if {$path eq $current_diff_path} {
4303                                 set after {reshow_diff;}
4304                         }
4305                 }
4306                 }
4307         }
4308         if {$pathList eq {}} {
4309                 unlock_index
4310         } else {
4311                 update_indexinfo \
4312                         $txt \
4313                         $pathList \
4314                         [concat $after {set ui_status_value {Ready.}}]
4315         }
4316 }
4317
4318 proc do_unstage_selection {} {
4319         global current_diff_path selected_paths
4320
4321         if {[array size selected_paths] > 0} {
4322                 unstage_helper \
4323                         {Unstaging selected files from commit} \
4324                         [array names selected_paths]
4325         } elseif {$current_diff_path ne {}} {
4326                 unstage_helper \
4327                         "Unstaging [short_path $current_diff_path] from commit" \
4328                         [list $current_diff_path]
4329         }
4330 }
4331
4332 proc add_helper {txt paths} {
4333         global file_states current_diff_path
4334
4335         if {![lock_index begin-update]} return
4336
4337         set pathList [list]
4338         set after {}
4339         foreach path $paths {
4340                 switch -glob -- [lindex $file_states($path) 0] {
4341                 _O -
4342                 ?M -
4343                 ?D -
4344                 U? {
4345                         lappend pathList $path
4346                         if {$path eq $current_diff_path} {
4347                                 set after {reshow_diff;}
4348                         }
4349                 }
4350                 }
4351         }
4352         if {$pathList eq {}} {
4353                 unlock_index
4354         } else {
4355                 update_index \
4356                         $txt \
4357                         $pathList \
4358                         [concat $after {set ui_status_value {Ready to commit.}}]
4359         }
4360 }
4361
4362 proc do_add_selection {} {
4363         global current_diff_path selected_paths
4364
4365         if {[array size selected_paths] > 0} {
4366                 add_helper \
4367                         {Adding selected files} \
4368                         [array names selected_paths]
4369         } elseif {$current_diff_path ne {}} {
4370                 add_helper \
4371                         "Adding [short_path $current_diff_path]" \
4372                         [list $current_diff_path]
4373         }
4374 }
4375
4376 proc do_add_all {} {
4377         global file_states
4378
4379         set paths [list]
4380         foreach path [array names file_states] {
4381                 switch -glob -- [lindex $file_states($path) 0] {
4382                 U? {continue}
4383                 ?M -
4384                 ?D {lappend paths $path}
4385                 }
4386         }
4387         add_helper {Adding all changed files} $paths
4388 }
4389
4390 proc revert_helper {txt paths} {
4391         global file_states current_diff_path
4392
4393         if {![lock_index begin-update]} return
4394
4395         set pathList [list]
4396         set after {}
4397         foreach path $paths {
4398                 switch -glob -- [lindex $file_states($path) 0] {
4399                 U? {continue}
4400                 ?M -
4401                 ?D {
4402                         lappend pathList $path
4403                         if {$path eq $current_diff_path} {
4404                                 set after {reshow_diff;}
4405                         }
4406                 }
4407                 }
4408         }
4409
4410         set n [llength $pathList]
4411         if {$n == 0} {
4412                 unlock_index
4413                 return
4414         } elseif {$n == 1} {
4415                 set s "[short_path [lindex $pathList]]"
4416         } else {
4417                 set s "these $n files"
4418         }
4419
4420         set reply [tk_dialog \
4421                 .confirm_revert \
4422                 "[appname] ([reponame])" \
4423                 "Revert changes in $s?
4424
4425 Any unadded changes will be permanently lost by the revert." \
4426                 question \
4427                 1 \
4428                 {Do Nothing} \
4429                 {Revert Changes} \
4430                 ]
4431         if {$reply == 1} {
4432                 checkout_index \
4433                         $txt \
4434                         $pathList \
4435                         [concat $after {set ui_status_value {Ready.}}]
4436         } else {
4437                 unlock_index
4438         }
4439 }
4440
4441 proc do_revert_selection {} {
4442         global current_diff_path selected_paths
4443
4444         if {[array size selected_paths] > 0} {
4445                 revert_helper \
4446                         {Reverting selected files} \
4447                         [array names selected_paths]
4448         } elseif {$current_diff_path ne {}} {
4449                 revert_helper \
4450                         "Reverting [short_path $current_diff_path]" \
4451                         [list $current_diff_path]
4452         }
4453 }
4454
4455 proc do_signoff {} {
4456         global ui_comm
4457
4458         set me [committer_ident]
4459         if {$me eq {}} return
4460
4461         set sob "Signed-off-by: $me"
4462         set last [$ui_comm get {end -1c linestart} {end -1c}]
4463         if {$last ne $sob} {
4464                 $ui_comm edit separator
4465                 if {$last ne {}
4466                         && ![regexp {^[A-Z][A-Za-z]*-[A-Za-z-]+: *} $last]} {
4467                         $ui_comm insert end "\n"
4468                 }
4469                 $ui_comm insert end "\n$sob"
4470                 $ui_comm edit separator
4471                 $ui_comm see end
4472         }
4473 }
4474
4475 proc do_select_commit_type {} {
4476         global commit_type selected_commit_type
4477
4478         if {$selected_commit_type eq {new}
4479                 && [string match amend* $commit_type]} {
4480                 create_new_commit
4481         } elseif {$selected_commit_type eq {amend}
4482                 && ![string match amend* $commit_type]} {
4483                 load_last_commit
4484
4485                 # The amend request was rejected...
4486                 #
4487                 if {![string match amend* $commit_type]} {
4488                         set selected_commit_type new
4489                 }
4490         }
4491 }
4492
4493 proc do_commit {} {
4494         commit_tree
4495 }
4496
4497 proc do_about {} {
4498         global appvers copyright
4499         global tcl_patchLevel tk_patchLevel
4500
4501         set w .about_dialog
4502         toplevel $w
4503         wm geometry $w "+[winfo rootx .]+[winfo rooty .]"
4504
4505         label $w.header -text "About [appname]" \
4506                 -font font_uibold
4507         pack $w.header -side top -fill x
4508
4509         frame $w.buttons
4510         button $w.buttons.close -text {Close} \
4511                 -font font_ui \
4512                 -command [list destroy $w]
4513         pack $w.buttons.close -side right
4514         pack $w.buttons -side bottom -fill x -pady 10 -padx 10
4515
4516         label $w.desc \
4517                 -text "git-gui - a graphical user interface for Git.
4518 $copyright" \
4519                 -padx 5 -pady 5 \
4520                 -justify left \
4521                 -anchor w \
4522                 -borderwidth 1 \
4523                 -relief solid \
4524                 -font font_ui
4525         pack $w.desc -side top -fill x -padx 5 -pady 5
4526
4527         set v {}
4528         append v "git-gui version $appvers\n"
4529         append v "[git version]\n"
4530         append v "\n"
4531         if {$tcl_patchLevel eq $tk_patchLevel} {
4532                 append v "Tcl/Tk version $tcl_patchLevel"
4533         } else {
4534                 append v "Tcl version $tcl_patchLevel"
4535                 append v ", Tk version $tk_patchLevel"
4536         }
4537
4538         label $w.vers \
4539                 -text $v \
4540                 -padx 5 -pady 5 \
4541                 -justify left \
4542                 -anchor w \
4543                 -borderwidth 1 \
4544                 -relief solid \
4545                 -font font_ui
4546         pack $w.vers -side top -fill x -padx 5 -pady 5
4547
4548         menu $w.ctxm -tearoff 0
4549         $w.ctxm add command \
4550                 -label {Copy} \
4551                 -font font_ui \
4552                 -command "
4553                 clipboard clear
4554                 clipboard append -format STRING -type STRING -- \[$w.vers cget -text\]
4555         "
4556
4557         bind $w <Visibility> "grab $w; focus $w"
4558         bind $w <Key-Escape> "destroy $w"
4559         bind_button3 $w.vers "tk_popup $w.ctxm %X %Y; grab $w; focus $w"
4560         wm title $w "About [appname]"
4561         tkwait window $w
4562 }
4563
4564 proc do_options {} {
4565         global repo_config global_config font_descs
4566         global repo_config_new global_config_new
4567
4568         array unset repo_config_new
4569         array unset global_config_new
4570         foreach name [array names repo_config] {
4571                 set repo_config_new($name) $repo_config($name)
4572         }
4573         load_config 1
4574         foreach name [array names repo_config] {
4575                 switch -- $name {
4576                 gui.diffcontext {continue}
4577                 }
4578                 set repo_config_new($name) $repo_config($name)
4579         }
4580         foreach name [array names global_config] {
4581                 set global_config_new($name) $global_config($name)
4582         }
4583
4584         set w .options_editor
4585         toplevel $w
4586         wm geometry $w "+[winfo rootx .]+[winfo rooty .]"
4587
4588         label $w.header -text "Options" \
4589                 -font font_uibold
4590         pack $w.header -side top -fill x
4591
4592         frame $w.buttons
4593         button $w.buttons.restore -text {Restore Defaults} \
4594                 -font font_ui \
4595                 -command do_restore_defaults
4596         pack $w.buttons.restore -side left
4597         button $w.buttons.save -text Save \
4598                 -font font_ui \
4599                 -command [list do_save_config $w]
4600         pack $w.buttons.save -side right
4601         button $w.buttons.cancel -text {Cancel} \
4602                 -font font_ui \
4603                 -command [list destroy $w]
4604         pack $w.buttons.cancel -side right -padx 5
4605         pack $w.buttons -side bottom -fill x -pady 10 -padx 10
4606
4607         labelframe $w.repo -text "[reponame] Repository" \
4608                 -font font_ui
4609         labelframe $w.global -text {Global (All Repositories)} \
4610                 -font font_ui
4611         pack $w.repo -side left -fill both -expand 1 -pady 5 -padx 5
4612         pack $w.global -side right -fill both -expand 1 -pady 5 -padx 5
4613
4614         set optid 0
4615         foreach option {
4616                 {t user.name {User Name}}
4617                 {t user.email {Email Address}}
4618
4619                 {b merge.summary {Summarize Merge Commits}}
4620                 {i-1..5 merge.verbosity {Merge Verbosity}}
4621
4622                 {b gui.trustmtime  {Trust File Modification Timestamps}}
4623                 {i-1..99 gui.diffcontext {Number of Diff Context Lines}}
4624                 {t gui.newbranchtemplate {New Branch Name Template}}
4625                 } {
4626                 set type [lindex $option 0]
4627                 set name [lindex $option 1]
4628                 set text [lindex $option 2]
4629                 incr optid
4630                 foreach f {repo global} {
4631                         switch -glob -- $type {
4632                         b {
4633                                 checkbutton $w.$f.$optid -text $text \
4634                                         -variable ${f}_config_new($name) \
4635                                         -onvalue true \
4636                                         -offvalue false \
4637                                         -font font_ui
4638                                 pack $w.$f.$optid -side top -anchor w
4639                         }
4640                         i-* {
4641                                 regexp -- {-(\d+)\.\.(\d+)$} $type _junk min max
4642                                 frame $w.$f.$optid
4643                                 label $w.$f.$optid.l -text "$text:" -font font_ui
4644                                 pack $w.$f.$optid.l -side left -anchor w -fill x
4645                                 spinbox $w.$f.$optid.v \
4646                                         -textvariable ${f}_config_new($name) \
4647                                         -from $min \
4648                                         -to $max \
4649                                         -increment 1 \
4650                                         -width [expr {1 + [string length $max]}] \
4651                                         -font font_ui
4652                                 bind $w.$f.$optid.v <FocusIn> {%W selection range 0 end}
4653                                 pack $w.$f.$optid.v -side right -anchor e -padx 5
4654                                 pack $w.$f.$optid -side top -anchor w -fill x
4655                         }
4656                         t {
4657                                 frame $w.$f.$optid
4658                                 label $w.$f.$optid.l -text "$text:" -font font_ui
4659                                 entry $w.$f.$optid.v \
4660                                         -borderwidth 1 \
4661                                         -relief sunken \
4662                                         -width 20 \
4663                                         -textvariable ${f}_config_new($name) \
4664                                         -font font_ui
4665                                 pack $w.$f.$optid.l -side left -anchor w
4666                                 pack $w.$f.$optid.v -side left -anchor w \
4667                                         -fill x -expand 1 \
4668                                         -padx 5
4669                                 pack $w.$f.$optid -side top -anchor w -fill x
4670                         }
4671                         }
4672                 }
4673         }
4674
4675         set all_fonts [lsort [font families]]
4676         foreach option $font_descs {
4677                 set name [lindex $option 0]
4678                 set font [lindex $option 1]
4679                 set text [lindex $option 2]
4680
4681                 set global_config_new(gui.$font^^family) \
4682                         [font configure $font -family]
4683                 set global_config_new(gui.$font^^size) \
4684                         [font configure $font -size]
4685
4686                 frame $w.global.$name
4687                 label $w.global.$name.l -text "$text:" -font font_ui
4688                 pack $w.global.$name.l -side left -anchor w -fill x
4689                 eval tk_optionMenu $w.global.$name.family \
4690                         global_config_new(gui.$font^^family) \
4691                         $all_fonts
4692                 spinbox $w.global.$name.size \
4693                         -textvariable global_config_new(gui.$font^^size) \
4694                         -from 2 -to 80 -increment 1 \
4695                         -width 3 \
4696                         -font font_ui
4697                 bind $w.global.$name.size <FocusIn> {%W selection range 0 end}
4698                 pack $w.global.$name.size -side right -anchor e
4699                 pack $w.global.$name.family -side right -anchor e
4700                 pack $w.global.$name -side top -anchor w -fill x
4701         }
4702
4703         bind $w <Visibility> "grab $w; focus $w"
4704         bind $w <Key-Escape> "destroy $w"
4705         wm title $w "[appname] ([reponame]): Options"
4706         tkwait window $w
4707 }
4708
4709 proc do_restore_defaults {} {
4710         global font_descs default_config repo_config
4711         global repo_config_new global_config_new
4712
4713         foreach name [array names default_config] {
4714                 set repo_config_new($name) $default_config($name)
4715                 set global_config_new($name) $default_config($name)
4716         }
4717
4718         foreach option $font_descs {
4719                 set name [lindex $option 0]
4720                 set repo_config(gui.$name) $default_config(gui.$name)
4721         }
4722         apply_config
4723
4724         foreach option $font_descs {
4725                 set name [lindex $option 0]
4726                 set font [lindex $option 1]
4727                 set global_config_new(gui.$font^^family) \
4728                         [font configure $font -family]
4729                 set global_config_new(gui.$font^^size) \
4730                         [font configure $font -size]
4731         }
4732 }
4733
4734 proc do_save_config {w} {
4735         if {[catch {save_config} err]} {
4736                 error_popup "Failed to completely save options:\n\n$err"
4737         }
4738         reshow_diff
4739         destroy $w
4740 }
4741
4742 proc do_windows_shortcut {} {
4743         global argv0
4744
4745         set fn [tk_getSaveFile \
4746                 -parent . \
4747                 -title "[appname] ([reponame]): Create Desktop Icon" \
4748                 -initialfile "Git [reponame].bat"]
4749         if {$fn != {}} {
4750                 if {[catch {
4751                                 set fd [open $fn w]
4752                                 puts $fd "@ECHO Entering [reponame]"
4753                                 puts $fd "@ECHO Starting git-gui... please wait..."
4754                                 puts $fd "@SET PATH=[file normalize [gitexec]];%PATH%"
4755                                 puts $fd "@SET GIT_DIR=[file normalize [gitdir]]"
4756                                 puts -nonewline $fd "@\"[info nameofexecutable]\""
4757                                 puts $fd " \"[file normalize $argv0]\""
4758                                 close $fd
4759                         } err]} {
4760                         error_popup "Cannot write script:\n\n$err"
4761                 }
4762         }
4763 }
4764
4765 proc do_cygwin_shortcut {} {
4766         global argv0
4767
4768         if {[catch {
4769                 set desktop [exec cygpath \
4770                         --windows \
4771                         --absolute \
4772                         --long-name \
4773                         --desktop]
4774                 }]} {
4775                         set desktop .
4776         }
4777         set fn [tk_getSaveFile \
4778                 -parent . \
4779                 -title "[appname] ([reponame]): Create Desktop Icon" \
4780                 -initialdir $desktop \
4781                 -initialfile "Git [reponame].bat"]
4782         if {$fn != {}} {
4783                 if {[catch {
4784                                 set fd [open $fn w]
4785                                 set sh [exec cygpath \
4786                                         --windows \
4787                                         --absolute \
4788                                         /bin/sh]
4789                                 set me [exec cygpath \
4790                                         --unix \
4791                                         --absolute \
4792                                         $argv0]
4793                                 set gd [exec cygpath \
4794                                         --unix \
4795                                         --absolute \
4796                                         [gitdir]]
4797                                 set gw [exec cygpath \
4798                                         --windows \
4799                                         --absolute \
4800                                         [file dirname [gitdir]]]
4801                                 regsub -all ' $me "'\\''" me
4802                                 regsub -all ' $gd "'\\''" gd
4803                                 puts $fd "@ECHO Entering $gw"
4804                                 puts $fd "@ECHO Starting git-gui... please wait..."
4805                                 puts -nonewline $fd "@\"$sh\" --login -c \""
4806                                 puts -nonewline $fd "GIT_DIR='$gd'"
4807                                 puts -nonewline $fd " '$me'"
4808                                 puts $fd "&\""
4809                                 close $fd
4810                         } err]} {
4811                         error_popup "Cannot write script:\n\n$err"
4812                 }
4813         }
4814 }
4815
4816 proc do_macosx_app {} {
4817         global argv0 env
4818
4819         set fn [tk_getSaveFile \
4820                 -parent . \
4821                 -title "[appname] ([reponame]): Create Desktop Icon" \
4822                 -initialdir [file join $env(HOME) Desktop] \
4823                 -initialfile "Git [reponame].app"]
4824         if {$fn != {}} {
4825                 if {[catch {
4826                                 set Contents [file join $fn Contents]
4827                                 set MacOS [file join $Contents MacOS]
4828                                 set exe [file join $MacOS git-gui]
4829
4830                                 file mkdir $MacOS
4831
4832                                 set fd [open [file join $Contents Info.plist] w]
4833                                 puts $fd {<?xml version="1.0" encoding="UTF-8"?>
4834 <!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
4835 <plist version="1.0">
4836 <dict>
4837         <key>CFBundleDevelopmentRegion</key>
4838         <string>English</string>
4839         <key>CFBundleExecutable</key>
4840         <string>git-gui</string>
4841         <key>CFBundleIdentifier</key>
4842         <string>org.spearce.git-gui</string>
4843         <key>CFBundleInfoDictionaryVersion</key>
4844         <string>6.0</string>
4845         <key>CFBundlePackageType</key>
4846         <string>APPL</string>
4847         <key>CFBundleSignature</key>
4848         <string>????</string>
4849         <key>CFBundleVersion</key>
4850         <string>1.0</string>
4851         <key>NSPrincipalClass</key>
4852         <string>NSApplication</string>
4853 </dict>
4854 </plist>}
4855                                 close $fd
4856
4857                                 set fd [open $exe w]
4858                                 set gd [file normalize [gitdir]]
4859                                 set ep [file normalize [gitexec]]
4860                                 regsub -all ' $gd "'\\''" gd
4861                                 regsub -all ' $ep "'\\''" ep
4862                                 puts $fd "#!/bin/sh"
4863                                 foreach name [array names env] {
4864                                         if {[string match GIT_* $name]} {
4865                                                 regsub -all ' $env($name) "'\\''" v
4866                                                 puts $fd "export $name='$v'"
4867                                         }
4868                                 }
4869                                 puts $fd "export PATH='$ep':\$PATH"
4870                                 puts $fd "export GIT_DIR='$gd'"
4871                                 puts $fd "exec [file normalize $argv0]"
4872                                 close $fd
4873
4874                                 file attributes $exe -permissions u+x,g+x,o+x
4875                         } err]} {
4876                         error_popup "Cannot write icon:\n\n$err"
4877                 }
4878         }
4879 }
4880
4881 proc toggle_or_diff {w x y} {
4882         global file_states file_lists current_diff_path ui_index ui_workdir
4883         global last_clicked selected_paths
4884
4885         set pos [split [$w index @$x,$y] .]
4886         set lno [lindex $pos 0]
4887         set col [lindex $pos 1]
4888         set path [lindex $file_lists($w) [expr {$lno - 1}]]
4889         if {$path eq {}} {
4890                 set last_clicked {}
4891                 return
4892         }
4893
4894         set last_clicked [list $w $lno]
4895         array unset selected_paths
4896         $ui_index tag remove in_sel 0.0 end
4897         $ui_workdir tag remove in_sel 0.0 end
4898
4899         if {$col == 0} {
4900                 if {$current_diff_path eq $path} {
4901                         set after {reshow_diff;}
4902                 } else {
4903                         set after {}
4904                 }
4905                 if {$w eq $ui_index} {
4906                         update_indexinfo \
4907                                 "Unstaging [short_path $path] from commit" \
4908                                 [list $path] \
4909                                 [concat $after {set ui_status_value {Ready.}}]
4910                 } elseif {$w eq $ui_workdir} {
4911                         update_index \
4912                                 "Adding [short_path $path]" \
4913                                 [list $path] \
4914                                 [concat $after {set ui_status_value {Ready.}}]
4915                 }
4916         } else {
4917                 show_diff $path $w $lno
4918         }
4919 }
4920
4921 proc add_one_to_selection {w x y} {
4922         global file_lists last_clicked selected_paths
4923
4924         set lno [lindex [split [$w index @$x,$y] .] 0]
4925         set path [lindex $file_lists($w) [expr {$lno - 1}]]
4926         if {$path eq {}} {
4927                 set last_clicked {}
4928                 return
4929         }
4930
4931         if {$last_clicked ne {}
4932                 && [lindex $last_clicked 0] ne $w} {
4933                 array unset selected_paths
4934                 [lindex $last_clicked 0] tag remove in_sel 0.0 end
4935         }
4936
4937         set last_clicked [list $w $lno]
4938         if {[catch {set in_sel $selected_paths($path)}]} {
4939                 set in_sel 0
4940         }
4941         if {$in_sel} {
4942                 unset selected_paths($path)
4943                 $w tag remove in_sel $lno.0 [expr {$lno + 1}].0
4944         } else {
4945                 set selected_paths($path) 1
4946                 $w tag add in_sel $lno.0 [expr {$lno + 1}].0
4947         }
4948 }
4949
4950 proc add_range_to_selection {w x y} {
4951         global file_lists last_clicked selected_paths
4952
4953         if {[lindex $last_clicked 0] ne $w} {
4954                 toggle_or_diff $w $x $y
4955                 return
4956         }
4957
4958         set lno [lindex [split [$w index @$x,$y] .] 0]
4959         set lc [lindex $last_clicked 1]
4960         if {$lc < $lno} {
4961                 set begin $lc
4962                 set end $lno
4963         } else {
4964                 set begin $lno
4965                 set end $lc
4966         }
4967
4968         foreach path [lrange $file_lists($w) \
4969                 [expr {$begin - 1}] \
4970                 [expr {$end - 1}]] {
4971                 set selected_paths($path) 1
4972         }
4973         $w tag add in_sel $begin.0 [expr {$end + 1}].0
4974 }
4975
4976 ######################################################################
4977 ##
4978 ## config defaults
4979
4980 set cursor_ptr arrow
4981 font create font_diff -family Courier -size 10
4982 font create font_ui
4983 catch {
4984         label .dummy
4985         eval font configure font_ui [font actual [.dummy cget -font]]
4986         destroy .dummy
4987 }
4988
4989 font create font_uibold
4990 font create font_diffbold
4991
4992 if {[is_Windows]} {
4993         set M1B Control
4994         set M1T Ctrl
4995 } elseif {[is_MacOSX]} {
4996         set M1B M1
4997         set M1T Cmd
4998 } else {
4999         set M1B M1
5000         set M1T M1
5001 }
5002
5003 proc apply_config {} {
5004         global repo_config font_descs
5005
5006         foreach option $font_descs {
5007                 set name [lindex $option 0]
5008                 set font [lindex $option 1]
5009                 if {[catch {
5010                         foreach {cn cv} $repo_config(gui.$name) {
5011                                 font configure $font $cn $cv
5012                         }
5013                         } err]} {
5014                         error_popup "Invalid font specified in gui.$name:\n\n$err"
5015                 }
5016                 foreach {cn cv} [font configure $font] {
5017                         font configure ${font}bold $cn $cv
5018                 }
5019                 font configure ${font}bold -weight bold
5020         }
5021 }
5022
5023 set default_config(merge.summary) false
5024 set default_config(merge.verbosity) 2
5025 set default_config(user.name) {}
5026 set default_config(user.email) {}
5027
5028 set default_config(gui.trustmtime) false
5029 set default_config(gui.diffcontext) 5
5030 set default_config(gui.newbranchtemplate) {}
5031 set default_config(gui.fontui) [font configure font_ui]
5032 set default_config(gui.fontdiff) [font configure font_diff]
5033 set font_descs {
5034         {fontui   font_ui   {Main Font}}
5035         {fontdiff font_diff {Diff/Console Font}}
5036 }
5037 load_config 0
5038 apply_config
5039
5040 ######################################################################
5041 ##
5042 ## feature option selection
5043
5044 if {[regexp {^git-(.+)$} [appname] _junk subcommand]} {
5045         unset _junk
5046 } else {
5047         set subcommand gui
5048 }
5049 if {$subcommand eq {gui.sh}} {
5050         set subcommand gui
5051 }
5052 if {$subcommand eq {gui} && [llength $argv] > 0} {
5053         set subcommand [lindex $argv 0]
5054         set argv [lrange $argv 1 end]
5055 }
5056
5057 enable_option multicommit
5058 enable_option branch
5059 enable_option transport
5060
5061 switch -- $subcommand {
5062 browser -
5063 blame {
5064         disable_option multicommit
5065         disable_option branch
5066         disable_option transport
5067 }
5068 citool {
5069         enable_option singlecommit
5070
5071         disable_option multicommit
5072         disable_option branch
5073         disable_option transport
5074 }
5075 }
5076
5077 ######################################################################
5078 ##
5079 ## ui construction
5080
5081 set ui_comm {}
5082
5083 # -- Menu Bar
5084 #
5085 menu .mbar -tearoff 0
5086 .mbar add cascade -label Repository -menu .mbar.repository
5087 .mbar add cascade -label Edit -menu .mbar.edit
5088 if {[is_enabled branch]} {
5089         .mbar add cascade -label Branch -menu .mbar.branch
5090 }
5091 if {[is_enabled multicommit] || [is_enabled singlecommit]} {
5092         .mbar add cascade -label Commit -menu .mbar.commit
5093 }
5094 if {[is_enabled transport]} {
5095         .mbar add cascade -label Merge -menu .mbar.merge
5096         .mbar add cascade -label Fetch -menu .mbar.fetch
5097         .mbar add cascade -label Push -menu .mbar.push
5098 }
5099 . configure -menu .mbar
5100
5101 # -- Repository Menu
5102 #
5103 menu .mbar.repository
5104
5105 .mbar.repository add command \
5106         -label {Browse Current Branch} \
5107         -command {new_browser $current_branch} \
5108         -font font_ui
5109 trace add variable current_branch write ".mbar.repository entryconf [.mbar.repository index last] -label \"Browse \$current_branch\" ;#"
5110 .mbar.repository add separator
5111
5112 .mbar.repository add command \
5113         -label {Visualize Current Branch} \
5114         -command {do_gitk $current_branch} \
5115         -font font_ui
5116 trace add variable current_branch write ".mbar.repository entryconf [.mbar.repository index last] -label \"Visualize \$current_branch\" ;#"
5117 .mbar.repository add command \
5118         -label {Visualize All Branches} \
5119         -command {do_gitk --all} \
5120         -font font_ui
5121 .mbar.repository add separator
5122
5123 if {[is_enabled multicommit]} {
5124         .mbar.repository add command -label {Database Statistics} \
5125                 -command do_stats \
5126                 -font font_ui
5127
5128         .mbar.repository add command -label {Compress Database} \
5129                 -command do_gc \
5130                 -font font_ui
5131
5132         .mbar.repository add command -label {Verify Database} \
5133                 -command do_fsck_objects \
5134                 -font font_ui
5135
5136         .mbar.repository add separator
5137
5138         if {[is_Cygwin]} {
5139                 .mbar.repository add command \
5140                         -label {Create Desktop Icon} \
5141                         -command do_cygwin_shortcut \
5142                         -font font_ui
5143         } elseif {[is_Windows]} {
5144                 .mbar.repository add command \
5145                         -label {Create Desktop Icon} \
5146                         -command do_windows_shortcut \
5147                         -font font_ui
5148         } elseif {[is_MacOSX]} {
5149                 .mbar.repository add command \
5150                         -label {Create Desktop Icon} \
5151                         -command do_macosx_app \
5152                         -font font_ui
5153         }
5154 }
5155
5156 .mbar.repository add command -label Quit \
5157         -command do_quit \
5158         -accelerator $M1T-Q \
5159         -font font_ui
5160
5161 # -- Edit Menu
5162 #
5163 menu .mbar.edit
5164 .mbar.edit add command -label Undo \
5165         -command {catch {[focus] edit undo}} \
5166         -accelerator $M1T-Z \
5167         -font font_ui
5168 .mbar.edit add command -label Redo \
5169         -command {catch {[focus] edit redo}} \
5170         -accelerator $M1T-Y \
5171         -font font_ui
5172 .mbar.edit add separator
5173 .mbar.edit add command -label Cut \
5174         -command {catch {tk_textCut [focus]}} \
5175         -accelerator $M1T-X \
5176         -font font_ui
5177 .mbar.edit add command -label Copy \
5178         -command {catch {tk_textCopy [focus]}} \
5179         -accelerator $M1T-C \
5180         -font font_ui
5181 .mbar.edit add command -label Paste \
5182         -command {catch {tk_textPaste [focus]; [focus] see insert}} \
5183         -accelerator $M1T-V \
5184         -font font_ui
5185 .mbar.edit add command -label Delete \
5186         -command {catch {[focus] delete sel.first sel.last}} \
5187         -accelerator Del \
5188         -font font_ui
5189 .mbar.edit add separator
5190 .mbar.edit add command -label {Select All} \
5191         -command {catch {[focus] tag add sel 0.0 end}} \
5192         -accelerator $M1T-A \
5193         -font font_ui
5194
5195 # -- Branch Menu
5196 #
5197 if {[is_enabled branch]} {
5198         menu .mbar.branch
5199
5200         .mbar.branch add command -label {Create...} \
5201                 -command do_create_branch \
5202                 -accelerator $M1T-N \
5203                 -font font_ui
5204         lappend disable_on_lock [list .mbar.branch entryconf \
5205                 [.mbar.branch index last] -state]
5206
5207         .mbar.branch add command -label {Delete...} \
5208                 -command do_delete_branch \
5209                 -font font_ui
5210         lappend disable_on_lock [list .mbar.branch entryconf \
5211                 [.mbar.branch index last] -state]
5212
5213         .mbar.branch add command -label {Reset...} \
5214                 -command do_reset_hard \
5215                 -font font_ui
5216         lappend disable_on_lock [list .mbar.branch entryconf \
5217                 [.mbar.branch index last] -state]
5218 }
5219
5220 # -- Commit Menu
5221 #
5222 if {[is_enabled multicommit] || [is_enabled singlecommit]} {
5223         menu .mbar.commit
5224
5225         .mbar.commit add radiobutton \
5226                 -label {New Commit} \
5227                 -command do_select_commit_type \
5228                 -variable selected_commit_type \
5229                 -value new \
5230                 -font font_ui
5231         lappend disable_on_lock \
5232                 [list .mbar.commit entryconf [.mbar.commit index last] -state]
5233
5234         .mbar.commit add radiobutton \
5235                 -label {Amend Last Commit} \
5236                 -command do_select_commit_type \
5237                 -variable selected_commit_type \
5238                 -value amend \
5239                 -font font_ui
5240         lappend disable_on_lock \
5241                 [list .mbar.commit entryconf [.mbar.commit index last] -state]
5242
5243         .mbar.commit add separator
5244
5245         .mbar.commit add command -label Rescan \
5246                 -command do_rescan \
5247                 -accelerator F5 \
5248                 -font font_ui
5249         lappend disable_on_lock \
5250                 [list .mbar.commit entryconf [.mbar.commit index last] -state]
5251
5252         .mbar.commit add command -label {Add To Commit} \
5253                 -command do_add_selection \
5254                 -font font_ui
5255         lappend disable_on_lock \
5256                 [list .mbar.commit entryconf [.mbar.commit index last] -state]
5257
5258         .mbar.commit add command -label {Add Existing To Commit} \
5259                 -command do_add_all \
5260                 -accelerator $M1T-I \
5261                 -font font_ui
5262         lappend disable_on_lock \
5263                 [list .mbar.commit entryconf [.mbar.commit index last] -state]
5264
5265         .mbar.commit add command -label {Unstage From Commit} \
5266                 -command do_unstage_selection \
5267                 -font font_ui
5268         lappend disable_on_lock \
5269                 [list .mbar.commit entryconf [.mbar.commit index last] -state]
5270
5271         .mbar.commit add command -label {Revert Changes} \
5272                 -command do_revert_selection \
5273                 -font font_ui
5274         lappend disable_on_lock \
5275                 [list .mbar.commit entryconf [.mbar.commit index last] -state]
5276
5277         .mbar.commit add separator
5278
5279         .mbar.commit add command -label {Sign Off} \
5280                 -command do_signoff \
5281                 -accelerator $M1T-S \
5282                 -font font_ui
5283
5284         .mbar.commit add command -label Commit \
5285                 -command do_commit \
5286                 -accelerator $M1T-Return \
5287                 -font font_ui
5288         lappend disable_on_lock \
5289                 [list .mbar.commit entryconf [.mbar.commit index last] -state]
5290 }
5291
5292 # -- Merge Menu
5293 #
5294 if {[is_enabled branch]} {
5295         menu .mbar.merge
5296         .mbar.merge add command -label {Local Merge...} \
5297                 -command do_local_merge \
5298                 -font font_ui
5299         lappend disable_on_lock \
5300                 [list .mbar.merge entryconf [.mbar.merge index last] -state]
5301         .mbar.merge add command -label {Abort Merge...} \
5302                 -command do_reset_hard \
5303                 -font font_ui
5304         lappend disable_on_lock \
5305                 [list .mbar.merge entryconf [.mbar.merge index last] -state]
5306
5307 }
5308
5309 # -- Transport Menu
5310 #
5311 if {[is_enabled transport]} {
5312         menu .mbar.fetch
5313
5314         menu .mbar.push
5315         .mbar.push add command -label {Push...} \
5316                 -command do_push_anywhere \
5317                 -font font_ui
5318 }
5319
5320 if {[is_MacOSX]} {
5321         # -- Apple Menu (Mac OS X only)
5322         #
5323         .mbar add cascade -label Apple -menu .mbar.apple
5324         menu .mbar.apple
5325
5326         .mbar.apple add command -label "About [appname]" \
5327                 -command do_about \
5328                 -font font_ui
5329         .mbar.apple add command -label "Options..." \
5330                 -command do_options \
5331                 -font font_ui
5332 } else {
5333         # -- Edit Menu
5334         #
5335         .mbar.edit add separator
5336         .mbar.edit add command -label {Options...} \
5337                 -command do_options \
5338                 -font font_ui
5339
5340         # -- Tools Menu
5341         #
5342         if {[file exists /usr/local/miga/lib/gui-miga]
5343                 && [file exists .pvcsrc]} {
5344         proc do_miga {} {
5345                 global ui_status_value
5346                 if {![lock_index update]} return
5347                 set cmd [list sh --login -c "/usr/local/miga/lib/gui-miga \"[pwd]\""]
5348                 set miga_fd [open "|$cmd" r]
5349                 fconfigure $miga_fd -blocking 0
5350                 fileevent $miga_fd readable [list miga_done $miga_fd]
5351                 set ui_status_value {Running miga...}
5352         }
5353         proc miga_done {fd} {
5354                 read $fd 512
5355                 if {[eof $fd]} {
5356                         close $fd
5357                         unlock_index
5358                         rescan [list set ui_status_value {Ready.}]
5359                 }
5360         }
5361         .mbar add cascade -label Tools -menu .mbar.tools
5362         menu .mbar.tools
5363         .mbar.tools add command -label "Migrate" \
5364                 -command do_miga \
5365                 -font font_ui
5366         lappend disable_on_lock \
5367                 [list .mbar.tools entryconf [.mbar.tools index last] -state]
5368         }
5369 }
5370
5371 # -- Help Menu
5372 #
5373 .mbar add cascade -label Help -menu .mbar.help
5374 menu .mbar.help
5375
5376 if {![is_MacOSX]} {
5377         .mbar.help add command -label "About [appname]" \
5378                 -command do_about \
5379                 -font font_ui
5380 }
5381
5382 set browser {}
5383 catch {set browser $repo_config(instaweb.browser)}
5384 set doc_path [file dirname [gitexec]]
5385 set doc_path [file join $doc_path Documentation index.html]
5386
5387 if {[is_Cygwin]} {
5388         set doc_path [exec cygpath --mixed $doc_path]
5389 }
5390
5391 if {$browser eq {}} {
5392         if {[is_MacOSX]} {
5393                 set browser open
5394         } elseif {[is_Cygwin]} {
5395                 set program_files [file dirname [exec cygpath --windir]]
5396                 set program_files [file join $program_files {Program Files}]
5397                 set firefox [file join $program_files {Mozilla Firefox} firefox.exe]
5398                 set ie [file join $program_files {Internet Explorer} IEXPLORE.EXE]
5399                 if {[file exists $firefox]} {
5400                         set browser $firefox
5401                 } elseif {[file exists $ie]} {
5402                         set browser $ie
5403                 }
5404                 unset program_files firefox ie
5405         }
5406 }
5407
5408 if {[file isfile $doc_path]} {
5409         set doc_url "file:$doc_path"
5410 } else {
5411         set doc_url {http://www.kernel.org/pub/software/scm/git/docs/}
5412 }
5413
5414 if {$browser ne {}} {
5415         .mbar.help add command -label {Online Documentation} \
5416                 -command [list exec $browser $doc_url &] \
5417                 -font font_ui
5418 }
5419 unset browser doc_path doc_url
5420
5421 # -- Standard bindings
5422 #
5423 bind .   <Destroy> do_quit
5424 bind all <$M1B-Key-q> do_quit
5425 bind all <$M1B-Key-Q> do_quit
5426 bind all <$M1B-Key-w> {destroy [winfo toplevel %W]}
5427 bind all <$M1B-Key-W> {destroy [winfo toplevel %W]}
5428
5429 # -- Not a normal commit type invocation?  Do that instead!
5430 #
5431 switch -- $subcommand {
5432 browser {
5433         if {[llength $argv] != 1} {
5434                 puts stderr "usage: $argv0 browser commit"
5435                 exit 1
5436         }
5437         set current_branch [lindex $argv 0]
5438         new_browser $current_branch
5439         return
5440 }
5441 blame {
5442         if {[llength $argv] != 2} {
5443                 puts stderr "usage: $argv0 blame commit path"
5444                 exit 1
5445         }
5446         set current_branch [lindex $argv 0]
5447         show_blame $current_branch [lindex $argv 1]
5448         return
5449 }
5450 citool -
5451 gui {
5452         if {[llength $argv] != 0} {
5453                 puts -nonewline stderr "usage: $argv0"
5454                 if {$subcommand ne {gui} && [appname] ne "git-$subcommand"} {
5455                         puts -nonewline stderr " $subcommand"
5456                 }
5457                 puts stderr {}
5458                 exit 1
5459         }
5460         # fall through to setup UI for commits
5461 }
5462 default {
5463         puts stderr "usage: $argv0 \[{blame|browser|citool}\]"
5464         exit 1
5465 }
5466 }
5467
5468 # -- Branch Control
5469 #
5470 frame .branch \
5471         -borderwidth 1 \
5472         -relief sunken
5473 label .branch.l1 \
5474         -text {Current Branch:} \
5475         -anchor w \
5476         -justify left \
5477         -font font_ui
5478 label .branch.cb \
5479         -textvariable current_branch \
5480         -anchor w \
5481         -justify left \
5482         -font font_ui
5483 pack .branch.l1 -side left
5484 pack .branch.cb -side left -fill x
5485 pack .branch -side top -fill x
5486
5487 # -- Main Window Layout
5488 #
5489 panedwindow .vpane -orient vertical
5490 panedwindow .vpane.files -orient horizontal
5491 .vpane add .vpane.files -sticky nsew -height 100 -width 200
5492 pack .vpane -anchor n -side top -fill both -expand 1
5493
5494 # -- Index File List
5495 #
5496 frame .vpane.files.index -height 100 -width 200
5497 label .vpane.files.index.title -text {Changes To Be Committed} \
5498         -background green \
5499         -font font_ui
5500 text $ui_index -background white -borderwidth 0 \
5501         -width 20 -height 10 \
5502         -wrap none \
5503         -font font_ui \
5504         -cursor $cursor_ptr \
5505         -xscrollcommand {.vpane.files.index.sx set} \
5506         -yscrollcommand {.vpane.files.index.sy set} \
5507         -state disabled
5508 scrollbar .vpane.files.index.sx -orient h -command [list $ui_index xview]
5509 scrollbar .vpane.files.index.sy -orient v -command [list $ui_index yview]
5510 pack .vpane.files.index.title -side top -fill x
5511 pack .vpane.files.index.sx -side bottom -fill x
5512 pack .vpane.files.index.sy -side right -fill y
5513 pack $ui_index -side left -fill both -expand 1
5514 .vpane.files add .vpane.files.index -sticky nsew
5515
5516 # -- Working Directory File List
5517 #
5518 frame .vpane.files.workdir -height 100 -width 200
5519 label .vpane.files.workdir.title -text {Changed But Not Updated} \
5520         -background red \
5521         -font font_ui
5522 text $ui_workdir -background white -borderwidth 0 \
5523         -width 20 -height 10 \
5524         -wrap none \
5525         -font font_ui \
5526         -cursor $cursor_ptr \
5527         -xscrollcommand {.vpane.files.workdir.sx set} \
5528         -yscrollcommand {.vpane.files.workdir.sy set} \
5529         -state disabled
5530 scrollbar .vpane.files.workdir.sx -orient h -command [list $ui_workdir xview]
5531 scrollbar .vpane.files.workdir.sy -orient v -command [list $ui_workdir yview]
5532 pack .vpane.files.workdir.title -side top -fill x
5533 pack .vpane.files.workdir.sx -side bottom -fill x
5534 pack .vpane.files.workdir.sy -side right -fill y
5535 pack $ui_workdir -side left -fill both -expand 1
5536 .vpane.files add .vpane.files.workdir -sticky nsew
5537
5538 foreach i [list $ui_index $ui_workdir] {
5539         $i tag conf in_diff -font font_uibold
5540         $i tag conf in_sel \
5541                 -background [$i cget -foreground] \
5542                 -foreground [$i cget -background]
5543 }
5544 unset i
5545
5546 # -- Diff and Commit Area
5547 #
5548 frame .vpane.lower -height 300 -width 400
5549 frame .vpane.lower.commarea
5550 frame .vpane.lower.diff -relief sunken -borderwidth 1
5551 pack .vpane.lower.commarea -side top -fill x
5552 pack .vpane.lower.diff -side bottom -fill both -expand 1
5553 .vpane add .vpane.lower -sticky nsew
5554
5555 # -- Commit Area Buttons
5556 #
5557 frame .vpane.lower.commarea.buttons
5558 label .vpane.lower.commarea.buttons.l -text {} \
5559         -anchor w \
5560         -justify left \
5561         -font font_ui
5562 pack .vpane.lower.commarea.buttons.l -side top -fill x
5563 pack .vpane.lower.commarea.buttons -side left -fill y
5564
5565 button .vpane.lower.commarea.buttons.rescan -text {Rescan} \
5566         -command do_rescan \
5567         -font font_ui
5568 pack .vpane.lower.commarea.buttons.rescan -side top -fill x
5569 lappend disable_on_lock \
5570         {.vpane.lower.commarea.buttons.rescan conf -state}
5571
5572 button .vpane.lower.commarea.buttons.incall -text {Add Existing} \
5573         -command do_add_all \
5574         -font font_ui
5575 pack .vpane.lower.commarea.buttons.incall -side top -fill x
5576 lappend disable_on_lock \
5577         {.vpane.lower.commarea.buttons.incall conf -state}
5578
5579 button .vpane.lower.commarea.buttons.signoff -text {Sign Off} \
5580         -command do_signoff \
5581         -font font_ui
5582 pack .vpane.lower.commarea.buttons.signoff -side top -fill x
5583
5584 button .vpane.lower.commarea.buttons.commit -text {Commit} \
5585         -command do_commit \
5586         -font font_ui
5587 pack .vpane.lower.commarea.buttons.commit -side top -fill x
5588 lappend disable_on_lock \
5589         {.vpane.lower.commarea.buttons.commit conf -state}
5590
5591 # -- Commit Message Buffer
5592 #
5593 frame .vpane.lower.commarea.buffer
5594 frame .vpane.lower.commarea.buffer.header
5595 set ui_comm .vpane.lower.commarea.buffer.t
5596 set ui_coml .vpane.lower.commarea.buffer.header.l
5597 radiobutton .vpane.lower.commarea.buffer.header.new \
5598         -text {New Commit} \
5599         -command do_select_commit_type \
5600         -variable selected_commit_type \
5601         -value new \
5602         -font font_ui
5603 lappend disable_on_lock \
5604         [list .vpane.lower.commarea.buffer.header.new conf -state]
5605 radiobutton .vpane.lower.commarea.buffer.header.amend \
5606         -text {Amend Last Commit} \
5607         -command do_select_commit_type \
5608         -variable selected_commit_type \
5609         -value amend \
5610         -font font_ui
5611 lappend disable_on_lock \
5612         [list .vpane.lower.commarea.buffer.header.amend conf -state]
5613 label $ui_coml \
5614         -anchor w \
5615         -justify left \
5616         -font font_ui
5617 proc trace_commit_type {varname args} {
5618         global ui_coml commit_type
5619         switch -glob -- $commit_type {
5620         initial       {set txt {Initial Commit Message:}}
5621         amend         {set txt {Amended Commit Message:}}
5622         amend-initial {set txt {Amended Initial Commit Message:}}
5623         amend-merge   {set txt {Amended Merge Commit Message:}}
5624         merge         {set txt {Merge Commit Message:}}
5625         *             {set txt {Commit Message:}}
5626         }
5627         $ui_coml conf -text $txt
5628 }
5629 trace add variable commit_type write trace_commit_type
5630 pack $ui_coml -side left -fill x
5631 pack .vpane.lower.commarea.buffer.header.amend -side right
5632 pack .vpane.lower.commarea.buffer.header.new -side right
5633
5634 text $ui_comm -background white -borderwidth 1 \
5635         -undo true \
5636         -maxundo 20 \
5637         -autoseparators true \
5638         -relief sunken \
5639         -width 75 -height 9 -wrap none \
5640         -font font_diff \
5641         -yscrollcommand {.vpane.lower.commarea.buffer.sby set}
5642 scrollbar .vpane.lower.commarea.buffer.sby \
5643         -command [list $ui_comm yview]
5644 pack .vpane.lower.commarea.buffer.header -side top -fill x
5645 pack .vpane.lower.commarea.buffer.sby -side right -fill y
5646 pack $ui_comm -side left -fill y
5647 pack .vpane.lower.commarea.buffer -side left -fill y
5648
5649 # -- Commit Message Buffer Context Menu
5650 #
5651 set ctxm .vpane.lower.commarea.buffer.ctxm
5652 menu $ctxm -tearoff 0
5653 $ctxm add command \
5654         -label {Cut} \
5655         -font font_ui \
5656         -command {tk_textCut $ui_comm}
5657 $ctxm add command \
5658         -label {Copy} \
5659         -font font_ui \
5660         -command {tk_textCopy $ui_comm}
5661 $ctxm add command \
5662         -label {Paste} \
5663         -font font_ui \
5664         -command {tk_textPaste $ui_comm}
5665 $ctxm add command \
5666         -label {Delete} \
5667         -font font_ui \
5668         -command {$ui_comm delete sel.first sel.last}
5669 $ctxm add separator
5670 $ctxm add command \
5671         -label {Select All} \
5672         -font font_ui \
5673         -command {focus $ui_comm;$ui_comm tag add sel 0.0 end}
5674 $ctxm add command \
5675         -label {Copy All} \
5676         -font font_ui \
5677         -command {
5678                 $ui_comm tag add sel 0.0 end
5679                 tk_textCopy $ui_comm
5680                 $ui_comm tag remove sel 0.0 end
5681         }
5682 $ctxm add separator
5683 $ctxm add command \
5684         -label {Sign Off} \
5685         -font font_ui \
5686         -command do_signoff
5687 bind_button3 $ui_comm "tk_popup $ctxm %X %Y"
5688
5689 # -- Diff Header
5690 #
5691 proc trace_current_diff_path {varname args} {
5692         global current_diff_path diff_actions file_states
5693         if {$current_diff_path eq {}} {
5694                 set s {}
5695                 set f {}
5696                 set p {}
5697                 set o disabled
5698         } else {
5699                 set p $current_diff_path
5700                 set s [mapdesc [lindex $file_states($p) 0] $p]
5701                 set f {File:}
5702                 set p [escape_path $p]
5703                 set o normal
5704         }
5705
5706         .vpane.lower.diff.header.status configure -text $s
5707         .vpane.lower.diff.header.file configure -text $f
5708         .vpane.lower.diff.header.path configure -text $p
5709         foreach w $diff_actions {
5710                 uplevel #0 $w $o
5711         }
5712 }
5713 trace add variable current_diff_path write trace_current_diff_path
5714
5715 frame .vpane.lower.diff.header -background orange
5716 label .vpane.lower.diff.header.status \
5717         -background orange \
5718         -width $max_status_desc \
5719         -anchor w \
5720         -justify left \
5721         -font font_ui
5722 label .vpane.lower.diff.header.file \
5723         -background orange \
5724         -anchor w \
5725         -justify left \
5726         -font font_ui
5727 label .vpane.lower.diff.header.path \
5728         -background orange \
5729         -anchor w \
5730         -justify left \
5731         -font font_ui
5732 pack .vpane.lower.diff.header.status -side left
5733 pack .vpane.lower.diff.header.file -side left
5734 pack .vpane.lower.diff.header.path -fill x
5735 set ctxm .vpane.lower.diff.header.ctxm
5736 menu $ctxm -tearoff 0
5737 $ctxm add command \
5738         -label {Copy} \
5739         -font font_ui \
5740         -command {
5741                 clipboard clear
5742                 clipboard append \
5743                         -format STRING \
5744                         -type STRING \
5745                         -- $current_diff_path
5746         }
5747 lappend diff_actions [list $ctxm entryconf [$ctxm index last] -state]
5748 bind_button3 .vpane.lower.diff.header.path "tk_popup $ctxm %X %Y"
5749
5750 # -- Diff Body
5751 #
5752 frame .vpane.lower.diff.body
5753 set ui_diff .vpane.lower.diff.body.t
5754 text $ui_diff -background white -borderwidth 0 \
5755         -width 80 -height 15 -wrap none \
5756         -font font_diff \
5757         -xscrollcommand {.vpane.lower.diff.body.sbx set} \
5758         -yscrollcommand {.vpane.lower.diff.body.sby set} \
5759         -state disabled
5760 scrollbar .vpane.lower.diff.body.sbx -orient horizontal \
5761         -command [list $ui_diff xview]
5762 scrollbar .vpane.lower.diff.body.sby -orient vertical \
5763         -command [list $ui_diff yview]
5764 pack .vpane.lower.diff.body.sbx -side bottom -fill x
5765 pack .vpane.lower.diff.body.sby -side right -fill y
5766 pack $ui_diff -side left -fill both -expand 1
5767 pack .vpane.lower.diff.header -side top -fill x
5768 pack .vpane.lower.diff.body -side bottom -fill both -expand 1
5769
5770 $ui_diff tag conf d_cr -elide true
5771 $ui_diff tag conf d_@ -foreground blue -font font_diffbold
5772 $ui_diff tag conf d_+ -foreground {#00a000}
5773 $ui_diff tag conf d_- -foreground red
5774
5775 $ui_diff tag conf d_++ -foreground {#00a000}
5776 $ui_diff tag conf d_-- -foreground red
5777 $ui_diff tag conf d_+s \
5778         -foreground {#00a000} \
5779         -background {#e2effa}
5780 $ui_diff tag conf d_-s \
5781         -foreground red \
5782         -background {#e2effa}
5783 $ui_diff tag conf d_s+ \
5784         -foreground {#00a000} \
5785         -background ivory1
5786 $ui_diff tag conf d_s- \
5787         -foreground red \
5788         -background ivory1
5789
5790 $ui_diff tag conf d<<<<<<< \
5791         -foreground orange \
5792         -font font_diffbold
5793 $ui_diff tag conf d======= \
5794         -foreground orange \
5795         -font font_diffbold
5796 $ui_diff tag conf d>>>>>>> \
5797         -foreground orange \
5798         -font font_diffbold
5799
5800 $ui_diff tag raise sel
5801
5802 # -- Diff Body Context Menu
5803 #
5804 set ctxm .vpane.lower.diff.body.ctxm
5805 menu $ctxm -tearoff 0
5806 $ctxm add command \
5807         -label {Refresh} \
5808         -font font_ui \
5809         -command reshow_diff
5810 lappend diff_actions [list $ctxm entryconf [$ctxm index last] -state]
5811 $ctxm add command \
5812         -label {Copy} \
5813         -font font_ui \
5814         -command {tk_textCopy $ui_diff}
5815 lappend diff_actions [list $ctxm entryconf [$ctxm index last] -state]
5816 $ctxm add command \
5817         -label {Select All} \
5818         -font font_ui \
5819         -command {focus $ui_diff;$ui_diff tag add sel 0.0 end}
5820 lappend diff_actions [list $ctxm entryconf [$ctxm index last] -state]
5821 $ctxm add command \
5822         -label {Copy All} \
5823         -font font_ui \
5824         -command {
5825                 $ui_diff tag add sel 0.0 end
5826                 tk_textCopy $ui_diff
5827                 $ui_diff tag remove sel 0.0 end
5828         }
5829 lappend diff_actions [list $ctxm entryconf [$ctxm index last] -state]
5830 $ctxm add separator
5831 $ctxm add command \
5832         -label {Apply/Reverse Hunk} \
5833         -font font_ui \
5834         -command {apply_hunk $cursorX $cursorY}
5835 set ui_diff_applyhunk [$ctxm index last]
5836 lappend diff_actions [list $ctxm entryconf $ui_diff_applyhunk -state]
5837 $ctxm add separator
5838 $ctxm add command \
5839         -label {Decrease Font Size} \
5840         -font font_ui \
5841         -command {incr_font_size font_diff -1}
5842 lappend diff_actions [list $ctxm entryconf [$ctxm index last] -state]
5843 $ctxm add command \
5844         -label {Increase Font Size} \
5845         -font font_ui \
5846         -command {incr_font_size font_diff 1}
5847 lappend diff_actions [list $ctxm entryconf [$ctxm index last] -state]
5848 $ctxm add separator
5849 $ctxm add command \
5850         -label {Show Less Context} \
5851         -font font_ui \
5852         -command {if {$repo_config(gui.diffcontext) >= 2} {
5853                 incr repo_config(gui.diffcontext) -1
5854                 reshow_diff
5855         }}
5856 lappend diff_actions [list $ctxm entryconf [$ctxm index last] -state]
5857 $ctxm add command \
5858         -label {Show More Context} \
5859         -font font_ui \
5860         -command {
5861                 incr repo_config(gui.diffcontext)
5862                 reshow_diff
5863         }
5864 lappend diff_actions [list $ctxm entryconf [$ctxm index last] -state]
5865 $ctxm add separator
5866 $ctxm add command -label {Options...} \
5867         -font font_ui \
5868         -command do_options
5869 bind_button3 $ui_diff "
5870         set cursorX %x
5871         set cursorY %y
5872         if {\$ui_index eq \$current_diff_side} {
5873                 $ctxm entryconf $ui_diff_applyhunk -label {Unstage Hunk From Commit}
5874         } else {
5875                 $ctxm entryconf $ui_diff_applyhunk -label {Stage Hunk For Commit}
5876         }
5877         tk_popup $ctxm %X %Y
5878 "
5879 unset ui_diff_applyhunk
5880
5881 # -- Status Bar
5882 #
5883 label .status -textvariable ui_status_value \
5884         -anchor w \
5885         -justify left \
5886         -borderwidth 1 \
5887         -relief sunken \
5888         -font font_ui
5889 pack .status -anchor w -side bottom -fill x
5890
5891 # -- Load geometry
5892 #
5893 catch {
5894 set gm $repo_config(gui.geometry)
5895 wm geometry . [lindex $gm 0]
5896 .vpane sash place 0 \
5897         [lindex [.vpane sash coord 0] 0] \
5898         [lindex $gm 1]
5899 .vpane.files sash place 0 \
5900         [lindex $gm 2] \
5901         [lindex [.vpane.files sash coord 0] 1]
5902 unset gm
5903 }
5904
5905 # -- Key Bindings
5906 #
5907 bind $ui_comm <$M1B-Key-Return> {do_commit;break}
5908 bind $ui_comm <$M1B-Key-i> {do_add_all;break}
5909 bind $ui_comm <$M1B-Key-I> {do_add_all;break}
5910 bind $ui_comm <$M1B-Key-x> {tk_textCut %W;break}
5911 bind $ui_comm <$M1B-Key-X> {tk_textCut %W;break}
5912 bind $ui_comm <$M1B-Key-c> {tk_textCopy %W;break}
5913 bind $ui_comm <$M1B-Key-C> {tk_textCopy %W;break}
5914 bind $ui_comm <$M1B-Key-v> {tk_textPaste %W; %W see insert; break}
5915 bind $ui_comm <$M1B-Key-V> {tk_textPaste %W; %W see insert; break}
5916 bind $ui_comm <$M1B-Key-a> {%W tag add sel 0.0 end;break}
5917 bind $ui_comm <$M1B-Key-A> {%W tag add sel 0.0 end;break}
5918
5919 bind $ui_diff <$M1B-Key-x> {tk_textCopy %W;break}
5920 bind $ui_diff <$M1B-Key-X> {tk_textCopy %W;break}
5921 bind $ui_diff <$M1B-Key-c> {tk_textCopy %W;break}
5922 bind $ui_diff <$M1B-Key-C> {tk_textCopy %W;break}
5923 bind $ui_diff <$M1B-Key-v> {break}
5924 bind $ui_diff <$M1B-Key-V> {break}
5925 bind $ui_diff <$M1B-Key-a> {%W tag add sel 0.0 end;break}
5926 bind $ui_diff <$M1B-Key-A> {%W tag add sel 0.0 end;break}
5927 bind $ui_diff <Key-Up>     {catch {%W yview scroll -1 units};break}
5928 bind $ui_diff <Key-Down>   {catch {%W yview scroll  1 units};break}
5929 bind $ui_diff <Key-Left>   {catch {%W xview scroll -1 units};break}
5930 bind $ui_diff <Key-Right>  {catch {%W xview scroll  1 units};break}
5931 bind $ui_diff <Button-1>   {focus %W}
5932
5933 if {[is_enabled branch]} {
5934         bind . <$M1B-Key-n> do_create_branch
5935         bind . <$M1B-Key-N> do_create_branch
5936 }
5937
5938 bind all <Key-F5> do_rescan
5939 bind all <$M1B-Key-r> do_rescan
5940 bind all <$M1B-Key-R> do_rescan
5941 bind .   <$M1B-Key-s> do_signoff
5942 bind .   <$M1B-Key-S> do_signoff
5943 bind .   <$M1B-Key-i> do_add_all
5944 bind .   <$M1B-Key-I> do_add_all
5945 bind .   <$M1B-Key-Return> do_commit
5946 foreach i [list $ui_index $ui_workdir] {
5947         bind $i <Button-1>       "toggle_or_diff         $i %x %y; break"
5948         bind $i <$M1B-Button-1>  "add_one_to_selection   $i %x %y; break"
5949         bind $i <Shift-Button-1> "add_range_to_selection $i %x %y; break"
5950 }
5951 unset i
5952
5953 set file_lists($ui_index) [list]
5954 set file_lists($ui_workdir) [list]
5955
5956 wm title . "[appname] ([file normalize [file dirname [gitdir]]])"
5957 focus -force $ui_comm
5958
5959 # -- Warn the user about environmental problems.  Cygwin's Tcl
5960 #    does *not* pass its env array onto any processes it spawns.
5961 #    This means that git processes get none of our environment.
5962 #
5963 if {[is_Cygwin]} {
5964         set ignored_env 0
5965         set suggest_user {}
5966         set msg "Possible environment issues exist.
5967
5968 The following environment variables are probably
5969 going to be ignored by any Git subprocess run
5970 by [appname]:
5971
5972 "
5973         foreach name [array names env] {
5974                 switch -regexp -- $name {
5975                 {^GIT_INDEX_FILE$} -
5976                 {^GIT_OBJECT_DIRECTORY$} -
5977                 {^GIT_ALTERNATE_OBJECT_DIRECTORIES$} -
5978                 {^GIT_DIFF_OPTS$} -
5979                 {^GIT_EXTERNAL_DIFF$} -
5980                 {^GIT_PAGER$} -
5981                 {^GIT_TRACE$} -
5982                 {^GIT_CONFIG$} -
5983                 {^GIT_CONFIG_LOCAL$} -
5984                 {^GIT_(AUTHOR|COMMITTER)_DATE$} {
5985                         append msg " - $name\n"
5986                         incr ignored_env
5987                 }
5988                 {^GIT_(AUTHOR|COMMITTER)_(NAME|EMAIL)$} {
5989                         append msg " - $name\n"
5990                         incr ignored_env
5991                         set suggest_user $name
5992                 }
5993                 }
5994         }
5995         if {$ignored_env > 0} {
5996                 append msg "
5997 This is due to a known issue with the
5998 Tcl binary distributed by Cygwin."
5999
6000                 if {$suggest_user ne {}} {
6001                         append msg "
6002
6003 A good replacement for $suggest_user
6004 is placing values for the user.name and
6005 user.email settings into your personal
6006 ~/.gitconfig file.
6007 "
6008                 }
6009                 warn_popup $msg
6010         }
6011         unset ignored_env msg suggest_user name
6012 }
6013
6014 # -- Only initialize complex UI if we are going to stay running.
6015 #
6016 if {[is_enabled transport]} {
6017         load_all_remotes
6018         load_all_heads
6019
6020         populate_branch_menu
6021         populate_fetch_menu
6022         populate_push_menu
6023 }
6024
6025 # -- Only suggest a gc run if we are going to stay running.
6026 #
6027 if {[is_enabled multicommit]} {
6028         set object_limit 2000
6029         if {[is_Windows]} {set object_limit 200}
6030         regexp {^([0-9]+) objects,} [git count-objects] _junk objects_current
6031         if {$objects_current >= $object_limit} {
6032                 if {[ask_popup \
6033                         "This repository currently has $objects_current loose objects.
6034
6035 To maintain optimal performance it is strongly
6036 recommended that you compress the database
6037 when more than $object_limit loose objects exist.
6038
6039 Compress the database now?"] eq yes} {
6040                         do_gc
6041                 }
6042         }
6043         unset object_limit _junk objects_current
6044 }
6045
6046 lock_index begin-read
6047 after 1 do_rescan