Code

Merge branch 'rs/optim-text-wrap' into maint
[git.git] / git-gui / lib / index.tcl
1 # git-gui index (add/remove) support
2 # Copyright (C) 2006, 2007 Shawn Pearce
4 proc _delete_indexlock {} {
5         if {[catch {file delete -- [gitdir index.lock]} err]} {
6                 error_popup [strcat [mc "Unable to unlock the index."] "\n\n$err"]
7         }
8 }
10 proc _close_updateindex {fd after} {
11         global use_ttk NS
12         fconfigure $fd -blocking 1
13         if {[catch {close $fd} err]} {
14                 set w .indexfried
15                 Dialog $w
16                 wm withdraw $w
17                 wm title $w [strcat "[appname] ([reponame]): " [mc "Index Error"]]
18                 wm geometry $w "+[winfo rootx .]+[winfo rooty .]"
19                 set s [mc "Updating the Git index failed.  A rescan will be automatically started to resynchronize git-gui."]
20                 text $w.msg -yscrollcommand [list $w.vs set] \
21                         -width [string length $s] -relief flat \
22                         -borderwidth 0 -highlightthickness 0 \
23                         -background [get_bg_color $w]
24                 $w.msg tag configure bold -font font_uibold -justify center
25                 ${NS}::scrollbar $w.vs -command [list $w.msg yview]
26                 $w.msg insert end $s bold \n\n$err {}
27                 $w.msg configure -state disabled
29                 ${NS}::button $w.continue \
30                         -text [mc "Continue"] \
31                         -command [list destroy $w]
32                 ${NS}::button $w.unlock \
33                         -text [mc "Unlock Index"] \
34                         -command "destroy $w; _delete_indexlock"
35                 grid $w.msg - $w.vs -sticky news
36                 grid $w.unlock $w.continue - -sticky se -padx 2 -pady 2
37                 grid columnconfigure $w 0 -weight 1
38                 grid rowconfigure $w 0 -weight 1
40                 wm protocol $w WM_DELETE_WINDOW update
41                 bind $w.continue <Visibility> "
42                         grab $w
43                         focus %W
44                 "
45                 wm deiconify $w
46                 tkwait window $w
48                 $::main_status stop
49                 unlock_index
50                 rescan $after 0
51                 return
52         }
54         $::main_status stop
55         unlock_index
56         uplevel #0 $after
57 }
59 proc update_indexinfo {msg pathList after} {
60         global update_index_cp
62         if {![lock_index update]} return
64         set update_index_cp 0
65         set pathList [lsort $pathList]
66         set totalCnt [llength $pathList]
67         set batch [expr {int($totalCnt * .01) + 1}]
68         if {$batch > 25} {set batch 25}
70         $::main_status start $msg [mc "files"]
71         set fd [git_write update-index -z --index-info]
72         fconfigure $fd \
73                 -blocking 0 \
74                 -buffering full \
75                 -buffersize 512 \
76                 -encoding binary \
77                 -translation binary
78         fileevent $fd writable [list \
79                 write_update_indexinfo \
80                 $fd \
81                 $pathList \
82                 $totalCnt \
83                 $batch \
84                 $after \
85                 ]
86 }
88 proc write_update_indexinfo {fd pathList totalCnt batch after} {
89         global update_index_cp
90         global file_states current_diff_path
92         if {$update_index_cp >= $totalCnt} {
93                 _close_updateindex $fd $after
94                 return
95         }
97         for {set i $batch} \
98                 {$update_index_cp < $totalCnt && $i > 0} \
99                 {incr i -1} {
100                 set path [lindex $pathList $update_index_cp]
101                 incr update_index_cp
103                 set s $file_states($path)
104                 switch -glob -- [lindex $s 0] {
105                 A? {set new _O}
106                 M? {set new _M}
107                 T_ {set new _T}
108                 D_ {set new _D}
109                 D? {set new _?}
110                 ?? {continue}
111                 }
112                 set info [lindex $s 2]
113                 if {$info eq {}} continue
115                 puts -nonewline $fd "$info\t[encoding convertto $path]\0"
116                 display_file $path $new
117         }
119         $::main_status update $update_index_cp $totalCnt
122 proc update_index {msg pathList after} {
123         global update_index_cp
125         if {![lock_index update]} return
127         set update_index_cp 0
128         set pathList [lsort $pathList]
129         set totalCnt [llength $pathList]
130         set batch [expr {int($totalCnt * .01) + 1}]
131         if {$batch > 25} {set batch 25}
133         $::main_status start $msg [mc "files"]
134         set fd [git_write update-index --add --remove -z --stdin]
135         fconfigure $fd \
136                 -blocking 0 \
137                 -buffering full \
138                 -buffersize 512 \
139                 -encoding binary \
140                 -translation binary
141         fileevent $fd writable [list \
142                 write_update_index \
143                 $fd \
144                 $pathList \
145                 $totalCnt \
146                 $batch \
147                 $after \
148                 ]
151 proc write_update_index {fd pathList totalCnt batch after} {
152         global update_index_cp
153         global file_states current_diff_path
155         if {$update_index_cp >= $totalCnt} {
156                 _close_updateindex $fd $after
157                 return
158         }
160         for {set i $batch} \
161                 {$update_index_cp < $totalCnt && $i > 0} \
162                 {incr i -1} {
163                 set path [lindex $pathList $update_index_cp]
164                 incr update_index_cp
166                 switch -glob -- [lindex $file_states($path) 0] {
167                 AD {set new __}
168                 ?D {set new D_}
169                 _O -
170                 AM {set new A_}
171                 _T {set new T_}
172                 _U -
173                 U? {
174                         if {[file exists $path]} {
175                                 set new M_
176                         } else {
177                                 set new D_
178                         }
179                 }
180                 ?M {set new M_}
181                 ?? {continue}
182                 }
183                 puts -nonewline $fd "[encoding convertto $path]\0"
184                 display_file $path $new
185         }
187         $::main_status update $update_index_cp $totalCnt
190 proc checkout_index {msg pathList after} {
191         global update_index_cp
193         if {![lock_index update]} return
195         set update_index_cp 0
196         set pathList [lsort $pathList]
197         set totalCnt [llength $pathList]
198         set batch [expr {int($totalCnt * .01) + 1}]
199         if {$batch > 25} {set batch 25}
201         $::main_status start $msg [mc "files"]
202         set fd [git_write checkout-index \
203                 --index \
204                 --quiet \
205                 --force \
206                 -z \
207                 --stdin \
208                 ]
209         fconfigure $fd \
210                 -blocking 0 \
211                 -buffering full \
212                 -buffersize 512 \
213                 -encoding binary \
214                 -translation binary
215         fileevent $fd writable [list \
216                 write_checkout_index \
217                 $fd \
218                 $pathList \
219                 $totalCnt \
220                 $batch \
221                 $after \
222                 ]
225 proc write_checkout_index {fd pathList totalCnt batch after} {
226         global update_index_cp
227         global file_states current_diff_path
229         if {$update_index_cp >= $totalCnt} {
230                 _close_updateindex $fd $after
231                 return
232         }
234         for {set i $batch} \
235                 {$update_index_cp < $totalCnt && $i > 0} \
236                 {incr i -1} {
237                 set path [lindex $pathList $update_index_cp]
238                 incr update_index_cp
239                 switch -glob -- [lindex $file_states($path) 0] {
240                 U? {continue}
241                 ?M -
242                 ?T -
243                 ?D {
244                         puts -nonewline $fd "[encoding convertto $path]\0"
245                         display_file $path ?_
246                 }
247                 }
248         }
250         $::main_status update $update_index_cp $totalCnt
253 proc unstage_helper {txt paths} {
254         global file_states current_diff_path
256         if {![lock_index begin-update]} return
258         set pathList [list]
259         set after {}
260         foreach path $paths {
261                 switch -glob -- [lindex $file_states($path) 0] {
262                 A? -
263                 M? -
264                 T_ -
265                 D? {
266                         lappend pathList $path
267                         if {$path eq $current_diff_path} {
268                                 set after {reshow_diff;}
269                         }
270                 }
271                 }
272         }
273         if {$pathList eq {}} {
274                 unlock_index
275         } else {
276                 update_indexinfo \
277                         $txt \
278                         $pathList \
279                         [concat $after [list ui_ready]]
280         }
283 proc do_unstage_selection {} {
284         global current_diff_path selected_paths
286         if {[array size selected_paths] > 0} {
287                 unstage_helper \
288                         {Unstaging selected files from commit} \
289                         [array names selected_paths]
290         } elseif {$current_diff_path ne {}} {
291                 unstage_helper \
292                         [mc "Unstaging %s from commit" [short_path $current_diff_path]] \
293                         [list $current_diff_path]
294         }
297 proc add_helper {txt paths} {
298         global file_states current_diff_path
300         if {![lock_index begin-update]} return
302         set pathList [list]
303         set after {}
304         foreach path $paths {
305                 switch -glob -- [lindex $file_states($path) 0] {
306                 _U -
307                 U? {
308                         if {$path eq $current_diff_path} {
309                                 unlock_index
310                                 merge_stage_workdir $path
311                                 return
312                         }
313                 }
314                 _O -
315                 ?M -
316                 ?D -
317                 ?T {
318                         lappend pathList $path
319                         if {$path eq $current_diff_path} {
320                                 set after {reshow_diff;}
321                         }
322                 }
323                 }
324         }
325         if {$pathList eq {}} {
326                 unlock_index
327         } else {
328                 update_index \
329                         $txt \
330                         $pathList \
331                         [concat $after {ui_status [mc "Ready to commit."]}]
332         }
335 proc do_add_selection {} {
336         global current_diff_path selected_paths
338         if {[array size selected_paths] > 0} {
339                 add_helper \
340                         {Adding selected files} \
341                         [array names selected_paths]
342         } elseif {$current_diff_path ne {}} {
343                 add_helper \
344                         [mc "Adding %s" [short_path $current_diff_path]] \
345                         [list $current_diff_path]
346         }
349 proc do_add_all {} {
350         global file_states
352         set paths [list]
353         foreach path [array names file_states] {
354                 switch -glob -- [lindex $file_states($path) 0] {
355                 U? {continue}
356                 ?M -
357                 ?T -
358                 ?D {lappend paths $path}
359                 }
360         }
361         add_helper {Adding all changed files} $paths
364 proc revert_helper {txt paths} {
365         global file_states current_diff_path
367         if {![lock_index begin-update]} return
369         set pathList [list]
370         set after {}
371         foreach path $paths {
372                 switch -glob -- [lindex $file_states($path) 0] {
373                 U? {continue}
374                 ?M -
375                 ?T -
376                 ?D {
377                         lappend pathList $path
378                         if {$path eq $current_diff_path} {
379                                 set after {reshow_diff;}
380                         }
381                 }
382                 }
383         }
386         # Split question between singular and plural cases, because
387         # such distinction is needed in some languages. Previously, the
388         # code used "Revert changes in" for both, but that can't work
389         # in languages where 'in' must be combined with word from
390         # rest of string (in diffrent way for both cases of course).
391         #
392         # FIXME: Unfortunately, even that isn't enough in some languages
393         # as they have quite complex plural-form rules. Unfortunately,
394         # msgcat doesn't seem to support that kind of string translation.
395         #
396         set n [llength $pathList]
397         if {$n == 0} {
398                 unlock_index
399                 return
400         } elseif {$n == 1} {
401                 set query [mc "Revert changes in file %s?" [short_path [lindex $pathList]]]
402         } else {
403                 set query [mc "Revert changes in these %i files?" $n]
404         }
406         set reply [tk_dialog \
407                 .confirm_revert \
408                 "[appname] ([reponame])" \
409                 "$query
411 [mc "Any unstaged changes will be permanently lost by the revert."]" \
412                 question \
413                 1 \
414                 [mc "Do Nothing"] \
415                 [mc "Revert Changes"] \
416                 ]
417         if {$reply == 1} {
418                 checkout_index \
419                         $txt \
420                         $pathList \
421                         [concat $after [list ui_ready]]
422         } else {
423                 unlock_index
424         }
427 proc do_revert_selection {} {
428         global current_diff_path selected_paths
430         if {[array size selected_paths] > 0} {
431                 revert_helper \
432                         [mc "Reverting selected files"] \
433                         [array names selected_paths]
434         } elseif {$current_diff_path ne {}} {
435                 revert_helper \
436                         [mc "Reverting %s" [short_path $current_diff_path]] \
437                         [list $current_diff_path]
438         }
441 proc do_select_commit_type {} {
442         global commit_type selected_commit_type
444         if {$selected_commit_type eq {new}
445                 && [string match amend* $commit_type]} {
446                 create_new_commit
447         } elseif {$selected_commit_type eq {amend}
448                 && ![string match amend* $commit_type]} {
449                 load_last_commit
451                 # The amend request was rejected...
452                 #
453                 if {![string match amend* $commit_type]} {
454                         set selected_commit_type new
455                 }
456         }