Spaces:
Running
Running
| # tkfbox.tcl -- | |
| # | |
| # Implements the "TK" standard file selection dialog box. This dialog | |
| # box is used on the Unix platforms whenever the tk_strictMotif flag is | |
| # not set. | |
| # | |
| # The "TK" standard file selection dialog box is similar to the file | |
| # selection dialog box on Win95(TM). The user can navigate the | |
| # directories by clicking on the folder icons or by selecting the | |
| # "Directory" option menu. The user can select files by clicking on the | |
| # file icons or by entering a filename in the "Filename:" entry. | |
| # | |
| # Copyright (c) 1994-1998 Sun Microsystems, Inc. | |
| # | |
| # See the file "license.terms" for information on usage and redistribution | |
| # of this file, and for a DISCLAIMER OF ALL WARRANTIES. | |
| # | |
| namespace eval ::tk::dialog {} | |
| namespace eval ::tk::dialog::file { | |
| namespace import -force ::tk::msgcat::* | |
| variable showHiddenBtn 0 | |
| variable showHiddenVar 1 | |
| # Create the images if they did not already exist. | |
| if {![info exists ::tk::Priv(updirImage)]} { | |
| set ::tk::Priv(updirImage) [image create photo -data { | |
| iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABmJLR0QA/gD+AP7rGN | |
| SCAAAACXBIWXMAAA3WAAAN1gGQb3mcAAAACXZwQWcAAAAWAAAAFgDcxelYAAAENUlE | |
| QVQ4y7WUbWiVZRjHf/f9POcc9+Kc5bC2aIq5sGG0XnTzNU13zAIlFMNc9CEhTCKwCC | |
| JIgt7AglaR0RcrolAKg14+GBbiGL6xZiYyy63cmzvu7MVznnOe537rw7bDyvlBoT/c | |
| n+6L3/3nf13XLZLJJP+HfICysjKvqqpq+rWKysvLR1tbW+11g+fPn/+bEGIe4KYqCs | |
| Owu66u7oG2trah6wJrrRc0NTVhjME5h7Vj5pxzCCE4duxYZUdHx/aGhoZmgJ+yb+wF | |
| uCO19RmAffv25f8LFslkktraWtvU1CS6u7vRWmOtxVpbAPu+T0tLS04pFU/J34Wd3S | |
| cdFtlfZWeZBU4IcaS5uXn1ZLAEMMY4ay1aa4wx/zpKKYIgoL6+vmjxqoXe5ZLTcsPq | |
| bTyycjODpe1y3WMrvDAMV14jCuW0VhhjiJQpOJ5w7Zwjk8/y9R+vsHHNNq6oFMrkeX | |
| BxI+8d2sktap3YvOPD0lRQrH+Z81fE7t3WB4gihVKazsuaA20aKSUgAG/seQdy2l6W | |
| 37+EyopqTv39I6HJUT2zlnlza2jLdgiTaxwmDov6alLHcZUTzXPGGAauWJbfO4dHl9 | |
| bgJs3HyfNf0N4ZsOa+jbT3/ownY/hO09p1kBULtjBw+Tvq7xzwauds4dWPDleAcP5E | |
| xlprgtBRUZRgYCRPTzoHwEi2g6OnX+eFrW/RM9qBE4p43CeTz5ATaU6nDrFm2cPs/+ | |
| E1SopqkZ7MFJqntXZaa7IKppckwIEvJbg8LWd28OT6nVihCPQQ8UScWCLGqO4hXuQx | |
| qDtJ204eWrqWb1ufRspwtABWaqx5gRKUFSdwDnxPcuLcyyxbuIyaqntIBV34MY9YzC | |
| Owg+S9YeJFkniRpGPkCLMrZzG3+jbktA/KClMxFoUhiKC0OAbAhd79CO8i6xe/STyW | |
| 4O7KVRgUJ/sP0heeJV4kEVKw/vZd40sFKxat4mLvp6VLdvnb/XHHGGPIKwBBpC1/9n | |
| 3DpfRZnn9/AwCxRII9O79kVPdjvByxuET6Ai8mePeTt4lyheXzhOSpCcdWa00uckTG | |
| kckbGu76nEhbIm2xznH4VB3OWYaiXqQn8GKSWGIMHuXyPL76LBcupmhp69pz4uMnXi | |
| w4VloTGcdQRtGdzmHs1f+RdYZslMZJhzUOHVnceN1ooEiP5JUzdqCQMWCD0JCIeQzn | |
| NNpO+clhrCYf5rC+A2cxWmDUWG2oHEOZMEKIwclgMnnLrTeXUV7sUzpNXgU9DmijWV | |
| v9LEKCkAIhKIBnlvpks6F21qUZ31u/sbExPa9h0/RzwzMov2nGlG5TmW1YOzzlnSfL | |
| mVnyGf19Q7lwZHBp+1fPtflAIgiC7389n9qkihP+lWyeqfUO15ZwQTqlw9H+o2cOvN | |
| QJCAHEgEqgYnI0NyALjAJdyWQy7wMa6AEujUdzo3LjcAXwD/XCTKIRjWytAAAAJXRF | |
| WHRjcmVhdGUtZGF0ZQAyMDA5LTA0LTA2VDIxOjI1OjQxLTAzOjAw8s+uCAAAACV0RV | |
| h0bW9kaWZ5LWRhdGUAMjAwOC0wMS0wM1QxNTowODoyMS0wMjowMJEc/44AAAAZdEVY | |
| dFNvZnR3YXJlAHd3dy5pbmtzY2FwZS5vcmeb7jwaAAAAAElFTkSuQmCC | |
| }] | |
| } | |
| if {![info exists ::tk::Priv(folderImage)]} { | |
| set ::tk::Priv(folderImage) [image create photo -data { | |
| iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABHNCSVQICAgIfAhkiA | |
| AAAAlwSFlzAAAN1wAADdcBQiibeAAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBl | |
| Lm9yZ5vuPBoAAAHCSURBVDiNpZAxa5NRFIafc+9XLCni4BC6FBycMnbrLpkcgtDVX6 | |
| C70D/g4lZX/4coxLlgxFkpiiSSUGm/JiXfveee45AmNlhawXc53HvPee55X+l2u/yP | |
| qt3d3Tfu/viatwt3fzIYDI5uBJhZr9fr3TMzzAx3B+D09PR+v98/7HQ6z5fNOWdCCG | |
| U4HH6s67oAVDlnV1UmkwmllBUkhMD29nYHeLuEAkyn06qU8qqu64MrgIyqYmZrkHa7 | |
| 3drc3KTVahFjJITAaDRiPB4/XFlQVVMtHH5IzJo/P4EA4MyB+erWPQB7++zs7ccYvl | |
| U5Z08pMW2cl88eIXLZeDUpXzsBkNQ5eP1+p0opmaoCTgzw6fjs6gLLsp58FB60t0Dc | |
| K1Ul54yIEIMQ43Uj68pquDmCeJVztpwzuBNE2LgBoMVpslHMCUEAFgDVxQbzVAiA+a | |
| K5uGPmmDtZF3VpoUm2ArhqQaRiUjcMf81p1G60UEVhcjZfAFTVUkrgkS+jc06mDX9n | |
| vq4YhJ9nlxZExMwMEaHJRutOdWuIIsJFUoBSuTvHJ4YIfP46unV4qdlsjsBRZRtb/X | |
| fHd5+C8+P7+J8BIoxFwovfRxYhnhxjpzEAAAAASUVORK5CYII= | |
| }] | |
| } | |
| if {![info exists ::tk::Priv(fileImage)]} { | |
| set ::tk::Priv(fileImage) [image create photo -data { | |
| iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QA/wD/AP+gva | |
| eTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH1QQWFA84umAmQgAAANpJREFU | |
| OMutkj1uhDAQhb8HSLtbISGfgZ+zbJkix0HmFhwhUdocBnMBGvqtTIqIFSReWKK8ai | |
| x73nwzHrVt+zEMwwvH9FrX9TsA1trpqKy10+yUzME4jnjvAZB0LzXHkojjmDRNVyh3 | |
| A+89zrlVwlKSqKrqVy/J8lAUxSZBSMny4ZLgp54iyPM8UPHGNJ2IomibAKDv+9VlWZ | |
| bABbgB5/0WQgSSkC4PF2JF4JzbHN430c4vhAm0TyCJruuClefph4yCBCGT3T3Isoy/ | |
| KDHGfDZNcz2SZIx547/0BVRRX7n8uT/sAAAAAElFTkSuQmCC | |
| }] | |
| } | |
| } | |
| # ::tk::dialog::file:: -- | |
| # | |
| # Implements the TK file selection dialog. This dialog is used when the | |
| # tk_strictMotif flag is set to false. This procedure shouldn't be | |
| # called directly. Call tk_getOpenFile or tk_getSaveFile instead. | |
| # | |
| # Arguments: | |
| # type "open" or "save" | |
| # args Options parsed by the procedure. | |
| # | |
| proc ::tk::dialog::file:: {type args} { | |
| variable ::tk::Priv | |
| variable showHiddenBtn | |
| set dataName __tk_filedialog | |
| upvar ::tk::dialog::file::$dataName data | |
| Config $dataName $type $args | |
| if {$data(-parent) eq "."} { | |
| set w .$dataName | |
| } else { | |
| set w $data(-parent).$dataName | |
| } | |
| # (re)create the dialog box if necessary | |
| # | |
| if {![winfo exists $w]} { | |
| Create $w TkFDialog | |
| } elseif {[winfo class $w] ne "TkFDialog"} { | |
| destroy $w | |
| Create $w TkFDialog | |
| } else { | |
| set data(dirMenuBtn) $w.contents.f1.menu | |
| set data(dirMenu) $w.contents.f1.menu.menu | |
| set data(upBtn) $w.contents.f1.up | |
| set data(icons) $w.contents.icons | |
| set data(ent) $w.contents.f2.ent | |
| set data(typeMenuLab) $w.contents.f2.lab2 | |
| set data(typeMenuBtn) $w.contents.f2.menu | |
| set data(typeMenu) $data(typeMenuBtn).m | |
| set data(okBtn) $w.contents.f2.ok | |
| set data(cancelBtn) $w.contents.f2.cancel | |
| set data(hiddenBtn) $w.contents.f2.hidden | |
| SetSelectMode $w $data(-multiple) | |
| } | |
| if {$showHiddenBtn} { | |
| $data(hiddenBtn) configure -state normal | |
| grid $data(hiddenBtn) | |
| } else { | |
| $data(hiddenBtn) configure -state disabled | |
| grid remove $data(hiddenBtn) | |
| } | |
| # Make sure subseqent uses of this dialog are independent [Bug 845189] | |
| unset -nocomplain data(extUsed) | |
| # Dialog boxes should be transient with respect to their parent, so that | |
| # they will always stay on top of their parent window. However, some | |
| # window managers will create the window as withdrawn if the parent window | |
| # is withdrawn or iconified. Combined with the grab we put on the window, | |
| # this can hang the entire application. Therefore we only make the dialog | |
| # transient if the parent is viewable. | |
| if {[winfo viewable [winfo toplevel $data(-parent)]]} { | |
| wm transient $w $data(-parent) | |
| } | |
| # Add traces on the selectPath variable | |
| # | |
| trace add variable data(selectPath) write \ | |
| [list ::tk::dialog::file::SetPath $w] | |
| $data(dirMenuBtn) configure \ | |
| -textvariable ::tk::dialog::file::${dataName}(selectPath) | |
| # Cleanup previous menu | |
| # | |
| $data(typeMenu) delete 0 end | |
| $data(typeMenuBtn) configure -state normal -text "" | |
| # Initialize the file types menu | |
| # | |
| if {[llength $data(-filetypes)]} { | |
| # Default type and name to first entry | |
| set initialtype [lindex $data(-filetypes) 0] | |
| set initialTypeName [lindex $initialtype 0] | |
| if {$data(-typevariable) ne ""} { | |
| upvar #0 $data(-typevariable) typeVariable | |
| if {[info exists typeVariable]} { | |
| set initialTypeName $typeVariable | |
| } | |
| } | |
| foreach type $data(-filetypes) { | |
| set title [lindex $type 0] | |
| set filter [lindex $type 1] | |
| $data(typeMenu) add command -label $title \ | |
| -command [list ::tk::dialog::file::SetFilter $w $type] | |
| # [string first] avoids glob-pattern char issues | |
| if {[string first ${initialTypeName} $title] == 0} { | |
| set initialtype $type | |
| } | |
| } | |
| SetFilter $w $initialtype | |
| $data(typeMenuBtn) configure -state normal | |
| $data(typeMenuLab) configure -state normal | |
| } else { | |
| set data(filter) "*" | |
| $data(typeMenuBtn) configure -state disabled -takefocus 0 | |
| $data(typeMenuLab) configure -state disabled | |
| } | |
| UpdateWhenIdle $w | |
| # Withdraw the window, then update all the geometry information | |
| # so we know how big it wants to be, then center the window in the | |
| # display (Motif style) and de-iconify it. | |
| ::tk::PlaceWindow $w widget $data(-parent) | |
| wm title $w $data(-title) | |
| # Set a grab and claim the focus too. | |
| ::tk::SetFocusGrab $w $data(ent) | |
| $data(ent) delete 0 end | |
| $data(ent) insert 0 $data(selectFile) | |
| $data(ent) selection range 0 end | |
| $data(ent) icursor end | |
| # Wait for the user to respond, then restore the focus and return the | |
| # index of the selected button. Restore the focus before deleting the | |
| # window, since otherwise the window manager may take the focus away so we | |
| # can't redirect it. Finally, restore any grab that was in effect. | |
| vwait ::tk::Priv(selectFilePath) | |
| ::tk::RestoreFocusGrab $w $data(ent) withdraw | |
| # Cleanup traces on selectPath variable | |
| # | |
| foreach trace [trace info variable data(selectPath)] { | |
| trace remove variable data(selectPath) {*}$trace | |
| } | |
| $data(dirMenuBtn) configure -textvariable {} | |
| return $Priv(selectFilePath) | |
| } | |
| # ::tk::dialog::file::Config -- | |
| # | |
| # Configures the TK filedialog according to the argument list | |
| # | |
| proc ::tk::dialog::file::Config {dataName type argList} { | |
| upvar ::tk::dialog::file::$dataName data | |
| set data(type) $type | |
| # 0: Delete all variable that were set on data(selectPath) the | |
| # last time the file dialog is used. The traces may cause troubles | |
| # if the dialog is now used with a different -parent option. | |
| foreach trace [trace info variable data(selectPath)] { | |
| trace remove variable data(selectPath) {*}$trace | |
| } | |
| # 1: the configuration specs | |
| # | |
| set specs { | |
| {-defaultextension "" "" ""} | |
| {-filetypes "" "" ""} | |
| {-initialdir "" "" ""} | |
| {-initialfile "" "" ""} | |
| {-parent "" "" "."} | |
| {-title "" "" ""} | |
| {-typevariable "" "" ""} | |
| } | |
| # The "-multiple" option is only available for the "open" file dialog. | |
| # | |
| if {$type eq "open"} { | |
| lappend specs {-multiple "" "" "0"} | |
| } | |
| # The "-confirmoverwrite" option is only for the "save" file dialog. | |
| # | |
| if {$type eq "save"} { | |
| lappend specs {-confirmoverwrite "" "" "1"} | |
| } | |
| # 2: default values depending on the type of the dialog | |
| # | |
| if {![info exists data(selectPath)]} { | |
| # first time the dialog has been popped up | |
| set data(selectPath) [pwd] | |
| set data(selectFile) "" | |
| } | |
| # 3: parse the arguments | |
| # | |
| tclParseConfigSpec ::tk::dialog::file::$dataName $specs "" $argList | |
| if {$data(-title) eq ""} { | |
| if {$type eq "open"} { | |
| set data(-title) [mc "Open"] | |
| } else { | |
| set data(-title) [mc "Save As"] | |
| } | |
| } | |
| # 4: set the default directory and selection according to the -initial | |
| # settings | |
| # | |
| if {$data(-initialdir) ne ""} { | |
| # Ensure that initialdir is an absolute path name. | |
| if {[file isdirectory $data(-initialdir)]} { | |
| set old [pwd] | |
| cd $data(-initialdir) | |
| set data(selectPath) [pwd] | |
| cd $old | |
| } else { | |
| set data(selectPath) [pwd] | |
| } | |
| } | |
| set data(selectFile) $data(-initialfile) | |
| # 5. Parse the -filetypes option | |
| # | |
| set data(origfiletypes) $data(-filetypes) | |
| set data(-filetypes) [::tk::FDGetFileTypes $data(-filetypes)] | |
| if {![winfo exists $data(-parent)]} { | |
| return -code error -errorcode [list TK LOOKUP WINDOW $data(-parent)] \ | |
| "bad window path name \"$data(-parent)\"" | |
| } | |
| # Set -multiple to a one or zero value (not other boolean types like | |
| # "yes") so we can use it in tests more easily. | |
| if {$type eq "save"} { | |
| set data(-multiple) 0 | |
| } elseif {$data(-multiple)} { | |
| set data(-multiple) 1 | |
| } else { | |
| set data(-multiple) 0 | |
| } | |
| } | |
| proc ::tk::dialog::file::Create {w class} { | |
| set dataName [lindex [split $w .] end] | |
| upvar ::tk::dialog::file::$dataName data | |
| variable ::tk::Priv | |
| global tk_library | |
| toplevel $w -class $class | |
| if {[tk windowingsystem] eq "x11"} {wm attributes $w -type dialog} | |
| pack [ttk::frame $w.contents] -expand 1 -fill both | |
| #set w $w.contents | |
| # f1: the frame with the directory option menu | |
| # | |
| set f1 [ttk::frame $w.contents.f1] | |
| bind [::tk::AmpWidget ttk::label $f1.lab -text [mc "&Directory:"]] \ | |
| <<AltUnderlined>> [list focus $f1.menu] | |
| set data(dirMenuBtn) $f1.menu | |
| if {![info exists data(selectPath)]} { | |
| set data(selectPath) "" | |
| } | |
| set data(dirMenu) $f1.menu.menu | |
| ttk::menubutton $f1.menu -menu $data(dirMenu) -direction flush \ | |
| -textvariable [format %s(selectPath) ::tk::dialog::file::$dataName] | |
| menu $data(dirMenu) -tearoff 0 | |
| $data(dirMenu) add radiobutton -label "" -variable \ | |
| [format %s(selectPath) ::tk::dialog::file::$dataName] | |
| set data(upBtn) [ttk::button $f1.up] | |
| $data(upBtn) configure -image $Priv(updirImage) | |
| $f1.menu configure -takefocus 1;# -highlightthickness 2 | |
| pack $data(upBtn) -side right -padx 4 -fill both | |
| pack $f1.lab -side left -padx 4 -fill both | |
| pack $f1.menu -expand yes -fill both -padx 4 | |
| # data(icons): the IconList that list the files and directories. | |
| # | |
| if {$class eq "TkFDialog"} { | |
| if { $data(-multiple) } { | |
| set fNameCaption [mc "File &names:"] | |
| } else { | |
| set fNameCaption [mc "File &name:"] | |
| } | |
| set fTypeCaption [mc "Files of &type:"] | |
| set iconListCommand [list ::tk::dialog::file::OkCmd $w] | |
| } else { | |
| set fNameCaption [mc "&Selection:"] | |
| set iconListCommand [list ::tk::dialog::file::chooseDir::DblClick $w] | |
| } | |
| set data(icons) [::tk::IconList $w.contents.icons \ | |
| -command $iconListCommand -multiple $data(-multiple)] | |
| bind $data(icons) <<ListboxSelect>> \ | |
| [list ::tk::dialog::file::ListBrowse $w] | |
| # f2: the frame with the OK button, cancel button, "file name" field | |
| # and file types field. | |
| # | |
| set f2 [ttk::frame $w.contents.f2] | |
| bind [::tk::AmpWidget ttk::label $f2.lab -text $fNameCaption -anchor e]\ | |
| <<AltUnderlined>> [list focus $f2.ent] | |
| # -pady 0 | |
| set data(ent) [ttk::entry $f2.ent] | |
| # The font to use for the icons. The default Canvas font on Unix is just | |
| # deviant. | |
| set ::tk::$w.contents.icons(font) [$data(ent) cget -font] | |
| # Make the file types bits only if this is a File Dialog | |
| if {$class eq "TkFDialog"} { | |
| set data(typeMenuLab) [::tk::AmpWidget ttk::label $f2.lab2 \ | |
| -text $fTypeCaption -anchor e] | |
| # -pady [$f2.lab cget -pady] | |
| set data(typeMenuBtn) [ttk::menubutton $f2.menu \ | |
| -menu $f2.menu.m] | |
| # -indicatoron 1 | |
| set data(typeMenu) [menu $data(typeMenuBtn).m -tearoff 0] | |
| # $data(typeMenuBtn) configure -takefocus 1 -relief raised -anchor w | |
| bind $data(typeMenuLab) <<AltUnderlined>> [list \ | |
| focus $data(typeMenuBtn)] | |
| } | |
| # The hidden button is displayed when ::tk::dialog::file::showHiddenBtn is | |
| # true. Create it disabled so the binding doesn't trigger if it isn't | |
| # shown. | |
| if {$class eq "TkFDialog"} { | |
| set text [mc "Show &Hidden Files and Directories"] | |
| } else { | |
| set text [mc "Show &Hidden Directories"] | |
| } | |
| set data(hiddenBtn) [::tk::AmpWidget ttk::checkbutton $f2.hidden \ | |
| -text $text -state disabled \ | |
| -variable ::tk::dialog::file::showHiddenVar \ | |
| -command [list ::tk::dialog::file::UpdateWhenIdle $w]] | |
| # -anchor w -padx 3 | |
| # the okBtn is created after the typeMenu so that the keyboard traversal | |
| # is in the right order, and add binding so that we find out when the | |
| # dialog is destroyed by the user (added here instead of to the overall | |
| # window so no confusion about how much <Destroy> gets called; exactly | |
| # once will do). [Bug 987169] | |
| set data(okBtn) [::tk::AmpWidget ttk::button $f2.ok \ | |
| -text [mc "&OK"] -default active];# -pady 3] | |
| bind $data(okBtn) <Destroy> [list ::tk::dialog::file::Destroyed $w] | |
| set data(cancelBtn) [::tk::AmpWidget ttk::button $f2.cancel \ | |
| -text [mc "&Cancel"] -default normal];# -pady 3] | |
| # grid the widgets in f2 | |
| # | |
| grid $f2.lab $f2.ent $data(okBtn) -padx 4 -pady 3 -sticky ew | |
| grid configure $f2.ent -padx 2 | |
| if {$class eq "TkFDialog"} { | |
| grid $data(typeMenuLab) $data(typeMenuBtn) $data(cancelBtn) \ | |
| -padx 4 -sticky ew | |
| grid configure $data(typeMenuBtn) -padx 0 | |
| grid $data(hiddenBtn) -columnspan 2 -padx 4 -sticky ew | |
| } else { | |
| grid $data(hiddenBtn) - $data(cancelBtn) -padx 4 -sticky ew | |
| } | |
| grid columnconfigure $f2 1 -weight 1 | |
| # Pack all the frames together. We are done with widget construction. | |
| # | |
| pack $f1 -side top -fill x -pady 4 | |
| pack $f2 -side bottom -pady 4 -fill x | |
| pack $data(icons) -expand yes -fill both -padx 4 -pady 1 | |
| # Set up the event handlers that are common to Directory and File Dialogs | |
| # | |
| wm protocol $w WM_DELETE_WINDOW [list ::tk::dialog::file::CancelCmd $w] | |
| $data(upBtn) configure -command [list ::tk::dialog::file::UpDirCmd $w] | |
| $data(cancelBtn) configure -command [list ::tk::dialog::file::CancelCmd $w] | |
| bind $w <KeyPress-Escape> [list $data(cancelBtn) invoke] | |
| bind $w <Alt-Key> [list tk::AltKeyInDialog $w %A] | |
| # Set up event handlers specific to File or Directory Dialogs | |
| # | |
| if {$class eq "TkFDialog"} { | |
| bind $data(ent) <Return> [list ::tk::dialog::file::ActivateEnt $w] | |
| $data(okBtn) configure -command [list ::tk::dialog::file::OkCmd $w] | |
| bind $w <Alt-t> [format { | |
| if {[%s cget -state] eq "normal"} { | |
| focus %s | |
| } | |
| } $data(typeMenuBtn) $data(typeMenuBtn)] | |
| } else { | |
| set okCmd [list ::tk::dialog::file::chooseDir::OkCmd $w] | |
| bind $data(ent) <Return> $okCmd | |
| $data(okBtn) configure -command $okCmd | |
| bind $w <Alt-s> [list focus $data(ent)] | |
| bind $w <Alt-o> [list $data(okBtn) invoke] | |
| } | |
| bind $w <Alt-h> [list $data(hiddenBtn) invoke] | |
| bind $data(ent) <Tab> [list ::tk::dialog::file::CompleteEnt $w] | |
| # Build the focus group for all the entries | |
| # | |
| ::tk::FocusGroup_Create $w | |
| ::tk::FocusGroup_BindIn $w $data(ent) [list \ | |
| ::tk::dialog::file::EntFocusIn $w] | |
| ::tk::FocusGroup_BindOut $w $data(ent) [list \ | |
| ::tk::dialog::file::EntFocusOut $w] | |
| } | |
| # ::tk::dialog::file::SetSelectMode -- | |
| # | |
| # Set the select mode of the dialog to single select or multi-select. | |
| # | |
| # Arguments: | |
| # w The dialog path. | |
| # multi 1 if the dialog is multi-select; 0 otherwise. | |
| # | |
| # Results: | |
| # None. | |
| proc ::tk::dialog::file::SetSelectMode {w multi} { | |
| set dataName __tk_filedialog | |
| upvar ::tk::dialog::file::$dataName data | |
| if { $multi } { | |
| set fNameCaption [mc "File &names:"] | |
| } else { | |
| set fNameCaption [mc "File &name:"] | |
| } | |
| set iconListCommand [list ::tk::dialog::file::OkCmd $w] | |
| ::tk::SetAmpText $w.contents.f2.lab $fNameCaption | |
| $data(icons) configure -multiple $multi -command $iconListCommand | |
| return | |
| } | |
| # ::tk::dialog::file::UpdateWhenIdle -- | |
| # | |
| # Creates an idle event handler which updates the dialog in idle time. | |
| # This is important because loading the directory may take a long time | |
| # and we don't want to load the same directory for multiple times due to | |
| # multiple concurrent events. | |
| # | |
| proc ::tk::dialog::file::UpdateWhenIdle {w} { | |
| upvar ::tk::dialog::file::[winfo name $w] data | |
| if {[info exists data(updateId)]} { | |
| return | |
| } | |
| set data(updateId) [after idle [list ::tk::dialog::file::Update $w]] | |
| } | |
| # ::tk::dialog::file::Update -- | |
| # | |
| # Loads the files and directories into the IconList widget. Also sets up | |
| # the directory option menu for quick access to parent directories. | |
| # | |
| proc ::tk::dialog::file::Update {w} { | |
| # This proc may be called within an idle handler. Make sure that the | |
| # window has not been destroyed before this proc is called | |
| if {![winfo exists $w]} { | |
| return | |
| } | |
| set class [winfo class $w] | |
| if {($class ne "TkFDialog") && ($class ne "TkChooseDir")} { | |
| return | |
| } | |
| set dataName [winfo name $w] | |
| upvar ::tk::dialog::file::$dataName data | |
| variable ::tk::Priv | |
| variable showHiddenVar | |
| global tk_library | |
| unset -nocomplain data(updateId) | |
| set folder $Priv(folderImage) | |
| set file $Priv(fileImage) | |
| set appPWD [pwd] | |
| if {[catch { | |
| cd $data(selectPath) | |
| }]} then { | |
| # We cannot change directory to $data(selectPath). $data(selectPath) | |
| # should have been checked before ::tk::dialog::file::Update is | |
| # called, so we normally won't come to here. Anyways, give an error | |
| # and abort action. | |
| tk_messageBox -type ok -parent $w -icon warning -message [mc \ | |
| "Cannot change to the directory \"%1\$s\".\nPermission denied."\ | |
| $data(selectPath)] | |
| cd $appPWD | |
| return | |
| } | |
| # Turn on the busy cursor. BUG?? We haven't disabled X events, though, | |
| # so the user may still click and cause havoc ... | |
| # | |
| set entCursor [$data(ent) cget -cursor] | |
| set dlgCursor [$w cget -cursor] | |
| $data(ent) configure -cursor watch | |
| $w configure -cursor watch | |
| update idletasks | |
| $data(icons) deleteall | |
| set showHidden $showHiddenVar | |
| # Make the dir list. Note that using an explicit [pwd] (instead of '.') is | |
| # better in some VFS cases. | |
| $data(icons) add $folder [GlobFiltered [pwd] d 1] | |
| if {$class eq "TkFDialog"} { | |
| # Make the file list if this is a File Dialog, selecting all but | |
| # 'd'irectory type files. | |
| # | |
| $data(icons) add $file [GlobFiltered [pwd] {f b c l p s}] | |
| } | |
| # Update the Directory: option menu | |
| # | |
| set list "" | |
| set dir "" | |
| foreach subdir [file split $data(selectPath)] { | |
| set dir [file join $dir $subdir] | |
| lappend list $dir | |
| } | |
| $data(dirMenu) delete 0 end | |
| set var [format %s(selectPath) ::tk::dialog::file::$dataName] | |
| foreach path $list { | |
| $data(dirMenu) add command -label $path -command [list set $var $path] | |
| } | |
| # Restore the PWD to the application's PWD | |
| # | |
| cd $appPWD | |
| if {$class eq "TkFDialog"} { | |
| # Restore the Open/Save Button if this is a File Dialog | |
| # | |
| if {$data(type) eq "open"} { | |
| ::tk::SetAmpText $data(okBtn) [mc "&Open"] | |
| } else { | |
| ::tk::SetAmpText $data(okBtn) [mc "&Save"] | |
| } | |
| } | |
| # turn off the busy cursor. | |
| # | |
| $data(ent) configure -cursor $entCursor | |
| $w configure -cursor $dlgCursor | |
| } | |
| # ::tk::dialog::file::SetPathSilently -- | |
| # | |
| # Sets data(selectPath) without invoking the trace procedure | |
| # | |
| proc ::tk::dialog::file::SetPathSilently {w path} { | |
| upvar ::tk::dialog::file::[winfo name $w] data | |
| set cb [list ::tk::dialog::file::SetPath $w] | |
| trace remove variable data(selectPath) write $cb | |
| set data(selectPath) $path | |
| trace add variable data(selectPath) write $cb | |
| } | |
| # This proc gets called whenever data(selectPath) is set | |
| # | |
| proc ::tk::dialog::file::SetPath {w name1 name2 op} { | |
| if {[winfo exists $w]} { | |
| upvar ::tk::dialog::file::[winfo name $w] data | |
| UpdateWhenIdle $w | |
| # On directory dialogs, we keep the entry in sync with the currentdir. | |
| if {[winfo class $w] eq "TkChooseDir"} { | |
| $data(ent) delete 0 end | |
| $data(ent) insert end $data(selectPath) | |
| } | |
| } | |
| } | |
| # This proc gets called whenever data(filter) is set | |
| # | |
| proc ::tk::dialog::file::SetFilter {w type} { | |
| upvar ::tk::dialog::file::[winfo name $w] data | |
| set data(filterType) $type | |
| set data(filter) [lindex $type 1] | |
| $data(typeMenuBtn) configure -text [lindex $type 0] ;#-indicatoron 1 | |
| # If we aren't using a default extension, use the one suppled by the | |
| # filter. | |
| if {![info exists data(extUsed)]} { | |
| if {[string length $data(-defaultextension)]} { | |
| set data(extUsed) 1 | |
| } else { | |
| set data(extUsed) 0 | |
| } | |
| } | |
| if {!$data(extUsed)} { | |
| # Get the first extension in the list that matches {^\*\.\w+$} and | |
| # remove all * from the filter. | |
| set index [lsearch -regexp $data(filter) {^\*\.\w+$}] | |
| if {$index >= 0} { | |
| set data(-defaultextension) \ | |
| [string trimleft [lindex $data(filter) $index] "*"] | |
| } else { | |
| # Couldn't find anything! Reset to a safe default... | |
| set data(-defaultextension) "" | |
| } | |
| } | |
| $data(icons) see 0 | |
| UpdateWhenIdle $w | |
| } | |
| # tk::dialog::file::ResolveFile -- | |
| # | |
| # Interpret the user's text input in a file selection dialog. Performs: | |
| # | |
| # (1) ~ substitution | |
| # (2) resolve all instances of . and .. | |
| # (3) check for non-existent files/directories | |
| # (4) check for chdir permissions | |
| # (5) conversion of environment variable references to their | |
| # contents (once only) | |
| # | |
| # Arguments: | |
| # context: the current directory you are in | |
| # text: the text entered by the user | |
| # defaultext: the default extension to add to files with no extension | |
| # expandEnv: whether to expand environment variables (yes by default) | |
| # | |
| # Return vaue: | |
| # [list $flag $directory $file] | |
| # | |
| # flag = OK : valid input | |
| # = PATTERN : valid directory/pattern | |
| # = PATH : the directory does not exist | |
| # = FILE : the directory exists by the file doesn't exist | |
| # = CHDIR : Cannot change to the directory | |
| # = ERROR : Invalid entry | |
| # | |
| # directory : valid only if flag = OK or PATTERN or FILE | |
| # file : valid only if flag = OK or PATTERN | |
| # | |
| # directory may not be the same as context, because text may contain a | |
| # subdirectory name | |
| # | |
| proc ::tk::dialog::file::ResolveFile {context text defaultext {expandEnv 1}} { | |
| set appPWD [pwd] | |
| set path [JoinFile $context $text] | |
| # If the file has no extension, append the default. Be careful not to do | |
| # this for directories, otherwise typing a dirname in the box will give | |
| # back "dirname.extension" instead of trying to change dir. | |
| if { | |
| ![file isdirectory $path] && ([file ext $path] eq "") && | |
| ![string match {$*} [file tail $path]] | |
| } then { | |
| set path "$path$defaultext" | |
| } | |
| if {[catch {file exists $path}]} { | |
| # This "if" block can be safely removed if the following code stop | |
| # generating errors. | |
| # | |
| # file exists ~nonsuchuser | |
| # | |
| return [list ERROR $path ""] | |
| } | |
| if {[file exists $path]} { | |
| if {[file isdirectory $path]} { | |
| if {[catch {cd $path}]} { | |
| return [list CHDIR $path ""] | |
| } | |
| set directory [pwd] | |
| set file "" | |
| set flag OK | |
| cd $appPWD | |
| } else { | |
| if {[catch {cd [file dirname $path]}]} { | |
| return [list CHDIR [file dirname $path] ""] | |
| } | |
| set directory [pwd] | |
| set file [file tail $path] | |
| set flag OK | |
| cd $appPWD | |
| } | |
| } else { | |
| set dirname [file dirname $path] | |
| if {[file exists $dirname]} { | |
| if {[catch {cd $dirname}]} { | |
| return [list CHDIR $dirname ""] | |
| } | |
| set directory [pwd] | |
| cd $appPWD | |
| set file [file tail $path] | |
| # It's nothing else, so check to see if it is an env-reference | |
| if {$expandEnv && [string match {$*} $file]} { | |
| set var [string range $file 1 end] | |
| if {[info exist ::env($var)]} { | |
| return [ResolveFile $context $::env($var) $defaultext 0] | |
| } | |
| } | |
| if {[regexp {[*?]} $file]} { | |
| set flag PATTERN | |
| } else { | |
| set flag FILE | |
| } | |
| } else { | |
| set directory $dirname | |
| set file [file tail $path] | |
| set flag PATH | |
| # It's nothing else, so check to see if it is an env-reference | |
| if {$expandEnv && [string match {$*} $file]} { | |
| set var [string range $file 1 end] | |
| if {[info exist ::env($var)]} { | |
| return [ResolveFile $context $::env($var) $defaultext 0] | |
| } | |
| } | |
| } | |
| } | |
| return [list $flag $directory $file] | |
| } | |
| # Gets called when the entry box gets keyboard focus. We clear the selection | |
| # from the icon list . This way the user can be certain that the input in the | |
| # entry box is the selection. | |
| # | |
| proc ::tk::dialog::file::EntFocusIn {w} { | |
| upvar ::tk::dialog::file::[winfo name $w] data | |
| if {[$data(ent) get] ne ""} { | |
| $data(ent) selection range 0 end | |
| $data(ent) icursor end | |
| } else { | |
| $data(ent) selection clear | |
| } | |
| if {[winfo class $w] eq "TkFDialog"} { | |
| # If this is a File Dialog, make sure the buttons are labeled right. | |
| if {$data(type) eq "open"} { | |
| ::tk::SetAmpText $data(okBtn) [mc "&Open"] | |
| } else { | |
| ::tk::SetAmpText $data(okBtn) [mc "&Save"] | |
| } | |
| } | |
| } | |
| proc ::tk::dialog::file::EntFocusOut {w} { | |
| upvar ::tk::dialog::file::[winfo name $w] data | |
| $data(ent) selection clear | |
| } | |
| # Gets called when user presses Return in the "File name" entry. | |
| # | |
| proc ::tk::dialog::file::ActivateEnt {w} { | |
| upvar ::tk::dialog::file::[winfo name $w] data | |
| set text [$data(ent) get] | |
| if {$data(-multiple)} { | |
| foreach t $text { | |
| VerifyFileName $w $t | |
| } | |
| } else { | |
| VerifyFileName $w $text | |
| } | |
| } | |
| # Verification procedure | |
| # | |
| proc ::tk::dialog::file::VerifyFileName {w filename} { | |
| upvar ::tk::dialog::file::[winfo name $w] data | |
| set list [ResolveFile $data(selectPath) $filename $data(-defaultextension)] | |
| foreach {flag path file} $list { | |
| break | |
| } | |
| switch -- $flag { | |
| OK { | |
| if {$file eq ""} { | |
| # user has entered an existing (sub)directory | |
| set data(selectPath) $path | |
| $data(ent) delete 0 end | |
| } else { | |
| SetPathSilently $w $path | |
| if {$data(-multiple)} { | |
| lappend data(selectFile) $file | |
| } else { | |
| set data(selectFile) $file | |
| } | |
| Done $w | |
| } | |
| } | |
| PATTERN { | |
| set data(selectPath) $path | |
| set data(filter) $file | |
| } | |
| FILE { | |
| if {$data(type) eq "open"} { | |
| tk_messageBox -icon warning -type ok -parent $w \ | |
| -message [mc "File \"%1\$s\" does not exist." \ | |
| [file join $path $file]] | |
| $data(ent) selection range 0 end | |
| $data(ent) icursor end | |
| } else { | |
| SetPathSilently $w $path | |
| if {$data(-multiple)} { | |
| lappend data(selectFile) $file | |
| } else { | |
| set data(selectFile) $file | |
| } | |
| Done $w | |
| } | |
| } | |
| PATH { | |
| tk_messageBox -icon warning -type ok -parent $w \ | |
| -message [mc "Directory \"%1\$s\" does not exist." $path] | |
| $data(ent) selection range 0 end | |
| $data(ent) icursor end | |
| } | |
| CHDIR { | |
| tk_messageBox -type ok -parent $w -icon warning -message \ | |
| [mc "Cannot change to the directory\ | |
| \"%1\$s\".\nPermission denied." $path] | |
| $data(ent) selection range 0 end | |
| $data(ent) icursor end | |
| } | |
| ERROR { | |
| tk_messageBox -type ok -parent $w -icon warning -message \ | |
| [mc "Invalid file name \"%1\$s\"." $path] | |
| $data(ent) selection range 0 end | |
| $data(ent) icursor end | |
| } | |
| } | |
| } | |
| # Gets called when user presses the Alt-s or Alt-o keys. | |
| # | |
| proc ::tk::dialog::file::InvokeBtn {w key} { | |
| upvar ::tk::dialog::file::[winfo name $w] data | |
| if {[$data(okBtn) cget -text] eq $key} { | |
| $data(okBtn) invoke | |
| } | |
| } | |
| # Gets called when user presses the "parent directory" button | |
| # | |
| proc ::tk::dialog::file::UpDirCmd {w} { | |
| upvar ::tk::dialog::file::[winfo name $w] data | |
| if {$data(selectPath) ne "/"} { | |
| set data(selectPath) [file dirname $data(selectPath)] | |
| } | |
| } | |
| # Join a file name to a path name. The "file join" command will break if the | |
| # filename begins with ~ | |
| # | |
| proc ::tk::dialog::file::JoinFile {path file} { | |
| if {[string match {~*} $file] && [file exists $path/$file]} { | |
| return [file join $path ./$file] | |
| } else { | |
| return [file join $path $file] | |
| } | |
| } | |
| # Gets called when user presses the "OK" button | |
| # | |
| proc ::tk::dialog::file::OkCmd {w} { | |
| upvar ::tk::dialog::file::[winfo name $w] data | |
| set filenames {} | |
| foreach item [$data(icons) selection get] { | |
| lappend filenames [$data(icons) get $item] | |
| } | |
| if { | |
| ([llength $filenames] && !$data(-multiple)) || | |
| ($data(-multiple) && ([llength $filenames] == 1)) | |
| } then { | |
| set filename [lindex $filenames 0] | |
| set file [JoinFile $data(selectPath) $filename] | |
| if {[file isdirectory $file]} { | |
| ListInvoke $w [list $filename] | |
| return | |
| } | |
| } | |
| ActivateEnt $w | |
| } | |
| # Gets called when user presses the "Cancel" button | |
| # | |
| proc ::tk::dialog::file::CancelCmd {w} { | |
| upvar ::tk::dialog::file::[winfo name $w] data | |
| variable ::tk::Priv | |
| bind $data(okBtn) <Destroy> {} | |
| set Priv(selectFilePath) "" | |
| } | |
| # Gets called when user destroys the dialog directly [Bug 987169] | |
| # | |
| proc ::tk::dialog::file::Destroyed {w} { | |
| upvar ::tk::dialog::file::[winfo name $w] data | |
| variable ::tk::Priv | |
| set Priv(selectFilePath) "" | |
| } | |
| # Gets called when user browses the IconList widget (dragging mouse, arrow | |
| # keys, etc) | |
| # | |
| proc ::tk::dialog::file::ListBrowse {w} { | |
| upvar ::tk::dialog::file::[winfo name $w] data | |
| set text {} | |
| foreach item [$data(icons) selection get] { | |
| lappend text [$data(icons) get $item] | |
| } | |
| if {[llength $text] == 0} { | |
| return | |
| } | |
| if {$data(-multiple)} { | |
| set newtext {} | |
| foreach file $text { | |
| set fullfile [JoinFile $data(selectPath) $file] | |
| if { ![file isdirectory $fullfile] } { | |
| lappend newtext $file | |
| } | |
| } | |
| set text $newtext | |
| set isDir 0 | |
| } else { | |
| set text [lindex $text 0] | |
| set file [JoinFile $data(selectPath) $text] | |
| set isDir [file isdirectory $file] | |
| } | |
| if {!$isDir} { | |
| $data(ent) delete 0 end | |
| $data(ent) insert 0 $text | |
| if {[winfo class $w] eq "TkFDialog"} { | |
| if {$data(type) eq "open"} { | |
| ::tk::SetAmpText $data(okBtn) [mc "&Open"] | |
| } else { | |
| ::tk::SetAmpText $data(okBtn) [mc "&Save"] | |
| } | |
| } | |
| } elseif {[winfo class $w] eq "TkFDialog"} { | |
| ::tk::SetAmpText $data(okBtn) [mc "&Open"] | |
| } | |
| } | |
| # Gets called when user invokes the IconList widget (double-click, Return key, | |
| # etc) | |
| # | |
| proc ::tk::dialog::file::ListInvoke {w filenames} { | |
| upvar ::tk::dialog::file::[winfo name $w] data | |
| if {[llength $filenames] == 0} { | |
| return | |
| } | |
| set file [JoinFile $data(selectPath) [lindex $filenames 0]] | |
| set class [winfo class $w] | |
| if {$class eq "TkChooseDir" || [file isdirectory $file]} { | |
| set appPWD [pwd] | |
| if {[catch {cd $file}]} { | |
| tk_messageBox -type ok -parent $w -icon warning -message \ | |
| [mc "Cannot change to the directory \"%1\$s\".\nPermission denied." $file] | |
| } else { | |
| cd $appPWD | |
| set data(selectPath) $file | |
| } | |
| } else { | |
| if {$data(-multiple)} { | |
| set data(selectFile) $filenames | |
| } else { | |
| set data(selectFile) $file | |
| } | |
| Done $w | |
| } | |
| } | |
| # ::tk::dialog::file::Done -- | |
| # | |
| # Gets called when user has input a valid filename. Pops up a dialog | |
| # box to confirm selection when necessary. Sets the | |
| # tk::Priv(selectFilePath) variable, which will break the "vwait" loop | |
| # in ::tk::dialog::file:: and return the selected filename to the script | |
| # that calls tk_getOpenFile or tk_getSaveFile | |
| # | |
| proc ::tk::dialog::file::Done {w {selectFilePath ""}} { | |
| upvar ::tk::dialog::file::[winfo name $w] data | |
| variable ::tk::Priv | |
| if {$selectFilePath eq ""} { | |
| if {$data(-multiple)} { | |
| set selectFilePath {} | |
| foreach f $data(selectFile) { | |
| lappend selectFilePath [JoinFile $data(selectPath) $f] | |
| } | |
| } else { | |
| set selectFilePath [JoinFile $data(selectPath) $data(selectFile)] | |
| } | |
| set Priv(selectFile) $data(selectFile) | |
| set Priv(selectPath) $data(selectPath) | |
| if {($data(type) eq "save") && $data(-confirmoverwrite) && [file exists $selectFilePath]} { | |
| set reply [tk_messageBox -icon warning -type yesno -parent $w \ | |
| -message [mc "File \"%1\$s\" already exists.\nDo you want\ | |
| to overwrite it?" $selectFilePath]] | |
| if {$reply eq "no"} { | |
| return | |
| } | |
| } | |
| if { | |
| [info exists data(-typevariable)] && $data(-typevariable) ne "" | |
| && [info exists data(-filetypes)] && [llength $data(-filetypes)] | |
| && [info exists data(filterType)] && $data(filterType) ne "" | |
| } then { | |
| upvar #0 $data(-typevariable) typeVariable | |
| set typeVariable [lindex $data(origfiletypes) \ | |
| [lsearch -exact $data(-filetypes) $data(filterType)] 0] | |
| } | |
| } | |
| bind $data(okBtn) <Destroy> {} | |
| set Priv(selectFilePath) $selectFilePath | |
| } | |
| # ::tk::dialog::file::GlobFiltered -- | |
| # | |
| # Gets called to do globbing, returning the results and filtering them | |
| # according to the current filter (and removing the entries for '.' and | |
| # '..' which are never shown). Deals with evil cases such as where the | |
| # user is supplying a filter which is an invalid list or where it has an | |
| # unbalanced brace. The resulting list will be dictionary sorted. | |
| # | |
| # Arguments: | |
| # dir Which directory to search | |
| # type List of filetypes to look for ('d' or 'f b c l p s') | |
| # overrideFilter Whether to ignore the filter for this search. | |
| # | |
| # NB: Assumes that the caller has mapped the state variable to 'data'. | |
| # | |
| proc ::tk::dialog::file::GlobFiltered {dir type {overrideFilter 0}} { | |
| variable showHiddenVar | |
| upvar 1 data(filter) filter | |
| if {$filter eq "*" || $overrideFilter} { | |
| set patterns [list *] | |
| if {$showHiddenVar} { | |
| lappend patterns .* | |
| } | |
| } elseif {[string is list $filter]} { | |
| set patterns $filter | |
| } else { | |
| # Invalid list; assume we can use non-whitespace sequences as words | |
| set patterns [regexp -inline -all {\S+} $filter] | |
| } | |
| set opts [list -tails -directory $dir -type $type -nocomplain] | |
| set result {} | |
| catch { | |
| # We have a catch because we might have a really bad pattern (e.g., | |
| # with an unbalanced brace); even [glob -nocomplain] doesn't like it. | |
| # Using a catch ensures that it just means we match nothing instead of | |
| # throwing a nasty error at the user... | |
| foreach f [glob {*}$opts -- {*}$patterns] { | |
| if {$f eq "." || $f eq ".."} { | |
| continue | |
| } | |
| # See ticket [1641721], $f might be a link pointing to a dir | |
| if {$type != "d" && [file isdir [file join $dir $f]]} { | |
| continue | |
| } | |
| lappend result $f | |
| } | |
| } | |
| return [lsort -dictionary -unique $result] | |
| } | |
| proc ::tk::dialog::file::CompleteEnt {w} { | |
| upvar ::tk::dialog::file::[winfo name $w] data | |
| set f [$data(ent) get] | |
| if {$data(-multiple)} { | |
| if {![string is list $f] || [llength $f] != 1} { | |
| return -code break | |
| } | |
| set f [lindex $f 0] | |
| } | |
| # Get list of matching filenames and dirnames | |
| set files [if {[winfo class $w] eq "TkFDialog"} { | |
| GlobFiltered $data(selectPath) {f b c l p s} | |
| }] | |
| set dirs2 {} | |
| foreach d [GlobFiltered $data(selectPath) d] {lappend dirs2 $d/} | |
| set targets [concat \ | |
| [lsearch -glob -all -inline $files $f*] \ | |
| [lsearch -glob -all -inline $dirs2 $f*]] | |
| if {[llength $targets] == 1} { | |
| # We have a winner! | |
| set f [lindex $targets 0] | |
| } elseif {$f in $targets || [llength $targets] == 0} { | |
| if {[string length $f] > 0} { | |
| bell | |
| } | |
| return | |
| } elseif {[llength $targets] > 1} { | |
| # Multiple possibles | |
| if {[string length $f] == 0} { | |
| return | |
| } | |
| set t0 [lindex $targets 0] | |
| for {set len [string length $t0]} {$len>0} {} { | |
| set allmatch 1 | |
| foreach s $targets { | |
| if {![string equal -length $len $s $t0]} { | |
| set allmatch 0 | |
| break | |
| } | |
| } | |
| incr len -1 | |
| if {$allmatch} break | |
| } | |
| set f [string range $t0 0 $len] | |
| } | |
| if {$data(-multiple)} { | |
| set f [list $f] | |
| } | |
| $data(ent) delete 0 end | |
| $data(ent) insert 0 $f | |
| return -code break | |
| } | |