Wishkit.app/0040755000000000000240000000000010153113671012105 5ustar rootstaffWishkit.app/Contents/0040755000000000000240000000000010153074464013710 5ustar rootstaffWishkit.app/Contents/Frameworks/0040755000000000000240000000000010153074451016024 5ustar rootstaffWishkit.app/Contents/Frameworks/Tcl.framework/0040755000000000000240000000000010153074464020546 5ustar rootstaffWishkit.app/Contents/Frameworks/Tcl.framework/Resources0120755000000000000240000000000010153113663027555 2Versions/Current/Resourcesustar rootstaffWishkit.app/Contents/Frameworks/Tcl.framework/Tcl0120755000000000000240000000000010153113663025075 2Versions/Current/Tclustar rootstaffWishkit.app/Contents/Frameworks/Tcl.framework/Versions/0040755000000000000240000000000010153074415022352 5ustar rootstaffWishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/0040755000000000000240000000000010153114231022652 5ustar rootstaffWishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/0040755000000000000240000000000010153074415024635 5ustar rootstaffWishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Info.plist0100644000000000001200000000167110153074415026571 0ustar rootadmin CFBundleDevelopmentRegion English CFBundleExecutable Tcl CFBundleGetInfoString Tcl Library 8.4, Copyright © 2004 Tcl Core Team. MacOS X Port by Jim Ingham <jingham@apple.com> & Ian Reid, Copyright © 2001-2002, Apple Computer, Inc. CFBundleIdentifier com.tcltk.tcllibrary CFBundleInfoDictionaryVersion 6.0 CFBundleName Tcl Library 8.4 CFBundlePackageType FMWK CFBundleShortVersionString 8.4.8 CFBundleSignature Tcl CFBundleVersion 8.4.8 Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/0040755000000000000240000000000010153074464026270 5ustar rootstaffWishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/auto.tcl0100644000000000001200000005003210146430441027714 0ustar rootadmin# auto.tcl -- # # utility procs formerly in init.tcl dealing with auto execution # of commands and can be auto loaded themselves. # # RCS: @(#) $Id: auto.tcl,v 1.12.2.1 2004/11/16 16:56:01 dgp Exp $ # # Copyright (c) 1991-1993 The Regents of the University of California. # 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. # # auto_reset -- # # Destroy all cached information for auto-loading and auto-execution, # so that the information gets recomputed the next time it's needed. # Also delete any procedures that are listed in the auto-load index # except those defined in this file. # # Arguments: # None. proc auto_reset {} { global auto_execs auto_index auto_oldpath foreach p [info procs] { if {[info exists auto_index($p)] && ![string match auto_* $p] && ([lsearch -exact {unknown pkg_mkIndex tclPkgSetup tcl_findLibrary pkg_compareExtension tclPkgUnknown tcl::MacOSXPkgUnknown tcl::MacPkgUnknown} $p] < 0)} { rename $p {} } } catch {unset auto_execs} catch {unset auto_index} catch {unset auto_oldpath} } # tcl_findLibrary -- # # This is a utility for extensions that searches for a library directory # using a canonical searching algorithm. A side effect is to source # the initialization script and set a global library variable. # # Arguments: # basename Prefix of the directory name, (e.g., "tk") # version Version number of the package, (e.g., "8.0") # patch Patchlevel of the package, (e.g., "8.0.3") # initScript Initialization script to source (e.g., tk.tcl) # enVarName environment variable to honor (e.g., TK_LIBRARY) # varName Global variable to set when done (e.g., tk_library) proc tcl_findLibrary {basename version patch initScript enVarName varName} { upvar #0 $varName the_library global env errorInfo set dirs {} set errors {} # The C application may have hardwired a path, which we honor set variableSet [info exists the_library] if {$variableSet && $the_library ne ""} { lappend dirs $the_library } else { # Do the canonical search # 1. From an environment variable, if it exists. # Placing this first gives the end-user ultimate control # to work-around any bugs, or to customize. if {[info exists env($enVarName)]} { lappend dirs $env($enVarName) } # 2. In the package script directory registered within # the configuration of the package itself. # # Only do this for Tcl 8.5+, when Tcl_RegsiterConfig() is available. #if {[catch { # ::${basename}::pkgconfig get scriptdir,runtime #} value] == 0} { # lappend dirs $value #} # 3. Relative to auto_path directories. This checks relative to the # Tcl library as well as allowing loading of libraries added to the # auto_path that is not relative to the core library or binary paths. foreach d $::auto_path { lappend dirs [file join $d $basename$version] if {$::tcl_platform(platform) eq "unix" && $::tcl_platform(os) eq "Darwin"} { # 4. On MacOSX, check the Resources/Scripts subdir too lappend dirs [file join $d $basename$version Resources Scripts] } } # 3. Various locations relative to the executable # ../lib/foo1.0 (From bin directory in install hierarchy) # ../../lib/foo1.0 (From bin/arch directory in install hierarchy) # ../library (From unix directory in build hierarchy) set parentDir [file dirname [file dirname [info nameofexecutable]]] set grandParentDir [file dirname $parentDir] lappend dirs [file join $parentDir lib $basename$version] lappend dirs [file join $grandParentDir lib $basename$version] lappend dirs [file join $parentDir library] # Remaining locations are out of date (when relevant, they ought # to be covered by the $::auto_path seach above). # # ../../library (From unix/arch directory in build hierarchy) # ../../foo1.0.1/library # (From unix directory in parallel build hierarchy) # ../../../foo1.0.1/library # (From unix/arch directory in parallel build hierarchy) # # For the sake of extra compatibility safety, we keep adding these # paths during the 8.4.* release series. if {1} { lappend dirs [file join $grandParentDir library] lappend dirs [file join $grandParentDir $basename$patch library] lappend dirs [file join [file dirname $grandParentDir] \ $basename$patch library] } } # uniquify $dirs in order array set seen {} foreach i $dirs { if {[interp issafe]} { set norm $i } else { set norm [file normalize $i] } if {[info exists seen($norm)]} { continue } set seen($norm) "" lappend uniqdirs $norm } set dirs $uniqdirs foreach i $dirs { set the_library $i set file [file join $i $initScript] # source everything when in a safe interpreter because # we have a source command, but no file exists command if {[interp issafe] || [file exists $file]} { if {![catch {uplevel #0 [list source $file]} msg]} { return } else { append errors "$file: $msg\n$errorInfo\n" } } } if {!$variableSet} { unset the_library } set msg "Can't find a usable $initScript in the following directories: \n" append msg " $dirs\n\n" append msg "$errors\n\n" append msg "This probably means that $basename wasn't installed properly.\n" error $msg } # ---------------------------------------------------------------------- # auto_mkindex # ---------------------------------------------------------------------- # The following procedures are used to generate the tclIndex file # from Tcl source files. They use a special safe interpreter to # parse Tcl source files, writing out index entries as "proc" # commands are encountered. This implementation won't work in a # safe interpreter, since a safe interpreter can't create the # special parser and mess with its commands. if {[interp issafe]} { return ;# Stop sourcing the file here } # auto_mkindex -- # Regenerate a tclIndex file from Tcl source files. Takes as argument # the name of the directory in which the tclIndex file is to be placed, # followed by any number of glob patterns to use in that directory to # locate all of the relevant files. # # Arguments: # dir - Name of the directory in which to create an index. # args - Any number of additional arguments giving the # names of files within dir. If no additional # are given auto_mkindex will look for *.tcl. proc auto_mkindex {dir args} { global errorCode errorInfo if {[interp issafe]} { error "can't generate index within safe interpreter" } set oldDir [pwd] cd $dir set dir [pwd] append index "# Tcl autoload index file, version 2.0\n" append index "# This file is generated by the \"auto_mkindex\" command\n" append index "# and sourced to set up indexing information for one or\n" append index "# more commands. Typically each line is a command that\n" append index "# sets an element in the auto_index array, where the\n" append index "# element name is the name of a command and the value is\n" append index "# a script that loads the command.\n\n" if {$args == ""} { set args *.tcl } auto_mkindex_parser::init foreach file [eval glob $args] { if {[catch {auto_mkindex_parser::mkindex $file} msg] == 0} { append index $msg } else { set code $errorCode set info $errorInfo cd $oldDir error $msg $info $code } } auto_mkindex_parser::cleanup set fid [open "tclIndex" w] puts -nonewline $fid $index close $fid cd $oldDir } # Original version of auto_mkindex that just searches the source # code for "proc" at the beginning of the line. proc auto_mkindex_old {dir args} { global errorCode errorInfo set oldDir [pwd] cd $dir set dir [pwd] append index "# Tcl autoload index file, version 2.0\n" append index "# This file is generated by the \"auto_mkindex\" command\n" append index "# and sourced to set up indexing information for one or\n" append index "# more commands. Typically each line is a command that\n" append index "# sets an element in the auto_index array, where the\n" append index "# element name is the name of a command and the value is\n" append index "# a script that loads the command.\n\n" if {[string equal $args ""]} { set args *.tcl } foreach file [eval glob $args] { set f "" set error [catch { set f [open $file] while {[gets $f line] >= 0} { if {[regexp {^proc[ ]+([^ ]*)} $line match procName]} { set procName [lindex [auto_qualify $procName "::"] 0] append index "set [list auto_index($procName)]" append index " \[list source \[file join \$dir [list $file]\]\]\n" } } close $f } msg] if {$error} { set code $errorCode set info $errorInfo catch {close $f} cd $oldDir error $msg $info $code } } set f "" set error [catch { set f [open tclIndex w] puts -nonewline $f $index close $f cd $oldDir } msg] if {$error} { set code $errorCode set info $errorInfo catch {close $f} cd $oldDir error $msg $info $code } } # Create a safe interpreter that can be used to parse Tcl source files # generate a tclIndex file for autoloading. This interp contains # commands for things that need index entries. Each time a command # is executed, it writes an entry out to the index file. namespace eval auto_mkindex_parser { variable parser "" ;# parser used to build index variable index "" ;# maintains index as it is built variable scriptFile "" ;# name of file being processed variable contextStack "" ;# stack of namespace scopes variable imports "" ;# keeps track of all imported cmds variable initCommands "" ;# list of commands that create aliases proc init {} { variable parser variable initCommands if {![interp issafe]} { set parser [interp create -safe] $parser hide info $parser hide rename $parser hide proc $parser hide namespace $parser hide eval $parser hide puts $parser invokehidden namespace delete :: $parser invokehidden proc unknown {args} {} # We'll need access to the "namespace" command within the # interp. Put it back, but move it out of the way. $parser expose namespace $parser invokehidden rename namespace _%@namespace $parser expose eval $parser invokehidden rename eval _%@eval # Install all the registered psuedo-command implementations foreach cmd $initCommands { eval $cmd } } } proc cleanup {} { variable parser interp delete $parser unset parser } } # auto_mkindex_parser::mkindex -- # # Used by the "auto_mkindex" command to create a "tclIndex" file for # the given Tcl source file. Executes the commands in the file, and # handles things like the "proc" command by adding an entry for the # index file. Returns a string that represents the index file. # # Arguments: # file Name of Tcl source file to be indexed. proc auto_mkindex_parser::mkindex {file} { variable parser variable index variable scriptFile variable contextStack variable imports set scriptFile $file set fid [open $file] set contents [read $fid] close $fid # There is one problem with sourcing files into the safe # interpreter: references like "$x" will fail since code is not # really being executed and variables do not really exist. # To avoid this, we replace all $ with \0 (literally, the null char) # later, when getting proc names we will have to reverse this replacement, # in case there were any $ in the proc name. This will cause a problem # if somebody actually tries to have a \0 in their proc name. Too bad # for them. regsub -all {\$} $contents "\0" contents set index "" set contextStack "" set imports "" $parser eval $contents foreach name $imports { catch {$parser eval [list _%@namespace forget $name]} } return $index } # auto_mkindex_parser::hook command # # Registers a Tcl command to evaluate when initializing the # slave interpreter used by the mkindex parser. # The command is evaluated in the master interpreter, and can # use the variable auto_mkindex_parser::parser to get to the slave proc auto_mkindex_parser::hook {cmd} { variable initCommands lappend initCommands $cmd } # auto_mkindex_parser::slavehook command # # Registers a Tcl command to evaluate when initializing the # slave interpreter used by the mkindex parser. # The command is evaluated in the slave interpreter. proc auto_mkindex_parser::slavehook {cmd} { variable initCommands # The $parser variable is defined to be the name of the # slave interpreter when this command is used later. lappend initCommands "\$parser eval [list $cmd]" } # auto_mkindex_parser::command -- # # Registers a new command with the "auto_mkindex_parser" interpreter # that parses Tcl files. These commands are fake versions of things # like the "proc" command. When you execute them, they simply write # out an entry to a "tclIndex" file for auto-loading. # # This procedure allows extensions to register their own commands # with the auto_mkindex facility. For example, a package like # [incr Tcl] might register a "class" command so that class definitions # could be added to a "tclIndex" file for auto-loading. # # Arguments: # name Name of command recognized in Tcl files. # arglist Argument list for command. # body Implementation of command to handle indexing. proc auto_mkindex_parser::command {name arglist body} { hook [list auto_mkindex_parser::commandInit $name $arglist $body] } # auto_mkindex_parser::commandInit -- # # This does the actual work set up by auto_mkindex_parser::command # This is called when the interpreter used by the parser is created. # # Arguments: # name Name of command recognized in Tcl files. # arglist Argument list for command. # body Implementation of command to handle indexing. proc auto_mkindex_parser::commandInit {name arglist body} { variable parser set ns [namespace qualifiers $name] set tail [namespace tail $name] if {[string equal $ns ""]} { set fakeName "[namespace current]::_%@fake_$tail" } else { set fakeName "_%@fake_$name" regsub -all {::} $fakeName "_" fakeName set fakeName "[namespace current]::$fakeName" } proc $fakeName $arglist $body # YUK! Tcl won't let us alias fully qualified command names, # so we can't handle names like "::itcl::class". Instead, # we have to build procs with the fully qualified names, and # have the procs point to the aliases. if {[regexp {::} $name]} { set exportCmd [list _%@namespace export [namespace tail $name]] $parser eval [list _%@namespace eval $ns $exportCmd] # The following proc definition does not work if you # want to tolerate space or something else diabolical # in the procedure name, (i.e., space in $alias) # The following does not work: # "_%@eval {$alias} \$args" # because $alias gets concat'ed to $args. # The following does not work because $cmd is somehow undefined # "set cmd {$alias} \; _%@eval {\$cmd} \$args" # A gold star to someone that can make test # autoMkindex-3.3 work properly set alias [namespace tail $fakeName] $parser invokehidden proc $name {args} "_%@eval {$alias} \$args" $parser alias $alias $fakeName } else { $parser alias $name $fakeName } return } # auto_mkindex_parser::fullname -- # Used by commands like "proc" within the auto_mkindex parser. # Returns the qualified namespace name for the "name" argument. # If the "name" does not start with "::", elements are added from # the current namespace stack to produce a qualified name. Then, # the name is examined to see whether or not it should really be # qualified. If the name has more than the leading "::", it is # returned as a fully qualified name. Otherwise, it is returned # as a simple name. That way, the Tcl autoloader will recognize # it properly. # # Arguments: # name - Name that is being added to index. proc auto_mkindex_parser::fullname {name} { variable contextStack if {![string match ::* $name]} { foreach ns $contextStack { set name "${ns}::$name" if {[string match ::* $name]} { break } } } if {[string equal [namespace qualifiers $name] ""]} { set name [namespace tail $name] } elseif {![string match ::* $name]} { set name "::$name" } # Earlier, mkindex replaced all $'s with \0. Now, we have to reverse # that replacement. regsub -all "\0" $name "\$" name return $name } # Register all of the procedures for the auto_mkindex parser that # will build the "tclIndex" file. # AUTO MKINDEX: proc name arglist body # Adds an entry to the auto index list for the given procedure name. auto_mkindex_parser::command proc {name args} { variable index variable scriptFile # Do some fancy reformatting on the "source" call to handle platform # differences with respect to pathnames. Use format just so that the # command is a little easier to read (otherwise it'd be full of # backslashed dollar signs, etc. append index [list set auto_index([fullname $name])] \ [format { [list source [file join $dir %s]]} \ [file split $scriptFile]] "\n" } # Conditionally add support for Tcl byte code files. There are some # tricky details here. First, we need to get the tbcload library # initialized in the current interpreter. We cannot load tbcload into the # slave until we have done so because it needs access to the tcl_patchLevel # variable. Second, because the package index file may defer loading the # library until we invoke a command, we need to explicitly invoke auto_load # to force it to be loaded. This should be a noop if the package has # already been loaded auto_mkindex_parser::hook { if {![catch {package require tbcload}]} { if {[llength [info commands tbcload::bcproc]] == 0} { auto_load tbcload::bcproc } load {} tbcload $auto_mkindex_parser::parser # AUTO MKINDEX: tbcload::bcproc name arglist body # Adds an entry to the auto index list for the given pre-compiled # procedure name. auto_mkindex_parser::commandInit tbcload::bcproc {name args} { variable index variable scriptFile # Do some nice reformatting of the "source" call, to get around # path differences on different platforms. We use the format # command just so that the code is a little easier to read. append index [list set auto_index([fullname $name])] \ [format { [list source [file join $dir %s]]} \ [file split $scriptFile]] "\n" } } } # AUTO MKINDEX: namespace eval name command ?arg arg...? # Adds the namespace name onto the context stack and evaluates the # associated body of commands. # # AUTO MKINDEX: namespace import ?-force? pattern ?pattern...? # Performs the "import" action in the parser interpreter. This is # important for any commands contained in a namespace that affect # the index. For example, a script may say "itcl::class ...", # or it may import "itcl::*" and then say "class ...". This # procedure does the import operation, but keeps track of imported # patterns so we can remove the imports later. auto_mkindex_parser::command namespace {op args} { switch -- $op { eval { variable parser variable contextStack set name [lindex $args 0] set args [lrange $args 1 end] set contextStack [linsert $contextStack 0 $name] $parser eval [list _%@namespace eval $name] $args set contextStack [lrange $contextStack 1 end] } import { variable parser variable imports foreach pattern $args { if {[string compare $pattern "-force"]} { lappend imports $pattern } } catch {$parser eval "_%@namespace import $args"} } } } return Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/encoding/0040755000000000000240000000000010153074464030056 5ustar rootstaffWishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/encoding/ascii.enc0100644000000000001200000000210206705504201031602 0ustar rootadmin# Encoding file: ascii, single-byte S 003F 0 1 00 0000000100020003000400050006000700080009000A000B000C000D000E000F 0010001100120013001400150016001700180019001A001B001C001D001E001F 0020002100220023002400250026002700280029002A002B002C002D002E002F 0030003100320033003400350036003700380039003A003B003C003D003E003F 0040004100420043004400450046004700480049004A004B004C004D004E004F 0050005100520053005400550056005700580059005A005B005C005D005E005F 0060006100620063006400650066006700680069006A006B006C006D006E006F 0070007100720073007400750076007700780079007A007B007C007D007E0000 0000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000 Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/encoding/cp1252.enc0100644000000000001200000000210307303043126031426 0ustar rootadmin# Encoding file: cp1252, single-byte S 003F 0 1 00 0000000100020003000400050006000700080009000A000B000C000D000E000F 0010001100120013001400150016001700180019001A001B001C001D001E001F 0020002100220023002400250026002700280029002A002B002C002D002E002F 0030003100320033003400350036003700380039003A003B003C003D003E003F 0040004100420043004400450046004700480049004A004B004C004D004E004F 0050005100520053005400550056005700580059005A005B005C005D005E005F 0060006100620063006400650066006700680069006A006B006C006D006E006F 0070007100720073007400750076007700780079007A007B007C007D007E007F 20AC0081201A0192201E20262020202102C62030016020390152008D017D008F 009020182019201C201D20222013201402DC21220161203A0153009D017E0178 00A000A100A200A300A400A500A600A700A800A900AA00AB00AC00AD00AE00AF 00B000B100B200B300B400B500B600B700B800B900BA00BB00BC00BD00BE00BF 00C000C100C200C300C400C500C600C700C800C900CA00CB00CC00CD00CE00CF 00D000D100D200D300D400D500D600D700D800D900DA00DB00DC00DD00DE00DF 00E000E100E200E300E400E500E600E700E800E900EA00EB00EC00ED00EE00EF 00F000F100F200F300F400F500F600F700F800F900FA00FB00FC00FD00FE00FF Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/encoding/iso8859-1.enc0100644000000000001200000000210606705504215032011 0ustar rootadmin# Encoding file: iso8859-1, single-byte S 003F 0 1 00 0000000100020003000400050006000700080009000A000B000C000D000E000F 0010001100120013001400150016001700180019001A001B001C001D001E001F 0020002100220023002400250026002700280029002A002B002C002D002E002F 0030003100320033003400350036003700380039003A003B003C003D003E003F 0040004100420043004400450046004700480049004A004B004C004D004E004F 0050005100520053005400550056005700580059005A005B005C005D005E005F 0060006100620063006400650066006700680069006A006B006C006D006E006F 0070007100720073007400750076007700780079007A007B007C007D007E007F 0080008100820083008400850086008700880089008A008B008C008D008E008F 0090009100920093009400950096009700980099009A009B009C009D009E009F 00A000A100A200A300A400A500A600A700A800A900AA00AB00AC00AD00AE00AF 00B000B100B200B300B400B500B600B700B800B900BA00BB00BC00BD00BE00BF 00C000C100C200C300C400C500C600C700C800C900CA00CB00CC00CD00CE00CF 00D000D100D200D300D400D500D600D700D800D900DA00DB00DC00DD00DE00DF 00E000E100E200E300E400E500E600E700E800E900EA00EB00EC00ED00EE00EF 00F000F100F200F300F400F500F600F700F800F900FA00FB00FC00FD00FE00FF ././@LongLink0000000000000000000000000000014500000000000011706 Lustar rootwheelWishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/encoding/iso8859-15.encWishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/encoding/iso8859-15.en0100644000000000001200000000210707271563407031743 0ustar rootadmin# Encoding file: iso8859-15, single-byte S 003F 0 1 00 0000000100020003000400050006000700080009000A000B000C000D000E000F 0010001100120013001400150016001700180019001A001B001C001D001E001F 0020002100220023002400250026002700280029002A002B002C002D002E002F 0030003100320033003400350036003700380039003A003B003C003D003E003F 0040004100420043004400450046004700480049004A004B004C004D004E004F 0050005100520053005400550056005700580059005A005B005C005D005E005F 0060006100620063006400650066006700680069006A006B006C006D006E006F 0070007100720073007400750076007700780079007A007B007C007D007E007F 0080008100820083008400850086008700880089008A008B008C008D008E008F 0090009100920093009400950096009700980099009A009B009C009D009E009F 00A000A100A200A320AC00A5016000A7016100A900AA00AB00AC00AD00AE00AF 00B000B100B200B3017D00B500B600B7017E00B900BA00BB01520153017800BF 00C000C100C200C300C400C500C600C700C800C900CA00CB00CC00CD00CE00CF 00D000D100D200D300D400D500D600D700D800D900DA00DB00DC00DD00DE00DF 00E000E100E200E300E400E500E600E700E800E900EA00EB00EC00ED00EE00EF 00F000F100F200F300F400F500F600F700F800F900FA00FB00FC00FD00FE00FF Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/encoding/iso8859-2.enc0100644000000000001200000000210606705504215032012 0ustar rootadmin# Encoding file: iso8859-2, single-byte S 003F 0 1 00 0000000100020003000400050006000700080009000A000B000C000D000E000F 0010001100120013001400150016001700180019001A001B001C001D001E001F 0020002100220023002400250026002700280029002A002B002C002D002E002F 0030003100320033003400350036003700380039003A003B003C003D003E003F 0040004100420043004400450046004700480049004A004B004C004D004E004F 0050005100520053005400550056005700580059005A005B005C005D005E005F 0060006100620063006400650066006700680069006A006B006C006D006E006F 0070007100720073007400750076007700780079007A007B007C007D007E007F 0080008100820083008400850086008700880089008A008B008C008D008E008F 0090009100920093009400950096009700980099009A009B009C009D009E009F 00A0010402D8014100A4013D015A00A700A80160015E0164017900AD017D017B 00B0010502DB014200B4013E015B02C700B80161015F0165017A02DD017E017C 015400C100C2010200C40139010600C7010C00C9011800CB011A00CD00CE010E 01100143014700D300D4015000D600D70158016E00DA017000DC00DD016200DF 015500E100E2010300E4013A010700E7010D00E9011900EB011B00ED00EE010F 01110144014800F300F4015100F600F70159016F00FA017100FC00FD016302D9 Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/encoding/macRoman.enc0100644000000000001200000000210507357142515032264 0ustar rootadmin# Encoding file: macRoman, single-byte S 003F 0 1 00 0000000100020003000400050006000700080009000A000B000C000D000E000F 0010001100120013001400150016001700180019001A001B001C001D001E001F 0020002100220023002400250026002700280029002A002B002C002D002E002F 0030003100320033003400350036003700380039003A003B003C003D003E003F 0040004100420043004400450046004700480049004A004B004C004D004E004F 0050005100520053005400550056005700580059005A005B005C005D005E005F 0060006100620063006400650066006700680069006A006B006C006D006E006F 0070007100720073007400750076007700780079007A007B007C007D007E007F 00C400C500C700C900D100D600DC00E100E000E200E400E300E500E700E900E8 00EA00EB00ED00EC00EE00EF00F100F300F200F400F600F500FA00F900FB00FC 202000B000A200A300A7202200B600DF00AE00A9212200B400A8226000C600D8 221E00B12264226500A500B522022211220F03C0222B00AA00BA03A900E600F8 00BF00A100AC221A01922248220600AB00BB202600A000C000C300D501520153 20132014201C201D2018201900F725CA00FF0178204420AC2039203AFB01FB02 202100B7201A201E203000C200CA00C100CB00C800CD00CE00CF00CC00D300D4 F8FF00D200DA00DB00D9013102C602DC00AF02D802D902DA00B802DD02DB02C7 Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/history.tcl0100644000000000001200000002162407300704560030456 0ustar rootadmin# history.tcl -- # # Implementation of the history command. # # RCS: @(#) $Id: history.tcl,v 1.5 2001/05/17 08:18:56 hobbs Exp $ # # Copyright (c) 1997 Sun Microsystems, Inc. # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # # The tcl::history array holds the history list and # some additional bookkeeping variables. # # nextid the index used for the next history list item. # keep the max size of the history list # oldest the index of the oldest item in the history. namespace eval tcl { variable history if {![info exists history]} { array set history { nextid 0 keep 20 oldest -20 } } } # history -- # # This is the main history command. See the man page for its interface. # This does argument checking and calls helper procedures in the # history namespace. proc history {args} { set len [llength $args] if {$len == 0} { return [tcl::HistInfo] } set key [lindex $args 0] set options "add, change, clear, event, info, keep, nextid, or redo" switch -glob -- $key { a* { # history add if {$len > 3} { return -code error "wrong # args: should be \"history add event ?exec?\"" } if {![string match $key* add]} { return -code error "bad option \"$key\": must be $options" } if {$len == 3} { set arg [lindex $args 2] if {! ([string match e* $arg] && [string match $arg* exec])} { return -code error "bad argument \"$arg\": should be \"exec\"" } } return [tcl::HistAdd [lindex $args 1] [lindex $args 2]] } ch* { # history change if {($len > 3) || ($len < 2)} { return -code error "wrong # args: should be \"history change newValue ?event?\"" } if {![string match $key* change]} { return -code error "bad option \"$key\": must be $options" } if {$len == 2} { set event 0 } else { set event [lindex $args 2] } return [tcl::HistChange [lindex $args 1] $event] } cl* { # history clear if {($len > 1)} { return -code error "wrong # args: should be \"history clear\"" } if {![string match $key* clear]} { return -code error "bad option \"$key\": must be $options" } return [tcl::HistClear] } e* { # history event if {$len > 2} { return -code error "wrong # args: should be \"history event ?event?\"" } if {![string match $key* event]} { return -code error "bad option \"$key\": must be $options" } if {$len == 1} { set event -1 } else { set event [lindex $args 1] } return [tcl::HistEvent $event] } i* { # history info if {$len > 2} { return -code error "wrong # args: should be \"history info ?count?\"" } if {![string match $key* info]} { return -code error "bad option \"$key\": must be $options" } return [tcl::HistInfo [lindex $args 1]] } k* { # history keep if {$len > 2} { return -code error "wrong # args: should be \"history keep ?count?\"" } if {$len == 1} { return [tcl::HistKeep] } else { set limit [lindex $args 1] if {[catch {expr {~$limit}}] || ($limit < 0)} { return -code error "illegal keep count \"$limit\"" } return [tcl::HistKeep $limit] } } n* { # history nextid if {$len > 1} { return -code error "wrong # args: should be \"history nextid\"" } if {![string match $key* nextid]} { return -code error "bad option \"$key\": must be $options" } return [expr {$tcl::history(nextid) + 1}] } r* { # history redo if {$len > 2} { return -code error "wrong # args: should be \"history redo ?event?\"" } if {![string match $key* redo]} { return -code error "bad option \"$key\": must be $options" } return [tcl::HistRedo [lindex $args 1]] } default { return -code error "bad option \"$key\": must be $options" } } } # tcl::HistAdd -- # # Add an item to the history, and optionally eval it at the global scope # # Parameters: # command the command to add # exec (optional) a substring of "exec" causes the # command to be evaled. # Results: # If executing, then the results of the command are returned # # Side Effects: # Adds to the history list proc tcl::HistAdd {command {exec {}}} { variable history # Do not add empty commands to the history if {[string trim $command] == ""} { return "" } set i [incr history(nextid)] set history($i) $command set j [incr history(oldest)] if {[info exists history($j)]} {unset history($j)} if {[string match e* $exec]} { return [uplevel #0 $command] } else { return {} } } # tcl::HistKeep -- # # Set or query the limit on the length of the history list # # Parameters: # limit (optional) the length of the history list # # Results: # If no limit is specified, the current limit is returned # # Side Effects: # Updates history(keep) if a limit is specified proc tcl::HistKeep {{limit {}}} { variable history if {[string length $limit] == 0} { return $history(keep) } else { set oldold $history(oldest) set history(oldest) [expr {$history(nextid) - $limit}] for {} {$oldold <= $history(oldest)} {incr oldold} { if {[info exists history($oldold)]} {unset history($oldold)} } set history(keep) $limit } } # tcl::HistClear -- # # Erase the history list # # Parameters: # none # # Results: # none # # Side Effects: # Resets the history array, except for the keep limit proc tcl::HistClear {} { variable history set keep $history(keep) unset history array set history [list \ nextid 0 \ keep $keep \ oldest -$keep \ ] } # tcl::HistInfo -- # # Return a pretty-printed version of the history list # # Parameters: # num (optional) the length of the history list to return # # Results: # A formatted history list proc tcl::HistInfo {{num {}}} { variable history if {$num == {}} { set num [expr {$history(keep) + 1}] } set result {} set newline "" for {set i [expr {$history(nextid) - $num + 1}]} \ {$i <= $history(nextid)} {incr i} { if {![info exists history($i)]} { continue } set cmd [string trimright $history($i) \ \n] regsub -all \n $cmd "\n\t" cmd append result $newline[format "%6d %s" $i $cmd] set newline \n } return $result } # tcl::HistRedo -- # # Fetch the previous or specified event, execute it, and then # replace the current history item with that event. # # Parameters: # event (optional) index of history item to redo. Defaults to -1, # which means the previous event. # # Results: # Those of the command being redone. # # Side Effects: # Replaces the current history list item with the one being redone. proc tcl::HistRedo {{event -1}} { variable history if {[string length $event] == 0} { set event -1 } set i [HistIndex $event] if {$i == $history(nextid)} { return -code error "cannot redo the current event" } set cmd $history($i) HistChange $cmd 0 uplevel #0 $cmd } # tcl::HistIndex -- # # Map from an event specifier to an index in the history list. # # Parameters: # event index of history item to redo. # If this is a positive number, it is used directly. # If it is a negative number, then it counts back to a previous # event, where -1 is the most recent event. # A string can be matched, either by being the prefix of # a command or by matching a command with string match. # # Results: # The index into history, or an error if the index didn't match. proc tcl::HistIndex {event} { variable history if {[catch {expr {~$event}}]} { for {set i [expr {$history(nextid)-1}]} {[info exists history($i)]} \ {incr i -1} { if {[string match $event* $history($i)]} { return $i; } if {[string match $event $history($i)]} { return $i; } } return -code error "no event matches \"$event\"" } elseif {$event <= 0} { set i [expr {$history(nextid) + $event}] } else { set i $event } if {$i <= $history(oldest)} { return -code error "event \"$event\" is too far in the past" } if {$i > $history(nextid)} { return -code error "event \"$event\" hasn't occured yet" } return $i } # tcl::HistEvent -- # # Map from an event specifier to the value in the history list. # # Parameters: # event index of history item to redo. See index for a # description of possible event patterns. # # Results: # The value from the history list. proc tcl::HistEvent {event} { variable history set i [HistIndex $event] if {[info exists history($i)]} { return [string trimright $history($i) \ \n] } else { return ""; } } # tcl::HistChange -- # # Replace a value in the history list. # # Parameters: # cmd The new value to put into the history list. # event (optional) index of history item to redo. See index for a # description of possible event patterns. This defaults # to 0, which specifies the current event. # # Side Effects: # Changes the history list. proc tcl::HistChange {cmd {event 0}} { variable history set i [HistIndex $event] set history($i) $cmd } Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/http2.5/0040755000000000000240000000000010153074405027467 5ustar rootstaffWishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/http2.5/http.tcl0100644000000000001200000005665410054746707031164 0ustar rootadmin# http.tcl -- # # Client-side HTTP for GET, POST, and HEAD commands. # These routines can be used in untrusted code that uses # the Safesock security policy. These procedures use a # callback interface to avoid using vwait, which is not # defined in the safe base. # # See the file "license.terms" for information on usage and # redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES. # # RCS: @(#) $Id: http.tcl,v 1.43.2.4 2004/05/25 22:50:47 hobbs Exp $ # Rough version history: # 1.0 Old http_get interface # 2.0 http:: namespace and http::geturl # 2.1 Added callbacks to handle arriving data, and timeouts # 2.2 Added ability to fetch into a channel # 2.3 Added SSL support, and ability to post from a channel # This version also cleans up error cases and eliminates the # "ioerror" status in favor of raising an error # 2.4 Added -binary option to http::geturl and charset element # to the state array. package require Tcl 8.2 # keep this in sync with pkgIndex.tcl # and with the install directories in Makefiles package provide http 2.5.0 namespace eval http { variable http array set http { -accept */* -proxyhost {} -proxyport {} -proxyfilter http::ProxyRequired -urlencoding utf-8 } set http(-useragent) "Tcl http client package [package provide http]" proc init {} { variable formMap variable alphanumeric a-zA-Z0-9 for {set i 0} {$i <= 256} {incr i} { set c [format %c $i] if {![string match \[$alphanumeric\] $c]} { set formMap($c) %[format %.2x $i] } } # These are handled specially array set formMap { " " + \n %0d%0a } } init variable urlTypes array set urlTypes { http {80 ::socket} } variable encodings [string tolower [encoding names]] # This can be changed, but iso8859-1 is the RFC standard. variable defaultCharset "iso8859-1" namespace export geturl config reset wait formatQuery register unregister # Useful, but not exported: data size status code } # http::register -- # # See documentaion for details. # # Arguments: # proto URL protocol prefix, e.g. https # port Default port for protocol # command Command to use to create socket # Results: # list of port and command that was registered. proc http::register {proto port command} { variable urlTypes set urlTypes($proto) [list $port $command] } # http::unregister -- # # Unregisters URL protocol handler # # Arguments: # proto URL protocol prefix, e.g. https # Results: # list of port and command that was unregistered. proc http::unregister {proto} { variable urlTypes if {![info exists urlTypes($proto)]} { return -code error "unsupported url type \"$proto\"" } set old $urlTypes($proto) unset urlTypes($proto) return $old } # http::config -- # # See documentaion for details. # # Arguments: # args Options parsed by the procedure. # Results: # TODO proc http::config {args} { variable http set options [lsort [array names http -*]] set usage [join $options ", "] if {[llength $args] == 0} { set result {} foreach name $options { lappend result $name $http($name) } return $result } set options [string map {- ""} $options] set pat ^-([join $options |])$ if {[llength $args] == 1} { set flag [lindex $args 0] if {[regexp -- $pat $flag]} { return $http($flag) } else { return -code error "Unknown option $flag, must be: $usage" } } else { foreach {flag value} $args { if {[regexp -- $pat $flag]} { set http($flag) $value } else { return -code error "Unknown option $flag, must be: $usage" } } } } # http::Finish -- # # Clean up the socket and eval close time callbacks # # Arguments: # token Connection token. # errormsg (optional) If set, forces status to error. # skipCB (optional) If set, don't call the -command callback. This # is useful when geturl wants to throw an exception instead # of calling the callback. That way, the same error isn't # reported to two places. # # Side Effects: # Closes the socket proc http::Finish { token {errormsg ""} {skipCB 0}} { variable $token upvar 0 $token state global errorInfo errorCode if {[string length $errormsg] != 0} { set state(error) [list $errormsg $errorInfo $errorCode] set state(status) error } catch {close $state(sock)} catch {after cancel $state(after)} if {[info exists state(-command)] && !$skipCB} { if {[catch {eval $state(-command) {$token}} err]} { if {[string length $errormsg] == 0} { set state(error) [list $err $errorInfo $errorCode] set state(status) error } } if {[info exists state(-command)]} { # Command callback may already have unset our state unset state(-command) } } } # http::reset -- # # See documentaion for details. # # Arguments: # token Connection token. # why Status info. # # Side Effects: # See Finish proc http::reset { token {why reset} } { variable $token upvar 0 $token state set state(status) $why catch {fileevent $state(sock) readable {}} catch {fileevent $state(sock) writable {}} Finish $token if {[info exists state(error)]} { set errorlist $state(error) unset state eval ::error $errorlist } } # http::geturl -- # # Establishes a connection to a remote url via http. # # Arguments: # url The http URL to goget. # args Option value pairs. Valid options include: # -blocksize, -validate, -headers, -timeout # Results: # Returns a token for this connection. # This token is the name of an array that the caller should # unset to garbage collect the state. proc http::geturl { url args } { variable http variable urlTypes variable defaultCharset # Initialize the state variable, an array. We'll return the # name of this array as the token for the transaction. if {![info exists http(uid)]} { set http(uid) 0 } set token [namespace current]::[incr http(uid)] variable $token upvar 0 $token state reset $token # Process command options. array set state { -binary false -blocksize 8192 -queryblocksize 8192 -validate 0 -headers {} -timeout 0 -type application/x-www-form-urlencoded -queryprogress {} state header meta {} coding {} currentsize 0 totalsize 0 querylength 0 queryoffset 0 type text/html body {} status "" http "" } # These flags have their types verified [Bug 811170] array set type { -binary boolean -blocksize integer -queryblocksize integer -validate boolean -timeout integer } set state(charset) $defaultCharset set options {-binary -blocksize -channel -command -handler -headers \ -progress -query -queryblocksize -querychannel -queryprogress\ -validate -timeout -type} set usage [join $options ", "] set options [string map {- ""} $options] set pat ^-([join $options |])$ foreach {flag value} $args { if {[regexp $pat $flag]} { # Validate numbers if {[info exists type($flag)] && \ ![string is $type($flag) -strict $value]} { unset $token return -code error "Bad value for $flag ($value), must be $type($flag)" } set state($flag) $value } else { unset $token return -code error "Unknown option $flag, can be: $usage" } } # Make sure -query and -querychannel aren't both specified set isQueryChannel [info exists state(-querychannel)] set isQuery [info exists state(-query)] if {$isQuery && $isQueryChannel} { unset $token return -code error "Can't combine -query and -querychannel options!" } # Validate URL, determine the server host and port, and check proxy case # Recognize user:pass@host URLs also, although we do not do anything # with that info yet. set exp {^(([^:]*)://)?([^@]+@)?([^/:]+)(:([0-9]+))?(/.*)?$} if {![regexp -nocase $exp $url x prefix proto user host y port srvurl]} { unset $token return -code error "Unsupported URL: $url" } if {[string length $proto] == 0} { set proto http set url ${proto}://$url } if {![info exists urlTypes($proto)]} { unset $token return -code error "Unsupported URL type \"$proto\"" } set defport [lindex $urlTypes($proto) 0] set defcmd [lindex $urlTypes($proto) 1] if {[string length $port] == 0} { set port $defport } if {[string length $srvurl] == 0} { set srvurl / } if {[string length $proto] == 0} { set url http://$url } set state(url) $url if {![catch {$http(-proxyfilter) $host} proxy]} { set phost [lindex $proxy 0] set pport [lindex $proxy 1] } # If a timeout is specified we set up the after event # and arrange for an asynchronous socket connection. if {$state(-timeout) > 0} { set state(after) [after $state(-timeout) \ [list http::reset $token timeout]] set async -async } else { set async "" } # If we are using the proxy, we must pass in the full URL that # includes the server name. if {[info exists phost] && [string length $phost]} { set srvurl $url set conStat [catch {eval $defcmd $async {$phost $pport}} s] } else { set conStat [catch {eval $defcmd $async {$host $port}} s] } if {$conStat} { # something went wrong while trying to establish the connection # Clean up after events and such, but DON'T call the command callback # (if available) because we're going to throw an exception from here # instead. Finish $token "" 1 cleanup $token return -code error $s } set state(sock) $s # Wait for the connection to complete if {$state(-timeout) > 0} { fileevent $s writable [list http::Connect $token] http::wait $token if {[string equal $state(status) "error"]} { # something went wrong while trying to establish the connection # Clean up after events and such, but DON'T call the command # callback (if available) because we're going to throw an # exception from here instead. set err [lindex $state(error) 0] cleanup $token return -code error $err } elseif {![string equal $state(status) "connect"]} { # Likely to be connection timeout return $token } set state(status) "" } # Send data in cr-lf format, but accept any line terminators fconfigure $s -translation {auto crlf} -buffersize $state(-blocksize) # The following is disallowed in safe interpreters, but the socket # is already in non-blocking mode in that case. catch {fconfigure $s -blocking off} set how GET if {$isQuery} { set state(querylength) [string length $state(-query)] if {$state(querylength) > 0} { set how POST set contDone 0 } else { # there's no query data unset state(-query) set isQuery 0 } } elseif {$state(-validate)} { set how HEAD } elseif {$isQueryChannel} { set how POST # The query channel must be blocking for the async Write to # work properly. fconfigure $state(-querychannel) -blocking 1 -translation binary set contDone 0 } if {[catch { puts $s "$how $srvurl HTTP/1.0" puts $s "Accept: $http(-accept)" if {$port == $defport} { # Don't add port in this case, to handle broken servers. # [Bug #504508] puts $s "Host: $host" } else { puts $s "Host: $host:$port" } puts $s "User-Agent: $http(-useragent)" foreach {key value} $state(-headers) { set value [string map [list \n "" \r ""] $value] set key [string trim $key] if {[string equal $key "Content-Length"]} { set contDone 1 set state(querylength) $value } if {[string length $key]} { puts $s "$key: $value" } } if {$isQueryChannel && $state(querylength) == 0} { # Try to determine size of data in channel # If we cannot seek, the surrounding catch will trap us set start [tell $state(-querychannel)] seek $state(-querychannel) 0 end set state(querylength) \ [expr {[tell $state(-querychannel)] - $start}] seek $state(-querychannel) $start } # Flush the request header and set up the fileevent that will # either push the POST data or read the response. # # fileevent note: # # It is possible to have both the read and write fileevents active # at this point. The only scenario it seems to affect is a server # that closes the connection without reading the POST data. # (e.g., early versions TclHttpd in various error cases). # Depending on the platform, the client may or may not be able to # get the response from the server because of the error it will # get trying to write the post data. Having both fileevents active # changes the timing and the behavior, but no two platforms # (among Solaris, Linux, and NT) behave the same, and none # behave all that well in any case. Servers should always read thier # POST data if they expect the client to read their response. if {$isQuery || $isQueryChannel} { puts $s "Content-Type: $state(-type)" if {!$contDone} { puts $s "Content-Length: $state(querylength)" } puts $s "" fconfigure $s -translation {auto binary} fileevent $s writable [list http::Write $token] } else { puts $s "" flush $s fileevent $s readable [list http::Event $token] } if {! [info exists state(-command)]} { # geturl does EVERYTHING asynchronously, so if the user # calls it synchronously, we just do a wait here. wait $token if {[string equal $state(status) "error"]} { # Something went wrong, so throw the exception, and the # enclosing catch will do cleanup. return -code error [lindex $state(error) 0] } } } err]} { # The socket probably was never connected, # or the connection dropped later. # Clean up after events and such, but DON'T call the command callback # (if available) because we're going to throw an exception from here # instead. # if state(status) is error, it means someone's already called Finish # to do the above-described clean up. if {[string equal $state(status) "error"]} { Finish $token $err 1 } cleanup $token return -code error $err } return $token } # Data access functions: # Data - the URL data # Status - the transaction status: ok, reset, eof, timeout # Code - the HTTP transaction code, e.g., 200 # Size - the size of the URL data proc http::data {token} { variable $token upvar 0 $token state return $state(body) } proc http::status {token} { variable $token upvar 0 $token state return $state(status) } proc http::code {token} { variable $token upvar 0 $token state return $state(http) } proc http::ncode {token} { variable $token upvar 0 $token state if {[regexp {[0-9]{3}} $state(http) numeric_code]} { return $numeric_code } else { return $state(http) } } proc http::size {token} { variable $token upvar 0 $token state return $state(currentsize) } proc http::error {token} { variable $token upvar 0 $token state if {[info exists state(error)]} { return $state(error) } return "" } # http::cleanup # # Garbage collect the state associated with a transaction # # Arguments # token The token returned from http::geturl # # Side Effects # unsets the state array proc http::cleanup {token} { variable $token upvar 0 $token state if {[info exists state]} { unset state } } # http::Connect # # This callback is made when an asyncronous connection completes. # # Arguments # token The token returned from http::geturl # # Side Effects # Sets the status of the connection, which unblocks # the waiting geturl call proc http::Connect {token} { variable $token upvar 0 $token state global errorInfo errorCode if {[eof $state(sock)] || [string length [fconfigure $state(sock) -error]]} { Finish $token "connect failed [fconfigure $state(sock) -error]" 1 } else { set state(status) connect fileevent $state(sock) writable {} } return } # http::Write # # Write POST query data to the socket # # Arguments # token The token for the connection # # Side Effects # Write the socket and handle callbacks. proc http::Write {token} { variable $token upvar 0 $token state set s $state(sock) # Output a block. Tcl will buffer this if the socket blocks set done 0 if {[catch { # Catch I/O errors on dead sockets if {[info exists state(-query)]} { # Chop up large query strings so queryprogress callback # can give smooth feedback puts -nonewline $s \ [string range $state(-query) $state(queryoffset) \ [expr {$state(queryoffset) + $state(-queryblocksize) - 1}]] incr state(queryoffset) $state(-queryblocksize) if {$state(queryoffset) >= $state(querylength)} { set state(queryoffset) $state(querylength) set done 1 } } else { # Copy blocks from the query channel set outStr [read $state(-querychannel) $state(-queryblocksize)] puts -nonewline $s $outStr incr state(queryoffset) [string length $outStr] if {[eof $state(-querychannel)]} { set done 1 } } } err]} { # Do not call Finish here, but instead let the read half of # the socket process whatever server reply there is to get. set state(posterror) $err set done 1 } if {$done} { catch {flush $s} fileevent $s writable {} fileevent $s readable [list http::Event $token] } # Callback to the client after we've completely handled everything if {[string length $state(-queryprogress)]} { eval $state(-queryprogress) [list $token $state(querylength)\ $state(queryoffset)] } } # http::Event # # Handle input on the socket # # Arguments # token The token returned from http::geturl # # Side Effects # Read the socket and handle callbacks. proc http::Event {token} { variable $token upvar 0 $token state set s $state(sock) if {[eof $s]} { Eof $token return } if {[string equal $state(state) "header"]} { if {[catch {gets $s line} n]} { Finish $token $n } elseif {$n == 0} { variable encodings set state(state) body if {$state(-binary) || ![string match -nocase text* $state(type)] || [string match *gzip* $state(coding)] || [string match *compress* $state(coding)]} { # Turn off conversions for non-text data fconfigure $s -translation binary if {[info exists state(-channel)]} { fconfigure $state(-channel) -translation binary } } else { # If we are getting text, set the incoming channel's # encoding correctly. iso8859-1 is the RFC default, but # this could be any IANA charset. However, we only know # how to convert what we have encodings for. set idx [lsearch -exact $encodings \ [string tolower $state(charset)]] if {$idx >= 0} { fconfigure $s -encoding [lindex $encodings $idx] } } if {[info exists state(-channel)] && \ ![info exists state(-handler)]} { # Initiate a sequence of background fcopies fileevent $s readable {} CopyStart $s $token } } elseif {$n > 0} { if {[regexp -nocase {^content-type:(.+)$} $line x type]} { set state(type) [string trim $type] # grab the optional charset information regexp -nocase {charset\s*=\s*(\S+)} $type x state(charset) } if {[regexp -nocase {^content-length:(.+)$} $line x length]} { set state(totalsize) [string trim $length] } if {[regexp -nocase {^content-encoding:(.+)$} $line x coding]} { set state(coding) [string trim $coding] } if {[regexp -nocase {^([^:]+):(.+)$} $line x key value]} { lappend state(meta) $key [string trim $value] } elseif {[string match HTTP* $line]} { set state(http) $line } } } else { if {[catch { if {[info exists state(-handler)]} { set n [eval $state(-handler) {$s $token}] } else { set block [read $s $state(-blocksize)] set n [string length $block] if {$n >= 0} { append state(body) $block } } if {$n >= 0} { incr state(currentsize) $n } } err]} { Finish $token $err } else { if {[info exists state(-progress)]} { eval $state(-progress) \ {$token $state(totalsize) $state(currentsize)} } } } } # http::CopyStart # # Error handling wrapper around fcopy # # Arguments # s The socket to copy from # token The token returned from http::geturl # # Side Effects # This closes the connection upon error proc http::CopyStart {s token} { variable $token upvar 0 $token state if {[catch { fcopy $s $state(-channel) -size $state(-blocksize) -command \ [list http::CopyDone $token] } err]} { Finish $token $err } } # http::CopyDone # # fcopy completion callback # # Arguments # token The token returned from http::geturl # count The amount transfered # # Side Effects # Invokes callbacks proc http::CopyDone {token count {error {}}} { variable $token upvar 0 $token state set s $state(sock) incr state(currentsize) $count if {[info exists state(-progress)]} { eval $state(-progress) {$token $state(totalsize) $state(currentsize)} } # At this point the token may have been reset if {[string length $error]} { Finish $token $error } elseif {[catch {eof $s} iseof] || $iseof} { Eof $token } else { CopyStart $s $token } } # http::Eof # # Handle eof on the socket # # Arguments # token The token returned from http::geturl # # Side Effects # Clean up the socket proc http::Eof {token} { variable $token upvar 0 $token state if {[string equal $state(state) "header"]} { # Premature eof set state(status) eof } else { set state(status) ok } set state(state) eof Finish $token } # http::wait -- # # See documentaion for details. # # Arguments: # token Connection token. # # Results: # The status after the wait. proc http::wait {token} { variable $token upvar 0 $token state if {![info exists state(status)] || [string length $state(status)] == 0} { # We must wait on the original variable name, not the upvar alias vwait $token\(status) } return $state(status) } # http::formatQuery -- # # See documentaion for details. # Call http::formatQuery with an even number of arguments, where # the first is a name, the second is a value, the third is another # name, and so on. # # Arguments: # args A list of name-value pairs. # # Results: # TODO proc http::formatQuery {args} { set result "" set sep "" foreach i $args { append result $sep [mapReply $i] if {[string equal $sep "="]} { set sep & } else { set sep = } } return $result } # http::mapReply -- # # Do x-www-urlencoded character mapping # # Arguments: # string The string the needs to be encoded # # Results: # The encoded string proc http::mapReply {string} { variable http variable formMap variable alphanumeric # The spec says: "non-alphanumeric characters are replaced by '%HH'" # 1 leave alphanumerics characters alone # 2 Convert every other character to an array lookup # 3 Escape constructs that are "special" to the tcl parser # 4 "subst" the result, doing all the array substitutions if {$http(-urlencoding) ne ""} { set string [encoding convertto $http(-urlencoding) $string] } regsub -all \[^$alphanumeric\] $string {$formMap(&)} string regsub -all {[][{})\\]\)} $string {\\&} string return [subst -nocommand $string] } # http::ProxyRequired -- # Default proxy filter. # # Arguments: # host The destination host # # Results: # The current proxy settings proc http::ProxyRequired {host} { variable http if {[info exists http(-proxyhost)] && [string length $http(-proxyhost)]} { if {![info exists http(-proxyport)] || \ ![string length $http(-proxyport)]} { set http(-proxyport) 8080 } return [list $http(-proxyhost) $http(-proxyport)] } } Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/http2.5/pkgIndex.tcl0100644000000000001200000000132610054746707031740 0ustar rootadmin# Tcl package index file, version 1.1 # This file is generated by the "pkg_mkIndex" command # and sourced either when an application starts up or # by a "package unknown" script. It invokes the # "package ifneeded" command to set up package-related # information so that packages will be loaded automatically # in response to "package require" commands. When this # script is sourced, the variable $dir must contain the # full path name of this file's directory. if {![package vsatisfies [package provide Tcl] 8.2]} {return} package ifneeded http 2.5.0 [list tclPkgSetup $dir http 2.5.0 {{http.tcl source {::http::config ::http::formatQuery ::http::geturl ::http::reset ::http::wait ::http::register ::http::unregister}}}] Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/init.tcl0100644000000000001200000000027610153074464027723 0ustar rootadminif {![interp issafe]} {set tcl_pkgPath [lsearch -all -inline $tcl_pkgPath [file join [file dirname [file dirname [info nameofexecutable]]] *]]}; source [file join $tcl_library realinit.tcl] Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/ldAout.tcl0100644000000000001200000001522207354750261030212 0ustar rootadmin# ldAout.tcl -- # # This "tclldAout" procedure in this script acts as a replacement # for the "ld" command when linking an object file that will be # loaded dynamically into Tcl or Tk using pseudo-static linking. # # Parameters: # The arguments to the script are the command line options for # an "ld" command. # # Results: # The "ld" command is parsed, and the "-o" option determines the # module name. ".a" and ".o" options are accumulated. # The input archives and object files are examined with the "nm" # command to determine whether the modules initialization # entry and safe initialization entry are present. A trivial # C function that locates the entries is composed, compiled, and # its .o file placed before all others in the command; then # "ld" is executed to bind the objects together. # # RCS: @(#) $Id: ldAout.tcl,v 1.5 2001/09/28 01:21:53 dgp Exp $ # # Copyright (c) 1995, by General Electric Company. All rights reserved. # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # # This work was supported in part by the ARPA Manufacturing Automation # and Design Engineering (MADE) Initiative through ARPA contract # F33615-94-C-4400. proc tclLdAout {{cc {}} {shlib_suffix {}} {shlib_cflags none}} { global env global argv if {[string equal $cc ""]} { set cc $env(CC) } # if only two parameters are supplied there is assumed that the # only shlib_suffix is missing. This parameter is anyway available # as "info sharedlibextension" too, so there is no need to transfer # 3 parameters to the function tclLdAout. For compatibility, this # function now accepts both 2 and 3 parameters. if {[string equal $shlib_suffix ""]} { set shlib_cflags $env(SHLIB_CFLAGS) } elseif {[string equal $shlib_cflags "none"]} { set shlib_cflags $shlib_suffix } # seenDotO is nonzero if a .o or .a file has been seen set seenDotO 0 # minusO is nonzero if the last command line argument was "-o". set minusO 0 # head has command line arguments up to but not including the first # .o or .a file. tail has the rest of the arguments. set head {} set tail {} # nmCommand is the "nm" command that lists global symbols from the # object files. set nmCommand {|nm -g} # entryProtos is the table of _Init and _SafeInit prototypes found in the # module. set entryProtos {} # entryPoints is the table of _Init and _SafeInit entries found in the # module. set entryPoints {} # libraries is the list of -L and -l flags to the linker. set libraries {} set libdirs {} # Process command line arguments foreach a $argv { if {!$minusO && [regexp {\.[ao]$} $a]} { set seenDotO 1 lappend nmCommand $a } if {$minusO} { set outputFile $a set minusO 0 } elseif {![string compare $a -o]} { set minusO 1 } if {[regexp {^-[lL]} $a]} { lappend libraries $a if {[regexp {^-L} $a]} { lappend libdirs [string range $a 2 end] } } elseif {$seenDotO} { lappend tail $a } else { lappend head $a } } lappend libdirs /lib /usr/lib # MIPS -- If there are corresponding G0 libraries, replace the # ordinary ones with the G0 ones. set libs {} foreach lib $libraries { if {[regexp {^-l} $lib]} { set lname [string range $lib 2 end] foreach dir $libdirs { if {[file exists [file join $dir lib${lname}_G0.a]]} { set lname ${lname}_G0 break } } lappend libs -l$lname } else { lappend libs $lib } } set libraries $libs # Extract the module name from the "-o" option if {![info exists outputFile]} { error "-o option must be supplied to link a Tcl load module" } set m [file tail $outputFile] if {[regexp {\.a$} $outputFile]} { set shlib_suffix .a } else { set shlib_suffix "" } if {[regexp {\..*$} $outputFile match]} { set l [expr {[string length $m] - [string length $match]}] } else { error "Output file does not appear to have a suffix" } set modName [string tolower $m 0 [expr {$l-1}]] if {[regexp {^lib} $modName]} { set modName [string range $modName 3 end] } if {[regexp {[0-9\.]*(_g0)?$} $modName match]} { set modName [string range $modName 0 [expr {[string length $modName]-[string length $match]-1}]] } set modName [string totitle $modName] # Catalog initialization entry points found in the module set f [open $nmCommand r] while {[gets $f l] >= 0} { if {[regexp {T[ ]*_?([A-Z][a-z0-9_]*_(Safe)?Init(__FP10Tcl_Interp)?)$} $l trash symbol]} { if {![regexp {_?([A-Z][a-z0-9_]*_(Safe)?Init)} $symbol trash s]} { set s $symbol } append entryProtos {extern int } $symbol { (); } \n append entryPoints { } \{ { "} $s {", } $symbol { } \} , \n } } close $f if {[string equal $entryPoints ""]} { error "No entry point found in objects" } # Compose a C function that resolves the initialization entry points and # embeds the required libraries in the object code. set C {#include } append C \n append C {char TclLoadLibraries_} $modName { [] =} \n append C { "@LIBS: } $libraries {";} \n append C $entryProtos append C {static struct } \{ \n append C { char * name;} \n append C { int (*value)();} \n append C \} {dictionary [] = } \{ \n append C $entryPoints append C { 0, 0 } \n \} \; \n append C {typedef struct Tcl_Interp Tcl_Interp;} \n append C {typedef int Tcl_PackageInitProc (Tcl_Interp *);} \n append C {Tcl_PackageInitProc *} \n append C TclLoadDictionary_ $modName { (symbol)} \n append C { CONST char * symbol;} \n append C { { int i; for (i = 0; dictionary [i] . name != 0; ++i) { if (!strcmp (symbol, dictionary [i] . name)) { return dictionary [i].value; } } return 0; } } append C \n # Write the C module and compile it set cFile tcl$modName.c set f [open $cFile w] puts -nonewline $f $C close $f set ccCommand "$cc -c $shlib_cflags $cFile" puts stderr $ccCommand eval exec $ccCommand # Now compose and execute the ld command that packages the module if {[string equal $shlib_suffix ".a"]} { set ldCommand "ar cr $outputFile" regsub { -o} $tail {} tail } else { set ldCommand ld foreach item $head { lappend ldCommand $item } } lappend ldCommand tcl$modName.o foreach item $tail { lappend ldCommand $item } puts stderr $ldCommand eval exec $ldCommand if {[string equal $shlib_suffix ".a"]} { exec ranlib $outputFile } # Clean up working files exec /bin/rm $cFile [file rootname $cFile].o } Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/msgcat1.3/0040755000000000000240000000000010153074406027764 5ustar rootstaffWishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/msgcat1.3/msgcat.tcl0100644000000000001200000003150610107233154031726 0ustar rootadmin# msgcat.tcl -- # # This file defines various procedures which implement a # message catalog facility for Tcl programs. It should be # loaded with the command "package require msgcat". # # Copyright (c) 1998-2000 by Ajuba Solutions. # Copyright (c) 1998 by Mark Harrison. # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # # RCS: @(#) $Id: msgcat.tcl,v 1.17.2.4 2004/08/13 21:45:16 dgp Exp $ package require Tcl 8.2 # When the version number changes, be sure to update the pkgIndex.tcl file, # and the installation directory in the Makefiles. package provide msgcat 1.3.3 namespace eval msgcat { namespace export mc mcload mclocale mcmax mcmset mcpreferences mcset \ mcunknown # Records the current locale as passed to mclocale variable Locale "" # Records the list of locales to search variable Loclist {} # Records the mapping between source strings and translated strings. The # array key is of the form ",," and the value is # the translated string. array set Msgs {} # Map of language codes used in Windows registry to those of ISO-639 array set WinRegToISO639 { 01 ar 0401 ar_SA 0801 ar_IQ 0c01 ar_EG 1001 ar_LY 1401 ar_DZ 1801 ar_MA 1c01 ar_TN 2001 ar_OM 2401 ar_YE 2801 ar_SY 2c01 ar_JO 3001 ar_LB 3401 ar_KW 3801 ar_AE 3c01 ar_BH 4001 ar_QA 02 bg 0402 bg_BG 03 ca 0403 ca_ES 04 zh 0404 zh_TW 0804 zh_CN 0c04 zh_HK 1004 zh_SG 1404 zh_MO 05 cs 0405 cs_CZ 06 da 0406 da_DK 07 de 0407 de_DE 0807 de_CH 0c07 de_AT 1007 de_LU 1407 de_LI 08 el 0408 el_GR 09 en 0409 en_US 0809 en_GB 0c09 en_AU 1009 en_CA 1409 en_NZ 1809 en_IE 1c09 en_ZA 2009 en_JM 2409 en_GD 2809 en_BZ 2c09 en_TT 3009 en_ZW 3409 en_PH 0a es 040a es_ES 080a es_MX 0c0a es_ES@modern 100a es_GT 140a es_CR 180a es_PA 1c0a es_DO 200a es_VE 240a es_CO 280a es_PE 2c0a es_AR 300a es_EC 340a es_CL 380a es_UY 3c0a es_PY 400a es_BO 440a es_SV 480a es_HN 4c0a es_NI 500a es_PR 0b fi 040b fi_FI 0c fr 040c fr_FR 080c fr_BE 0c0c fr_CA 100c fr_CH 140c fr_LU 180c fr_MC 0d he 040d he_IL 0e hu 040e hu_HU 0f is 040f is_IS 10 it 0410 it_IT 0810 it_CH 11 ja 0411 ja_JP 12 ko 0412 ko_KR 13 nl 0413 nl_NL 0813 nl_BE 14 no 0414 no_NO 0814 nn_NO 15 pl 0415 pl_PL 16 pt 0416 pt_BR 0816 pt_PT 17 rm 0417 rm_CH 18 ro 0418 ro_RO 19 ru 1a hr 041a hr_HR 081a sr_YU 0c1a sr_YU@cyrillic 1b sk 041b sk_SK 1c sq 041c sq_AL 1d sv 041d sv_SE 081d sv_FI 1e th 041e th_TH 1f tr 041f tr_TR 20 ur 0420 ur_PK 0820 ur_IN 21 id 0421 id_ID 22 uk 0422 uk_UA 23 be 0423 be_BY 24 sl 0424 sl_SI 25 et 0425 et_EE 26 lv 0426 lv_LV 27 lt 0427 lt_LT 28 tg 0428 tg_TJ 29 fa 0429 fa_IR 2a vi 042a vi_VN 2b hy 042b hy_AM 2c az 042c az_AZ@latin 082c az_AZ@cyrillic 2d eu 2e wen 042e wen_DE 2f mk 042f mk_MK 30 bnt 0430 bnt_TZ 31 ts 0431 ts_ZA 33 ven 0433 ven_ZA 34 xh 0434 xh_ZA 35 zu 0435 zu_ZA 36 af 0436 af_ZA 37 ka 0437 ka_GE 38 fo 0438 fo_FO 39 hi 0439 hi_IN 3a mt 043a mt_MT 3b se 043b se_NO 043c gd_UK 083c ga_IE 3d yi 043d yi_IL 3e ms 043e ms_MY 083e ms_BN 3f kk 043f kk_KZ 40 ky 0440 ky_KG 41 sw 0441 sw_KE 42 tk 0442 tk_TM 43 uz 0443 uz_UZ@latin 0843 uz_UZ@cyrillic 44 tt 0444 tt_RU 45 bn 0445 bn_IN 46 pa 0446 pa_IN 47 gu 0447 gu_IN 48 or 0448 or_IN 49 ta 4a te 044a te_IN 4b kn 044b kn_IN 4c ml 044c ml_IN 4d as 044d as_IN 4e mr 044e mr_IN 4f sa 044f sa_IN 50 mn 51 bo 0451 bo_CN 52 cy 0452 cy_GB 53 km 0453 km_KH 54 lo 0454 lo_LA 55 my 0455 my_MM 56 gl 0456 gl_ES 57 kok 0457 kok_IN 58 mni 0458 mni_IN 59 sd 5a syr 045a syr_TR 5b si 045b si_LK 5c chr 045c chr_US 5d iu 045d iu_CA 5e am 045e am_ET 5f ber 045f ber_MA 60 ks 0460 ks_PK 0860 ks_IN 61 ne 0461 ne_NP 0861 ne_IN 62 fy 0462 fy_NL 63 ps 64 tl 0464 tl_PH 65 div 0465 div_MV 66 bin 0466 bin_NG 67 ful 0467 ful_NG 68 ha 0468 ha_NG 69 nic 0469 nic_NG 6a yo 046a yo_NG 70 ibo 0470 ibo_NG 71 kau 0471 kau_NG 72 om 0472 om_ET 73 ti 0473 ti_ET 74 gn 0474 gn_PY 75 cpe 0475 cpe_US 76 la 0476 la_VA 77 so 0477 so_SO 78 sit 0478 sit_CN 79 pap 0479 pap_AN } } # msgcat::mc -- # # Find the translation for the given string based on the current # locale setting. Check the local namespace first, then look in each # parent namespace until the source is found. If additional args are # specified, use the format command to work them into the traslated # string. # # Arguments: # src The string to translate. # args Args to pass to the format command # # Results: # Returns the translatd string. Propagates errors thrown by the # format command. proc msgcat::mc {src args} { # Check for the src in each namespace starting from the local and # ending in the global. variable Msgs variable Loclist variable Locale set ns [uplevel 1 [list ::namespace current]] while {$ns != ""} { foreach loc $Loclist { if {[info exists Msgs($loc,$ns,$src)]} { if {[llength $args] == 0} { return $Msgs($loc,$ns,$src) } else { return [uplevel 1 \ [linsert $args 0 ::format $Msgs($loc,$ns,$src)]] } } } set ns [namespace parent $ns] } # we have not found the translation return [uplevel 1 \ [linsert $args 0 [::namespace origin mcunknown] $Locale $src]] } # msgcat::mclocale -- # # Query or set the current locale. # # Arguments: # newLocale (Optional) The new locale string. Locale strings # should be composed of one or more sublocale parts # separated by underscores (e.g. en_US). # # Results: # Returns the current locale. proc msgcat::mclocale {args} { variable Loclist variable Locale set len [llength $args] if {$len > 1} { error {wrong # args: should be "mclocale ?newLocale?"} } if {$len == 1} { set newLocale [lindex $args 0] if {$newLocale ne [file tail $newLocale]} { return -code error "invalid newLocale value \"$newLocale\":\ could be path to unsafe code." } set Locale [string tolower $newLocale] set Loclist {} set word "" foreach part [split $Locale _] { set word [string trimleft "${word}_${part}" _] set Loclist [linsert $Loclist 0 $word] } } return $Locale } # msgcat::mcpreferences -- # # Fetch the list of locales used to look up strings, ordered from # most preferred to least preferred. # # Arguments: # None. # # Results: # Returns an ordered list of the locales preferred by the user. proc msgcat::mcpreferences {} { variable Loclist return $Loclist } # msgcat::mcload -- # # Attempt to load message catalogs for each locale in the # preference list from the specified directory. # # Arguments: # langdir The directory to search. # # Results: # Returns the number of message catalogs that were loaded. proc msgcat::mcload {langdir} { set x 0 foreach p [mcpreferences] { set langfile [file join $langdir $p.msg] if {[file exists $langfile]} { incr x set fid [open $langfile "r"] fconfigure $fid -encoding utf-8 uplevel 1 [read $fid] close $fid } } return $x } # msgcat::mcset -- # # Set the translation for a given string in a specified locale. # # Arguments: # locale The locale to use. # src The source string. # dest (Optional) The translated string. If omitted, # the source string is used. # # Results: # Returns the new locale. proc msgcat::mcset {locale src {dest ""}} { variable Msgs if {[llength [info level 0]] == 3} { ;# dest not specified set dest $src } set ns [uplevel 1 [list ::namespace current]] set Msgs([string tolower $locale],$ns,$src) $dest return $dest } # msgcat::mcmset -- # # Set the translation for multiple strings in a specified locale. # # Arguments: # locale The locale to use. # pairs One or more src/dest pairs (must be even length) # # Results: # Returns the number of pairs processed proc msgcat::mcmset {locale pairs } { variable Msgs set length [llength $pairs] if {$length % 2} { error {bad translation list: should be "mcmset locale {src dest ...}"} } set locale [string tolower $locale] set ns [uplevel 1 [list ::namespace current]] foreach {src dest} $pairs { set Msgs($locale,$ns,$src) $dest } return $length } # msgcat::mcunknown -- # # This routine is called by msgcat::mc if a translation cannot # be found for a string. This routine is intended to be replaced # by an application specific routine for error reporting # purposes. The default behavior is to return the source string. # If additional args are specified, the format command will be used # to work them into the traslated string. # # Arguments: # locale The current locale. # src The string to be translated. # args Args to pass to the format command # # Results: # Returns the translated value. proc msgcat::mcunknown {locale src args} { if {[llength $args]} { return [uplevel 1 [linsert $args 0 ::format $src]] } else { return $src } } # msgcat::mcmax -- # # Calculates the maximun length of the translated strings of the given # list. # # Arguments: # args strings to translate. # # Results: # Returns the length of the longest translated string. proc msgcat::mcmax {args} { set max 0 foreach string $args { set translated [uplevel 1 [list [namespace origin mc] $string]] set len [string length $translated] if {$len>$max} { set max $len } } return $max } # Convert the locale values stored in environment variables to a form # suitable for passing to [mclocale] proc msgcat::ConvertLocale {value} { # Assume $value is of form: $language[_$territory][.$codeset][@modifier] # Convert to form: $language[_$territory][_$modifier] # # Comment out expanded RE version -- bugs alleged # regexp -expanded { # ^ # Match all the way to the beginning # ([^_.@]*) # Match "lanugage"; ends with _, ., or @ # (_([^.@]*))? # Match (optional) "territory"; starts with _ # ([.]([^@]*))? # Match (optional) "codeset"; starts with . # (@(.*))? # Match (optional) "modifier"; starts with @ # $ # Match all the way to the end # } $value -> language _ territory _ codeset _ modifier if {![regexp {^([^_.@]+)(_([^.@]*))?([.]([^@]*))?(@(.*))?$} $value \ -> language _ territory _ codeset _ modifier]} { return -code error "invalid locale '$value': empty language part" } set ret $language if {[string length $territory]} { append ret _$territory } if {[string length $modifier]} { append ret _$modifier } return $ret } # Initialize the default locale proc msgcat::Init {} { # # set default locale, try to get from environment # foreach varName {LC_ALL LC_MESSAGES LANG} { if {[info exists ::env($varName)] && ![string equal "" $::env($varName)]} { if {![catch {mclocale [ConvertLocale $::env($varName)]}]} { return } } } # # The rest of this routine is special processing for Windows; # all other platforms, get out now. # if { ![string equal $::tcl_platform(platform) windows] } { mclocale C return } # # On Windows, try to set locale depending on registry settings, # or fall back on locale of "C". # set key {HKEY_CURRENT_USER\Control Panel\International} if {[catch {package require registry}] \ || [catch {registry get $key "locale"} locale]} { mclocale C return } # # Keep trying to match against smaller and smaller suffixes # of the registry value, since the latter hexadigits appear # to determine general language and earlier hexadigits determine # more precise information, such as territory. For example, # 0409 - English - United States # 0809 - English - United Kingdom # Add more translations to the WinRegToISO639 array above. # variable WinRegToISO639 set locale [string tolower $locale] while {[string length $locale]} { if {![catch {mclocale [ConvertLocale $WinRegToISO639($locale)]}]} { return } set locale [string range $locale 1 end] } # # No translation known. Fall back on "C" locale # mclocale C } msgcat::Init Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/msgcat1.3/pkgIndex.tcl0100644000000000001200000000020610107233154032212 0ustar rootadminif {![package vsatisfies [package provide Tcl] 8.2]} {return} package ifneeded msgcat 1.3.3 [list source [file join $dir msgcat.tcl]] Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/opt0.4/0040755000000000000240000000000010153074406027310 5ustar rootstaffWishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/opt0.4/optparse.tcl0100644000000000001200000010037607727704707031660 0ustar rootadmin# optparse.tcl -- # # (private) Option parsing package # Primarily used internally by the safe:: code. # # WARNING: This code will go away in a future release # of Tcl. It is NOT supported and you should not rely # on it. If your code does rely on this package you # may directly incorporate this code into your application. # # RCS: @(#) $Id: optparse.tcl,v 1.8.2.1 2003/09/10 20:29:59 dgp Exp $ package require Tcl 8.2 # When this version number changes, update the pkgIndex.tcl file # and the install directory in the Makefiles. package provide opt 0.4.4.1 namespace eval ::tcl { # Exported APIs namespace export OptKeyRegister OptKeyDelete OptKeyError OptKeyParse \ OptProc OptProcArgGiven OptParse \ Lempty Lget \ Lassign Lvarpop Lvarpop1 Lvarset Lvarincr \ SetMax SetMin ################# Example of use / 'user documentation' ################### proc OptCreateTestProc {} { # Defines ::tcl::OptParseTest as a test proc with parsed arguments # (can't be defined before the code below is loaded (before "OptProc")) # Every OptProc give usage information on "procname -help". # Try "tcl::OptParseTest -help" and "tcl::OptParseTest -a" and # then other arguments. # # example of 'valid' call: # ::tcl::OptParseTest save -4 -pr 23 -libsok SybTcl\ # -nostatics false ch1 OptProc OptParseTest { {subcommand -choice {save print} "sub command"} {arg1 3 "some number"} {-aflag} {-intflag 7} {-weirdflag "help string"} {-noStatics "Not ok to load static packages"} {-nestedloading1 true "OK to load into nested slaves"} {-nestedloading2 -boolean true "OK to load into nested slaves"} {-libsOK -choice {Tk SybTcl} "List of packages that can be loaded"} {-precision -int 12 "Number of digits of precision"} {-intval 7 "An integer"} {-scale -float 1.0 "Scale factor"} {-zoom 1.0 "Zoom factor"} {-arbitrary foobar "Arbitrary string"} {-random -string 12 "Random string"} {-listval -list {} "List value"} {-blahflag -blah abc "Funny type"} {arg2 -boolean "a boolean"} {arg3 -choice "ch1 ch2"} {?optarg? -list {} "optional argument"} } { foreach v [info locals] { puts stderr [format "%14s : %s" $v [set $v]] } } } ################### No User serviceable part below ! ############### # Array storing the parsed descriptions variable OptDesc; array set OptDesc {}; # Next potentially free key id (numeric) variable OptDescN 0; # Inside algorithm/mechanism description: # (not for the faint hearted ;-) # # The argument description is parsed into a "program tree" # It is called a "program" because it is the program used by # the state machine interpreter that use that program to # actually parse the arguments at run time. # # The general structure of a "program" is # notation (pseudo bnf like) # name :== definition defines "name" as being "definition" # { x y z } means list of x, y, and z # x* means x repeated 0 or more time # x+ means "x x*" # x? means optionally x # x | y means x or y # "cccc" means the literal string # # program :== { programCounter programStep* } # # programStep :== program | singleStep # # programCounter :== {"P" integer+ } # # singleStep :== { instruction parameters* } # # instruction :== single element list # # (the difference between singleStep and program is that \ # llength [lindex $program 0] >= 2 # while # llength [lindex $singleStep 0] == 1 # ) # # And for this application: # # singleStep :== { instruction varname {hasBeenSet currentValue} type # typeArgs help } # instruction :== "flags" | "value" # type :== knowType | anyword # knowType :== "string" | "int" | "boolean" | "boolflag" | "float" # | "choice" # # for type "choice" typeArgs is a list of possible choices, the first one # is the default value. for all other types the typeArgs is the default value # # a "boolflag" is the type for a flag whose presence or absence, without # additional arguments means respectively true or false (default flag type). # # programCounter is the index in the list of the currently processed # programStep (thus starting at 1 (0 is {"P" prgCounterValue}). # If it is a list it points toward each currently selected programStep. # (like for "flags", as they are optional, form a set and programStep). # Performance/Implementation issues # --------------------------------- # We use tcl lists instead of arrays because with tcl8.0 # they should start to be much faster. # But this code use a lot of helper procs (like Lvarset) # which are quite slow and would be helpfully optimized # for instance by being written in C. Also our struture # is complex and there is maybe some places where the # string rep might be calculated at great exense. to be checked. # # Parse a given description and saves it here under the given key # generate a unused keyid if not given # proc ::tcl::OptKeyRegister {desc {key ""}} { variable OptDesc; variable OptDescN; if {[string equal $key ""]} { # in case a key given to us as a parameter was a number while {[info exists OptDesc($OptDescN)]} {incr OptDescN} set key $OptDescN; incr OptDescN; } # program counter set program [list [list "P" 1]]; # are we processing flags (which makes a single program step) set inflags 0; set state {}; # flag used to detect that we just have a single (flags set) subprogram. set empty 1; foreach item $desc { if {$state == "args"} { # more items after 'args'... return -code error "'args' special argument must be the last one"; } set res [OptNormalizeOne $item]; set state [lindex $res 0]; if {$inflags} { if {$state == "flags"} { # add to 'subprogram' lappend flagsprg $res; } else { # put in the flags # structure for flag programs items is a list of # {subprgcounter {prg flag 1} {prg flag 2} {...}} lappend program $flagsprg; # put the other regular stuff lappend program $res; set inflags 0; set empty 0; } } else { if {$state == "flags"} { set inflags 1; # sub program counter + first sub program set flagsprg [list [list "P" 1] $res]; } else { lappend program $res; set empty 0; } } } if {$inflags} { if {$empty} { # We just have the subprogram, optimize and remove # unneeded level: set program $flagsprg; } else { lappend program $flagsprg; } } set OptDesc($key) $program; return $key; } # # Free the storage for that given key # proc ::tcl::OptKeyDelete {key} { variable OptDesc; unset OptDesc($key); } # Get the parsed description stored under the given key. proc OptKeyGetDesc {descKey} { variable OptDesc; if {![info exists OptDesc($descKey)]} { return -code error "Unknown option description key \"$descKey\""; } set OptDesc($descKey); } # Parse entry point for ppl who don't want to register with a key, # for instance because the description changes dynamically. # (otherwise one should really use OptKeyRegister once + OptKeyParse # as it is way faster or simply OptProc which does it all) # Assign a temporary key, call OptKeyParse and then free the storage proc ::tcl::OptParse {desc arglist} { set tempkey [OptKeyRegister $desc]; set ret [catch {uplevel 1 [list ::tcl::OptKeyParse $tempkey $arglist]} res]; OptKeyDelete $tempkey; return -code $ret $res; } # Helper function, replacement for proc that both # register the description under a key which is the name of the proc # (and thus unique to that code) # and add a first line to the code to call the OptKeyParse proc # Stores the list of variables that have been actually given by the user # (the other will be sets to their default value) # into local variable named "Args". proc ::tcl::OptProc {name desc body} { set namespace [uplevel 1 [list ::namespace current]]; if {[string match "::*" $name] || [string equal $namespace "::"]} { # absolute name or global namespace, name is the key set key $name; } else { # we are relative to some non top level namespace: set key "${namespace}::${name}"; } OptKeyRegister $desc $key; uplevel 1 [list ::proc $name args "set Args \[::tcl::OptKeyParse $key \$args\]\n$body"]; return $key; } # Check that a argument has been given # assumes that "OptProc" has been used as it will check in "Args" list proc ::tcl::OptProcArgGiven {argname} { upvar Args alist; expr {[lsearch $alist $argname] >=0} } ####### # Programs/Descriptions manipulation # Return the instruction word/list of a given step/(sub)program proc OptInstr {lst} { lindex $lst 0; } # Is a (sub) program or a plain instruction ? proc OptIsPrg {lst} { expr {[llength [OptInstr $lst]]>=2} } # Is this instruction a program counter or a real instr proc OptIsCounter {item} { expr {[lindex $item 0]=="P"} } # Current program counter (2nd word of first word) proc OptGetPrgCounter {lst} { Lget $lst {0 1} } # Current program counter (2nd word of first word) proc OptSetPrgCounter {lstName newValue} { upvar $lstName lst; set lst [lreplace $lst 0 0 [concat "P" $newValue]]; } # returns a list of currently selected items. proc OptSelection {lst} { set res {}; foreach idx [lrange [lindex $lst 0] 1 end] { lappend res [Lget $lst $idx]; } return $res; } # Advance to next description proc OptNextDesc {descName} { uplevel 1 [list Lvarincr $descName {0 1}]; } # Get the current description, eventually descend proc OptCurDesc {descriptions} { lindex $descriptions [OptGetPrgCounter $descriptions]; } # get the current description, eventually descend # through sub programs as needed. proc OptCurDescFinal {descriptions} { set item [OptCurDesc $descriptions]; # Descend untill we get the actual item and not a sub program while {[OptIsPrg $item]} { set item [OptCurDesc $item]; } return $item; } # Current final instruction adress proc OptCurAddr {descriptions {start {}}} { set adress [OptGetPrgCounter $descriptions]; lappend start $adress; set item [lindex $descriptions $adress]; if {[OptIsPrg $item]} { return [OptCurAddr $item $start]; } else { return $start; } } # Set the value field of the current instruction proc OptCurSetValue {descriptionsName value} { upvar $descriptionsName descriptions # get the current item full adress set adress [OptCurAddr $descriptions]; # use the 3th field of the item (see OptValue / OptNewInst) lappend adress 2 Lvarset descriptions $adress [list 1 $value]; # ^hasBeenSet flag } # empty state means done/paste the end of the program proc OptState {item} { lindex $item 0 } # current state proc OptCurState {descriptions} { OptState [OptCurDesc $descriptions]; } ####### # Arguments manipulation # Returns the argument that has to be processed now proc OptCurrentArg {lst} { lindex $lst 0; } # Advance to next argument proc OptNextArg {argsName} { uplevel 1 [list Lvarpop1 $argsName]; } ####### # Loop over all descriptions, calling OptDoOne which will # eventually eat all the arguments. proc OptDoAll {descriptionsName argumentsName} { upvar $descriptionsName descriptions upvar $argumentsName arguments; # puts "entered DoAll"; # Nb: the places where "state" can be set are tricky to figure # because DoOne sets the state to flagsValue and return -continue # when needed... set state [OptCurState $descriptions]; # We'll exit the loop in "OptDoOne" or when state is empty. while 1 { set curitem [OptCurDesc $descriptions]; # Do subprograms if needed, call ourselves on the sub branch while {[OptIsPrg $curitem]} { OptDoAll curitem arguments # puts "done DoAll sub"; # Insert back the results in current tree; Lvarset1nc descriptions [OptGetPrgCounter $descriptions]\ $curitem; OptNextDesc descriptions; set curitem [OptCurDesc $descriptions]; set state [OptCurState $descriptions]; } # puts "state = \"$state\" - arguments=($arguments)"; if {[Lempty $state]} { # Nothing left to do, we are done in this branch: break; } # The following statement can make us terminate/continue # as it use return -code {break, continue, return and error} # codes OptDoOne descriptions state arguments; # If we are here, no special return code where issued, # we'll step to next instruction : # puts "new state = \"$state\""; OptNextDesc descriptions; set state [OptCurState $descriptions]; } } # Process one step for the state machine, # eventually consuming the current argument. proc OptDoOne {descriptionsName stateName argumentsName} { upvar $argumentsName arguments; upvar $descriptionsName descriptions; upvar $stateName state; # the special state/instruction "args" eats all # the remaining args (if any) if {($state == "args")} { if {![Lempty $arguments]} { # If there is no additional arguments, leave the default value # in. OptCurSetValue descriptions $arguments; set arguments {}; } # puts "breaking out ('args' state: consuming every reminding args)" return -code break; } if {[Lempty $arguments]} { if {$state == "flags"} { # no argument and no flags : we're done # puts "returning to previous (sub)prg (no more args)"; return -code return; } elseif {$state == "optValue"} { set state next; # not used, for debug only # go to next state return ; } else { return -code error [OptMissingValue $descriptions]; } } else { set arg [OptCurrentArg $arguments]; } switch $state { flags { # A non-dash argument terminates the options, as does -- # Still a flag ? if {![OptIsFlag $arg]} { # don't consume the argument, return to previous prg return -code return; } # consume the flag OptNextArg arguments; if {[string equal "--" $arg]} { # return from 'flags' state return -code return; } set hits [OptHits descriptions $arg]; if {$hits > 1} { return -code error [OptAmbigous $descriptions $arg] } elseif {$hits == 0} { return -code error [OptFlagUsage $descriptions $arg] } set item [OptCurDesc $descriptions]; if {[OptNeedValue $item]} { # we need a value, next state is set state flagValue; } else { OptCurSetValue descriptions 1; } # continue return -code continue; } flagValue - value { set item [OptCurDesc $descriptions]; # Test the values against their required type if {[catch {OptCheckType $arg\ [OptType $item] [OptTypeArgs $item]} val]} { return -code error [OptBadValue $item $arg $val] } # consume the value OptNextArg arguments; # set the value OptCurSetValue descriptions $val; # go to next state if {$state == "flagValue"} { set state flags return -code continue; } else { set state next; # not used, for debug only return ; # will go on next step } } optValue { set item [OptCurDesc $descriptions]; # Test the values against their required type if {![catch {OptCheckType $arg\ [OptType $item] [OptTypeArgs $item]} val]} { # right type, so : # consume the value OptNextArg arguments; # set the value OptCurSetValue descriptions $val; } # go to next state set state next; # not used, for debug only return ; # will go on next step } } # If we reach this point: an unknown # state as been entered ! return -code error "Bug! unknown state in DoOne \"$state\"\ (prg counter [OptGetPrgCounter $descriptions]:\ [OptCurDesc $descriptions])"; } # Parse the options given the key to previously registered description # and arguments list proc ::tcl::OptKeyParse {descKey arglist} { set desc [OptKeyGetDesc $descKey]; # make sure -help always give usage if {[string equal -nocase "-help" $arglist]} { return -code error [OptError "Usage information:" $desc 1]; } OptDoAll desc arglist; if {![Lempty $arglist]} { return -code error [OptTooManyArgs $desc $arglist]; } # Analyse the result # Walk through the tree: OptTreeVars $desc "#[expr {[info level]-1}]" ; } # determine string length for nice tabulated output proc OptTreeVars {desc level {vnamesLst {}}} { foreach item $desc { if {[OptIsCounter $item]} continue; if {[OptIsPrg $item]} { set vnamesLst [OptTreeVars $item $level $vnamesLst]; } else { set vname [OptVarName $item]; upvar $level $vname var if {[OptHasBeenSet $item]} { # puts "adding $vname" # lets use the input name for the returned list # it is more usefull, for instance you can check that # no flags at all was given with expr # {![string match "*-*" $Args]} lappend vnamesLst [OptName $item]; set var [OptValue $item]; } else { set var [OptDefaultValue $item]; } } } return $vnamesLst } # Check the type of a value # and emit an error if arg is not of the correct type # otherwise returns the canonical value of that arg (ie 0/1 for booleans) proc ::tcl::OptCheckType {arg type {typeArgs ""}} { # puts "checking '$arg' against '$type' ($typeArgs)"; # only types "any", "choice", and numbers can have leading "-" switch -exact -- $type { int { if {![string is integer -strict $arg]} { error "not an integer" } return $arg; } float { return [expr {double($arg)}] } script - list { # if llength fail : malformed list if {[llength $arg]==0 && [OptIsFlag $arg]} { error "no values with leading -" } return $arg; } boolean { if {![string is boolean -strict $arg]} { error "non canonic boolean" } # convert true/false because expr/if is broken with "!,... return [expr {$arg ? 1 : 0}] } choice { if {[lsearch -exact $typeArgs $arg] < 0} { error "invalid choice" } return $arg; } any { return $arg; } string - default { if {[OptIsFlag $arg]} { error "no values with leading -" } return $arg } } return neverReached; } # internal utilities # returns the number of flags matching the given arg # sets the (local) prg counter to the list of matches proc OptHits {descName arg} { upvar $descName desc; set hits 0 set hitems {} set i 1; set larg [string tolower $arg]; set len [string length $larg]; set last [expr {$len-1}]; foreach item [lrange $desc 1 end] { set flag [OptName $item] # lets try to match case insensitively # (string length ought to be cheap) set lflag [string tolower $flag]; if {$len == [string length $lflag]} { if {[string equal $larg $lflag]} { # Exact match case OptSetPrgCounter desc $i; return 1; } } elseif {[string equal $larg [string range $lflag 0 $last]]} { lappend hitems $i; incr hits; } incr i; } if {$hits} { OptSetPrgCounter desc $hitems; } return $hits } # Extract fields from the list structure: proc OptName {item} { lindex $item 1; } proc OptHasBeenSet {item} { Lget $item {2 0}; } proc OptValue {item} { Lget $item {2 1}; } proc OptIsFlag {name} { string match "-*" $name; } proc OptIsOpt {name} { string match {\?*} $name; } proc OptVarName {item} { set name [OptName $item]; if {[OptIsFlag $name]} { return [string range $name 1 end]; } elseif {[OptIsOpt $name]} { return [string trim $name "?"]; } else { return $name; } } proc OptType {item} { lindex $item 3 } proc OptTypeArgs {item} { lindex $item 4 } proc OptHelp {item} { lindex $item 5 } proc OptNeedValue {item} { expr {![string equal [OptType $item] boolflag]} } proc OptDefaultValue {item} { set val [OptTypeArgs $item] switch -exact -- [OptType $item] { choice {return [lindex $val 0]} boolean - boolflag { # convert back false/true to 0/1 because expr !$bool # is broken.. if {$val} { return 1 } else { return 0 } } } return $val } # Description format error helper proc OptOptUsage {item {what ""}} { return -code error "invalid description format$what: $item\n\ should be a list of {varname|-flagname ?-type? ?defaultvalue?\ ?helpstring?}"; } # Generate a canonical form single instruction proc OptNewInst {state varname type typeArgs help} { list $state $varname [list 0 {}] $type $typeArgs $help; # ^ ^ # | | # hasBeenSet=+ +=currentValue } # Translate one item to canonical form proc OptNormalizeOne {item} { set lg [Lassign $item varname arg1 arg2 arg3]; # puts "called optnormalizeone '$item' v=($varname), lg=$lg"; set isflag [OptIsFlag $varname]; set isopt [OptIsOpt $varname]; if {$isflag} { set state "flags"; } elseif {$isopt} { set state "optValue"; } elseif {![string equal $varname "args"]} { set state "value"; } else { set state "args"; } # apply 'smart' 'fuzzy' logic to try to make # description writer's life easy, and our's difficult : # let's guess the missing arguments :-) switch $lg { 1 { if {$isflag} { return [OptNewInst $state $varname boolflag false ""]; } else { return [OptNewInst $state $varname any "" ""]; } } 2 { # varname default # varname help set type [OptGuessType $arg1] if {[string equal $type "string"]} { if {$isflag} { set type boolflag set def false } else { set type any set def "" } set help $arg1 } else { set help "" set def $arg1 } return [OptNewInst $state $varname $type $def $help]; } 3 { # varname type value # varname value comment if {[regexp {^-(.+)$} $arg1 x type]} { # flags/optValue as they are optional, need a "value", # on the contrary, for a variable (non optional), # default value is pointless, 'cept for choices : if {$isflag || $isopt || ($type == "choice")} { return [OptNewInst $state $varname $type $arg2 ""]; } else { return [OptNewInst $state $varname $type "" $arg2]; } } else { return [OptNewInst $state $varname\ [OptGuessType $arg1] $arg1 $arg2] } } 4 { if {[regexp {^-(.+)$} $arg1 x type]} { return [OptNewInst $state $varname $type $arg2 $arg3]; } else { return -code error [OptOptUsage $item]; } } default { return -code error [OptOptUsage $item]; } } } # Auto magic lasy type determination proc OptGuessType {arg} { if {[regexp -nocase {^(true|false)$} $arg]} { return boolean } if {[regexp {^(-+)?[0-9]+$} $arg]} { return int } if {![catch {expr {double($arg)}}]} { return float } return string } # Error messages front ends proc OptAmbigous {desc arg} { OptError "ambigous option \"$arg\", choose from:" [OptSelection $desc] } proc OptFlagUsage {desc arg} { OptError "bad flag \"$arg\", must be one of" $desc; } proc OptTooManyArgs {desc arguments} { OptError "too many arguments (unexpected argument(s): $arguments),\ usage:"\ $desc 1 } proc OptParamType {item} { if {[OptIsFlag $item]} { return "flag"; } else { return "parameter"; } } proc OptBadValue {item arg {err {}}} { # puts "bad val err = \"$err\""; OptError "bad value \"$arg\" for [OptParamType $item]"\ [list $item] } proc OptMissingValue {descriptions} { # set item [OptCurDescFinal $descriptions]; set item [OptCurDesc $descriptions]; OptError "no value given for [OptParamType $item] \"[OptName $item]\"\ (use -help for full usage) :"\ [list $item] } proc ::tcl::OptKeyError {prefix descKey {header 0}} { OptError $prefix [OptKeyGetDesc $descKey] $header; } # determine string length for nice tabulated output proc OptLengths {desc nlName tlName dlName} { upvar $nlName nl; upvar $tlName tl; upvar $dlName dl; foreach item $desc { if {[OptIsCounter $item]} continue; if {[OptIsPrg $item]} { OptLengths $item nl tl dl } else { SetMax nl [string length [OptName $item]] SetMax tl [string length [OptType $item]] set dv [OptTypeArgs $item]; if {[OptState $item] != "header"} { set dv "($dv)"; } set l [string length $dv]; # limit the space allocated to potentially big "choices" if {([OptType $item] != "choice") || ($l<=12)} { SetMax dl $l } else { if {![info exists dl]} { set dl 0 } } } } } # output the tree proc OptTree {desc nl tl dl} { set res ""; foreach item $desc { if {[OptIsCounter $item]} continue; if {[OptIsPrg $item]} { append res [OptTree $item $nl $tl $dl]; } else { set dv [OptTypeArgs $item]; if {[OptState $item] != "header"} { set dv "($dv)"; } append res [format "\n %-*s %-*s %-*s %s" \ $nl [OptName $item] $tl [OptType $item] \ $dl $dv [OptHelp $item]] } } return $res; } # Give nice usage string proc ::tcl::OptError {prefix desc {header 0}} { # determine length if {$header} { # add faked instruction set h [list [OptNewInst header Var/FlagName Type Value Help]]; lappend h [OptNewInst header ------------ ---- ----- ----]; lappend h [OptNewInst header {( -help} "" "" {gives this help )}] set desc [concat $h $desc] } OptLengths $desc nl tl dl # actually output return "$prefix[OptTree $desc $nl $tl $dl]" } ################ General Utility functions ####################### # # List utility functions # Naming convention: # "Lvarxxx" take the list VARiable name as argument # "Lxxxx" take the list value as argument # (which is not costly with Tcl8 objects system # as it's still a reference and not a copy of the values) # # Is that list empty ? proc ::tcl::Lempty {list} { expr {[llength $list]==0} } # Gets the value of one leaf of a lists tree proc ::tcl::Lget {list indexLst} { if {[llength $indexLst] <= 1} { return [lindex $list $indexLst]; } Lget [lindex $list [lindex $indexLst 0]] [lrange $indexLst 1 end]; } # Sets the value of one leaf of a lists tree # (we use the version that does not create the elements because # it would be even slower... needs to be written in C !) # (nb: there is a non trivial recursive problem with indexes 0, # which appear because there is no difference between a list # of 1 element and 1 element alone : [list "a"] == "a" while # it should be {a} and [listp a] should be 0 while [listp {a b}] would be 1 # and [listp "a b"] maybe 0. listp does not exist either...) proc ::tcl::Lvarset {listName indexLst newValue} { upvar $listName list; if {[llength $indexLst] <= 1} { Lvarset1nc list $indexLst $newValue; } else { set idx [lindex $indexLst 0]; set targetList [lindex $list $idx]; # reduce refcount on targetList (not really usefull now, # could be with optimizing compiler) # Lvarset1 list $idx {}; # recursively replace in targetList Lvarset targetList [lrange $indexLst 1 end] $newValue; # put updated sub list back in the tree Lvarset1nc list $idx $targetList; } } # Set one cell to a value, eventually create all the needed elements # (on level-1 of lists) variable emptyList {} proc ::tcl::Lvarset1 {listName index newValue} { upvar $listName list; if {$index < 0} {return -code error "invalid negative index"} set lg [llength $list]; if {$index >= $lg} { variable emptyList; for {set i $lg} {$i<$index} {incr i} { lappend list $emptyList; } lappend list $newValue; } else { set list [lreplace $list $index $index $newValue]; } } # same as Lvarset1 but no bound checking / creation proc ::tcl::Lvarset1nc {listName index newValue} { upvar $listName list; set list [lreplace $list $index $index $newValue]; } # Increments the value of one leaf of a lists tree # (which must exists) proc ::tcl::Lvarincr {listName indexLst {howMuch 1}} { upvar $listName list; if {[llength $indexLst] <= 1} { Lvarincr1 list $indexLst $howMuch; } else { set idx [lindex $indexLst 0]; set targetList [lindex $list $idx]; # reduce refcount on targetList Lvarset1nc list $idx {}; # recursively replace in targetList Lvarincr targetList [lrange $indexLst 1 end] $howMuch; # put updated sub list back in the tree Lvarset1nc list $idx $targetList; } } # Increments the value of one cell of a list proc ::tcl::Lvarincr1 {listName index {howMuch 1}} { upvar $listName list; set newValue [expr {[lindex $list $index]+$howMuch}]; set list [lreplace $list $index $index $newValue]; return $newValue; } # Removes the first element of a list # and returns the new list value proc ::tcl::Lvarpop1 {listName} { upvar $listName list; set list [lrange $list 1 end]; } # Same but returns the removed element # (Like the tclX version) proc ::tcl::Lvarpop {listName} { upvar $listName list; set el [lindex $list 0]; set list [lrange $list 1 end]; return $el; } # Assign list elements to variables and return the length of the list proc ::tcl::Lassign {list args} { # faster than direct blown foreach (which does not byte compile) set i 0; set lg [llength $list]; foreach vname $args { if {$i>=$lg} break uplevel 1 [list ::set $vname [lindex $list $i]]; incr i; } return $lg; } # Misc utilities # Set the varname to value if value is greater than varname's current value # or if varname is undefined proc ::tcl::SetMax {varname value} { upvar 1 $varname var if {![info exists var] || $value > $var} { set var $value } } # Set the varname to value if value is smaller than varname's current value # or if varname is undefined proc ::tcl::SetMin {varname value} { upvar 1 $varname var if {![info exists var] || $value < $var} { set var $value } } # everything loaded fine, lets create the test proc: # OptCreateTestProc # Don't need the create temp proc anymore: # rename OptCreateTestProc {} } Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/opt0.4/pkgIndex.tcl0100644000000000001200000000114107727704707031562 0ustar rootadmin# Tcl package index file, version 1.1 # This file is generated by the "pkg_mkIndex -direct" command # and sourced either when an application starts up or # by a "package unknown" script. It invokes the # "package ifneeded" command to set up package-related # information so that packages will be loaded automatically # in response to "package require" commands. When this # script is sourced, the variable $dir must contain the # full path name of this file's directory. if {![package vsatisfies [package provide Tcl] 8.2]} {return} package ifneeded opt 0.4.4.1 [list source [file join $dir optparse.tcl]] Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/package.tcl0100644000000000001200000005671007707713565030374 0ustar rootadmin# package.tcl -- # # utility procs formerly in init.tcl which can be loaded on demand # for package management. # # RCS: @(#) $Id: package.tcl,v 1.23.2.2 2003/07/24 08:23:17 rmax Exp $ # # Copyright (c) 1991-1993 The Regents of the University of California. # 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. # # Create the package namespace namespace eval ::pkg { } # pkg_compareExtension -- # # Used internally by pkg_mkIndex to compare the extension of a file to # a given extension. On Windows, it uses a case-insensitive comparison # because the file system can be file insensitive. # # Arguments: # fileName name of a file whose extension is compared # ext (optional) The extension to compare against; you must # provide the starting dot. # Defaults to [info sharedlibextension] # # Results: # Returns 1 if the extension matches, 0 otherwise proc pkg_compareExtension { fileName {ext {}} } { global tcl_platform if {![string length $ext]} {set ext [info sharedlibextension]} if {[string equal $tcl_platform(platform) "windows"]} { return [string equal -nocase [file extension $fileName] $ext] } else { # Some unices add trailing numbers after the .so, so # we could have something like '.so.1.2'. set root $fileName while {1} { set currExt [file extension $root] if {[string equal $currExt $ext]} { return 1 } # The current extension does not match; if it is not a numeric # value, quit, as we are only looking to ignore version number # extensions. Otherwise we might return 1 in this case: # pkg_compareExtension foo.so.bar .so # which should not match. if { ![string is integer -strict [string range $currExt 1 end]] } { return 0 } set root [file rootname $root] } } } # pkg_mkIndex -- # This procedure creates a package index in a given directory. The # package index consists of a "pkgIndex.tcl" file whose contents are # a Tcl script that sets up package information with "package require" # commands. The commands describe all of the packages defined by the # files given as arguments. # # Arguments: # -direct (optional) If this flag is present, the generated # code in pkgMkIndex.tcl will cause the package to be # loaded when "package require" is executed, rather # than lazily when the first reference to an exported # procedure in the package is made. # -verbose (optional) Verbose output; the name of each file that # was successfully rocessed is printed out. Additionally, # if processing of a file failed a message is printed. # -load pat (optional) Preload any packages whose names match # the pattern. Used to handle DLLs that depend on # other packages during their Init procedure. # dir - Name of the directory in which to create the index. # args - Any number of additional arguments, each giving # a glob pattern that matches the names of one or # more shared libraries or Tcl script files in # dir. proc pkg_mkIndex {args} { global errorCode errorInfo set usage {"pkg_mkIndex ?-direct? ?-lazy? ?-load pattern? ?-verbose? ?--? dir ?pattern ...?"}; set argCount [llength $args] if {$argCount < 1} { return -code error "wrong # args: should be\n$usage" } set more "" set direct 1 set doVerbose 0 set loadPat "" for {set idx 0} {$idx < $argCount} {incr idx} { set flag [lindex $args $idx] switch -glob -- $flag { -- { # done with the flags incr idx break } -verbose { set doVerbose 1 } -lazy { set direct 0 append more " -lazy" } -direct { append more " -direct" } -load { incr idx set loadPat [lindex $args $idx] append more " -load $loadPat" } -* { return -code error "unknown flag $flag: should be\n$usage" } default { # done with the flags break } } } set dir [lindex $args $idx] set patternList [lrange $args [expr {$idx + 1}] end] if {[llength $patternList] == 0} { set patternList [list "*.tcl" "*[info sharedlibextension]"] } set oldDir [pwd] cd $dir if {[catch {eval glob $patternList} fileList]} { global errorCode errorInfo cd $oldDir return -code error -errorcode $errorCode -errorinfo $errorInfo $fileList } foreach file $fileList { # For each file, figure out what commands and packages it provides. # To do this, create a child interpreter, load the file into the # interpreter, and get a list of the new commands and packages # that are defined. if {[string equal $file "pkgIndex.tcl"]} { continue } # Changed back to the original directory before initializing the # slave in case TCL_LIBRARY is a relative path (e.g. in the test # suite). cd $oldDir set c [interp create] # Load into the child any packages currently loaded in the parent # interpreter that match the -load pattern. if {[string length $loadPat]} { if {$doVerbose} { tclLog "currently loaded packages: '[info loaded]'" tclLog "trying to load all packages matching $loadPat" } if {![llength [info loaded]]} { tclLog "warning: no packages are currently loaded, nothing" tclLog "can possibly match '$loadPat'" } } foreach pkg [info loaded] { if {! [string match -nocase $loadPat [lindex $pkg 1]]} { continue } if {$doVerbose} { tclLog "package [lindex $pkg 1] matches '$loadPat'" } if {[catch { load [lindex $pkg 0] [lindex $pkg 1] $c } err]} { if {$doVerbose} { tclLog "warning: load [lindex $pkg 0] [lindex $pkg 1]\nfailed with: $err" } } elseif {$doVerbose} { tclLog "loaded [lindex $pkg 0] [lindex $pkg 1]" } if {[string equal [lindex $pkg 1] "Tk"]} { # Withdraw . if Tk was loaded, to avoid showing a window. $c eval [list wm withdraw .] } } cd $dir $c eval { # Stub out the package command so packages can # require other packages. rename package __package_orig proc package {what args} { switch -- $what { require { return ; # ignore transitive requires } default { eval __package_orig {$what} $args } } } proc tclPkgUnknown args {} package unknown tclPkgUnknown # Stub out the unknown command so package can call # into each other during their initialilzation. proc unknown {args} {} # Stub out the auto_import mechanism proc auto_import {args} {} # reserve the ::tcl namespace for support procs # and temporary variables. This might make it awkward # to generate a pkgIndex.tcl file for the ::tcl namespace. namespace eval ::tcl { variable file ;# Current file being processed variable direct ;# -direct flag value variable x ;# Loop variable variable debug ;# For debugging variable type ;# "load" or "source", for -direct variable namespaces ;# Existing namespaces (e.g., ::tcl) variable packages ;# Existing packages (e.g., Tcl) variable origCmds ;# Existing commands variable newCmds ;# Newly created commands variable newPkgs {} ;# Newly created packages } } $c eval [list set ::tcl::file $file] $c eval [list set ::tcl::direct $direct] # Download needed procedures into the slave because we've # just deleted the unknown procedure. This doesn't handle # procedures with default arguments. foreach p {pkg_compareExtension} { $c eval [list proc $p [info args $p] [info body $p]] } if {[catch { $c eval { set ::tcl::debug "loading or sourcing" # we need to track command defined by each package even in # the -direct case, because they are needed internally by # the "partial pkgIndex.tcl" step above. proc ::tcl::GetAllNamespaces {{root ::}} { set list $root foreach ns [namespace children $root] { eval lappend list [::tcl::GetAllNamespaces $ns] } return $list } # init the list of existing namespaces, packages, commands foreach ::tcl::x [::tcl::GetAllNamespaces] { set ::tcl::namespaces($::tcl::x) 1 } foreach ::tcl::x [package names] { if {[string compare [package provide $::tcl::x] ""]} { set ::tcl::packages($::tcl::x) 1 } } set ::tcl::origCmds [info commands] # Try to load the file if it has the shared library # extension, otherwise source it. It's important not to # try to load files that aren't shared libraries, because # on some systems (like SunOS) the loader will abort the # whole application when it gets an error. if {[pkg_compareExtension $::tcl::file [info sharedlibextension]]} { # The "file join ." command below is necessary. # Without it, if the file name has no \'s and we're # on UNIX, the load command will invoke the # LD_LIBRARY_PATH search mechanism, which could cause # the wrong file to be used. set ::tcl::debug loading load [file join . $::tcl::file] set ::tcl::type load } else { set ::tcl::debug sourcing source $::tcl::file set ::tcl::type source } # As a performance optimization, if we are creating # direct load packages, don't bother figuring out the # set of commands created by the new packages. We # only need that list for setting up the autoloading # used in the non-direct case. if { !$::tcl::direct } { # See what new namespaces appeared, and import commands # from them. Only exported commands go into the index. foreach ::tcl::x [::tcl::GetAllNamespaces] { if {! [info exists ::tcl::namespaces($::tcl::x)]} { namespace import -force ${::tcl::x}::* } # Figure out what commands appeared foreach ::tcl::x [info commands] { set ::tcl::newCmds($::tcl::x) 1 } foreach ::tcl::x $::tcl::origCmds { catch {unset ::tcl::newCmds($::tcl::x)} } foreach ::tcl::x [array names ::tcl::newCmds] { # determine which namespace a command comes from set ::tcl::abs [namespace origin $::tcl::x] # special case so that global names have no leading # ::, this is required by the unknown command set ::tcl::abs \ [lindex [auto_qualify $::tcl::abs ::] 0] if {[string compare $::tcl::x $::tcl::abs]} { # Name changed during qualification set ::tcl::newCmds($::tcl::abs) 1 unset ::tcl::newCmds($::tcl::x) } } } } # Look through the packages that appeared, and if there is # a version provided, then record it foreach ::tcl::x [package names] { if {[string compare [package provide $::tcl::x] ""] \ && ![info exists ::tcl::packages($::tcl::x)]} { lappend ::tcl::newPkgs \ [list $::tcl::x [package provide $::tcl::x]] } } } } msg] == 1} { set what [$c eval set ::tcl::debug] if {$doVerbose} { tclLog "warning: error while $what $file: $msg" } } else { set what [$c eval set ::tcl::debug] if {$doVerbose} { tclLog "successful $what of $file" } set type [$c eval set ::tcl::type] set cmds [lsort [$c eval array names ::tcl::newCmds]] set pkgs [$c eval set ::tcl::newPkgs] if {$doVerbose} { if { !$direct } { tclLog "commands provided were $cmds" } tclLog "packages provided were $pkgs" } if {[llength $pkgs] > 1} { tclLog "warning: \"$file\" provides more than one package ($pkgs)" } foreach pkg $pkgs { # cmds is empty/not used in the direct case lappend files($pkg) [list $file $type $cmds] } if {$doVerbose} { tclLog "processed $file" } } interp delete $c } append index "# Tcl package index file, version 1.1\n" append index "# This file is generated by the \"pkg_mkIndex$more\" command\n" append index "# and sourced either when an application starts up or\n" append index "# by a \"package unknown\" script. It invokes the\n" append index "# \"package ifneeded\" command to set up package-related\n" append index "# information so that packages will be loaded automatically\n" append index "# in response to \"package require\" commands. When this\n" append index "# script is sourced, the variable \$dir must contain the\n" append index "# full path name of this file's directory.\n" foreach pkg [lsort [array names files]] { set cmd {} foreach {name version} $pkg { break } lappend cmd ::pkg::create -name $name -version $version foreach spec $files($pkg) { foreach {file type procs} $spec { if { $direct } { set procs {} } lappend cmd "-$type" [list $file $procs] } } append index "\n[eval $cmd]" } set f [open pkgIndex.tcl w] puts $f $index close $f cd $oldDir } # tclPkgSetup -- # This is a utility procedure use by pkgIndex.tcl files. It is invoked # as part of a "package ifneeded" script. It calls "package provide" # to indicate that a package is available, then sets entries in the # auto_index array so that the package's files will be auto-loaded when # the commands are used. # # Arguments: # dir - Directory containing all the files for this package. # pkg - Name of the package (no version number). # version - Version number for the package, such as 2.1.3. # files - List of files that constitute the package. Each # element is a sub-list with three elements. The first # is the name of a file relative to $dir, the second is # "load" or "source", indicating whether the file is a # loadable binary or a script to source, and the third # is a list of commands defined by this file. proc tclPkgSetup {dir pkg version files} { global auto_index package provide $pkg $version foreach fileInfo $files { set f [lindex $fileInfo 0] set type [lindex $fileInfo 1] foreach cmd [lindex $fileInfo 2] { if {[string equal $type "load"]} { set auto_index($cmd) [list load [file join $dir $f] $pkg] } else { set auto_index($cmd) [list source [file join $dir $f]] } } } } # tclPkgUnknown -- # This procedure provides the default for the "package unknown" function. # It is invoked when a package that's needed can't be found. It scans # the auto_path directories and their immediate children looking for # pkgIndex.tcl files and sources any such files that are found to setup # the package database. (On the Macintosh we also search for pkgIndex # TEXT resources in all files.) As it searches, it will recognize changes # to the auto_path and scan any new directories. # # Arguments: # name - Name of desired package. Not used. # version - Version of desired package. Not used. # exact - Either "-exact" or omitted. Not used. proc tclPkgUnknown {name version {exact {}}} { global auto_path env if {![info exists auto_path]} { return } # Cache the auto_path, because it may change while we run through # the first set of pkgIndex.tcl files set old_path [set use_path $auto_path] while {[llength $use_path]} { set dir [lindex $use_path end] # Make sure we only scan each directory one time. if {[info exists tclSeenPath($dir)]} { set use_path [lrange $use_path 0 end-1] continue } set tclSeenPath($dir) 1 # we can't use glob in safe interps, so enclose the following # in a catch statement, where we get the pkgIndex files out # of the subdirectories catch { foreach file [glob -directory $dir -join -nocomplain \ * pkgIndex.tcl] { set dir [file dirname $file] if {![info exists procdDirs($dir)] && [file readable $file]} { if {[catch {source $file} msg]} { tclLog "error reading package index file $file: $msg" } else { set procdDirs($dir) 1 } } } } set dir [lindex $use_path end] if {![info exists procdDirs($dir)]} { set file [file join $dir pkgIndex.tcl] # safe interps usually don't have "file readable", # nor stderr channel if {([interp issafe] || [file readable $file])} { if {[catch {source $file} msg] && ![interp issafe]} { tclLog "error reading package index file $file: $msg" } else { set procdDirs($dir) 1 } } } set use_path [lrange $use_path 0 end-1] # Check whether any of the index scripts we [source]d above # set a new value for $::auto_path. If so, then find any # new directories on the $::auto_path, and lappend them to # the $use_path we are working from. This gives index scripts # the (arguably unwise) power to expand the index script search # path while the search is in progress. set index 0 if {[llength $old_path] == [llength $auto_path]} { foreach dir $auto_path old $old_path { if {$dir ne $old} { # This entry in $::auto_path has changed. break } incr index } } # $index now points to the first element of $auto_path that # has changed, or the beginning if $auto_path has changed length # Scan the new elements of $auto_path for directories to add to # $use_path. Don't add directories we've already seen, or ones # already on the $use_path. foreach dir [lrange $auto_path $index end] { if {![info exists tclSeenPath($dir)] && ([lsearch -exact $use_path $dir] == -1) } { lappend use_path $dir } } set old_path $auto_path } } # tcl::MacOSXPkgUnknown -- # This procedure extends the "package unknown" function for MacOSX. # It scans the Resources/Scripts directories of the immediate children # of the auto_path directories for pkgIndex files. # Only installed in interps that are not safe so we don't check # for [interp issafe] as in tclPkgUnknown. # # Arguments: # original - original [package unknown] procedure # name - Name of desired package. Not used. # version - Version of desired package. Not used. # exact - Either "-exact" or omitted. Not used. proc tcl::MacOSXPkgUnknown {original name version {exact {}}} { # First do the cross-platform default search uplevel 1 $original [list $name $version $exact] # Now do MacOSX specific searching global auto_path if {![info exists auto_path]} { return } # Cache the auto_path, because it may change while we run through # the first set of pkgIndex.tcl files set old_path [set use_path $auto_path] while {[llength $use_path]} { set dir [lindex $use_path end] # get the pkgIndex files out of the subdirectories foreach file [glob -directory $dir -join -nocomplain \ * Resources Scripts pkgIndex.tcl] { set dir [file dirname $file] if {[file readable $file] && ![info exists procdDirs($dir)]} { if {[catch {source $file} msg]} { tclLog "error reading package index file $file: $msg" } else { set procdDirs($dir) 1 } } } set use_path [lrange $use_path 0 end-1] if {[string compare $old_path $auto_path]} { foreach dir $auto_path { lappend use_path $dir } set old_path $auto_path } } } # tcl::MacPkgUnknown -- # This procedure extends the "package unknown" function for Mac. # It searches for pkgIndex TEXT resources in all files # Only installed in interps that are not safe so we don't check # for [interp issafe] as in tclPkgUnknown. # # Arguments: # original - original [package unknown] procedure # name - Name of desired package. Not used. # version - Version of desired package. Not used. # exact - Either "-exact" or omitted. Not used. proc tcl::MacPkgUnknown {original name version {exact {}}} { # First do the cross-platform default search uplevel 1 $original [list $name $version $exact] # Now do Mac specific searching global auto_path if {![info exists auto_path]} { return } # Cache the auto_path, because it may change while we run through # the first set of pkgIndex.tcl files set old_path [set use_path $auto_path] while {[llength $use_path]} { # We look for pkgIndex TEXT resources in the resource fork of shared libraries set dir [lindex $use_path end] foreach x [concat [list $dir] [glob -directory $dir -nocomplain *] ] { if {[file isdirectory $x] && ![info exists procdDirs($x)]} { set dir $x foreach x [glob -directory $dir -nocomplain *.shlb] { if {[file isfile $x]} { set res [resource open $x] foreach y [resource list TEXT $res] { if {[string equal $y "pkgIndex"]} {source -rsrc pkgIndex} } catch {resource close $res} } } set procdDirs($dir) 1 } } set use_path [lrange $use_path 0 end-1] if {[string compare $old_path $auto_path]} { foreach dir $auto_path { lappend use_path $dir } set old_path $auto_path } } } # ::pkg::create -- # # Given a package specification generate a "package ifneeded" statement # for the package, suitable for inclusion in a pkgIndex.tcl file. # # Arguments: # args arguments used by the create function: # -name packageName # -version packageVersion # -load {filename ?{procs}?} # ... # -source {filename ?{procs}?} # ... # # Any number of -load and -source parameters may be # specified, so long as there is at least one -load or # -source parameter. If the procs component of a # module specifier is left off, that module will be # set up for direct loading; otherwise, it will be # set up for lazy loading. If both -source and -load # are specified, the -load'ed files will be loaded # first, followed by the -source'd files. # # Results: # An appropriate "package ifneeded" statement for the package. proc ::pkg::create {args} { append err(usage) "[lindex [info level 0] 0] " append err(usage) "-name packageName -version packageVersion" append err(usage) "?-load {filename ?{procs}?}? ... " append err(usage) "?-source {filename ?{procs}?}? ..." set err(wrongNumArgs) "wrong # args: should be \"$err(usage)\"" set err(valueMissing) "value for \"%s\" missing: should be \"$err(usage)\"" set err(unknownOpt) "unknown option \"%s\": should be \"$err(usage)\"" set err(noLoadOrSource) "at least one of -load and -source must be given" # process arguments set len [llength $args] if { $len < 6 } { error $err(wrongNumArgs) } # Initialize parameters set opts(-name) {} set opts(-version) {} set opts(-source) {} set opts(-load) {} # process parameters for {set i 0} {$i < $len} {incr i} { set flag [lindex $args $i] incr i switch -glob -- $flag { "-name" - "-version" { if { $i >= $len } { error [format $err(valueMissing) $flag] } set opts($flag) [lindex $args $i] } "-source" - "-load" { if { $i >= $len } { error [format $err(valueMissing) $flag] } lappend opts($flag) [lindex $args $i] } default { error [format $err(unknownOpt) [lindex $args $i]] } } } # Validate the parameters if { [llength $opts(-name)] == 0 } { error [format $err(valueMissing) "-name"] } if { [llength $opts(-version)] == 0 } { error [format $err(valueMissing) "-version"] } if { [llength $opts(-source)] == 0 && [llength $opts(-load)] == 0 } { error $err(noLoadOrSource) } # OK, now everything is good. Generate the package ifneeded statment. set cmdline "package ifneeded $opts(-name) $opts(-version) " set cmdList {} set lazyFileList {} # Handle -load and -source specs foreach key {load source} { foreach filespec $opts(-$key) { foreach {filename proclist} {{} {}} { break } foreach {filename proclist} $filespec { break } if { [llength $proclist] == 0 } { set cmd "\[list $key \[file join \$dir [list $filename]\]\]" lappend cmdList $cmd } else { lappend lazyFileList [list $filename $key $proclist] } } } if { [llength $lazyFileList] > 0 } { lappend cmdList "\[list tclPkgSetup \$dir $opts(-name)\ $opts(-version) [list $lazyFileList]\]" } append cmdline [join $cmdList "\\n"] return $cmdline } Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/parray.tcl0100644000000000001200000000156206577261403030263 0ustar rootadmin# parray: # Print the contents of a global array on stdout. # # RCS: @(#) $Id: parray.tcl,v 1.3 1998/09/14 18:40:03 stanton Exp $ # # Copyright (c) 1991-1993 The Regents of the University of California. # Copyright (c) 1994 Sun Microsystems, Inc. # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # proc parray {a {pattern *}} { upvar 1 $a array if {![array exists array]} { error "\"$a\" isn't an array" } set maxl 0 foreach name [lsort [array names array $pattern]] { if {[string length $name] > $maxl} { set maxl [string length $name] } } set maxl [expr {$maxl + [string length $a] + 2}] foreach name [lsort [array names array $pattern]] { set nameString [format %s(%s) $a $name] puts stdout [format "%-*s = %s" $maxl $nameString $array($name)] } } Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/realinit.tcl0100644000000000001200000005470510145254126030571 0ustar rootadmin# init.tcl -- # # Default system startup file for Tcl-based applications. Defines # "unknown" procedure and auto-load facilities. # # RCS: @(#) $Id: init.tcl,v 1.55.2.4 2004/11/13 00:41:58 dgp Exp $ # # Copyright (c) 1991-1993 The Regents of the University of California. # Copyright (c) 1994-1996 Sun Microsystems, Inc. # Copyright (c) 1998-1999 Scriptics Corporation. # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # if {[info commands package] == ""} { error "version mismatch: library\nscripts expect Tcl version 7.5b1 or later but the loaded version is\nonly [info patchlevel]" } package require -exact Tcl 8.4 # Compute the auto path to use in this interpreter. # The values on the path come from several locations: # # The environment variable TCLLIBPATH # # tcl_library, which is the directory containing this init.tcl script. # tclInitScript.h searches around for the directory containing this # init.tcl and defines tcl_library to that location before sourcing it. # # The parent directory of tcl_library. Adding the parent # means that packages in peer directories will be found automatically. # # Also add the directory ../lib relative to the directory where the # executable is located. This is meant to find binary packages for the # same architecture as the current executable. # # tcl_pkgPath, which is set by the platform-specific initialization routines # On UNIX it is compiled in # On Windows, it is not used # On Macintosh it is "Tool Command Language" in the Extensions folder if {![info exists auto_path]} { if {[info exists env(TCLLIBPATH)]} { set auto_path $env(TCLLIBPATH) } else { set auto_path "" } } namespace eval tcl { variable Dir if {[info library] != ""} { foreach Dir [list [info library] [file dirname [info library]]] { if {[lsearch -exact $::auto_path $Dir] < 0} { lappend ::auto_path $Dir } } } set Dir [file join [file dirname [file dirname \ [info nameofexecutable]]] lib] if {[lsearch -exact $::auto_path $Dir] < 0} { lappend ::auto_path $Dir } if {[info exists ::tcl_pkgPath]} { foreach Dir $::tcl_pkgPath { if {[lsearch -exact $::auto_path $Dir] < 0} { lappend ::auto_path $Dir } } } } # Windows specific end of initialization if {(![interp issafe]) && [string equal $tcl_platform(platform) "windows"]} { namespace eval tcl { proc EnvTraceProc {lo n1 n2 op} { set x $::env($n2) set ::env($lo) $x set ::env([string toupper $lo]) $x } proc InitWinEnv {} { global env tcl_platform foreach p [array names env] { set u [string toupper $p] if {![string equal $u $p]} { switch -- $u { COMSPEC - PATH { if {![info exists env($u)]} { set env($u) $env($p) } trace variable env($p) w \ [namespace code [list EnvTraceProc $p]] trace variable env($u) w \ [namespace code [list EnvTraceProc $p]] } } } } if {![info exists env(COMSPEC)]} { if {[string equal $tcl_platform(os) "Windows NT"]} { set env(COMSPEC) cmd.exe } else { set env(COMSPEC) command.com } } } InitWinEnv } } # Setup the unknown package handler package unknown tclPkgUnknown if {![interp issafe]} { # setup platform specific unknown package handlers if {[string equal $::tcl_platform(platform) "unix"] && \ [string equal $::tcl_platform(os) "Darwin"]} { package unknown [list tcl::MacOSXPkgUnknown [package unknown]] } if {[string equal $::tcl_platform(platform) "macintosh"]} { package unknown [list tcl::MacPkgUnknown [package unknown]] } } # Conditionalize for presence of exec. if {[llength [info commands exec]] == 0} { # Some machines, such as the Macintosh, do not have exec. Also, on all # platforms, safe interpreters do not have exec. set auto_noexec 1 } set errorCode "" set errorInfo "" # Define a log command (which can be overwitten to log errors # differently, specially when stderr is not available) if {[llength [info commands tclLog]] == 0} { proc tclLog {string} { catch {puts stderr $string} } } # unknown -- # This procedure is called when a Tcl command is invoked that doesn't # exist in the interpreter. It takes the following steps to make the # command available: # # 1. See if the command has the form "namespace inscope ns cmd" and # if so, concatenate its arguments onto the end and evaluate it. # 2. See if the autoload facility can locate the command in a # Tcl script file. If so, load it and execute it. # 3. If the command was invoked interactively at top-level: # (a) see if the command exists as an executable UNIX program. # If so, "exec" the command. # (b) see if the command requests csh-like history substitution # in one of the common forms !!, !, or ^old^new. If # so, emulate csh's history substitution. # (c) see if the command is a unique abbreviation for another # command. If so, invoke the command. # # Arguments: # args - A list whose elements are the words of the original # command, including the command name. proc unknown args { global auto_noexec auto_noload env unknown_pending tcl_interactive global errorCode errorInfo # If the command word has the form "namespace inscope ns cmd" # then concatenate its arguments onto the end and evaluate it. set cmd [lindex $args 0] if {[regexp "^:*namespace\[ \t\n\]+inscope" $cmd] && [llength $cmd] == 4} { set arglist [lrange $args 1 end] set ret [catch {uplevel 1 ::$cmd $arglist} result] if {$ret == 0} { return $result } else { return -code $ret -errorcode $errorCode $result } } # Save the values of errorCode and errorInfo variables, since they # may get modified if caught errors occur below. The variables will # be restored just before re-executing the missing command. # Safety check in case something unsets the variables # ::errorInfo or ::errorCode. [Bug 1063707] if {![info exists errorCode]} { set errorCode "" } if {![info exists errorInfo]} { set errorInfo "" } set savedErrorCode $errorCode set savedErrorInfo $errorInfo set name [lindex $args 0] if {![info exists auto_noload]} { # # Make sure we're not trying to load the same proc twice. # if {[info exists unknown_pending($name)]} { return -code error "self-referential recursion in \"unknown\" for command \"$name\""; } set unknown_pending($name) pending; set ret [catch {auto_load $name [uplevel 1 {::namespace current}]} msg] unset unknown_pending($name); if {$ret != 0} { append errorInfo "\n (autoloading \"$name\")" return -code $ret -errorcode $errorCode -errorinfo $errorInfo $msg } if {![array size unknown_pending]} { unset unknown_pending } if {$msg} { set errorCode $savedErrorCode set errorInfo $savedErrorInfo set code [catch {uplevel 1 $args} msg] if {$code == 1} { # # Compute stack trace contribution from the [uplevel]. # Note the dependence on how Tcl_AddErrorInfo, etc. # construct the stack trace. # set cinfo $args set ellipsis "" while {[string bytelength $cinfo] > 150} { set cinfo [string range $cinfo 0 end-1] set ellipsis "..." } append cinfo $ellipsis "\"\n (\"uplevel\" body line 1)" append cinfo "\n invoked from within" append cinfo "\n\"uplevel 1 \$args\"" # # Try each possible form of the stack trace # and trim the extra contribution from the matching case # set expect "$msg\n while executing\n\"$cinfo" if {$errorInfo eq $expect} { # # The stack has only the eval from the expanded command # Do not generate any stack trace here. # return -code error -errorcode $errorCode $msg } # # Stack trace is nested, trim off just the contribution # from the extra "eval" of $args due to the "catch" above. # set expect "\n invoked from within\n\"$cinfo" set exlen [string length $expect] set eilen [string length $errorInfo] set i [expr {$eilen - $exlen - 1}] set einfo [string range $errorInfo 0 $i] # # For now verify that $errorInfo consists of what we are about # to return plus what we expected to trim off. # if {$errorInfo ne "$einfo$expect"} { error "Tcl bug: unexpected stack trace in \"unknown\"" {} \ [list CORE UNKNOWN BADTRACE $expect $errorInfo] } return -code error -errorcode $errorCode \ -errorinfo $einfo $msg } else { return -code $code $msg } } } if {([info level] == 1) && [string equal [info script] ""] \ && [info exists tcl_interactive] && $tcl_interactive} { if {![info exists auto_noexec]} { set new [auto_execok $name] if {$new != ""} { set errorCode $savedErrorCode set errorInfo $savedErrorInfo set redir "" if {[string equal [info commands console] ""]} { set redir ">&@stdout <@stdin" } return [uplevel 1 exec $redir $new [lrange $args 1 end]] } } set errorCode $savedErrorCode set errorInfo $savedErrorInfo if {[string equal $name "!!"]} { set newcmd [history event] } elseif {[regexp {^!(.+)$} $name dummy event]} { set newcmd [history event $event] } elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name dummy old new]} { set newcmd [history event -1] catch {regsub -all -- $old $newcmd $new newcmd} } if {[info exists newcmd]} { tclLog $newcmd history change $newcmd 0 return [uplevel 1 $newcmd] } set ret [catch {set candidates [info commands $name*]} msg] if {[string equal $name "::"]} { set name "" } if {$ret != 0} { return -code $ret -errorcode $errorCode \ "error in unknown while checking if \"$name\" is\ a unique command abbreviation:\n$msg" } # Filter out bogus matches when $name contained # a glob-special char [Bug 946952] set cmds [list] foreach x $candidates { if {[string range $x 0 [expr [string length $name]-1]] eq $name} { lappend cmds $x } } if {[llength $cmds] == 1} { return [uplevel 1 [lreplace $args 0 0 $cmds]] } if {[llength $cmds]} { if {[string equal $name ""]} { return -code error "empty command name \"\"" } else { return -code error \ "ambiguous command name \"$name\": [lsort $cmds]" } } } return -code error "invalid command name \"$name\"" } # auto_load -- # Checks a collection of library directories to see if a procedure # is defined in one of them. If so, it sources the appropriate # library file to create the procedure. Returns 1 if it successfully # loaded the procedure, 0 otherwise. # # Arguments: # cmd - Name of the command to find and load. # namespace (optional) The namespace where the command is being used - must be # a canonical namespace as returned [namespace current] # for instance. If not given, namespace current is used. proc auto_load {cmd {namespace {}}} { global auto_index auto_oldpath auto_path if {[string length $namespace] == 0} { set namespace [uplevel 1 [list ::namespace current]] } set nameList [auto_qualify $cmd $namespace] # workaround non canonical auto_index entries that might be around # from older auto_mkindex versions lappend nameList $cmd foreach name $nameList { if {[info exists auto_index($name)]} { namespace eval :: $auto_index($name) # There's a couple of ways to look for a command of a given # name. One is to use # info commands $name # Unfortunately, if the name has glob-magic chars in it like * # or [], it may not match. For our purposes here, a better # route is to use # namespace which -command $name if {[namespace which -command $name] ne ""} { return 1 } } } if {![info exists auto_path]} { return 0 } if {![auto_load_index]} { return 0 } foreach name $nameList { if {[info exists auto_index($name)]} { namespace eval :: $auto_index($name) if {[namespace which -command $name] ne ""} { return 1 } } } return 0 } # auto_load_index -- # Loads the contents of tclIndex files on the auto_path directory # list. This is usually invoked within auto_load to load the index # of available commands. Returns 1 if the index is loaded, and 0 if # the index is already loaded and up to date. # # Arguments: # None. proc auto_load_index {} { global auto_index auto_oldpath auto_path errorInfo errorCode if {[info exists auto_oldpath] && \ [string equal $auto_oldpath $auto_path]} { return 0 } set auto_oldpath $auto_path # Check if we are a safe interpreter. In that case, we support only # newer format tclIndex files. set issafe [interp issafe] for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} { set dir [lindex $auto_path $i] set f "" if {$issafe} { catch {source [file join $dir tclIndex]} } elseif {[catch {set f [open [file join $dir tclIndex]]}]} { continue } else { set error [catch { set id [gets $f] if {[string equal $id \ "# Tcl autoload index file, version 2.0"]} { eval [read $f] } elseif {[string equal $id "# Tcl autoload index file: each line identifies a Tcl"]} { while {[gets $f line] >= 0} { if {[string equal [string index $line 0] "#"] \ || ([llength $line] != 2)} { continue } set name [lindex $line 0] set auto_index($name) \ "source [file join $dir [lindex $line 1]]" } } else { error "[file join $dir tclIndex] isn't a proper Tcl index file" } } msg] if {$f != ""} { close $f } if {$error} { error $msg $errorInfo $errorCode } } } return 1 } # auto_qualify -- # # Compute a fully qualified names list for use in the auto_index array. # For historical reasons, commands in the global namespace do not have leading # :: in the index key. The list has two elements when the command name is # relative (no leading ::) and the namespace is not the global one. Otherwise # only one name is returned (and searched in the auto_index). # # Arguments - # cmd The command name. Can be any name accepted for command # invocations (Like "foo::::bar"). # namespace The namespace where the command is being used - must be # a canonical namespace as returned by [namespace current] # for instance. proc auto_qualify {cmd namespace} { # count separators and clean them up # (making sure that foo:::::bar will be treated as foo::bar) set n [regsub -all {::+} $cmd :: cmd] # Ignore namespace if the name starts with :: # Handle special case of only leading :: # Before each return case we give an example of which category it is # with the following form : # ( inputCmd, inputNameSpace) -> output if {[regexp {^::(.*)$} $cmd x tail]} { if {$n > 1} { # ( ::foo::bar , * ) -> ::foo::bar return [list $cmd] } else { # ( ::global , * ) -> global return [list $tail] } } # Potentially returning 2 elements to try : # (if the current namespace is not the global one) if {$n == 0} { if {[string equal $namespace ::]} { # ( nocolons , :: ) -> nocolons return [list $cmd] } else { # ( nocolons , ::sub ) -> ::sub::nocolons nocolons return [list ${namespace}::$cmd $cmd] } } elseif {[string equal $namespace ::]} { # ( foo::bar , :: ) -> ::foo::bar return [list ::$cmd] } else { # ( foo::bar , ::sub ) -> ::sub::foo::bar ::foo::bar return [list ${namespace}::$cmd ::$cmd] } } # auto_import -- # # Invoked during "namespace import" to make see if the imported commands # reside in an autoloaded library. If so, the commands are loaded so # that they will be available for the import links. If not, then this # procedure does nothing. # # Arguments - # pattern The pattern of commands being imported (like "foo::*") # a canonical namespace as returned by [namespace current] proc auto_import {pattern} { global auto_index # If no namespace is specified, this will be an error case if {![string match *::* $pattern]} { return } set ns [uplevel 1 [list ::namespace current]] set patternList [auto_qualify $pattern $ns] auto_load_index foreach pattern $patternList { foreach name [array names auto_index $pattern] { if {([namespace which -command $name] eq "") && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} { namespace eval :: $auto_index($name) } } } } # auto_execok -- # # Returns string that indicates name of program to execute if # name corresponds to a shell builtin or an executable in the # Windows search path, or "" otherwise. Builds an associative # array auto_execs that caches information about previous checks, # for speed. # # Arguments: # name - Name of a command. if {[string equal windows $tcl_platform(platform)]} { # Windows version. # # Note that info executable doesn't work under Windows, so we have to # look for files with .exe, .com, or .bat extensions. Also, the path # may be in the Path or PATH environment variables, and path # components are separated with semicolons, not colons as under Unix. # proc auto_execok name { global auto_execs env tcl_platform if {[info exists auto_execs($name)]} { return $auto_execs($name) } set auto_execs($name) "" set shellBuiltins [list cls copy date del erase dir echo mkdir \ md rename ren rmdir rd time type ver vol] if {[string equal $tcl_platform(os) "Windows NT"]} { # NT includes the 'start' built-in lappend shellBuiltins "start" } if {[info exists env(PATHEXT)]} { # Add an initial ; to have the {} extension check first. set execExtensions [split ";$env(PATHEXT)" ";"] } else { set execExtensions [list {} .com .exe .bat] } if {[lsearch -exact $shellBuiltins $name] != -1} { # When this is command.com for some reason on Win2K, Tcl won't # exec it unless the case is right, which this corrects. COMSPEC # may not point to a real file, so do the check. set cmd $env(COMSPEC) if {[file exists $cmd]} { set cmd [file attributes $cmd -shortname] } return [set auto_execs($name) [list $cmd /c $name]] } if {[llength [file split $name]] != 1} { foreach ext $execExtensions { set file ${name}${ext} if {[file exists $file] && ![file isdirectory $file]} { return [set auto_execs($name) [list $file]] } } return "" } set path "[file dirname [info nameof]];.;" if {[info exists env(WINDIR)]} { set windir $env(WINDIR) } if {[info exists windir]} { if {[string equal $tcl_platform(os) "Windows NT"]} { append path "$windir/system32;" } append path "$windir/system;$windir;" } foreach var {PATH Path path} { if {[info exists env($var)]} { append path ";$env($var)" } } foreach dir [split $path {;}] { # Skip already checked directories if {[info exists checked($dir)] || [string equal {} $dir]} { continue } set checked($dir) {} foreach ext $execExtensions { set file [file join $dir ${name}${ext}] if {[file exists $file] && ![file isdirectory $file]} { return [set auto_execs($name) [list $file]] } } } return "" } } else { # Unix version. # proc auto_execok name { global auto_execs env if {[info exists auto_execs($name)]} { return $auto_execs($name) } set auto_execs($name) "" if {[llength [file split $name]] != 1} { if {[file executable $name] && ![file isdirectory $name]} { set auto_execs($name) [list $name] } return $auto_execs($name) } foreach dir [split $env(PATH) :] { if {[string equal $dir ""]} { set dir . } set file [file join $dir $name] if {[file executable $file] && ![file isdirectory $file]} { set auto_execs($name) [list $file] return $auto_execs($name) } } return "" } } # ::tcl::CopyDirectory -- # # This procedure is called by Tcl's core when attempts to call the # filesystem's copydirectory function fail. The semantics of the call # are that 'dest' does not yet exist, i.e. dest should become the exact # image of src. If dest does exist, we throw an error. # # Note that making changes to this procedure can change the results # of running Tcl's tests. # # Arguments: # action - "renaming" or "copying" # src - source directory # dest - destination directory proc tcl::CopyDirectory {action src dest} { set nsrc [file normalize $src] set ndest [file normalize $dest] if {[string equal $action "renaming"]} { # Can't rename volumes. We could give a more precise # error message here, but that would break the test suite. if {[lsearch -exact [file volumes] $nsrc] != -1} { return -code error "error $action \"$src\" to\ \"$dest\": trying to rename a volume or move a directory\ into itself" } } if {[file exists $dest]} { if {$nsrc == $ndest} { return -code error "error $action \"$src\" to\ \"$dest\": trying to rename a volume or move a directory\ into itself" } if {[string equal $action "copying"]} { return -code error "error $action \"$src\" to\ \"$dest\": file already exists" } else { # Depending on the platform, and on the current # working directory, the directories '.', '..' # can be returned in various combinations. Anyway, # if any other file is returned, we must signal an error. set existing [glob -nocomplain -directory $dest * .*] eval [list lappend existing] \ [glob -nocomplain -directory $dest -type hidden * .*] foreach s $existing { if {([file tail $s] != ".") && ([file tail $s] != "..")} { return -code error "error $action \"$src\" to\ \"$dest\": file already exists" } } } } else { if {[string first $nsrc $ndest] != -1} { set srclen [expr {[llength [file split $nsrc]] -1}] set ndest [lindex [file split $ndest] $srclen] if {$ndest == [file tail $nsrc]} { return -code error "error $action \"$src\" to\ \"$dest\": trying to rename a volume or move a directory\ into itself" } } file mkdir $dest } # Have to be careful to capture both visible and hidden files. # We will also be more generous to the file system and not # assume the hidden and non-hidden lists are non-overlapping. # # On Unix 'hidden' files begin with '.'. On other platforms # or filesystems hidden files may have other interpretations. set filelist [concat [glob -nocomplain -directory $src *] \ [glob -nocomplain -directory $src -types hidden *]] foreach s [lsort -unique $filelist] { if {([file tail $s] != ".") && ([file tail $s] != "..")} { file copy $s [file join $dest [file tail $s]] } } return } Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/safe.tcl0100644000000000001200000006611410070234265027674 0ustar rootadmin# safe.tcl -- # # This file provide a safe loading/sourcing mechanism for safe interpreters. # It implements a virtual path mecanism to hide the real pathnames from the # slave. It runs in a master interpreter and sets up data structure and # aliases that will be invoked when used from a slave interpreter. # # See the safe.n man page for details. # # Copyright (c) 1996-1997 Sun Microsystems, Inc. # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # # RCS: @(#) $Id: safe.tcl,v 1.9.2.2 2004/06/29 09:39:01 dkf Exp $ # # The implementation is based on namespaces. These naming conventions # are followed: # Private procs starts with uppercase. # Public procs are exported and starts with lowercase # # Needed utilities package package require opt 0.4.1; # Create the safe namespace namespace eval ::safe { # Exported API: namespace export interpCreate interpInit interpConfigure interpDelete \ interpAddToAccessPath interpFindInAccessPath setLogCmd #### # # Setup the arguments parsing # #### # Make sure that our temporary variable is local to this # namespace. [Bug 981733] variable temp # Share the descriptions set temp [::tcl::OptKeyRegister { {-accessPath -list {} "access path for the slave"} {-noStatics "prevent loading of statically linked pkgs"} {-statics true "loading of statically linked pkgs"} {-nestedLoadOk "allow nested loading"} {-nested false "nested loading"} {-deleteHook -script {} "delete hook"} }] # create case (slave is optional) ::tcl::OptKeyRegister { {?slave? -name {} "name of the slave (optional)"} } ::safe::interpCreate # adding the flags sub programs to the command program # (relying on Opt's internal implementation details) lappend ::tcl::OptDesc(::safe::interpCreate) $::tcl::OptDesc($temp) # init and configure (slave is needed) ::tcl::OptKeyRegister { {slave -name {} "name of the slave"} } ::safe::interpIC # adding the flags sub programs to the command program # (relying on Opt's internal implementation details) lappend ::tcl::OptDesc(::safe::interpIC) $::tcl::OptDesc($temp) # temp not needed anymore ::tcl::OptKeyDelete $temp # Helper function to resolve the dual way of specifying staticsok # (either by -noStatics or -statics 0) proc InterpStatics {} { foreach v {Args statics noStatics} { upvar $v $v } set flag [::tcl::OptProcArgGiven -noStatics]; if {$flag && ($noStatics == $statics) && ([::tcl::OptProcArgGiven -statics])} { return -code error\ "conflicting values given for -statics and -noStatics" } if {$flag} { return [expr {!$noStatics}] } else { return $statics } } # Helper function to resolve the dual way of specifying nested loading # (either by -nestedLoadOk or -nested 1) proc InterpNested {} { foreach v {Args nested nestedLoadOk} { upvar $v $v } set flag [::tcl::OptProcArgGiven -nestedLoadOk]; # note that the test here is the opposite of the "InterpStatics" # one (it is not -noNested... because of the wanted default value) if {$flag && ($nestedLoadOk != $nested) && ([::tcl::OptProcArgGiven -nested])} { return -code error\ "conflicting values given for -nested and -nestedLoadOk" } if {$flag} { # another difference with "InterpStatics" return $nestedLoadOk } else { return $nested } } #### # # API entry points that needs argument parsing : # #### # Interface/entry point function and front end for "Create" proc interpCreate {args} { set Args [::tcl::OptKeyParse ::safe::interpCreate $args] InterpCreate $slave $accessPath \ [InterpStatics] [InterpNested] $deleteHook } proc interpInit {args} { set Args [::tcl::OptKeyParse ::safe::interpIC $args] if {![::interp exists $slave]} { return -code error "\"$slave\" is not an interpreter" } InterpInit $slave $accessPath \ [InterpStatics] [InterpNested] $deleteHook; } proc CheckInterp {slave} { if {![IsInterp $slave]} { return -code error \ "\"$slave\" is not an interpreter managed by ::safe::" } } # Interface/entry point function and front end for "Configure" # This code is awfully pedestrian because it would need # more coupling and support between the way we store the # configuration values in safe::interp's and the Opt package # Obviously we would like an OptConfigure # to avoid duplicating all this code everywhere. -> TODO # (the app should share or access easily the program/value # stored by opt) # This is even more complicated by the boolean flags with no values # that we had the bad idea to support for the sake of user simplicity # in create/init but which makes life hard in configure... # So this will be hopefully written and some integrated with opt1.0 # (hopefully for tcl8.1 ?) proc interpConfigure {args} { switch [llength $args] { 1 { # If we have exactly 1 argument # the semantic is to return all the current configuration # We still call OptKeyParse though we know that "slave" # is our given argument because it also checks # for the "-help" option. set Args [::tcl::OptKeyParse ::safe::interpIC $args] CheckInterp $slave set res {} lappend res [list -accessPath [Set [PathListName $slave]]] lappend res [list -statics [Set [StaticsOkName $slave]]] lappend res [list -nested [Set [NestedOkName $slave]]] lappend res [list -deleteHook [Set [DeleteHookName $slave]]] join $res } 2 { # If we have exactly 2 arguments # the semantic is a "configure get" ::tcl::Lassign $args slave arg # get the flag sub program (we 'know' about Opt's internal # representation of data) set desc [lindex [::tcl::OptKeyGetDesc ::safe::interpIC] 2] set hits [::tcl::OptHits desc $arg] if {$hits > 1} { return -code error [::tcl::OptAmbigous $desc $arg] } elseif {$hits == 0} { return -code error [::tcl::OptFlagUsage $desc $arg] } CheckInterp $slave set item [::tcl::OptCurDesc $desc] set name [::tcl::OptName $item] switch -exact -- $name { -accessPath { return [list -accessPath [Set [PathListName $slave]]] } -statics { return [list -statics [Set [StaticsOkName $slave]]] } -nested { return [list -nested [Set [NestedOkName $slave]]] } -deleteHook { return [list -deleteHook [Set [DeleteHookName $slave]]] } -noStatics { # it is most probably a set in fact # but we would need then to jump to the set part # and it is not *sure* that it is a set action # that the user want, so force it to use the # unambigous -statics ?value? instead: return -code error\ "ambigous query (get or set -noStatics ?)\ use -statics instead" } -nestedLoadOk { return -code error\ "ambigous query (get or set -nestedLoadOk ?)\ use -nested instead" } default { return -code error "unknown flag $name (bug)" } } } default { # Otherwise we want to parse the arguments like init and create # did set Args [::tcl::OptKeyParse ::safe::interpIC $args] CheckInterp $slave # Get the current (and not the default) values of # whatever has not been given: if {![::tcl::OptProcArgGiven -accessPath]} { set doreset 1 set accessPath [Set [PathListName $slave]] } else { set doreset 0 } if {(![::tcl::OptProcArgGiven -statics]) \ && (![::tcl::OptProcArgGiven -noStatics]) } { set statics [Set [StaticsOkName $slave]] } else { set statics [InterpStatics] } if {([::tcl::OptProcArgGiven -nested]) \ || ([::tcl::OptProcArgGiven -nestedLoadOk]) } { set nested [InterpNested] } else { set nested [Set [NestedOkName $slave]] } if {![::tcl::OptProcArgGiven -deleteHook]} { set deleteHook [Set [DeleteHookName $slave]] } # we can now reconfigure : InterpSetConfig $slave $accessPath $statics $nested $deleteHook # auto_reset the slave (to completly synch the new access_path) if {$doreset} { if {[catch {::interp eval $slave {auto_reset}} msg]} { Log $slave "auto_reset failed: $msg" } else { Log $slave "successful auto_reset" NOTICE } } } } } #### # # Functions that actually implements the exported APIs # #### # # safe::InterpCreate : doing the real job # # This procedure creates a safe slave and initializes it with the # safe base aliases. # NB: slave name must be simple alphanumeric string, no spaces, # no (), no {},... {because the state array is stored as part of the name} # # Returns the slave name. # # Optional Arguments : # + slave name : if empty, generated name will be used # + access_path: path list controlling where load/source can occur, # if empty: the master auto_path will be used. # + staticsok : flag, if 0 :no static package can be loaded (load {} Xxx) # if 1 :static packages are ok. # + nestedok: flag, if 0 :no loading to sub-sub interps (load xx xx sub) # if 1 : multiple levels are ok. # use the full name and no indent so auto_mkIndex can find us proc ::safe::InterpCreate { slave access_path staticsok nestedok deletehook } { # Create the slave. if {$slave ne ""} { ::interp create -safe $slave } else { # empty argument: generate slave name set slave [::interp create -safe] } Log $slave "Created" NOTICE # Initialize it. (returns slave name) InterpInit $slave $access_path $staticsok $nestedok $deletehook } # # InterpSetConfig (was setAccessPath) : # Sets up slave virtual auto_path and corresponding structure # within the master. Also sets the tcl_library in the slave # to be the first directory in the path. # Nb: If you change the path after the slave has been initialized # you probably need to call "auto_reset" in the slave in order that it # gets the right auto_index() array values. proc ::safe::InterpSetConfig {slave access_path staticsok\ nestedok deletehook} { # determine and store the access path if empty if {[string equal "" $access_path]} { set access_path [uplevel \#0 set auto_path] # Make sure that tcl_library is in auto_path # and at the first position (needed by setAccessPath) set where [lsearch -exact $access_path [info library]] if {$where == -1} { # not found, add it. set access_path [concat [list [info library]] $access_path] Log $slave "tcl_library was not in auto_path,\ added it to slave's access_path" NOTICE } elseif {$where != 0} { # not first, move it first set access_path [concat [list [info library]]\ [lreplace $access_path $where $where]] Log $slave "tcl_libray was not in first in auto_path,\ moved it to front of slave's access_path" NOTICE } # Add 1st level sub dirs (will searched by auto loading from tcl # code in the slave using glob and thus fail, so we add them # here so by default it works the same). set access_path [AddSubDirs $access_path] } Log $slave "Setting accessPath=($access_path) staticsok=$staticsok\ nestedok=$nestedok deletehook=($deletehook)" NOTICE # clear old autopath if it existed set nname [PathNumberName $slave] if {[Exists $nname]} { set n [Set $nname] for {set i 0} {$i<$n} {incr i} { Unset [PathToken $i $slave] } } # build new one set slave_auto_path {} set i 0 foreach dir $access_path { Set [PathToken $i $slave] $dir lappend slave_auto_path "\$[PathToken $i]" incr i } Set $nname $i Set [PathListName $slave] $access_path Set [VirtualPathListName $slave] $slave_auto_path Set [StaticsOkName $slave] $staticsok Set [NestedOkName $slave] $nestedok Set [DeleteHookName $slave] $deletehook SyncAccessPath $slave } # # # FindInAccessPath: # Search for a real directory and returns its virtual Id # (including the "$") proc ::safe::interpFindInAccessPath {slave path} { set access_path [GetAccessPath $slave] set where [lsearch -exact $access_path $path] if {$where == -1} { return -code error "$path not found in access path $access_path" } return "\$[PathToken $where]" } # # addToAccessPath: # add (if needed) a real directory to access path # and return its virtual token (including the "$"). proc ::safe::interpAddToAccessPath {slave path} { # first check if the directory is already in there if {![catch {interpFindInAccessPath $slave $path} res]} { return $res } # new one, add it: set nname [PathNumberName $slave] set n [Set $nname] Set [PathToken $n $slave] $path set token "\$[PathToken $n]" Lappend [VirtualPathListName $slave] $token Lappend [PathListName $slave] $path Set $nname [expr {$n+1}] SyncAccessPath $slave return $token } # This procedure applies the initializations to an already existing # interpreter. It is useful when you want to install the safe base # aliases into a preexisting safe interpreter. proc ::safe::InterpInit { slave access_path staticsok nestedok deletehook } { # Configure will generate an access_path when access_path is # empty. InterpSetConfig $slave $access_path $staticsok $nestedok $deletehook # These aliases let the slave load files to define new commands # NB we need to add [namespace current], aliases are always # absolute paths. ::interp alias $slave source {} [namespace current]::AliasSource $slave ::interp alias $slave load {} [namespace current]::AliasLoad $slave # This alias lets the slave use the encoding names, convertfrom, # convertto, and system, but not "encoding system " to set # the system encoding. ::interp alias $slave encoding {} [namespace current]::AliasEncoding \ $slave # This alias lets the slave have access to a subset of the 'file' # command functionality. AliasSubset $slave file file dir.* join root.* ext.* tail \ path.* split # This alias interposes on the 'exit' command and cleanly terminates # the slave. ::interp alias $slave exit {} [namespace current]::interpDelete $slave # The allowed slave variables already have been set # by Tcl_MakeSafe(3) # Source init.tcl into the slave, to get auto_load and other # procedures defined: # We don't try to use the -rsrc on the mac because it would get # confusing if you would want to customize init.tcl # for a given set of safe slaves, on all the platforms # you just need to give a specific access_path and # the mac should be no exception. As there is no # obvious full "safe ressources" design nor implementation # for the mac, safe interps there will just don't # have that ability. (A specific app can still reenable # that using custom aliases if they want to). # It would also make the security analysis and the Safe Tcl security # model platform dependant and thus more error prone. if {[catch {::interp eval $slave\ {source [file join $tcl_library init.tcl]}} msg]} { Log $slave "can't source init.tcl ($msg)" error "can't source init.tcl into slave $slave ($msg)" } return $slave } # Add (only if needed, avoid duplicates) 1 level of # sub directories to an existing path list. # Also removes non directories from the returned list. proc AddSubDirs {pathList} { set res {} foreach dir $pathList { if {[file isdirectory $dir]} { # check that we don't have it yet as a children # of a previous dir if {[lsearch -exact $res $dir]<0} { lappend res $dir } foreach sub [glob -directory $dir -nocomplain *] { if {([file isdirectory $sub]) \ && ([lsearch -exact $res $sub]<0) } { # new sub dir, add it ! lappend res $sub } } } } return $res } # This procedure deletes a safe slave managed by Safe Tcl and # cleans up associated state: proc ::safe::interpDelete {slave} { Log $slave "About to delete" NOTICE # If the slave has a cleanup hook registered, call it. # check the existance because we might be called to delete an interp # which has not been registered with us at all set hookname [DeleteHookName $slave] if {[Exists $hookname]} { set hook [Set $hookname] if {![::tcl::Lempty $hook]} { # remove the hook now, otherwise if the hook # calls us somehow, we'll loop Unset $hookname if {[catch {eval $hook [list $slave]} err]} { Log $slave "Delete hook error ($err)" } } } # Discard the global array of state associated with the slave, and # delete the interpreter. set statename [InterpStateName $slave] if {[Exists $statename]} { Unset $statename } # if we have been called twice, the interp might have been deleted # already if {[::interp exists $slave]} { ::interp delete $slave Log $slave "Deleted" NOTICE } return } # Set (or get) the loging mecanism proc ::safe::setLogCmd {args} { variable Log if {[llength $args] == 0} { return $Log } else { if {[llength $args] == 1} { set Log [lindex $args 0] } else { set Log $args } } } # internal variable variable Log {} # ------------------- END OF PUBLIC METHODS ------------ # # sets the slave auto_path to the master recorded value. # also sets tcl_library to the first token of the virtual path. # proc SyncAccessPath {slave} { set slave_auto_path [Set [VirtualPathListName $slave]] ::interp eval $slave [list set auto_path $slave_auto_path] Log $slave "auto_path in $slave has been set to $slave_auto_path"\ NOTICE ::interp eval $slave [list set tcl_library [lindex $slave_auto_path 0]] } # base name for storing all the slave states # the array variable name for slave foo is thus "Sfoo" # and for sub slave {foo bar} "Sfoo bar" (spaces are handled # ok everywhere (or should)) # We add the S prefix to avoid that a slave interp called "Log" # would smash our "Log" variable. proc InterpStateName {slave} { return "S$slave" } # Check that the given slave is "one of us" proc IsInterp {slave} { expr {[Exists [InterpStateName $slave]] && [::interp exists $slave]} } # returns the virtual token for directory number N # if the slave argument is given, # it will return the corresponding master global variable name proc PathToken {n {slave ""}} { if {$slave ne ""} { return "[InterpStateName $slave](access_path,$n)" } else { # We need to have a ":" in the token string so # [file join] on the mac won't turn it into a relative # path. return "p(:$n:)" } } # returns the variable name of the complete path list proc PathListName {slave} { return "[InterpStateName $slave](access_path)" } # returns the variable name of the complete path list proc VirtualPathListName {slave} { return "[InterpStateName $slave](access_path_slave)" } # returns the variable name of the number of items proc PathNumberName {slave} { return "[InterpStateName $slave](access_path,n)" } # returns the staticsok flag var name proc StaticsOkName {slave} { return "[InterpStateName $slave](staticsok)" } # returns the nestedok flag var name proc NestedOkName {slave} { return "[InterpStateName $slave](nestedok)" } # Run some code at the namespace toplevel proc Toplevel {args} { namespace eval [namespace current] $args } # set/get values proc Set {args} { eval [list Toplevel set] $args } # lappend on toplevel vars proc Lappend {args} { eval [list Toplevel lappend] $args } # unset a var/token (currently just an global level eval) proc Unset {args} { eval [list Toplevel unset] $args } # test existance proc Exists {varname} { Toplevel info exists $varname } # short cut for access path getting proc GetAccessPath {slave} { Set [PathListName $slave] } # short cut for statics ok flag getting proc StaticsOk {slave} { Set [StaticsOkName $slave] } # short cut for getting the multiples interps sub loading ok flag proc NestedOk {slave} { Set [NestedOkName $slave] } # interp deletion storing hook name proc DeleteHookName {slave} { return [InterpStateName $slave](cleanupHook) } # # translate virtual path into real path # proc TranslatePath {slave path} { # somehow strip the namespaces 'functionality' out (the danger # is that we would strip valid macintosh "../" queries... : if {[regexp {(::)|(\.\.)} $path]} { error "invalid characters in path $path" } set n [expr {[Set [PathNumberName $slave]]-1}] for {} {$n>=0} {incr n -1} { # fill the token virtual names with their real value set [PathToken $n] [Set [PathToken $n $slave]] } # replaces the token by their value subst -nobackslashes -nocommands $path } # Log eventually log an error # to enable error logging, set Log to {puts stderr} for instance proc Log {slave msg {type ERROR}} { variable Log if {[info exists Log] && [llength $Log]} { eval $Log [list "$type for slave $slave : $msg"] } } # file name control (limit access to files/ressources that should be # a valid tcl source file) proc CheckFileName {slave file} { # This used to limit what can be sourced to ".tcl" and forbid files # with more than 1 dot and longer than 14 chars, but I changed that # for 8.4 as a safe interp has enough internal protection already # to allow sourcing anything. - hobbs if {![file exists $file]} { # don't tell the file path error "no such file or directory" } if {![file readable $file]} { # don't tell the file path error "not readable" } } # AliasSource is the target of the "source" alias in safe interpreters. proc AliasSource {slave args} { set argc [llength $args] # Allow only "source filename" # (and not mac specific -rsrc for instance - see comment in ::init # for current rationale) if {$argc != 1} { set msg "wrong # args: should be \"source fileName\"" Log $slave "$msg ($args)" return -code error $msg } set file [lindex $args 0] # get the real path from the virtual one. if {[catch {set file [TranslatePath $slave $file]} msg]} { Log $slave $msg return -code error "permission denied" } # check that the path is in the access path of that slave if {[catch {FileInAccessPath $slave $file} msg]} { Log $slave $msg return -code error "permission denied" } # do the checks on the filename : if {[catch {CheckFileName $slave $file} msg]} { Log $slave "$file:$msg" return -code error $msg } # passed all the tests , lets source it: if {[catch {::interp invokehidden $slave source $file} msg]} { Log $slave $msg return -code error "script error" } return $msg } # AliasLoad is the target of the "load" alias in safe interpreters. proc AliasLoad {slave file args} { set argc [llength $args] if {$argc > 2} { set msg "load error: too many arguments" Log $slave "$msg ($argc) {$file $args}" return -code error $msg } # package name (can be empty if file is not). set package [lindex $args 0] # Determine where to load. load use a relative interp path # and {} means self, so we can directly and safely use passed arg. set target [lindex $args 1] if {[string length $target]} { # we will try to load into a sub sub interp # check that we want to authorize that. if {![NestedOk $slave]} { Log $slave "loading to a sub interp (nestedok)\ disabled (trying to load $package to $target)" return -code error "permission denied (nested load)" } } # Determine what kind of load is requested if {[string length $file] == 0} { # static package loading if {[string length $package] == 0} { set msg "load error: empty filename and no package name" Log $slave $msg return -code error $msg } if {![StaticsOk $slave]} { Log $slave "static packages loading disabled\ (trying to load $package to $target)" return -code error "permission denied (static package)" } } else { # file loading # get the real path from the virtual one. if {[catch {set file [TranslatePath $slave $file]} msg]} { Log $slave $msg return -code error "permission denied" } # check the translated path if {[catch {FileInAccessPath $slave $file} msg]} { Log $slave $msg return -code error "permission denied (path)" } } if {[catch {::interp invokehidden\ $slave load $file $package $target} msg]} { Log $slave $msg return -code error $msg } return $msg } # FileInAccessPath raises an error if the file is not found in # the list of directories contained in the (master side recorded) slave's # access path. # the security here relies on "file dirname" answering the proper # result.... needs checking ? proc FileInAccessPath {slave file} { set access_path [GetAccessPath $slave] if {[file isdirectory $file]} { error "\"$file\": is a directory" } set parent [file dirname $file] # Normalize paths for comparison since lsearch knows nothing of # potential pathname anomalies. set norm_parent [file normalize $parent] foreach path $access_path { lappend norm_access_path [file normalize $path] } if {[lsearch -exact $norm_access_path $norm_parent] == -1} { error "\"$file\": not in access_path" } } # This procedure enables access from a safe interpreter to only a subset of # the subcommands of a command: proc Subset {slave command okpat args} { set subcommand [lindex $args 0] if {[regexp $okpat $subcommand]} { return [eval [list $command $subcommand] [lrange $args 1 end]] } set msg "not allowed to invoke subcommand $subcommand of $command" Log $slave $msg error $msg } # This procedure installs an alias in a slave that invokes "safesubset" # in the master to execute allowed subcommands. It precomputes the pattern # of allowed subcommands; you can use wildcards in the pattern if you wish # to allow subcommand abbreviation. # # Syntax is: AliasSubset slave alias target subcommand1 subcommand2... proc AliasSubset {slave alias target args} { set pat ^(; set sep "" foreach sub $args { append pat $sep$sub set sep | } append pat )\$ ::interp alias $slave $alias {}\ [namespace current]::Subset $slave $target $pat } # AliasEncoding is the target of the "encoding" alias in safe interpreters. proc AliasEncoding {slave args} { set argc [llength $args] set okpat "^(name.*|convert.*)\$" set subcommand [lindex $args 0] if {[regexp $okpat $subcommand]} { return [eval ::interp invokehidden $slave encoding $subcommand \ [lrange $args 1 end]] } if {[string match $subcommand system]} { if {$argc == 1} { # passed all the tests , lets source it: if {[catch {::interp invokehidden \ $slave encoding system} msg]} { Log $slave $msg return -code error "script error" } } else { set msg "wrong # args: should be \"encoding system\"" Log $slave $msg error $msg } } else { set msg "wrong # args: should be \"encoding option ?arg ...?\"" Log $slave $msg error $msg } return $msg } } Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/tclIndex0100644000000000001200000001372107557263421027757 0ustar rootadmin# Tcl autoload index file, version 2.0 # This file is generated by the "auto_mkindex" command # and sourced to set up indexing information for one or # more commands. Typically each line is a command that # sets an element in the auto_index array, where the # element name is the name of a command and the value is # a script that loads the command. set auto_index(auto_reset) [list source [file join $dir auto.tcl]] set auto_index(tcl_findLibrary) [list source [file join $dir auto.tcl]] set auto_index(auto_mkindex) [list source [file join $dir auto.tcl]] set auto_index(auto_mkindex_old) [list source [file join $dir auto.tcl]] set auto_index(::auto_mkindex_parser::init) [list source [file join $dir auto.tcl]] set auto_index(::auto_mkindex_parser::cleanup) [list source [file join $dir auto.tcl]] set auto_index(::auto_mkindex_parser::mkindex) [list source [file join $dir auto.tcl]] set auto_index(::auto_mkindex_parser::hook) [list source [file join $dir auto.tcl]] set auto_index(::auto_mkindex_parser::slavehook) [list source [file join $dir auto.tcl]] set auto_index(::auto_mkindex_parser::command) [list source [file join $dir auto.tcl]] set auto_index(::auto_mkindex_parser::commandInit) [list source [file join $dir auto.tcl]] set auto_index(::auto_mkindex_parser::fullname) [list source [file join $dir auto.tcl]] set auto_index(history) [list source [file join $dir history.tcl]] set auto_index(::tcl::HistAdd) [list source [file join $dir history.tcl]] set auto_index(::tcl::HistKeep) [list source [file join $dir history.tcl]] set auto_index(::tcl::HistClear) [list source [file join $dir history.tcl]] set auto_index(::tcl::HistInfo) [list source [file join $dir history.tcl]] set auto_index(::tcl::HistRedo) [list source [file join $dir history.tcl]] set auto_index(::tcl::HistIndex) [list source [file join $dir history.tcl]] set auto_index(::tcl::HistEvent) [list source [file join $dir history.tcl]] set auto_index(::tcl::HistChange) [list source [file join $dir history.tcl]] set auto_index(tclLdAout) [list source [file join $dir ldAout.tcl]] set auto_index(pkg_compareExtension) [list source [file join $dir package.tcl]] set auto_index(pkg_mkIndex) [list source [file join $dir package.tcl]] set auto_index(tclPkgSetup) [list source [file join $dir package.tcl]] set auto_index(tclPkgUnknown) [list source [file join $dir package.tcl]] set auto_index(::tcl::MacOSXPkgUnknown) [list source [file join $dir package.tcl]] set auto_index(::tcl::MacPkgUnknown) [list source [file join $dir package.tcl]] set auto_index(::pkg::create) [list source [file join $dir package.tcl]] set auto_index(parray) [list source [file join $dir parray.tcl]] set auto_index(::safe::InterpStatics) [list source [file join $dir safe.tcl]] set auto_index(::safe::InterpNested) [list source [file join $dir safe.tcl]] set auto_index(::safe::interpCreate) [list source [file join $dir safe.tcl]] set auto_index(::safe::interpInit) [list source [file join $dir safe.tcl]] set auto_index(::safe::CheckInterp) [list source [file join $dir safe.tcl]] set auto_index(::safe::interpConfigure) [list source [file join $dir safe.tcl]] set auto_index(::safe::InterpCreate) [list source [file join $dir safe.tcl]] set auto_index(::safe::InterpSetConfig) [list source [file join $dir safe.tcl]] set auto_index(::safe::interpFindInAccessPath) [list source [file join $dir safe.tcl]] set auto_index(::safe::interpAddToAccessPath) [list source [file join $dir safe.tcl]] set auto_index(::safe::InterpInit) [list source [file join $dir safe.tcl]] set auto_index(::safe::AddSubDirs) [list source [file join $dir safe.tcl]] set auto_index(::safe::interpDelete) [list source [file join $dir safe.tcl]] set auto_index(::safe::setLogCmd) [list source [file join $dir safe.tcl]] set auto_index(::safe::SyncAccessPath) [list source [file join $dir safe.tcl]] set auto_index(::safe::InterpStateName) [list source [file join $dir safe.tcl]] set auto_index(::safe::IsInterp) [list source [file join $dir safe.tcl]] set auto_index(::safe::PathToken) [list source [file join $dir safe.tcl]] set auto_index(::safe::PathListName) [list source [file join $dir safe.tcl]] set auto_index(::safe::VirtualPathListName) [list source [file join $dir safe.tcl]] set auto_index(::safe::PathNumberName) [list source [file join $dir safe.tcl]] set auto_index(::safe::StaticsOkName) [list source [file join $dir safe.tcl]] set auto_index(::safe::NestedOkName) [list source [file join $dir safe.tcl]] set auto_index(::safe::Toplevel) [list source [file join $dir safe.tcl]] set auto_index(::safe::Set) [list source [file join $dir safe.tcl]] set auto_index(::safe::Lappend) [list source [file join $dir safe.tcl]] set auto_index(::safe::Unset) [list source [file join $dir safe.tcl]] set auto_index(::safe::Exists) [list source [file join $dir safe.tcl]] set auto_index(::safe::GetAccessPath) [list source [file join $dir safe.tcl]] set auto_index(::safe::StaticsOk) [list source [file join $dir safe.tcl]] set auto_index(::safe::NestedOk) [list source [file join $dir safe.tcl]] set auto_index(::safe::DeleteHookName) [list source [file join $dir safe.tcl]] set auto_index(::safe::TranslatePath) [list source [file join $dir safe.tcl]] set auto_index(::safe::Log) [list source [file join $dir safe.tcl]] set auto_index(::safe::CheckFileName) [list source [file join $dir safe.tcl]] set auto_index(::safe::AliasSource) [list source [file join $dir safe.tcl]] set auto_index(::safe::AliasLoad) [list source [file join $dir safe.tcl]] set auto_index(::safe::FileInAccessPath) [list source [file join $dir safe.tcl]] set auto_index(::safe::Subset) [list source [file join $dir safe.tcl]] set auto_index(::safe::AliasSubset) [list source [file join $dir safe.tcl]] set auto_index(tcl_wordBreakAfter) [list source [file join $dir word.tcl]] set auto_index(tcl_wordBreakBefore) [list source [file join $dir word.tcl]] set auto_index(tcl_endOfWord) [list source [file join $dir word.tcl]] set auto_index(tcl_startOfNextWord) [list source [file join $dir word.tcl]] set auto_index(tcl_startOfPreviousWord) [list source [file join $dir word.tcl]] Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/tcltest2.2/0040755000000000000240000000000010153074406030170 5ustar rootstaff././@LongLink0000000000000000000000000000014500000000000011706 Lustar rootwheelWishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/tcltest2.2/pkgIndex.tclWishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/tcltest2.2/pkgIndex.tc0100644000000000001200000000114210140603576032250 0ustar rootadmin# Tcl package index file, version 1.1 # This file is generated by the "pkg_mkIndex -direct" command # and sourced either when an application starts up or # by a "package unknown" script. It invokes the # "package ifneeded" command to set up package-related # information so that packages will be loaded automatically # in response to "package require" commands. When this # script is sourced, the variable $dir must contain the # full path name of this file's directory. if {![package vsatisfies [package provide Tcl] 8.3]} {return} package ifneeded tcltest 2.2.7 [list source [file join $dir tcltest.tcl]] Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/tcltest2.2/tcltest.tcl0100644000000000001200000030075210141754753032353 0ustar rootadmin# tcltest.tcl -- # # This file contains support code for the Tcl test suite. It # defines the tcltest namespace and finds and defines the output # directory, constraints available, output and error channels, # etc. used by Tcl tests. See the tcltest man page for more # details. # # This design was based on the Tcl testing approach designed and # initially implemented by Mary Ann May-Pumphrey of Sun # Microsystems. # # Copyright (c) 1994-1997 Sun Microsystems, Inc. # Copyright (c) 1998-1999 by Scriptics Corporation. # Copyright (c) 2000 by Ajuba Solutions # Contributions from Don Porter, NIST, 2002. (not subject to US copyright) # All rights reserved. # # RCS: @(#) $Id: tcltest.tcl,v 1.78.2.12 2004/11/02 19:03:07 dgp Exp $ package require Tcl 8.3 ;# uses [glob -directory] namespace eval tcltest { # When the version number changes, be sure to update the pkgIndex.tcl file, # and the install directory in the Makefiles. When the minor version # changes (new feature) be sure to update the man page as well. variable Version 2.2.7 # Compatibility support for dumb variables defined in tcltest 1 # Do not use these. Call [package provide Tcl] and [info patchlevel] # yourself. You don't need tcltest to wrap it for you. variable version [package provide Tcl] variable patchLevel [info patchlevel] ##### Export the public tcltest procs; several categories # # Export the main functional commands that do useful things namespace export cleanupTests loadTestedCommands makeDirectory \ makeFile removeDirectory removeFile runAllTests test # Export configuration commands that control the functional commands namespace export configure customMatch errorChannel interpreter \ outputChannel testConstraint # Export commands that are duplication (candidates for deprecation) namespace export bytestring ;# dups [encoding convertfrom identity] namespace export debug ;# [configure -debug] namespace export errorFile ;# [configure -errfile] namespace export limitConstraints ;# [configure -limitconstraints] namespace export loadFile ;# [configure -loadfile] namespace export loadScript ;# [configure -load] namespace export match ;# [configure -match] namespace export matchFiles ;# [configure -file] namespace export matchDirectories ;# [configure -relateddir] namespace export normalizeMsg ;# application of [customMatch] namespace export normalizePath ;# [file normalize] (8.4) namespace export outputFile ;# [configure -outfile] namespace export preserveCore ;# [configure -preservecore] namespace export singleProcess ;# [configure -singleproc] namespace export skip ;# [configure -skip] namespace export skipFiles ;# [configure -notfile] namespace export skipDirectories ;# [configure -asidefromdir] namespace export temporaryDirectory ;# [configure -tmpdir] namespace export testsDirectory ;# [configure -testdir] namespace export verbose ;# [configure -verbose] namespace export viewFile ;# binary encoding [read] namespace export workingDirectory ;# [cd] [pwd] # Export deprecated commands for tcltest 1 compatibility namespace export getMatchingFiles mainThread restoreState saveState \ threadReap # tcltest::normalizePath -- # # This procedure resolves any symlinks in the path thus creating # a path without internal redirection. It assumes that the # incoming path is absolute. # # Arguments # pathVar - name of variable containing path to modify. # # Results # The path is modified in place. # # Side Effects: # None. # proc normalizePath {pathVar} { upvar $pathVar path set oldpwd [pwd] catch {cd $path} set path [pwd] cd $oldpwd return $path } ##### Verification commands used to test values of variables and options # # Verification command that accepts everything proc AcceptAll {value} { return $value } # Verification command that accepts valid Tcl lists proc AcceptList { list } { return [lrange $list 0 end] } # Verification command that accepts a glob pattern proc AcceptPattern { pattern } { return [AcceptAll $pattern] } # Verification command that accepts integers proc AcceptInteger { level } { return [incr level 0] } # Verification command that accepts boolean values proc AcceptBoolean { boolean } { return [expr {$boolean && $boolean}] } # Verification command that accepts (syntactically) valid Tcl scripts proc AcceptScript { script } { if {![info complete $script]} { return -code error "invalid Tcl script: $script" } return $script } # Verification command that accepts (converts to) absolute pathnames proc AcceptAbsolutePath { path } { return [file join [pwd] $path] } # Verification command that accepts existing readable directories proc AcceptReadable { path } { if {![file readable $path]} { return -code error "\"$path\" is not readable" } return $path } proc AcceptDirectory { directory } { set directory [AcceptAbsolutePath $directory] if {![file exists $directory]} { return -code error "\"$directory\" does not exist" } if {![file isdir $directory]} { return -code error "\"$directory\" is not a directory" } return [AcceptReadable $directory] } ##### Initialize internal arrays of tcltest, but only if the caller # has not already pre-initialized them. This is done to support # compatibility with older tests that directly access internals # rather than go through command interfaces. # proc ArrayDefault {varName value} { variable $varName if {[array exists $varName]} { return } if {[info exists $varName]} { # Pre-initialized value is a scalar: destroy it! unset $varName } array set $varName $value } # save the original environment so that it can be restored later ArrayDefault originalEnv [array get ::env] # initialize numTests array to keep track of the number of tests # that pass, fail, and are skipped. ArrayDefault numTests [list Total 0 Passed 0 Skipped 0 Failed 0] # createdNewFiles will store test files as indices and the list of # files (that should not have been) left behind by the test files # as values. ArrayDefault createdNewFiles {} # initialize skippedBecause array to keep track of constraints that # kept tests from running; a constraint name of "userSpecifiedSkip" # means that the test appeared on the list of tests that matched the # -skip value given to the flag; "userSpecifiedNonMatch" means that # the test didn't match the argument given to the -match flag; both # of these constraints are counted only if tcltest::debug is set to # true. ArrayDefault skippedBecause {} # initialize the testConstraints array to keep track of valid # predefined constraints (see the explanation for the # InitConstraints proc for more details). ArrayDefault testConstraints {} ##### Initialize internal variables of tcltest, but only if the caller # has not already pre-initialized them. This is done to support # compatibility with older tests that directly access internals # rather than go through command interfaces. # proc Default {varName value {verify AcceptAll}} { variable $varName if {![info exists $varName]} { variable $varName [$verify $value] } else { variable $varName [$verify [set $varName]] } } # Save any arguments that we might want to pass through to other # programs. This is used by the -args flag. # FINDUSER Default parameters {} # Count the number of files tested (0 if runAllTests wasn't called). # runAllTests will set testSingleFile to false, so stats will # not be printed until runAllTests calls the cleanupTests proc. # The currentFailure var stores the boolean value of whether the # current test file has had any failures. The failFiles list # stores the names of test files that had failures. Default numTestFiles 0 AcceptInteger Default testSingleFile true AcceptBoolean Default currentFailure false AcceptBoolean Default failFiles {} AcceptList # Tests should remove all files they create. The test suite will # check the current working dir for files created by the tests. # filesMade keeps track of such files created using the makeFile and # makeDirectory procedures. filesExisted stores the names of # pre-existing files. # # Note that $filesExisted lists only those files that exist in # the original [temporaryDirectory]. Default filesMade {} AcceptList Default filesExisted {} AcceptList proc FillFilesExisted {} { variable filesExisted # Save the names of files that already exist in the scratch directory. foreach file [glob -nocomplain -directory [temporaryDirectory] *] { lappend filesExisted [file tail $file] } # After successful filling, turn this into a no-op. proc FillFilesExisted args {} } # Kept only for compatibility Default constraintsSpecified {} AcceptList trace variable constraintsSpecified r {set ::tcltest::constraintsSpecified \ [array names ::tcltest::testConstraints] ;# } # tests that use threads need to know which is the main thread Default mainThread 1 variable mainThread if {[info commands thread::id] != {}} { set mainThread [thread::id] } elseif {[info commands testthread] != {}} { set mainThread [testthread id] } # Set workingDirectory to [pwd]. The default output directory for # Tcl tests is the working directory. Whenever this value changes # change to that directory. variable workingDirectory trace variable workingDirectory w \ [namespace code {cd $workingDirectory ;#}] Default workingDirectory [pwd] AcceptAbsolutePath proc workingDirectory { {dir ""} } { variable workingDirectory if {[llength [info level 0]] == 1} { return $workingDirectory } set workingDirectory [AcceptAbsolutePath $dir] } # Set the location of the execuatble Default tcltest [info nameofexecutable] trace variable tcltest w [namespace code {testConstraint stdio \ [eval [ConstraintInitializer stdio]] ;#}] # save the platform information so it can be restored later Default originalTclPlatform [array get ::tcl_platform] # If a core file exists, save its modification time. if {[file exists [file join [workingDirectory] core]]} { Default coreModTime \ [file mtime [file join [workingDirectory] core]] } # stdout and stderr buffers for use when we want to store them Default outData {} Default errData {} # keep track of test level for nested test commands variable testLevel 0 # the variables and procs that existed when saveState was called are # stored in a variable of the same name Default saveState {} # Internationalization support -- used in [SetIso8859_1_Locale] and # [RestoreLocale]. Those commands are used in cmdIL.test. if {![info exists [namespace current]::isoLocale]} { variable isoLocale fr switch -- $::tcl_platform(platform) { "unix" { # Try some 'known' values for some platforms: switch -exact -- $::tcl_platform(os) { "FreeBSD" { set isoLocale fr_FR.ISO_8859-1 } HP-UX { set isoLocale fr_FR.iso88591 } Linux - IRIX { set isoLocale fr } default { # Works on SunOS 4 and Solaris, and maybe # others... Define it to something else on your # system if you want to test those. set isoLocale iso_8859_1 } } } "windows" { set isoLocale French } } } variable ChannelsWeOpened; array set ChannelsWeOpened {} # output goes to stdout by default Default outputChannel stdout proc outputChannel { {filename ""} } { variable outputChannel variable ChannelsWeOpened # This is very subtle and tricky, so let me try to explain. # (Hopefully this longer comment will be clear when I come # back in a few months, unlike its predecessor :) ) # # The [outputChannel] command (and underlying variable) have to # be kept in sync with the [configure -outfile] configuration # option ( and underlying variable Option(-outfile) ). This is # accomplished with a write trace on Option(-outfile) that will # update [outputChannel] whenver a new value is written. That # much is easy. # # The trick is that in order to maintain compatibility with # version 1 of tcltest, we must allow every configuration option # to get its inital value from command line arguments. This is # accomplished by setting initial read traces on all the # configuration options to parse the command line option the first # time they are read. These traces are cancelled whenever the # program itself calls [configure]. # # OK, then so to support tcltest 1 compatibility, it seems we want # to get the return from [outputFile] to trigger the read traces, # just in case. # # BUT! A little known feature of Tcl variable traces is that # traces are disabled during the handling of other traces. So, # if we trigger read traces on Option(-outfile) and that triggers # command line parsing which turns around and sets an initial # value for Option(-outfile) -- -- the write trace that # would keep [outputChannel] in sync with that new initial value # would not fire! # # SO, finally, as a workaround, instead of triggering read traces # by invoking [outputFile], we instead trigger the same set of # read traces by invoking [debug]. Any command that reads a # configuration option would do. [debug] is just a handy one. # The end result is that we support tcltest 1 compatibility and # keep outputChannel and -outfile in sync in all cases. debug if {[llength [info level 0]] == 1} { return $outputChannel } if {[info exists ChannelsWeOpened($outputChannel)]} { close $outputChannel unset ChannelsWeOpened($outputChannel) } switch -exact -- $filename { stderr - stdout { set outputChannel $filename } default { set outputChannel [open $filename a] set ChannelsWeOpened($outputChannel) 1 # If we created the file in [temporaryDirectory], then # [cleanupTests] will delete it, unless we claim it was # already there. set outdir [normalizePath [file dirname \ [file join [pwd] $filename]]] if {[string equal $outdir [temporaryDirectory]]} { variable filesExisted FillFilesExisted set filename [file tail $filename] if {[lsearch -exact $filesExisted $filename] == -1} { lappend filesExisted $filename } } } } return $outputChannel } # errors go to stderr by default Default errorChannel stderr proc errorChannel { {filename ""} } { variable errorChannel variable ChannelsWeOpened # This is subtle and tricky. See the comment above in # [outputChannel] for a detailed explanation. debug if {[llength [info level 0]] == 1} { return $errorChannel } if {[info exists ChannelsWeOpened($errorChannel)]} { close $errorChannel unset ChannelsWeOpened($errorChannel) } switch -exact -- $filename { stderr - stdout { set errorChannel $filename } default { set errorChannel [open $filename a] set ChannelsWeOpened($errorChannel) 1 # If we created the file in [temporaryDirectory], then # [cleanupTests] will delete it, unless we claim it was # already there. set outdir [normalizePath [file dirname \ [file join [pwd] $filename]]] if {[string equal $outdir [temporaryDirectory]]} { variable filesExisted FillFilesExisted set filename [file tail $filename] if {[lsearch -exact $filesExisted $filename] == -1} { lappend filesExisted $filename } } } } return $errorChannel } ##### Set up the configurable options # # The configurable options of the package variable Option; array set Option {} # Usage strings for those options variable Usage; array set Usage {} # Verification commands for those options variable Verify; array set Verify {} # Initialize the default values of the configurable options that are # historically associated with an exported variable. If that variable # is already set, support compatibility by accepting its pre-set value. # Use [trace] to establish ongoing connection between the deprecated # exported variable and the modern option kept as a true internal var. # Also set up usage string and value testing for the option. proc Option {option value usage {verify AcceptAll} {varName {}}} { variable Option variable Verify variable Usage variable OptionControlledVariables set Usage($option) $usage set Verify($option) $verify if {[catch {$verify $value} msg]} { return -code error $msg } else { set Option($option) $msg } if {[string length $varName]} { variable $varName if {[info exists $varName]} { if {[catch {$verify [set $varName]} msg]} { return -code error $msg } else { set Option($option) $msg } unset $varName } namespace eval [namespace current] \ [list upvar 0 Option($option) $varName] # Workaround for Bug (now Feature Request) 572889. Grrrr.... # Track all the variables tied to options lappend OptionControlledVariables $varName # Later, set auto-configure read traces on all # of them, since a single trace on Option does not work. proc $varName {{value {}}} [subst -nocommands { if {[llength [info level 0]] == 2} { Configure $option [set value] } return [Configure $option] }] } } proc MatchingOption {option} { variable Option set match [array names Option $option*] switch -- [llength $match] { 0 { set sorted [lsort [array names Option]] set values [join [lrange $sorted 0 end-1] ", "] append values ", or [lindex $sorted end]" return -code error "unknown option $option: should be\ one of $values" } 1 { return [lindex $match 0] } default { # Exact match trumps ambiguity if {[lsearch -exact $match $option] >= 0} { return $option } set values [join [lrange $match 0 end-1] ", "] append values ", or [lindex $match end]" return -code error "ambiguous option $option:\ could match $values" } } } proc EstablishAutoConfigureTraces {} { variable OptionControlledVariables foreach varName [concat $OptionControlledVariables Option] { variable $varName trace variable $varName r [namespace code {ProcessCmdLineArgs ;#}] } } proc RemoveAutoConfigureTraces {} { variable OptionControlledVariables foreach varName [concat $OptionControlledVariables Option] { variable $varName foreach pair [trace vinfo $varName] { foreach {op cmd} $pair break if {[string equal r $op] && [string match *ProcessCmdLineArgs* $cmd]} { trace vdelete $varName $op $cmd } } } # Once the traces are removed, this can become a no-op proc RemoveAutoConfigureTraces {} {} } proc Configure args { variable Option variable Verify set n [llength $args] if {$n == 0} { return [lsort [array names Option]] } if {$n == 1} { if {[catch {MatchingOption [lindex $args 0]} option]} { return -code error $option } return $Option($option) } while {[llength $args] > 1} { if {[catch {MatchingOption [lindex $args 0]} option]} { return -code error $option } if {[catch {$Verify($option) [lindex $args 1]} value]} { return -code error "invalid $option\ value \"[lindex $args 1]\": $value" } set Option($option) $value set args [lrange $args 2 end] } if {[llength $args]} { if {[catch {MatchingOption [lindex $args 0]} option]} { return -code error $option } return -code error "missing value for option $option" } } proc configure args { RemoveAutoConfigureTraces set code [catch {eval Configure $args} msg] return -code $code $msg } proc AcceptVerbose { level } { set level [AcceptList $level] if {[llength $level] == 1} { if {![regexp {^(pass|body|skip|start|error)$} $level]} { # translate single characters abbreviations to expanded list set level [string map {p pass b body s skip t start e error} \ [split $level {}]] } } set valid [list] foreach v $level { if {[regexp {^(pass|body|skip|start|error)$} $v]} { lappend valid $v } } return $valid } proc IsVerbose {level} { variable Option return [expr {[lsearch -exact $Option(-verbose) $level] != -1}] } # Default verbosity is to show bodies of failed tests Option -verbose {body error} { Takes any combination of the values 'p', 's', 'b', 't' and 'e'. Test suite will display all passed tests if 'p' is specified, all skipped tests if 's' is specified, the bodies of failed tests if 'b' is specified, and when tests start if 't' is specified. ErrorInfo is displayed if 'e' is specified. } AcceptVerbose verbose # Match and skip patterns default to the empty list, except for # matchFiles, which defaults to all .test files in the # testsDirectory and matchDirectories, which defaults to all # directories. Option -match * { Run all tests within the specified files that match one of the list of glob patterns given. } AcceptList match Option -skip {} { Skip all tests within the specified tests (via -match) and files that match one of the list of glob patterns given. } AcceptList skip Option -file *.test { Run tests in all test files that match the glob pattern given. } AcceptPattern matchFiles # By default, skip files that appear to be SCCS lock files. Option -notfile l.*.test { Skip all test files that match the glob pattern given. } AcceptPattern skipFiles Option -relateddir * { Run tests in directories that match the glob pattern given. } AcceptPattern matchDirectories Option -asidefromdir {} { Skip tests in directories that match the glob pattern given. } AcceptPattern skipDirectories # By default, don't save core files Option -preservecore 0 { If 2, save any core files produced during testing in the directory specified by -tmpdir. If 1, notify the user if core files are created. } AcceptInteger preserveCore # debug output doesn't get printed by default; debug level 1 spits # up only the tests that were skipped because they didn't match or # were specifically skipped. A debug level of 2 would spit up the # tcltest variables and flags provided; a debug level of 3 causes # some additional output regarding operations of the test harness. # The tcltest package currently implements only up to debug level 3. Option -debug 0 { Internal debug level } AcceptInteger debug proc SetSelectedConstraints args { variable Option foreach c $Option(-constraints) { testConstraint $c 1 } } Option -constraints {} { Do not skip the listed constraints listed in -constraints. } AcceptList trace variable Option(-constraints) w \ [namespace code {SetSelectedConstraints ;#}] # Don't run only the "-constraint" specified tests by default proc ClearUnselectedConstraints args { variable Option variable testConstraints if {!$Option(-limitconstraints)} {return} foreach c [array names testConstraints] { if {[lsearch -exact $Option(-constraints) $c] == -1} { testConstraint $c 0 } } } Option -limitconstraints false { whether to run only tests with the constraints } AcceptBoolean limitConstraints trace variable Option(-limitconstraints) w \ [namespace code {ClearUnselectedConstraints ;#}] # A test application has to know how to load the tested commands # into the interpreter. Option -load {} { Specifies the script to load the tested commands. } AcceptScript loadScript # Default is to run each test file in a separate process Option -singleproc 0 { whether to run all tests in one process } AcceptBoolean singleProcess proc AcceptTemporaryDirectory { directory } { set directory [AcceptAbsolutePath $directory] if {![file exists $directory]} { file mkdir $directory } set directory [AcceptDirectory $directory] if {![file writable $directory]} { if {[string equal [workingDirectory] $directory]} { # Special exception: accept the default value # even if the directory is not writable return $directory } return -code error "\"$directory\" is not writeable" } return $directory } # Directory where files should be created Option -tmpdir [workingDirectory] { Save temporary files in the specified directory. } AcceptTemporaryDirectory temporaryDirectory trace variable Option(-tmpdir) w \ [namespace code {normalizePath Option(-tmpdir) ;#}] # Tests should not rely on the current working directory. # Files that are part of the test suite should be accessed relative # to [testsDirectory] Option -testdir [workingDirectory] { Search tests in the specified directory. } AcceptDirectory testsDirectory trace variable Option(-testdir) w \ [namespace code {normalizePath Option(-testdir) ;#}] proc AcceptLoadFile { file } { if {[string equal "" $file]} {return $file} set file [file join [temporaryDirectory] $file] return [AcceptReadable $file] } proc ReadLoadScript {args} { variable Option if {[string equal "" $Option(-loadfile)]} {return} set tmp [open $Option(-loadfile) r] loadScript [read $tmp] close $tmp } Option -loadfile {} { Read the script to load the tested commands from the specified file. } AcceptLoadFile loadFile trace variable Option(-loadfile) w [namespace code ReadLoadScript] proc AcceptOutFile { file } { if {[string equal stderr $file]} {return $file} if {[string equal stdout $file]} {return $file} return [file join [temporaryDirectory] $file] } # output goes to stdout by default Option -outfile stdout { Send output from test runs to the specified file. } AcceptOutFile outputFile trace variable Option(-outfile) w \ [namespace code {outputChannel $Option(-outfile) ;#}] # errors go to stderr by default Option -errfile stderr { Send errors from test runs to the specified file. } AcceptOutFile errorFile trace variable Option(-errfile) w \ [namespace code {errorChannel $Option(-errfile) ;#}] } ##################################################################### # tcltest::Debug* -- # # Internal helper procedures to write out debug information # dependent on the chosen level. A test shell may overide # them, f.e. to redirect the output into a different # channel, or even into a GUI. # tcltest::DebugPuts -- # # Prints the specified string if the current debug level is # higher than the provided level argument. # # Arguments: # level The lowest debug level triggering the output # string The string to print out. # # Results: # Prints the string. Nothing else is allowed. # # Side Effects: # None. # proc tcltest::DebugPuts {level string} { variable debug if {$debug >= $level} { puts $string } return } # tcltest::DebugPArray -- # # Prints the contents of the specified array if the current # debug level is higher than the provided level argument # # Arguments: # level The lowest debug level triggering the output # arrayvar The name of the array to print out. # # Results: # Prints the contents of the array. Nothing else is allowed. # # Side Effects: # None. # proc tcltest::DebugPArray {level arrayvar} { variable debug if {$debug >= $level} { catch {upvar $arrayvar $arrayvar} parray $arrayvar } return } # Define our own [parray] in ::tcltest that will inherit use of the [puts] # defined in ::tcltest. NOTE: Ought to construct with [info args] and # [info default], but can't be bothered now. If [parray] changes, then # this will need changing too. auto_load ::parray proc tcltest::parray {a {pattern *}} [info body ::parray] # tcltest::DebugDo -- # # Executes the script if the current debug level is greater than # the provided level argument # # Arguments: # level The lowest debug level triggering the execution. # script The tcl script executed upon a debug level high enough. # # Results: # Arbitrary side effects, dependent on the executed script. # # Side Effects: # None. # proc tcltest::DebugDo {level script} { variable debug if {$debug >= $level} { uplevel 1 $script } return } ##################################################################### proc tcltest::Warn {msg} { puts [outputChannel] "WARNING: $msg" } # tcltest::mainThread # # Accessor command for tcltest variable mainThread. # proc tcltest::mainThread { {new ""} } { variable mainThread if {[llength [info level 0]] == 1} { return $mainThread } set mainThread $new } # tcltest::testConstraint -- # # sets a test constraint to a value; to do multiple constraints, # call this proc multiple times. also returns the value of the # named constraint if no value was supplied. # # Arguments: # constraint - name of the constraint # value - new value for constraint (should be boolean) - if not # supplied, this is a query # # Results: # content of tcltest::testConstraints($constraint) # # Side effects: # none proc tcltest::testConstraint {constraint {value ""}} { variable testConstraints variable Option DebugPuts 3 "entering testConstraint $constraint $value" if {[llength [info level 0]] == 2} { return $testConstraints($constraint) } # Check for boolean values if {[catch {expr {$value && $value}} msg]} { return -code error $msg } if {[limitConstraints] && [lsearch -exact $Option(-constraints) $constraint] == -1} { set value 0 } set testConstraints($constraint) $value } # tcltest::interpreter -- # # the interpreter name stored in tcltest::tcltest # # Arguments: # executable name # # Results: # content of tcltest::tcltest # # Side effects: # None. proc tcltest::interpreter { {interp ""} } { variable tcltest if {[llength [info level 0]] == 1} { return $tcltest } if {[string equal {} $interp]} { set tcltest {} } else { set tcltest $interp } } ##################################################################### # tcltest::AddToSkippedBecause -- # # Increments the variable used to track how many tests were # skipped because of a particular constraint. # # Arguments: # constraint The name of the constraint to be modified # # Results: # Modifies tcltest::skippedBecause; sets the variable to 1 if # didn't previously exist - otherwise, it just increments it. # # Side effects: # None. proc tcltest::AddToSkippedBecause { constraint {value 1}} { # add the constraint to the list of constraints that kept tests # from running variable skippedBecause if {[info exists skippedBecause($constraint)]} { incr skippedBecause($constraint) $value } else { set skippedBecause($constraint) $value } return } # tcltest::PrintError -- # # Prints errors to tcltest::errorChannel and then flushes that # channel, making sure that all messages are < 80 characters per # line. # # Arguments: # errorMsg String containing the error to be printed # # Results: # None. # # Side effects: # None. proc tcltest::PrintError {errorMsg} { set InitialMessage "Error: " set InitialMsgLen [string length $InitialMessage] puts -nonewline [errorChannel] $InitialMessage # Keep track of where the end of the string is. set endingIndex [string length $errorMsg] if {$endingIndex < (80 - $InitialMsgLen)} { puts [errorChannel] $errorMsg } else { # Print up to 80 characters on the first line, including the # InitialMessage. set beginningIndex [string last " " [string range $errorMsg 0 \ [expr {80 - $InitialMsgLen}]]] puts [errorChannel] [string range $errorMsg 0 $beginningIndex] while {![string equal end $beginningIndex]} { puts -nonewline [errorChannel] \ [string repeat " " $InitialMsgLen] if {($endingIndex - $beginningIndex) < (80 - $InitialMsgLen)} { puts [errorChannel] [string trim \ [string range $errorMsg $beginningIndex end]] break } else { set newEndingIndex [expr {[string last " " \ [string range $errorMsg $beginningIndex \ [expr {$beginningIndex + (80 - $InitialMsgLen)}] ]] + $beginningIndex}] if {($newEndingIndex <= 0) || ($newEndingIndex <= $beginningIndex)} { set newEndingIndex end } puts [errorChannel] [string trim \ [string range $errorMsg \ $beginningIndex $newEndingIndex]] set beginningIndex $newEndingIndex } } } flush [errorChannel] return } # tcltest::SafeFetch -- # # The following trace procedure makes it so that we can safely # refer to non-existent members of the testConstraints array # without causing an error. Instead, reading a non-existent # member will return 0. This is necessary because tests are # allowed to use constraint "X" without ensuring that # testConstraints("X") is defined. # # Arguments: # n1 - name of the array (testConstraints) # n2 - array key value (constraint name) # op - operation performed on testConstraints (generally r) # # Results: # none # # Side effects: # sets testConstraints($n2) to 0 if it's referenced but never # before used proc tcltest::SafeFetch {n1 n2 op} { variable testConstraints DebugPuts 3 "entering SafeFetch $n1 $n2 $op" if {[string equal {} $n2]} {return} if {![info exists testConstraints($n2)]} { if {[catch {testConstraint $n2 [eval [ConstraintInitializer $n2]]}]} { testConstraint $n2 0 } } } # tcltest::ConstraintInitializer -- # # Get or set a script that when evaluated in the tcltest namespace # will return a boolean value with which to initialize the # associated constraint. # # Arguments: # constraint - name of the constraint initialized by the script # script - the initializer script # # Results # boolean value of the constraint - enabled or disabled # # Side effects: # Constraint is initialized for future reference by [test] proc tcltest::ConstraintInitializer {constraint {script ""}} { variable ConstraintInitializer DebugPuts 3 "entering ConstraintInitializer $constraint $script" if {[llength [info level 0]] == 2} { return $ConstraintInitializer($constraint) } # Check for boolean values if {![info complete $script]} { return -code error "ConstraintInitializer must be complete script" } set ConstraintInitializer($constraint) $script } # tcltest::InitConstraints -- # # Call all registered constraint initializers to force initialization # of all known constraints. # See the tcltest man page for the list of built-in constraints defined # in this procedure. # # Arguments: # none # # Results: # The testConstraints array is reset to have an index for each # built-in test constraint. # # Side Effects: # None. # proc tcltest::InitConstraints {} { variable ConstraintInitializer initConstraintsHook foreach constraint [array names ConstraintInitializer] { testConstraint $constraint } } proc tcltest::DefineConstraintInitializers {} { ConstraintInitializer singleTestInterp {singleProcess} # All the 'pc' constraints are here for backward compatibility and # are not documented. They have been replaced with equivalent 'win' # constraints. ConstraintInitializer unixOnly \ {string equal $::tcl_platform(platform) unix} ConstraintInitializer macOnly \ {string equal $::tcl_platform(platform) macintosh} ConstraintInitializer pcOnly \ {string equal $::tcl_platform(platform) windows} ConstraintInitializer winOnly \ {string equal $::tcl_platform(platform) windows} ConstraintInitializer unix {testConstraint unixOnly} ConstraintInitializer mac {testConstraint macOnly} ConstraintInitializer pc {testConstraint pcOnly} ConstraintInitializer win {testConstraint winOnly} ConstraintInitializer unixOrPc \ {expr {[testConstraint unix] || [testConstraint pc]}} ConstraintInitializer macOrPc \ {expr {[testConstraint mac] || [testConstraint pc]}} ConstraintInitializer unixOrWin \ {expr {[testConstraint unix] || [testConstraint win]}} ConstraintInitializer macOrWin \ {expr {[testConstraint mac] || [testConstraint win]}} ConstraintInitializer macOrUnix \ {expr {[testConstraint mac] || [testConstraint unix]}} ConstraintInitializer nt {string equal $::tcl_platform(os) "Windows NT"} ConstraintInitializer 95 {string equal $::tcl_platform(os) "Windows 95"} ConstraintInitializer 98 {string equal $::tcl_platform(os) "Windows 98"} # The following Constraints switches are used to mark tests that # should work, but have been temporarily disabled on certain # platforms because they don't and we haven't gotten around to # fixing the underlying problem. ConstraintInitializer tempNotPc {expr {![testConstraint pc]}} ConstraintInitializer tempNotWin {expr {![testConstraint win]}} ConstraintInitializer tempNotMac {expr {![testConstraint mac]}} ConstraintInitializer tempNotUnix {expr {![testConstraint unix]}} # The following Constraints switches are used to mark tests that # crash on certain platforms, so that they can be reactivated again # when the underlying problem is fixed. ConstraintInitializer pcCrash {expr {![testConstraint pc]}} ConstraintInitializer winCrash {expr {![testConstraint win]}} ConstraintInitializer macCrash {expr {![testConstraint mac]}} ConstraintInitializer unixCrash {expr {![testConstraint unix]}} # Skip empty tests ConstraintInitializer emptyTest {format 0} # By default, tests that expose known bugs are skipped. ConstraintInitializer knownBug {format 0} # By default, non-portable tests are skipped. ConstraintInitializer nonPortable {format 0} # Some tests require user interaction. ConstraintInitializer userInteraction {format 0} # Some tests must be skipped if the interpreter is not in # interactive mode ConstraintInitializer interactive \ {expr {[info exists ::tcl_interactive] && $::tcl_interactive}} # Some tests can only be run if the installation came from a CD # image instead of a web image. Some tests must be skipped if you # are running as root on Unix. Other tests can only be run if you # are running as root on Unix. ConstraintInitializer root {expr \ {[string equal unix $::tcl_platform(platform)] && ([string equal root $::tcl_platform(user)] || [string equal "" $::tcl_platform(user)])}} ConstraintInitializer notRoot {expr {![testConstraint root]}} # Set nonBlockFiles constraint: 1 means this platform supports # setting files into nonblocking mode. ConstraintInitializer nonBlockFiles { set code [expr {[catch {set f [open defs r]}] || [catch {fconfigure $f -blocking off}]}] catch {close $f} set code } # Set asyncPipeClose constraint: 1 means this platform supports # async flush and async close on a pipe. # # Test for SCO Unix - cannot run async flushing tests because a # potential problem with select is apparently interfering. # (Mark Diekhans). ConstraintInitializer asyncPipeClose {expr { !([string equal unix $::tcl_platform(platform)] && ([catch {exec uname -X | fgrep {Release = 3.2v}}] == 0))}} # Test to see if we have a broken version of sprintf with respect # to the "e" format of floating-point numbers. ConstraintInitializer eformat {string equal [format %g 5e-5] 5e-05} # Test to see if execed commands such as cat, echo, rm and so forth # are present on this machine. ConstraintInitializer unixExecs { set code 1 if {[string equal macintosh $::tcl_platform(platform)]} { set code 0 } if {[string equal windows $::tcl_platform(platform)]} { if {[catch { set file _tcl_test_remove_me.txt makeFile {hello} $file }]} { set code 0 } elseif { [catch {exec cat $file}] || [catch {exec echo hello}] || [catch {exec sh -c echo hello}] || [catch {exec wc $file}] || [catch {exec sleep 1}] || [catch {exec echo abc > $file}] || [catch {exec chmod 644 $file}] || [catch {exec rm $file}] || [llength [auto_execok mkdir]] == 0 || [llength [auto_execok fgrep]] == 0 || [llength [auto_execok grep]] == 0 || [llength [auto_execok ps]] == 0 } { set code 0 } removeFile $file } set code } ConstraintInitializer stdio { set code 0 if {![catch {set f [open "|[list [interpreter]]" w]}]} { if {![catch {puts $f exit}]} { if {![catch {close $f}]} { set code 1 } } } set code } # Deliberately call socket with the wrong number of arguments. The # error message you get will indicate whether sockets are available # on this system. ConstraintInitializer socket { catch {socket} msg string compare $msg "sockets are not available on this system" } # Check for internationalization ConstraintInitializer hasIsoLocale { if {[llength [info commands testlocale]] == 0} { set code 0 } else { set code [string length [SetIso8859_1_Locale]] RestoreLocale } set code } } ##################################################################### # Usage and command line arguments processing. # tcltest::PrintUsageInfo # # Prints out the usage information for package tcltest. This can # be customized with the redefinition of [PrintUsageInfoHook]. # # Arguments: # none # # Results: # none # # Side Effects: # none proc tcltest::PrintUsageInfo {} { puts [Usage] PrintUsageInfoHook } proc tcltest::Usage { {option ""} } { variable Usage variable Verify if {[llength [info level 0]] == 1} { set msg "Usage: [file tail [info nameofexecutable]] script " append msg "?-help? ?flag value? ... \n" append msg "Available flags (and valid input values) are:" set max 0 set allOpts [concat -help [Configure]] foreach opt $allOpts { set foo [Usage $opt] foreach [list x type($opt) usage($opt)] $foo break set line($opt) " $opt $type($opt) " set length($opt) [string length $line($opt)] if {$length($opt) > $max} {set max $length($opt)} } set rest [expr {72 - $max}] foreach opt $allOpts { append msg \n$line($opt) append msg [string repeat " " [expr {$max - $length($opt)}]] set u [string trim $usage($opt)] catch {append u " (default: \[[Configure $opt]])"} regsub -all {\s*\n\s*} $u " " u while {[string length $u] > $rest} { set break [string wordstart $u $rest] if {$break == 0} { set break [string wordend $u 0] } append msg [string range $u 0 [expr {$break - 1}]] set u [string trim [string range $u $break end]] append msg \n[string repeat " " $max] } append msg $u } return $msg\n } elseif {[string equal -help $option]} { return [list -help "" "Display this usage information."] } else { set type [lindex [info args $Verify($option)] 0] return [list $option $type $Usage($option)] } } # tcltest::ProcessFlags -- # # process command line arguments supplied in the flagArray - this # is called by processCmdLineArgs. Modifies tcltest variables # according to the content of the flagArray. # # Arguments: # flagArray - array containing name/value pairs of flags # # Results: # sets tcltest variables according to their values as defined by # flagArray # # Side effects: # None. proc tcltest::ProcessFlags {flagArray} { # Process -help first if {[lsearch -exact $flagArray {-help}] != -1} { PrintUsageInfo exit 1 } if {[llength $flagArray] == 0} { RemoveAutoConfigureTraces } else { set args $flagArray while {[llength $args]>1 && [catch {eval configure $args} msg]} { # Something went wrong parsing $args for tcltest options # Check whether the problem is "unknown option" if {[regexp {^unknown option (\S+):} $msg -> option]} { # Could be this is an option the Hook knows about set moreOptions [processCmdLineArgsAddFlagsHook] if {[lsearch -exact $moreOptions $option] == -1} { # Nope. Report the error, including additional options, # but keep going if {[llength $moreOptions]} { append msg ", " append msg [join [lrange $moreOptions 0 end-1] ", "] append msg "or [lindex $moreOptions end]" } Warn $msg } } else { # error is something other than "unknown option" # notify user of the error; and exit puts [errorChannel] $msg exit 1 } # To recover, find that unknown option and remove up to it. # then retry while {![string equal [lindex $args 0] $option]} { set args [lrange $args 2 end] } set args [lrange $args 2 end] } if {[llength $args] == 1} { puts [errorChannel] \ "missing value for option [lindex $args 0]" exit 1 } } # Call the hook catch { array set flag $flagArray processCmdLineArgsHook [array get flag] } return } # tcltest::ProcessCmdLineArgs -- # # This procedure must be run after constraint initialization is # set up (by [DefineConstraintInitializers]) because some constraints # can be overridden. # # Perform configuration according to the command-line options. # # Arguments: # none # # Results: # Sets the above-named variables in the tcltest namespace. # # Side Effects: # None. # proc tcltest::ProcessCmdLineArgs {} { variable originalEnv variable testConstraints # The "argv" var doesn't exist in some cases, so use {}. if {![info exists ::argv]} { ProcessFlags {} } else { ProcessFlags $::argv } # Spit out everything you know if we're at a debug level 2 or # greater DebugPuts 2 "Flags passed into tcltest:" if {[info exists ::env(TCLTEST_OPTIONS)]} { DebugPuts 2 \ " ::env(TCLTEST_OPTIONS): $::env(TCLTEST_OPTIONS)" } if {[info exists ::argv]} { DebugPuts 2 " argv: $::argv" } DebugPuts 2 "tcltest::debug = [debug]" DebugPuts 2 "tcltest::testsDirectory = [testsDirectory]" DebugPuts 2 "tcltest::workingDirectory = [workingDirectory]" DebugPuts 2 "tcltest::temporaryDirectory = [temporaryDirectory]" DebugPuts 2 "tcltest::outputChannel = [outputChannel]" DebugPuts 2 "tcltest::errorChannel = [errorChannel]" DebugPuts 2 "Original environment (tcltest::originalEnv):" DebugPArray 2 originalEnv DebugPuts 2 "Constraints:" DebugPArray 2 testConstraints } ##################################################################### # Code to run the tests goes here. # tcltest::TestPuts -- # # Used to redefine puts in test environment. Stores whatever goes # out on stdout in tcltest::outData and stderr in errData before # sending it on to the regular puts. # # Arguments: # same as standard puts # # Results: # none # # Side effects: # Intercepts puts; data that would otherwise go to stdout, stderr, # or file channels specified in outputChannel and errorChannel # does not get sent to the normal puts function. namespace eval tcltest::Replace { namespace export puts } proc tcltest::Replace::puts {args} { variable [namespace parent]::outData variable [namespace parent]::errData switch [llength $args] { 1 { # Only the string to be printed is specified append outData [lindex $args 0]\n return # return [Puts [lindex $args 0]] } 2 { # Either -nonewline or channelId has been specified if {[string equal -nonewline [lindex $args 0]]} { append outData [lindex $args end] return # return [Puts -nonewline [lindex $args end]] } else { set channel [lindex $args 0] set newline \n } } 3 { if {[string equal -nonewline [lindex $args 0]]} { # Both -nonewline and channelId are specified, unless # it's an error. -nonewline is supposed to be argv[0]. set channel [lindex $args 1] set newline "" } } } if {[info exists channel]} { if {[string equal $channel [[namespace parent]::outputChannel]] || [string equal $channel stdout]} { append outData [lindex $args end]$newline return } elseif {[string equal $channel [[namespace parent]::errorChannel]] || [string equal $channel stderr]} { append errData [lindex $args end]$newline return } } # If we haven't returned by now, we don't know how to handle the # input. Let puts handle it. return [eval Puts $args] } # tcltest::Eval -- # # Evaluate the script in the test environment. If ignoreOutput is # false, store data sent to stderr and stdout in outData and # errData. Otherwise, ignore this output altogether. # # Arguments: # script Script to evaluate # ?ignoreOutput? Indicates whether or not to ignore output # sent to stdout & stderr # # Results: # result from running the script # # Side effects: # Empties the contents of outData and errData before running a # test if ignoreOutput is set to 0. proc tcltest::Eval {script {ignoreOutput 1}} { variable outData variable errData DebugPuts 3 "[lindex [info level 0] 0] called" if {!$ignoreOutput} { set outData {} set errData {} rename ::puts [namespace current]::Replace::Puts namespace eval :: \ [list namespace import [namespace origin Replace::puts]] namespace import Replace::puts } set result [uplevel 1 $script] if {!$ignoreOutput} { namespace forget puts namespace eval :: namespace forget puts rename [namespace current]::Replace::Puts ::puts } return $result } # tcltest::CompareStrings -- # # compares the expected answer to the actual answer, depending on # the mode provided. Mode determines whether a regexp, exact, # glob or custom comparison is done. # # Arguments: # actual - string containing the actual result # expected - pattern to be matched against # mode - type of comparison to be done # # Results: # result of the match # # Side effects: # None. proc tcltest::CompareStrings {actual expected mode} { variable CustomMatch if {![info exists CustomMatch($mode)]} { return -code error "No matching command registered for `-match $mode'" } set match [namespace eval :: $CustomMatch($mode) [list $expected $actual]] if {[catch {expr {$match && $match}} result]} { return -code error "Invalid result from `-match $mode' command: $result" } return $match } # tcltest::customMatch -- # # registers a command to be called when a particular type of # matching is required. # # Arguments: # nickname - Keyword for the type of matching # cmd - Incomplete command that implements that type of matching # when completed with expected string and actual string # and then evaluated. # # Results: # None. # # Side effects: # Sets the variable tcltest::CustomMatch proc tcltest::customMatch {mode script} { variable CustomMatch if {![info complete $script]} { return -code error \ "invalid customMatch script; can't evaluate after completion" } set CustomMatch($mode) $script } # tcltest::SubstArguments list # # This helper function takes in a list of words, then perform a # substitution on the list as though each word in the list is a separate # argument to the Tcl function. For example, if this function is # invoked as: # # SubstArguments {$a {$a}} # # Then it is as though the function is invoked as: # # SubstArguments $a {$a} # # This code is adapted from Paul Duffin's function "SplitIntoWords". # The original function can be found on: # # http://purl.org/thecliff/tcl/wiki/858.html # # Results: # a list containing the result of the substitution # # Exceptions: # An error may occur if the list containing unbalanced quote or # unknown variable. # # Side Effects: # None. # proc tcltest::SubstArguments {argList} { # We need to split the argList up into tokens but cannot use list # operations as they throw away some significant quoting, and # [split] ignores braces as it should. Therefore what we do is # gradually build up a string out of whitespace seperated strings. # We cannot use [split] to split the argList into whitespace # separated strings as it throws away the whitespace which maybe # important so we have to do it all by hand. set result {} set token "" while {[string length $argList]} { # Look for the next word containing a quote: " { } if {[regexp -indices {[^ \t\n]*[\"\{\}]+[^ \t\n]*} \ $argList all]} { # Get the text leading up to this word, but not including # this word, from the argList. set text [string range $argList 0 \ [expr {[lindex $all 0] - 1}]] # Get the word with the quote set word [string range $argList \ [lindex $all 0] [lindex $all 1]] # Remove all text up to and including the word from the # argList. set argList [string range $argList \ [expr {[lindex $all 1] + 1}] end] } else { # Take everything up to the end of the argList. set text $argList set word {} set argList {} } if {$token != {}} { # If we saw a word with quote before, then there is a # multi-word token starting with that word. In this case, # add the text and the current word to this token. append token $text $word } else { # Add the text to the result. There is no need to parse # the text because it couldn't be a part of any multi-word # token. Then start a new multi-word token with the word # because we need to pass this token to the Tcl parser to # check for balancing quotes append result $text set token $word } if { [catch {llength $token} length] == 0 && $length == 1} { # The token is a valid list so add it to the result. # lappend result [string trim $token] append result \{$token\} set token {} } } # If the last token has not been added to the list then there # is a problem. if { [string length $token] } { error "incomplete token \"$token\"" } return $result } # tcltest::test -- # # This procedure runs a test and prints an error message if the test # fails. If verbose has been set, it also prints a message even if the # test succeeds. The test will be skipped if it doesn't match the # match variable, if it matches an element in skip, or if one of the # elements of "constraints" turns out not to be true. # # If testLevel is 1, then this is a top level test, and we record # pass/fail information; otherwise, this information is not logged and # is not added to running totals. # # Attributes: # Only description is a required attribute. All others are optional. # Default values are indicated. # # constraints - A list of one or more keywords, each of which # must be the name of an element in the array # "testConstraints". If any of these elements is # zero, the test is skipped. This attribute is # optional; default is {} # body - Script to run to carry out the test. It must # return a result that can be checked for # correctness. This attribute is optional; # default is {} # result - Expected result from script. This attribute is # optional; default is {}. # output - Expected output sent to stdout. This attribute # is optional; default is {}. # errorOutput - Expected output sent to stderr. This attribute # is optional; default is {}. # returnCodes - Expected return codes. This attribute is # optional; default is {0 2}. # setup - Code to run before $script (above). This # attribute is optional; default is {}. # cleanup - Code to run after $script (above). This # attribute is optional; default is {}. # match - specifies type of matching to do on result, # output, errorOutput; this must be a string # previously registered by a call to [customMatch]. # The strings exact, glob, and regexp are pre-registered # by the tcltest package. Default value is exact. # # Arguments: # name - Name of test, in the form foo-1.2. # description - Short textual description of the test, to # help humans understand what it does. # # Results: # None. # # Side effects: # Just about anything is possible depending on the test. # proc tcltest::test {name description args} { global tcl_platform variable testLevel variable coreModTime DebugPuts 3 "test $name $args" DebugDo 1 { variable TestNames catch { puts "test name '$name' re-used; prior use in $TestNames($name)" } set TestNames($name) [info script] } FillFilesExisted incr testLevel # Pre-define everything to null except output and errorOutput. We # determine whether or not to trap output based on whether or not # these variables (output & errorOutput) are defined. foreach item {constraints setup cleanup body result returnCodes match} { set $item {} } # Set the default match mode set match exact # Set the default match values for return codes (0 is the standard # expected return value if everything went well; 2 represents # 'return' being used in the test script). set returnCodes [list 0 2] # The old test format can't have a 3rd argument (constraints or # script) that starts with '-'. if {[string match -* [lindex $args 0]] || ([llength $args] <= 1)} { if {[llength $args] == 1} { set list [SubstArguments [lindex $args 0]] foreach {element value} $list { set testAttributes($element) $value } foreach item {constraints match setup body cleanup \ result returnCodes output errorOutput} { if {[info exists testAttributes(-$item)]} { set testAttributes(-$item) [uplevel 1 \ ::concat $testAttributes(-$item)] } } } else { array set testAttributes $args } set validFlags {-setup -cleanup -body -result -returnCodes \ -match -output -errorOutput -constraints} foreach flag [array names testAttributes] { if {[lsearch -exact $validFlags $flag] == -1} { incr testLevel -1 set sorted [lsort $validFlags] set options [join [lrange $sorted 0 end-1] ", "] append options ", or [lindex $sorted end]" return -code error "bad option \"$flag\": must be $options" } } # store whatever the user gave us foreach item [array names testAttributes] { set [string trimleft $item "-"] $testAttributes($item) } # Check the values supplied for -match variable CustomMatch if {[lsearch [array names CustomMatch] $match] == -1} { incr testLevel -1 set sorted [lsort [array names CustomMatch]] set values [join [lrange $sorted 0 end-1] ", "] append values ", or [lindex $sorted end]" return -code error "bad -match value \"$match\":\ must be $values" } # Replace symbolic valies supplied for -returnCodes foreach {strcode numcode} {ok 0 normal 0 error 1 return 2 break 3 continue 4} { set returnCodes [string map -nocase [list $strcode $numcode] $returnCodes] } } else { # This is parsing for the old test command format; it is here # for backward compatibility. set result [lindex $args end] if {[llength $args] == 2} { set body [lindex $args 0] } elseif {[llength $args] == 3} { set constraints [lindex $args 0] set body [lindex $args 1] } else { incr testLevel -1 return -code error "wrong # args:\ should be \"test name desc ?options?\"" } } if {[Skipped $name $constraints]} { incr testLevel -1 return } # Save information about the core file. if {[preserveCore]} { if {[file exists [file join [workingDirectory] core]]} { set coreModTime [file mtime [file join [workingDirectory] core]] } } # First, run the setup script set code [catch {uplevel 1 $setup} setupMsg] if {$code == 1} { set errorInfo(setup) $::errorInfo set errorCode(setup) $::errorCode } set setupFailure [expr {$code != 0}] # Only run the test body if the setup was successful if {!$setupFailure} { # Verbose notification of $body start if {[IsVerbose start]} { puts [outputChannel] "---- $name start" flush [outputChannel] } set command [list [namespace origin RunTest] $name $body] if {[info exists output] || [info exists errorOutput]} { set testResult [uplevel 1 [list [namespace origin Eval] $command 0]] } else { set testResult [uplevel 1 [list [namespace origin Eval] $command 1]] } foreach {actualAnswer returnCode} $testResult break if {$returnCode == 1} { set errorInfo(body) $::errorInfo set errorCode(body) $::errorCode } } # Always run the cleanup script set code [catch {uplevel 1 $cleanup} cleanupMsg] if {$code == 1} { set errorInfo(cleanup) $::errorInfo set errorCode(cleanup) $::errorCode } set cleanupFailure [expr {$code != 0}] set coreFailure 0 set coreMsg "" # check for a core file first - if one was created by the test, # then the test failed if {[preserveCore]} { if {[file exists [file join [workingDirectory] core]]} { # There's only a test failure if there is a core file # and (1) there previously wasn't one or (2) the new # one is different from the old one. if {[info exists coreModTime]} { if {$coreModTime != [file mtime \ [file join [workingDirectory] core]]} { set coreFailure 1 } } else { set coreFailure 1 } if {([preserveCore] > 1) && ($coreFailure)} { append coreMsg "\nMoving file to:\ [file join [temporaryDirectory] core-$name]" catch {file rename -force \ [file join [workingDirectory] core] \ [file join [temporaryDirectory] core-$name] } msg if {[string length $msg] > 0} { append coreMsg "\nError:\ Problem renaming core file: $msg" } } } } # check if the return code matched the expected return code set codeFailure 0 if {!$setupFailure && [lsearch -exact $returnCodes $returnCode] == -1} { set codeFailure 1 } # If expected output/error strings exist, we have to compare # them. If the comparison fails, then so did the test. set outputFailure 0 variable outData if {[info exists output] && !$codeFailure} { if {[set outputCompare [catch { CompareStrings $outData $output $match } outputMatch]] == 0} { set outputFailure [expr {!$outputMatch}] } else { set outputFailure 1 } } set errorFailure 0 variable errData if {[info exists errorOutput] && !$codeFailure} { if {[set errorCompare [catch { CompareStrings $errData $errorOutput $match } errorMatch]] == 0} { set errorFailure [expr {!$errorMatch}] } else { set errorFailure 1 } } # check if the answer matched the expected answer # Only check if we ran the body of the test (no setup failure) if {$setupFailure || $codeFailure} { set scriptFailure 0 } elseif {[set scriptCompare [catch { CompareStrings $actualAnswer $result $match } scriptMatch]] == 0} { set scriptFailure [expr {!$scriptMatch}] } else { set scriptFailure 1 } # if we didn't experience any failures, then we passed variable numTests if {!($setupFailure || $cleanupFailure || $coreFailure || $outputFailure || $errorFailure || $codeFailure || $scriptFailure)} { if {$testLevel == 1} { incr numTests(Passed) if {[IsVerbose pass]} { puts [outputChannel] "++++ $name PASSED" } } incr testLevel -1 return } # We know the test failed, tally it... if {$testLevel == 1} { incr numTests(Failed) } # ... then report according to the type of failure variable currentFailure true if {![IsVerbose body]} { set body "" } puts [outputChannel] "\n==== $name\ [string trim $description] FAILED" if {[string length $body]} { puts [outputChannel] "==== Contents of test case:" puts [outputChannel] $body } if {$setupFailure} { puts [outputChannel] "---- Test setup\ failed:\n$setupMsg" if {[info exists errorInfo(setup)]} { puts [outputChannel] "---- errorInfo(setup): $errorInfo(setup)" puts [outputChannel] "---- errorCode(setup): $errorCode(setup)" } } if {$scriptFailure} { if {$scriptCompare} { puts [outputChannel] "---- Error testing result: $scriptMatch" } else { puts [outputChannel] "---- Result was:\n$actualAnswer" puts [outputChannel] "---- Result should have been\ ($match matching):\n$result" } } if {$codeFailure} { switch -- $returnCode { 0 { set msg "Test completed normally" } 1 { set msg "Test generated error" } 2 { set msg "Test generated return exception" } 3 { set msg "Test generated break exception" } 4 { set msg "Test generated continue exception" } default { set msg "Test generated exception" } } puts [outputChannel] "---- $msg; Return code was: $returnCode" puts [outputChannel] "---- Return code should have been\ one of: $returnCodes" if {[IsVerbose error]} { if {[info exists errorInfo(body)] && ([lsearch $returnCodes 1]<0)} { puts [outputChannel] "---- errorInfo: $errorInfo(body)" puts [outputChannel] "---- errorCode: $errorCode(body)" } } } if {$outputFailure} { if {$outputCompare} { puts [outputChannel] "---- Error testing output: $outputMatch" } else { puts [outputChannel] "---- Output was:\n$outData" puts [outputChannel] "---- Output should have been\ ($match matching):\n$output" } } if {$errorFailure} { if {$errorCompare} { puts [outputChannel] "---- Error testing errorOutput: $errorMatch" } else { puts [outputChannel] "---- Error output was:\n$errData" puts [outputChannel] "---- Error output should have\ been ($match matching):\n$errorOutput" } } if {$cleanupFailure} { puts [outputChannel] "---- Test cleanup failed:\n$cleanupMsg" if {[info exists errorInfo(cleanup)]} { puts [outputChannel] "---- errorInfo(cleanup): $errorInfo(cleanup)" puts [outputChannel] "---- errorCode(cleanup): $errorCode(cleanup)" } } if {$coreFailure} { puts [outputChannel] "---- Core file produced while running\ test! $coreMsg" } puts [outputChannel] "==== $name FAILED\n" incr testLevel -1 return } # Skipped -- # # Given a test name and it constraints, returns a boolean indicating # whether the current configuration says the test should be skipped. # # Side Effects: Maintains tally of total tests seen and tests skipped. # proc tcltest::Skipped {name constraints} { variable testLevel variable numTests variable testConstraints if {$testLevel == 1} { incr numTests(Total) } # skip the test if it's name matches an element of skip foreach pattern [skip] { if {[string match $pattern $name]} { if {$testLevel == 1} { incr numTests(Skipped) DebugDo 1 {AddToSkippedBecause userSpecifiedSkip} } return 1 } } # skip the test if it's name doesn't match any element of match set ok 0 foreach pattern [match] { if {[string match $pattern $name]} { set ok 1 break } } if {!$ok} { if {$testLevel == 1} { incr numTests(Skipped) DebugDo 1 {AddToSkippedBecause userSpecifiedNonMatch} } return 1 } if {[string equal {} $constraints]} { # If we're limited to the listed constraints and there aren't # any listed, then we shouldn't run the test. if {[limitConstraints]} { AddToSkippedBecause userSpecifiedLimitConstraint if {$testLevel == 1} { incr numTests(Skipped) } return 1 } } else { # "constraints" argument exists; # make sure that the constraints are satisfied. set doTest 0 if {[string match {*[$\[]*} $constraints] != 0} { # full expression, e.g. {$foo > [info tclversion]} catch {set doTest [uplevel #0 expr $constraints]} } elseif {[regexp {[^.a-zA-Z0-9 \n\r\t]+} $constraints] != 0} { # something like {a || b} should be turned into # $testConstraints(a) || $testConstraints(b). regsub -all {[.\w]+} $constraints {$testConstraints(&)} c catch {set doTest [eval expr $c]} } elseif {![catch {llength $constraints}]} { # just simple constraints such as {unixOnly fonts}. set doTest 1 foreach constraint $constraints { if {(![info exists testConstraints($constraint)]) \ || (!$testConstraints($constraint))} { set doTest 0 # store the constraint that kept the test from # running set constraints $constraint break } } } if {$doTest == 0} { if {[IsVerbose skip]} { puts [outputChannel] "++++ $name SKIPPED: $constraints" } if {$testLevel == 1} { incr numTests(Skipped) AddToSkippedBecause $constraints } return 1 } } return 0 } # RunTest -- # # This is where the body of a test is evaluated. The combination of # [RunTest] and [Eval] allows the output and error output of the test # body to be captured for comparison against the expected values. proc tcltest::RunTest {name script} { DebugPuts 3 "Running $name {$script}" # If there is no "memory" command (because memory debugging isn't # enabled), then don't attempt to use the command. if {[llength [info commands memory]] == 1} { memory tag $name } set code [catch {uplevel 1 $script} actualAnswer] return [list $actualAnswer $code] } ##################################################################### # tcltest::cleanupTestsHook -- # # This hook allows a harness that builds upon tcltest to specify # additional things that should be done at cleanup. # if {[llength [info commands tcltest::cleanupTestsHook]] == 0} { proc tcltest::cleanupTestsHook {} {} } # tcltest::cleanupTests -- # # Remove files and dirs created using the makeFile and makeDirectory # commands since the last time this proc was invoked. # # Print the names of the files created without the makeFile command # since the tests were invoked. # # Print the number tests (total, passed, failed, and skipped) since the # tests were invoked. # # Restore original environment (as reported by special variable env). # # Arguments: # calledFromAllFile - if 0, behave as if we are running a single # test file within an entire suite of tests. if we aren't running # a single test file, then don't report status. check for new # files created during the test run and report on them. if 1, # report collated status from all the test file runs. # # Results: # None. # # Side Effects: # None # proc tcltest::cleanupTests {{calledFromAllFile 0}} { variable filesMade variable filesExisted variable createdNewFiles variable testSingleFile variable numTests variable numTestFiles variable failFiles variable skippedBecause variable currentFailure variable originalEnv variable originalTclPlatform variable coreModTime FillFilesExisted set testFileName [file tail [info script]] # Call the cleanup hook cleanupTestsHook # Remove files and directories created by the makeFile and # makeDirectory procedures. Record the names of files in # workingDirectory that were not pre-existing, and associate them # with the test file that created them. if {!$calledFromAllFile} { foreach file $filesMade { if {[file exists $file]} { DebugDo 1 {Warn "cleanupTests deleting $file..."} catch {file delete -force $file} } } set currentFiles {} foreach file [glob -nocomplain \ -directory [temporaryDirectory] *] { lappend currentFiles [file tail $file] } set newFiles {} foreach file $currentFiles { if {[lsearch -exact $filesExisted $file] == -1} { lappend newFiles $file } } set filesExisted $currentFiles if {[llength $newFiles] > 0} { set createdNewFiles($testFileName) $newFiles } } if {$calledFromAllFile || $testSingleFile} { # print stats puts -nonewline [outputChannel] "$testFileName:" foreach index [list "Total" "Passed" "Skipped" "Failed"] { puts -nonewline [outputChannel] \ "\t$index\t$numTests($index)" } puts [outputChannel] "" # print number test files sourced # print names of files that ran tests which failed if {$calledFromAllFile} { puts [outputChannel] \ "Sourced $numTestFiles Test Files." set numTestFiles 0 if {[llength $failFiles] > 0} { puts [outputChannel] \ "Files with failing tests: $failFiles" set failFiles {} } } # if any tests were skipped, print the constraints that kept # them from running. set constraintList [array names skippedBecause] if {[llength $constraintList] > 0} { puts [outputChannel] \ "Number of tests skipped for each constraint:" foreach constraint [lsort $constraintList] { puts [outputChannel] \ "\t$skippedBecause($constraint)\t$constraint" unset skippedBecause($constraint) } } # report the names of test files in createdNewFiles, and reset # the array to be empty. set testFilesThatTurded [lsort [array names createdNewFiles]] if {[llength $testFilesThatTurded] > 0} { puts [outputChannel] "Warning: files left behind:" foreach testFile $testFilesThatTurded { puts [outputChannel] \ "\t$testFile:\t$createdNewFiles($testFile)" unset createdNewFiles($testFile) } } # reset filesMade, filesExisted, and numTests set filesMade {} foreach index [list "Total" "Passed" "Skipped" "Failed"] { set numTests($index) 0 } # exit only if running Tk in non-interactive mode # This should be changed to determine if an event # loop is running, which is the real issue. # Actually, this doesn't belong here at all. A package # really has no business [exit]-ing an application. if {![catch {package present Tk}] && ![testConstraint interactive]} { exit } } else { # if we're deferring stat-reporting until all files are sourced, # then add current file to failFile list if any tests in this # file failed if {$currentFailure \ && ([lsearch -exact $failFiles $testFileName] == -1)} { lappend failFiles $testFileName } set currentFailure false # restore the environment to the state it was in before this package # was loaded set newEnv {} set changedEnv {} set removedEnv {} foreach index [array names ::env] { if {![info exists originalEnv($index)]} { lappend newEnv $index unset ::env($index) } else { if {$::env($index) != $originalEnv($index)} { lappend changedEnv $index set ::env($index) $originalEnv($index) } } } foreach index [array names originalEnv] { if {![info exists ::env($index)]} { lappend removedEnv $index set ::env($index) $originalEnv($index) } } if {[llength $newEnv] > 0} { puts [outputChannel] \ "env array elements created:\t$newEnv" } if {[llength $changedEnv] > 0} { puts [outputChannel] \ "env array elements changed:\t$changedEnv" } if {[llength $removedEnv] > 0} { puts [outputChannel] \ "env array elements removed:\t$removedEnv" } set changedTclPlatform {} foreach index [array names originalTclPlatform] { if {$::tcl_platform($index) \ != $originalTclPlatform($index)} { lappend changedTclPlatform $index set ::tcl_platform($index) $originalTclPlatform($index) } } if {[llength $changedTclPlatform] > 0} { puts [outputChannel] "tcl_platform array elements\ changed:\t$changedTclPlatform" } if {[file exists [file join [workingDirectory] core]]} { if {[preserveCore] > 1} { puts "rename core file (> 1)" puts [outputChannel] "produced core file! \ Moving file to: \ [file join [temporaryDirectory] core-$testFileName]" catch {file rename -force \ [file join [workingDirectory] core] \ [file join [temporaryDirectory] core-$testFileName] } msg if {[string length $msg] > 0} { PrintError "Problem renaming file: $msg" } } else { # Print a message if there is a core file and (1) there # previously wasn't one or (2) the new one is different # from the old one. if {[info exists coreModTime]} { if {$coreModTime != [file mtime \ [file join [workingDirectory] core]]} { puts [outputChannel] "A core file was created!" } } else { puts [outputChannel] "A core file was created!" } } } } flush [outputChannel] flush [errorChannel] return } ##################################################################### # Procs that determine which tests/test files to run # tcltest::GetMatchingFiles # # Looks at the patterns given to match and skip files and uses # them to put together a list of the tests that will be run. # # Arguments: # directory to search # # Results: # The constructed list is returned to the user. This will # primarily be used in 'all.tcl' files. It is used in # runAllTests. # # Side Effects: # None # a lower case version is needed for compatibility with tcltest 1.0 proc tcltest::getMatchingFiles args {eval GetMatchingFiles $args} proc tcltest::GetMatchingFiles { args } { if {[llength $args]} { set dirList $args } else { # Finding tests only in [testsDirectory] is normal operation. # This procedure is written to accept multiple directory arguments # only to satisfy version 1 compatibility. set dirList [list [testsDirectory]] } set matchingFiles [list] foreach directory $dirList { # List files in $directory that match patterns to run. set matchFileList [list] foreach match [matchFiles] { set matchFileList [concat $matchFileList \ [glob -directory $directory -nocomplain -- $match]] } # List files in $directory that match patterns to skip. set skipFileList [list] foreach skip [skipFiles] { set skipFileList [concat $skipFileList \ [glob -directory $directory -nocomplain -- $skip]] } # Add to result list all files in match list and not in skip list foreach file $matchFileList { if {[lsearch -exact $skipFileList $file] == -1} { lappend matchingFiles $file } } } if {[llength $matchingFiles] == 0} { PrintError "No test files remain after applying your match and\ skip patterns!" } return $matchingFiles } # tcltest::GetMatchingDirectories -- # # Looks at the patterns given to match and skip directories and # uses them to put together a list of the test directories that we # should attempt to run. (Only subdirectories containing an # "all.tcl" file are put into the list.) # # Arguments: # root directory from which to search # # Results: # The constructed list is returned to the user. This is used in # the primary all.tcl file. # # Side Effects: # None. proc tcltest::GetMatchingDirectories {rootdir} { # Determine the skip list first, to avoid [glob]-ing over subdirectories # we're going to throw away anyway. Be sure we skip the $rootdir if it # comes up to avoid infinite loops. set skipDirs [list $rootdir] foreach pattern [skipDirectories] { foreach path [glob -directory $rootdir -nocomplain -- $pattern] { if {[file isdirectory $path]} { lappend skipDirs $path } } } # Now step through the matching directories, prune out the skipped ones # as you go. set matchDirs [list] foreach pattern [matchDirectories] { foreach path [glob -directory $rootdir -nocomplain -- $pattern] { if {[file isdirectory $path]} { if {[lsearch -exact $skipDirs $path] == -1} { set matchDirs [concat $matchDirs \ [GetMatchingDirectories $path]] if {[file exists [file join $path all.tcl]]} { lappend matchDirs $path } } } } } if {[llength $matchDirs] == 0} { DebugPuts 1 "No test directories remain after applying match\ and skip patterns!" } return $matchDirs } # tcltest::runAllTests -- # # prints output and sources test files according to the match and # skip patterns provided. after sourcing test files, it goes on # to source all.tcl files in matching test subdirectories. # # Arguments: # shell being tested # # Results: # None. # # Side effects: # None. proc tcltest::runAllTests { {shell ""} } { variable testSingleFile variable numTestFiles variable numTests variable failFiles FillFilesExisted if {[llength [info level 0]] == 1} { set shell [interpreter] } set testSingleFile false puts [outputChannel] "Tests running in interp: $shell" puts [outputChannel] "Tests located in: [testsDirectory]" puts [outputChannel] "Tests running in: [workingDirectory]" puts [outputChannel] "Temporary files stored in\ [temporaryDirectory]" # [file system] first available in Tcl 8.4 if {![catch {file system [testsDirectory]} result] && ![string equal native [lindex $result 0]]} { # If we aren't running in the native filesystem, then we must # run the tests in a single process (via 'source'), because # trying to run then via a pipe will fail since the files don't # really exist. singleProcess 1 } if {[singleProcess]} { puts [outputChannel] \ "Test files sourced into current interpreter" } else { puts [outputChannel] \ "Test files run in separate interpreters" } if {[llength [skip]] > 0} { puts [outputChannel] "Skipping tests that match: [skip]" } puts [outputChannel] "Running tests that match: [match]" if {[llength [skipFiles]] > 0} { puts [outputChannel] \ "Skipping test files that match: [skipFiles]" } if {[llength [matchFiles]] > 0} { puts [outputChannel] \ "Only running test files that match: [matchFiles]" } set timeCmd {clock format [clock seconds]} puts [outputChannel] "Tests began at [eval $timeCmd]" # Run each of the specified tests foreach file [lsort [GetMatchingFiles]] { set tail [file tail $file] puts [outputChannel] $tail flush [outputChannel] if {[singleProcess]} { incr numTestFiles uplevel 1 [list ::source $file] } else { # Pass along our configuration to the child processes. # EXCEPT for the -outfile, because the parent process # needs to read and process output of children. set childargv [list] foreach opt [Configure] { if {[string equal $opt -outfile]} {continue} lappend childargv $opt [Configure $opt] } set cmd [linsert $childargv 0 | $shell $file] if {[catch { incr numTestFiles set pipeFd [open $cmd "r"] while {[gets $pipeFd line] >= 0} { if {[regexp [join { {^([^:]+):\t} {Total\t([0-9]+)\t} {Passed\t([0-9]+)\t} {Skipped\t([0-9]+)\t} {Failed\t([0-9]+)} } ""] $line null testFile \ Total Passed Skipped Failed]} { foreach index {Total Passed Skipped Failed} { incr numTests($index) [set $index] } if {$Failed > 0} { lappend failFiles $testFile } } elseif {[regexp [join { {^Number of tests skipped } {for each constraint:} {|^\t(\d+)\t(.+)$} } ""] $line match skipped constraint]} { if {[string match \t* $match]} { AddToSkippedBecause $constraint $skipped } } else { puts [outputChannel] $line } } close $pipeFd } msg]} { puts [outputChannel] "Test file error: $msg" # append the name of the test to a list to be reported # later lappend testFileFailures $file } } } # cleanup puts [outputChannel] "\nTests ended at [eval $timeCmd]" cleanupTests 1 if {[info exists testFileFailures]} { puts [outputChannel] "\nTest files exiting with errors: \n" foreach file $testFileFailures { puts [outputChannel] " [file tail $file]\n" } } # Checking for subdirectories in which to run tests foreach directory [GetMatchingDirectories [testsDirectory]] { set dir [file tail $directory] puts [outputChannel] [string repeat ~ 44] puts [outputChannel] "$dir test began at [eval $timeCmd]\n" uplevel 1 [list ::source [file join $directory all.tcl]] set endTime [eval $timeCmd] puts [outputChannel] "\n$dir test ended at $endTime" puts [outputChannel] "" puts [outputChannel] [string repeat ~ 44] } return } ##################################################################### # Test utility procs - not used in tcltest, but may be useful for # testing. # tcltest::loadTestedCommands -- # # Uses the specified script to load the commands to test. Allowed to # be empty, as the tested commands could have been compiled into the # interpreter. # # Arguments # none # # Results # none # # Side Effects: # none. proc tcltest::loadTestedCommands {} { variable l if {[string equal {} [loadScript]]} { return } return [uplevel 1 [loadScript]] } # tcltest::saveState -- # # Save information regarding what procs and variables exist. # # Arguments: # none # # Results: # Modifies the variable saveState # # Side effects: # None. proc tcltest::saveState {} { variable saveState uplevel 1 [list ::set [namespace which -variable saveState]] \ {[::list [::info procs] [::info vars]]} DebugPuts 2 "[lindex [info level 0] 0]: $saveState" return } # tcltest::restoreState -- # # Remove procs and variables that didn't exist before the call to # [saveState]. # # Arguments: # none # # Results: # Removes procs and variables from your environment if they don't # exist in the saveState variable. # # Side effects: # None. proc tcltest::restoreState {} { variable saveState foreach p [uplevel 1 {::info procs}] { if {([lsearch [lindex $saveState 0] $p] < 0) && ![string equal [namespace current]::$p \ [uplevel 1 [list ::namespace origin $p]]]} { DebugPuts 2 "[lindex [info level 0] 0]: Removing proc $p" uplevel 1 [list ::catch [list ::rename $p {}]] } } foreach p [uplevel 1 {::info vars}] { if {[lsearch [lindex $saveState 1] $p] < 0} { DebugPuts 2 "[lindex [info level 0] 0]:\ Removing variable $p" uplevel 1 [list ::catch [list ::unset $p]] } } return } # tcltest::normalizeMsg -- # # Removes "extra" newlines from a string. # # Arguments: # msg String to be modified # # Results: # string with extra newlines removed # # Side effects: # None. proc tcltest::normalizeMsg {msg} { regsub "\n$" [string tolower $msg] "" msg set msg [string map [list "\n\n" "\n"] $msg] return [string map [list "\n\}" "\}"] $msg] } # tcltest::makeFile -- # # Create a new file with the name , and write to it. # # If this file hasn't been created via makeFile since the last time # cleanupTests was called, add it to the $filesMade list, so it will be # removed by the next call to cleanupTests. # # Arguments: # contents content of the new file # name name of the new file # directory directory name for new file # # Results: # absolute path to the file created # # Side effects: # None. proc tcltest::makeFile {contents name {directory ""}} { variable filesMade FillFilesExisted if {[llength [info level 0]] == 3} { set directory [temporaryDirectory] } set fullName [file join $directory $name] DebugPuts 3 "[lindex [info level 0] 0]:\ putting ``$contents'' into $fullName" set fd [open $fullName w] fconfigure $fd -translation lf if {[string equal [string index $contents end] \n]} { puts -nonewline $fd $contents } else { puts $fd $contents } close $fd if {[lsearch -exact $filesMade $fullName] == -1} { lappend filesMade $fullName } return $fullName } # tcltest::removeFile -- # # Removes the named file from the filesystem # # Arguments: # name file to be removed # directory directory from which to remove file # # Results: # return value from [file delete] # # Side effects: # None. proc tcltest::removeFile {name {directory ""}} { variable filesMade FillFilesExisted if {[llength [info level 0]] == 2} { set directory [temporaryDirectory] } set fullName [file join $directory $name] DebugPuts 3 "[lindex [info level 0] 0]: removing $fullName" set idx [lsearch -exact $filesMade $fullName] set filesMade [lreplace $filesMade $idx $idx] if {$idx == -1} { DebugDo 1 { Warn "removeFile removing \"$fullName\":\n not created by makeFile" } } if {![file isfile $fullName]} { DebugDo 1 { Warn "removeFile removing \"$fullName\":\n not a file" } } return [file delete $fullName] } # tcltest::makeDirectory -- # # Create a new dir with the name . # # If this dir hasn't been created via makeDirectory since the last time # cleanupTests was called, add it to the $directoriesMade list, so it # will be removed by the next call to cleanupTests. # # Arguments: # name name of the new directory # directory directory in which to create new dir # # Results: # absolute path to the directory created # # Side effects: # None. proc tcltest::makeDirectory {name {directory ""}} { variable filesMade FillFilesExisted if {[llength [info level 0]] == 2} { set directory [temporaryDirectory] } set fullName [file join $directory $name] DebugPuts 3 "[lindex [info level 0] 0]: creating $fullName" file mkdir $fullName if {[lsearch -exact $filesMade $fullName] == -1} { lappend filesMade $fullName } return $fullName } # tcltest::removeDirectory -- # # Removes a named directory from the file system. # # Arguments: # name Name of the directory to remove # directory Directory from which to remove # # Results: # return value from [file delete] # # Side effects: # None proc tcltest::removeDirectory {name {directory ""}} { variable filesMade FillFilesExisted if {[llength [info level 0]] == 2} { set directory [temporaryDirectory] } set fullName [file join $directory $name] DebugPuts 3 "[lindex [info level 0] 0]: deleting $fullName" set idx [lsearch -exact $filesMade $fullName] set filesMade [lreplace $filesMade $idx $idx] if {$idx == -1} { DebugDo 1 { Warn "removeDirectory removing \"$fullName\":\n not created\ by makeDirectory" } } if {![file isdirectory $fullName]} { DebugDo 1 { Warn "removeDirectory removing \"$fullName\":\n not a directory" } } return [file delete -force $fullName] } # tcltest::viewFile -- # # reads the content of a file and returns it # # Arguments: # name of the file to read # directory in which file is located # # Results: # content of the named file # # Side effects: # None. proc tcltest::viewFile {name {directory ""}} { FillFilesExisted if {[llength [info level 0]] == 2} { set directory [temporaryDirectory] } set fullName [file join $directory $name] set f [open $fullName] set data [read -nonewline $f] close $f return $data } # tcltest::bytestring -- # # Construct a string that consists of the requested sequence of bytes, # as opposed to a string of properly formed UTF-8 characters. # This allows the tester to # 1. Create denormalized or improperly formed strings to pass to C # procedures that are supposed to accept strings with embedded NULL # bytes. # 2. Confirm that a string result has a certain pattern of bytes, for # instance to confirm that "\xe0\0" in a Tcl script is stored # internally in UTF-8 as the sequence of bytes "\xc3\xa0\xc0\x80". # # Generally, it's a bad idea to examine the bytes in a Tcl string or to # construct improperly formed strings in this manner, because it involves # exposing that Tcl uses UTF-8 internally. # # Arguments: # string being converted # # Results: # result fom encoding # # Side effects: # None proc tcltest::bytestring {string} { return [encoding convertfrom identity $string] } # tcltest::OpenFiles -- # # used in io tests, uses testchannel # # Arguments: # None. # # Results: # ??? # # Side effects: # None. proc tcltest::OpenFiles {} { if {[catch {testchannel open} result]} { return {} } return $result } # tcltest::LeakFiles -- # # used in io tests, uses testchannel # # Arguments: # None. # # Results: # ??? # # Side effects: # None. proc tcltest::LeakFiles {old} { if {[catch {testchannel open} new]} { return {} } set leak {} foreach p $new { if {[lsearch $old $p] < 0} { lappend leak $p } } return $leak } # # Internationalization / ISO support procs -- dl # # tcltest::SetIso8859_1_Locale -- # # used in cmdIL.test, uses testlocale # # Arguments: # None. # # Results: # None. # # Side effects: # None. proc tcltest::SetIso8859_1_Locale {} { variable previousLocale variable isoLocale if {[info commands testlocale] != ""} { set previousLocale [testlocale ctype] testlocale ctype $isoLocale } return } # tcltest::RestoreLocale -- # # used in cmdIL.test, uses testlocale # # Arguments: # None. # # Results: # None. # # Side effects: # None. proc tcltest::RestoreLocale {} { variable previousLocale if {[info commands testlocale] != ""} { testlocale ctype $previousLocale } return } # tcltest::threadReap -- # # Kill all threads except for the main thread. # Do nothing if testthread is not defined. # # Arguments: # none. # # Results: # Returns the number of existing threads. # # Side Effects: # none. # proc tcltest::threadReap {} { if {[info commands testthread] != {}} { # testthread built into tcltest testthread errorproc ThreadNullError while {[llength [testthread names]] > 1} { foreach tid [testthread names] { if {$tid != [mainThread]} { catch { testthread send -async $tid {testthread exit} } } } ## Enter a bit a sleep to give the threads enough breathing ## room to kill themselves off, otherwise the end up with a ## massive queue of repeated events after 1 } testthread errorproc ThreadError return [llength [testthread names]] } elseif {[info commands thread::id] != {}} { # Thread extension thread::errorproc ThreadNullError while {[llength [thread::names]] > 1} { foreach tid [thread::names] { if {$tid != [mainThread]} { catch {thread::send -async $tid {thread::exit}} } } ## Enter a bit a sleep to give the threads enough breathing ## room to kill themselves off, otherwise the end up with a ## massive queue of repeated events after 1 } thread::errorproc ThreadError return [llength [thread::names]] } else { return 1 } return 0 } # Initialize the constraints and set up command line arguments namespace eval tcltest { # Define initializers for all the built-in contraint definitions DefineConstraintInitializers # Set up the constraints in the testConstraints array to be lazily # initialized by a registered initializer, or by "false" if no # initializer is registered. trace variable testConstraints r [namespace code SafeFetch] # Only initialize constraints at package load time if an # [initConstraintsHook] has been pre-defined. This is only # for compatibility support. The modern way to add a custom # test constraint is to just call the [testConstraint] command # straight away, without all this "hook" nonsense. if {[string equal [namespace current] \ [namespace qualifiers [namespace which initConstraintsHook]]]} { InitConstraints } else { proc initConstraintsHook {} {} } # Define the standard match commands customMatch exact [list string equal] customMatch glob [list string match] customMatch regexp [list regexp --] # If the TCLTEST_OPTIONS environment variable exists, configure # tcltest according to the option values it specifies. This has # the effect of resetting tcltest's default configuration. proc ConfigureFromEnvironment {} { upvar #0 env(TCLTEST_OPTIONS) options if {[catch {llength $options} msg]} { Warn "invalid TCLTEST_OPTIONS \"$options\":\n invalid\ Tcl list: $msg" return } if {[llength $::env(TCLTEST_OPTIONS)] % 2} { Warn "invalid TCLTEST_OPTIONS: \"$options\":\n should be\ -option value ?-option value ...?" return } if {[catch {eval Configure $::env(TCLTEST_OPTIONS)} msg]} { Warn "invalid TCLTEST_OPTIONS: \"$options\":\n $msg" return } } if {[info exists ::env(TCLTEST_OPTIONS)]} { ConfigureFromEnvironment } proc LoadTimeCmdLineArgParsingRequired {} { set required false if {[info exists ::argv] && [lsearch -exact $::argv -help] != -1} { # The command line asks for -help, so give it (and exit) # right now. ([configure] does not process -help) set required true } foreach hook { PrintUsageInfoHook processCmdLineArgsHook processCmdLineArgsAddFlagsHook } { if {[string equal [namespace current] [namespace qualifiers \ [namespace which $hook]]]} { set required true } else { proc $hook args {} } } return $required } # Only initialize configurable options from the command line arguments # at package load time if necessary for backward compatibility. This # lets the tcltest user call [configure] for themselves if they wish. # Traces are established for auto-configuration from the command line # if any configurable options are accessed before the user calls # [configure]. if {[LoadTimeCmdLineArgParsingRequired]} { ProcessCmdLineArgs } else { EstablishAutoConfigureTraces } package provide [namespace tail [namespace current]] $Version } Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Resources/Scripts/word.tcl0100644000000000001200000001042707560345303027733 0ustar rootadmin# word.tcl -- # # This file defines various procedures for computing word boundaries # in strings. This file is primarily needed so Tk text and entry # widgets behave properly for different platforms. # # Copyright (c) 1996 by Sun Microsystems, Inc. # Copyright (c) 1998 by Scritpics Corporation. # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # # RCS: @(#) $Id: word.tcl,v 1.7 2002/11/01 00:28:51 andreas_kupries Exp $ # The following variables are used to determine which characters are # interpreted as white space. if {[string equal $::tcl_platform(platform) "windows"]} { # Windows style - any but a unicode space char set tcl_wordchars "\\S" set tcl_nonwordchars "\\s" } else { # Motif style - any unicode word char (number, letter, or underscore) set tcl_wordchars "\\w" set tcl_nonwordchars "\\W" } # tcl_wordBreakAfter -- # # This procedure returns the index of the first word boundary # after the starting point in the given string, or -1 if there # are no more boundaries in the given string. The index returned refers # to the first character of the pair that comprises a boundary. # # Arguments: # str - String to search. # start - Index into string specifying starting point. proc tcl_wordBreakAfter {str start} { global tcl_nonwordchars tcl_wordchars set str [string range $str $start end] if {[regexp -indices "$tcl_wordchars$tcl_nonwordchars|$tcl_nonwordchars$tcl_wordchars" $str result]} { return [expr {[lindex $result 1] + $start}] } return -1 } # tcl_wordBreakBefore -- # # This procedure returns the index of the first word boundary # before the starting point in the given string, or -1 if there # are no more boundaries in the given string. The index returned # refers to the second character of the pair that comprises a boundary. # # Arguments: # str - String to search. # start - Index into string specifying starting point. proc tcl_wordBreakBefore {str start} { global tcl_nonwordchars tcl_wordchars if {[string equal $start end]} { set start [string length $str] } if {[regexp -indices "^.*($tcl_wordchars$tcl_nonwordchars|$tcl_nonwordchars$tcl_wordchars)" [string range $str 0 $start] result]} { return [lindex $result 1] } return -1 } # tcl_endOfWord -- # # This procedure returns the index of the first end-of-word location # after a starting index in the given string. An end-of-word location # is defined to be the first whitespace character following the first # non-whitespace character after the starting point. Returns -1 if # there are no more words after the starting point. # # Arguments: # str - String to search. # start - Index into string specifying starting point. proc tcl_endOfWord {str start} { global tcl_nonwordchars tcl_wordchars if {[regexp -indices "$tcl_nonwordchars*$tcl_wordchars+$tcl_nonwordchars" \ [string range $str $start end] result]} { return [expr {[lindex $result 1] + $start}] } return -1 } # tcl_startOfNextWord -- # # This procedure returns the index of the first start-of-word location # after a starting index in the given string. A start-of-word # location is defined to be a non-whitespace character following a # whitespace character. Returns -1 if there are no more start-of-word # locations after the starting point. # # Arguments: # str - String to search. # start - Index into string specifying starting point. proc tcl_startOfNextWord {str start} { global tcl_nonwordchars tcl_wordchars if {[regexp -indices "$tcl_wordchars*$tcl_nonwordchars+$tcl_wordchars" \ [string range $str $start end] result]} { return [expr {[lindex $result 1] + $start}] } return -1 } # tcl_startOfPreviousWord -- # # This procedure returns the index of the first start-of-word location # before a starting index in the given string. # # Arguments: # str - String to search. # start - Index into string specifying starting point. proc tcl_startOfPreviousWord {str start} { global tcl_nonwordchars tcl_wordchars if {[string equal $start end]} { set start [string length $str] } if {[regexp -indices \ "$tcl_nonwordchars*($tcl_wordchars+)$tcl_nonwordchars*\$" \ [string range $str 0 [expr {$start - 1}]] result word]} { return [lindex $word 0] } return -1 } Wishkit.app/Contents/Frameworks/Tcl.framework/Versions/8.4/Tcl0100755000000000001200000261350010153114231023310 0ustar rootadmin X__TEXT __text__TEXT ll__picsymbol_stub__TEXT tt$__picsymbolstub1__TEXT t^t __cstring__TEXT L__literal8__TEXT ``__literal4__TEXT __const__TEXT  __eh_frame__TEXT lh __DATA __data__DATA L__dyld__DATA :L :L__la_symbol_ptr__DATA :T :T__nl_symbol_ptr__DATA F( F(__const__DATA G  G __bss__DATA H$__common__DATA O8__LINKEDIT `@ P@ XA@executable_path/../Frameworks/Tcl.framework/Versions/8.4/Tcl 4@ #G/usr/lib/libSystem.B.dylib hAL&+ /System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation  D P[['  >8V O L#  P  ϸ.|B}|}cx= 2}| x= N }cxK|B}h|=k k2}iN |!B<8c<8@K@/A< c>P}N!h8!`|N |B}=|9}N ||@&p BA|3x!|yx;@;@A<_ B=;BX/A /@ 8`HsAs8`@W8`/AT<8@9>8|^,9`8 ;`>04>^^ ^>0Ub:9kbI.4@A8@=? 8`B9)Y8@8` (Y 8@9^h`dlptxH/||xyAdc;<xxHT dx|8| | $dHà~`/@8`d88 H}/~@x8 HDxH|}y@XxH8xH}~/@d|dxxH|`x|dxxH%a~88H~/@(xH5pA$HR|dx~dHYud~h~`H]]/@^`8ex8pH퀞~p/@~`Hm/@.A8<88Fx8cH ~`DxH|~pDx8H1pxH- ~p8H-U~|~pH-xH-A,<88#Fx8cH~pDx8H1UpxExH./|x@;@H;`DA<Cxx84H!xEx;|;{DH.AĀ/@^ppA^` /A<888cTFxH̀~`DxHl/@4`xH/@~`8Hx=/A xH^,8`ِY pp|8pA<_ |H <_ x s 8 $A< #x=8XH/x8H8!a|}p N ||}x88T0V":x8(Fx~dzx~I.`|tHŀ/@H |wx#H/L@ 8@eC /@ 8~$4@A 8@e^ /@ 8>0Ub:|H./@ 8@e^ /@ 8/@8b8Fx~dzxxH>$8n|wx8Fx~dzx#~`HTMxH( /+A4A/*AH/?A8/{AXH^$:H ^$: |@x; H^$x:;  |@:H(-H0xH( xH |tx/,@LxH'/A< ; /d@xHY|yxA,^$ |@:H ~x: /}A$8@e^ /@X8 HLxH'mH; ::-@t/@l/A~xxHI/(@>0V":"I.~`Dx~ųxHXA~`Fx~dzx8n88!a|}a HR.|t|xA|tx/(Ah/bA`W0V":~`|BH.HVр/@|@~`8n8xHP=WV/}@t~xT dTպT |BJBxHI8px||xCxHI.|vx@~`xHH}~`HD||x/@Ȁ~`8px~xxHFE/@~x8pHIi|}x@l~`xfx 8pHK~`xgx8$8HE~`xgx8$8HEـ x~`8ahxdH@H̀v 8$8HH/@P~`8$8xgxHE~`8$8xgxHEq~`8adxhx H@!] /A@v 8pHHu/@~`8pxgxHE/@Ȁ/@~`xHC/@P79:A~`DxxHJA~`DxHDx8!px~`Ёa|}p HC܀x8!pa|}p N |AB|~x!|#x|+xC 9"+-AP<_U):8BD| .|| N 0p0000000000000000000000000000000000000000$@H /RA8~/A@H\/@@xexFxH!Hpx8@8BHHHm@A 8@e^ /@ 8/@(|exxxH]||x/AHH@A 8@e^ /@ 8/@|exxxH]I/@|dxxT8H_HxH@A 8@e^ /@ 8/@`|exxxT8H`AH$8@e^ /@08HЀ /R@xH /RAA/IA0H/p@$x@Hx8@8BHLxH@A 8@e^ /@ 8/@|exxxH\/A(Ht8@e^ /@`8 HTA^`|exxxT8H\|dx/@xexFxH5x8!pA|N ||~x!H݀ /p@xH /pAxHX8!Px|N ||}x|#x!c`H=͐}}`H=}/@;@;y$[#x;{xHYi/@Px#xHXy}`H=ix||x}dH3ŀ8p|ex}`xH?}`dH7H,dWպW }8p|BB|HB ;}dH3ex|ex}`8pH?=}`dH79A0h8!`|N |a|}x|+x|3x!p@8cd`H2h8!`|exxxx8pa|H>HcMh8!`|dxxxxa|H||#x|+x|3x!|zxHY%/@`z/AZ#@4HxZ8bHVz|yx/AHHV|yxH; w/@xz/AxHWa/@,zdxH18p~x|exz`~dzxH=H$#xxHW%/@x#xHV57{;Aw /@HL@xCx8~x~dzxH2#xxHV/@#xxHU8T>@A8CxxxH/|~x@xxCx~x~dzxH27{;Ah/A/@/A,Z`y/@~x8p:dTպT |BJBxH?|cyA H@z`H9|~x/@z`8px~xxH<%/@zx8pH?I8$8 x~dzxz`H;z`8$8x~dzxH;Հz`xdx8a~ȳxH6/@(7{;A;`@ ;7$;9zdH5-/@$8@eZ /@8Ḥ~x8pd;Wպ|BW BxH>a|cyA H@z`H8|~x/@tz`x8p~xxH:/@Px8pd~dzxz`Wպ|BW B|H:/@;{Ax8!p|N C9 8`/M B/@8| A (A/A H@| x8BB}#KxN ||~x!l/AX8!P|H,c`H7}||x~`H7q|}x/@<xH xH xxxKqxH /@lX8!P|N |A|~x|#x|+x!|3x|;xcx/A xHD8`DHtm|cy@(8@e^ /@ 8 8`HHt@~t89 8@C#cC#  h8!`A|N |#y||}x!AD /AKـ/A xKŀX8!Pxx|HX8!P|N |#y||}x!AP/A 8~HO/8Ax xHX8!Px|HrpX8!P|N ||}x|#x!/A( /A xKр/|x@؀X8!P|N ||~x! 8d/A|dx|xKр/A|dx|xKX8!P|N ||~x!~ /`@AKՀ/|x@؀X8!P|N ||}x!ct/A$@p@@Hq/x@8xtX8!P|N |a|#x|}x|+x! /AKـ/AxxKh8!`xxxa|HA|+y|B|}x!`|#x;@A(8@82xHq<|ex8ͬcxHpdx`H1)8@|~x/@`H;р/@xH=AxdxH=|zx/@8xHIxH2-Bx8!|CxA|N |a|~x|#x|+x!|3x/@8`Hp89 ~H Dc8DHoq>~8 /@(8@e^ /@ 8 8`H$ID}#Kx|@8bh8!`a|N A7||{x;D!@,;`/A xHK7;D;DAh8!`cxA|Hn||cy|!A8@`B@x88~<H!倞/A 8`Kـ~ /A $K1/A 8~HJX8!Px|Hm܀X8!P|N N /|B!|#x@ <88 x8cHn HHX8!Px|Hm(|B|~x!p|#x|+x828@HY<|ex8x|tHm}pA<888cxHmypA<88 8cxHmUpA<88 8cxHm1pA<88 8cxHm pA<88 8cxHlp@@<888cxHlŀ/A<x8Hl<@`BA@<x8Hla /A<x8 HlE8`}xHky/A$^<x>8$Hl~ /A$8@82H<|ex80xHk~/A$8@82H<|ex88xHk/A(x8` Hj8~xHHi8` xHjɀ~ /AxxK~/AxxK8!|N + |B!|#xA<8cȼH4/A<8ȜH<|ex8xHj xX8!P|N ||~x!Hq/@PpA 8HpA 8H8(8nx X8!P|HX8!P|N |B|~x!p@C|P|p/@/@/*@ؠ/*@̠/*@/=A8A/:A`H/?@8@eC /@8HtC`8C#`B|B89)#CHdC`C`8BCH 8@e^ /@$8 HT/@ ^|P|p/@/@/(@/?@ԠbHg/AĀ^`^8B^H,~K9"+AT<_U):8B| .|| N \h4t4444444444T8HTvH|`THl`H``HT`@TnHD`T:H4TH(THT`H ` 8 ^@@bHfm/@^@@/)A$8@e^ /@,8H >8q A U X8!P|N C CN |B}H|<8ld|+x8K|B|~x!^8`/@ ؀ /n@p A^$8AHЁ> /A,^@A^8> ^p A,^(/A /@8+A xHy~X@A|^(9"+Al<_U):8B| .|| N $$$008e H ؀8@e^ /@ 8 H ^(89*+A<_U):8Bp| .|| N $ \@@HT\dX8!Pxx|HP/9A/0@$/,A,H/\A/}A H8а$8dK( H /@8@^(pAH^X@@</?@08^8``8$ H 8$8}K/@0^X@@$"/}@8> 8HȀ8@e^ /@ <8 H 0/[A@A/-AH/\A HD8$8?KTp A xHQ^@@bH]/@4^8``^`8p$H0^8``8{ 8(H>q A ^X@@/?@^`^9">9I^/#A(A/!AH/:A/=AXH~X@@0 /)A$^8X@@/)@^X@@8K^8``8H^8``8$8L H8@e^ /@|8 Hpq"8A8$8(K/(@^`$8)K\^|XP|p/@/[@t/:@h/@T/:@H/]@< /]@08 ^`@ 8KX@8(@$/^@88@^$H 8$8[K8.K8^K|8$Kt^X@A,8@e^ /@(8H$8pK@p @XbHZ/A$^`^`8p^8` 8B^$HxH́~/A8e H /C@^$9"+3A`<_U):8B | .|| N @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@<8kH<8kH <8k|+x8H4<8l|+x8H <8l@@8p8I8` ^T$H^8``8dH^8``8D$8CH^<x8_x8|+x8`8p H E~$H8 K48H8 K8 K^8``8sKx^8``8SK\8 Kx888Htx888H`8 K^8``8wK^8``8WK^x888`H^8``8$8wH^8``8$8WH|8$8ZH̃x8 888H|}x/@|PTA,A(^8``8b$ H^x888`^8B^Hi|}x/A8e H4$8p 8`H$8@e^ /@ 88`X8!P|N 9|B09@|@c8@@K8 9b+6A4<_Ui:8B\| .|| N   }i[xHD9 H<9 H49 H,9 H$9 H9 HC9 8BC AC9 8BC/A$9J|!0}J@c8@Al(@ 8@eC /@ 8U>N T>|9>B+:!|}xA<_U):8B4| .|| N $/nA/(A/^A8*H#C|HP|p/@/[@t/:@h/@T/:@H/]@< /]@08 ]`@ 8H$H@8(@$/^@88@]$H 8$8[H8.H܀/n@ 8^H/(@C8``8^Hdp AH]@A 8$H||P|p/@d/\@X/)@L]8``8$HC@A(8@eC /@ 88`H 8/9A /1@/(AL/)APH/>APA/8``8b=$ HDxHM/A$]`]`$8p 8`X8!P|N ||~x!H^8B^^@@bHL/@؀^~|IxX@@4/#@(8IX@^@ |Ix/ @KA^`X8!P|N 8` N ||~x8|3x!H-u|dxW>/@0x|#x8H.I|bxW>/A BbX8!P|N 8v9D8@8 9$<9`8dDD D J J8I8 9 })8BB5k| xA9`8D9$}i88BB*N |a88|~x!8;H @A@;|| p@c/AHK ;;@@̀~8Ah8!`a|HKh8!`a|N |!TP*|C|+x!||x;"|#x;;AD/@xx8KH ^B|BA xHK)@h8!`!|N |@&|ؐ|zx|#xA|+x!C/@/A;;`;/~0xT9 .A ^. B|BH9 x. A @pA 8`H8`HJ|}y@0Z8e z/@ 8 8@H@Ax8H x8HJM.x7{;A8V |^~.x8!p|Cxa|}p N C|ix8`/L iN |a|}x!C8`/@/A]|bHā=] 8 @@8@ ||H8U;<@(|#xHI|~yA$xHIAHxHI|~x/@0]8e }/@ 8 8`HP] }8B] |~8@8CCCC |P|p|4h8!`a|N |a/d|#x!|}xA$~8 /AHH8] @܁}};Z p A$9) 8B/] A p @]= |@4H@@(|B4B|BZ]|@4H@A]/@|JxB|B"/@d I}@@}"ZJ)|BZ"H|BZ}*Kx"/AH |P|pͰh8!`a|N ||~x!K=^9 /@(>C8|I.|ix|B8 X8!P}#Kx|N |aTպ|BT !||x|#xBxHy\|}x8`/@LxA@<~x]dxx|KH.8B|KI.<|JH.8B|JI.Kxh8!`a|N ||}x!#|^Jb/@D|H.|4/A8K8/|kxA$]#|^b})i}d[xX8!P|#x|N (|!8|#xT.!|+x|{x|3x|;xPAH/@@{dx;;K8p&x|ex{`GxH YA /AAl|P/@(xcx;%xFxH]|P/AA4{dx;K 8p&x|ex{`GxH @Ԁh8!`!|N |Tպ|wx|+x!|3xd;8\x.~[|ZA @dxxK\c|}x|[/@`8`HD}|~y@,\8e |/@ 8 H8x| 8BB\|[.~x~dzx8pxw`H́<}|ZH.8B|ZI.<|KH.8B|KI.H;@; yxdxKE8p~x|}xw`~dzxxHqW@<Kx|@;Z;9/8BAA\;}kP]| .| P| .\| .|Z| .@xx8!p|N ||#x|xx;@! D|]x|B;"@@؀ p@/9 AA|]/@P=|^y|@Z"A(/@cxDxKH@=|^y|@Z"A(xx H /@;8@|4A0h8!`|N C|BN C|B" @H8/A(  A)/A  @ 8N TպT #|BB|DB|H.|BJ/@8`/M 8`N ||#x|vx|+x!|3x|;x}Cx; D|^x|B;b@@xD/@h^ p@@8A,A$p@@~óx~xx&xGxHq;8@|4@\/Ax8!p|N ||#x|vx|+x!|3x|;x}Cx; D|^x|B;b@@tD/@d p@4x8pxH/@~óx~xx&xGxH;8@|4@\/Ax8!p|N |a||x8`4|#x!|+xH?8@|~yA,88@ 8@^(^&^$^*,H8>~ xH~0~xH~xHy~/@x8p 8Kx8^8Hx8^8Hy x 8p8KUx 8$8HEx 8$8H-x/AxH!8@h8!`|Cxa|N ||~x!/A$8xH /@䀞/A  xHA/@8@8x^ ^^X8!P|H=||}x!/A xHL8`HH=i|cy@0],8e },/@ 8 8@HtD(]8C8B]/@}8  ]/Ab |bx$}X8!P|Cx|N ||#x!K|byAX8!P|N ||#x|}x! /AxH /@/AxH/@X8!Pxx|HD 88/$A $HD$ /A  H8$ N ||#x!d(/AH:/x@8x  X8!P|H:|!|3x||x|#x!|+x|;xf/A4 @ @ Ak/@xxH\,|kx/@Cc  } ~^=8B9)^=/pA/aA /r@,0/@ h8!`}d[x| !|K,h8!`!|N ||#x|}x!/@($D/ AI8 D|D8B,H/@8`H9|cy@0],8e },/@ 8 8@HP(9`9# |bx8 ~(| "9)b8BB8c^X8!P|Cx|N ||#x! /pA/aA /r@0/@c xK=@H8/A( A)/A @ < ]8B]@ H8/A( A)/A @ \88B\ X8!P|N C/A, @|Cx(M B/@8`N |+x|3x|xKp|a|#x|}x|+x! /A0xxfxKxxK1 /@؀h8!`a|N |||x|+x! /A$xxxKM/@X8!P|N |a|#x|}x|+x!/A0 xxexKxxKq/@؀h8!`a|N |||x|+x!/A$ xxxK/@X8!P|N |A|zx|+x|3x!|;x/A(CxxfxxK/@h8!`A|N ||+x|#x!|#xH%8X8!P|N |A|+x|{x|#x!/Ax/@l/AT cxDxxKcxxK/@/@xcxK/@8h8!`A|N (|a|+x|#x!||x|3x@ h8!`8n8a|KTH)8xxh8!`a|H||#x|}x!/@|+y@ K|`x/Ad/AX],/@H x8K^ xxK!/A],/AX8!P|N ||}x!/A08/A xKŃ/@X8!P|N ||~x!#0/@8c K땰~$~ K뉰~&~ K}~(~ Kq~*H$ $I($C( &I*&C*X8!P|N |@&|BA0D|!|#x.!|}xA<888cxH2]xH A(xxH<88c$8 xH2-xxHA<888c0xH2xxHUxxHiA<x88c@8H1xH }X8!Pax|}p H |@&|!||x|#xA!<;@/A\,/@i /AX/@P/^A /r@xxH/A;@/xA\,/A/ixA\,/A.AxKxH|zxxH|{xxH|}xADxxKAxdxKAAxxK;@xh8!`|Cxa!|}p N  8`M 8`N ||bx|#x|+x!p AT/x@L888KQ8x|~xKx8yK/A`x8XKx8YHD/A X8!Px|Cx|H8|Cx88KW>|~xKX8!Px|N ||(PB|#x!|p|xx|3x8a@HxDx8@H/;|{xAL/@D<dx88c~H/A <dx88c~4H/@ ?;{}?; ;;9L/A<|HE@|dxExH /AH;/@8a@HM/@08@eX /@ 88`H(xK+ A<_W):8B<| .|| N 4T|\l40x8u88K%|~yA;<_W<x8B(H;|.K+t@;<_W:x8B%;} |.K+@;<_W:x8B)2;} |.Km+@Hx8u88K}|~yA;<_W:x8B%;} |.K+@;<_W<x8B(H;|.K+t@Hx888K|~yAd88Ht88x8K8 |~xKx8 KyH(888xK88|~xKmx88Hx888Ky|~yA;<_W:x8B)2;} |.K+@Hx8?88K)|~yA;<_W:x8B);} |.K+@;<_W<x8B);|.K+>@H,x888K|~yA8089Kmx8a8fK]x8A8FKMHx888Ke|~yA;<_W:x8B*p;} |.K+@;<_W<x8B*x;|.K+@Hhx8d8 8K|~yAL;<_W:x8B*;} |.K+@;<_W<x8B+;|.KI+c@Hx8a88Ku|~yA;<_W:x8B-;} |.K+@;<_W<x8B.J;|.K+`@Hxx8~88K|~yA\;<_W:x8B1 ;} |.K+@;<_W<x8B8P;|.KY+}@/@ 8@eX /@ 8 xH8!@|N |AT>|{xx!H)|zxxH||xxH|~xA(cx888K x|}xKHcx888K|}xxDxKAxxKuh8!`xA|N TTp A;. ATb 8+A8DHTc88cH~8` /AT^B 8B^ H~W<>|^8 A\^b8+(A8E $HTc:H~$$/@,~A8DAHI8` Hē$Ax8<8HAHx8<8H/|}x@DA8/A0cxxH~ @@xTe8cxH~A8DAH~$/A8E AHxE8!Ea|}p N |;(|~x|#x!x|+x;@C"8 THU |}x/|x@x9@9 xA@|+xH|{xxH /|x@܀^pA@@^>/@|P|p ^>|P|p /8`A 8`/At8x~xxx@@Hy ||x/|x@@@A/A(|3xxxxx99!DH Hxxx8DHQ |zx/|x@D/A@/@@/@;@@|xH^|P|p^|P|p^pA@@^>/@|P|p ^>|P|p  8`/A$~H9^xxFxH58!|N |A8(|~x|#x!|+xC8H |}x/@xDxex8"0Hŀ ||x/AxH Hex|fxDxx9@xH|{xxHQxHI /@T^pA@@>^/@|P|p ^>|@P|BpI`x|xx8!pA|N |@&|Ԑ8||xA|3x|;x!}CxCCBB@TWExFxx~x9@9 Hu|zyAd@8@A@@|xA@|x.A(x~ijxx&xgx99!DH%Hx~ijxxfx8DH iD|~x/A@/@@/A| H\xH\xxxH|cy@@ /A,\|P|p\|P|p8`Hd/A /@X| HPA HA0A ;>K;~K;@@Ȁ@A|8`@8!a|}p N 4M T8|88M K||}x|#x!/At^8=$TB:|I.|t/(@,^9`=TB8}bI.^TB8|Bb /A xK/|x@X8!P|N D @L TB8#|(P|p|I.#|0P|BJ|pN |A|}x|#x|+x!|3x|t/=A0A/(At/.AHH/bA|/|AHp8`Hlh8!`xxxfxA|HXh8!`xxxfxA|H8xxxfxK K\8`h8!`A|N |@&|ؐ|#x|}xA|+x|3x! T.A |3xH|+x8x8(8$TB:|BH./@txDx%x~x8H|}yA<[}9P~$})p9)TB:}"Y.H@CxH =xH 5xHCxH %xH 8HTB<|Y; x%xxK||y@@xxx~x8H9@ xx~xK||yAl+AhAx8xDx%x8H|}yAX[}9Px~$})p9)TB:}"Y. KxKKDCxH AxH 98|xx8!p|N ||#x||x|+x!|3x8 C88^~( >,^4>8^0h8!`!|N ||~x!Ub:9k}BI.A](8^B TKTB}+P.|0})x}+Q.~/@ cHK8 ~9`@(9 Ub(49k|B"A8x40X8!P|N |@&|!ĐT:|+xA|3x|#x!|rx|;x}CxEd(|./@`;@$9`<W:;}bI.A; :9;@ԁwWW|X.|L0pA;W:|BH.;/Ax9@@X9|T T|IX.}@0|Bx|IY.^@; ;TB:|BH./@:|4/@;AH.ATH .;@/;A;;@@|WW|X.|L0p AЁ;W:|BH.;/A@>;|U"U)|X.|L0p @p~Cxdx~exH/AX;@|T T|IX.0|Bx|IY.^@; ;TB:|BH./@:|4/@T;A /@@ 8H|/@ cH K|{x/@@@(/A(|T:H /A7; A/@h~Cx~ex~&xxHa|~x@(<W:;~|H.|Y.A/W <~A `/@,7V89~ I.|B}+D}"E x|x8!a!|}p N |a|~x|+x!ݐC|0PD 8<28@8KI|}y@  /@ 8  8`HDxexx8KE|~xxKՀ0^|b/@ |`"x8!"pa|N ||#x!H9@8C |D|EA@/A@8!DjU":U)8|Y.J|I}bD}hEJ| .A@/@89  @8CU:}G./A @, @@ U89* |B|D|EH8J 9a@}"D}+E@/A`@D@AL9AP|D|E!@AD TB8|B|D|E@/A@̨D@@AP!TcU8U)8|BZ})}BD}IECU 8|.C|. 9Ap A(C0A/A @@^0p A(C4A/A @@^4x8!p|N D|hxDP@|HxTK(4D$|8@|jZT:})8}*Y.CCC  D |T:|BC D$|9T8|BC L 9@#U:U 89}BI.C}K. L K= UUUB<|(Pa)UV|p}"H|Bp}"HPH@U <|(PH8 8N $U@(4d8|I@|kx@0/A 0@@p A8c @AX@}#Kx@0/A 0@@pA8c X@A؀ /@ 8 dN |byM B}N /e|Ba!@|+x|3xA/fALH?; 4/A$~xH/A /@<8LH?|+x; 4HU/AA /@/A Hd<8SHH?; 4/AA /@/A H<8 |ex8a@HE;@xHY/;A8@@xxHyH xx8HE|\88!xa|N |B8!< 8cH/AX8!P8c|HԀX8!P|N |Ba||x!< |#x8c8H|{x8`He8|~x ;cHA~xH/@ H [xH̀h8!`xa|N ||~x!c8cH9 ^> /@"~HQX8!P~|8cHT|BA|zx!< |#x8cx8H;|}xxH5x/A/88 @;`/A/@/@/A<8xH쭁ex~ Dx}N!|{xxHK88} Huh8!`cxA|N |Ba|~x!< 88cH;|}xxHA@/@DH<|xAB@@]xH뽀h8!`xa|HD|B8!< 8cHX8!Pc|N |!B8`!;H8`Hy8|~x;C H]~|ixxI8BIH!8~CxH8蓾X\88~`dhlptx|H8~̓Huē쓾 H<8~|ix8F8Cx8BIH/~@<8cQ8Hux?? ?H;@~ /A/@(/@ /@<8cQhH~8@8c`}N!@||x/A8`8H89 ^# C /@<_c BhCH # /@<_cBdCH884$(,0| /@<_ ;`/At;xx89HILCx}N!|cy@<8cQH8`HDC ;$b;{$/@x`HxH<<<8R 8R08R8xH=8`H<<8|fx8R 8R<xH<<8RH8RX8xH<<8R`8Rl8xH}< <煠98Rp88qxH9xH<<<88R 8R8RxHم<<8Rx8RlH<x8Rl8H}xx8!p!|N |}y|B8`!AD?;/A,/@x|#xHՄ/@8`X8!P|N |AB||x!P8`|#x|+x? ;H|~x< 8cH所<8M8a@Hu]< 8c8B]H= /@8`8Hi8| H| 8@80}N!~^ 8!A|N ||#x|+x!c /AP8@H|~yA@~ @ @H1xHiH8a@H=|~y@Ȁh8!`|N |a|~x|#x|+x!|3x /@8`8Hm8~ H!~ x8@0}N!@|~x/@ c H 8`H)c~ x8!pa|N |a||x!c /AX,}N!|}yAD /Ax~}N!xH h8!`xa|H4h8!`a|N ||+x8!c /A4,}N!8|cyA/c A |xX8!P|N cTcN |B}H|p L `<H8|B||x!X/@<8cJHŀp@<8cKH|Hŀ|H띃/ADx8@H%|cyA xHA8a@H|cy@xHxH; 8@xH|cyAc Hq8a@H|cy@xHـ /A 88@ xH|cyAD He/A~x}N!xHx8@HU|cy@xHexH݀ /@|;H%xH\"9)/"A |H鹀|p/A Hp|t/A Hqt|x/A H]xxHQ/AxH7ɀ/@|/AH݀\"9)/"A |H8/A$~HxxH/@x8H]xHߵh8!`|N |AB||x!|#x|+x8`p@H<|+x8HH|zyA xH<<8H8HHLxx88HE|}y8`A\A(xHa<<8H8I8H)Ht/@8`8Hq8|~xH%0xdx8@}N!@|~x/@0xH<<8I4ex8IL8H8`HH}/AH蝀] ]8B] /A\8B\8`x8!pA|N |AB||x!|#x|+x8`p@@<|+x8G HQ|zyA(xH!<<8G8G8HHĀ|/A,x}N!|~y@$xH<<8Hx8H8Hx }A xH<88H$^(^H؃0xcx>0H Ia@8PL8c`}N!P|}x/@ c Hم8`8H<_/} 9 |~xB0@#C8$C(#4# #C~ #,#0A 0\B/@cxxHx8!|N ||+x8|yx!@/|#x|3x;@x@T:8cHA||x;@ W:;|}.HA|}.AW`:8@x|\.exxy }N!|~xA xH98!x|N |/B|+x!@|ux|#x|3x;@x@T:H؁|xx;@W:;`|z.Ha|}xHY<_c/|~xBscc @H(8}Hx~|.Hש^b鮓;^8B^.At~x%xxu}N!|{x~xHy/A~xHeH~xHUHޱ|dx~x8Ha/@8HuxC|}xxx8B]H%A|t/@xx;`H!Hxdx888 9$9!(9A,Hia /A,/@$xHݩ<<8Aex8A0H88c`}N!/A0xHq<<8Aex8AD8;`H1H$a 80,^8c`}N!x ~x HܑxxxH|{yA~Hѓ>^H8a@H]A 8a@8Hۉ\ A<8a@88?He,88a@HU^x8B^H@x|ex8 xH8a@HaCxH9^ /8B^ A\8B\xH]8B/]AT /A/Ax}N!}/A<_Br AHqxHIcxh8!`a!|}p N |8|+x8!HIX8!Px|H|cy|B}H8@|AT  /@ЮW9 6U">+A TB:|BZ4tA })t8I/ @8I/@8Bs@T@>9xAA"8B; A;ZAH;@@<_bЮ9&pU">+A LTB:|BZ4tA 8})t8I/ @8I/@8Bs@T@&69xAA"8B; A;ZAsBA0@|t/H@ W9 6H9&pA"8BAAP@@h9 8"P@|xAHH/;W:@8@|AAH,|.~óx88Hi/@ ;x@AW:~óx@8|.|tH /8`@Ѐ;AH/@ 8a8HA|Hp!@@};W >9)|8cAHL9 @@<_8BPq W9 6@ >;W >9)|8cAW:~óx8|.x8;H/A0A8B|Bp|BZH;H;H;H;@L/@0|PA|w|t8HZ|}xH/@|P|֐A||ZPAlHq;|}xw@<@cx8{|tH]x|ex8`Hq;À|ZW:~óx8|.x8;HU/@ЀaH ]8B/]AxHIH/@ 8A/At|PZH\/@ 8/A @ ;@HD@PH</A/A|x@AHaH H|t/@t~óxH%~óxH8HՀaH 8`H~óxH~óxH<<=8x8x99 HMHaH q?;(H|aH ]?;PHh8xH5a8H 88|)<<8~óx8 8HaH4<~óx8H<~óx8H ~óxx8H-8`8!|N |B|kx!|+x# |t/ @$8 }"Kx | x|t/ AK8`/A|K8bk"} t/*@8 8HDU >+A4<_T :B(}) 4pA}d[x8 H~H 88`X8!P|N |@&.d|BaA|#x!p|+x|3xA$A /WH/fA/wAH8@H/8`@@ =8A@|D|E]8BHɁ@<_(b@0< O@<_H<_H`с``]]8BH8HH/8`@/w@O9%9i9K9 88AHaL8T|>P\|[FpbxxeAHaLTe>PE|Dp|#x|+xiAHaLT|F>P\@.|[pbxxkAHaL|Dp|Ep|#x|+xjAHaL|Ip|JFp}"Kx}CSxhAHaL|Jp|Kp}BSx}c[xgAHaL|Kp|Lp}b[x}cxfHAHaL9%9I9j|[p|\p9 bxx8e8AHaL|[p|\pbxxe8AHaL|[p|\FpbxxiAHaL|[p|\pbxxjAHaLTjF>PJ@.|Ip}"Kx}CSxkAHaLTk>PK|Jp}BSx}c[xhAHaLTl>PL|KFp}b[x}cxgOH8PH/8`@/c@]SHD/s@S]P|FpH /S@(P]|FpS8B]H/i@8]SP|FpP9"9iP|pHTc@.}bxU>U}JxT9`})x}JCxU>dU|x}JcxU`|Kx});x})[x|bx8`}JxU@.})x9U})[x}Jcx9dHc8@8T@@.9 DTkF>Tc@.}bxU>U}JxdT9`})x}JCxU>U|x}JcxU`|Kx});x|bx8`})[x}JxdU@.})x9U})[x}Jcx9Tb});x}JCx8`}+x}Lx}c[x}cxHH #H8AH}#D}"E!HH|`xH8|xx8!pa|N |~y|!AP8@H|cyA8c /AC8B/CAHi8a@Ha|cy@xHh8!`|N |B|}x!H|~y@/A<x8cHHX8!Px|N |aB|#x!|+x|}xH|~y@4/A,<cL8cXH=<x8c xfxH%h8!`xa|N HHHD|B|#x!H|~y@/A<x8cHŀX8!Px|N |aB|+x!|3x|#xH|~y@4/A,<ct8cXHe<x8cxxfxHMh8!`xa|N HPHLH(|!HX8`8!P|N N 8`N N N N |B|+x!p8|#x|#x|3x??;9;`HM/|zxA<xex88H؀<<88x89PH/8`@P/A+A/A/A@Hp/@\{8THT|yx/@$/@8<80H/AD<<Cx8@%x8PH/AX<xex8l8HH8a@HED<b`MӀA@Cx| |pB|6p| P|"HHH;+@<xex8|Kx8XH=/8`@t/; @<<88tx89PHA/8`@8P/A/AH4}8\H|yxH x8`H/8`@;;/A|/@8Xx&x`HH8+@<xex8K/|+x; @<<88tx89PHi/8`@`P/A/AH(H x8`H /8`@$;;/A/@\/A$xx8dH/8`@H Had`?c+A<<_U):B4}) 4pA x88 HcaH\/*@T@W@:x8|.Hj/@/@|:@8-;;Z;A<`A/@ 8/A,xHfy|t/A|t/@|t/.@;;9|+A<<_Ui:B4}) 4pA x88 HbaH8/*@0@W@:x8|.Hiq/@;Z;.A0xHe|t/A|t/@|t/l@܈\8 |Bt9"+ A<_U):8B| .|| N <_8B||;;H/h@;;;`8@|t+xAH<_U):8B| .|| N ((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((D(((8dA W@:/A$|.x8;H^/A$H|.x8HT/@;A8B(HW@:8 ;|u.HT |wxHa|vxA@|x~x~ijxHa|wPa @|P|HlW@:x8|.HS/@PA;8BA H|W@:x8|.HS=/@ A8@; / @H8@ H<<x8H;<|t80xHOxx8H;Z;A @A / A~x~xH @08ApA #xHOa 8cHPy |yx+A<_W:8B| .|| N Tt<#x8@04!0HNH|#x8@HNHd/A  H#x8@H@/;0@; /=x@4A8B/A@ ;A8B/AAaxH]A8B/A@;A8B/AAH/;`0@;` =xPA;/@ /@};;B~x~ijxH^|P/ Ax~xHNq /@};B8H#x8@~xHMu~x$x8HTe@Ax~xHQq8pA #xHM8`Ht<x8LH(/A<x8|H<x88HT8pA #xHMeT8B/TA ~xHVi8`8!a|}p N |B|3x!|#x|+x; ;;@d/@cx8@H]|cy@;;A ~HTy<<|}x8x8HEQ8`X8!P|N /|B!|#x|3xA|#x88HD8`H<<x88\HNE|~y8`AxH>x8HD8`X8!P|N |!B|+x!|#x|#x|3x; HN/@aP!\H/@X}H<88|~x8Pcxx9T9!X9A\H=P/AQ|~yAĀAP/A/;@\/AxH9/Ax xHK/@ xHK/ATHK/AH/A H@x|~xcxxH:Hx8H9M|~xxcxDxH98a@H=Q|~y@DcxDxH68`8!!|N |B8+!|#x|3x@$<|#xx8Ʈ8H@8`H`/@@$/A I8B/IA dH;=>I8BI/A xH68`X8!P|N /|B|#x|3x!A88H@58`HH:i<88`HA8`X8!P|N /|B!|#x|3xA|#x88H?8`H<<x888`HԀP8`/A8HI[d|yx/A/A /Aha\/AHI]/AЀaP\8c}N!|cyAT p/A|}x/A0/A ^8B/^A xH09xHcxxH*8`x8!pa!|}p N /||+x|#x!|3x@H/88H=рX8!P8`|N /|B!|#x|3xA <|#x88ƌH́!HW:Cx8h|H.HM|~y@hɡXh&WHAHW:|i.H$=~xH"|~xHt!HW:Cx~$x889|H.H3)|~y@H]8B/]A xH%E/AY8B/YA#xH%!H/A /A|x+ @D/\A /&@|P}x|px8H 8\;;HA|Pxx|pH U@ADADWi8}i.}) /A(/A T|Px|ZT<|H /\@;;}@A|Pxx|pH/TA|T@0\@T<x8|"HAT8BATAT\@/@X8BXH(T\(@T<|(Px|"H1/@p ~#x8x8H1/@4z 9H<<|ex8~#x8rD8HH,~#xH Q~ijxHH9H~#xxHq/A0Z@ U8B/UA ~xH /A0Z@ T8B/TA ~xH /A X8B/XA xH e}sx|x8!a|}p N /|Ba!|#x|3x@8fH|}x~Hh8!`|exxxa|H<|#xx8~8H ̀h8!`8`a|N |AB|#x!|+x|3xdp/AHa8pzt/AHI8t;{8;/H@,|8@H8D|~x|H<8|}x8~\xH/@D|t/o@(<x88~dH|cy@ aHH/e@$<x88dH}8/A|/r@$<x88eHU8/AT/b@$<x88dtH-8/A,/c@,<x8 8dH/@8HH8`8HHa|~yACxHCxHI|}x|H<<<|ex8~hx8~8~9HxH<x8 8~Hy/@xH)8cH!zpH4<x8 8~HE/@$xH8cHztxH!H0CxH<<8~x8~8HY8`H4;{;/A/@CxHH8`lx8!pA|N /|B|#x|3x!@X8!P|H,<88|LH X8!P8`|N /|Bܐ!0|#x|3x@?8;{H@/@f8H|xxH$<|#xx8{8H 8`H4~8H|~xx^H-|yx/A/@;P8xH@@^T@>+A|@t;`@Hx8@H |{xx8@}N!|}x/AxdxH5} Hc |ex$x8`H@Ax8aPHHD/@\H$|PxH$x|ex8`H;|t/Ax|tH5|}y@x|PH@x~@^T@>+A8|@t;`@H8|PxHa$x|ex8`H1Hhx8@H|{x@x@L]T@>+A|@t8`Hx8He@AA@A@APx|PH$x|ex8`H8`8!к|N |@&/|Ba̐A|+x!|#x|3xA<|#xx8z88HD<<8 @8g|~x89H98/@~xHa|xx+A<_Ui:8B| .|| N hTT , h `4<l\\\\dpxh8:+8@<~xx8zPH4; 8@;~{8H|zx/@0/x@8<8wH /@ :H/@`/x@8<Cx8zxH/@88Y8@T~x8|YxH )8/@XH <<x8xEx8zH;98;{A(W:|^;/Ab~X@xh |!H.@L<_# B@8 H@,8H 8|{x~H <_|zxHԀ~<_B# @H H@<8H8|{x~H|zxA<_H<_Hx8HU8|{x~HE|zx/@@<_H@cxHaCxH/aA<_H <_/@$/@8`A@x@|x/@@ |xH/@ 8cxDxx}N!|cy@@A|`P/|&T/AA@ 8H 48H ,8H $8+A8;`8.a~HE8|zx~ H5||x@h~x88H u8|cy@A@@/@$|@PT<AH|P|pHt@a/@AT<xTB<|\|@P;@@<Z@ CxxT+A|@t8`PHcx8PHa,x)aPN!/AT:{@A/@8/A0~óxH~dx8|fx8~xH8/Atx~xH8+@<~xx8{H h8;`8a~H 8|zx~ H /A||x@x~x88H8/@A/A@TB+A|@t;H>xHtx8H9||x]x@@]T@>+A|@t8}Hx8H|}A|}x@{|P@A`/A@@xdxHEC|~xT@>+A|@t;H~xHl8Hq||x]x@@]T@>+A|@t8}Hx8H5|}A|}x@|P@A\xdxHH,;:K;K/@~8H-|{xH 8|}x~x8H8|cy@؀/@ax@cxH|~x{@@T^T@>+A|@t;Hx8H1axH/A@;A@;xxH$/A<~xx8|@K0~8H)|{xH 8;|}x~xxH8/@H$<~xx8|P8H98HA;/@|cxHi|~x/AT^T@>+A|@tHx8HaH/AxdxH7|~x@A;xxH-8|x(8! aa|}p N ;;%|B|+x!|#x|3x;@;<<8|8Ccx89@;H/8`@@/A(A/AH(/AHWH W|@P;8BxHA;8BAЀ/@$A x|PxHIH cxH}xH$\8B/\A xH8`8!A|N ;|(B!|3x|#x|3x;@tW:|~.H|t/-@X|.<<88GL#x89H 8/@\!8\/A8|\x}8KxA|\P/A <#xx8\Hl|\xK8W:;/}"b.;@#x88HU8/@Ȁ/AP<#xEx8] 8HeH<<<<#x8]@8]X8]8]9HH䃡;Ap@Al#xHݵ<#x8]8H/A;@x~;Hy|t/#Al;AHhTB:|BbHE<88]HU/@H#xH%ATB:|BbH<<|ex8]#x8C8H8H;@tW:|~.H̀A|zx8B@,|t/d@<88JHԹ/A|/Ax#x|dx8H }|~y@H/A <Ex8E$8H8`Hf ;H]88|{x#xdxHԥ/8`A8`8H|zxH|88`8PHрC|~x8BCpA$<88cU0H%x|ex8`HpA$<88cU8Hx|ex8`HɀpA$<8 8cU@Hx|ex8`HѝpA$<8 8cULHѡx|ex8`Hq8`x8PHP/@$^8B/^AxxHyHl88`Hx|dx|}x8`H^8B/^A xH988| H x|ex8`H#xDxxH<x#x|dx8Hu||y@h#xDxH]8`8!|N /|B!|#x|3x|yxAX+A /@/;`A<Ex8PxxDx8HA|~y@H/A <x8;8H8`H`H-;|{x~ H}|zxH8`8H)|~xpA$<88c+$Hɉx|ex8`HYpA$<88c-@H]x|ex8`H-p A$<88cKH1x|ex8`Hp@A$<88c,Hx|ex8`H88`Hix|}x|dx8`Hȵ88|Hx|ex8`HșxdxxHȉ<xxDx8H||y@xdxH8`8!|N |8|3x|;x!8H]|by8`AtHc HDcH`/b4A0/A(@AȀc /@/AAc /@8`X8!P|N |a|+x|3x8!8|;xHɥ|~y8`AL8`Hs`8c^4C ~4pA,`,8`h8!`a|N |!|+x|3x8!8|;x|zx; H |}yA}4s`9 /A@0Cp@`@ @p@A; H|ixc KZ/A$@  B/@/ @ 4H C88B/CAH)/A4}4/Ap@c /@,T,h8!`!|N |!B|}x!|;x|#x|+x|3xC| 898BCAp@;0xHe8 xHƕ$xxH)y@ <8xxHs@ A<8FHs@@A<8Fx8HAcx8@Hٕs@lA`08cx4H cx8@H=lxH1s@@A/A$cxHǑ}8/AHpA 8sAc@s AcHs Ac@<cx$xxxK)]8B]]8B/]@<8cFHՀ/@ xH88!0!|N |#y|B|{x!|3x|;x}Cx}5Kx}VSx;@A4/@ 8`H Cd;/A8A@[8@@D4/ArA48H4 A$H  @H  H/At^b xdxx&xx8B~x~ɳx^H%^|zx8B/^@<8cE@Hy/@ xH/xH@ /@,DCx8!|N |#y||}x|+x!|3x|;x}Cx}7Kx}XSx;AXc/ALp@@]8@|~xA@8@]Xs`A48D A$D  @H  D/@ Ap@xH`pAH/Al|9Ad~xEx&x~dzx~x xc}N!H,s`A(xx~ųx&x~x~x xHU||xxT4HAx/D@ /@@8!x|N ||;x|3x|wx!8g|#x|+x}Cx}8KxH5dxx||xH8|~xGx(x xxXv}N!|}xxHIx8!px|N |B|~x!C8B/C@<8cAHƵ/@X8!Px|HЀX8!P|N |AB||x!|#x|+x|3x}Cx}3Kx:;c8`p@ sb@sb :A `8Ts`AP/AD @8~xHE|~y@$#xH|/AH/A;A0;CxHŀ8 CxHxH/@0~}x~޳x}8;Hm|dxxHa7@CxHM8aHs`A$sb A<8?,H<8?pHsA<8>tx8Hs A<8>xKs@Ap<8>|K/A<8>HDsA<x88>H0s A<8>Hs@A<8>x8Hx8@HQ/A`0x84H/AxHC|{x8BCx8@HxHsA8/A$[8B/[A cxHi;`x8H9xHq88!0cx|N /|B!`|#x|3xA$<|#xx8<|8H8`Hx8Hġ|~y@t/ALx8H|~yA/A/@$<8a@8WȄ>W>9"<_9iI8 BO8L"8/AX@(] @]<@!> |J H cx8xH|zy@|D/AHA@/A/A/=P]LAD8H@@ xH]L8RC8B]L<_BO8"H 8H@@ xHѩ]L8S@@9"9i8K@T> C ]L<_BO8"H/A/=P]LAD8H@@ xH-]L8TC8B]L<_BO8"Hd8H@@ xH]L8U@@9"9i8K@T> C ]L<_BO8"/A@Ԁ] @]<@@! HL]P@ xHQ]L8V8B]L<_BO8"H<L]P@ xH]L8W8B]L<_BO8"0/A8@(] @]<@9  |J @x|xx8!paA|}p N |B|+x!|}x/A(HExH<887H8`H|LEP@ |+xH-^L8A8B^L<_BJā" /A8@(^ @^<@9  |J 8`X8!P|N |@&|ܐB|+xA|zx!$ 8 +@(HYCxH<886H8`H/@ 8`/AD/;` T 6|B;@X\ 8`TB 6|\;/@|}H͵/8`Ad88} Hq|{x^8B^@|@x8`xH!^LP|}x8B@@ xH́^LWF>8EW>W>??"9"B9i 8 YIL"/A8@(^ @^<@!= |J 8/@(^LCx8HxPH1|zxH CxxH̙>LP|zx^HHP@ xH̕^L89I8B^L)/A8@(^ @^<@9  |J ^h/|XA ;@HL.>H^h| P|P|X A/^L>PA@8H@@ xHـ^L8b8B^L<_BI"H\8H@@ xH˝^LWiF>8Wj>Wh>"9"B<_9i 8 kBIL"/A8@(^ @^<@!; |J L^P@ xH^L8?8B^L\I"P/A8@(^ @^<@9  |J <x888Hʱ^L/|}x>PA<8H@@ xHi^L88W>W>"9"9iI9 \IL"8/A8@(^ @^<@!= |J x88@H^hL>H|X | PAĀL^P@ xHm^L8G?8B^L]I"/A8@(^ @^<@9  |J /^L>PA<8H@@ xH^L8=Ib8B^L)HX8H@@ xHȵ^LWiF>8Wj>W`>"9"9iI9 k]IL"/A8@(^ @^<@!; |J L^P@ xH!^L88B^L<_BI"P/A8@(^ @^<@9  |J L^P@ xHǭ^L8H?8B^L\I"/A8@(^ @^<@9  |J Hx8@^L8|@PDPxHI/A<x8c6HL^P@ xH^L8F8B^LT@4"P/A8@(^ @^<@9  |J x88@H… 8^LCxxH; PH ||yA0/@@;P<8<xHCxxH؀L>H^h| P|P|W ^LP@ xH±^L84@48B^L)P/A8@(^ @^<@9  |J 8Cx^LxH `PH ||yA/@T<Cx8XHL>H^h| P|P|X ^LP@ xHـ^L84@48B^L)P/A8@(^ @^<@9  |J Lx8@H8AD |(P|(PHy/A ;9;{ ~ijxCx8xH1||yA$/@T<Cx8.8HH<^LH >P|PP/@`8H@@ xHՀ^L}=8%U+F>U(>U'>b9b9K8 *T@4L"H<8H@@ xHy^L}=8$"4@48B^L)h/A8@(^ @^<@9= |J ^h<x888|W"^h|Wb^h|Xb^h>HL}x|W| P  Hـ^L/|}x>PA@8H@@ xH^L88B^L<_B@4" H\8H@@ xHU^LWF>8W>W>"9"B<_9i 8 B@4L"8/A8@(^ @^<@!= |J ;^x8B^8!кa|N |B|+x!|#x9 E 99a(/E AA $/@ rA(H1a(H<88'H9 H 6d@~[ TB 6|[;bBpx9 /@ 8|p~s/@ V}:xH|nxxH|mx:@ ~i8@V::|N.|M.B^8B^@|@x:;q@p|T<|P/@:/@;V:xH5xHe|a(|H|uxxH/@`.;@@<}9h.WB::H.xH|dxxH/A$;ZA:[ ;TB 6|[;bA,:9@48`888~GxH /@|ox:A888~Gx8`H|}xVc:8cH/|xxc@: :~wxp.;@W:8cH|yx@H;c}5h.WB:;ZH.xH88|dx~GxxHQ{;{A66::@<xx8Ő;T:HQx;||x8`Hq|vx@s@/@| 8xa(H |uy@^L/~PA@8X@@ xH^L88B^L<_B9܁"H\8X@@ xH^LWF>8W>W>"9"B<_9i 8 B9ܐL"/A8@(^ @^<@!= |J L^P@ xH%^L88B^L<_B9܁"P/A8@(^ @^<@9  |J :[ ;TB 6|[;bA`^LP8B@@ xH^L8CWF>W>W>?9"B9i)8 X9ܐL"P/A8@(^ @^<@!< |J ^hvL>H|[| P^LP8B@@ xHՀ^L8DX9ܘ9"B9i)8 L*h/A8@(^ @^<@!< |J x88@H^h8Lx>H|[a(| PA ;BH^ |uyAU(>U'>b9b9K8 *X9ܐL"PH<8 X@@ xH^L}=8""898B^L)8/A8@(^ @^<@9= |J Lx8@^H8D|P|PHQ/Ah^h;;/x||["9)"H}H@,TF>T>T>8#|ᮘJ*jH8"|ᮘ~HV<>h8hxL88|BJ| PA^ H^L/|}x~PA@8X@@ xHa^L88B^L<_B9܁" H\8X@@ xH%^LWF>8W>W>"9"B<_9i 8 B9ܐL"8/A8@(^ @^<@!= |J ^ /@(~wx}kx};/AH6@8A}sxH}kxHy^~x8B^8!}#Kx|N |!|}x!W:8cH/]||xC@d;] ;c x:;ZW:8cH/@$998C 9)8BB7{;{@h8!`x!|N |a||x!/@ |x; };Ha7@h8!`xa|H@|!:B|#x!|+x|xx::~۳x$E @$8`/@;{; A8a@:!:Hi~#x;`H]@$A(/@<x88 Ha/@^ ;{TB 6|^;A(/2x;@82<x8H4/Z xA耞~H8C|}x8`x8B]H݀]|wx8B/]A xH/@:/@:H|xHuxx8FxH|wyA/@<x8HDAHA 8a@HDCx8@V 6|8DHe ;{T 6|^;AD;/2@82<8xHxHxHQxH/@L/@<<x88 |H/@ ^ ;{TB 6|^;@t/A@Z x8Fx H|wyA /@<;8 H|/AAA ~#xHAV 6Cx88B|AH-@CxL8xZH|"|(P|(PH/A4!}=JI8BIH:/@ ::^ ;{TB 6|^;AZ @/@胾/@X<x88 H5/@<^ ;{TB 6|^;A xHxH<8 H /AT x8FxH9|wyA8/@h<;8,xHQxx8H!H<;{@LxHixH<8 H/A(<Cx888HuZL/|~x:PAh8H@@ CxH-ZL88BZL<_B.H" HxHxHu<8L8:HH|8H@@ CxHɀZLWF>8Wʄ>W>"9"B<_9i 8 B.HL"8/A8@(Z @Z<@!> |J A/@܀:CxV 6L8H|"D|(P|(PH-/AA@:H|^B| |/&@| t9kdHd/'@PD$dTTB|xU)@.|Kx| [x9kU`F>Ub>Ui>dD$H<8cHQ/~³xA,88a@ H8aH~xh8!`!|N |B|#x!|{x|+xD8B+@(HcxHu<88H8`HD88@9D9!H T 6|B;xH=-|wy@;; /@̀^ TB 6|^8B/@bxcxH@xxcxHq8LC|~x8`x8B^H^|zx8B/^A xHQ/@$L/A/A|x;H(dxxx8H]L/|~x=PA@8H@@ xH]L88B]L<_B'd" H\8H@@ xHq]LWF>8Wʄ>W>"9"B<_9i 8 B'dL"8/Ad@(] @]<@!> |J H, cx8xH|wyAH;; D/A؀HA@/A//A]L=PAD8H@@ xH}]L8C8B]L<_B'd"H8H@@ xH=]L8C8B]L<_B'd"HH|]L=PA@8H@@ xH]L8"8B]L<_B'd"H0H@ xH]L88B]L<_B'd"`H`//A,]L=PA8H@@ xHi]L8C8B]L<_B'd"/A<@,] @]<@ @!  |J L]P@ xH]L"8B]LH8H@@ xH]L8C8B]L<_B'd"x/A@] @]<@h@! H\]L=PA@8H@@ xHA]L8 "8B]L<_B'd"HH@ xH ]L88B]L<_B'd"H/]L=PAp8H@@ xH]L8!"8B]L<_B'd" /A@] @]<@l!9HdH@ xHY]L88B]L<_B'd"/A8@(] @]<@9  |J ~x8!|N |AB|+x!|{x /8A /@(HcxH<88H-8H/8@D88@9D9!H T 6|B;xH6|zy@^ TB 6|^8B/@x8H5]L/|~x=PA@8H@@ xH]L88B]L<_B!" HX8H@@ xH]LWF>WȄ>W>9"<_9iI8 B!L"8/AX@(] @]<@!> |J H cx8xH|zy@|D/AHA@/A/A/=P]LAD8H@@ xH̀]L8XC8B]L<_B!"HH 8H@@ xH]L8Y@@9"9i8K@T> C ]L<_B!"`H/A/=P]LAD8H@@ xH]L8ZC8B]L<_B!"xHd8H@@ xHр]L8[@@9"9i8K@T> C ]L<_B!"/A@Ԁ] @]<@@! HL]P@ xH5]L8\8B]L<_B!"H<L]P@ xH]L8]8B]L<_B!"/A8@(] @]<@9  |J @x|xx8!pA|N |B|xx!|+x8`D/@pD;  T 6|B;@@|/@x8H1^L/|}x>PA@8H@@ xH^L88B^L<_B" HX8H@@ xH^LWF>W>W>b9"<_9iI8 BL"8/AX@(^ @^<@!= |J H x8xH|cy@0\ ;9TB 6|\;A/^L>P@hH@ xHՀ^L8P8B^L<_B"/A@^ @^<@9 H8H@@ xHm^L9:8^U+F>U(>U'>b9b<_9K8 *BL"/A8@(^ @^<@!: |J 8`h8!`|N |B|xx!|+x8` /AD/@<|+x88ڌ8H^L/|}x>PA<8H@@ xHU^LB8B^L<_B" H\8H@@ xH^LWF>8W>W>"9"B<_9i 8 BL"8/A,@^ @^<@!=HD;  T 6|B;@@|/@x8H^L/|}x>PA@8H@@ xH=^L88B^L<_B" HX8H@@ xH^LWF>W>W>b9"<_9iI8 BL"8/AX@(^ @^<@!= |J H x8xHM|cy@Ā\ ;9TB 6|\;AȀ^LP8B@@ xH-^L9:8OU+F>U(>U'>b9b<_9K8 *BL"p/A8@(^ @^<@!: |J 8`h8!`|N |B|+x!/A<88H8`HD T 6|B8B/@x8H=^L/|}x>PA@8H@@ xH^L88B^L<_B" HX8H@@ xH^LWF>W>W>9"<_9iI8 BL"8/AT@(^ @^<@!= |J H 8xH |cy@|L^P@ xH ^L8Q8B^L<_B"/A8@(^ @^<@9  |J 8`X8!P|N |B|#x!|xx|+x/8@ D88@9D9!H T 6|B;xH*|cy@ ;@@D\ TB 6|\b;/@x8H ~L/|}xPA@8 8@@ xHŀ^L88B^L<_Bā" HX8 8@@ xH^LWF>W>W>b9"<_9iI8 BĐL"8/AX@(^ @^<@!= |J H x8xH|cy@Ѐ;ZAĀD/A@/@H/AY;H Y;^LP8B@@ xH^LWF>8_W>W>"9"B<_9i 8 BĐL"/A8@(^ @^<@!= |J D/AȀH/@@Y~L/P@ ;H;8 8@@ xH^LWF>8_W>W>"9"B<_9i 8 BĐL"/A8@(^ @^<@!= |J D/@@L^P@ xH^L88B^L<_Bā"HLHA@/A/@@L^P@ xH^L8 8B^L<_Bā"(H/~LPAD8 8@@ xHy^L8 C8B^L<_Bā"H8 8@@ xH9^L8 @@9"9i8K@T> C ^L<_Bā"H(/@pL^P@ xHɀ^L88B^L<_Bā"p/A @^ @^<@9 H/~LPAD8 8@@ xHQ^L8 C8B^L<_Bā"@Hd8 8@@ xH^L8@@9"9i8K@T> C ^L<_Bā"X/A<@,^ @^<@ @!  |J ~LP/@p8@ xHa^L8`8B^L<_Bā" /A@(^ @^<@9  |JH8 8@@ xH>L8a 9)>L9i9K9 Y88BTBF>I~LY8BTB>I^LY8BTB>KLY8BJ<_LBĀ /A<@,^ @^<@   |" D/@@L^P@ xH^L88B^L<_Bā"0HLHA@/A/@@L^P@ xH^L88B^L<_Bā"H/~LPAD8 8@@ xHu^L8C8B^L<_Bā"H8 8@@ xH5^L8@@9"9i8K@T> C ^L<_Bā"H0/@pL^P@ xHŀ^L88B^L<_Bā"/A(@^ @^<@9 H/~LPAL8 8@@ xHM^L8C8B^L<_Bā"Hl|`xH8 8@@ xH^L8@@9"9i8K@T> C ^L<_Bā"/A<@,^ @^<@ @!  |J 8|xx8!p|N |@&|АB|txA|#x!|+x8`$/@H ;H;8:D@Z 8`TB 6|Z;B/@z/@$|t/-@|t/-A/@/x@8<cx8THk/@;8:Ap8`|P/@Z TB 6|Z;Bz/@L|t/-AWȄ>W>9"<_9iI8 B L"8/A@] @]<@!>H8~; :Hlـx|{xHl8||t/^@ ; :|[|t/$@0/A|t/\A;8:|H:8@0|Ȯ|t/.@ |[|t/*@ ;9:8@H|[|t/\A4|t/.@$|t/*@;8:|<8xHi/@dxH9/@cxHk 8`H.A/A|Pxx8H݀]L/|~x=PA@8H@@ xH]L88B]L<_B " H\8H@@ xHY]LWF>8Wʄ>W>"9"B<_9i 8 B L"8/A@(] @]<@!> |J H\8~HjP|xxAxxH8*xx;8cHjy/@8*|;8xx|x8H]L/|~x=PA@8H@@ xHA]L88B]L<_B " H\8H@@ xH]LWF>8Wʄ>W>"9"B<_9i 8 B L"8/A8@(] @]<@!> |J xHhcxHhZ TB 6|Z;B/@x8He]L/|~x=PA@8H@@ xH]L88B]L<_B " HX8H@@ xH]LWF>WȄ>W>9"<_9iI8 B L"8/AX@(] @]<@!> |J H ~x8xH-|cy@/A/Ax/@pL]P@ xH]L8I8B]L<_B "/A@] @]<@|9 Ht]LP8B@@ xH]L8N8B]L<_B "X/A8@(] @]<@!5 |J 8`x8!pa|}p N |AB|#x!|+x|zx El/88@A/ADd;@^h|C||媀@/@X8@/At48c@̃/A/AH<x888H^L/|}x>PA$8H@@ xHI^LH8H@@ xH)^LWF>8W>W>"9"B9i HĀ[ T 6|B8B/@x8H^L/|}x>PA@8H@@ xH^L88B^L<_BT" HX8H@@ xHa^LWF>W>W>9"I9i8 <_LBT"8/Ah@(^ @^<@!= |J H0 Cx8xH|cyA|bxH8@H|L^P@ xH^L88B^L<_BT"/A8@(^ @^<@9  |J 8@8!|CxA|N |@&|AB|{xA|+x!d8 +@(HhcxHka<88XHiq8`HD88@9D9!H T 6|Bi| ;xH |zy@.A4^ TB 6|^8B/@x8Hq]L/|~x=PA@8H@@ xH)]L88B]L<_BL" HX8H@@ xH]LWF>WȄ>W>9"<_9iI8 BLL"8/AX@(] @]<@!> |J H cx8xH9|zy@pD/AЀHA@/A@/A/=P]LA`8H@@ xH ]L8LA 8H8 ]LC8B]LA 8H8H8H@@ xH]L8LA 8H8 ]L@@@9"9iT>C }LA 8HD8H<L]P@ xH-]L8LA 8H8 A 8H8 H/A0/=P]LA`8H@@ xH̀]L8LA 8H8 ]LC8B]LA 8H88H|8H@@ xHq]L8LA 8H8]L@@@9"9iT>C }LA 8H8P<_BL|B"/A@] @]<@@! H؀L]P@ xH]L8LA 8H8A 8HT8hHLL]P@ xHa]L8LA 8H8A 8(H8<_BL|B"/A8@(] @]<@9  |J Cxx8!paA|}p N |B|wx!`|#x|+x8`/@ D T 6|B;|Hc<<|~x8~xx8˼89`Hki^/A(8/A xHfe~xHbH8/A xHfA!`8`\ +TB 6|\;AP<_U):8B| .|| N |TT|||||||||||||||8`/@;@|/@x8H}]]L/|~x=PA@8H@@ xH}]L88B]L<_B" HX8H@@ xH|ـ]LWF>WȄ>W>b9"<_9iI8 BL"8/AX@(] @]<@!> |J H ~x8xH|%|cy@\ ;Z/TB 6|\;@ȀL]P@ xH| `9 K]L/8LA9 I"9 `/A9 <_B|BJ"H8`/@;@|/@x8H{]L/|~x=PA@8H@@ xH{a]L88B]L<_B" HX8H@@ xH{%]LWF>WȄ>W>b9"<_9iI8 BL"8/AX@(] @]<@!> |J H ~x8xHzq|cy@\ ;Z/TB 6|\;@ȀL]P@ xHzU]L8M8B]L<_B"@H8`/@|/@|Hi<|ex88a@HX8@8|exxHz]L/|~x=PA@8H@@ xHy]L88B]L<_B" HX8H@@ xHy}]LWF>WȄ>W>b9"<_9iI8 BL"8/A@] @]<@p!>Hh ~x8xHx|cy@\L]P@ xHxՀ]L8L8B]L<_B"(Ht:;8`8+A/@d/@|\/@,/ex@8<Cx8HUQ/A 8`H\ ;TB 6|\;; /@h/\|@\/@TdxCxH]C|~x8BCH^<84Hu9^ ~8B/^A xH_Dxexx8Hw]L/|~x=PA@8H@@ xHwy]L88B]L<_B" H\8H@@ xHw=]LWF>8Wʄ>W>"9"B<_9i 8 BL"8/AX@(] @]<@!> |J H ~x8xHv|cy@ \ ;9/TB 6|\;@\/]L=PAhH@ xHva]L8I8B]L<_B"/A@] @]<@t9 Hl8H@@ xHu]L8N8B]L<_B"X/A8@(] @]<@!8 |J 8`8!|N |a|+x! /AD; T 6|B;@Ѐ/@>^|I8b|t/)AH@A@H/:@|t/:A08cH@@$|t/:@|t/:@؈|t/:@H@@8c |P888Ht-^ TB 6|^;;A8h8!`8`a|N |@&|АB|+xA|vx!0;  /A(HX~óxH[<88HY8`HXD T 6|B";b /T 6|[;B@/A 8`H{HX8C|}x8`x8B]HU]||x8B/]A xH[/@/A; ^8B^@|@x.8`xHr|}xAx88@HrI:H^LH~P 8~óx^Lx;H@PHr1 ||yA0/@ ;P<8xHQE~óxxHL>H^h| P|P|W ^LP@ xHra^L8??8B^LY"P/A8@(^ @^<@9  |J ^LHA(D~Px8@8|PHp/A ;Z: dx~óx8xHp||yA$/@<~óx88HUH܀^LH ~P|PP/@`8X@@ xHqY^L}=8%U+F>U(>U'>b9b9K8 *YL"H8X@@ xHp^L}=8$"98B^L)hH|P~PP/@`8X@@ xHp^L}=8#U+F>U(>U'>b9b9K8 *YL"PH<8X@@ xHpQ^L}=8""98B^L)8/A8@(^ @^<@9= |J ^h|W^h|WB^hL>H|W| P <x8 88Hoŀ^L/|}x~PA@8X@@ xHo}^L88B^L<_B" H\8X@@ xHoA^LWF>8W>W>"9"B<_9i 8 BL"8/A8@(^ @^<@!= |J ^8`H ^x8B^8!Ёa|}p N |B|#x!p|mx|+x|3x: :;:9::::`; :@/!@ĀD|t/{A:$|W|t/)@9 ~x@Ȉ 9k|t/(AP9)A/A/A8`:;HMY88|vx cHh|IP}u[x}9Kx:bK:H /@/@W 6| .|J/@܀B|B|t/)@X:9 x}h[x@ |t/(A9)9kA/A}*I/@ ;H8x W 6}Cx(XP}=:;X I 8$|KP|B}+HP:b7ADx:HL%888|vxDxx 8cHKH Vx;/AH 8@HT8@9 ~x@@ |t/:@ 8 @ |t/:A9)9kAȀ /AH/@@0|U~x8$xHk5q|rxA/@:@/@~x%xcx8Hk[L/|~x;PA@8H@@ cxHk9[L88B[L<_B鸁" H\8H@@ cxHj[LWF>8Wʄ>W>"9"B<_9i 8 B鸐L"8/A8@([ @[<@!> |J /A8/A}kxxfx~ijxH<cx88D8Hja[L/|~x;PA@8H@@ cxHj[L88B[L<_B鸁" H\8H@@ cxHi݀[LWF>8Wʄ>W>"9"B<_9i 8 B鸐L"8/AT@([ @[<@!> |J H }kxfx8Hi%|qx/AU 6})I8BI/A ~óxHH5 U|A~#xBAA8!|N |+y|B|ux!|#x|3x@/;A|#xHF]|}x>;刀/@<8cHI/@<8>8c;@HSՀp /AX;`;<_;7p 88B|.0|Cx}N!/AC ;{ ;Z; |./@8<8cHHa;`|xL~x8xxP@DHHh-|}y@at8@xH|}y@P/@xL\P@ xHgi\L8@8B\L<_B"/A8@(\ @\<@9  |J xHI(8! x|N |B!<?;8cHGa/A<8cHOI8X<8!P8c㤻|HG|B|xx!|#x|+x/@A<|x8cҜHR!;@;/AA(/AXA/A8H`/ATHT/@AA/ AH8W>W>"9"B<_9i 8 BᴐL"8/A @(] @]<@!< |J H耞xx888Hd|zy@;Hxxx8Hd%Hxx$xK|zy@^ TB 6|^;Ht8a@HB 8a@HJ=<_8B<|{x,|Cxdx}N!||y@8dxx%x80xH 1|zx8a@HA1/@,0H8a@HA <_8Bm `/@;$xxxK|zy@^ /TB 6|^;@,x$xxK|zy@^ TB 6|^;L]P@ xHc]L 8B]L<_Bᴁ;)}))H9<+A<_U):8B| .|| N @@;$xxxK|zy@Ѐ^ 8 TB 6U) 6|^}8J;9)H@TL]P@ xHb =L/k1`|K8B:8 LI@ 8pH8Hxx$xxKE|zy@@=LP^ TB 6|^;@ xHa=L/k1`|K8B58 LI@ 8H8<_B|B"/A@(] @]<@9  |J HTxxx%x80HHxx$x80H |zy@\0H<x8cHL8H<8cHLX TB 6|X8BA#x;@H h8!`Cx|N |@&|ؐB; A|3x!`|+x|#xx|+x|3x|;xF K|}y@\ ;aPx8ex;!`TB 6|\;H_1<x888H_^L/|}x>PA@8H@@ xH_^L88B^L<_Bې" H\8H@@ xH_u^LWF>8W>W>"9"B<_9i 8 BېL"8/A8@(^ @^<@!= |J x8%xH^%Hdx^Lx8|@PTPxH]/A<x8c HJ^ <x888H^^L/|}x>PA@8H@@ xH^a^L88B^L<_Bې" H\8H@@ xH^%^LWF>8W>W>"9"B<_9i 8 BېL"8/A8@(^ @^<@!= |J Hx$x^L8|@PdPxH\/@ĀL^P@ xH]]^L8?8B^L[ې"h/A8@(^ @^<@9  |J jx8@0@|. H\!xxxKQ|}y@́>LP\ TB 6|\;@ xH\^L8L@ 8)H8(ې@ 8@H8@|@B/A8@(> H@><@8@ | Hx8@L8|(PD|(PH[%8x 8!a|}p N |B; !p|+xx|3x|#x K%||y@] x88@TB 6|];HZxDxxK||y@] /TB 6|];@xL^P@ xH[-^L8@8B^L<_B"/A8@(^ @^<@9  |J ;!Px8%xHY8>L^HxDx xbHPK||y@] /TB 6|];@xL^P@ xHZY^L8@8B^L<_B"/A8@(^ @^<@9  |J L$xx^H8T|P|PHX/A;{Dx8@8|PHXՓ8x 8!|N |B||x!|#x|+x|3x|;x;eL8{ }N!|cy@,cxH@<<8|x8Ƣ8H@HxC /@xx88HY]L/|~x=PA@8H@@ xHXр]L88B]L<_B" H\8H@@ xHX]LWF>8Wʄ>W>"9"B<_9i 8 BL"8/A8@(] @]<@!> |J ; \ /TB 6|\;"@P;@DAx~xxKQ|xy@;^ TB 6|^;AA cxH8B]L9"<_=LB"/A<@,] @]<@ !  |J Z |PHcxH;cxH>9<8Ƽ8HHA~x| PUB 6|P|BZL!Hp|I8B@;/8@Hx~x^L:~ P|HP~&xHePT@D/@/@^ ;/A B}kx8H=U}kxH4倁~óxx8H5.|{xA/At,p@hp @\~óx8@x}^LH^ PN!|}yA/@H^|LH^8B^H@x8HN|}xA<XC ex~óx|BHOHx8HM|}x/^L>PA@8H@@ xHq^L8=?9)Y(8B^L) H\8H@@ xH5^LWF>8W>W>"9"B<_9i 8BY(8 L"8/AX@(^ @^<@!= |J H ~óx8xHI|}y@P:\ TB 6|\;A/@/^L>PA@8H@@ xHI^L8=?9)Y(8B^L)H\8H@@ xH ^LVF>8V>V>"9"B<_9i 8BY(8 L"/A8@(^ @^<@!7 |J L~xxHx;|0P|0PHH.8a@AL9|Px~PH-AAp|t/]A /ALA@<x88|8HK9^L/|}x>PA@8H@@ xHр^L8=?9)Y(8B^L) H\8H@@ xH^LWF>8W>W>"9"B<_9i 8BY(8 L"8/A8@(^ @^<@!= |J |pPA8Hv8aH'8`H|<88cH/|dx~óxH,L;AHp|B8B@;Hx~óx~xH/A 8a@H,)|P8aH'x8!a|}p N |@&|ԐB|+xA|3x!|vx|#x;8a@LH'9/@H/A4A/AH/AD/ A|HH z; 8xH,Ax|ex8a@H/H؀D/@@x8;HH̀^L/|}x>PA@8H@@ xHe^L8=?9)Qؘ8B^L) H\8H@@ xH)^LWF>8W>W>"9"B<_9i 8BQ8 L"8/A8@(^ @^<@!= |J 8a@xH%=~óx8x;88K|}yAH܀D/@@x8;HG^L/|}x>PAP8H@@ xH%^L8=?9)Qؘ8B^L) Hl8H88H08H@@ xHـ^LWF>8W>W>"9"B<_9i 8BQ8 L"8/A8@(^ @^<@!= |J 8a@xH# 8:/Ax9`8@h9}Y"x"/:@@@|t/:A/(@  /@ |t/)A9k8BA/;`A$#xx8H.|{x@H.x$xx8HE^L/|}x>PA@8H@@ xHU^L8=?9)Qؘ8B^L) H\8H@@ xH^LWF>8W>W>"9"B<_9i 8BQ8 L"8/A8@(^ @^<@!= |J /@@@L^P@ xHq^L8 =?9)Qؘ8B^L)(H@/^L>PA@8H@@ xH)^L8 =?9)Qؘb8B^L)H8H@@ xH^LWiF>8 Wj>Wh>"9"B<_9i 8BQ8 kL"Hp8~óx8 xK=|}yA@/dx;0@8d<&xx8H"!~óxx8H&H@pL^P@ xH1^L8=?9)Qؘ8B^L)p/A@^ @^<@9 H/^L>PA@8H@@ xH^L8 =?9)Qؘb8B^L)@H\8H@@ xH}^LWiF>8Wj>Wh>"9"B<_9i 8BQ8 kL"X/A8@(^ @^<@!; |J Z ;T@ 6~PZH<8c$H-6;ZAD/@@x8;HA^L/|}x>PA@8H@@ xH ^L8=?9)Qؘ8B^L) H\8H@@ xH I^LWF>8W>W>"9"B<_9i 8BQ8 L"8/A8@(^ @^<@!= |J x/@^LP8B@@ xH ^L8=?9)Qؘ88B^L)/A8@(^ @^<@9  |J ;/Ax/@^LP8B@@ xH ^L8=?9)Qؘ8B^L)/A8@(^ @^<@!8 |J L@<x88,8H?ɀ^L/|}x>PA@8H@@ xH a^L8=?9)Qؘ8B^L) H\8H@@ xH %^LWF>8W>W>"9"B<_9i 8BQ8 L"8/A8@(^ @^<@!= |J 8a@H=8`H8a@H-x8!a|}p N /|B!|3x|bx@4/@(X8!P|3x8|Kp|CxxK|cy@|L^P@ xH ^L8=?9)F8B^L)/A8@(^ @^<@9  |J 8`X8!P|N /|B!|+x|xx|3x; @,/@ h8!`|H>\;@|#x@L x8xK|yy@(8@<x888H= ^L/|}x>PA@8H@@ xH^L8=?9)E8B^L) H\8H@@ xHi^LWF>8W>W>"9"B<_9i 8BE8 L"8/A8@(^ @^<@!= |J \ ;ZTB 6|\;A/@Wb<;/@^LP8B@@ xH^L8=?9)E88B^L)/A8@(^ @^<@9  |J ;/Ax/@^LP8B@@ xH^L8=?9)E8B^L)/A8@(^ @^<@!= |J L^P@ xH^L8 =?9)E8B^L)/A8@(^ @^<@9  |J h8!`#x|N |!B|#x!|rx|#xdLHDl$@XP$\:U88H[W):V8|ux:i8bh:7jdV`8|cV 8|c/|c|cA HHY|~xv;hH:Ex~x8\8^  $^,>0(l4<8@HDHHa9V8L@0)9@[XU :9~L|J9J | Y.B/V`8AP~xxhHHP/V 8ATxxHHT|cxxH9 /A/A~Cx}N!<_8BKR 8!!|N |B||x!?|+x;sȀ|3xp@(8A0|(P| |t/ @\8B\8B/@ xHI/@?8`;ނ|T2/@ ?;ނ8c|T2/A<|exx8x8a@Hx8@8H(8! |N |@&.|ؐ|{xA|#x|+x!|3x|;x;A\G;@H p@,8@cx%xH5/xA;A/@@8yH!|~x/@||H\b|/;b >@ b Adx8~%xHU|Y\8B\xx8!pa|}p N |A|zx|+x!D(/A` p@/ @/AA${P8fx8@}N!H8`/@H/A@ /A {P8fx8@}N!/@ /@/@ A@`] 8`/A/ACx}N!/89~ A<9 8>>C~>8B> C>H(~~~~ ~~ }~[x/@x8!pA|N |a|~x!CHP#L|PT<HPcxHHx|}xHAT/A ~HH}=|]8T^L>PHh8!`a|N |@&.|BA|#x!|~x|+x|3xAA<8cH-|AHT(4T 6Tl|8^hx9)>l"Y.|BZ>" h8!`!|N |!|+x|yx|#x!ADT 6TWɄ>W>8#H0WF>WɄ>W>8%HWF>WɄ>W>8' J*j\=8@,|IP}>Kx|I|xW 6;|IX.8B|IY.B\l ;bA\h|.|D/8BDA/A,H8$D/8BDA08 H$D8BDH<8c\He;;@8`h8!`a|N |B}H|Ui>U`F>; J*j;}<.A/\@t;}x|;/@<8cH%HD/9^A~}^SxH,8Ub>Ui>U`F>; J*j7@;`9 @p8W 689^|H}iP8 +A~}^SxH(U`F>Ub>Ui>; J*j|H|;x"A/d@t; }x|;/@<8cH)HD/9^A~}^SxH,8Ub>Ui>U`F>; J*j7@h8!`x!|N |B|ux!<_|#x8B/L;@dH<c;~ P<8cX8~x|.)H @WB:|B"+Ax<_U):8B| .|| N X@|V/|t@/"A`/$AX/&HL|V/"bTBU)|KxUk@.|[x|x@8/#A/%A /'@ <<xc8|H`<8cH/|V@|/A/ A/ A/A /@T(@/@BH|V/"bTBU)|KxUk@.|[x|x@p| P@ 8H88c + A0/m@(/A /@8B8T`:|.@ 9 H/8@@$<_|i8B88B|B@/@x9 (@8NA@?Q|cޅq 9@8}i}*p}`.p| Pd@}`>p| P@9|Bb9)8BmBHl A@?Q| |+xcޅq 9@8}i}*p}`.p| Pd@}`>p| P@9|LP9)8BBA@!@<_<B,`Q|3x|;x}Cxx})B<@K9 |cyAP/|@A$/@(8a@8H u /AA@8BA@@9 Ah8!`}#Kx|N |?*c!ah8ahl8H 8C8al8B||Ip|pPPH ݀hC!l8B|Kp} HPp| P|P|`PX8!Pc||iN ||#x|~x8!|+x8a@@H e<@I= `B$a)Q/P;|]p|B|Bp|@PT@8|P<@ P`B:@I|\|@|@@ +@$H iT`H4<_<~H<_Ti:B}) 4T/A8?;1/A$xH)/A /@8`x|t/A4x/.A 9)H8c|t/@/8 A4;./A$xH/A /@8`h8!`a|N |B!H9>hI8BI?\hxb+@H T`bH <_Ti:B}) 4Tb/@9\hJ+|tA<_bT:|BZ4pA<_9 }h[x8B̑"|KxHK9)B |B8BАKJ8BJ+|tAT:|BB4p@8\h/8`"9)"Ad8` H\/AW>+@H T`H <_Ti:B}) 4T/;@@H8S@@ ;9>>?>8aP>PH)<C`<=?<9)=|~x>8Bl>_=V==C8BP<_ X<a\`@88 H 8ЀX<_9 :<_9s ;<_9O ;\;B98T88:;f`"<_+*;&('="$5;97<H/@@\/A4/A(=/A{/A/@ 8`H/@/@ /A|96 /@ |А I/cA/D8lA8А =_p8PJЀՒ 28K/8`A(H8P/@(^>B<||J|PPAP8T |B|CxAPK/8`AĀP8TAT||xPK/8`AA\AP/T|baPA4X/@$<<ԀKـP|PA`/A(<<aP܀KaP|PP8`A8!|N |B8!p=?=<_=<==_9x)"8|9Jk"8ϙ89)9k"p<_bt<_>>?>_Ppqtx>>;{:";"7xU :|@A>/|CP;5"|VpU>8U;<|P|p@hxHi|}xxH]/|~xAx/ApxT:HUxxT:H=yH@|\xKHxHxxyHՀy/A /@;`9T" A<8cKHd3"V:WB:u"jiK?xx<_W:<g8B`i.@??;/@K/}@ 89Y*JAl/Ad<_W:8B.<_8BW:|.H@<=?<_89)Bxi V/@8 K<_8B`./@?;ݔ/@K%/~@ 8<_8B褀/@A/@@"/A@8`/A /@?/A/@8/AH/AH<8cK9/I8BI<_8B"@A`=_==?9J9k9)|HxT:|J.;+AW:|I.T@:| ./AX;{;Z@@@8`H L<_8`8B/A 48K<_W:=8B8ș|Ex| .=_p|p<_@T :8BXIP.iP8JW:}".[|I;/A0<_W:8B.<_8BW:|B.|A<_U :8B.KT :8BXIP.iP8JW:}".[|I;/A0<_W:8B.<_8BW:|B.|A<_U :8B.H|xqt9"Pp+4A<_U):8B| .|| N (TT| (0DLd,L`h`Hhh =?9)tH<=?9)xH0=?9)dH$=?9)lH=?9)hH =?9)pI8BIK==_9kt9JdK*8B9)K*K=_=<9Jt9d8pJ(g8B9)J9k(gK`e<_=?89) b<_H(<_<_8%<_"<_HĀ<_<_8<_8<_T<Q`%| }"p|.p|P@d<}"HP<_})"|K<_<_<_Kh<_= Qa)<_8<_e8<_T<_b} H|p}).p}"HPId)<|P<_|J|KH<_|8H<_|8<_TK8H<8<_XH4H %<_})֑"XH8<_X<_\KtH̀H E= h=`Qa)ak|H|Bp|fp|P<_E}"H|@p})fp} HP)'|IP|X|Bp|.p|P<_}`X|p}k.p}bXPkd| PHl<_<_H<_<_HԀ<_HHH<_<_Kp9 <_8"<_<_"KL<_<_HX8H<_`<_K 8`/\@ԀE=`h=@QakaJ|X|Bp|fp|P<_E|X|Ip|fp| P'|@P|P|Bp|.p|P<_%H8`/\@\E= h=`Qa)ak|H|Bp|fp|P<_E}"H|@p})fp} HP)'|IP|X|Bp|.p|P<_}`X|p}k.p}bXP<_kd| P<_<_HE=`h=@QakaJ|X|Bp|fp|P<_E|X|Ip|fp| P'|@P|P|Bp|.p|P<_%| P}"p|.p|P<_d} HP"<_} X|p})fp} HP"}`X|p}kfp}bXP<_k'| P} P|p}).p} HP"}@P|p}J.p}BPPJd| P<_K= b9`a)M=89|@H|p}Cx|B6p|@P9B<_b<_q@B<_bE}"H|@p})6p} HP)}iP@@<Q}Ip`|J|@.p| Pd@|@>p| P@88Gm<b&|K`M=9k||Bp|6p|PK})(!|BKK==_=9k9J9 J(||BА })АJ(K%<_eB})})YH(<_%B})H<_%B|JKX8H 8H=?9)H =?9)H=?9)<_"K =? t/A4<_Bd/A$<_Bp/@<_K9)t==_I8BI%/cA8+ H@<Q`|I})p|B.p|IPKE||Ip|.p| Pd|@PJ8<_8<_K@8HK,8!|N |B;!<;8cH)<88cHH<8cH=?<_)08Byp8a@A@L!H!DTPH<_@b8`H<_=?b<_9)y|B,8a@!@TAD<_B(LPAHH<_8By88a@A@<_B$TPAD<_B LAHH]x8!p|N |B!<8c~dH<8c~l<_~(H<8@8c~,H|cyA$c H<8@8c~,H|cy@<8c~,H<8c~dHh8!`|N |B}H|48I9)8|B,B^|@t/ATB>8|B,^|@t/ATB>8|B,<_88a@BL!@TAD<_BHPAH<_BDALK8!!|N 5)8`@9 H@ }%Kx8`A8A<4M 8|89BN |!8<8@HMh8!`|N |!8<8@Hh8!`|N |*p|#x!}Cx}TSx;@|#xx@;<@|]Jx;;`@@@ x|PH)/@ ;@H@@ ;@H|uA@ /A;H,/@,/@$/@8;;H$x8@H xa@H@;{APA|P}7PCx"Ab8!|N ||#xp}Cx!}VSx; A T<; [*|^J}x@;x;@T@@ ; HD]8+~A;HxTC>H ;;@AA|P}7P#x"Ax8!p|N |*p|#x!}Cx}USx|#xx@;@|YJ=x:;@;`@|@@ x|PH/@ ;@HX@@ ;@HH^T@>+A|@t8~HxxH1|~@|~x;;{AA|P}9PCx"Abx8!p|N |A*@}(J!|#x}Cx|3x}RSx::|#x}Cx#;`;@@@@ ;`H~}WX/A4;@A;;`HU`:^}9.TB<|bJ.H U`<|x./@,/A$r`A ;`HH/A;Uc>8+~A};HxH;;Z@AH|P}4PcxA"AB8!A|N |!*p|3x!p|#x|yx}Cx}QSx;`:|#xx@:@|^Jx;;@@@@ x|PH/@ ;`H]T@>+A|@t8`@Hx8@Ha@U`պUb }6.|BJ./@ /Ar@A ;`H`Y|IFp|H|t/A 8@A>^;H@@ ;`H^;;Z@A$A|P}4Pcx"A̓B8!!|N ||}x!cH}HX8!Px|H|}(Jp:@!`|3x}Cx|#x|wx~*99,:`|#xAԒA@ADHA:@: @p@@ :@H||t/A P:@xA(/:Ax8xH/A@@@x@A0/:A$x8xHu/@ HD,;`;0@T@@x@A(/:Ax8xH/A,;{;8A/A؀W,8BA rAlr@ H:@H/@(~x~xHYC|sx"8BA@!Da@| |t/A8;@A;:@HXx]Hux:`H4x8aDT:TB<$x;:1}+.|bJ.H̉9@Aa| P~CxAH}"PAԐAؑ"Aܒ"8!|N |~*p|3x!`|#x|xx}Cx:~xȑAԐD@9r"|]Jx:AH; |*@@!8`AؒHpx8HH Aȃ"x$x:H@c:[{@x@@Cx|PH/AZT@>+A|@t9@HCx8@HI|nxa@U`պUb }3.J./@/A,7x; @Dx$xH%A@cTIպTB {})X.J./@,;9A/@$r ~x@x~xHуc:[{A080|*@Ax84HQ0Fp||t/A 8@A|];H@Ad;Zr:@A/@|r At/0|A|@@$H:HH:H@~x:H4Ax84xHx8H!~xAD)|P|MP!Ԑ !ؐIAܒ8!|N a|~y|!AL,;;0@ }4;;8K9,Ah8!`xa|Hh8!`a|N 8|B!|c";04/@<8D8`Kە|~yA<_BA<8cSHݓ4X8!Px|N |bx/A/@|bPN |@&|BA?||x!;XH;/@H}/@8xHaH=|~xHޕ.A$/AH!88@|dx8`K1HAD/A<@; 8x8`Kŀa 8HHܕ8a@HmxHeHa8!xa|}p N |B|zx!???H޹;<@<Cx8R88q9H-<Cx8R88HU^/@T<88cRHU8C|~xCxx8B^H^8B/^AxH9H<8cYH^/A;;;y<88@[8`|.H8=|~xHI|cyA088<8Rx8CxH8a@H[;;|./@<8cYHр@<Cx8R88q9HQH8!@|N |B!|yx!<|#x8cXH#x8 Hܥ/||x@?a ;W8C@\Tc:?8cHm;񜀡 ||xT:H/A ~HA 8B]H܍ <_8B#x;`W:}) H|}xHp?T{:8;8@8`^|.Hq |Cx8H=/@8a@Hm<8cXHaH8a@HU^ {.CxH|}8cHu$x|~xH8=|~|Dx8cH88@x8`H=|}xH58xHx|~xH]8a@H=/9kW:K.A$K|.@cxxHH xH1<8cXH<#x8Pt8H/@ 8`HځX8!P!|N |cy|!AP|dx88@8`H8=|~xH5|dyA A8x8KY8a@H88!08`|N |B|}x!<8cU4Hx8@H/A<<_Ti:B}i.})8i/8c@}c[x8H<8cU4HQh8!`|N |B|}x!<|#x8cTH1x8 HE;/Ah<_Ti:8B<8`8@|.H¹ |}x|/=@(;xH9xx8HiH;8a@H<8cTHH8!@x|N |Bap!|;x|#x|+x|3xA|#xKH/8`Ap A(<|3xx8LD8H |dxxKesA@x8@K|fy@<8cLPH4xdxx8H8a@Hs@A xK8`H8!@a|N |BA;<_!|#xR@4<_| xBR8BA/A;HA??;R胼@;{RW:[|}./AH/A[].H\8B@4jxxjW:;|IZ| Y.E8BA<_=?8BR)RTB:|BJHW:;xHx8|~x;RH/AxT:H%}H݀T:^.\TB:|B8\8B\h8!`A|N |B!?;QP~/A(He=?<_89)QL8BQT X8!P|N |Ba|{x!<8 H cxHa8@H|}x8`Hc|~xa@8cHyx~@8H<cx8I8H1|}y@xH=8cH5x~Hi<cx8"p8H|}y@ ?; x;H8cHx~ H%<8Icx8H|}y@48`H<<|}x8IxcxHٕ/@<xcHUH ]cxH}x8!pa|N |@&|aB||xA!H/AD\.A<88GxHm\<8 8x HQ<_;08BHxA0\4HmxHex8x8H1/@0xH/A4x8@HMxx88Hx8@H H$8`Hס|~yAxH88HI<8|{x8Hx8H/@\x8Ht<8x8HH<88H<xH \8xH<88HTxH<88HXxH̀8xdxHֽ<x8HT8H֩xHցH8/@0/A$8@@^/@\/A4bHu\bHi\b H]|HQA xH/@8xHeh8!`aa|}p N |B|~x!/A<}H̀}Hŀ} HxH/@<xc|H9X8!Px8|H||aB|{x!8` |#xHc|}x<8cLPH<_<8BL@8cLPh8!`a|Hl|B|}x!<|#x8cKHa=?8@iK/AL@0@$/@ KHHH|bxc/@X<8!P8cK仁|H|Ba|{x!<|#x8cKD8 H|}x8` H͓c}h8!`a|N |B|}x!<|#x8cJ8 H8@|ixc/AX@<@0/@ HX8!P|H||bxc/@X8!P|N ||}x!HxHҙ|B||x!<8 8cJH/|}xA\8B\=/A I8B/IA }H퓝?;J ~/AH8@xHe|}xa@8cH5x~@8Hh8!`|N |B8 !<8cIHH%|~x/@$<8cI@H%~C8BCX8!P~|N |B!<_BH/A<8cAH<?;H8cHH|}x/@@Hˁ>/@,<_8BD"HНHyHUH1H H/@(<8 8cHH1X8!P|HϼX8!P|N |BA!<?8cH?H}G8G/AL;G<8cHH1~}N!xH<8cHH-/@<_;<G8cHHHe<_8BG/A<8 8cHH=HHΕHqHMH)<_CD~/A H1<_CP~/A H<_CL~/A H?;G~/A Hݓ8`H͑HmHIH%HH8[Gh8!`A|H̠|B!<8cF|Hν|}yA=8/A(I8B/IA }He8/A0~}N!xH/@HH˽H˙X8!P|Hd|B}H|xx8>8HY8|xx8!pa|N 88`N /|B!|#x|3x;@ ;H/@X<<88Dx89@H /8`@d@/@ ;&H4<8c=HH$<|#x|Ex8=8H8`H xH/@xHe8`h8!`|N |!HqX8!Pxx|N |!B|yx!8`|#x|+x|3x|;xH<fx|exGx#xܼh8!`!|HN |aB|{x!8`;?;BHU|~x8`@HI888c~<88c=(H}8~ |ix<8c=4I8BIHY~|ix<8cBĀI8BIH/@HcxK=<8cBHqh8!`xa|N ||~xB!c/@8cHH<8c8W> W>I9i 8KK8BA<_B:"8/A8@(A`\@A\<@!>`|J`A:!H@ 8a@HYA88BA<_B:"/A8@(A`\@A\<@9 `|J`#x8@H8a@HCxH]C|~xCx8B^H\Cxx8B\H \|{x8B/\AxH 8 /@(Cxx:I8BIH^8B/^AT /A/Ax}N!~/A<_B:AHxH`x|x(8! |N |AB||x!|#xCXC8BCXH/@\X8`H`\d/A "H<=_[ 6AL8<_xdxB6}N!|}yA\X8B\XHpăH~ @0\@ H@ ^ ALpA( A<8c5HHJ6cx}N!K4(/@A;pA<^xx8B^H^|}x8B/^A xH\X8B\X@TH=/AHxxH /|}x@0p@$8@cxHŀ@|dxx|#xHqxA@T\Ȁx8!pA|N |@&|B9`9: A!a9!@Ad@!/H BdAa@Tc:HaAa DT|@~xKADT|AHp/A@A/AH /AH:V:.H$>0>P>BBBC8  | @  t t D 4< A :HDtV:a|.|xlH]HCa:^V:;#LTB:H.HAx^>ATBT~U)@.|Bx|BKx*L|B[xTB:H.HV::}6.!lI8B/IA@al /A/A }N!Alb/A<_B3TAHalHH@V:.H@^>T~TB|xU)@.|Kx|[x|PT:.:;H@p;`/@(V:8h|v.H1h/@ ;KP\P::A8V :}8h;H/A h{:1@H8<_/|}xB3TB C@x::8{H}}|yx}APV :8h;|xlHi|zyAh#xDxHрh9:1@8];HĈ;^>T~TB|xU)@.|Kx|[xH ;A|P;@T:"|VAh;b/A4}"Kx"B /A@aXH@0/@H8aH-|cyA$,pAx8hHF|zxV;a8BVHIaxhexFx9H]|ox8B/]@ xHE/x@>aH|}xH<_8B3TBC AbKV:.xaK|oy@HaH%|}xH]<_8;B3TBC AbK; H=V:.aH-ax8lKy|oy@>;lKaC(W(4Bp AZp @p /@ /@:;H<; ;H^>aTTB~|xU)@.|KxC(|[xW(4Bp AZp @p /@/@ K; ;!p;`HV:; |}.H|{xHV:; ;`./@xH|}xa<x8ex899 9ApH|zyA:|p /@8/@,Ap/A/@;]H;H ;^>T~TB|xU)@.|Kx|[xH ;V:|v.c/@ H|{xA(W(4|p|xpAp|xp @Ap<xa8ex899 H|zyA9lp /@4/@(Ap/A/@H; xDxgx9paH|}yA8]HV:;`:HV:|.|Blbc/@ H|{x:HV:;`:HpV:|.|Blbc/@ H|{x:HHV:|.|Blbc/@ HY|{x:HV:;`:|.l.V:A 8H8./@xH |}xa<x8ex899 9ApH|zyA7@ ; H; ;Hh;^>T~TB|xU)@.|Kx|[xH ;:H;^>T~TB|xU)@.|Kx|[xH ;:H@;^>T~TB|xU)@.|Kx|[xH ;:V:|.|Blbc/@ H|{xA(W(4|p|xpAp|xp @Ap<xa8ex899 H|zyA6X; H ;^>T~TB|xU)@.|Kx|[xH ;:H;^>T~TB|xU)@.|Kx|[xH ;:H@;^>T~TB|xU)@.|Kx|[xH ;:V:aW(4|.l(@p AZp @8; ;`p/@ZpKA /A/@p@ ÀAp/A/@:V:!l.A(/ApI8B/IAlal /A/A }N!Alb/A<_B3TAH̀alHH`T]8B]HDxxgx~xplaHHXV:<_|.3LlD @ $H?3x@ $Ha8xHe|oy@PAx/A@@|/@0/A(@|/AAl !|Al"A<8ĀaHH+Al;3x H@!|Al:"9)/"AXal /A/A }N!Alb/A<_B3TAH9alH/A/AH;H;H;H;|t/ A /@,V:|v.c/@ H|{xHV:;`./@xHY|}xa<x8ex899 9ApHm|zy@(<883aHH10 ;9H;|tV:|v.c/@ H|{xA(W(4|p|xpAp|xp @Ap<xa8ex899 H}|zyA1D; HT;|taW(4C(Bp AZp @8;`; pp /@/@܀Ap/A/@<_ B3L@\/~1@~#xH5\|}x8B/\AT /A/Ax}N!|/A<_B3TAHuxHM]8B]HLx~$xxHH8Dxxgx~(x9 paH|}yA/||~/A]|~xHT|tH,^>T~TB|xU)@.|Kx|[xK$;^>T~TB|xU)@.|Kx|[xHP;^>T~TB|xU)@.|Kx|[xH ;|tH;|tV:<_|.B3Ll @0`|C|@xH0<_B3H@(=?ɤ OB|&THP<_B3x@,9 xAx||JyA9 !Ha8Hq|oy@0/@ KhK`V:?|@6.b3Lal|ix A<_B3@ 0`|C|@xHh<_B3x@,9 xAx||JyA9 !H<_B3H@(=ɣ OB|&TH8hHehH݀l/A8`8xH|oy@LAx/A@@|/@0/A(@|/AAl !|Al"Al;3L H@0Q|H@x9 A||yA9 !H$8H̀|ox0`|C|@x/@$?3LA<_B3@0`|C|@xHh<_B3x@,9 xAx||JyA9 !H<_B3H@(=ɹ OB|&TH8h#xHခhHY/A8`$x8xHA|oy@DAx/A8@|/@(/A @|/A !|9[3L @0Q|H4x9 A||yA9 !H$x8HM|ox/@lA/(@/8@@ H/8@A/A8@;/@|CxHiHd|#x|DxHyHl^>~TTB|xU)@.|Kx|[x|PxT:|"8H5;C|}xx8B]KV:a8h|.|xlH|oy@,Ѐah;H|}x]H&V:a|@6.%x|xlHH؈V:^|2>~TTBa|xU)@.|Kx|[x8|PT:|.T:|0P8H|}yA);xKV:^:6.>TBy^T|xU)@.9k|Kx/|Sxy;AT /A/A#x}N!y/A<_B3TAHz9#xHV:aW:|F.|Ʋ$x|0Px|GxAlH|}yA(;;<KV::.\8B/\AT /A/Ax}N!|/A<_B3TAHyxHaV:ax|°.|BlH|}yA(;KV:|@6.bal@hI C|bHt8H|8|}x#xH|ɀA|dx~@8/J@xHz0C||xH$xHy |`HhcJ C|b^/%A@A/$A$H `/&A/'AH L/H /H /H /H V:|@6.B|CxAl@8HH" <_B3@H H@<8H 8|}x#xH|dx@|xxH<_# B3@ H@Hua#xHiAla!@,@ H|exb@@}%KxH8|CxH|}x#xH|dx@|xxTT~TB|xU)@.|Kx|[xK;KָxH|U|}xCH ,V:>;@|@6.;`;;3L:`l @ $H<_B3x@xHda8xHw|oy@Ax/A@@|/@0/A(@|/AAl !|Al"@ 3L@ YH|<_B3x@H`a$x8Hwe|oy@@A/A8@/@(/A @/A A̓Y@^9"+A<_U):8B.| .|| N X``````````@=9 3x@ȀA|yAL3L@ /A8Al;k3x XA X@ȀU3L@~#x~"pAxa|H  @CxBpAȐà/@8AȀa;!C}"Axa|!ȑA c|BAxa|ȃ̀ax|xxH]|bx|#x/@ |c|B/A c|BH/@Z~1;|||`Q@|c/A|c|{xH<_ "3xH@ÀAl/? H@x|@;;H|/<@4xxW8TiT}}<xWWW|CxH@/@,xxW8TiT}}<xxxHxxExH||x|#xH@ ;`H/<;`A/~;0@8V;{0H<_ "3xH@ÀAl H@!x/?!xA|/}T~TBa|xAU)@.|Kx|[x"TW8|BJ#dB(T(4||.|/@ 8`H`||.C8BCH 8Hb;`T;@: ^>T~TBa|xAU)@.|Kx|[x"TW8|BJCd(\T(4|N.Al|CxB:~xHa|@; W`(4=8|.;a HkA|oy@4|րA@;@:1;{A.A|: @:| W`(439|N. B֐A@4:; A@HZ9 <_al; #B3TAlAl"Al" HaW:C| .l!I(T(4Bp AZp @Zp@A /A/@pC A:lAL/AlY8B/YAd /A/A#x}N!y/A<_B3TAHR1#xHY H`@Tl!lI8BIHDxx889 laH~y/@/ApAl"9)/"AXal /A/A }N!Alb/A<_B3TAHQ]alHX59H9;:A:1;{:sAH./&@@|tH8;Kd@L^>T~TB|xU)@.|Kx|[xK0Aa8BT@:A~.;K!;99)!Ka:HX|}xHX9 <_#B3TV:# #8!i.;K}{xH[|}x:;V:.]8B]Kx<8c4H\9aHUaHXI<884DHVYa<<<84T84\84D8HUUH 8+Ax8H ||yA$/A\/;9AV:]:;Al"9)/"AXal /A/A }N!Alb/A<_B3TAHNalHU/;9@/@a9\H\|/A!9 HK/@`A p @Px8hH|zyA8ExAahHR݀A`a/A؀x8H9||yAAaT[:|.@V:]:;Al"9)/"AXal /A/A }N!Alb/A<_B3TAHMalHTiA|.A|a\HKЁ! H@V:]:;Al"9)/"AXal /A/A }N!Alb/A<_B3TAHLalHS AA @/0@|t/xA /X@8 ;9@| y@@0>+A$<_U):B}) 4tA9@/A8 <_;@bH8 ;@!@/AȈ^+ATB:|BZ4tAK/9@A,+A$<_U):B}) 4pA9@/Ah8 <_;@bH8 ;@!@/A8^+A,TB:|BZ4pAKȀA@;8BA@@/A@~+@H^T`bH <_Ti:B}) 4Tb/@@/@Px8`Hs/A?;HP<<<8,88 cx8|3xHN H$x8`8HHsY/@ ?;TcxHP=?WB:9)<<|BJ=8l`x8x9h9 HPIx8!pA|N H?`|+xc{$$:;|`QA,A 8`H;X;@\;`d@tL9LT@>/@4 9J*TjTB|xU)@.|Kx|[xH |@t}LSx/9E}Cx@4 8J*TjTB|xU)@.|Kx|[xH |t}ESx/|^9F}Cx;@4 8J*TjTB|xU)@.|Kx|[xH |t}FSx/Z9G@4 8J*TjTB|xU)@.|Kx|[xH }t}GSxA0A|^PA|[x|xWx;A<8``A/A|`N E4H/} P8`M P|e8c(@A@/CHA$ |@M /M 8c(@@8`N |AB|#x!<_||xB A$<_B<A<_B @ 8`H8@xHHـ@|{xHbM/A`8`x8HHR5|~y@XAH/AL@L/@ @,^<C0@lBAD<_:ɡ@(H,<_B@~HmH= @,]<C0@lBAD<_:ɡ@(H,<_B@}Hm)HHS8@~̳x~ N!HSՀ/@,@$<_:4A<_:<@ ~x; HH$ ;HMW:|{.C8BC^8B/^AT /A/Ax}N!~/A<_BAH@1xHG ]8B/]AT /A/Ax}N!}/A<_BAH?xHF#x8!|N |!B|#x!||x;@dW:;.xK/@<_ B0@$/|x@ |`ADHJH<_B\@=]/}#Kx}DSx@` |i/@PxHDxHG=<88݈HEM<<<x888|8݈8HDI;@H|HK;H\<_=7d@ P@$<_7|A<_7@x;@HH ;HK=W:|{.C8BC]8B/]AT /A/Ax}N!}/A<_B8AH=xHDCxh8!`!|N |AB|#x!;@W:;.xK/A ;@H<_ B8@,^<C0@lBAD<_5dɡ@-(H(<_Bd@~HiH>;HIW:||.C8BC^8B/^AT /A/Ax}N!~/A<_B@AH<xHC]Cxx8!pA|N |!B|#x!||x;`DW:;.xK/@<_ B@ ~H<_B@ ~H<_>4$@`<_4T@`xHAyxHD<88HHB!<<<x88<8H8HA;`Ht<_4LA@$<_4<A<_4D@x;`H H,@aD;HFyW:|z.C8BC^8B/^AT /A/Ax}N!~/A<_BAH:xHAcxx8!p!|N |!B|#x!||x;`DW:;.xK/@<_ B@@~H<_B@|x|pH<_>2H@`<_2@`xH?xHB)<88lH@9<<<x88`8l8H?5;`Hl<_2A@$<_2`A<_2h@x;`H H$Hd!;HFYW:|z.C8BC^8B/^AT /A/Ax}N!~/A<_BAH8xH?cxh8!`!|N |aB|~x!|#xp@@L`@HH|}xH:Tc`&W~/A<`@o[h$^<N= ` _a)||Kp||p| P} I |IPBA|@P/^@ <88PH<<<<x88D8P8H;;@KPCxx8!p!|N |AB|#x!|+x|}xDW:;.xK/@X<_ B@ H<_B@ HxH:xH=)<88H<^8B/^AT /A/Ax}N!~/A<_BAH4]xH;58`HT~/]`@A<`@l@[h$^8B/^AT /A/Ax}N!~/A<_BAH3xH:xdxExK8`h8!`A|N |!B|3x!|#x|sx|+xH9|/@ H:|}xL8s x}N!|cy@,~cxH;q<<8Lx8Ɲ8H;5H(c 8A<~x8chH?:@H:; @;;[;:~cx;:@xK|cy@<_ B@z/@8l8A@=?}|.|\<C0ɩ+<h(H/9A@@ |x|p}=R}}Q.IiH|]R|}Q.H<_B<@h}/@;@|.H]=H/9A@@|]R|Q.H|]R8|Q.bHp|T="/@$8A@}<.|\HY/@|~.8@HW/AH;y/AtHH|~.T&/@@T8HWI|yyAH/@H;1/A|~.xHV/A.H HV|yx/@;A@H/; @(CxH=Q<8|ex84CxH5HxxH/|}xCxH=!<<|gx8TCxx8ƛH9H5]H<; H4|~.H/I<<|ex8TCx8h8H5)CxH]cxx<H' ]|xx8B/]A xH,/Ax;H=HxcxH=H$xxHR5/A x|zx|t//@(<88cDHDx|ex8`H;x|t/A$//A|t/A //@}Q@`|t/~@0A(<88c$HUxex||xHHxdxH5||xx8`DxH;|t/@Xh8!`Cx!|N |!B8!|yx Hm|zx8a@H #x8@88 Km|~xA Da@HDx|ex8`He8a@H ݈x|t/A4//A,/\A$|t/A//A /\@}Q@`|t/~@0A(<88cH xex||xHyHxdxH||xx8`DxH;|t/@HX8!PCx!|N |B!|yx!<88c;`HY|}xH|zxK988`;H$U%x&x|~x|dx8`H=/@`x88@8DH=a@/AL<88cH8@8D|}x8xH=-D$x@x|PHUxHXx88@8DH<@/A ;Hx88@8DH<р@/A;`;HTx8 8@8DH<@/A ; H,x8 8@8DH<}@/A ;`; 8Dx8@xHH ^;;C/@H/@@|^|t//A,/:A$<cx88}H YA@8BA@x;Ha@|cxHcxHi]@/Ax9 /|@t//A /\@X|t//A /\@ 8c|t//A/\A|t/A /A>H ^;;C/@cxH |Pcx|x@H1Hx8:; H#]/@Xx8/H#I/AD; |t/A09 :x|t//@"|t/@A@/@P| t/ :@|t/A|^|t/:A/ALAHH$@@;H8|t/A,/:A$<cx88}H }A@8BA@xHx||xcxxH UcxH @|c|t/:@<cxH i8@@(|t/:A@cx|8H/A0Dx/A 8@//:@D/@x8!p!|N |A|{x|#x|+x!H/|}x@4x~x|8;H x|ex8`H 7@܀]dxx8B]H2C|~x8BC]8B/]A xH 8@xHE@|dxCxH ^8B/^A xH yx8!pzA|N |B|}x!|#x8|+xH C|~xxx8B^H3|}y@(^8B/^A xH 8`HxHxH }8|dxxH ̀^8B/^A xH ]8B/]A xH <_BB/@0\/A 9 \//@"/@|X8!P|N |B||x<_!;@/A+A$/A8Hl8:HU/@x8/H x8:H1|}xH<|~x/A,<|t8c8H /Ax/@x8.H1i|~yA/A@@;X8!Px|N |B|#x!|~x|+x|t/@l<8@8chH0/a @4/AxH<<x8L8l8HyHd8 x8`Ky8a@HHP|#x|+xH0M/@8nCx89H /A0|~.8Hi8`|t/-A CxHMH!+A<_U):8B| .|| N $P`XbH8A8/@<|^b;{:`Hx: HpbHh8A/@|^;{:`H@8A|^Cx8B;{~DxH/AH;{H;{A~QA <Cx%x8ƣ8H HrA/@<8cH<_:>/A0+A/AH$>:uXH>::u`/@x~óx8H|~xA(~x|tHQ/@;@|@ :`H; xHy@xx8H:HXxx|*|(PH|Px8HQ|vxH <8H}/@8~óx8H8a@H HLx|P8a@H%<88u\8a@;H 8a@x8H|t/A<x8H|~y@|t/Ax8a@8HxH-AV8BV/A~Dx8CxH8`H8 ||xA8B/AA<8 ~DxCxH a 8H8 |~x<8cxH/@`H<x88c(H/@`H/@^|Bt8b+A@<_Ti:8B| .|| N           \   ht`H`H `H`HH`H<`H0`H$`H` H `@H/@ /@d ! H 8`8H/@ /@ 88CxH ŀaH8 |dx<8c0H /@Ȁ 88CxH aH8|dx<8csH/@0 Cx88H U/@HPaHu8|dx<8cx~8;Hq|dx8a@H8A8a@~x8H;{A@Cx~ųx~xxH/AH @;`@x=x; xH@@xDHA}8;Hр|`xx|xH Cx~ųx~xxHm/@8;{A8a H)HL;`@D>x~;Hm~ųx~x|`xxCx|xH/@T;{Ar@DCxH8|dxCxH/@ /@@ /@<8jH <8<Cx88HA|@Cx8HH<8cH0<8cH$<8cH<8c,H <8cX8H|dxCxHQ8`Hx;HHh?;\@@>x~x~;H5x8|`xCx?|x;mlH7{@<Cx88jLH;/@ /@ 8a@H}A V8B/VA ~óxH/A\</A I8B/IA |H< /A I8B/IA | HxHxh8!`a!|}c N |@&|ܐB|zxA|#x!<_|+x|3x|;x;`4D/A +A4/@@?;{H4/@$|#x8:H/@?;{jH ?;{j.8a@HAxH|~xH~x|t/~@xcx|t/\@cx|tH /@|t/@s]88|\tA 8`HCx8@K/@s|`&TcH4@A|dx88a@H-A<x8a@8H~xH$~xAxH8|dx8a@HD/@@A@cx|B|tH-/@ sA8a@dx8H;CxHC|~xCx8B^H)'xCxdxx8@H!|yyAsA$Cxx; H^/@48/A xH-xHC|~x8BCCxHM8 8$|dx8`H 8@@s;$TC:Ah|c(.8(Hi(@@|t/AcxH/@<8cH <8cj8H |c| PHUH|c(.|exxCxH xAhCxxH^8B/^A xH%8a@H]#xh8!`a|}p N #9@9` |t/A/A 9@Hd/@( D|t|Bt@#8`N |t/{@ 9kH /}@ 9kH/\@9@ |t/@#8`N |@&|a̐B|+xA|wx!|#x|3x|;x:;`.@E|B|tx;|t/AX|t/\@$x|tH%/A0;HxH /A;|t/@>/~ӳx/A+A/AHL|t//@@/AH /@@ /:A<8fdH/:@;/;@<#x88fdH/;AHЈ|t/:@<#x88fdHHP|t/A@dxxH /A@|/@t<#x88f\H}@\/H+@HT`bH <_Ti:Bd}) 4Tb/@A@|t/@8`x8!pa|N |aB|~x!|#x|+xH88@8xH]@||x@+@H)T`bH <_Ti:B}) 4Tb/@A@|t/@8`x8!pa|N |B|~x|#x|+x!H88@xH@@0/A|<<x8x8N8HHXH-/A\<_A$<_A<_܌@,/A xH}8`H|A@8BA@A@B|@t/A@TC>+@HT`bH <_Ti:B}) 4Tb/@A@|t/@ 8`x8!p|N |AB|{x!|#x|+x9 8A@|H|t/A(8+A 8 |tI9)/@8A@8|I|CxHᑈ@|}x|t/0@A|t/A/1@A|t/A/y@,/x@8<8a@8PHm/A/n@,/x@8<8a@8TH=|cyA/t@,/x@8<8a@8cH /Al/f@,/x@8<8a@8cH|cyAt/o@t+@l/x@8<8a@8XHߥ/@8Hh/x@8`<|ex8a@8\Hm|cy@ |H4/A$<<cx8`Ex8M8H8`H8`x8!pA|N 8H|B|+y}H|8 /TB:T:8B9)> ^$@=_9JH4/@=_9JH 8 +A ^4H =_9J/x@h/Ax$|9|0|H8HK$|@8^T :| . ^}i.h/@79Ax8Ah8!`xa|Hh8!`a|N ||#x|}x|#x!|+xHӁ|cy@|dxxHxC|~x|dx8BCxH||xxH/AxH퀃HxHH9|dxx8H^8B/^AxHmHx;HX8!Px|N |Ba|{x!<|#x8c{t8|+xH8a@<8cYH8@HaD8`HI<C|~xcxx8B^H^8B/^A xHܭw8`@WcxxHֱx8!pa|N |B|;x}H| |vx8WD|+x|3x|;x}Cx}4Kx @8d(@(0@8` H}\SxHx8@;H); |{x|t/Ax9@/At|Hx^ix|t@0|Kx |t/A K|t|BtA܈ |t/@ ;9}\Sx|n9J/@r@p/@h 8D@ }H8/A/Ax}N!8` H8D }C8`H/AH8<_|}x~óxBnxB ]HԽ/@<8zHH <8zT8<=~ex8=|gx9z\x9@H|.;/A\|./@(/@<8zhH <8zpH<8zxx8;Hع|n/@8`8!a|N |B!Hؙ<88wH֩X8!P8`|N |!||x!C"B})BH.CxH};|yxxHmDxx|{xH<|h8!`!|N |B|#x!8` H<_8B|d|e] }X8!P|N cHD|B|#x!|+x|3x|}x;@Hֵ8<_|~xxBjxB ^H҅<x8oH8HQ@=x}<_;8B @(#8xI )|B|.HHA8|dxxHֱ8A /A<x88I8B/IA ~HxHHx/x@cxHр\08B/\0Ap@Dx~xH)x8@H|{y@0xHxHA8!|N |B|}x!<8 8cCH݀@, /A 0/Ax80Hh@,/A 0/AD80H4@(/A0/A80X8!P|N |B|~x!<8 8cBDHA A8`@8`X8!P|N |aB|#x!|}xDp/@<8cN`Ha/ALxKe8@0}N!@|}x/@ A <8cNH ^08B^0x8!pa|N |B|#x!||xDBptA /A<88NHHH-/8`@]xBpK0/A^@H ^D" ^<8<^D.@@8`p@/A \8@|*||P8}N!|cy@a@/@8@K/#@,p@`xHB8@HA,/@0~,H(H/AcxH8|dxcxHxKK;@]|@ /@@Dxx8KK`^p@A8/@@/@$T@nX\| }N!pAL0/A@@/@4^H^t@A<cx88=HH,dB^/ADAB@ a @\;/@ (dx8|}N!|}xcxx8`K/@/8`A8`h8!`a|N |B|}x!<8 8c.HAc<l/A09`C/AH@cc/@܀|T/AH /x@;|hTHQY\X/A<^"9)/"A ~HxxH/@8\X8!P|N |a|#x8|+x!C|CxlH&1/@8/@xH|~xh8!`xxxa|HN4h8!`8`a|N ||}x|#x<!`|+xcH%/8`@L/@xHe|~x]xx}8@}N!|~y@ a@Hxh8!`|N |a|~x|#x8!|+xcH%!/@$h8!`xxxa|Hh8!`8`a|N |/|#x!pl@|#xHapp/@X|+xxH8p|}xHp|~xxxH݀]|~x8B/]A xHxHxxH݀X8!P|N ||#x8!xlH$/8`@L/@$8@xH @|dxxH9H 8@xH@|dxxHMh8!`|N ||+y|vx|#x!;; :c@P8@D@D/A 8 8;  A@8BA@cxEx8@8DH=@9|:@@ @:x%xA@~óx|H-/8`@(D; PZ|\A@Ax8!|N |@&||px|+xA|#x:`!P:::=T|@H`:@}8`d@!d/A 8 :;{A`8BA`dxx~x8`8dtPH `~|:`@ `:A`d|B}" P~@/|^J;IPA,x~ųx8PHVP|:8h8``~$xex88l9<x89Z@H .T<A,hAl|@@`:A`9~PHAl>|H@ ~P|8aP~ųxHx~x~xH/8`@h::@A`{|@P||IxA`/l~s@ @;| |@A/A|} A@/@8`H 8`H~cx8!a|}p N  8`G/A$+A/L HH/L H}$RH@@p}$HP})8/ @8`8BHD}$RH@@88 e8D8/ @8`Hd|DxH@AԑFN |#x|+x}$R}dA}i[xH@@H9@ |t/ @X@@9)D8`888H@A|(P|B PFN |!c+q @@8DA q"A/AH q A a @  p@A |dx88`KE/8`@8`X8!P|N ||}x|#x!H|~xxxH]|}y@ 8@xH@|dxxH^8B/^A xHـh8!`x|N |aB|#x! 8;x|lH=|~y@H4;H;H;;H;`H胼LCx8<H:`/ A}/@<8`83H |yx8A:ATA\p|AP!X`dhl$A@A(cx8PH]/@܀Ah|/A0A@@ |tA8;@A/A\+A/A/AtHTxKЃA@@8|t/ A;@AHA@@|t/ A\;@AHA@@؈|t/ @`;@ADcx8PAPH9/@:Ah|@@|t/ AA;@AHX;pAT$|t/ @\8@89`9!X9@8`d8|*A@8A|J/APh8!`x8!|H@Ԁ8@>|J^^ >^|J h8!`!|N |!|#x!cL/A4^ A xcxx8KA/@/L@ PH\ /AP^Q@0|~|Px8c8 Hz8@]|x /@/@h8!`Cx!|Hh8!`!|N |a|#x8|+x!Cl|CxH/@$h8!`xxxa|H6h8!`8`a|N ||#x<|yx!`|+xxH%/8`@;@XP#xDxxH:a|cy@̀p@pAp@TfYDxxy8@ }N!|cy@@p`H`@ ^`B`^H@@I8B/IA ~H[xHRiHx/x@h8!`!|N |Ba|~x!<|#x8c48 HS/|{xAP/AD~H|cyA|lxx~}N!|}x/A/@/AxHXxHWpA sA8`x8KyW8@D8@\T/A@"| 9A$!@xb }N!A@H}"Kx/@Ȁ/A xH1xHW9xHW1Dx8!pa|N |aB||x!XpAcsATp@@L]L/A@B@0dWWv/@<8`xH͐}d\xh8!`|a쁂 |}N |B|}x!p@@pXpAd^L/AXB@H<|ex8`LH9~dxHV x8KeX8!Px|HU8xdX8!P|K|!|}x|#x|+x!|3x~T/A4@@ Ac/@/@,8`HO8c T~TC8X~T/A ^X|Bx^Xc/@h8!`~l!|K|BA|}x!<|#x8c8 |+xHP99 |bx~T/A8@ @A|ixc/@/AB/A$@ B/@/@ TH HM~T8X/A ^X|Bx^Xc/@h8!`~lA|Kh8!`A|N |B|#x!9@$\/xA@t (@h@ \H <}c[xxKa>I8B/IA ~HUX8!Px|HLx/@xX8!P|N |!B|#x!|yx|+x|3x\/AT@< @0^"9)/"A ~HU=8H/@/@48`HL<x|~xcxxKu\\~> Z8BZ^h8!`!|N |A|}x!c xHQՀx<HN/A(/AxexxKxH~h8!`xA|HQ`|BA8+!|+x|#x|3x@ <|#xex8t8HXH<<888x89@HX/8`@@<_{8BDT:.HRI8|dxxKu|~y8`A܀^| 9@L/@<8XH <8<x88HW8`HxHMH/@8B\/Al@ AȀB/@HD{ HQ|t/@xxxKUH xxxK8`x8!pA|N |@&|АB|#xA0G9!|;x-|+x|3xW8|vx$eh/AHQ|}xxK H h/A8HQe|}xxK<<|ex8x8 8HQHYW@8~A|TH/@ADV8A8|8`xTH/AAxWE8`HHy`T4` 8c(HH`|ix 8C AX8BX 89h;hx8!pa|}a H$x8!p8`a|}a N |@&|B|~xA|#x!p:;: #CcX! ~I|x!7~ ~@ /@HSC||x8BC/A܃,/AxHu8,Hx,/AHt,H^/A @ @HA@-@ /Avl8$@HHvlx8@K.|}x8@A@@8@@4HS|tx#xKM|}xCxH[<<|gx8XH-Ah@#xK/@#xK/@@r`@8rbA<~xxKa<#x8xKmAL@ /A@8$H8@xHIi|dx/@ /Axl@HHxl@Kma@@ /A@@/@HHQ|tx~xK=|}xCxHZ<<|gx8h~xx8ƹ9HMYH̀/A |P#x|Ky/@@8pA,ri@Lr`A,<#xxK)H/AP/@<~xx8K!/A \8B/\A xHM8`H /@,/A \8B/\A xHMI/.AcxHGC|{xx8B[HaCxHJQxHU dx|exCxHIA~xCxdxHICxdx<HF/ACx: Hw[8B/[A cxHLCxHIH<xHACx~x: HFHCxHICxHKxHY~#x8!a|}c N |!|zx|#x|+x!p@ T;8@|8@lx||PH||y@Hp@TpAp@DTfCxKQ|cyA/#A$;HATfCxKh8!`x!|N |AB|{x!|#x|+xL8`/A0[;@</| PA`+A/A/AHx/8`A(@|x|Jxx8xHA|HD/8`A(@|x|Jxx8xHA|]@|@|]P|I8@ |t/ @];BH/@48`p/@(8 8`T$H (@|x|Jxx8HA|]@xx|@$|]P9 |I [| t/ / @T@$Hp@AT@$ 9)@`H i9)9JBH/8`AP(@|x|Jxx8H@I|]@xx|@h|]P9@ |I |t/ @`I9)H,/ @p@ I9)T$9kB]HPH0}:Kx[``B[HL<8cHL$/A49 @('|t|H|tA9)A\@( /L@Pcxx8KCxh8!`A|N |a|#x||x|+x!8`/A;`^|Q@$|x8K|8`|Hd(@|x|}#Kxx8H>^|@( /@|x8Kxh8!`a|N ||+yB|ux!|#x:;:@y/A,8xH>Edx|exxH>/8`@8a@HBA|cy@X8`x8!pA|N |B8!D<8tpHb8|byA0,}N!8|cyA |x @||xX8!P|N C8`0/M 8`N |Ba||x!<8 8cTH9|}xxH5Ƀ|{x/A^l@<8cH8@<8cH @<8cH~C|t|Bt@xexH4/8`At/@x8`h8!`a|N cN 8`/M /8`M 8`N ||#x!K8`@8`X8!P|N |8|~x!K/A ~,H~X8!P|N cN c(N c N cN cN cN cN c N c$N |8|~x!K!/8`A~0X8!P|N |8|~x!K/8`A~4X8!P|N |8|~x!K/8`A~8X8!P|N /|BA!|#x|3xA4A/AH/AdH?;;HfHHH=|~xxxHe|{y@|xHi/@hxHh/@X^8B/^A xH9xH6ixHF<<|gx8PxEx8ƣ9H>=HL;`/@\x8x8H2U/@(^8B/^A xH9Q8`H(xH8dxHEHxxH38`x8!p|N |B8+!|+x|#x|3x@@<8ex8(xH=ɀ{H7a<<|ex8@x8HHf;; H75<8 8XH-E/@ ; ;AW:|{.H78@|zxxDxHb |xy8`À@p@(<<x8|Ex8 8H~ [8B[H E<#x8[FxxxHSQ/~@`xHO=<<|ex88#x8Ƅ8H'> I8B/IA ~ H"]xH xH-HpA0<x88T8899 H/@`pAh<x88d8899 H]/A<<x88p8899 H1#xxHR)8`H8`H8!@!|N |@&||}x. AB|#x!|+x|3x|;x}Cxc H|~xA}8@H2-@ ;H^x8;8B^H|eyA|}xH||y@hCx$x;H49|eyAP}xH||y@<}x<H̀^||x8B/^A xH /A0/A(}A@H|dxcxHH+A<_W :}8B8| .|| N 8\|HY80H+|~x}HPex0H H580H+̀0|~x}xHPH8H80H+0|dx8}$H HH8|dx}H*}H9AD}8@H0H4A}8@H0A ^8B/^A xHUh8!`xa|}a N /@ `HT<8`N ||~xB|#x!c/AHKA8pA(<xx88899 K%pA</@08<x8x8899 KpA(<xx88899 KpA(<xx88899 K8~$H)^ "9)/"A ~ HxHX8!P8`|N |@&.|BA||x!|+x|#x|3x8`AH8#H8H|;HM|xx@`;\$dxxCxHQ{A<<x888899 K/A@|x.x@xdxxHL|cy@,HAm/#@/xAHAUy8`H@xHK/@/@p@Hx/@|8<88̬8899 xKCxH/xA /@8<_b/AH %~ C8BC<_B^H`<_BALI8B/IA ~ H<_b/@ ~ HH~ C8BC<8cH/@<xcG H5!8~ |cx |`X8!P|N |B8!<;8cH)||x/A,^ 8B/^A xHy@8<_E/Ax /@yAH8`Hy8@|||}xC \/Ab/@/@<xcEH48X8!P|N |B8!<8c|H|~x<8ctH/A<_BDAK<_BDĐ^<8ctHQX8!P~|N |@&|BAA.|{x!<88c;@H}|~xAcx8@HI|zx<?8cxH8}؁#/A I8B/IA cH e@ |H @CxH-}؀C8BC<_<8B8c"9)">HY> /A I8B/IA ~ H @ ~ H @CxH~ C8BCx8!paA|}p N |B!?;ޢ>/A4I8B/IA ~H e<_88B?}B/A4 /A<_8BBAH/x@=?<_89)8B=9k B X8!P|N |B}H|=*+@H 1T`H <_Ti:B(}) 4T/A|t/rA A/aA$H0/wAH$;HH;H@8;H0/A<<cx8$x8a8HQH|t/+@W|zx/A I8B/IA ~HY/@xH|zxHKx|;x}Cx|}x8@@H|cy@@@8`/A0exxH@%x|xHݐz8`x8!p!|N |~y|!A/A~}N!^ /@~H݀~H H4\~}N!^"9)/"A ~HAX8!Px|HX8!P|N |a|~x|#x|+x!H 5|cyA4@/A(h}8!`xxxa|N 8`K h8!`8`a|N |!H ||xK|}yA\]D/A@}N!|~yA08`xxH^8B/^A xH- /@X8!Px|N |AB8!|zx|#x8;8a@HU8@KI|~yA`<_8B"0AD^8/A4/@ H||xx8`xExfx8@N! /@x8!pxA|N |B|#x!|~x;/8D8@H}/@@<_8B @x$xHH$(/A$x}N!/AHm|tHA|zxxHUD|~xHDx|ex8`HYDx|t/A$A|t/A @}Q@X|t/~@(<88cKx/@H(h8!`xxx8a|Kh8!`8`a|N |/!B8!p|yx\@$8`$x8H/8`@pH48`$x8DH/8`@PAD@AH;`|}x@ 8ex8`$x8HdH8@/@x!H<_8BP @`I/A|t/AD8$x8L8`HaaL888K/@aL8PHyP|~x/@(]8B/]A xH׭aHHL|t/.A<_Bk/@8\H/@]8B/]A xHUaHxPHyH<_k/A8aL8TH8\/A/@88/Ha/@(]8B/]A xH݀aLH|aH8XHi8\8`|~xaH8dK/Ap]8B/]A xH֍ad/A0H=Ad|}x"9)/"A adHYH`xH)|}x`x8hHрh||x/@DX/@8|t/.@(|t//@|t/~@;|t/Ad\<_8BA /@xxH H88/;@@(/A$x}N!/AH@h/@4|\|t//A x8@8HҝAh8BAhxHʩh|xH9xHӱ^h/Ata@|It@L|tH@|x;|tA|t/A /A|H \;@;^/@xH%|Px|xhH͑;{Ax8!!|N |B|}x!<|#x8cl@8Hـ <_8B @<^#HAL/@ xHIxH8 X<8!Pxx8 |HX8!P8`|N |B|ix}H|8`Y8BY8 z h8!`|N |BA||x!<|#x8ci8|+x?_Ha 8Z |{x@~ /A@ԃ /Ax/@P /@8/A(xH<<x888Hս9@H(x}N!^ /Ax}N!8`He9 9z x#]8B]##~# ~ Hx8@H5<_BdhB/AP+A/A H\!@|CJ|t//H8!@|CJ|t//A,/\H!@|CJ|t/:A 8 @8DxHʩ@D|c| PH|jxx8!p}CSxA|N |BA|}x!<|#x8cg8|+x?Ha 8 ||x9`A/Ax/@P /@8/A(xH<<x888H9`Hhx}N!^ /Ax}N!8`Hƅ8@9; C9`CCC~C > h8!`}c[xA|N |B|}x!<|#x8cf8HIx8@|~xxK9|}yA /A@/@ /Ax}N!] /Ax}N!8`Hř9@=9kxCC!@#I8BI}C } h8!`}Cx|N ||#x|}x!KY8/@H> /|x@$ /AxxHHiC|`x8BC|xX8!P|N |!Km8|~yAP8@Hǭ|}xa@8cH}@x||x8H ^8B/^A xHx|xh8!`|N |!B|yx!|#xKI8|cy@ /ADaD~K򹀞|}x#xK8|{yA/@ CxH cxH8@C||x8BC[8B[HƩ<_B_I8BI>I8B/IA ~H퓞[8B/[A cxH̀]x8B/]@hHh]8B/]A ~Hʕ8>I8B/IA ~Hm[8B/[A cxHMD/AZ8 ~/AtKe|}y@L/@ CxH qCxH  <8#xDxH%8/@8H /@L~Hy8HC|}x8BCHA<_B_IAD/@ xHxHQ88` xH/8`@ >I/A 8`X8!P|N |Ba|{x!<|#x8c]8|+xH[]8B]h8!`a|N  ||#x||x!8A/A/A8@H8D|}xxH@AD|dx@xH)8/AKMx|}x8`K]x||x8`KM|~xxKE/AP/AH8@xHq8D|}xxHa@AD|dx@xH8/A8|xh8!`|N |B|{x!<|#x8c\t8?H  8X|yx8`A$Cx8Hň||x|t/~@|8/<_ BW /@8:HM/A 8: x8 KE|~xA 8||t/@A  |;0<8cTxHA/a@4/AcxH<<cx8^x8^8HH8a@H88@8`HmxHeH8a@;Hx8@H/@X/A,cxH<<cx8^x8/8Hq8a@H A  |8`HA  |a@DHm|}xA||A |Bt|t@8CxHU88|~x|dx8`HA!8B/9)A!A8Ab8BAH|dxxH]A8B/A@Ѐ^8B/^A4xHH(88cH88 a xH˩|}x8a@HHCx88Hˉ|}x8`H8|~x]8B] /A/ACx}N!8X88` Z X8!P|N ||}x!>/A(A I8B/IA ~H>/A0A I8B/IA ~H8>/A I8B/IA ~HU~/A0^/A$B/A}N!8>/A$I8BI~/AHрX8!Px|H|B|#x!8`H1||~x=/A #AI8BIH#=/A >AI8BIH>=/A>I8BIH>] / A8}/A,B/A}N!~HH 8=/>AI8BIX<_8!P8B\ |N |B||x! /A/@<8cpxH}H 8@C|~x8BCH<_BQ$B/At+A/A HA@|C|t//H8!@|CJ|t//Ah/\A`/@|t/:AH<8*H$A@|C|t/:A$<8*x8HA@8BA@xHx8@H@<_>|8BQ9)/B>^A xH!h8!`|N |B!<_8BP @ c/A,8`|tH8@H]@8`/A8`h8!`|N |AB|{x!8`|3x|#x|+xH8c|~xCxH1sWn~C8BC A8xH倞8|}x8cxxH/@P^"9)/"A ~Hـ]8B/]A xHxH8`HT<cxDx8qxH1|}yA,^"9)/"A ~HixHAxh8!`A|N |BA8?!8|}x|#xH5|~yATxx8qxH^"9)/"A ~HՀh8!`xA|Hh8!`A|N |B8<!8 ||xH̙|~yA@cWH%8|fx8xH%T|xX8!P|N |BAp@!|#x|~xApA0C"9)/"A cHxHH4pA,H8|fx8xH~H9<x|dx8qxHH8@p @pA؀C 9"+A<_U):8B| .|| N 4TC#|Jx0@}"} KxHHCɣhOB|&TH(#I@ CH/A$xHu8|fx8xHu8@H.I8B/IA |~.H^.8`h8!`A|N |A|zx!|/@4|x}x};C8B/CAH7@cxHxHy8h8!`A|N |AB|#x!CBbWC:H9`|}x@(U`:9k};.}=.I8BIB8` H8<_C8Bܓ\ h8!`|A|N |B|#x!p|tx~óx:8@ H=@|}x|~x@@P~+@HUT`bH <_Ti:B9h}) 4Tb/A:;@AV:H@x|{x;/@x~x8D8H9L9!PH]|zyAL/@4x}x};C8B/CAH7@cxHCxHD@@@<8cZH-aL;=W:8cHP|~xDL/AH}L^H|+xxHمaLH8=x L|x.C8BCH|QA8` Hy/|~xcA/A~óx}N!<_88B48`V 8!|N ||zx!@#;@y/@Wc:H|xx;8@@YW:8;|}.Hـ|HMZ|B8BZAȀz;Hz|~x@@YW:8;|}.H|.xH8 |;A8@A xH@8H 8|P8!|N 88@9# 88 #CCCCC N |a9`|#x||x!/@T}~[x@8]W:|I./AxH}xH;AЀ/A}8Ah8!`a|Hph8!`a|N ||+yB|vx!`|#x|3x;$C;b@/;A|#xH||xCxxHQ >|yx|x8W:H./A@h/A4~C|t|Bt@DDxxH/@0/A CxHX<@`B|P|p|`H̃/@ [ 8T:./Al@P/A4~C|t|Bt@,DxxH/@/ADCxHH8/@Hy9 <_#/8b4|~xK# C#A CH:8c1H1/A.@ ;H`8a@8H8dx8a@H!x8Hu8xHa@H=a H5a @H 8a@8H5~DxH |`,A/@HAD/A|t/@xA@|t/@H/@$<8c1H/@~޳x.A@<#x88N H|fyA ;A@/@@,|t/@(<<x8N(ex8N48HH@/Adx8a@8HHpCx8@H˕/@\w8HA8|dx||x8`8HaH|}x|t/l@(|t/i@|t/b@;x|t/Atx8He|{x+AXa+@HT`H <_Ti:B,0}) 4T/@/_@|/@@<\8B/\A xH<xEx8NP8H%Hx|P8a@Hq\8B/\A xHUa@HM|dx8a@H@8~xH1<88Nx~xH@8~xH <8 8N~xH<8c1HM8̀99!Ԁ9AxHɉ||x<8c1H/@Ѐ/@8<x8N8H-/Aa}N!H8`H|~xCxH8cHDx~H aD8cH~@H<8c1ؐ̐ АHe8S1<8c1H)#xH/AD#x/@<<<<x8N8N8N9HA;H #x}N!/||x@<8#x8N H |}x8`H<<|fx8N #xHHT<<=x8NEx8N99 ;H<8c1H9H#xxxH8a@H8aH8aH 8a Hx(8! aa|}p N |B||x!<??8c*|#x|+x|3xH̓*/A< @$@~xH=/A/@<8c*H]/@x8`H|~x8`H8~xHm8cHex~H8~ <^8c*H8Y*<8c*H/A|<x88G0H%/|fx|}xAAL/@8`H<<|fx8G0x h8!`|Hh8!`|N /|Ba!|{x@<?8c);FH5<_)/AT8xcxHUcx?;FHcxH<cx8-@8H!/@<8c)HHHa8/A|<8?8E;FH||yAX8xcx?;FHcxH cxH<cx8-@8H/@8|xh8!`a|N |cy|!AH/x@X8!P|N |B?!'/A8;'}H%}HxH/@ЀX8!P|N |B|~x?!9}'+/A I8B/IA kH/'A^8B^X8!P|N |B}H|8^ 8~H<8c(Hx%=?<9)$8c(I8BI^LHwᓞP8~`T8X\H8~8H쓾Гԓؓܓ䓾a/A D88c }N! 8a@; xHtxHtA(<88a@8H|8a@8H|퀁 88a@H|x8H1@8xH|8a@8H/@ xHt8cHvx~HvI8a@HsxHsxH8!@!|N |a|~x!PxKX|}x/@H~T/`TA$@8c}N!/AH8HlxHy@pAP~P8H8~H~8~`H~\/@h8!`xa|HT`Th8!`a|N |@&|AB|{xA!CPCxK@<888 CxHx<8|~x.{P88Hw||xA^8B^-A\8B\;CxxH x8HA<{P<88 x8H~^8B/^A xH|A\{P<88x8H~\8B/\A,xH|EH ;CxxHqx8He{/A$@8c}N!/AH}8;8@xH}!|cyA c Kux8@H}|cy@;`8@xH||cyA$ CxH|x8@H||cy@;`xH{x8H~/AL;@$;W:;|bH.HrA{Hr 8ؐАԁ /A{}N!8L x8!paA|}a N ||}x!cHq}HqX8!Px|Hqx|AB|#x!|+x|3x|{xK/|~xAx/AX/AL;@$>W:;|bH.HqA~Hp8ؐА9DcxDxx88@} Cx9AHH !@@HCxHq/A0cxHx<<81`Ex81|8Hx8`H/AD;@4^W:Cx|.Hqa/8`A;AԃЃ/8@ 8`Hp8Ԑ~АH@~@4Wc8W:W{8`TB:I.^8B^Ԁx8!pA|N |#y|a|+x||x!@K|~xH|#x;@@>W:8|bH.Hudx|exxHt|cy@;A8`h8!`a|N |@&|ؐB|#xA|+x!|3x|yxK/|{xAx<#x88.8H |~yA<88c.Hta8a0|ix~xI8BIHtA80$xa48C8BC~}N!!0|~xI8B/IA a0HwA4"9)/"A a4Hv/8`@$#xHs}|t/@ #xHv<88/H|H9<#x~xex888} Cx9A@Hрa8/@#xHu<<8/H,@@@$#xHu<<8/D~x8HP#xHumA8<<=8/p~x8/9/9 Hu!H #xHu5P<<<=?8/p~x8/8/9)9@HtCxHjH8c`8@Hv||yAA8/A/;@@xHry/AA8;@;@"W:x|H.HrE/@ A8;A/AL8{`x}N!.|xxA /A;APCxHjCx8Hr݀A<Cx88HrxCx8Hr A@<_$B@,x | xxBBA|$HA8`Hk<<||x#xxPH]||}xCxHia8`Hk0~0H0#xHs=<<8/x8.8Hs8`H8a@Ht||y@(8`8!a|}p N |#y|BA!`|+x|zx@K|~xH|#x9tCxxx88p} Cx9AxHp/@0CxHry<<8+x8Ԭ8Hr=8`HDxxHk /8~`@|8@Ht5|cyA <_B$@@/A/8@x|xHo/AxCxHs8a@Hs|cy@H8@Hs|cyA ;aPxHdx|}xHo/AllApA4\ALdxxHolAp@0xx8`HxHn/AxCxHri8a@Hr|cy@h8`8!A|N |B9 }H|$;@|yxxI(/A/; @ /AA/#xALW`:x^;@8c}N!|cyA`c @8/AHx8c`}N!|cyA,]8B]܀C /A]8B];{@8Wc8H_xWe:|zxH_QW~KxpA;/@H<_Cxx8BP}N!|}y@(\/ATpA;:dxh8!`|N /|Ba!|+x|~x|#x|3xA$<|#xex88HkA8`H<<88@x89@Hj|cy@́!@+A<_U):8B| .|| N <Tl,D\txxxfxHiHPxxxfxHIH8xxxfxHH xxxfxHHxxxfxHHxxxfxHHxxxfxHiHxxxfxH HxxxfxH HxxxfxH HxxxxfxH H`xxxfxH HHxxxfxHqH0xxxfxHHxxxfxHUx8!pa|N |!B|+x!|#x|#x|3x;@Ka/|yx@cxK-|~xH8+Adcx80K/8`@t0/@\cxHb|}x|Hb=<<|ex8x88HbH<cxx88Hha8`H8a@HY/@t| Ha|}x|t/:@|zx|t/:AD8a@8Ha A<8a@88H`x8a@8H`݃A@88`;! Hs)$x||x8~Hc|cyAP/ A}DxH_/A }8H_ex|excxH_5#xHcm|cy@cxxH\8a@HW8`h8!`!|N /|Ba!|#x|3xA$<|#xex88Hf8`Hf8@H\|~x|t/:@ A@8BA@|t/:A|t/n@@/@<x8 8HVE/@l 8~ |t/ @|t/ A|t/i@8|8C@A(<88PHU/@xH88`Hqi8|}x<8cH]x|exxH]<88cPH]x|exxH]xK|~xxK@<8c$H~8H]qx|exxH]AxxH]1xxHZ8`x8!pa|N /|B!|#x|3xA|#x88He8`HL|#xKE|}xxKY@xH_)<88HxH_8H])8`X8!P|N /|B!!|+x|#x|3xA\<|#xex8H8HdmH8#xH^|}x|z.H]<<|ex8`x8X8H^U8`H;(@@;}W:;H]88|dx#xK/A;A/@@;;};H]i88|dx#xK=/AKM7@8`h8!`!|N /|Ba!@|+x|#x|3xA$<|#xx8P8HcE8`Hx8Ka|~y@/@4}8HX88|dxxK/a8`Ax8@8K=/8`@/aHL@ x8H8 8{Hi<|dxxHW/|~x@4A;p<8dxHSxx8HXxKۍx8!a|N /|B!|#x|3xA <|#x88tHa8`H<x8@K/8`@ xH\ @0@|Hf8`h8!`|N |B|+x!|#x|#x|3x;Kٱ/|yxA$<Cxx88HaM8`H;@,}HZ<88HP/@ ;;@D/8`A8HlU$x|~xCxxK]|cy@lCxxHVMHXx@LW:}HZMxA8|ex$xCxK|cy@;;A8`h8!`|N /|Ba|+x!|#x|3xA <|#x88H`8`HH;@8;~;HY8|excxKE|cy@;A8`h8!`a|N /|BA!|+x|#x|3x;`A$<|#xx8 8H_u8`H;(@HB DxlxixN!|}xxHB /A@0/@<@p<Hh|yA(AB/A@/A0/@\@\H;/A xH?xHA-8`H ~/@8| HA 8`h8!`|N |B84!<8cHAMX8!Pc|N |B|}x!<848cHA <_Bh/Ax}N!X8!Px|N |B|~x!<848cH@/A(^A@(C@8C8}>D}"E /@,8c/@8`X8!P|H~X8!P|N |BA|}x!<848cd;`H?||xHB/A(8`8HB8`HP;`H@;`H8W@ g`\|W/ @ ;"Hx;`Ka|cy@sA8||H$8 /A,/A~x}N! /@s8 @8`/A8|H||{yA($/A,/A~x}N! /@xK/@s AH|1/@s@ /A\cxh8!`A|N |B84!<;8cݰH>1|}x8`/A蓝HA5/A8`8HA$8 /A,/A~8}N! /@܃$/A4/A~8}N! /@H;8`Ki/@H{/A;8`/A8}H{-8x8 X8!P|N |B|~x!<8c܀H<<_"|/A@ (@(<_B쁂d/A i,}N!H)0/@ȀX<8!P8c܀|H<|B!<8c0H<<8<_88cHF<8c0H;<8c|HE<cּH9<8c|H-<cH!<8c|H<8c|H <cִH<cLH<cH<cH<cH<cH<cHX<8!P8c}(|H|B!<?;8c,H;/A<8cHB8<8c,H:<8cH:<8<_8c{H:HyQX8!P|Hy|B|}x!<?8cژH:q;`<,8c`}N!/AHC 0<8@8c`}N!@/A <8cژH9h8!`|N |B|}x!<|#x8cH9<8@8cHB|cyAPC 8bH>)x|exxH=/@<8cH9e8`H$8a@HB|cy@<8cH9A8`h8!`|N |B|}x!<8cDH9!<_x8B ,|Cx}N!|cyA <8cDH8xH<8cDH88`X8!P|N  (A}N 8`N |B!H>8<_By$ CX8!P|N K|B8` `!H7Q88 `|}xHDA8d| 9 =x;BX<_8!P"x̻|N ||~x! /A/A }N!xHX8!Px|H<|aB;!|}xc H==?9)x|~x  ]/@ HT AH}/@H08cH6-~H5]>/A8/@9=8^~ }iD}bEHxx}N!h8!`xa|N |B|~x!/@<  /@<8cPHA^ x }N!|xX8!P|N |B|~x!|#x/@8  /@<8cHA^ x }N!/A X8!P~|N ||~xB!c/A <_BvAH38X8!P|N |B|}x!H;=<_0}`8Bu8cC X8!P|N K|aB|~x!|#x /@<8cH?/A/Ax}N!<_1<| x8Bud^ h8!`a|K|B|#x!<_|+x8Bt؀ 8@AH-|by@ X8!P|Cx|N ||#xB|yxCx!8 K <_8Bt|{x@0@H<_8Bt@=?ɩ*(hH\<_8Bt@;Z| yH;@T||t/A\W>xHG/AxH/||t8A@;/AA88A@|@|t/0@A;|t/A/1@A;|t/A/y@0/@8<8a@;8PH./Ad/n@0/@8<8a@;8TH./A0/t@0/@8<8a@;8H.i/A/f@0/@8<8a@;8H.5/A/o@l/@`/x@8<8a@;8XH-/A/x@8<8a@;8\H-/A\Hcx88Ho|}x|#xAHA8BAĀa|@@@c+@HET`bH <_Ti:B}) 4Tb/@A|@y;A;Hcx8HL%AHA8BAĀa|@@@c+@HDT`bH <_Ti:B}) 4Tb/@A|@T<_*(OB&W/A/ACx}N!<_8`8BtlZ HD/A8;P<ex8xH-#xH3#xH6x8H48`8!|N ||}x8`!H.} @| 188}X8!P|N |B!H5<_88BoC X8!P|N K|B|~x! /@<8cH9/A/Ax}N!<_x8BoX^ h8!`|K|B|#x!<_|+x8BnЀ @8`HH)|cy@ X8!P|N |aB|#x||xx! 8} K|~xH>88xHH@@/A\<x8a@88H+QxH1xH4!8@8H25H(H>/A,/A xHW 8`HA8BAa|@@@c+@HAUT`bH <_Ti:B}) 4Tb/@A|@,/A/Ax}N!<_8`8Bnd] 8!a|N ||}x!#8@8`H,8a@H)=||x8cH+18@}H+ex8!p|N |B|}x!H1<_88BlC X8!P|N |aB|~x!|#x /@<8c8H6/A/Ax}N!<_x8BlH^ h8!`a|K|AB|#x!?|+x8k||x;$ A <_8BkAHq|cy@> 8k@ H\<_8Bk@@8@8`|c(|B!+A8/@8@A$|+xH<8cH58`H0/A$xH.qxH1 <88H/8`h8!`A|N |B|~x!|#xH|cy@l <_8`8BjAT/AHx?H-;hxH0}x8H.<<x88\x8H-8`X8!P|N |@&|ܐB|#xA|{x!Cx; :8 K||xH:q#xH;}+@H=qT`bH <_Ti:BÈ}) 4Tb/@Ĉ|t/-@;:H/+@;=+A <_U):Bx}) 4p@L/A<x8a@8H&YcxH,cxH/)8@8H-=cxxHQHx88H3|~xAH9i/"@d/AHcx?H,);ŸcxH.x8H,<<cx8h8Ŭx8H+8`HA8BAa|@@@c+@H;T`bH <_Ti:BÈ}) 4Tb/@A|@.A<@AH/@; /A/ACx}N!/A,x9 A !J})<_:Z8BjHxA|~<_z8BjZ 8`8!a|}p N ||}x!8a@H5||x8cH%}8@}H%x8!p|N |B|}x!H,9<_88BfC X8!P|N K|aB|~x!|#x /@<8c@H0/A/Ax}N!<_x8Bf^ h8!`a|K|B|#x!<_|+x8Bf |}x A <_8Bf AK|cy@ <_8Bf @t8@8`|c(|B!+A$/@8@A8`H@/A$xH(xH+}<88H)8`H8`X8!P|N |!B|#x|~x! x8< K|}xH588x8H?|zx|#x@L/A<x8a@8H!xH(xH*8@8H(xxHM]H`H5/"@d/AHx?H';xH*ix8H(}<<x8|8x8H'}8`HA8BAa|@@@c+@H7T`bH <_Ti:B}) 4Tb/@A|@/A/Ax}N!<_\|8`8Be(\ 8!!|N |aB|}x!<8$8a@H e8a@H};|{xxH!mx8@}H }8!a|N |B||x|#x!H(!<_88BbC X8!P|N K|AB|~x!|#x|+x /@<8cXH,/A/Ax}N!<_~x8Bb^ h8!`A|K|B|#x!<_|+x8Ba @8`HK|cy@ X8!P|N C8BCN #9)/#M KĀ8`/M 8`N |B8}H|<8alHO|8`|#x!Hu]X8!P8B]|N |||x8!At/@ Km|}x~/@ xKQ@8|ixxC8c 9)@/8A;K8|xX8!P|N ||~x!cC8B/CAKqX8!Px|H||#x!$/@|#xK|ix~9`9@@$|i| PUb89J|t|B}kBX8!P}c[x|N |aB|~x!|#x|#xdK 8c|t/:@|t/:@ 8d <_8B_A xdx}N!/@^d;/A bH~/;AP X@D KL@4 ܀I @$ ] A;/@D<_xdx8B_}N!/Ad8`H;/Adxh8!`a|N |!B|#x!??|+x8^\ ACd/A H[8`8B[H-/c|~xLܐ 8[ CA/ACx}N!8^\ 8h8!`!|N |!/A8^8B/^@$~H!X8!Px|HȀX8!P|N #|B}H|8/$AI8BI@e|jPN |#y|B|+x!p|3x;@/Ae8`H/@;!P/AL9@|t/rAA@/bAlA /aAX/A/ AH/fAL/nALH/uAA/tADH/vA@/xA@H8H8H8 H8 H8 H8 H8 H8~88@KU/9C@ @HAHp/8~8@88@K/9C@8uH@9@9J;@|t/ A/ A8 H 8\9@@H4~+A<_@A~+AUb:|BB4pA+7AĠA@/;9@TB8|K8BTB>A@A~+ATb:|BB4pA|+7AtA@9@TB8|C8BTB>A@HT;xxH4|zyAx8@H(;`xxxH8@x|DBH!9C/AXa@$xH8!|N a|#y||{x|+x!|~xAxxx8@KeQaDA |t/ @;;@/A|t/#@/@|t/\@Txxx8@K/aDAPH@xx8D8K!DPH;;|t/ A /@/|P@x8!p|{Pa|N ||#yB|3x!|}x|+xA<_8B8B|t||t(9@Ā[@ cxHas;T 68 @D<_c 8B8B7;A|t||t| H9A8@H@|t/$@@{,xxfx8H9/8`@pW 6|BH/[@;;{,xx88@K/A$`8` p0t4H aT8xAH;(LHPAH ŀAp(@@ |t/]@t/AH/@h{,/A<88{tH88` 8^4[0Ht8@|P^H/\@xx88K/@8|.Hx|t/ @,/@ 84sA@H8[8B[PH@/@,8|.8;;[8B[H<8cH1/A(<_8B8B|t||t9AD[@P@ cxH[T 68 88[8B[08`8!|N ||~x;8!cA H X8!P|N ||~x!T(4T 7;A4<_8B8B|t||t/@7;@/@/8[0 8;4A<~x88\H @@|t/#A,A/ AH`/{@X;HP;HH/A@}+@HT`bH <_Ti:B }) 4Tb/@ ;@A|cxK8`H<~x88pH)K܈|t/{A A/\AhK/}AK;K7@^@@|P[8B[/A 88`Hxx8@8K=A@/@|t/ @/@ 84|P/A[8B[[8BA cxK݀[89`;TB 6| .@~ 8[!@8B[|IP}=J;;>~ Kx}"P|];;Kd8!|N |+y|BA!|zx|#x|3x|;x}CxA/A@|#xH9|ex/@088|\* 8^($^,88|8xK/@d^0|t/"A8/A~,<88$H 80 84H/A 88`HxK8`h8!`A|N ||}x"!0H HAL@@,8a@Kx8`|P88@K9/Aȃt8a@K 8!x|N ||}x!HɀX8!P|dxx|KL|!8@H@K1h8!`|N |"|B8}H| @A(0^4DALX!\@AHPTH/@48a@HU/@$D8`/ A(<8a@8ǸH~AH98`8!a|N |B|zx!cH1|~y@/@[8BA cxH?W 6|(Px8} T 6H3A[8@Cx8B[|.88;Z ]H|~y@CxK5|~y@p/A<Cx8H8`HLCxH|~y@<CxK|~y@,;|P}) [|XP8BI 8`x8!p|N |a|~x!CbH|cy@d/@TxH|cy@DxHQ|cy@4x8xgxx|0PH]/A8`h8!`a|N |a|~x!CbH|cy@d/@TxH e|cy@DxHQ|cy@4x8xgxx|0PH/A8`h8!`a|N |a|~x!CbH|cy@d/@TxH |cy@DxHQ|cy@4x8xgxx|0PH/A8`h8!`a|N |a|~x!CbH|cy@d/@TxH %|cy@DxHQ|cy@4x8xgxx|0PH}/A8`h8!`a|N |a|~x!CbH|cy@d/@TxH |cy@DxHQ|cy@4x8xgxx|0PH݀/A8`h8!`a|N |a|~x!CbH|cy@^8+@/"A /#@hxH |cy@XxHe|cy@Hx8xgxx|0PH)^8+@/"A/#A8`h8!`a|N |A|~x!CcBH|cy@^8+Al8x ||#H |cy@HxHU|cy@8xxexGxx|0PH]^8+@8`h8!`A|N |a|~x!CbH|cy@l^8+AXxH ]|cy@HxHU|cy@8x8xgxx|0PH^8+@8`h8!`a|N |a|~x!CbH|cy@l^8+AXxH|cy@HxHU|cy@8x8xgxx|0PH ^8+@8`h8!`a|N |a|~x!CbH|cy@l^8+AXxH |cy@HxHU|cy@8x8xgxx|0PHe^8+@8`h8!`a|N ||~x!#C8 +@/!A / @HxHe|cy@HxK|cy@8xxx8x|0PHHH%|cy@8`X8!P|N |B|zx!/,@TH|cy@CxK%|cy@t/A<Cx8THlCxH9 |cyApH@^@ xH6̀+^T 68@|.}B ^;">A<_W:8B| .|| N tdT$4ttttttttttttttttttDT^@ xH5^8>TB 6| .i8Z  [^8B^}@Z HZxx8;|(PxH5|cy@Ȁ^W) 6|I||I}@BJ})I 8BJ HTxx89|(PH4|cy@XAZ}@ |@PHt^@ xH4ɀ^8>TB 6| .i8Z [^8B^(xx88@|(PH/@aT8xAHLAHmAp>(H@@ |t/]@t/AHH@,/A<x88bH8@^408 HP|P[|BP}@8JH4xx89|(PH31|cy@AZ|@P}@J|P/ @^A xH3AW= 6||P8{dxT 6H&݀^8B^}@8|.J j*8 ;[ {H^@ xH2ŀ^8Cx>TB 6| .i8Z  [^8B^H!|cy@Ԁ/ApZ;x,HYxHL|dx8} }N!|}xxH/A<Cx8tH<Cx8HpCxH|cy@L/AHCxK|cy@0/@CxHa|cyAH/@/@^}BJ|P |P H<Cx8H<Cx8H<Cx8H<Cx8LH<Cx8pH<Cx8H<Cx8Hx<_W:<8B9;8|.xHCxxHHCxHq|cyADH p0` t4H|ixH(<Cx8H 9 H9 08!}#Kx|N |B||x!#|x,(Pxx%x8BH/QA |t/ @;;@/0@8 H\|t/+Ah/-A`x|PHU/|{x|zxAx|dxxH80C|}xxx8B]Hр]|zx8B/]A xH/A|^8\| Y0HxxH|{yAH;PCxHexxxH188|zxH xHY8ApHɀc/A(/A xHI8 8` H(8||P@ | H  8`|H8^8 \Y0^|Bt9"+]A<_U):8B<| .|| N |4xx p8H 8H8H8H8H8H8H8 H8 H8H8H8H8H8H8@\|P/@d|t/@88@H88@H8 |t/=@Ѐ|P/@88@H8 |t/=@|P/@88@Hp8|t/&@h|P/@X88@H<8H8|t/|@,|P/@88@\8@\ 8`0H88!H(|t/q@`|P/@P88@"H,|t/e@4|P/@$88@#\8@\ 0Hx~PdxH A|zyAx8@H,;PxexxHY8A@x|Dx|BBHaA|zx|tW>+@HT`H <_Ti:B8}) 4T/A8HdzPxdxH |zyAx8@H,;`xexxH8A@x|Dx|BB HA|zx|tW>+@H=p`H <_Ti:B8}) 4p/@h/_A`|P 0D|Bt9"+AH<_U):8B| .|| N P(((((((p(((((((( /@<88coH5H /@<88cpHH /@<88cxH|cyAh/@p<88ctHH@ /@L<88cpHH  /@,<88clH|cy@|H 8 8`x8!p|N /|B|ix!@P|t/0@@|t/xA /X@(8c88@H'!8|cyAt8Hl<_B$H 89)/|HPALiUb>+ATB:|BR4p@}`t/.A/eA/E|HP@8|xh8!`|N  @|B}H|kx|@xC|Bt9"+MAdA/|@(|t/&@;|t/@8A`8A8@<~x880H)H9a`HĀ8/AaL8H!0/A0|t/<@88L:}4|t/@l|/Ap8H|.80x~x899!49A88:`K/aL@HH;; |t/>@;;; |t/&@$H/A~xHHA;:@/A(aP8@@8HHH @;; |t/>@;;; H/A~xHHD/AD/AT|t/@@D|t/1@4|t/@$8@$8P:4H<|^|.8Dxx(x~x9!49AH8Km|uyA44/AL};@4U":T:})P|P})|B}`8B 9kB4;{@P;{A8L/@/A0~cxH/aL@L~xH<|ex8THdA<8aL~$xH/@~xHy<|ex8H488H08`H/A 8H%/aLA 80P/@lA<}{x8PH/@~xH<|ex8H8@H08`H/A 8H/aPA 8+A<_B^,T:|BR4pAlD}+t9$/AL+ATB:|BR4p@ |t/.@,/.A$ I| t/@/.8`@$<<}Cx88,8Hu8`X8!P|N 8#99@} t/A4/.A,} t#J }+t|B/9BA /.@܉$} t/A4/.A,} t$H }+t|B/9A /.@ @@H|t/A 8cH|t/A |t/A88K0/A 8A@/@8@8`M @ 8`N 8`N |B!HEC9"+ZAX<_U):8B<| .|| N $X ld|xPD,L4\<, x0(@htH 8l`Tp8888888888<8cH<8cH<8cH<8cH<8cH<8cH<8cH<8cHx<8cHl<8c H`<8c(HT<8c0HH<8c@H<<8cPH0<8c\H$<8cdH<8ctH <8c|H<8cH<8cH<8cH<8cH<8cH<8cH<8cH<8cH<8cH<8cH<8cH|<8cHp<8cHd<8cHX<8cHL<8cH@<8cH4<8c$H(<8c0H<8c+AH<_T :B?x}) 4pA,xx8@H=/8`@`@|PH 8;`@!@8@/A0]d/AHAB/@/ADZcxx8!pA|N /|BA!P|+x|#x|3xA$<cxx8Ƃ|8H]8`HĀFb/@ |CxH|dx8cxKA/|~x8`AP7AW:/[d|};d@ HxxH|dxcx<H/|~x@(<8a@8H cx8@8Hݓ[dx8!A|N |B8!8H]9 |`yA4|xH)|cyA|~x<_9 B@> X8!P}#Kx|N |B|~x!H|cyA|~x<_8`BL@~ X8!P|N |B8!@/|+x|xx|#x|3x;a@wx@T:8cH|{x;@0W:8;|}.H!|}.C8BCA8W:Dx|.xfxxH|yxCxH=/ACxH)HCxHHu|dxCx8H%/@x|x;]8B/]AT /A/Ax}N!}/A<_B<$AH1xH 7@A cxH8!#x|N |a|yxB|#x!|3x|+xC8:pf;a@~xHq <|wx$x~óx8(x~xH)|}y@ /@W(4H|tx~óxdxx8H|}y@dxx~óxd;;zAHL!\hHehA;U pAp@@0|t/a@ <8~88H/A/@:Tv=H >/AD=TvI;; ;Z;{8BI@X/@d~óxH~óxH<88>|{xH8~xHe|exAPA@8H@@ xH^L88B^L<_B1$" H\8H@@ xH^LWF>8W>W>"9"B<_9i 8 B1$L"8/A8@(^ @^<@!= |J 8`h8!`!|N |||x|#x|#x!HX8!P|exxx8|H|A|#x8|+x!|zxe0{{А$ 8a@Hi8@x8HDx|exhxCx8T~H|}x8a@HH8!@xA|N |A||x|+x|3x!@AC(T8|./@8HLc$/AH|~xH \(x|.H={x\(|]H%zh8!`A|N |B|;y|#x!|~x} CxD|+x|3x8A8@@|x (8k8,Hյ|ey8`A,/8`A /A<x8sH8`X8!P|N pA/@,0H@@8N #(T8|H.(|BK||#x|+x|}x!Ki|dyA$X8!Pxxx|KX8!P8`|N |A|3x8|#x!|zx|+x |;x}Cx$8@H@@|x|PW<x|*|xCxxhx@K1x8!pA|N ||#x|+x|~x!8Hi|dyA,X8!Pxx889|K(X8!P8`|N (,N |!B|#x!??|zx8҄|+x @(Ah8@xH@fx|dxCxH|~y8`A@^4/8B^4A/Ax}N!8҄ xx8!p!|N |@&|aB|#xA|}x!H퀼<?8p8a@xH;x8@H!8@/A0< }+9A8B/@.A H.<x88LHm;̀/A, ^| 9AxH/@A<x883H8!8`aa|}p N |B|+x!|#x||xHx88@8dHA+d@<8H <88xx8@;H<x8xH9x88d8`fH<xx8@8o8H)88!0|N cC48B/C4M H́c|B}H|=*K49)8BK4$ N |8!K |`X8!P|N |B|xx!<|#x8c-8l|+x|3xH|}x/@88<cH;/Ax|@^@x#xHy/@d/AT4\^A8TB:8}bT|  K|+ K+9kB]]|}HP;;/A/@X8`8Hm88@ ||xC0$C,8a@HDx8@#xH9Dfx||dx8|T~HΝ|~x8a@H/A0xHa/A<xx8nxK 8`H|Tc88cH8|(4x/A(}hC48B/C4AHm}xH89}p|  K|+ K+9kB8zH]$x}H]|xH8!@|N ||~x8c!Hu~(/AHeX8!Px|HL|B8l!<8c*H/AD|~x;t~C48B/C4AKi~HA/@̀X8!P|N !|;y||}x|#x!|+x|3xAC8BC/A }H /ALD|t|Bt@$xHq/@^ ~>HP/@8`H|~xxH8cHx~H~>^ h8!`!|N ||#x|+x!/A\D|t|Bt@4xH/@$8` H/@8`X8!P|N |a|}x|#x;!/A@D|t|Bt@cxH/A;/@/8`AL /A]8B]/A }H5~HxH8`h8!`a|N ||bx!#8@8c9)"H|cyAc K8a@HY|cy@h8!`|N #܀C9)8BC#N /@ /@8`/M 8`N ||~x|#x!H-9>~C8BC~H@8}}H58HDx@0} 8^|]^}]x|H8} 88@8^X8!P|N ||#x|~x!H 8]=@8~~HyHD @4~x/AHy x]^|]^H>^"9)/"A ~HUX8!P|N |B|~x!C"9)/"AXc /A/A }N!^b/A<_BAH~Hq~ A/A8/@X8!P|HXX}8!P|N X8!P|N A||#y|~x!c@8HX/@HxH/@8cHu8~H88x~HH /A(/@cxHHcxxN!h8!`xA|H||~x!C|t/@@H=/AxH)cHxHH|dx8xKрX8!P~|N |B|}x!䐃D8BD^8B/^AT /A/Ax}N!~/A<_BxAHUxH-/A(/}@ H1H }N!88]8]X8!P|N |B||x!C|t/AH|HY|~y@<_BH,8~H1x}H]8|/A(/|@ HUH }N!888X8!P|仁|N ||{x|#x:!PC;A@|t/@@K/AcxKـcHcxKHy|dx8cxK;;;9/A|AX:@:V:@8;|#xH |zx@,W:;|W.|Z.BHCxHY|zxxH}W:;.K|[x@(;|H|t/@||XJAxcxH/@Dx]x;x{x|`HxH}E7|@8@A CxH~}8!|N |!8Al||DxK9X8!P|N |A||x|#x!C|t/@@K/AxKcHxKH|dx8xKCx8@Hɀ\x9c@(<|H|t/@||KJAx|"Hmx|xxHI/A\8 ;8B\|ٮ@CxxH|x8!pA|N ||}x|#x!c]xA,|/@|CxH|8|x}H]||t/A H{Q}]|AH/cA ;HW<xH}||xH}Q}x/AH|ax|H}xAH}!xH!xX8!P|N ||~x!/A(/c@ H{H }N!8X8!Px|H|||~x!He/A(/~@ H{H }N!88^^T8X8!P|N |B|}x!^/@8/AT /A/Ax}N!~/A<_BAHzxHHY9 <_#8BB# C#}Hl~/A<_BAHze <_8B/B^A/Ax}N!8 X8!P|N |B||x!|#x; ;/A$<xx8H8cH=KԀ`X8!P|N |!8Al||DxKuX8!P|N |B|#x!<|}x888Hy`X8!P|N (|B!|+x|~xA/@p@<8մHрxTK<x8h88H||cyA,<|fx88hx8H`<x88T8H|]|cyA|dxxKlxlKE|dxxKQX8!Px|KXX8!P|N |a8|#x8!||xH}x8@H1@/^@88@xH @/]@x8@H@;`/]A,/-@;{x8@HŠ@/]@|}PTc<8cHw/|@Wc:Hwѐ|H 88x8@ Hi@/]|xA /-@,\x8@|TI<8B| [.\H)A@/]A|t/-@ |^xHԡA@/-@/]@4\|TI<8B[.9bTB<@<|K.|Hx8@H@\ <@@(TB:K.\ !@TB:|B"H TB:|K.\ TB:|B\ 8B\ H\|TI<8B}I[.\x8@H%A@/]@x8!pxa|N C9`T>9 P@8C8B A9)PA/@PH 9`HD 9 @@4CU":|R.|BR @A @@9)@A؀ic/L }c[xN ||}x!cHt݀}/AX8!P|HtX8!P|N |a/B|+x! |wx|3x;@;Px@T:xHu||x/@I8x8BBa::; ;|t/A8@;`Hm@/%|`a@8@HMA@/%|`aAp/*@ 8@;`H!|H+A!A+A<_U):BH}) 4pA8c88 HрA|}x|t/$@d88@:|xH/|@D7=AX/A@HH8x@x|xxH /:A<~x8`H\@+A\!A+AP<_U):BH}) 4pA4a88 c{8cHa8@H|@/hAA /LH/l@ c{a8@H|s`@/A @Pa@9#+A<_U):8B| .|| N xsb@s`A`8;H8|~xHy<<8WPx8WxH s`@Ȁa|t/A8@Hy@A/^}"!@,||t/A}#Kx8@HE|@/]@,a|t/A\8@H|@/]Aa|t/A(8@H~ݠ@/]|@HP<~x8WH8;H~8|~xHx<<8Wx88HxYHs`@A/]x;ZAxWD:@8|#xHp}89!P| ||x8@ 9)|.8BBHxHo||x@$|}PW:|i|@88BBW :;9|\.8B|\.a|t/@@/@/x@>x/A8`@4/x8B/A`@ /Ad8cA8PA xHn8`Hx/AD<~x8H@<~x8WH0<~x8WH <~x8X8H<~x8Xp8Hu8PA xHni8`8!a|N |@&|/BA8!|#x|3x:`::: :@:;@A$<|#x}kx8RP8H|8`H f88Hq8|`x|dx}sxK /8`A a/@@Tc:;Hn)|vx@$9 |bx";8BAm8;9Hq|~xa|t/A t8@;H{}|a@Hl /AD;BH|t/A 4xxH{9|}xaBHk/@H @/%A8|t/A dx8BHzA@BA H ̀a8@HzՠA@/%|`aA/*@8@;Hp+Ax!A+Al<_U):B }) 4pAP8c88 HyiA|}x|t/$@(88@;|xHz9|@+A`!A+AT<_U):B }) 4pA8a88 8cHx8@|{xaHyՀ|H;`@/hAA /LH/l@ ca8@Hy|A@9"+AL<_U):8B@| .|| N $,,,,,,,,,,,,x,,,,,,s@A|bPH<_" <_B H`<_:`i:" <_B Ht<_:`i:H<_:`i:" <_B HH<_c" <_B :`i: H(:`fH :`sHc:`cH c:`[|t/A|s@@8BxHx |}xaBHh/A|/@؈|t/A893+A<_U):8B| .|| N @d/@;`x|t/AD8BHw!|}xaBHg/@(A7{|baA||t/@s@xH/@;`;!`#xKYaa|t/AH8BHvB|}x#xK/A(A7{|baA||t/@8a`K A0s@,x| PHmW:;C|zx8BC|v.Hx8BHvs@ȠaBHxH8+@;`/;!Pcp!A(~}bt9"+MA<_U):8B| .|| N 8dddddddtt/@ c:/@cs@A8W0Hl/@(: H /@: /H/ @h8O8H4sATW4H$sAD8AQ@4Wn:Ab8BA|t/A 7{@s @A|t/xA /X@8;s@HW<|BbX8!P|N ||dx|~x8`!H~/A /@xH ~X8!P8c|N ||~x|#x8`!xH]~/A /@xH ~/A X8!P8c|N ||~x|#x8`!x|+xH> /@xK>IP@8x;Hcqx|cK|~x|dx8`H>HW<8|i8cKM|~xX8!Px|N |aB|}x!|#x|+x /@<8c?Hg/A/Ax}N!8x Hii/@/;AcxHYm|~x/@<_BH,8~H[Adxx}HZр]8|h8!`a|N |AB|{x!|#x/@<8cHf8`dxH !@{/@ /@l<_BAA8HZ|}xH48zHZq|}x/A/AHYcxHh)8 ^/A8<_[BA 8|Ѯ8 8HTW]<@@x8HY]{|~x/^8A8|] h8!`A|N |aB||x!|#x/@<8c=\He}8`xH @|/@ /@|<_BA A8H8|}yAH<8{Hq8|}yA܀/A/AHXixHf8 ~</A8<_|BA 8| ٮ8 8HdW}<@@$x8H8|~yA@/~9`A9`9 |]8~ ><8|xh8!`a|N !|+y|B|{x!|#x@0/;A$/A|#x;/@ W+A|@t8|HxxH\e||@||x;A8h8!`A|N |aB|#x! /@8`HN=|~xHD}8cHN%8|~x8cT 8BȀ[ h8!`a|N |B|#x!?8D A/A</@ |#x}N!^ /Ax}N!88` HM-9`8cc /A>^}iH~X8!P8`|N |B|yx!/A/@/A <_8B̀BYH;`;;@@,x~8@;{HY;ZA8z;`HL-Yy|}x\@,x~x;{HY;A8x8!p|N cHK$||}x|#x!/@H}xHU|~y@(xHK8x|~xHXuxxH X8!Px|N H ||~x|#x!/@HX8!Pxx|H|a|#x|{x!DAx8b;dTc:HJ̀9@||x@8|kx^UI:| ./A ;9k9JAԀ~/AHIՓ^>TB:bI.^8B^h8!`a|N D9`PL $Ub:|H.@8|I.N 9kPL K|B}H|<8 K|B|}x!HAX<8!Px8컡|Kh|B}H|<8K|B}H|<8Kd|B|}x!HX<8!Px8ꀻ|K|aB!?HI(;@(;(W:;=|bH.HAh8!`a|H|aB!?H;@(;W:;=|bH.HYA?;}/AHG8?;8@̐]]@0;W:=|bH./AH;A?;̀}/AHGI8?;8@ؐ]]@0;W:=|bH./AH;A?;؀~/AHF88h8!`a|HT||}x!HnX8!Px|H|Ba!?;L/@`H||xHG̀/@@H]~HU<_;bP<_W 6;8BH1/ } @xHG]H|~y@\8`8HH|~y@<8c+HR;L}HGE<_8BH}HG HGE~xHYh8!`xa|N |aB|~x!;;;/@xxHQ;/ @܀ /@0?;H}HF< <xH}HF]?}DHFq<_8B@AB@8}DHFh8!`xa|HD||AB|{x!H}|}y@ K|}x8{+?@$Hg}; |cyA|H<_;8B@@;W 6|.@A/@xxH/AX~^>,c8B9)^|>,~/A h8!`xexA|Hh8!`8`A|N |}y|B!AH]|~y@ K|~xxHIC/ $@$| PX8!P|HB}) ,I| P ,CiiI 9k8BiI <_B8A<<_T 68B|@@ X8!Px|HX8!P|N |AB|{x!|#xH]/||x@h8!`xA|K/@ K||xcxH%9~|}x/ Al/8@=?T 69)|BJ@@<_T 68B|.@AxD=xx|B,| P|,H<+?@H}d[x\|@P|B\Hd8/AXx8 h8!`A|H@xK||yA(@@|xxdxHAmcxKx|xh8!`A|N |B!H|~y@ Ka|~x /@?}HBE<_bĀ /@/ @8 xH=}HA /@L8 8`K Hc|}y@<8 8c&\HM!8 8}J| ~8cB~^ 8B^ X8!P|N |B|}x!H|~y@ Ki|~x^ 8B/^ @@?;܀}HA5<x8 HAX8!P}|H@X8!P|N |B!|{x??!ycx8PHC;x;]<_<8B8% |.8aP; >,^($8H>-;cx8PHC]@cxHrm/@HyՀ\(8B\(<_BT](8B](X8!P|N |BT 6}H|T|4B!|#x|\|~x|+x| "=x@ B|\=xdx"|PK=?x9)dxI|\I|\"I|\|h8!`|K|BA|{x?_!|#x;A|^/@KY}~ /@<_W 6 8BD}~})I@A` 9 ]|^ ]|^"]|^"Hxh<_U@ 68BD9)|.c(hH |x]|^| PK5J@}IcBZ|^8cxxK|^/@9@ 8`8@48[09"8B/AD9J9A/@8`?H]8?8|cyAT<_W 69"D|^|H.b}GB5J@ }"Kx}I|.||xB88|xh8!`A|N |B;!<_W 6;8B~0;} H/ @??;;}He|HYX8!P|N |ixc |B}H|/A<@`BM ===_I/A( |II HJK|Hx8!pa|N |B!<8cیHa|~y@@<88cیH:<8|~x<ЀcH<8cHhX8!Px|N |B!<8c Ha<8|~x<PcTHu/A(~/AH7~/@X8!P|N |A|}x|#x|+x!K||x8`H7|~x8a@HG<bp`M= |a)B?|6p|P@PA@}bD~|@H^@@ H8`8Hx8!p~A|N ||~x!K8@|ixc/AL@0/@ HX8!P|H5|bxc/@X8!P|N ||#x!K5s |~xA /@sA/@psA|/Ap8a@HE^@B} PD!@^B|@P/AD@<xlI8BIY8BYatK<~ 8D8a@H<<8`8\8P89xH=-/A <<Cx8x8\Hx/A$+A/AH/A <Cxex88H<xclI8BI8Y8BY K<8D8a@H,Cx8@8H:H$/@L/A@$<8a@8DH,iCx8@H^/@H/A<Cxex8K䀛xH|~y@4{H4U<<|ex8Cx8ƥp8H:58`HxCxH4ŀ|}xCxxH21 /@<8cH <8c8H2)x|exCxH1CxxH/H<8cH88`8!a!|}p N |B|}x!|#xH3y<8|~x8H)8@/@d;8@8 xH8A@|ixA<|t/@,}/A |bxHAc/@8@h8!`|Cx|N ||}xB!c@H,|xAB@xH1}8@H.i@<|dxxH./A<x8H;}xH]xH0]"9)/"A }H3mxH*Eh8!`|N ||~x!C@H,|xAB@^"9)/"A ~H2ـX8!Px|H)|B|}x!/Ah~ /A KH<xcyK^"9)/"A ~H2IxH)!/@X8!Px|H(8|bx8`+~L /8`L 8`N 8+~Ad8`N /A,8|b6p9 |`x|BKx8`TDN 8`A<8@|k6p|ifp}kx8|bxTBUk})x$8`DdN 8``cK|!|#x||xW"Cx|"T<8H6U@x@D^T@>+A|@t8~HxxK|~@|~x;A8|PCx|"H5h8!`x!|N |B}H|+A|@t8@@Hx8@Ky|bx@xA8`|t/@h8!`|N ||~x|#x;!^T@>+A|@t8`@Hx8@K@@x|t/@h8!`x|N ||~x!CT@>+A|@t8c@H8@Ky|~h8!`|N 9#9`}"Kx @@ @@4|#xH,/@ /|CxM 9k8B/@}#KxN |#y||~x!AD^;T@>+A|@t8~@Hx8@K|~/|~x@Āha@8!`|N |#y||~x!@D^;T@>+A|@t8~@Hx8@KM|~/|~xAĀh8!`x|N ||+x|#xx!8|~x8@Hj@/@ xH!!x8@|dxxHjm/A @h8!`|N |A|zx|~x||x!|t/A\T@>+A|@t;`@Hx8@KU|{xa@H|}xK@xxexH"HxxK|/@8|zPx8!pA|N |A|zx|~x||x!|t/A\T@>+A|@t;`@Hx8@K|{xa@Hm|}xK@xxexH!=HxxK|/@8|zPx8!pA|N |A|zx|~x||x!C|@t/ApT@>+A|@t;@H8@K|}xa@H|~xK]@CxDxxH }HxDxKY/Ax+A|t;@Hx8@KU|}xa@H5|{xK@xxxH HxcxK|/@8|zPx8!pA|N |+y9@| A(#d} t}bt@P8c8B| /Al#/A/@TH8`/A}#KxHU">U`>}@PK$/@8@/A}"Kx}BP}CSxN /||}x|#x!;A]T@>+A|@t8}@Hx8@K|}^|}xT@>+A|@t8~BHx8BK|~@|~xAB|bP@/;@|8`h8!`|N /||}x|#x!;A]T@>+A|@t8}@Hx8@K!|}^|}xT@>+A|@t8~BHx8BK|~A@|~xBA0|CxHa@aBH@aBAB|bP@/;@T8`h8!`|N |BTi}H|T`~8Bm|N |BTi}H|T`~8Bm|N |BTi}H|T`~L |p|XPT>N 8@/A8B/@|CxN T||/ M 8`N |B}H|T`~+@H-T`bH <_Ti:B̀}) 4Tb|THL<_T`~Ti8Bht|<_8BtT(4|Kx|<_8B T:|B.8pTB|0TX8!P|N |B}H|T`~8B T:|.T|c0TcN |@&|A||x|#xA|+x!\/ |`A@/@/*8`@,/*@Ԥ/*A|y8`A .AxKm|}x/[Al/?Ad/\A\A0H;|/ADAAxKiHx@>xA @@ @A@@Kx@p/]AlAL/]@HT/\@;8`AD/{AK|}xxKH8`@;{;Kx8!pa|}p N |BА|#x!|zx|3x|;x}Cx}7Kx*;; ;H;@@@~+@H&T`bH <_Ti:B}) 4Tb/@xA|t/{@;;H/"@ ;; /xA@@t|t/"ApA / AL/ @D/ A|| N 8L$```````````````````````````````````````````````````````````````````````````````````````````````````````8\}>KxHs`Ax8\;Hh8\}>Kx8fHX8\}>Kx8nHD8\}>Kx8rH08\}>Kx8tH8\}>Kx8vH;;@X8||Ph8!`a|N |/!|{x|#x!P;A@@Tc:H|zx;;@(W:;|d.|"Ke|~;Ax;H||x|~x@0W:x;|.|y.K8 |;A@8H 88@A CxH8!x!|N |!8@HA@T@>+A|@tPH8a@8PHaQx8!p|ct|N |@&|zy|B|#x;A!@(|#x]x~;Hq7||;@xHY/|yx@ CH ;||x@wxw:H;{{+@HqT`bH <_Ti:BĀ}) 4Tb/@cxH|~xH;.@\x+@HT`bH <_Ti:BĀ}) 4Tb/A/@|t/\@A xdxxH8 |;;AA8H 8x8!p#xa|}p N ;`|B!|zx|#x@<<_"|#x8B H@/@;{A@h8`8Hq/|~x@Px[x8@8D8`;H@<D`8`x8H7{@H/;@Lx[x8H;xH1/AAH/@ |\;7{@/@;x;H/|yx@ Hp|}x;`@@8L;xH|~xHAL;8BALL/@T~+~AH+@HT`bH <_Ti:B}) 4Tb/@H 8 LL/@l|^b+~A\+@HaT`bH <_Ti:B}) 4Tb/A$!L/@|^J|t/\@L/A,xxH=AL8 |AL;|\;;{AA8;H 8HQ8|~x #x8!px|N 8H|@&|AB|#xA||x!|+x|#x\|t/@ |`H/@/*8`@/*@̌|t/*A/8`A.AHA8T>+@ HFH=?Tb:)( |Bb4|bxHT>ABH x8BH AaBHͰaB/[A/?A/\A/\Ah/|@xA+A|t;@Hx8@H |}xBa@A|H]BAl|/@H\/|@xAP|xT>+A|@t;@Hx8@H )|}xBA@A|/@xxExK%/8`@\\8`|@t/AHT@>+A|@t8|@Hx8@H ||||xK/?@8+;A|@t8|@Hx8@H u||||xK/[@|@x;.p@`A8T>+@ HDH=?Tb:)( |Bb4|`xHT>@;H8xdxH|~xHx8@H Aa@Ha@^|@t/]A,/A$.ALA8TC>+@ HD]H=?Tb:)( |Bb4|bxHTB>AD;H$x8DH ]AaDH-aD|t/-@^8`|@uA.ALA8TC>+@ HCH=?Tb:)( |Bb4|bxHTB>AF;H$x8FH AaFHaF!DA@@AF@@,F@AH@@KDA@@/]A/A`/]@;K/\@8`|t/A+A|@t8|@Hx8@H ||^||xT@>+A|@t8~BHx8BH|~/|~xa@A$H|}xaBH8`@KBA8`x8!paA|}p N 8c|t/?A,A/8A /*AK8+A8|xN 8 8@8ȘC CN a|+y|||x|#x!@|#xH)|{x\|{AH\8 Td<@$|#xH|}xHH|CxHQ|}>\H@|B@ }>HP});8BB8||h8!`a|N !|#y|||x!ACxHI|yxH; Cx$x8@K\|c8cAH\8 Td<@$|#xH|}xHH|CxHU||xxH/A8 ;|ٮ\8B\@Cx$xxK݀||x8!p!|N |#y||~x!@;ATT<A8~8 @$|#xH|}xHH Hi~^8|ᮀX8!P|N ||~x; !cAH8@8ȓ^ ^X8!P|N ||#x|}x; !Hm^A8]H4/A8}}HUHxx8H8@8ȓ^ ^X8!P|N |; |#x|~x!A |xH^|t/@DxHI/AxH5cHxH%H|dx8xH1~HI}/AX/8c@}H$H}HM~}N!]88B]H@/A8ȓH8cHŀ]}8B]}H8^8^X8!P|N ||~xB!c|"H-/A<x8H<x8|X8!P8|K|B8}H|<8K|B|3x<!8cpHP <x8{tPTH<8cpHa/A|t/A ;Hx8@H5A|t/.AdT>+@H T`H <_Ti:B}) 4T/@(/@88.808!|N |B!p@!|;x|hx|#x|+x|3xA0T/@d<|#x|+xz|3x8qHHD<8cdH]sA$<Wdx%x8z\CxH9HCxHW/A4<dx%x8z\CxH <8cdH<8c,H|;xCxdx%xH|~y@ ?;Ox8@8 H8|}x+A A@A|t/A8<Wdx%x8z\CxHu<8cdHI<8c\H<<x8cz\H<<8|x8czhH5<8cdH 8`x8!p!|N |~x||#x!8@AxH e|t/{@(8@AhxH A|t/{A8@|t/ A =Hx/AhxHY|~xxHMxH<<88 x8H<x8D8H5/@;xxH-8`H8`x8!pA|N ||}x<en;!`d@/A8-|8aDCK;8~Hm8@}Hx8!p|N |@&|!B|}xA|#x!??8`8sȃd A<|#x8@H||x|t/e@,@.x@8<8 H |cyA4/AxHxHi<<8x8LHA aDH/@@|t/-@0x88DH%/8`@D|АDH@/A0xHQxH<<8x8 8H8`H8/A/ACx}N!AD8s8` Zx8!pa!|}p N |B|}x!|#xH;~+@HT`bH <_Ti:BЀ}) 4Tb/@Ĉ|t/+A /-@;|t/0@<_"H;^+A TB:|BJ4pA K;~+@H=T`bH <_Ti:BЀ}) 4Tb/@Ĉ|t/@(/A<x88H8`H8`X8!P|N |B}H||#x8o@|xx}TSx|+x|3x|;xD }Cx}2KxDd@T/AD/A0pA d/@|#xH|{x<nH|x$^ ;x8@H/|{x@ 8H< /@/@ <_8Bo@@^>A /Ar@@\(U (4H<_8Bo,@^9`@Hr@<|t/:@|t/:AA/@@9`/@<H@`r@,/AP/@Dr@<p@0 /A$H/@!@|[J|t/)@;H@||t/(@/A(rA <%xxndx~ƳxHC@|[;"@P8};H$xx||xHm/8x|xA/Ax}N!8o@cx @H铝c|~xC}/C 8BC@H}|{xH;HA/A$/Ax}N!8 xdx~x~fx8D9HH|}y@4D/A rAxdx%x~ƳxHA8`HĀH/A48d<_8Bo)^ I8BI>HH<_88Bo@^ pAp@/AH~/@xHa|{xxxdx%x~x~dzx~hx~IxH|}xx8!A|N |8@pB!p8|+x|{x}Cx|#x|3x|;xADCd@d/@ H/ @/Aw@A$cx$xxx8@}N!H8`/@H/A@/A cx$xxx8@}N!/@ /@/@ a@H/8`@s@0/A(/A<#x8LXH/Ahs@4A(&|t/:@@|t/:@0<c`|^888/&WH$wA cTsA 8Wcx$xxH*u/|bxa@@/Acx$xxx8D9H9!L9APH9aD/@<_BjHP/@<_BjH|8T8c}N!|~xH4YW > W>~ |bx D@D/@ 8H8H8Z#x;(bH-|xx@\ p@<D|t|Bt@ @#xHe/A;; A/ /Ad@8`8H8|~xHa 0x$x8T}N!T|~x/A`H3=8~ |bx HHA ,x$x}N!|~y@$<_Bj8`VHxH ^ |Cx8!|N |B}]Sx!|3x|;x}>Kx|yx|#x|+xJp@H/@t/@pA(<fHp@A$ /@pA<fH88`8|@8`TvHY8}H H p@@pA<fH/}Ad0dx8@}N!@|~x/A/A xH4H1~ ]T`@CHH,dx}N!|~y@0sA <#xxfexFxH;8`H~ x8!p|N |+x8H|!H98|byA/@ HM|`x|xX8!P|N |aBT!<9 8D`|~x|#x|3x|+x9A@K|dy8`A@xxxhxHŀx8!pa|N |!B|+x!|yx|#x|#x|3xH/;|zxAxHu|~x<dxW8C#xxx9 9A@K|dy8`A@#xFxxxHx8!p!|N |!B|#x!|+x}Cx|{x|3x|;x/@/A0/A$WWxaxH+/A\p@ /@ |HsA`pIA$/Ap @<_cH p@A<_cH <_c<cxDx%x8CH58`H8s@AP/@/A</A0WI#xdxxx~x9H'U/8`AWB:/@`/ApA4/A,^8B/^A xHM8;s@/A@4Hޭ8<_|~xBt$B C}H</@<xHڭ}^8B/^A xH̓^8B^xx#xHm/8`@H<@\8B\H$/@xH1}^8B/^AT /A/Ax}N!~/A<_Bt$AHxHɃ^8B^xxH-HA/\8B\Ah^8B/^AT /A/Ax}N!~/A<_Bt$AHMxH%/`TATv/@A</A0WHWIx~xa #xdxxH$/A p /@ }H$pAxdxH1~óxx8!p|N |B|#x!|zx|+x|3x|;x/@|#xH ||x/;A/@xH|}x<dxCx8;xx&x99 9A@KM|dy@ <Cx88p|HA8`H @Cxxxx)xHx8!p|N |B}Cx!}(Kx}:Kx|{x|#x|+x|3x|;xK!|~y@<cx88oHױH;/@H;|~x<_ Bod@ >^xp||H<_Bo8@x|HHcxx8@H /A0/A ^8B/^A xH8`Hp@D8@<`|c(|B!+ADx|HHxp||xH-cx$xx~x~dzxxIxK8!|N |+x8H|aB||x!|#x8|+x|3xHxfxC|~xxx8B^H^|}x8B/^AT /A/Ax}N!~/A<_BmAHYxH1h8!`xa|N |B|#x!`|yx|+x|3x/@|#xHؽ||x<#xDx87~xx99 9A`K!|}y8`Aha`/TA/AH&Y8;a@||]T=TB/`B 9)]=@A`/A/A\W#x`a@exx~x9 T\H݀T/A$aT8 THT/@Yh/A$9 @"B/@\p /@W#xx`@exH*\pA|@/Ap^8B/^AT /A/Ax}N!~/A<_BlЀAH!xH8pA]Tn8B]/ADsA<`/@<_XxH <_X<#xx~x87H,]: <_8BX@Cx}N!8 ]x8B]`H+M~óx8!|N |3x|;x|+x|x8H|AB|3x!|;xT<}Cx`8499 9A@KQ8@|~yAT<W`@<8c|Hڅ?8`cpHU8@8Cc ~x8!p|CxA|N |3x|;x|+x|x8H|A9 |3x|;x!}CxT89||x9A@K|}yA<]9 `p8/A@@A|IxB K̀|h/A$@  c/@/ @ H |Cx8H։pAx8H)Yx8!pA|N |3x|;x|+x|x8H|T}Cx|;x!899 9A@Ku|by8`AtHc HDcH`/bA0/A(@AȀc /@/AAc /@8`h8!`|N !|+y|B|#x!|3x;@A$<|#xex8Ƶ8Ha8`H/8`Af;/@ H|~x|t/-@l<x8 8cnH/@0;8`A{;@/@ H}|~x<x88cIhHȅ/@;@DW:#x8FxKA;/A/8`A;A8`h8!`!|N /|B!|+x|#x|3x;`A$<|#xx8ƴ8H8`H/@$Cx88K|{y8`AH<Cx880d899 9A@K|xx~/@ HA|}x/8`A`;@D;Cxx@x89 K;|{y8`A ;ACxdxH̹8`x8!p|N /|B!Đ!p|+x|#x|3xA <|#x~ex8Ƴ8HH/@H~x88K|dy@tH18|~x8~xxK-|dy@LH$<~x88/,899 9A@:@K: |wy8`AW8BW!@/AI8BIs/@ HϹ|vx@~x~x~Ƴx89K덀W|~x8BW!@/AI8BI/@:@T8H9H/@He:@|~x<_ BdAL~xx}N!|}yA0/A ^8B/^A xHIxH ^:z|Y;@4W8WH /aJAH$/@aJ9k/@\]H9|t/A|@888@89@9`}>B|t/AX/@T| X|t/gA,A/aA0H4/oA/u@$aJ HaJ8HaJHaJH/8@9@/}>B@L| X|t/-A(A/+AH/=AH8H8H88Hx| X|t/tAXA /rA,A@/,9kAdH@/wA/xAH,`B$H,`BH$`BIH`B H`BH 8`H9k}>B| X|t/@/A4H/A/AH8/A H,}@8|xH}@|8H}B8|Px|x}Z|@|t/@$8`X8!P|N |A|#x|+x!8 H`|خ||x|t//@;|t//@HA@\P8@xEx8`Hl-8He|}x8a@HZ/@[xK/@X8!PcxA|N A|{y|B8`!A?_Zhb/@~x8a}xHZ|t/A$|t//A|t/@<8cOLHe|}y@?;OTH|t/@ H8;}+@HqT`bH <_Ti:B}) 4Tb/@Ĉx|t/:A$/A|t/:A /@;8xHjA8xx|PHb!|t//A<x88tHadx8xHa8|~xH/@0x8@H/@H8@`BT&A4|t/A;|t/@?;TKȈ|t//@@;x8x8`Hiua8cHZɀZhbHZxH/.@|t//@;;8xx;8`HixHX1x8`HMa|c8cHZQh}HZ=8/A| }|c8cHZYxHW8aHW<_Bhb8!A|N |@&|AȐB|#xA|+x!p|+x|3x|;x|wxH-|}y8`A/A|t/@L~xH~ijxH/A~x~Dx~xH^]8B/]AtxHaHh;ACxHWu8@xH\I@|~xCxxH_@/@?;H@|^|t//A(<Cx88pH_QA@|~x8BA@]8B/]A xHa%;x8x8`Hg8@|}xH/@HT&/@ACxHV!xH|xH1|{y@PxHV~xH]Y~xHl<<|gx8L`~x89He-CxHU8`H(.:`Ap@,|t/.A/\@Ȉ|t/.@:`H/|t/.@ @ H@;;!`8x&x8`Hfx8|~xH/ATA0x~xHf-x8xH]~ijxH}/A$dx~xH~Dx|ex~xH\M#xHTcxH|cy@HcxH8aHTCxHT8`8!aA|}p N |#y||}x!P@8@H/8`@H/A8@H/8`@^p@AHp @tp@Ax8H}/@XpAx8H]/@8pAx8H=/@/A/@$x8@H/Ap HpAHT&/`ApAHT&/ ApAHT&/@ApAHT&/ApAH8@`BT&Adp@AH8@`BT&ADp A4x8@HE/@ H8@8``BT&A8`H8`8!|N |8|#x|dx!8`8@HcH|~x8a@HRI/@H=8`H 8x8`HcH}88!0|N ||#x!H-/AX8!Px|HLX8!P8`|N |!H/AX8!P|HX8!P8`|N ||#x!HX8!Px|H|!8@HM/8`A,a@8HXC|}x8a@8B]HPx88!0|N |B|~x!|#x88a@H/@4/A$xHg<8|ex8ExH_8`Hx8`8@8HaEh8!`|N |8|#x|dx!8`;@xHae8@8HY|~xxHP /8`Ax8@xH`р|88!0|N ||#x!H/AX8!Px|H X8!P8`|N a|#y||+x|~x!AH|}xxH/|~xA/Ax8H/AHc8Hhx8H/@Hc8HHs`AxxHHs`A xxH/8@@HHcE88@HxH8`xHa8@|iyAI8B/IAHY=xH8@8H8@|cyAL;@|ex8@x8`H_%Da@HU|~xxHN-/A^8B^xH8!@|Cxa|N 8`N ||#x!HX8!Px|Hd|!8@Hq/8`@ A@8bh8!`|N |8|#x|dx!8`8@H^x8Hy|~x8a@HMM/8`A4x88HsAx888H8~88!0|N |aB|{x!<_8BB;@|T|UxHM|c|t//A<x8H<x8B HxH8/|~xA88HxH/Ap;Pdx8x8`H]|}xHL}|exxxHM/@xHxHL8H$xHLx888H8|xX8!Pa|N |B!<_8B@;@|T|UxHK|c|t//A<x8¤H<x;8@HxH/||xA,88HxHxH9|}xxHh8!`x|N ||}x|#x!8a@H/8`@@a@88H9aD88H)!@8`AD9)8B=^h8!`|N ;|+!@$xHuX8!Px|HX8!P8`|N |@&|HG $;A;`!Ba88a <8$@DHL!P $K/@a8H`<|ex8Hl<;`T:HKa48}HKp| P@88m<8|3ր]`9<x81<|||p|.p|PH)|}xxxHYX8!Px|N K|B||x!<8X8cLH=;,H-xxH݀X8!Px|N K|Ba!<8c/H=|~x<8cH= /@ ?;ޘ`?;}/AxH<8c/x|ex8`H>x8P8THAP/@lTTB:;x|BH/AHAPxTTB:|BTaPH\$H>Ex|ex8`H>xH6aTH8%/Acx8X8\HMaX8PTc:H8X;aT@A\W:.|t/.@`<x88H5/A\<x88+H5y!P/@ 8 HAT8 U):.PHAP!TTK:8BI.APX;AdAP/@dTTB:; x|BBaPT8cH[mAPTTB:|B$H<x|ex8`H<xH59AP/@hTTB:; x|B8aPT8cHZAPTTB:|B$H<x|ex8`H!X/@ <8`;8H=/A8a@H28`H8|dx8a@H:||xa@HP \/i@p|t/s@`|t/o@P|t/-@@A@9"8B|t/A8B |t/@H/i@|t/b@|t/m@x|t//@h/9A`A@8c8p8B9"|t/A` 9)|t/@H@HG|xxH/A <x88)H0Y/@ ?;8`xHF|xyAD?_М/A4;`;Мx|{.H3M/A;{|./@8a@H0m/AH H<;8c)H|}yA|t/@<8c)He|}x/A|t/@<8c)H=|}x/A|t/@;/A??М/AH;`;Мx|{.[H2m/AH;{|./@/@H |}xH,/A /.8}A|}x/@|t/AL; xH/x8xH7||xa HM!8`xHE5|xyA;xH//A /@ ?;x8`HD<8`8)HHU|cyA8|dx88`8H>%;@\AW:8;; ||.H3ـx|dx8`H?EA $||.H?xH.IA8X?;T/@<8`8HDѐ}H8!@|N |aB8!p||x; xH9/@ <x88xH:m<x88xH:U<<888xH:9; 0<8c%lxH^|cyA|t/ApA 09 |t/:@"8B|t/@܀ 0<88xH9<<888xH9xH,H]|{yAH1|~yA|8x8H/A\x8 H~%/@H T&/@@8<x88xH95<<x888H9xHqcxHI|~yA; 88xHm/A\x8 H}/@H T&/@@8<x88xH8<<x888H8xH<<x8888H8<<888`xH8M<<x8888H81<<<88|8%8xH8m8a@H/A4;@8@8x8`H<<<|fx888xH8%;@xH*x8.HJ /@,!@+A <_U):B@}) 4p@$<<x88x8Hd<<8@888xH7<<<8888xH7y<<x88x8H7Y<<88x8@8H798/@p<<<888ƌ48xH7 <<<888ƌ48xH6<<<x888ƌ48H6;@xH*<x8c%H[|fy@$<x8c%HZ|fy@ <8ƌ4<<x888H6axH)9 8! a|N |AB|}x!?|#x;8a@H)u[$;B/A8`88@H9xC|t|Bt@ C|t|BtA|t/=@$ |t/@|HPxH,8a@H(a[$;W:B|./@l8a@H(9H8!@xA|N |B|~x<_!/AHC/APHN|cy@H6<|fx88x8H4X<8!Px8̻|HC\X8!P|N |B8!<|}x88HA}|~yA8a@H'xx8@H;}|~yA|<8`x8d8H}|cyA\|dx8`HM)xxH}/A<8`HR|~yA,xH0|dxxH`<x88HR=8a@H&88!0|N 8`N |B|#x}H|+x|<<88X8H}|A|3x|zx|#x!`|+x|;x8a@H8a@8Hq/Ax8a@H=s@8a@8H 8ap8@xfxH/A$xfx8ap8H;/@p;8a@Hy8!xA|N |!H10C||xX8!P|N |!HH|B}H|WF>W>W>8||xH!X8!Px|N |B8`0!HE|~y@<8c@H.8~8~HzX8!Px|N |~y|!A$8~HyX8!Px|H!LX8!P|N |B!?;ŜHw/A<cŤHx8X8!P|N |B!?;D/@D?;}Hye/@ <<8cLHx8}HyX<8!PcL|Hx8|B|dx}H|8cH=<8cА Hp<8cH;!@88W#x?H$!|[.W8<;|H08c;@|Bx|[.HՃػ/Ad8`9>9`| | .I9)|x| .9kB@|x pA`;A /@<8cH=xGx8@88@H_/A$<8cH1ػ/A8`9@x| 9`| .9kI|8 }Jx9)B/@ pAd8@^/AH^/A HĀ^/A 8 8~Hn݃/@P<8cHE|.|9A@x88Hbi|cyA/@ |t/q@xHa<8cH<88cА Hna<8cH8`HỲ8!|N |AB||x!|#x|#x|+x|3xH_8Ho|~y@4xH88@|dx8`H#8Hn|~x8a@HI/@4H&8$8(|dx8a Hn(x8H!y8H48`HI8|cyA <_8B{Z|xX8!PA|N |!B|#x!|+x|zx88`;`;! &xH"|~x8a@H<88 8a@H-x88a@H8|~x|xHm|}yA8Hm]|{x8`Hq|~yAHxHm!~H,H%88|dx8aHmUCx8H E8a@H#xHՀ88!0cx!|N ||}x!/A$~8HlqxH%/@X8!Px|H8`N |3x|;x|+x|x8H|@&|ؐ8BA|+x<!`8`}Cx|3x|;xHm|}xHm|~xxHg /A/A<x8``;@;`Hm}||xxHm1.|yxAHm|}yA$x8Hl/@xxHfAT/@L<8`$x888Hlu|}yA$8`xx8HlY|{xxHfM#xHfExHf=/A8`dxHl |zxcxHf^x/A/A?T>|STi>|@Q|x}!}b8PU`| Kx@@@$}k280@A@@@ 8}k2}hXPTi>| S|@Q| x}!|XPT|Kx@@@ |29J0@A@@@9JT| SxH/@ 8|3|4/@|8PT>9TĄ>H |P0|,0TĄ>},#|b,0|P0|xT>|cP0T>x|#x|I!}%Kx} }B`PU@| [x@@@$}J280@A@@@ 8}J2}HPPT>| |@|x}|BPPT@|Kx@@@$|B280@A@@@ 8|B2T| ;x|P|#Ti>|@!|x}}b8PU`| Kx@@@$}k280@A@@@ 8}k2}hXPTi>| #|@!| x}|XPT|Kx@@@ |29J0@A@@@9JT| SxH08@9 A } 4/@ @@A0@9 A9 H }P0|,0|,0|Hx|b,0U>|P0},#|xU>|cP0|P0T>|I!}>Kx|}B`PU@| [x(@@$}JB;@@A(@@ ;}JB}EPPT>| #|@!|x|}BPPU@| Kx(@@$}JB8@@A(@@ }JB8W}EPP| ;x}i0P@| 1AP@@@9)9/!aA |caN |B<_d!AX8!P|Hf PHfX8!P |c|N ||ip|jpB<@C0}|m@A=( T>| ;T>|@9|x}}bPPU`| Kx@@@$}k280@A@@@ 8}k2}hXPT>| ;|@9| x}|BXPT@|Kx@@@$|B29J0@A@@@ |B29JT|P|Sx;H/@ 8|3|4/@}FPPT>;Tń>H# |0}L0Tń>},+|0}@0| xT>UK>~x|0|+x|I)}=Kx|}`PU|[x8@@$}2;0@A8@@ ;}2}@PUI>||@| x||B@PT@|Kx8@@$|B29J0@A8@@ 9J|B2W|Sx}GP| +T>|@)|x}}bPPU`| Kx@@@$}k280@A@@@ 8}k2}hXPT>| +|@)| x}|BXPT@|Kx@@@$|B29J0@A@@@ |B29JT|P|Sx/A|08@ĐAHP@@(8A;aĐaАH}4/@@@@A0@8A| }HQ8|x/;ADđAH0# }0|0}L0|Hx|0U>}B0},|JxU>UK>|0|0|I}||@| x||8PT|Kx(@@$|B9@@A(@@ 9|B|8PW|cx|08@|E1A8@ @@}&|8}"Kx/;A,}" }@9}"0}@0}I0|x!/A aЀ |caАH aЀԻ!N px!Aaځڡ!AaہۡN px!Aaʁʡ!Aaˁˡ|N |B<_!@8@8`H`<_|<_ɢ2hOA@DHh(١HLl|x8`|]x|~x8xx8H_/@xxH/uH,WW~|JxW~8`W|cKx|SxH/M!*(<_@TP<_"OAHLH(١@Dl|x8@HL<_OAHLH(١@Dl|x8@xxx8!p|dx|Cx|N aА8`AЀM AA8`@M @ 8`N 8`N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|h}N |B}h=k|L}N |B}h=k|0}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|l}N |B}h=k|P}N |B}h=k|4}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|p}N |B}h=k|T}N |B}h=k|8}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|t}N |B}h=k|X}N |B}h=k|<}N |B}h=k| }N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|x}N |B}h=k|\}N |B}h=k|@}N |B}h=k|$}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k||}N |B}h=k|`}N |B}h=k|D}N |B}h=k|(}N |B}h=k| }N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|d}N |B}h=k|H}N |B}h=k|,}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|h}N |B}h=k|L}N |B}h=k|0}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|l}N |B}h=k|P}N |B}h=k|4}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|p}N |B}h=k|T}N |B}h=k|8}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|t}N |B}h=k|X}N |B}h=k|<}N |B}h=k| }N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|x}N |B}h=k|\}N |B}h=k|@}N |B}h=k|$}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k||}N |B}h=k|`}N |B}h=k|D}N |B}h=k|(}N |B}h=k| }N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|d}N |B}h=k|H}N |B}h=k|,}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|h}N |B}h=k|L}N |B}h=k|0}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|l}N |B}h=k|P}N |B}h=k|4}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|p}N |B}h=k|T}N |B}h=k|8}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|t}N |B}h=k|X}N |B}h=k|<}N |B}h=k| }N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|x}N |B}h=k|\}N |B}h=k|@}N |B}h=k|$}N |B}h=k|}N |B}h=k|~}N |B}h=k|~}N |B}h=k|~}N |B}h=k|~}N |B}h=k|~|}N |B}h=k|~`}N |B}h=k|~D}N |B}h=k|~(}N |B}h=k|~ }N |B}h=k|}}N |B}h=k|}}N |B}h=k|}}N |B}h=k|}}N |B}h=k|}}N |B}h=k|}d}N |B}h=k|}H}N |B}h=k|},}N |B}h=k|}}N |B}h=k||}N |B}h=k||}N |B}h=k||}N |B}h=k||}N |B}h=k||}N |B}h=k||h}N |B}h=k||L}N |B}h=k||0}N |B}h=k||}N |B}h=k|{}N |B}h=k|{}N |B}h=k|{}N |B}h=k|{}N |B}h=k|{}N |B}h=k|{l}N |B}h=k|{P}N |B}h=k|{4}N |B}h=k|{}N |B}h=k|z}N |B}h=k|z}N |B}h=k|z}N |B}h=k|z}N |B}h=k|z}N |B}h=k|zp}N |B}h=k|zT}N |B}h=k|z8}N |B}h=k|z}N |B}h=k|z}N |B}h=k|y}N |B}h=k|y}N |B}h=k|y}N |B}h=k|y}N |B}h=k|yt}N |B}h=k|yX}N |B}h=k|y<}N |B}h=k|y }N |B}h=k|y}N |B}h=k|x}N |B}h=k|x}N |B}h=k|x}N |B}h=k|x}N |B}h=k|xx}N |B}h=k|x\}N |B}h=k|x@}N |B}h=k|x$}N |B}h=k|x}N |B}h=k|w}N |B}h=k|w}N |B}h=k|w}N |B}h=k|w}N |B}h=k|w|}N |B}h=k|w`}N |B}h=k|wD}N |B}h=k|w(}N |B}h=k|w }N |B}h=k|v}N |B}h=k|v}N |B}h=k|v}N |B}h=k|v}N |B}h=k|v}N |B}h=k|vd}N |B}h=k|vH}N |B}h=k|v,}N |B}h=k|v}N |B}h=k|u}N |B}h=k|u}N |B}h=k|u}N |B}h=k|u}N |B}h=k|u}N |B}h=k|uh}N |B}h=k|uL}N |B}h=k|u0}N |B}h=k|u}N |B}h=k|t}N |B}h=k|t}N |B}h=k|t}N |B}h=k|t}N |B}h=k|t}N |B}h=k|tl}N |B}h=k|tP}N |B}h=k|t4}N |B}h=k|t}N |B}h=k|s}N |B}h=k|s}N |B}h=k|s}N |B}h=k|s}N |B}h=k|s}N |B}h=k|sp}N |B}h=k|sT}N |B}h=k|s8}N |B}h=k|s}N |B}h=k|s}N |B}h=k|r}N |B}h=k|r}N |B}h=k|r}N |B}h=k|r}N |B}h=k|rt}N |B}h=k|rX}N |B}h=k|r<}N |B}h=k|r }N |B}h=k|r}N |B}h=k|q}N |B}h=k|q}N |B}h=k|q}N |B}h=k|q}N |B}h=k|qx}N |B}h=k|q\}N |B}h=k|q@}N |B}h=k|q$}N |B}h=k|q}N |B}h=k|p}N |B}h=k|p}N |B}h=k|p}N |B}h=k|p}N |B}h=k|p|}N |B}h=k|p`}N |B}h=k|pD}N |B}h=k|p(}N |B}h=k|p }N |B}h=k|o}N |B}h=k|o}N |B}h=k|o}N |B}h=k|o}N |B}h=k|o}N |B}h=k|od}N |B}h=k|oH}N |B}h=k|o,}N |B}h=k|o}N |B}h=k|n}N |B}h=k|n}N |B}h=k|n}N |B}h=k|n}N |B}h=k|n}N |B}h=k|nh}N |B}h=k|nL}N |B}h=k|n0}N |B}h=k|n}N |B}h=k|m}N |B}h=k|m}N |B}h=k|m}N |B}h=k|m}N |B}h=k|m}N |B}h=k|ml}N |B}h=k|mP}N |B}h=k|m4}N |B}h=k|m}N |B}h=k|l}N |B}h=k|l}N |B}h=k|l}N |B}h=k|l}N |B}h=k|l}N |B}h=k|lp}N |B}h=k|lT}N |B}h=k|l8}N |B}h=k|l}N |B}h=k|l}N |B}h=k|k}N |B}h=k|k}N |B}h=k|k}N |B}h=k|k}N |B}h=k|kt}N |B}h=k|kX}N |B}h=k|k<}N |B}h=k|k }N |B}h=k|k}N |B}h=k|j}N |B}h=k|j}N |B}h=k|j}N |B}h=k|j}N |B}h=k|jx}N |B}h=k|j\}N |B}h=k|j@}N |B}h=k|j$}N |B}h=k|j}N |B}h=k|i}N |B}h=k|i}N |B}h=k|i}N |B}h=k|i}N |B}h=k|i|}N |B}h=k|i`}N |B}h=k|iD}N |B}h=k|i(}N |B}h=k|i }N |B}h=k|h}N |B}h=k|h}N |B}h=k|h}N |B}h=k|h}N |B}h=k|h}N |B}h=k|hd}N |B}h=k|hH}N |B}h=k|h,}N |B}h=k|h}N |B}h=k|g}N |B}h=k|g}N |B}h=k|g}N |B}h=k|g}N |B}h=k|g}N |B}h=k|gh}N |B}h=k|gL}N |B}h=k|g0}N |B}h=k|g}N |B}h=k|f}N |B}h=k|f}N |B}h=k|f}N |B}h=k|f}N |B}h=k|f}N |B}h=k|fl}N |B}h=k|fP}N |B}h=k|f4}N |B}h=k|f}N |B}h=k|e}N |B}h=k|e}N |B}h=k|e}N |B}h=k|e}N |B}h=k|e}N |B}h=k|ep}N |B}h=k|eT}N |B}h=k|e8}N |B}h=k|e}N |B}h=k|e}N |B}h=k|d}N |B}h=k|d}N |B}h=k|d}N |B}h=k|d}N |B}h=k|dt}N |B}h=k|dX}N |B}h=k|d<}N |B}h=k|d }N |B}h=k|d}N |B}h=k|c}N |B}h=k|c}N |B}h=k|c}N |B}h=k|c}N |B}h=k|cx}N |B}h=k|c\}N |B}h=k|c@}N |B}h=k|c$}N |B}h=k|c}N |B}h=k|b}N |B}h=k|b}N |B}h=k|b}N |B}h=k|b}N |B}h=k|b|}N |B}h=k|b`}N |B}h=k|bD}N |B}h=k|b(}N |B}h=k|b }N |B}h=k|a}N |B}h=k|a}N |B}h=k|a}N |B}h=k|a}N |B}h=k|a}N |B}h=k|ad}N |B}h=k|aH}N |B}h=k|a,}N |B}h=k|a}N |B}h=k|`}N |B}h=k|`}N |B}h=k|`}N |B}h=k|`}N |B}h=k|`}N |B}h=k|`h}N |B}h=k|`L}N |B}h=k|`0}N |B}h=k|`}N |B}h=k|_}N |B}h=k|_}N |B}h=k|_}N |B}h=k|_}N |B}h=k|_}N |B}h=k|_l}N |B}h=k|_P}N |B}h=k|_4}N |B}h=k|_}N |B}h=k|^}N |B}h=k|^}N |B}h=k|^}N |B}h=k|^}N |B}h=k|^}N |B}h=k|^p}N |B}h=k|^T}N |B}h=k|^8}N |B}h=k|^}N |B}h=k|^}N |B}h=k|]}N |B}h=k|]}N |B}h=k|]}N |B}h=k|]}N |B}h=k|]t}N |B}h=k|]X}N |B}h=k|]<}N |B}h=k|] }N |B}h=k|]}N |B}h=k|\}N |B}h=k|\}N |B}h=k|\}N |B}h=k|\}N |B}h=k|\x}N |B}h=k|\\}N |B}h=k|\@}N |B}h=k|\$}N |B}h=k|\}N |B}h=k|[}N |B}h=k|[}N |B}h=k|[}N |B}h=k|[}N |B}h=k|[|}N |B}h=k|[`}N |B}h=k|[D}N |B}h=k|[(}N |B}h=k|[ }N |B}h=k|Z}N |B}h=k|Z}N |B}h=k|Z}N |B}h=k|Z}N |B}h=k|Z}N |B}h=k|Zd}N |B}h=k|ZH}N |B}h=k|Z,}N |B}h=k|Z}N |B}h=k|Y}N |B}h=k|Y}N |B}h=k|Y}N |B}h=k|Y}N |B}h=k|Y}N |B}h=k|Yh}N |B}h=k|YL}N |B}h=k|Y0}N |B}h=k|Y}N |B}h=k|X}N |B}h=k|X}N |B}h=k|X}N |B}h=k|X}N |B}h=k|X}N |B}h=k|Xl}N |B}h=k|XP}N |B}h=k|X4}N |B}h=k|X}N |B}h=k|W}N |B}h=k|W}N |B}h=k|W}N |B}h=k|W}N |B}h=k|W}N |B}h=k|Wp}N |B}h=k|WT}N |B}h=k|W8}N |B}h=k|W}N |B}h=k|W}N |B}h=k|V}N |B}h=k|V}N |B}h=k|V}N |B}h=k|V}N |B}h=k|Vt}N |B}h=k|VX}N |B}h=k|V<}N |B}h=k|V }N |B}h=k|V}N |B}h=k|U}N |B}h=k|U}N |B}h=k|U}N |B}h=k|U}N |B}h=k|Ux}N |B}h=k|U\}N |B}h=k|U@}N |B}h=k|U$}N |B}h=k|U}N |B}h=k|T}N |B}h=k|T}N |B}h=k|T}N |B}h=k|T}N |B}h=k|T|}N |B}h=k|T`}N |B}h=k|TD}N |B}h=k|T(}N |B}h=k|T }N |B}h=k|S}N |B}h=k|S}N |B}h=k|S}N |B}h=k|S}N |B}h=k|S}N |B}h=k|Sd}N |B}h=k|SH}N |B}h=k|S,}N |B}h=k|S}N |B}h=k|R}N |B}h=k|R}N |B}h=k|R}N |B}h=k|R}N |B}h=k|R}N |B}h=k|Rh}N |B}h=k|RL}N |B}h=k|R0}N |B}h=k|R}N |B}h=k|Q}N |B}h=k|Q}N |B}h=k|Q}N |B}h=k|Q}N |B}h=k|Q}N |B}h=k|Ql}N |B}h=k|QP}N |B}h=k|Q4}N |B}h=k|Q}N |B}h=k|P}N |B}h=k|P}N |B}h=k|P}N |B}h=k|P}N |B}h=k|P}N |B}h=k|Pp}N |B}h=k|PT}N |B}h=k|P8}N |B}h=k|P}N |B}h=k|P}N |B}h=k|O}N |B}h=k|O}N |B}h=k|O}N |B}h=k|O}N |B}h=k|Ot}N |B}h=k|OX}N |B}h=k|O<}N |B}h=k|O }N |B}h=k|O}N |B}h=k|N}N |B}h=k|N}N |B}h=k|N}N |B}h=k|N}N |B}h=k|Nx}N |B}h=k|N\}N |B}h=k|N@}N |B}h=k|N$}N |B}h=k|N}N |B}h=k|M}N |B}h=k|M}N |B}h=k|M}N |B}h=k|M}N |B}h=k|M|}N |B}h=k|M`}N |B}h=k|MD}N |B}h=k|M(}N |B}h=k|M }N |B}h=k|L}N |B}h=k|L}N |B}h=k|L}N |B}h=k|L}N |B}h=k|L}N |B}h=k|Ld}N |B}h=k|LH}N |B}h=k|L,}N |B}h=k|L}N |B}h=k|K}N |B}h=k|K}N |B}h=k|K}N |B}h=k|K}N |B}h=k|K}N |B}h=k|Kh}N |B}h=k|KL}N |B}h=k|K0}N |B}h=k|K}N |B}h=k|J}N |B}h=k|J}N |B}h=k|J}N |B}h=k|J}N |B}h=k|J}N |B}h=k|Jl}N |B}h=k|JP}N |B}h=k|J4}N |B}h=k|J}N |B}h=k|I}N |B}h=k|I}N |B}h=k|I}N |B}h=k|I}N |B}h=k|I}N |B}h=k|Ip}N |B}h=k|IT}N |B}h=k|I8}N |B}h=k|I}N |B}h=k|I}N |B}h=k|H}N |B}h=k|H}N |B}h=k|H}N |B}h=k|H}N |B}h=k|Ht}N |B}h=k|HX}N |B}h=k|H<}N |B}h=k|H }N |B}h=k|H}N |B}h=k|G}N |B}h=k|G}N |B}h=k|G}N |B}h=k|G}N |B}h=k|Gx}N |B}h=k|G\}N |B}h=k|G@}N |B}h=k|G$}N |B}h=k|G}N |B}h=k|F}N |B}h=k|F}N |B}h=k|F}N |B}h=k|F}N |B}h=k|F|}N |B}h=k|F`}N |B}h=k|FD}N |B}h=k|F(}N |B}h=k|F }N |B}h=k|E}N |B}h=k|E}N |B}h=k|E}N |B}h=k|E}N |B}h=k|E}N |B}h=k|Ed}N |B}h=k|EH}N |B}h=k|E,}N |B}h=k|E}N |B}h=k|D}N |B}h=k|D}N |B}h=k|D}N |B}h=k|D}N |B}h=k|D}N |B}h=k|Dh}N |B}h=k|DL}N |B}h=k|D0}N |B}h=k|D}N |B}h=k|C}N |B}h=k|C}N |B}h=k|C}N |B}h=k|C}N |B}h=k|C}N |B}h=k|Cl}N |B}h=k|CP}N |B}h=k|C4}N |B}h=k|C}N |B}h=k|B}N |B}h=k|B}N |B}h=k|B}N |B}h=k|B}N |B}h=k|B}N |B}h=k|Bp}N |B}h=k|BT}N |B}h=k|B8}N |B}h=k|B}N |B}h=k|B}N |B}h=k|A}N |B}h=k|A}N |B}h=k|A}N |B}h=k|A}N |B}h=k|At}N |B}h=k|AX}N |B}h=k|A<}N |B}h=k|A }N |B}h=k|A}N |B}h=k|@}N |B}h=k|@}N |B}h=k|@}N |B}h=k|@}N |B}h=k|@x}N |B}h=k|@\}N |B}h=k|@@}N |B}h=k|@$}N |B}h=k|@}N |B}h=k|?}N |B}h=k|?}N |B}h=k|?}N |B}h=k|?}N |B}h=k|?|}N |B}h=k|?`}N |B}h=k|?D}N |B}h=k|?(}N __dyld_call_module_initializers_for_dylib ========= RAW ========== ========= TREE FIXED ========== ========= LA%d ========== ========= SEARCH ========== ========= TREE NODE %s ========== null tree %s. `%c' longest shortest hasmixed hascapture hasbackref UNUSED (#%d) {%d,%d %ld-%ld L:%s R:%sunable%p initial cleanup: empties: constraints: final cleanup: NULSOHSTXETXEOTENQACKBELalertBSbackspaceHTtabLFnewlineVTvertical-tabFFform-feedCRcarriage-returnSOSIDLEDC1DC2DC3DC4NAKSYNETBCANEMSUBESCIS4FSIS3GSIS2RSIS1USspaceexclamation-markquotation-marknumber-signdollar-signpercent-signampersandapostropheleft-parenthesisright-parenthesisasteriskplus-signcommahyphenhyphen-minusperiodfull-stopslashsoliduszeroonetwothreefourfivesixseveneightninecolonsemicolonless-than-signequals-signgreater-than-signquestion-markcommercial-atleft-square-bracketbackslashreverse-solidusright-square-bracketcircumflexcircumflex-accentunderscorelow-linegrave-accentleft-braceleft-curly-bracketvertical-lineright-braceright-curly-brackettildeDELalnumalphaasciiblankcntrldigitgraphlowerprintpunctupperxdigitREG_OKAYno errors detectedREG_NOMATCHfailed to matchREG_BADPATinvalid regexp (reg version 0.8)REG_ECOLLATEinvalid collating elementREG_ECTYPEinvalid character classREG_EESCAPEinvalid escape \ sequenceREG_ESUBREGinvalid backreference numberREG_EBRACKbrackets [] not balancedREG_EPARENparentheses () not balancedREG_EBRACEbraces {} not balancedREG_BADBRinvalid repetition count(s)REG_ERANGEinvalid character rangeREG_ESPACEout of memoryREG_BADRPTquantifier operand invalidREG_ASSERT"can't happen" -- you found a bugREG_INVARGinvalid argument to regex functionREG_MIXEDcharacter widths of regex and string differREG_BADOPTinvalid embedded optionoopsREG_%uappendarraybinarybreakcasecatchclockconcatcontinueencodingerrorevalexitexprfcopyfileeventforforeachformatglobalifincrinfojoinlappendlindexlinsertlistllengthloadlrangelreplacelsearchlsetlsortnamespacepackageprocregexpregsubrenamereturnscansetsplitstringsubstswitchtraceunsetuplevelupvarvariablewhileaftercdcloseeoffblockedfconfigurefileflushgetsglobopenpidputspwdreadseeksockettelltimeupdatevwaitexecsourceTcl_CreateInterp: can't create global namespaceTcl_CreateInterp: builtin command with NULL string and object command procs and a NULL compile proc Tcl_CreateInterp: Tcl_CreateMathFunc incorrectly registered '%s'bigEndiantcl_platformbyteOrderwordSizetcl_patchLevel8.4.8tcl_version8.4tcl_precisionthreaded1TclAssoc Data Key #%dDeleteInterpProc called with active evalsDeleteInterpProc called on interpreter not marked deleted::cannot use namespace qualifiers in hidden command token (rename)can only hide global namespace commands (use rename then hide)hidden command named "" already existscan not expose to a namespace (use expose to toplevel, then rename)unknown hidden command ""trying to expose a non global command name space commandexposed command "deletecan't "": command doesn't existcan't rename to "": bad command name": command already existsmath function "" not known in this interpreterattempt to call eval in deleted interpreterCOREIDELETEtoo many nested evaluations (infinite loop?)::unknowninvalid command name "... while executing "%.*s%s" invoked from within "%.*s%s"unexpected token type in Tcl_EvalTokensStandardmissing close-bracketinvoked "break" outside of a loopinvoked "continue" outside of a loopcommand returned bad code: %dexpression didn't have numeric valueillegal argument vectorinvalid hidden command name "unknown while invoking " invoked from within " %ld0NONEbytearrayTcl_SetByteArrayObj called with shared objectTcl_SetObjLength called with shared objectoption ?arg arg ...?optionformatString ?arg arg ...?hexadecimalvalue formatString ?varName varName ...?expected string but got "" insteadmissing count for "@" field specifiernot enough arguments for all format specifiersbad field specifier "number of elements in list does not match countcannot use "*" in format string with "x"unable to alloc %u bytesunable to alloc %u bytes, %s line %dunable to realloc %u bytesunable to realloc %u bytes, %s line %dclicksseconds-format-gmt-base%a %b %d %X %Z %Yoption ?arg ...?-millisecondsbad switch "": must be -milliseconds?-milliseconds?clockval ?-format string? ?-gmt boolean?dateString ?-base clockValue? ?-gmt boolean?unable to convert date-time string "bad format string "string ?in? patList body ... ?default body?indefault ("%.50s" arm line %d)extra case pattern with no bodycommand ?varName?couldn't save command result in variable?dirName?~couldn't change working directory to "": convertfromconverttonamessystem?encoding? data?encoding?message ?errorInfo? ?errorCode?errorCodearg ?arg ...? ("eval" body line %d)?returnCode?atimeattributeschannelscopydirnameexecutableexistsextensionisdirectoryisfilelinklstatmtimemkdirnativenamenormalizeownedpathtypereadablereadlinkrootnameseparatorsizestattailtypevolumeswritable-symbolic-hardcould not set access time for file "?pattern??-linktype? linkname ?target?could not create new link "": that path already exists" since target "" doesn't exist" pointing to "could not read link "name varNamename ?time?could not set modification time for file "name ?name ...?filenameabsoluterelativevolumerelativecould not readlink "?name?/\:stat name varNameUnrecognised pathnamecould not read "devinonlinkuidgidctimemodedirectorycharacterSpecialblockSpecialfifostart test next command ("for" initial command) ("for" body line %d) ("for" loop-end command)varList list ?varList list ...? commandforeach varlist is emptyTcl_ForeachObjCmd: could not reconvert variable list %d to a list object Tcl_ForeachObjCmd: could not reconvert value list %d to a list object couldn't set loop variable: " ("foreach" body line %d)llformat string ended in middle of field specifierbad field specifier "%c"cannot mix "%" and "%n$" conversion specifiers"%n$" argument index out of rangewrong # args: no script following "" argumentthenelseifelsewrong # args: no script following "else" argumentwrong # args: extra words after "else" clause in "if" commandwrong # args: no expression after "varName ?increment? (reading increment)argsbodycmdcountcommandscompletefunctionsglobalshostnamelevellibraryloadedlocalsnameofexecutablepatchlevelprocsscriptsharedlibextensiontclversionvarsprocname" isn't a procedurecommandprocname arg varnamecouldn't store default value in variable "procedure "" doesn't have an argument "varNameunable to determine name of hostbad level "?number?tcl_libraryno library has been specified for Tcl?interp??filename?.dyliblist ?joinString?list ?index...?list index element ?element ...?list first lastlist first last ?element element ...?list doesn't contain element -all-ascii-decreasing-dictionary-exact-glob-increasing-inline-integer-not-real-regexp-sorted-start?options? list patternmissing starting indexlistVar index ?index...? value-command-index-unique?options? list"-command" option must be followed by comparison command"-index" option must be followed by list indexelement missing from sublist " (-compare command)-compare command returned non-integer resultexecution-about-indices-expanded-line-linestop-lineanchor-nocase--?switches? exp string ?matchVar? ?subMatchVar subMatchVar ...?regexp match variables not allowed when using -inlinecouldn't set variable "?switches? exp string subSpec ?varName?&\*+?{}()[].\|^$oldName newName-codeokbad completion code "": must be ok, error, return, break, continue, or an integer-errorinfo-errorcodebad option "": must be -code, -errorcode, or -errorinfofileName string ?splitChars?bytelengthcompareequalfirstindexislastlengthmapmatchrangerepeatreplacetolowertouppertotitletrimtrimlefttrimrightwordendwordstartcontrolbooleandoublefalseintegertruewordcharoption arg ?arg ...??-nocase? ?-length int? string1 string2-length": must be -nocase or -lengthstring charIndexclass ?-strict? ?-failindex var? strclass-strict-failindex": must be -strict or -failindexsubString string ?startIndex??-nocase? charMap stringchar map list unbalanced?-nocase? pattern string": must be -nocasestring first laststring countstring size overflow, must be less than string first last ?string?string ?first? ?last? string ?chars?string index?-strict? ?-failindex var? str-nobackslashes-nocommands-novariablesTcl_SubstObjCmd: bad option index to SubstOptions?-nobackslashes? ?-nocommands? ?-novariables? string?switches? string pattern body ... ?default body??switches? string {pattern body ... ?default body?}, this may be due to a comment incorrectly placed outside of a switch body - see the "switch" documentationextra switch pattern with no body-no body specified for pattern "fall-out when searching for body to match patterncommand ?count?%.0f microseconds per iterationaddremovevdeletevinfotype ?arg arg ...?name ops commandwritebad operations "": should be one or more of rwuaenterleaveenterstepleavestepname opList commandbad operation list "": must be one or more of enter, leave, enterstep, or leavestepoperationTclTraceExecutionObjCmd: negative TraceCommandInfo refCountbad operation list "": must be one or more of delete or renameTclTraceCommandObjCmd: negative TraceCommandInfo refCountbad operation list "": must be one or more of array, read, unset, or write rename deleteTraceCommandProc: negative TraceCommandInfo refCountTclCheckExecutionTraces: negative TraceCommandInfo refCountCommandObjTraceDeleted: negative TraceCommandInfo refCountTraceExecutionProc: bad flag combinationTraceExecutionProc: negative TraceCommandInfo refCount a r w u array read write unsettest command ("while" body line %d)ForeachInfowrong # args: should be "append varName ?value value ...?"wrong # args: should be "break"wrong # args: should be "catch command ?varName?"TclCompileCatchCmd: bad jump distance %d wrong # args: should be "continue"wrong # args: should be "expr arg ?arg ...?"wrong # args: should be "for start test next command" ("for" test expression)wrong # args: should be "foreach varList list ?varList list ...? command"wrong # args: no expression after "%.*s" argument ("if" test expression)wrong # args: no script following "%.*s" argument ("if" then script line %d) ("if" else script line %d)wrong # args: no script following "then" argumentTclCompileIfCmd: unexpected opcode updating ifFalse jumpwrong # args: should be "incr varName ?increment?"wrong # args: should be "lappend varName ?value value ...?"wrong # args: should be "llength list"wrong # args: should be "set varName ?newValue?"*[]?\wrong # args: should be "while test command" ("while" test expression)*%+<<>><><=>===!=&^|&&||?!eqneCompileSubExpr: token type %d not TCL_TOKEN_SUB_EXPR CompileSubExpr: unexpected operator %d requiring special treatment CompileSubExpr: unexpected token type %d CompileLandOrLorExpr: bad jump distance %d unknown math function "too many arguments for math functiontoo few arguments for math functionsyntax error in expression "%.*s"donepush1push4popdupconcat1invokeStk1invokeStk4evalStkexprStkloadScalar1loadScalar4loadScalarStkloadArray1loadArray4loadArrayStkloadStkstoreScalar1storeScalar4storeScalarStkstoreArray1storeArray4storeArrayStkstoreStkincrScalar1incrScalarStkincrArray1incrArrayStkincrStkincrScalar1ImmincrScalarStkImmincrArray1ImmincrArrayStkImmincrStkImmjump1jump4jumpTrue1jumpTrue4jumpFalse1jumpFalse4lorlandbitorbitxorbitandneqltgtlegelshiftrshiftsubmultdivmoduplusuminusbitnotnotcallBuiltinFunc1callFunc1tryCvtToNumericforeach_start4foreach_step4beginCatch4endCatchpushResultpushReturnCodestreqstrneqstrcmpstrlenstrindexstrmatchlistindexlistlengthappendScalar1appendScalar4appendArray1appendArray4appendArrayStkappendStklappendScalar1lappendScalar4lappendArray1lappendArray4lappendArrayStklappendStklindexMultioverlsetListlsetFlatbytecode (parsing index for array "%.*s")Unexpected token type in TclCompileTokens while compiling "%.*s%s"EnterCmdStartData: bad command index %d EnterCmdStartData: cmd map not sorted by code offsetEnterCmdExtentData: bad command index %d EnterCmdExtentData: missing start data for command %d TclFixupForwardJump: bad ExceptionRange type %d GetCmdLocEncodingSize: bad code offsetGetCmdLocEncodingSize: bad code lengthGetCmdLocEncodingSize: bad source lengthEncodeCmdLocMap: bad code offsetEncodeCmdLocMap: bad code lengthEncodeCmdLocMap: bad source length(%u) %s %d # pc %u%u # TclPrintInstruction: bad local var index %u (%u locals) %u # temp var %u%u # var %u ""\"\f\n\r\t\vjanuaryfebruarymarchaprilmayjunejulyaugustseptemberseptoctobernovemberdecembersundaymondaytuesdaytueswednesdaywednesthursdaythurthursfridaysaturdayyearmonthfortnightweekdayhourminuteminsecondsectomorrowyesterdaytodaynowthisnextagoepochstardategmtututcuctwetbstwatatnftnstndtastadtestedtcstcdtmstmdtpstpdtystydthsthdtcatahstntidlwcetcestmetmewtmestswtsstfwtfsteetbtitzp4zp5istzp6wastwadtjtcctjstcastcadteasteadtgstnztnzstnzdtidledstabcdefghiklmnopqrstuvwxyzama.m.pmp.m.yacc stack overflowsyntax erroridentityutf-8unicode*.enc-encodinginvalid encoding file "unknown encoding ".encinitfinalEscapeToUtfProc: invalid sub tableenvHOMEno such variableerrorInfotclBgErrorbgerrorbgerror failed to handle background error. Original error: Error in bgerror: TclInitSubsystems called while finalizingcan't wait for variable "": would wait foreveridletasksTcl_UpdateObjCmd: bad option index to UpdateOptions?idletasks?BUILTIN FUNCTIONFUNCTIONacosasinatanatan2ceilcoscoshexpfloorfmodhypotloglog10powsinsinhsqrttantanhabsintrandroundsrandwide::errorInfo::errorCodeERROR: freeing an execEnv whose stack is still in use. Tcl_ExprObj: compiled expression jumped interpsTcl_EvalObj: compiled script jumped interps (reading value of variable to increment)TclExecuteByteCode: unrecognized builtin function code %dTclExecuteByteCode: unrecognized opCode %udivide by zeroARITHDIVZERO TclExecuteByteCode: abnormal return at pc %u: stack top %d < entry stack top %d TclExecuteByteCode execution failure: end stack top < start stack topcan't use empty string as operand of "non-numeric stringnon-numeric floating-point valueinfinite floating-point valueinvalid octal numberIOVERFLOWinteger value too large to representfloating-point valuecan't use as operand of "argument to math function was an invalid octal numberargument to math function didn't have numeric valuecan't use floating-point value as argument to srandExprCallMathFunc: expected number of args %d != actual number %ddomain error: argument not in valid rangeDOMAINfloating-point value too small to representUNDERFLOWfloating-point value too large to representOVERFLOWunknown floating-point error, errno = %dUNKNOWNwrong # args: should be " ?options? source ?source ...? target"copyingrenamingerror : target "" is not a directorycan't create directory " ?options? file ?file ...?"error deleting unknown file: error deleting "": directory not emptycan't overwrite file "" with directory "can't overwrite directory "" with file "error renaming "" to "": trying to rename a volume or move a directory into itself::tcl::CopyDirectorycan't unlink "error copying "": "-force": should be -force or --name ?option? ?value? ?option value ...?", there are no file attributes in this filesystem.value for "" missing^((/+([.][.]?/+)*([.][.]?)?)|(~[^:/]*)(/[^:]*)?|(~[^:]*)(:.*)?|/+([.][.]?/+)*([^:/]+)(/[^:]*)?|([^:]+):.*)$//.//\:couldn't find HOME environment variable to expand pathuser "-directory-join-nocomplain-path-tails-types?switches? name ?name ...?"-tails" must be used with either "-directory" or "-path"\/\[]*?{}readonlyhiddenmacintoshcreatorbad argument to "-types": only one MacOS type or creator argument to "-types" alloweds "no files matched glob patternmissing argument to "-directory""-directory" cannot be used with "-path"missing argument to "-path""-path" cannot be used with "-directory"missing argument to "-types".}unmatched open-brace in file name,unmatched close-brace in file nameexpected integer but got "expected floating-point number but got "yesnoonoffexpected boolean value but got "malformed bucket chain in Tcl_DeleteHashEntry%d entries in table, %d buckets number of buckets with %d entries: %d number of buckets with %d or more entries: %d average search distance for entry: %.1fcalled Tcl_FindHashEntry on deleted tablecalled Tcl_CreateHashEntry on deleted tablehistoryambiguous bad ": must be , or or , can't convert value to index except via Tcl_GetIndexFromObj APIinterpInterpInfoDeleteProc: still exist commandsInterpInfoDeleteProc: still exist aliasesaliasaliasescreateexposehideissafeinvokehiddenmarktrustedrecursionlimitslavessharetargettransfer-safe-globalcmd ?arg ...?slavePath slaveCmd ?masterPath masterCmd? ?args ..?interp%dpath arg ?arg ...?path hiddenCmdName ?cmdName?path cmdName ?hiddenCmdName?path ?-global? ?--? cmd ?arg ..?pathpath ?newlimit?path aliasalias "" in path "" not foundtarget interpreter for alias "" is not my descendantsrcPath channelId destPath?-safe? ?--? ?path?cannot delete the current interpreter?path?cannot define or rename alias "": interpreter deleted": would create a loopcould not find interpreter "interpreter named "" already exists, cannot createtcl_interactiveSlaveObjCmd: interpreter has been deletedaliasName ?targetName? ?args..?hiddenCmdName ?cmdName?cmdName ?hiddenCmdName??-global? ?--? cmd ?arg ..??newlimit?permission denied: safe interpreter cannot expose commandspermission denied: safe interpreters cannot change recursion limitrecursion limit must be > 0falling back due to new recursion limitpermission denied: safe interpreter cannot hide commandsnot allowed to invoke hidden commands from safe interpreterpermission denied: safe interpreter cannot mark trustedososVersionmachineusertclDefaultLibrarytcl_pkgPath-blockingtclIOTcl_RegisterChannel: channel without nameTcl_RegisterChannel: duplicate channel namesIllegal recursive call to close through close-handler of channelstdinstdoutstderrcan not find channel named "Tcl_CreateChannel: NULL channel namecouldn't find state for channel "reading and writing both disallowed for channel "could not flush channel "unable to access channel: invalid channelTclFlush, closed channel: queued output leftFlushChannel: damaged channel listTcl_SpliceChannel: trying to add channel used in different listcalled Tcl_Close on channel with refCount > 0iso8859-1blocking buffering buffersize encoding eofchar translationmalformed option list in channel driver": should be one of or --bufferinglinenonefull-buffersize-eofchar%c-translationautocrcrlflfunable to set channel options: background copy in progressbad value for -buffering: must be one of full, line, or nonebad value for -eofchar: should be a list of zero, one, or two elementsbad value for -translation: must be a one or two element listplatformtcpbad value for -translation: must be one of auto, binary, cr, lf, crlf, or platformchannelId event ?script?event namechannel is not channel "" is busyerror reading "error writing "unknown eol translation modeTcl_Write: AUTO output translation mode not supportedTcl_Write: unknown output translation modeerror setting blocking mode: -nonewlinenonewlinebad argument "": should be "nonewline"?-nonewline? ?channelId? string" wasn't opened for writingchannelIderror flushing "channelId ?varName?" wasn't opened for readingchannelId ?numChars? or " ?-nonewline? channelId"startcurrentendchannelId offset ?origin?originerror during seek on "channelId ?optionName? ?value? ?optionName value?...-keepnewline?switches? arg ?arg ...?error reading output from command: fileName ?access? ?permissions?Tcl_OpenCmd: invalid mode valuetclTCPAcceptCallbacksRegisterTcpServerCleanup: damaged accept record table-async-myaddr-myport-serverTcl_SocketObjCmd: bad option index to SocketOptionsOption -myport is not valid for serverswrong # args: should be either: ?-myaddr addr? ?-myport myport? ?-async? host port -server command ?-myaddr addr? portno argument given for -myaddr optionno argument given for -myport optioncannot set -async option for server socketsno argument given for -server option-sizeinput output ?-size size? ?-command callback?transform failed to stack channel "create/writecreate/readdelete/writeflush/writeflush/readdelete/readquery/maxReadclear/readcouldn't open socket: port number too highnativeglob couldn't determine the current working directoryillegal access mode " while processing open access modes "RDONLYWRONLYRDWRAPPENDCREATEXCLNOCTTYNONBLOCKTRUNCinvalid access mode "": must be RDONLY, WRONLY, RDWR, APPEND, CREAT EXCL, NOCTTY, NONBLOCK, or TRUNCaccess mode must include either RDONLY, WRONLY, or RDWRcouldn't read file " (file "%.150s" line %d)POSIXcould not seek to end of file while opening "couldn't open "couldn't load library "0700Tcl_FSGetFileSystemForPath called with object with refCount == 0can't find objectstring representationCalled UpdateStringOfFsPath with invalid objectlinked variable is read-onlyinternal error: linked variable couldn't be readvariable must have integer valuevariable must have real valuevariable must have boolean valueinternal error: bad linked variable typeNULL??Tcl_SetListObj called with shared objectTcl_ListObjAppendList called with shared objectTcl_ListObjAppendElement called with shared objectTcl_ListObjReplace called with shared objectlist index out of rangeTcl_ListObjSetElement called with shared objectSetListFromAny: bad size estimate for listfileName ?packageName? ?interp?must specify either file name or package nametclLoadpackage "" isn't loaded staticallycouldn't figure out package name for _Init_SafeInitcouldn't find procedure can't use package in a safe interpreter: no _SafeInit procedurefile "" is already loaded for package "{ {argvargcargv0application-specific initialization failed: exit %dtcl_prompt2tcl_prompt1% (script that generates prompt)nsNameTrying to push call frame for dead namespacecan't create namespace "": only global namespace can have empty namecan't create namespace "": already existsinvalid export pattern "": pattern can't specify a namespaceauto_importempty import patternunknown namespace in import pattern "no namespace specified in import pattern "import pattern "" tries to import from namespace "" into itself" would create a loop containing command "can't import command "unknown namespace in namespace forget pattern "DeleteImportedCmd: did not find cmd in real cmd's list of import referencesCould not create namespace '%s'unknown namespace "unknown command "unknown variable "childrencodeexportforgetimportinscopeparentqualifierswhichsubcommand ?arg ...?" in namespace children command?name? ?pattern?arg::namespace?name name...?" in namespace delete commandname arg ?arg...? (in namespace eval "%.200s" script line %d)?-clear? ?pattern pattern...?-clear?pattern pattern...??-force? ?pattern pattern...?" in inscope namespace command (in namespace inscope "%.200s" script line %d)" in namespace parent command?-command? ?-variable? name-variablewideIntcmdNameUpdateStringProc should not be invoked for type %sTcl_SetBooleanObj called with shared objectexpected boolean value but got "%.50s"Tcl_SetDoubleObj called with shared objectexpected floating-point number but got "%.50s"Tcl_SetIntObj called with shared objectstring->integer conversion failed to convert the obj.integer value too large to represent as non-long integerexpected integer but got "%.50s"Tcl_SetLongObj called with shared object%lldTcl_SetWideIntObj called with shared objectcan't parse a NULL pointerextra characters after close-quoteextra characters after close-braceParseTokens encountered unknown charactermissing close-brace for variable namemissing )$missing close-brace: possible unbalanced brace in commentmissing "LITERALFUNCNAME[()ENDUNKNOWN_CHARextra tokens at end of expressionmissing colon from ternary conditionallooking for close parenthesisexpected parenthesis enclosing function argumentsvariable references require preceding $commas can only separate function argumentspremature end of expressionsingle equality character not legal in expressionscharacter not legal in expressionsunexpected ternary 'then' separatorunexpected ternary 'else' separatorunexpected close parenthesisunexpected operator %smissing close parenthesis at end of function callsyntax error in expression "%.60s...": writingreading" wasn't opened for couldn't file "can't specify "" as last word in commandchild process lost (is SIGCHLD ignored or trapped?)error waiting for process to exit: CHILDSTATUSCHILDKILLEDchild killed: CHILDSUSPchild suspended: child wait status didn't make sense error reading stderr output file: child process exited abnormallyillegal use of | or |& in commandcouldn't create input file for command: couldn't create input pipe for command: couldn't create output pipe for command: couldn't create error file for command: must specify "couldn't create pipe: can't read output from command: standard output was redirectedcan't write input to command: standard input was redirectedpipe for command could not be createdconflicting versions provided for package ", then Cannot load package "" in standalone executable: This package is not compiled with stub support ("package ifneeded" script){} -exact ("package unknown" script)can't find package version conflict for package "": have , need package is not presentifneededpresentproviderequirevcompareversionsvsatisfiespackage version ?script?package ?version??-exact? package ?version??command?version1 version2Tcl_PackageObjCmd: bad option index to pkgOptionsexpected version number but got "E2BIGEACCESEADDRINUSEEADDRNOTAVAILEAFNOSUPPORTEAGAINEALREADYEBADFEBADRPCEBUSYECHILDECONNABORTEDECONNREFUSEDECONNRESETEDEADLKEDESTADDRREQEDOMEDQUOTEEXISTEFAULTEFBIGEHOSTDOWNEHOSTUNREACHEIDRMEINPROGRESSEINTREINVALEIOEISCONNEISDIRELOOPEMFILEEMLINKEMSGSIZEENAMETOOLONGENETDOWNENETRESETENETUNREACHENFILEENOBUFSENODEVENOENTENOEXECENOLCKENOMEMENOMSGENOPROTOOPTENOSPCENOSYSENOTBLKENOTCONNENOTDIRENOTEMPTYENOTSOCKENOTSUPENOTTYENXIOEOVERFLOWEPERMEPFNOSUPPORTEPIPEEPROCLIMEPROCUNAVAILEPROGMISMATCHEPROGUNAVAILEPROTONOSUPPORTEPROTOTYPEERANGEEREMOTEEROFSERPCMISMATCHESHUTDOWNESOCKTNOSUPPORTESPIPEESRCHESTALEETIMEDOUTETOOMANYREFSETXTBSYEUSERSEXDEVunknown errorargument list too longpermission deniedaddress already in usecan't assign requested addressaddress family not supported by protocol familyresource temporarily unavailableoperation already in progressbad file numberRPC structure is badfile busyno childrensoftware caused connection abortconnection refusedconnection reset by peerresource deadlock avoideddestination address requiredmath argument out of rangedisk quota exceededfile already existsbad address in system call argumentfile too largehost is downhost is unreachableidentifier removedoperation now in progressinterrupted system callinvalid argumentI/O errorsocket is already connectedillegal operation on a directorytoo many levels of symbolic linkstoo many open filestoo many linksmessage too longfile name too longnetwork is downnetwork dropped connection on resetnetwork is unreachablefile table overflowno buffer space availableno such deviceno such file or directoryexec format errorno locks availablenot enough memoryno message of desired typebad protocol optionno space left on devicefunction not implementedblock device requiredsocket is not connectednot a directorydirectory not emptysocket operation on non-socketoperation not supportedinappropriate device for ioctlno such device or addressfile too bignot ownerprotocol family not supportedbroken pipetoo many processesbad procedure for programprogram version wrongRPC program not availableprotocol not supporedprotocol wrong type for socketmath result unrepresentablepathname hit remote file systemread-only file systemRPC version is wrongcan't send afer socket shutdownsocket type not supportedinvalid seekno such processstale remote file handleconnection timed outtoo many references: can't splicetext file or pseudo-device busytoo many userscross-domain linkSIGABRTSIGALRMSIGBUSSIGCHLDSIGCONTSIGEMTSIGFPESIGHUPSIGILLSIGINTSIGIOSIGKILLSIGPIPESIGPROFSIGQUITSIGSEGVSIGSTOPSIGSYSSIGTERMSIGTRAPSIGTSTPSIGTTINSIGTTOUSIGURGSIGUSR1SIGUSR2SIGVTALRMSIGWINCHSIGXCPUSIGXFSZunknown signalalarm clockbus errorchild status changedcontinue after stopEMT instructionfloating-point exceptionhangupillegal instructioninterruptinput/output possible on filekill signalwrite on pipe with no readersprofiling alarmquit signalsegmentation violationstopbad argument to system callsoftware termination signaltrace trapstop signal from ttybackground tty readbackground tty writeurgent I/O conditionuser-defined signal 1user-defined signal 2virtual time alarmwindow changedexceeded CPU time limitexceeded file size limitTcl_Release couldn't find reference for 0x%xTcl_EventuallyFree called twice for 0x%x procbodyname args bodycan't create procedure "": unknown namespace": bad procedure name" in non-global namespace with name starting with ":"": arg list contains %d entries, precompiled header expects %d" has argument with no name" has formal parameter "" that is an array element": formal parameter %d is inconsistent with precompiled body": formal parameter "" has default value inconsistent with precompiled body" that is not a simple nametoo many fields in argument specifier "?level? command ?arg ...? ("uplevel" body line %d)body of proc ?TclObjInterpProc: local variable %s is not argument but should beTclObjInterpProc: local variable %d is temporary but should be an argumenta precompiled script jumped interps (compiling %s "%.*s%s", line %d) (procedure "%.*s%s" line %d)called ProcBodySetFromAnycalled ProcBodyUpdateStringerror while matching regular expression: REG_UBACKREFREG_ULOOKAHEADREG_UBOUNDSREG_UBRACESREG_UBSALNUMREG_UPBOTCHREG_UBBSREG_UNONPOSIXREG_UUNSPECREG_UUNPORTREG_ULOCALEREG_UEMPTYMATCHREG_UIMPOSSIBLEREG_USHORTEST%uREGEXPcouldn't compile regular expression pattern: 'l' modifier may not be specified in % conversionunmatched [ in format stringbad scan conversion character "field width may not be specified in %c conversionvariable is assigned by multiple "%n$" conversion specifiersvariable is not assigned by any conversion specifiersdifferent numbers of variable names and field specifiersstring format ?varName varName ...?%llu%luTcl_SetStringObj called with shared objectTcl_AttemptSetObjLength called with shared objectTcl_AppendToObj called with shared objectTcl_AppendUnicodeToObj called with shared objectTcl_AppendStringsToObj called with shared objectalloc: could not allocate new cachealloc: could not allocate %d new objectssharedthread%d%d %d %d %d %d %d %dalloc: invalid block: %p: %x %x %x This interpreter does not support stubs-enabled extensions.canceltclAfterafter#%dargument": must be cancel, idle, info, or a numberid|commandscript script ...?id?event "timerTcl_AfterObjCmd: bad subcommand index to afterSubCmdsafter# ("after" script)end-offsetlist element in braces followed by "%.*s" instead of spacelist element in quotes followed by "%.*s" %sinstead of spaceunmatched open brace in listunmatched open quote in listinternal error in Tcl_SplitListcan't modify precision from a safe interpreterimproper value for precision%%.%dg0123456789TclLooksLikeInt: cannot scan %d bytes from NULLbad index "": must be integer or end?-integer?end-": must be end?-integer? (looks like invalid octal number)variable is arrayvariable isn't arrayno such element in arrayupvar refers to element in deleted arrayupvar refers to variable in deleted namespaceparent namespace doesn't existmissing variable namename refers to an element in an arraylocalVarNamenamespaceVarNameparsedVarNamearray searchvarName ?newValue?bad result flag combination?-nocomplain? ?--? ?varName varName ...?varName ?value value ...?anymoredonesearchgetnextelementstartsearchstatisticsoption arrayName ?arg ...?arrayName searchIdarrayName ?mode? ?pattern?arrayName listarrayNames-1-s-error reading array statisticsarrayName ?pattern?" isn't an arraylist must have an even number of elementsarray setaccessObjMakeUpvar called with an index outside from a proc. bad variable name "": upvar won't create namespace variable that refers to procedure variablecan't upvar from variable to itselfvariable "" has traces: can't use for upvarvarName ?varName ...??name value...? name ?value?define?level? otherVar localVar ?otherVar localVar ...?trace arrayillegal search identifier "search identifier "" isn't for variable "couldn't find search "ERROR: scalar parsedVarName without a string rep. ttyCTSDSRRINGDCD-mode-handshakeXONXOFFRTSCTSDTRDSR-handshake DTRDSR not supported for this platformbad value for -handshake: must be one of xonxoff, rtscts, dtrdsr or none-xcharbad value for -xchar: should be a list of two elements-timeout-ttycontrolbad value for -ttycontrol: should be a list ofsignal,value pairsDTRRTSBREAKbad signal "" for -ttycontrol: must be DTR, RTS or BREAKmode handshake timeout ttycontrol xchar %d,%c,%d,%d-queue-ttystatusmode queue ttystatus xcharbad value for -mode%d,%c,%d,%d%n: should be baud,parity,data,stopnoe parity: should be n, o, or e data: should be 5, 6, 7, or 8 stop: should be 1 or 2TclpOpenFileChannel: invalid mode value/dev/ttyfile%dauto crlfserial%d-error-peernamecan't get peername: -socknamecan't get sockname: peername socknamecouldn't open socket: sock%dTclGetDefaultStdChannel: Unexpected channel typepipecannot get a FILE * for "" cannot be used to get a FILE *TclWaitForFile can't handle file id %d-group-owner-permissions..%0#5locould not set group for file "": group "" does not existcould not set owner for file "": user "unknown permission string format "could not set permissions for file "PATH:/bin:/usr/bincouldn't read directory "error getting working directory name: /var/tmp/tclXXXXXX%dforked process couldn't set up input/output: %dcouldn't execute "%.150s": couldn't fork child process: ?channelId?Stardate %2d%03d.%01dTZgb2312-1980gb2312ja_JP.SJISshiftjisja_JP.EUCeuc-jpja_JP.eucJPja_JP.JISiso2022-jpja_JP.mscodeja_JP.ujisja_JPJa_JPJp_JPjapanjapanesejajapanese.sjisjapanese.eucjapanese-sjisjapanese-ujiskoeuc-krko_KRko_KR.EUCko_KR.eucko_KR.eucKRkoreanruiso8859-5ru_RUru_SUzhcp936/dev/nulllib/tcl%stcl%s/libraryTCL_LIBRARYansi_x3.4-1968LC_ALLLC_CTYPELANGCDYLD_FRAMEWORK_PATHunixUSERLOGNAMEtcl_libPathtcl_rcFileNamecom.tcltk.tcllibrary%u.%u.%u.%ucould not allocate lockTcl_InitNotifier: unable to start notifier threadTcl_FinalizeNotifier: notifier pipe not initializedNotifierThreadProc: could not create trigger pipe.NotifierThreadProc: could not make receive pipe non blocking.NotifierThreadProc: could not make trigger pipe non blocking._VersionsScripts_CFBundleOpenBundleResourceMapCoreFoundationC0GA.AC> A?@C0=A($6Q)5%*:&8! =2PL3KJIHGFE410/-'>N.ODA<CB7,? #+9;M "@@gigigigigigigigigigigigigi ,gigigigigigigigigigigi gigigigi gigigigigigigigigigigigigigigigi gigi0FEDBA@?><;:97       gi   -+ :/-   ,       ,.-:/--:        -:   5!*01/234  ,'#-)6"%$.+ 7(6& @@zR|A P zR|A     <[[:digit:]][^[:digit:]][:digit:][[:space:]][^[:space:]][:space:][[:alnum:]_][^[:alnum:]_][:alnum:]_alertESC                        ,  0  <  @  P  T  X  \  `  d  h  l  p  t  x  |                       !  "  #  $  %  &  '  (  ()  <*  H+  T,  \-  d-  t.  |.  /  /  0  1  2  3  4  5  6  7  8  9  :  ;  <  =  >  ?  0@  @[  T\  `\  p]  ^  ^  _  _  `  {  {  |  }  }  ~  (AZaz"3P1Va!:@Jq,  9 X a   ( * 0 Y \ r t   ( * 0 6 9 _ a     ( * 3 5 9     ( * 9 0@F@GIj!#'PUY_FJMPVZ]` FHZlov w EHMPW_}! !!!!*!-!/!1!3!901050A0000011,111114MNף-(*68@ACDt09`i f o f o f o f o f oPY )@Iiq!#%*,/[]Z_jm :=JOah  ' 0 C H M0000000DIRTa ;=ae:;?@_{}~  d e p OZ[mn E F } ~ #)#*000>?chjk ?[]  ( ) /0az~P0_a '07@EPW`gp}AZ   !#%')+-/13578:<>@BDFHIKMOQSUWY[]_acegikmoqsuwz|   #%')+-/13acegikmoqsuwy{}   !#%')+-/13579;=?ACEGIKMOQSUWY[]_acegikmoqsuwy{} ! !!!!/!4!9AZ/1V(/8?HMho! ! !!!!!*!-!:   "$&(*,.02469;=?ACEGJLNPRTVXZ\^`bdfhjlnprtvxy{}  "$&(*,.02`bdfhjlnprtvxz|~   "$&(*,.02468:<>@BDFHJLNPRTVXZ\^`bdfhjlnprtvxz|~Y[]_!!!!$!&!(!0!1!3!~!"3P!N`b!1VY_a!:@U`mp !,0J     ! 9 < M P T X p    ! ( * 0 > B K M Y \ f t      ! ( * 0 6 9 < C K M _ a f p        ! ( * 3 5 9 > D F H J M f o      ! ( * 9 > C F H J M f o !:?[!GIjq#',269@Y!Y_!FJMPVZ]`!FHZa|!!!v !w!!EHMPW_}   ! ) / F H M t !!!!!:!S!!!"""!"###!#{#}#$$$!$&$@$J$`$%%%!%%%&&&&&!&q'''' ' ''!''')'K'O'R'X'^'a'g'v'''''(((!(....///!///000!0:0A00000111!1,11111222!2C2`2{222222333!3v3{333444!55!66!77!88!99!::!;;!<>!??!@@!AA!BB!CC!DD!EE!FF!GG!HH!II!JJ!KK!LL!MM!MNNN!OO!PP!QQ!RR!SS!TT!UU!VV!WW!XX!YY!ZZ![[!\\!]]!^^!__!``!aa!bb!cc!dd!ee!ff!gg!hh!ii!jj!kk!ll!mm!nn!oo!pp!qq!rr!ss!tt!uu!vv!ww!xx!yy!zz!{{!||!}}!~~!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!¤Ĭ!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!ף!!-!680?>@ACDt  ,  4  <  D  L  T  \  d  l  t   |  H P*** unknown regex error code 0x%x ***              $  0  H  T  p  |          8 D \ h x         8 D @ \ l ` h t  |    .<   .|  1@   (l  3\  3    3  6  6  7  8<   H  _x  L8 t  M    R    ]p X  _l D  ` ( | 0  % 8 ~ ) @ D H  , P  / X  `  h  t  |  1    M0    L   <  l  x   DT   BP BT BX B` Bh Bp Bx B| 0 B 0 B0 B 0 B B < B x B B B , B h B  B  B  B X B  B  B B B L B  B B B \ B B B B l B 0 B        T    D   <  D     7 7 7 7| 7x 7p 7t 7` 7d 7h 7l 7X 7\ 7T / 7L  7P 7T / L 7 E E4 @ @ @ @ @ @ @ @ 7 7 E@ fp" EH fp# EP fp EX h<c E` fp@ Eh fp` El fp Et fpӠ Ex fpq` E h< E h< E fp E fp E h<@ E fp@ E fp ` E fp^ E fp@ E fp E j +  l E n8 E q E s0 E uD E p M N N N N$ N, (  Ҝ X  \    ӄ l  *p L  ڈ D R R R   d R R N R R S S S( S0 S8 S@ SL ( ST ( R R  R R N R R S S ST (  H ,  H   0 n Zx ^ D _ _ _$ _ ( `| ` ` ` b '4 X `  bX    X      0 d x c|   $ |  M Z  Y V P QP [ Yp Hd    9 ; 9 6 5 :| W @ W WD p  T$    <  t  H   @   # , i a$ a b a l l _   d l l l l _D l l  l BD BX  + | x, +  ~L E   n       n   ( q q r iD r r q  P r J r 7L  7P 7T / 7X 7\ 7` 7d 7h 7l 7p 7t 7x 7| 7 7 7 7  7 L 7 7 l x  x x x  x y y     ` $ |     $ @ x T d t   @         @ !L  _l \ ^d ] @@@   ? Lp Lp L   ( , ׬ s t x h a Δ <   d (d { P  8  P  . x  0  \ " B L  A Vx     ܘ < x Ѹ    h   X  e g l k  l@ h P X  0    Jh x o   d  ր 6H h ! ;0 2 5X 9 F F< " $ H @ T  0 1  ; 1 1 #T $x k l l X   X u X      ( @  ` , \  %8 %d  ^  T v  $ %  ,    n| n$  d ^` c ] ^ [4 [l 2d [  n nx 4       ِ d , &| (, 'T & (0 '  ( L 4  r [ T0 0 sX X H p w8  }T  4 s Kh t t0 4 w   } <    r u v  T , D  4 v  | , H  sx J w<   }X   8 P, O@   4 ,\ ,0 D T h 0 G L w X X  |  4   [0   e  ݐ  s$  0 \  $ h f  l  0 , tT $  lh wl    x d     E   X   @ ̄ H d P  p   =P .| ` | Ǹ  G  \ x  H p ذ  j    ) 0  &t & k L  (<     d Et E $ t h $  @  , <  XX ͜ L   + -T ( <  < f 0 ʴ Ք t  q|    d  .   D n i` Ƙ F N, P  1 k (  'l kD 1, (    \  p   !  D@ L d X <\ p  h ؀ ،  4     < T  T (X (` * Y 4 h ݌ ݔ و \ 0 D i D D (T   H , U $ 0  & c | 4  ,    ͜  פ _t $ @ @  l \ | 2h % $ Ѐ  oT g   P x  d H  @  H   x    P   @ u ˀ ˜      l  @    `  | p  | @ X d  p  $ 4 4    8   ( l ` Kl SD LX M0 M N T  e@ $ q` qh L a aX H 1  P FX t$ t, t t t t t t t u u u u uX X s r (   s8    l l  8  | 'L 'P ($ (( Q d N t ߀ ΄   H  H  x   Ȥ  @ @ L   $      p ڤ l (  \ ,     ( ռ        E  l d 4 ׈ P   T  @4 B u  B  x  v r u t  !"#$%&'()*+,-.//01234#/5##########6789:;<=>?@ABCDE:FGHIJKLMNOPQRSPQTUPVWXYZ[\#]^_#`abcdef#/gh##ijk//l//m/no/p/qrstr/uv#//wZ//////////////////xy//z####/{|}~//###############################################################################################Z/Z///##ŠƠ/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////##/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////##////////////////////////////////////#########################################################/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////##/////////######//////////////#///##########################################################################################################################///////////////////////////////////////////////////////////////////////////////////########################################/#########################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################            !"#$#%&'''(()*+****,-.,-.,-./,-.0123445647899:;<<<==>????????? ??????? ?? ????? ?@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@A@@@@@@@@@@@@ ? BCCCDEE FGGG H IJJKLMMMNOPQ/RSTTTTTTTTTTTTTTTT QQQQQQQQQQQQQQQQ@@@@UUMVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV?WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@********************************************************?**********@@@@@@@@@@@ @********************************************************************@@@@@@@UU@@@@@@??@@@@@@ ***X*@***************************@@@@@@@@@@@@@@@@@@@@@@@@@@@******@@@@@@@@@@@@@Y*****************************************************@*YYY@@@@@@@@YYYY@*@@@@**********@@ @YY********************************************@YYY@@@@YYYY@Y*****@@ **@*******************************************@YYY@@@@@@@***** @@***@@Y***********************************************@*YYY@@@@@@@YYY@** **********************@*Y@Y@@@YYYY@@Y***** @Y**********************************YY@YYYYYYYY@Y YYY*************************************************@@@YYYY@@@@@@@@@** YY*************************************************Y@YYYYY@YYYY@@YY**************************YYY@@@YYYYYY@YYY***********************************************************@YYY@@@@YYYYYYYYYY************************************************@**@@@@@@@******?@@@@@@@@ *****************************@**@@@@@@@@******?@@@@@@ ***@@ @@@YY******************************************@@@@@@@@@@@@@@Y@@@@@@@****@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@*********Y@@@@Y@@@Y@ ******YY@@MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM************************************************************************************************************************************************************************************************************************************************************************************************************************* *******************************************************************************ZZZ********************YYY@@@@@@@YYYYYYYY@YY@@@@@@@@@@@ XXXX ***?*************************************************************@[\\\\\\\\]]]]]]]]\\\\\\]]]]]]\\\\\\\\]]]]]]]]\\\\\\\\]]]]]]]]\\\\\\]]]]]]\\\\]]]]\\\\\\\\]]]]]]]]^^____``aabbcc\\\\\\\\dddddddd\\\\\\\\dddddddd\\\\\\\\dddddddd\\e]]ffg h eiiiig \\]]jj \\k]]llm ennoog XXXXpqXXXXX XXXXXX@@@@@@@@@@@@@UUUU@UUMMMMMMMMMMMMMMMrMstMMMMM****uuuuuuuuuuuuuuuuvvvvvvvvvvvvvvvvZZZZwwwwwwwwwwwwwwwwwwwwwwwwwwxxxxxxxxxxxxxxxxxxxxxxxxxx?*ZZZZZZZZZZ@@@@@@?????ZZZ*********************@@ ??*************************** ???*******************************************************************************************************************yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz***************@******************************************************************************************************************************************************************************************@@@@  *******************************************X   **********?*********************************************??**************************************************** XXX***{{{~~Y@MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM **XXXXXXXzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz  A F@@A@@A:AK4A3A3@AA2A2A3A4A4@A5@A5A6A6@A6Aa@AA433@2234@45@566@6 A @AAA @@ AA A  ACAC @AA@A@AAA A@AAJ]AA12%.12g  |  P C      4 T l         @   |  4   L P X d d  h   t   & & & X   P  t       P   t   \ # " #< $ ' ( !T  -    A @t X f g4 g h$ h eP oif {[info proc tclInit]==""} { proc tclInit {} { global tcl_libPath tcl_library errorInfo global env tclDefaultLibrary rename tclInit {} set errors {} set dirs {} if {[info exists tcl_library]} { lappend dirs $tcl_library } else { if {[info exists env(TCL_LIBRARY)]} { lappend dirs $env(TCL_LIBRARY) } catch { lappend dirs $tclDefaultLibrary unset tclDefaultLibrary } set dirs [concat $dirs $tcl_libPath] } foreach i $dirs { set tcl_library $i set tclfile [file join $i init.tcl] if {[file exists $tclfile]} { if {![catch {uplevel #0 [list source $tclfile]} msg]} { return } else { append errors "$tclfile: $msg $errorInfo " } } } set msg "Can't find a usable init.tcl in the following directories: " append msg " $dirs " append msg "$errors " append msg "This probably means that Tcl wasn't installed properly. " error $msg } } tclInit/usr/lib/tcl8.4~/Library/Tcl /Library/Tcl /Network/Library/Tcl /System/Library/Tcl ~/Library/Frameworks /Library/Frameworks /Network/Library/Frameworks /System/Library/Frameworks222 : @  $ <_ P x  xn `     ܐoI@ (, 'T`Ӡ< &|`v oT  @  aX _t L < P, U }  w    X ( u t $   | h  T  , T X 1 . T J   ( T0 4 ׈ j x  X  'l i u Jh B F [ )`   $ P t0 .| 5X  $ 6H    l  qH ِ { d      ܘ ݐ  2 P d  sx ,  |   ` 8\ ,0 , < T   v  g h e O@ 4 l  x l  l@ k l l d |  d  ,   D ( l T ռ | m  X ~ Ȥ \ w< x  $ | qh  L @  Ѐ ͜     0 <  p   l @  0 ͜ l |  4    ~  A   "  j ߀    0 1 H  8  d & X (< % $ 4 L | 8  <  p ΄    P    SD    4   T Kl N N ` M0 LX @    d   (   x  h p   T < GT z d   t  b  ( x, z \ @ yD  X  ` v p  H 2h  h X &t N, NP  , $     ،Ġ   lh b 8 d(   (h pt  $4 bx (    p  c 0   o o _` p w =P   t 4 wl Ƙ Ǹ    }X  { P   \   M   H <  \     $  H  H @ x (  @  ڤ   d Vx @  d  0 l t פ ؀  ̄ 0   ,\ $  h   1  L h s$ uX t$   E E  t` | &   4 4 tT (  \ . a +  -T  k    d   H B @4 Et E  @ XX u t u \ t p 1  H  U  sX      0   9 @  , ]$ 0    0   v   h P  \   L [0 p $ pV <  ذ   x  L`  d q| @    l c ^ ] [ ^` \  i [l [4 ݔ  dʀ  1   1 0   < < \  |   'L ($      |       6`   $ 4 f k f e    4  T ` H @ 5@7ހ`54 d 4)`  2d`  Ԑ n 3 3 7 G 5|    (`@@ Y  -@ Ȑ_@: @Dà\@ Xp] t  @ ʴ  ,"`N@o`[ |L@ @Ӏ@ n$ n|u Ơ    d N 2DЀ@  ˀ e`Q `@ aJ } a`? a<+@ 6p  j`4` l a \` v ^W̠ȐА$,e( l $ L   (  P    t @ X   @ (  l    8       _     h 1n  1 4 G 3T D  2D  1 줐 `` XX  h B$ D C E C F             ,  8  @  H  P  X  d  h  x                            (@@@@@Ǽ@Ǹ@Ǵ@ǰ@Ǭ@Ǩ@Ǥ@Ǡ@ǜ@ǘ@ǔ@@@@@@@@@@@@x@p@h@`@X@P@H@@@8@0@(@ @@@@@@@@@@@@@@@@@@@@@x@p@h@`@X@P@H@@@8@0@(@ @@@@@@@@@@@@@@@@@@@@@x@p@h@`@X@P@H@@@8@0@(@ @@@@@@@@@@@@@@@@ȸ@ȴ@Ȭ@Ȩ@Ƞ@Ȝ@Ȕ@Ȑ@Ȉ@Ȅ@|@x@p@l@d@`@X@T@L@H@@@<@4@0@(@$@@@@ @@@@@@@@@μ@Ψ@Δ@΀@l@X@D@0@@@@@@͸@ͤ@͐@|@h@T@@@,@@@@@@̴@̠@̌@x@d@P@<@(@@@@@@˰@˜@ˈ@t@`@L@8@$@@@@@@ʬ@ʘ@ʄ@p@\@H@4@ @ @@@@ɼ@ɨ@ɔ@ɀ@l@X@D@0@@@@@$@ @@@@@ @d@`@X@T@L@H@D@@@ @@@@@@@@@@@@@@@@@@@ϼ@ϸ@ϴ@ϰ@Ϭ@Ϩ@Ϥ@Ϡ@Ϝ@Ϙ@ϔ@ϐ@ό@ψ@τ@π@x@t@p@l@@@@м@и@д@а@Ь@Ш@Р@М@И@Д@А@Ќ@Ј@Є@Ѐ@|@x@t@p@l@d@`@\@X@T@P@L@H@D@@@<@8@4@0@,@(@$@ @@@@d@`@\@X@P@L@H@D@<@8@0@,@(@$@@@@@ @@@@@@@@@@@@@@@@@Ѽ@Ѹ@Ѵ@Ѱ@Ѭ@Ѩ@Ѥ@Ѡ@ќ@ј@ѐ@ь@ш@ф@р@|@x@t@p@l@h@d@`@\@X@T@P@L@H@D@@@8@4@0@,@(@$@ @@@@ @@@@@@@@@@@@@@@@@Ҽ@Ҹ@Ҵ@Ұ@Ҭ@Ҩ@Ҥ@Ҡ@Ҝ@Ҙ@Ҕ@Ґ@Ҍ@҈@҄@Ҁ@|@x@t@p@l@h@@@Ӽ@Ӱ@Ӥ@Ә@ӌ@Ӏ@t@h@\@P@D@8@,@ @@@@@@@@D@<@8@4@@@@ܼ@ܤ@܌@t@\@D@,@@@@@۴@ۜ@ۄ@l@T@<@$@ @@@@ڬ@ڔ@|@d@L@4@@@@@ټ@٤@ٌ@t@\@D@,@@@@@ش@؜@؄@l@T@<@$@ @@@@׬@ה@|@d@L@4@@@@@ּ@֤@֌@t@\@D@,@@@@@մ@՜@Մ@l@T@<@$@ @@@@Ԭ@Ԕ@|@d@L@4@@@@@x@l@`@T@H@<@0@$@@ @@@@@@@@@@@@|@p@d@L@@@4@(@@@@@@@@@@@@@@@t@h@\@P@D@8@,@ @@@@@@@@@@@@@@x@l@`@T@H@<@0@$@@ @@@@@@@߸@߬@ߠ@ߔ@߈@p@d@X@L@@@4@(@@@@@@@@޼@ް@ޤ@ޘ@ތ@ހ@h@\@P@D@8@,@ @@@@@@@@@ݴ@ݨ@ݜ@ݐ@݄@x@l@`@T@L@H@@@@@@@@@@@@@@@@@@@H@,@$@@@@@@@@@x@p@T@L@0@(@ @@@@@@@@|@t@X@P@4@,@@@@@@@@@@x@\@T@8@0@@ @@@@@@@@@@@@@@@@|@x@t@p@l@h@d@`@\@X@T@P@L@H@D@@@<@8@4@0@,@(@$@ @@@@@@@|@x@@@@@@@@@@@@@@@@@@@@@@@@@@@@|@x@t@p@l@h@`@\@T@P@H@D@@@<@8@4@0@,@(@$@ @@@@@ @@@@@@@@,@(@$@@@@ @@@@@@@@l@h@d@\@T@P@L@H@D@@@<@8@0@ @@@@@ @@ @ @@@@@@@@@|@p@$@8@4@0@,@(@<@@@@@@@@@@|@x@t@p@l@h@d@`@\@X@T@P@L@H@D@$@@@@@ @@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@|@x@t@p@l@h@d@`@\@X@T@P@L@H@D@@@<@8@4@0@,@(@@@@@@@@@@@@@@@@@@@@@@@@@|@t@l@d@\@T@L@D@<@4@,@$@@@@ @@@@@@d@`@ @ @ @ @@@@@@@@@@ 1@ 1@ 1@ 1@ 2@ 2@ 2@ 2@ 2|@ 2x@ 2t@ 2p@ 2l@ 2h@ 2d@ 2`@ 2\@ 2X@ 2T@ 2D@ 2<@ 28@ 24@ 20@ 2$@ 2 @ 2@ 2@ 2@ 2 @ 2@ 2@ 2@ 1@ 1@ 1@ 1@ 1@ 1@ 1@ 3P@ 3L@ 3<@ 34@ 30@ 3,@ 3 @ 3@ 3@ 3@ 3@ 2@ 2@ 2@ 2@ 2@ 2@ 2@ 2@ 2@ 2@ 2@ 2@ 2@ 2@ 2@ 2@ 2@ 3h@ 3d@ 3\@ 3X@ 3T@ G @ G@ G@ G@ G@ G @ 3@ 3@ 3@ 3|@ 3x@ 3t@ 3l@ 3@ G@ G@ G@ G@ G@ G@ G@ G@ G@ G@ G@ G@ G@ G@ G@ G@ G@ G@ G@ G@ G@ G@ G@ G@ G@ G@ G@ G@ G@ G@ G@ G|@ Gx@ Gt@ Gp@ Gl@ Gh@ Gd@ G`@ G\@ GX@ GT@ GP@ GL@ GH@ GD@ G@@ G<@ G8@ G4@ G0@ G,@ G(@ G$@ :8@ :4 @ :D@ :@@ :H@ H@ H @ : l : l : l : l : l : l : l : l : l : l : l : l :| l :x l :t l :p l :l l :h l :d l :` l :\ l :X l :T l : l : l : l : l : l : l : l : l : l : l <4 l <0 l <, l <( l <$ l < l < l < l < l < l < l < l < l < l ; l ; l ; l ; l ; l ; l ; l ; l ; l ; l ; l ; l ; l ; l ; l ; l ; l ; l ; l ; l ; l ; l ; l ; l ; l ; l ; l ; l ; l ; l ; l ; l ;| l ;x l ;t l ;p l ;l l ;h l ;d l ;` l ;\ l ;X l ;T l ;P l ;L l ;H l ;D l ;@ l ;< l ;8 l ;4 l ;0 l ;, l ;( l ;$ l ; l ; l ; l ; l ; l ; l ; l ; l ; l : l : l : l : l : l : l : l : l : l : l x l >t l >p l >l l >h l >d l >` l >\ l >X l >T l >P l >L l >H l >D l >@ l >< l >8 l >4 l >0 l >, l >( l >$ l > l > l > l > l > l > l > l > l > l = l = l = l = l = l = l = l = l = l = l = l > l > l > l > l > l > l > l > l > l > l > l > l > l > l > l > l >| l > l > l > l > l > l > l > l > l > l > l > l > l > l > l ? l > l > l ?@ l ?< l ?8 l ?4 l ?0 l ?, l ?( l ?$ l ? l ? l ? l ? l ? l ? l ? l ? l ?X l ?T l ?P l ?L l ?H l ?D l ? l ? l ? l ? l ? l ? l ? l ? l ? l ? l ? l ? l ? l ? l ? l ? l ? l ? l ? l ? l ? l ? l ? l ? l ? l ? l ? l ? l ? l ?| l ?x l ?t l ?p l ?l l ?h l ?d l ?` l ?\ l @D l @@ l @< l @8 l @4 l @0 l @, l @( l @$ l @ l @ l @ l @ l @ l @ l @ l @ l @ l ? l ? l ? l @ l @ l @| l @x l @t l @p l @l l @h l @d l @` l @\ l @X l @T l @P l @L l @H l @ l @ l @ l @ l @ l @ l @ l @ l @ l @ l @ l @ l A l @ l @ l @ l @ l @ l @ l @ l @ l @ l @ l @ l @ l @ l @ l @ l @ l @ l @ l AX l AT l AP l AL l AH l AD l A@ l A< l A8 l A4 l A0 l A, l A( l A$ l A l A l A l A l A l A l A l A l A l A l A l A l A l A l A l A l A l A| l Ax l At l Ap l Al l Ah l Ad l A` l A\ l A l A l A l A l A l A l A l A l A l A l A l A l A l A l A l A l B4 l B0 l B, l B( l B$ l B l B l B l B l B l B l B l B l B l A l A l A l A l A l A l A l B8 l BL l BH l BD l B@ l B< l BP l B\ l BX l BT l Bx l Bt l Bp l Bl l Bh l Bd l B` l B l B l B| l B l B l B l B l B l B l B l B l B l B l B l B l B l B l B l B l B l B l B l B l B l B l B l B l B l B l B l B l C l C l C l C l C l C l B l B l C, l C( l C$ l C l C l C l C8 l C4 l C0 l C@ l C< l Ch l Cd l C` l C\ l CX l CT l CP l CL l CH l CD l C l C| l Cx l Ct l Cp l Cl l C l C l C l C l C l C l C l C l C l C l C l C l C l C l C l DP l DL l DH l DD l D@ l D< l D8 l D4 l D0 l D, l D( l D$ l D l D l D l D l D l D l D l D l D l C l C l C l C l C l C l C l C l C l C l C l C l C l C l C l C l D l D l D l D l D l D l D l D l D l D l D l D l D l D l D l D| l Dx l Dt l Dp l Dl l Dh l Dd l D` l D\ l DX l DT l D l D l D l D l D l E l E l E l E l D l D l D l D l D l D l D l D l D l D l D l D l E l E4 l E0 l E, l E( l E$ l E l E l E l E l Ed l E` l E\ l EX l ET l EP l EL l EH l ED l E@ l E< l E8 l E l E l E l E l E l E l E l E l E l E l E l E l E l E l E l E l E l E l E l E l E l E| l Ex l Et l Ep l El l Eh l E l E l E l E l E l E l E l E l E l F l F l F l F l F l F l F l F l E l E l F l F$ lS@ :LSe S{ :PS S S S lS S <T `T  8T  T T& T3  T? #4TH #TN #TW $hT_ 'Th (<Tr +|T} /PT /T 0T 1lT 5T 5T 6T 7PT 7T 8<T 8T 8T 9HT 9T : U :U ;U <U! <U) =0U1 ?U7 @(UA @UK DUT U[ Ub 6Uk HUr ^Uy vU U U U DU D@U U U QTU VLU XHU \pU ](U ]0U ]U ^HV ^V  _V `V  `V* b<V5 cVB dVL dVT e4V^ f4Vh gVr i V~ i@V iV iV jV kV mV mV nV nV o8V oV oW q W  qW s4W spW& sW/ sW8 tHWB tWL uWW ulW_ uWl v`Wt vW wW wW xlW ypW zW |W ~W W W W W W X  `X X X( X2 X; XE XN hXY Xa Xk Xt |X| X X X X X zX X :X X Y  Y NY, Y= YM TY^ ƘYn Yv Y Y Y Y LY `Y ǔY 4Y Y HY PY 4Y Y Y Y Z Z  Z Z Z* xZ4 \ZA ZN ZZ Zg Zp Zz tZ Z Z ,Z TZ |Z @Z Z Z Z Z H$Z Z H(Z H,[  `[ T[0 [I h[Z  [q [ [  [ [  [ ,[ D[ 8\ "P\ &\) @\5 T\G `\W H0\c ,\p l\ π\ \ F\ F\ G\ Kt\ \ c\ d\ e]  e] i\]. i]> k]M lh]_ m]o n] oT] p] qT] q] r] t] t] u ^ w^ xP^% x^8 yD^E l^P Ш^\ ^g ^s ^ ^ ^ ^ ^ ^ @^ ј^ ^ ^ _  $_ 8_& D_3 _E _Y h_q _ \_ H_ _ t_ \_ H4_ _ H8_ H<` d` k`. o`? q`T u`d w`} w` w` l` ` ` H` Ha  Hta ,a6 XaG PaX Tag ހas a ߈a da a a a a Ha $a a b 0b b b) Db5 HbC HbP Hb^ Hbj Hbw Hb Hb Hb Hb Hb Ib Ib Ib Hc  Hc% Hc5 HcF HcW I cj Hc} Hc Hc c  c 4c |c c c |c d Id ILd) Id8 IPdI ITdY dg dy ٴd d ڀd IXd d <d d d e  De e0 e@ TeR ea er e e e e e KXe K\e K`e Kde e hf Khf Klf( Kpf? KtfR fb fu Kxf K|f f f  f Kf  f fpf h<f jg lg n8g" qg0 s0g? uDgN pg\ gs Kg~  $g g ^Tg bg dg eg wh  |h xh- \h> PhL dhZ Khc ht Th h h h dh xh h Ҝh Xh i \i i' i9 ӄiD iQ i_ Lij it ڈi Di Ki Hi i Pi \i i i Kj 4j j$ \j/ j< ,jS `j^ \jk hjv j Hj j Hj j j j j 4k k Kk hk/ DkC lkc  kr k 8k k ,k k 4k k  k "l $l %l! ,hl3 .l> /lQ 2l^ 4li 6lt 9l =l >Xl Ddl Wl Yl Zxl ]8m ^ m m* m7 bmA gxmI h\ma kmm lmv nm nm p<m pm tPm m m m n 8n$ nJ `n^ Xnr n n 0n n n n Xn o  o%  o9 oU om 0o do 0o xo o ,o @o Ho p Kp Kp$ Kp= $pT pk p p p p p p Kp Kq tq Kq Kq) $qB 4qX Kqi qv q q Kq q ɰq q r   r# <r5 (rC rR |r\  rq  @r  r  r r tr r r Ks  Ks #s) Ks? KsM ,sX /s` Ksn a$s as bs as Ks 8s BDs BXt Kt Xt! Ot7 QtI Slt^ Ttr U0t Vt Wt X\t Xt Yt [t \u ]u) ^u; _uN KuW Kua Kus gu Ku |u x,u u ~Lu u v  v  v3 v? vO v^ vl v| v v (v Lv Kv v L v L$w  w w% @w2 wC (wR xwa wo pw~ w w Pw w w tw w x  lx x+ x6  xL Ƥxb hxr L(x{  x L,x x x x x L0x L4x x L<y L8y y y+ `yA $yU tyl |y| $y @y xy  y  y y L@y !y !Lz $ z! -z4 /PzD 2zR 4z] 5zm 5z} _lz \z ^dz ]z Vz W{ X{ Y({. [{> LD{I LP{V L\{b `0{v `{ `{ Lp{ d{ d{ Lh{ Ll{ l4{ l|{ l{ m{ m||  m| nd|" |0 p|@ r$|K M|T r|c t|s u| v| | ~| x| h| | | | /| }  } 1}& 1}7 |}P }e M}u 1} 1} 1} 1} 1} 1} 1} 2} 2}  }  ~  ~#  ~2  @~@  |~S  4~e  ~z L~ 2X~ 2~ $~ (~ \~ ~ P~ L   | H$ 25 D S Pc  q t     2    3  # "& #<5 $G 'U ( g !Ty   8 3L  T ! ( * , -& B$9 DL C_ Er C F 6, 7 8 :$ < = @t A  A. HE T|V 3lg fv g4 g h$ h eP a b M N M  N N n. N7 oF 3R Nd Nt N 7l 8D G$ ` 9 9 : :4 N  N N N* N: :<G NP N_ Oo O{  $ O O   P   \     l% $/  <  % 1 B S Db 8t T  D Ѹ      4- LB U g ݐ{  d  0  $ 0  $ 6 X@ L Y h v p  ̄ H d   P  ( Ǹ: R f 4 ذ t    $ ߀ | Ƙ, P@ ׈] t  D x    \ < x , D Y n      ' 'T (, (X (d (T  (`! &|, 'PB 'LT (hp (( ($ & (0 (l 2@ R M L8  9 .<- 8<= 7M 6] 6n 3 3 3\ 1@ .|  ` _l ]p | ~ * = DP d t    ~    ,     ) l ; x M  _ 4 p   P      ֬  |      ΄  8 ! D 9  R  i /  L  GT  DT  1  <       ! h 6  J t \  r U  h  W  ,  X  D  %  )  b # d ; z N  e d |         (  4  u  h  8 3  C  S  h   yD  @  t        x 0 TD ] x,q p z O  Qx O  O L S S H S S& X4 SB OO O_ Sm  ˀ 4 Ѐ  ͜   ˜% x? ] w $ |    ( \    + 7 H e ps `  , H @   ,  ! h6 0S j |      {    |    |0 $B dM d] xn w     0 t X   h \+ = L X \d 4t   l d     l. B l[ 4j Ք} t <  פ T  ܘ X t' 48 I `W |h {  L    t$ uX u u u+ tA tX FXm t G a ^  \  2h  $ (4 L [0f  y   u u t, t qh t t3 tI  h`  u =P    N, &t   @      X <\% D@2 B< N a t F D @4 1 0 E XX  H _x s$ r= s8T Eg Ety & P  H p d H q` - xA \] s G E    , 8  u z D w% }T5 ~E HV h xx    d  p ̌    l0 < LI ` 0|   X <      p" (8 V o  ր 4 $     ,      ?  O  d  t       4  d  |      ! !+  !9 !G @!Y !p ڤ! ! ! $! (! x! ! "  H" H"7 ռ"L "c "w " " " " ׬" ,# # #- Ȥ#9 #L @#Y  #p # p# $# # 0# # 4# # T$  ,$" H$2 D$D $W $n  $~ ($  $ $ X$ P$ $ <% % \%- "%C %S !%f $4%w %8% $% %% %% ,% %d% B& F&+ 1&> 9 &J M0&_ 1&q 1& 0& 6H& ;& A& @& D& H' ;0'* F<'= 0'V 5X'k Jh' 2' kD' g' e@' k' i`' n(  f( k(/ h(A f(X e(o d(( c( lh( oT( ( P( o( s) r)% t)7 8)G )Z v)m |) w) ) T) }X) }) ) ,*  u* u*0 X*D H*X p*h w8*} * * w<* * sx* T* v* }T+  +$ t0+0 +@ +L p+d +w 4+ + + S+ + sX+ + + s,  q|, r,. (,@ ,,K D,X ,k , l, p, , h, , , - X- @-$ X-9 -H -Y d-h t-| Δ- ,- - ʴ- P- ݔ- و. \. ِ.& d.8 .K ݌.[ .j .w . \. (. . . . . (. /  / h/' /8 /K  8/X </g /t 0/ L/ L/ h/  / / 0/ 0   0 01 `0D  0U  0d @0q 0 \0 0 l0 0 |0 d0 #T1 !1& "1> $1Y $x1t 1,1 ,01 .1 $1 &1 11 *1 ,\2 02 %2/ )2A (<2V .|2f (2x 'l2 12  x7R `7k H7x 7 @7 7 7 7 7 7 |8  d8 H8/ 8H 8V P8f 8v 8 8 8 8 8  8 8 (9 9 9* 89@ 9Q 9g |9{ 9 9 9 09 9 19 9 : :! :: :K :^ x:o 0:~ : d: : :  : <: : : <;  ;' h;; P;K ;f ;~ ; P; 1; 1; ; ; ; <  < <# H<1   d> >$  >1 >@ d>O >` 2D>t > <> ͜> L>  @> 4> .? 4? P?, 2d?@ 0?Q ,?k -T?~ +? 4? M? :|? 6? 9? 9@ 9@ 3T@) G @< ;@T 5@g Hd@{ Y @ X@ Yp@ W@ NP@ X@ Vx@ Z@ QPA VA WDA- WA< [AG ^AZ ]Aj cA ^`A iA i|A ]$A dA [lA [4A [B jB kB' kB7 lBE l@BV lBe nBy n|B nxB lB n$B lB pB vB oC pC {C& oC8 XCM CW Ci C| C C C $C C C D   D D/ |DF DX lDm \D D XD D D D @D D 4E E @E$ E6 EL Ec Ey E (E E E E @E ,F  LF <F' 0F7 FL @FX F F F  2F F  dG ̠G" ,GC DGZ  Ge Gv e(G $G G NG H vH WH4  HE ^Hd H{  H `H XH H ĠH H I I ~I LI N@I&  I- 5@I5 I= "IC #II IO cIV I\ 4Ib 6`Ij @Ip  7I}  3I  3I  I I @I I _I `I `I  I o`I @I I I `I ӠI J  J J q`J J" ӠJ+ I@J2 J8 <J@ \@JH JP mJY  Jc Jm  J| 7J )`J pJ J J  J `J UJ u J  @J  J ހK K VK àK 5K# K0 K5 K<  KC DKJ KR _KZ `Kb `Kk \Ks :Kz K K K ЀK K K [K @K K `K K 4L j`L1 `LI Q L_ J Lr @L  L L p L L  L `L  M ? M +@M1  ME M[ 6Mi }M~ M `M M  M  M M -@M M M  M @M M "`M @M  `M N oN ^N nN @N @N+ N3  N;  NC v NK ʀNU ӀN_ n Ng |Nt N} `N N @N `N  N  N `N  `N N @N @N  N N  5N ƠN @O  O LO O  O O' ]O0 `]fgnqt~ ht.1>@CDFO $'(.=X^acdpst!$*Jipqz| (CI*]^_`suvw(6U_`ehjkloqvz-Kc~ * @ A c f !PPΰPPΜMPΈPtP`PLP8P$PPPPePPͬP͘P̈́PpP\PHP4P ?PP PPPP̼P̨P̔P̀PpPlPXPHPDP0P PPPPPPP˸PˤdPːPˀP|PhPTP@P,WPPPPPPPPPPʴPʠPʐPʌP|PxPdPPP@P<P,P(PPPPPPPɰPɜPɌPɈPtP`PPPLP8P(P$PPPPPPP,PPPPPxPTP0zP ePdP`PZP|YPXOP4KPJPIPHPPP$PPPPPPPPPPPPPPPPPPPPrPPPPPPPrPPP9PPPPPP|PxPt;Pp/PlPhPdP`P\ PXPTqPPPL)PHPD%P@P<P8P40P0P,P((P$&P 'PPPP7PPSP3P=P"P}P~P{PPIPVPps@FG~CBLDJxjvVnpfHrz e`^]_jwvi   S U, KZ0pgR<9>%b -Y#:=DSg;+_JClDSsR\QPUT\&'"(!.,-#*)$<+%dC Vhwo mqU@qu=@B3wutk1il>K$"5Nu#?@}1A ^ELebn][^\[l~oNzw}~AmbFp{XMoqvQRP|VHaGsUn]t\mWT~jSkrT^D[yx% *.3(-j20($& ) ;:5974)86+2/1',0XYMNLyOtKHJIgchfiL*!gY]} {Ek_cFm3 ,r`aTZx q~vh|;FpXsQzQGWV142 3k9"YXj;I/_ln`B:qfhcbaO4657>ps@FG~CBLDJxjvVnpfHrz e`^]_jwvi   S U, KZ0pgR<9>%b -Y#:=DSg;+_JClDSsR\QPUT\&'"(!.,-#*)$<+%dC Vhwo mqU@qu=@B3wutk1il>K$"5Nu#?@}1A ^ELebn][^\[l~oNzw}~AmbFp{XMoqvQRP|VHaGsUn]t\mWT~jSkrT^D[yx% *.3(-j20($& ) ;:5974)86+2/1',0XYCM[8=m<<eGfgFhKJiIHab\cd? lrE7>!!!8!7!6!P$)?>  -]   > X-1.!$#!0/.-,+*)('&%?ZT$?d +\4!1!2!5!!!!abch`_b):D^=!Y% H (#7-8%7>1>08).D"Cf1x>1RV%u`'13!j'_&\&g#J0000R$TH?;Q$g'()Qf+1  N#w>?O$??C#B#n>~>!1+1gh??!!++,+>1111???[^\]222S$U$(7$7&7i!r'A< )BKGZ&[&F   ! !h',8+7'738    4j=@A1? !j3k?<I rl)4n'?6446666?d`_ac    6Uz> mC<    ! + {>p> )7 H H >l>)n<~(LIyops'qrNV@<s>>q>y>|>t>>k>u>   )))))E#))6)tuv}(|(WI~wq'IB<x-4(D<y ) // z{ !| }~0O "7c'Y =3!!!-!,!+!!*!)!!(!'!&!!!!!!!! !!%!q:!;!!<!!9!!0!/!!$!#!!!!! JISa'1xo'm'  k'  7+ 4Hv)6)p'H!2s)>65"!f'Et)3)/8v>34)@o62{()) 4!7F666????e)e? i'  Gz I);;) p H? @" F#K# G#I#J#D# W%     &K%K]&@@>*7HHd')))H#))66)|X=??-!@@.**++,+++D......e'!0>1b'G z( -2222222 ) 03 44 4>o>5y(x(I)8)!!44)L#)^&w(3v(?46 4* 4t( 64 I6???)//A Gs> j!X%>m>    (u(   ??nU=T=H=I=i=J=h=F=g=f=K=G=e=S=d=c=L=M=N=W=O=?"??? ????A"M1?Y=E=Z=R=Q=b=a=P=`=@9_=^=V=[=]= ???PID 28GDDDDD@B$JCHHHHC"JG18HHHFCF@iF}>FCFFEHGHG H!FFDHHCkl!HCCBBBBCCBCBBBCD@HC48HGG@FDHHHHH!J\=CE.8w?)[ ?)))r>>)!9:=;6:<;)M#?>!l'?))}7:?5:>;m12{68::;)BB!O7O@[OJ\OT]%O^^&OiOt_.Oe==`O7- OdOzOkOXOWO@O. OID O!0P1EMPA$hPHVn P$Xj~y`P1_1P;d? PIsXPRw j P\} PiPw IPM+PuV P*P PK sP?(PB #*PO.PV%2PZ 15P`QH9PtSQ0eWQ  kQ $ mQ' D"qQ6 f(Q@ +QI QW Qe DQo $ Q{ 7 Q D$Q h!Q ' Q! Q,  QQ5 Q: mQ? r, RE& .R k# NR,kR T R*R9 ARG 4$RU R@% Rc .Rq 1R C6R@>R?E R!]R%rN RPRQRRRSRTSUS VSXS*YS4ZZ[ytHIJKLMNOCcfghi\]^Lbd`_ac!*fghijklmnopqrstuvwxyz{|}~e]XZT`QQrFh,3?_csyt~qYa ez;FWd|  mMEP[M8,~zFG|WV=214Cc"ytk3 9abch`_fjkpy}OY3q:;</7>65GIX   4smnWY9<=@BlmxV`jCBnj}~pfvFGIJDH|L  mFGLV=Mxwijjkryt~xz{}av zFGJHXL   mHIiJhFgfKGedcLWYEba`_^V]\=B   SkytX s  Syt~zE      QSUkytk~az ECfgi$#!0/.-,+*)('&%"_<=@:;<=3172>6584@9?RgQKytk~q0zpFG|sWZV DCBFAGEyt399>RTHQKULNVWIOJSMPb:D=Y #-%;g+jlCDa! _?]XZ\^Y[xwCBSU,3jjk_csJH W\<=@PQRBSTUCHIJKOYZ`defz Mabc`_.}-,+*)('&%<$#"FIJH! BdhfgrqoepjniklmCVytk %!FGIJH  uvst\  <@By~xz|w}{}H , gh lmpoqv~w}~afzFGH|  U@qytu~B}=7v>6!zF|!  smY@L3Uyt~0z| s=@ytB}"F yt9uw>876.4125=3     -,+*)('& %:;<90/$#"!hCjVyt{3q!pFKGIJDH s9$"ikl<@Bm@?A NCBEFKGIJDHLMx,3 <@PTRQOSUuw,3 YVWX# ytkI _^V<@_\Z[]^joywz}O31@?}`jgrhnsqcaomkpfideblkpqytkv~}zFH|  m~}|{zyxwvtuA_c!* 8\^,3~azF|GL<=@B rMlCEcfg WZV<=@\yt ZV<=@Byt  nBjyt~|  =BL] `jS3kpnqyt}atHeb s<=@ [^\]Vyt!Y[|     ~,3jloFL  KWV= ,ytXWOV[#%($&+')"!*S-0,3/214.quNh9675876Pd\"CfxRVu`3j_\#RTHfNwn~ghirA KZ[F  hj jkrlnd`_acUzmC {p)  ln<~LyopsqrNV@sqy|tkuEtuv}|W~wqIBxDyz{ |}~O"cY=3-,+*)('& %q:;<90/$#JSa1xomk7 vp2s>65"ftvo{ !eizp @FKGIJD&%*H|XebGzoyx8!L^wv  t 4 sjXmunUTHIiJhFgfKGeSdcLMNWO?AYEZRQbaP`@9_^V[]21}4\;=<>:A?C@BD+jUp~V}{!Fzw =jXUTHIiJhFgfKGeSdcLMNWOYEZRQbaP`_^V[]\k<@xwn~z{plqy|tkuvosm}r,tGDH LE`V<=@AM`,3kyt~mpzFG|   mMHqyu3vts9BFMPQRVXabopqvw{|}yk3 9BGTUVW\]mnstytk3 F9<@BGSW]jks~TyF9BDV[^arVW=pL!kxy(*-.3CRKytz 32>pFG% 4jn_=BEkm     0($&!h )  !zVa78#$"!4579:;yt9B&%')+,./0123568?PQRSXTUVWXYTYZ_TclReComp_TclReExec_TclReFree_TclReError_Tcl_AsyncInvoke_Tcl_AsyncDelete_Tcl_AsyncMark_TclFinalizeAsync_Tcl_AsyncReady_Tcl_AsyncCreate_Tcl_GetVersion_TclInvokeStringCommand_TclObjInvoke_TclObjInvokeGlobal_TclRenameCommand_Tcl_AddErrorInfo_Tcl_AddObjErrorInfo_Tcl_AllowExceptions_Tcl_CallWhenDeleted_Tcl_CreateCommand_Tcl_CreateInterp_Tcl_CreateMathFunc_Tcl_CreateObjCommand_Tcl_CreateObjTrace_Tcl_CreateTrace_Tcl_DeleteAssocData_Tcl_DeleteCommand_Tcl_DeleteCommandFromToken_Tcl_DeleteInterp_Tcl_DeleteTrace_Tcl_DontCallWhenDeleted_Tcl_Eval_Tcl_EvalEx_Tcl_EvalObj_Tcl_EvalObjEx_Tcl_EvalObjv_Tcl_EvalTokens_Tcl_EvalTokensStandard_Tcl_ExposeCommand_Tcl_ExprBoolean_Tcl_ExprBooleanObj_Tcl_ExprDouble_Tcl_ExprDoubleObj_Tcl_ExprLong_Tcl_ExprLongObj_Tcl_ExprString_Tcl_GetAssocData_Tcl_GetCommandFullName_Tcl_GetCommandInfo_Tcl_GetCommandInfoFromToken_Tcl_GetCommandName_Tcl_GetMathFuncInfo_Tcl_GlobalEval_Tcl_GlobalEvalObj_Tcl_HideCommand_Tcl_InterpDeleted_Tcl_ListMathFuncs_Tcl_LogCommandInfo_Tcl_SetAssocData_Tcl_SetCommandInfo_Tcl_SetCommandInfoFromToken_Tcl_SetRecursionLimit_Tcl_VarEval_Tcl_VarEvalVA_TclCleanupCommand_TclEvalObjvInternal_TclGlobalInvoke_TclHideUnsafeCommands_TclInterpReady_TclInvoke_TclInvokeObjectCommand_Tcl_GetByteArrayFromObj_Tcl_SetByteArrayLength_Tcl_NewByteArrayObj_Tcl_SetByteArrayObj_Tcl_BinaryObjCmd_Tcl_DbNewByteArrayObj_tclByteArrayType_Tcl_DbCkrealloc_Tcl_Realloc_Tcl_Free_Tcl_DumpActiveMemory_TclDumpMemoryInfo_Tcl_InitMemory_Tcl_ValidateAllMemory_Tcl_Alloc_Tcl_AttemptDbCkalloc_Tcl_AttemptAlloc_TclFinalizeMemorySubsystem_Tcl_AttemptDbCkrealloc_Tcl_AttemptRealloc_Tcl_DbCkalloc_Tcl_DbCkfree_Tcl_ClockObjCmd_Tcl_CdObjCmd_Tcl_FormatObjCmd_Tcl_ForeachObjCmd_Tcl_ForObjCmd_Tcl_FileObjCmd_Tcl_BreakObjCmd_Tcl_ExprObjCmd_Tcl_ExitObjCmd_Tcl_EvalObjCmd_Tcl_ErrorObjCmd_Tcl_EncodingObjCmd_Tcl_ContinueObjCmd_Tcl_ConcatObjCmd_Tcl_CatchObjCmd_Tcl_CaseObjCmd_Tcl_LsortObjCmd_Tcl_InfoObjCmd_Tcl_IncrObjCmd_Tcl_IfObjCmd_Tcl_JoinObjCmd_Tcl_LindexObjCmd_Tcl_LsearchObjCmd_Tcl_LinsertObjCmd_Tcl_LreplaceObjCmd_Tcl_ListObjCmd_Tcl_LlengthObjCmd_Tcl_LrangeObjCmd_TclLindexFlat_TclLindexList_Tcl_LsetObjCmd_Tcl_ReturnObjCmd_TclCheckExecutionTraces_TclCheckInterpTraces_Tcl_PwdObjCmd_Tcl_RegexpObjCmd_Tcl_RegsubObjCmd_Tcl_RenameObjCmd_Tcl_SourceObjCmd_Tcl_SplitObjCmd_Tcl_StringObjCmd_Tcl_SubstObjCmd_Tcl_SwitchObjCmd_Tcl_TimeObjCmd_Tcl_TraceObjCmd_Tcl_UntraceCommand_Tcl_WhileObjCmd_Tcl_TraceCommand_Tcl_SubstObj_Tcl_CommandTraceInfo_TclTraceVariableObjCmd_TclTraceExecutionObjCmd_TclTraceCommandObjCmd_TclCompileLlengthCmd_TclCompileStringCmd_TclCompileSetCmd_TclCompileReturnCmd_TclCompileLsetCmd_TclCompileRegexpCmd_TclCompileCatchCmd_TclCompileContinueCmd_TclCompileExprCmd_TclCompileAppendCmd_TclCompileBreakCmd_TclCompileForCmd_TclCompileForeachCmd_TclCompileVariableCmd_tclForeachInfoType_TclCompileWhileCmd_TclCompileListCmd_TclCompileIfCmd_TclCompileIncrCmd_TclCompileLappendCmd_TclCompileLindexCmd_TclCompileExpr_TclFinalizeCompilation_TclFreeCompileEnv_TclInitJumpFixupArray_TclFreeJumpFixupArray_TclFixupForwardJump_TclCompileCmdWord_TclCompileExprWords_TclCompileTokens_TclCreateAuxData_tclByteCodeType_TclSetByteCodeFromAny_TclCreateExceptRange_TclRegisterAuxDataType_TclPrintSource_TclPrintObject_TclPrintInstruction_TclInitCompiledLocals_TclInitCompileEnv_TclInitByteCodeObj_TclInitAuxDataTypeTable_TclGetInstructionTable_TclGetAuxDataType_tclInstructionTable_TclEmitForwardJump_TclFinalizeAuxDataTypeTable_TclExpandCodeArray_TclExpandJumpFixupArray_TclCleanupByteCode_TclFindCompiledLocal_TclCompileScript_TclDatechar_TclGetDate_TclDate_TclDatev_TclDate_TclDates_TclDateval_TclDatev_TclDatetmp_TclDatestate_TclDates_TclDatepv_TclDateps_TclDateparse_TclDatenerrs_TclDatelval_TclDateerrflag_TclDatedebug_Tcl_FindExecutable_Tcl_GetDefaultEncodingDir_Tcl_ExternalToUtfDString_Tcl_SetSystemEncoding_Tcl_GetEncodingNames_Tcl_GetEncodingName_Tcl_FreeEncoding_Tcl_SetDefaultEncodingDir_Tcl_UtfToExternalDString_TclFinalizeEncodingSubsystem_TclInitEncodingSubsystem_Tcl_CreateEncoding_Tcl_ExternalToUtf_Tcl_GetEncoding_tclDefaultEncodingDir_Tcl_UtfToExternal_TclUnsetEnv_TclSetEnv_TclGetEnv_TclFinalizeEnvironment__environ_TclSetupEnv_Tcl_PutEnv_TclInThreadExit_Tcl_DeleteThreadExitHandler_Tcl_Finalize_TclSetLibraryPath_Tcl_CreateExitHandler_Tcl_UpdateObjCmd_Tcl_CreateThread_Tcl_Exit_Tcl_VwaitObjCmd_TclInitSubsystems_TclGetLibraryPath_Tcl_FinalizeThread_TclInExit_Tcl_BackgroundError_Tcl_CreateThreadExitHandler_Tcl_DeleteExitHandler_TclCreateExecEnv_Tcl_ExprObj_TclDeleteExecEnv_tclBuiltinFuncTable_TclExprFloatError_TclCompEvalObj_TclFinalizeExecution_TclFileRenameCmd_TclFileMakeDirsCmd_TclFileAttrsCmd_TclFileCopyCmd_TclFileDeleteCmd_TclDoGlob_Tcl_GlobObjCmd_TclGetExtension_TclGlob_TclFileDirname_TclpGetNativePathType_Tcl_SplitPath_TclpNativeJoinPath_TclpNativeSplitPath_tclPlatform_Tcl_TranslateFileName_Tcl_GetPathType_Tcl_JoinPath_Tcl_FSJoinToPath_Tcl_AllocStatBuf_Tcl_GetDouble_Tcl_GetInt_TclGetLong_Tcl_GetBoolean_tclArrayHashKeyType_Tcl_FindHashEntry_Tcl_CreateHashEntry_Tcl_InitHashTable_tclStringHashKeyType_Tcl_NextHashEntry_tclOneWordHashKeyType_Tcl_DeleteHashTable_Tcl_DeleteHashEntry_Tcl_FirstHashEntry_Tcl_InitCustomHashTable_Tcl_HashStats_Tcl_RecordAndEval_Tcl_RecordAndEvalObj_Tcl_GetIndexFromObj_tclIndexType_Tcl_GetIndexFromObjStruct_Tcl_WrongNumArgs_Tcl_CreateAliasObj_TclInterpInit_TclPreventAliasLoop_Tcl_IsSafe_Tcl_CreateAlias_Tcl_CreateSlave_Tcl_GetAlias_Tcl_GetAliasObj_Tcl_GetInterpPath_Tcl_GetMaster_Tcl_GetSlave_Tcl_InterpObjCmd_Tcl_MakeSafe_Tcl_ChannelName_Tcl_ChannelHandlerProc_Tcl_ChannelGetOptionProc_Tcl_ChannelGetHandleProc_Tcl_ChannelFlushProc_Tcl_ChannelCloseProc_Tcl_ChannelClose2Proc_Tcl_ChannelBuffered_Tcl_ChannelBlockModeProc_Tcl_BadChannelOption_TclCopyChannel_TclChannelEventScriptInvoker_Tcl_DeleteCloseHandler_Tcl_DeleteChannelHandler_Tcl_ReadChars_TclFinalizeIOSubsystem_Tcl_CutChannel_Tcl_CreateCloseHandler_Tcl_CreateChannelHandler_Tcl_CreateChannel_Tcl_ClearChannelHandlers_Tcl_ChannelWideSeekProc_Tcl_ChannelWatchProc_Tcl_ChannelVersion_Tcl_ChannelSetOptionProc_Tcl_GetChannelNamesEx_Tcl_ChannelSeekProc_Tcl_ChannelOutputProc_Tcl_ChannelInputProc_Tcl_UnregisterChannel_Tcl_RegisterChannel_Tcl_Flush_Tcl_GetStdChannel_Tcl_GetChannel_Tcl_SetChannelOption_Tcl_Gets_Tcl_WriteRaw_Tcl_WriteObj_Tcl_WriteChars_Tcl_Write_Tcl_UnstackChannel_Tcl_Close_Tcl_Ungets_Tcl_TellOld_Tcl_Tell_Tcl_StackChannel_Tcl_SpliceChannel_Tcl_SetStdChannel_Tcl_SetChannelBufferSize_Tcl_SeekOld_Tcl_Seek_Tcl_ReadRaw_Tcl_Read_Tcl_OutputBuffered_Tcl_NotifyChannel_Tcl_IsStandardChannel_Tcl_FileEventObjCmd_Tcl_IsChannelShared_Tcl_IsChannelRegistered_Tcl_IsChannelExisting_Tcl_InputBuffered_Tcl_InputBlocked_Tcl_GetsObj_Tcl_GetTopChannel_TclInitIOSubsystem_Tcl_GetStackedChannel_Tcl_GetChannelType_Tcl_GetChannelThread_Tcl_GetChannelOption_Tcl_GetChannelNames_Tcl_GetChannelName_Tcl_GetChannelMode_Tcl_GetChannelInstanceData_Tcl_GetChannelHandle_Tcl_GetChannelBufferSize_Tcl_Eof_Tcl_DetachChannel_Tcl_ExecObjCmd_Tcl_FblockedObjCmd_Tcl_FconfigureObjCmd_Tcl_PutsObjCmd_Tcl_ReadObjCmd_Tcl_CloseObjCmd_Tcl_FlushObjCmd_Tcl_SeekObjCmd_Tcl_TellObjCmd_Tcl_FcopyObjCmd_Tcl_SocketObjCmd_Tcl_GetsObjCmd_Tcl_OpenObjCmd_Tcl_EofObjCmd_TclChannelTransform_TclSockMinimumBuffers_TclSockGetPort_tclNativeFilesystem_GetPathType_TclResetFilesystem_NativeDupInternalRep_Tcl_FSSplitPath_Tcl_FSStat_Tcl_FSUtime_TclFSMakePathRelative_TclFSNormalizeToUniquePath_TclFSSetPathDetails_TclNewFSPathObj_TclOpenFileChannelDeleteProc_Tcl_PosixError_Tcl_FSEvalFile_Tcl_FSGetCwd_Tcl_FSAccess_Tcl_FSChdir_Tcl_FSConvertToPathType_Tcl_FSFileSystemInfo_TclOpenFileChannelInsertProc_Tcl_FSGetNormalizedPath_TclStatDeleteProc_TclStatInsertProc_Tcl_Access_Tcl_Chdir_Tcl_EvalFile_Tcl_FSData_Tcl_FSGetFileSystemForPath_Tcl_FSGetInternalRep_Tcl_FSGetNativePath_Tcl_FSGetPathType_Tcl_FSGetTranslatedStringPath_Tcl_FSLoadFile_Tcl_FSNewNativePath_Tcl_FSRegister_Tcl_FSUnregister_Tcl_GetCwd_Tcl_OpenFileChannel_Tcl_Stat_TclpLoadFile_TclpNativeToNormalized_tclFsPathType_theFilesystemEpoch_Tcl_FSMatchInDirectory_Tcl_FSGetTranslatedPath_Tcl_SetErrno_Tcl_GetErrno_Tcl_FSRenameFile_Tcl_FSRemoveDirectory_Tcl_FSJoinPath_Tcl_FSFileAttrsSet_Tcl_FSFileAttrsGet_Tcl_FSFileAttrStrings_Tcl_FSEqualPaths_Tcl_FSDeleteFile_Tcl_FSCreateDirectory_Tcl_FSCopyFile_Tcl_FSCopyDirectory_TclCrossFilesystemCopy_Tcl_FSPathSeparator_Tcl_FSOpenFileChannel_TclFSEnsureEpochOk_TclFSInternalToNormalized_TclGetOpenMode_TclFSCwdPointerEquals_TclFSMakePathFromNormalized_TclAccessInsertProc_TclAccessDeleteProc_NativePathInFilesystem_Tcl_FSMountsChanged_Tcl_FSLink_Tcl_FSListVolumes_Tcl_FSLstat_TclFinalizeFilesystem_FSGetPathType_Tcl_UnlinkVar_Tcl_LinkVar_Tcl_UpdateLinkedVar_TclLsetList_TclLsetFlat_Tcl_ListObjReplace_Tcl_DbNewListObj_Tcl_ListObjAppendElement_Tcl_ListObjGetElements_Tcl_NewListObj_Tcl_ListObjIndex_Tcl_ListObjLength_Tcl_ListObjAppendList_Tcl_SetListObj_tclListType_TclListObjSetElement_TclLookupLiteralEntry_TclAddLiteralObj_TclInitLiteralTable_TclHideLiteral_TclRegisterLiteral_TclDeleteLiteralTable_TclReleaseLiteral_TclGetLoadedPackages_Tcl_LoadObjCmd_Tcl_StaticPackage_TclFinalizeLoad_TclSetStartupScriptFileName_TclSetStartupScriptPath_TclGetStartupScriptPath_Tcl_Main_Tcl_SetMainLoop_TclGetStartupScriptFileName_TclGetNamespaceForQualName_Tcl_FindCommand_Tcl_PushCallFrame_Tcl_Export_Tcl_NamespaceObjCmd_Tcl_PopCallFrame_Tcl_GetGlobalNamespace_TclInitNamespaceSubsystem_TclTeardownNamespace_Tcl_Import_TclGetOriginalCommand_Tcl_ForgetImport_tclNsNameType_Tcl_FindNamespaceVar_Tcl_AppendExportList_Tcl_FindNamespace_Tcl_GetCurrentNamespace_Tcl_DeleteNamespace_TclResetShadowedCmdRefs_Tcl_CreateNamespace_Tcl_SetServiceMode_Tcl_ThreadQueueEvent_Tcl_SetNotifier_Tcl_SetMaxBlockTime_Tcl_ServiceEvent_Tcl_ServiceAll_Tcl_QueueEvent_Tcl_GetServiceMode_Tcl_DeleteEvents_Tcl_DeleteEventSource_Tcl_CreateEventSource_TclFinalizeNotifier_TclInitNotifier_Tcl_DoOneEvent_Tcl_ThreadAlert_Tcl_InitObjHashTable_Tcl_DbNewWideIntObj_TclInitObjSubsystem_TclAllocateFreeObjects_Tcl_AppendAllObjTypes_Tcl_DuplicateObj_Tcl_SetLongObj_Tcl_NewWideIntObj_Tcl_NewBooleanObj_Tcl_NewDoubleObj_Tcl_GetBooleanFromObj_Tcl_GetIntFromObj_Tcl_GetCommandFromObj_Tcl_SetDoubleObj_Tcl_GetDoubleFromObj_Tcl_GetLongFromObj_Tcl_NewIntObj_Tcl_GetString_Tcl_GetStringFromObj_Tcl_DbDecrRefCount_Tcl_DbIncrRefCount_Tcl_DbIsShared_Tcl_DbNewBooleanObj_Tcl_NewLongObj_TclSetCmdNameObj_Tcl_SetBooleanObj_Tcl_SetIntObj_Tcl_NewObj_Tcl_SetWideIntObj_Tcl_InvalidateStringRep_Tcl_DbNewDoubleObj_Tcl_GetWideIntFromObj_TclFreeObj_tclWideIntType_tclIntType_TclFinalizeCompExecEnv_tclEmptyStringRep_Tcl_DbNewLongObj_tclDoubleType_tclBooleanType_tclObjMutex_tclObjHashKeyType_Tcl_ConvertToType_tclFreeObjList_tclEmptyString_Tcl_DbNewObj_Tcl_RegisterObjType_Tcl_GetObjType_Tcl_SetPanicProc_Tcl_Panic_Tcl_PanicVA_TclParseBackslash_TclParseWhiteSpace_TclParseHex_Tcl_ParseVarName_TclExpandTokenArray_Tcl_ParseVar_TclObjCommandComplete_Tcl_ParseQuotedString_TclIsLocalScalar_Tcl_ParseCommand_Tcl_ParseBraces_Tcl_CommandComplete_Tcl_FreeParse_TclParseInteger_Tcl_ParseExpr_TclCleanupChildren_TclCreatePipeline_Tcl_DetachPids_Tcl_OpenCommandChannel_Tcl_ReapDetachedProcs_TclFreePackageInfo_Tcl_PkgPresentEx_Tcl_PkgProvide_Tcl_PkgRequire_Tcl_PkgProvideEx_Tcl_PkgRequireEx_Tcl_PackageObjCmd_Tcl_PkgPresent_Tcl_SignalMsg_Tcl_ErrnoId_Tcl_ErrnoMsg_Tcl_SignalId_TclHandleRelease_Tcl_EventuallyFree_TclHandleFree_TclHandlePreserve_Tcl_Release_Tcl_Preserve_TclHandleCreate_TclIsProc_TclUpdateReturnInfo_tclProcBodyType_Tcl_UplevelObjCmd_TclFindProc_TclCreateProc_TclGetFrame_TclGetInterpProc_Tcl_ProcObjCmd_TclGetObjInterpProc_TclNewProcBodyObj_TclObjInterpProc_TclProcCleanupProc_TclProcCompileProc_TclProcDeleteProc_TclProcInterpProc_Tcl_RegExpCompile_Tcl_RegExpGetInfo_Tcl_RegExpMatch_tclRegexpType_TclRegAbout_Tcl_RegExpMatchObj_TclRegError_TclRegExpRangeUniChar_Tcl_RegExpExecObj_Tcl_RegExpExec_Tcl_GetRegExpFromObj_Tcl_RegExpRange_Tcl_RemoveInterpResolvers_Tcl_AddInterpResolvers_Tcl_GetInterpResolvers_Tcl_GetNamespaceResolvers_Tcl_SetNamespaceResolvers_Tcl_SetObjErrorCode_Tcl_AppendResult_Tcl_ResetResult_Tcl_SaveResult_Tcl_DiscardResult_Tcl_SetErrorCode_Tcl_AppendResultVA_Tcl_AppendElement_Tcl_SetErrorCodeVA_Tcl_RestoreResult_Tcl_GetObjResult_Tcl_GetStringResult_Tcl_FreeResult_Tcl_SetObjResult_Tcl_SetResult_TclTransferResult_Tcl_ScanObjCmd_Tcl_GetUniChar_Tcl_AppendUnicodeToObj_Tcl_GetCharLength_Tcl_GetRange_Tcl_GetUnicodeFromObj_Tcl_NewUnicodeObj_Tcl_SetUnicodeObj_tclStringType_Tcl_SetObjLength_Tcl_NewStringObj_Tcl_AppendToObj_Tcl_AppendStringsToObj_Tcl_AppendObjToObj_Tcl_GetUnicode_Tcl_AppendStringsToObjVA_Tcl_AttemptSetObjLength_Tcl_DbNewStringObj_Tcl_SetStringObj_Tcl_GetThreadData_Tcl_ExitThread_TclFinalizeSynchronization_TclRememberDataKey_TclFinalizeThreadData_TclRememberMutex_TclThreadDataKeySet_TclRememberCondition_Tcl_ConditionFinalize_Tcl_MutexFinalize_TclThreadDataKeyGet_TclThreadAllocObj_TclFinalizeThreadAlloc_binfo_Tcl_GetMemoryInfo_TclFreeAllocCache_TclpFree_TclpAlloc_TclThreadFreeObj_TclpRealloc_tclPlatStubs_tclIntStubs_tclOriginalNotifier_tclStubs_tclIntPlatStubs_tclStubsPtr_Tcl_InitStubs_tclIntStubsPtr_tclIntPlatStubsPtr_tclPlatStubsPtr_Tcl_AfterObjCmd_Tcl_CreateTimerHandler_TclServiceIdle_Tcl_DeleteTimerHandler_Tcl_CancelIdleCall_Tcl_DoWhenIdle_Tcl_UtfBackslash_Tcl_UniCharIsLower_Tcl_UniCharIsUpper_Tcl_UniCharIsAlnum_Tcl_UniCharIsAlpha_Tcl_UniCharIsDigit_Tcl_UniCharIsSpace_Tcl_UniCharToLower_Tcl_UniCharToTitle_Tcl_UniCharToUpper_Tcl_UniCharToUtfDString_Tcl_UtfNext_Tcl_UtfFindLast_Tcl_UtfFindFirst_Tcl_UniCharLen_Tcl_UniCharCaseMatch_Tcl_UniCharAtIndex_Tcl_UtfToUniChar_Tcl_UniCharToUtf_Tcl_NumUtfChars_Tcl_UtfAtIndex_Tcl_UtfCharComplete_Tcl_UtfToUniCharDString_TclpUtfNcmp2_Tcl_UtfToUpper_Tcl_UtfToTitle_Tcl_UtfToLower_Tcl_UtfPrev_Tcl_UtfNcmp_Tcl_UtfNcasecmp_Tcl_UniCharNcmp_Tcl_UniCharNcasecmp_Tcl_UniCharIsWordChar_Tcl_UniCharIsPunct_Tcl_UniCharIsPrint_Tcl_UniCharIsGraph_Tcl_UniCharIsControl_TclUniCharMatch_Tcl_DStringSetLength_Tcl_ConvertElement_Tcl_StringMatch_TclMatchIsTrivial_Tcl_ScanElement_Tcl_ConcatObj_Tcl_DStringEndSublist_tclEndOffsetType_Tcl_SplitList_Tcl_DStringInit_Tcl_DStringStartSublist_Tcl_GetNameOfExecutable_TclLooksLikeInt_TclGetIntForIndex_Tcl_DStringFree_Tcl_Backslash_Tcl_Concat_Tcl_DStringGetResult_TclpGetTime_TclNeedSpace_Tcl_StringCaseMatch_Tcl_Merge_TclFormatInt_Tcl_DStringAppend_Tcl_PrintDouble_Tcl_DStringAppendElement_TclCopyAndCollapse_TclFindElement_Tcl_ConvertCountedElement_Tcl_ScanCountedElement_TclCheckBadOctal_TclPrecTraceProc_tclNativeExecutableName_tclExecutableName_Tcl_DStringResult_TclLookupVar_Tcl_UpVar_Tcl_UpVar2_TclPtrSetVar_TclPtrIncrVar_TclPtrGetVar_TclObjLookupVar_TclLookupArrayElement_Tcl_VarTraceInfo2_Tcl_UnsetObjCmd_Tcl_UntraceVar_TclLookupSimpleVar_TclObjUnsetVar2_tclLocalVarNameType_tclNsVarNameType_tclParsedVarNameType_Tcl_AppendObjCmd_TclDeleteCompiledLocalVars_TclDeleteVars_Tcl_UnsetVar2_Tcl_GetVar2_TclArraySet_Tcl_ArrayObjCmd_Tcl_UnsetVar_TclIncrVar2_Tcl_UntraceVar2_TclVarTraceExists_Tcl_GetVar2Ex_Tcl_GlobalObjCmd_Tcl_VariableObjCmd_Tcl_LappendObjCmd_Tcl_ObjSetVar2_Tcl_GetVar_Tcl_SetObjCmd_Tcl_SetVar_Tcl_SetVar2_Tcl_SetVar2Ex_Tcl_TraceVar2_Tcl_UpvarObjCmd_tclArraySearchType_Tcl_GetVariableFullName_Tcl_VarTraceInfo_Tcl_ObjGetVar2_Tcl_TraceVar_Tcl_MakeFileChannel_TclpSpliceFileChannel_TclpGetDefaultStdChannel_TclpCutFileChannel_TclpOpenFileChannel_TclUnixWaitForFile_Tcl_GetOpenFile_Tcl_MakeTcpClientChannel_Tcl_OpenTcpServer_Tcl_OpenTcpClient_Tcl_Sleep_TclpObjNormalizePath_TclpObjCopyDirectory_TclpObjCopyFile_TclpObjCreateDirectory_TclpObjDeleteFile_TclpDeleteFile_tclpFileAttrStrings_tclpFileAttrProcs_TclpObjRemoveDirectory_TclpObjRenameFile_TclpObjListVolumes_TclpObjStat_TclpReadlink_TclpObjLink_TclpObjLstat_TclpFindExecutable_TclpGetCwd_TclpGetUserHome_TclpFilesystemPathType_TclpMatchInDirectory_TclpObjAccess_TclpObjChdir_TclpObjGetCwd_TclpUtime_TclpCreateProcess_TclpCreatePipe_TclpCreateCommandChannel_TclpCloseFile_Tcl_WaitPid_Tcl_PidObjCmd_TclpTempFileName_TclGetAndDetachPids_TclpOpenFile_TclpMakeFile_TclpCreateTempFile_Tcl_GetHostName_TclpHasSockets_TclpGetSeconds_TclpStrftime_TclpGetTimeZone_TclpGetClicks_TclpLocaltime_unix_TclpLocaltime_TclpGmtime_unix_TclpGetDate_TclpGmtime_Tcl_GetTime_TclpInitLibraryPath_TclpSetInitialEncodings_TclSetPreInitScript_Tcl_SourceRCFile_TclpSetVariables_TclpInitPlatform_TclpCheckStackSpace_Tcl_Init_TclpFindVariable_TclpNewAllocMutex_TclpMasterLock_TclpFinalizeThreadDataKey_TclpFinalizeThreadData_Tcl_GetAllocMutex_TclpFreeAllocMutex_TclpGetAllocCache_TclpThreadExit_TclpSetAllocCache_TclpFinalizeMutex_TclpFinalizeCondition_TclpThreadCreate_Tcl_ConditionNotify_Tcl_ConditionWait_TclFinalizeLock_Tcl_JoinThread_TclpInitUnlock_TclpInitLock_Tcl_MutexUnlock_Tcl_MutexLock_Tcl_GetCurrentThread_TclpInetNtoa_TclpReaddir_TclpFreeAllocCache_TclpMasterUnlock_TclpThreadDataKeyGet_TclpThreadDataKeyInit_TclpThreadDataKeySet_Tcl_ServiceModeHook_Tcl_DeleteFileHandler_Tcl_WaitForEvent_Tcl_CreateFileHandler_Tcl_AlertNotifier_Tcl_InitNotifier_Tcl_FinalizeNotifier_Tcl_SetTimer_TclpUnloadFile_TclpFindSymbol_TclGuessPackageName_TclpDlopen_Tcl_MacOSXOpenVersionedBundleResources_Tcl_MacOSXOpenBundleResources_CFBundleCopyBundleURL_CFBundleCopyPrivateFrameworksURL_CFBundleCopyResourceURL_CFBundleCopySharedFrameworksURL_CFBundleCreate_CFBundleGetBundleWithIdentifier_CFBundleGetMainBundle_CFRelease_CFStringCompare_CFStringCreateWithCString_CFURLCopyLastPathComponent_CFURLCreateCopyAppendingPathComponent_CFURLGetFileSystemRepresentation_NSAddImage_NSAddressOfSymbol_NSIsSymbolNameDefinedWithHint_NSLinkEditError_NSLookupAndBindSymbolWithHint_NSLookupSymbolInImage_NSModuleForSymbol_NSUnLinkModule__CurrentRuneLocale__DefaultRuneLocale__NSGetEnviron___CFConstantStringClassReference____runetype____tolower___error___sF__exit_abort_accept_access_acos_asin_atan_atan2_atoi_bind_calloc_ceil_cfgetospeed_cfsetispeed_cfsetospeed_chdir_chmod_chown_close_closedir_connect_cos_cosh_dup2_endgrent_endpwent_execvp_exit_exp_fcntl_fdopen_fflush_floor_fmod_fprintf_fputc_free_fwrite_getcwd_getenv_geteuid_getgrgid_getgrnam_gethostbyaddr_gethostbyname_getpeername_getpid_getpwnam_getpwuid_getservbyname_getsockname_getsockopt_gettimeofday_gmtime_r_hypot_inet_addr_ioctl_isatty_link_listen_localtime_r_log_log10_lseek_lstat_malloc_memcmp_memcpy_memmove_memset_mkdir_mkfifo_mknod_mkstemp_nl_langinfo_open_opendir_pipe_pow_pthread_attr_destroy_pthread_attr_init_pthread_attr_setdetachstate_pthread_attr_setscope_pthread_attr_setstacksize_pthread_cond_broadcast_pthread_cond_destroy_pthread_cond_init_pthread_cond_timedwait_pthread_cond_wait_pthread_create_pthread_exit_pthread_getspecific_pthread_join_pthread_key_create_pthread_key_delete_pthread_mutex_destroy_pthread_mutex_init_pthread_mutex_lock_pthread_mutex_unlock_pthread_self_pthread_setspecific_read_readdir_r_readlink_realloc_recv_rename_rewinddir_rmdir_select_send_setlocale_setsockopt_signal_sin_sinh_socket_sprintf_sqrt_sscanf_stat_strcasecmp_strcat_strchr_strcmp_strcpy_strerror_strftime_strlen_strncasecmp_strncmp_strncpy_strpbrk_strrchr_strstr_strtod_strtol_strtoll_strtoul_strtoull_symlink_tan_tanh_tcgetattr_tcsetattr_time_tzset_umask_uname_unlink_utime_vfork_waitpid_writedylib1.oregcomp.oregexec.oregfree.oregerror.otclAlloc.otclAsync.otclBasic.otclBinary.otclCkalloc.otclClock.otclCmdAH.otclCmdIL.otclCmdMZ.otclCompCmds.otclCompExpr.otclCompile.otclDate.otclEncoding.otclEnv.otclEvent.otclExecute.otclFCmd.otclFileName.otclGet.otclHash.otclHistory.otclIndexObj.otclInterp.otclIO.otclIOCmd.otclIOGT.otclIOSock.otclIOUtil.otclLink.otclListObj.otclLiteral.otclLoad.otclMain.otclNamesp.otclNotify.otclObj.otclPanic.otclParse.otclParseExpr.otclPipe.otclPkg.otclPosixStr.otclPreserve.otclProc.otclRegexp.otclResolve.otclResult.otclScan.otclStringObj.otclThread.otclThreadAlloc.otclThreadJoin.otclStubInit.otclStubLib.otclTimer.otclUtf.otclUtil.otclVar.otclUnixChan.otclUnixEvent.otclUnixFCmd.otclUnixFile.otclUnixPipe.otclUnixSock.otclUnixTime.otclUnixInit.otclUnixThrd.otclUnixNotfy.otclLoadDyld.otclMacOSXBundle.o_ashldi3.o_ashrdi3.o_divdi3.o_fixdfdi.o_floatdidf.o_moddi3.odarwin-fpsave.o_fixunsdfdi.o_cmpdi2.olink editordyld_lazy_symbol_binding_entry_pointdyld__mh_dylib_headerdyld_func_lookup_pointer___initialize_Cplusplus__dyld_func_lookupcfm_stub_binding_helperdyld_stub_binding_helper_functions_rfree_moresubs_freev_makesearch_parse_parsebranch_parseqatom_nonword_word_scannum_repeat_bracket_cbracket_brackpart_scanplain_leaders_onechr_dovec_nextleader_wordchrs_subre_freesubre_freesrnode_optst_numst_markst_cleanst_nfatree_nfanode_newlacon_freelacons_dump_dumpst_stdump_stid_lexstart_prefixes_lexnest_backd_backD_brbackd_backs_backS_brbacks_backw_backW_brbackw_lexword_next_alert.0_esc.1_lexescape_lexdigits_brenext_skip_newline_chrnamed_initcm_freecm_cmtreefree_setcolor_maxcolor_newcolor_freecolor_pseudocolor_subcolor_newsub_subrange_subblock_okcolors_colorchain_uncolorchain_singleton_rainbow_colorcomplement_newnfa_freenfa_newstate_newfstate_dropstate_freestate_destroystate_newarc_allocarc_freearc_findarc_cparc_moveins_copyins_moveouts_copyouts_cloneouts_delsub_deltraverse_dupnfa_duptraverse_cleartraverse_specialcolors_optimize_pullback_pull_pushfwd_push_combine_fixempties_unempty_cleanup_markreachable_markcanreach_analyze_compact_carcsort_freecnfa_dumpnfa_dumpcnfa_newcvec_clearcvec_addchr_addrange_addmcce_haschr_getcvec_freecvec_cnames_alphaRangeTable_alphaCharTable_digitRangeTable_punctRangeTable_punctCharTable_spaceRangeTable_spaceCharTable_lowerRangeTable_lowerCharTable_upperRangeTable_upperCharTable_graphRangeTable_graphCharTable_nmcces_nleaders_allmcces_element_range_before_eclass_classNames.2_cclass_allcases_cmp_casecmp_find_cfind_cfindloop_zapsubs_zapmem_subset_dissect_condissect_altdissect_cdissect_ccondissect_crevdissect_cbrdissect_caltdissect_longest_shortest_lastcold_newdfa_freedfa_hash_initialize_miss_lacon_getvacant_pickss_unk_rerrs_dataKey_builtInCmds_assocDataCounter.0_assocMutex.1_DeleteInterpProc_CallCommandTraces_ProcessUnexpectedResult_StringTraceProc_StringTraceDeleteProc_FreeByteArrayInternalRep_DupByteArrayInternalRep_UpdateStringOfByteArray_SetByteArrayFromAny_options.0_hexdigit.1_GetFormatSpec_FormatNumber_ScanNumber_DeleteScanNumberCache_switches.0_formatSwitches.1_scanSwitches.2_clockMutex_FormatClock_optionStrings.0_fileOptions.1_linkTypes.2_CheckAccess_GetStatBuf_StoreStatData_GetTypeFromMode_subCmds.0_InfoArgsCmd_InfoBodyCmd_InfoCmdCountCmd_InfoCommandsCmd_InfoCompleteCmd_InfoDefaultCmd_InfoExistsCmd_InfoFunctionsCmd_InfoGlobalsCmd_InfoHostnameCmd_InfoLevelCmd_InfoLibraryCmd_InfoLoadedCmd_InfoLocalsCmd_AppendLocals_InfoNameOfExecutableCmd_InfoPatchLevelCmd_InfoProcsCmd_InfoScriptCmd_InfoSharedlibCmd_InfoTclVersionCmd_InfoVarsCmd_options.1_switches.2_MergeSort_MergeLists_SortCompare_DictionaryCompare_traceTypeOptions_traceSubCmds_options.0_options.1_options.2_isOptions.3_substOptions.4_options.5_traceOptions.6_opStrings.7_opStrings.8_opStrings.9_TraceCommandProc_CallTraceProcedure_CommandObjTraceDeleted_TraceExecutionProc_TraceVarProc_DupForeachInfo_FreeForeachInfo_options.0_TclPushVarName_opTableInitialized_operatorTable_opMutex_opHashTable_CompileSubExpr_CompileLandOrLorExpr_CompileCondExpr_CompileMathFuncCall_LogSyntaxError_FreeByteCodeInternalRep_DupByteCodeInternalRep_SetByteCodeFromAny_LogCompilationInfo_EnterCmdStartData_EnterCmdExtentData_tableMutex_auxDataTypeTableInitialized_auxDataTypeTable_GetCmdLocEncodingSize_EncodeCmdLocMap_TclDatemaxdepth_MonthDayTable_UnitsTable_OtherTable_TimezoneTable_MilitaryTable_TclDateerror_ToSeconds_DaysInMonth.0_Convert_TclDateTimezone_DSTcorrect_NamedDay_NamedMonth_RelativeMonth_RelativeDay_LookupWord_TclDatelex_TclDateInput_TclDateYear_TclDateMonth_TclDateDay_TclDateHour_TclDateMinutes_TclDateHaveDate_TclDateHaveDay_TclDateSeconds_TclDateMeridian_TclDateRelSeconds_TclDateRelMonth_TclDateRelDay_TclDateDSTmode_TclDateHaveOrdinalMonth_TclDateHaveRel_TclDateHaveTime_TclDateHaveZone_TclDateRelPointer_TclDateDayOrdinal_TclDateDayNumber_TclDateMonthOrdinal_TclDateexca_TclDateact_TclDatepact_TclDatepgo_TclDater1_TclDater2_TclDatechk_TclDatedef_encodingsInitialized_encodingMutex_encodingTable_defaultEncoding_systemEncoding_FreeEncoding_LoadEncodingFile_OpenEncodingFile_staticHex.0_LoadTableEncoding_emptyPage_LoadEscapeEncoding_BinaryProc_UtfIntToUtfExtProc_UtfExtToUtfIntProc_UtfToUtfProc_UnicodeToUtfProc_UtfToUnicodeProc_TableToUtfProc_TableFromUtfProc_TableFreeProc_EscapeToUtfProc_EscapeFromUtfProc_EscapeFreeProc_GetTableEncoding_unilen_TclFindEncodings_cacheSize_environCache_environSize_envMutex_EnvTraceProc_ReplaceString_firstExitPtr_inFinalize_subsystemsInitialized_tclLibraryPathStr_HandleBgErrors_BgErrorDeleteProc_exitMutex_dataKey_VwaitVarProc_updateOptions.0_NewThreadProc_execInitialized_operatorStrings_ExprUnaryFunc_ExprBinaryFunc_ExprAbsFunc_ExprDoubleFunc_ExprIntFunc_ExprRandFunc_ExprRoundFunc_ExprSrandFunc_ExprWideFunc_InitByteCodeExecution_execMutex_GrowEvaluationStack_TclExecuteByteCode_IllegalExprOperandType_GetSrcInfoForPc_GetExceptRangeForPc_VerifyExprObjType_ExprCallMathFunc_FileCopyRename_CopyRenameOneFile_FileForceOption_FileBasename_FileNameInit_dataKey_FileNameCleanup_ExtractWinRoot_SplitUnixPath_SplitWinPath_SplitMacPath_DoTildeSubst_options.0_SkipToChar_HashArrayKey_CompareArrayKeys_AllocArrayEntry_HashStringKey_CompareStringKeys_AllocStringEntry_BogusFind_BogusCreate_RebuildTable_FreeIndex_DupIndex_UpdateStringOfIndex_SetIndexFromAny_aliasCounter_InterpInfoDeleteProc_options.0_options.1_hiddenOptions.2_GetInterp2_AliasCreate_cntMutex_AliasDelete_AliasDescribe_AliasList_AliasObjCmd_AliasObjCmdDeleteProc_GetInterp_SlaveCreate_options.3_hiddenOptions.4_SlaveObjCmd_SlaveObjCmdDeleteProc_SlaveEval_SlaveExpose_SlaveRecursionLimit_SlaveHide_SlaveHidden_SlaveInvokeHidden_SlaveMarkTrusted_dataKey_GetChannelTable_DeleteChannelTable_CheckForStdChannelsBeingClosed_DetachChannel_AllocChannelBuffer_RecycleBuffer_DiscardOutputQueued_CheckForDeadChannel_FlushChannel_CloseChannel_DoWriteChars_WriteBytes_WriteChars_TranslateOutputEOL_CheckFlush_FilterInputBytes_PeekAhead_CommonGetsCleanup_DoReadChars_ReadBytes_ReadChars_TranslateInputEOL_DiscardInputQueued_GetInput_CheckChannelErrors_CleanupChannelHandlers_UpdateInterest_ChannelTimerProc_DeleteScriptRecord_CreateScriptRecord_modeOptions.0_maskArray.1_CopyData_DoRead_CopyAndTranslateBuffer_CopyBuffer_DoWrite_CopyEventProc_StopCopy_StackSetBlockMode_SetBlockMode_HaveVersion_originOptions.0_modeArray.1_options.2_TcpAcceptCallbacksDeleteProc_RegisterTcpServerInterpCleanup_UnregisterTcpServerInterpCleanupProc_AcceptCallbackProc_TcpServerCloseProc_socketOptions.3_switches.4_transformChannelType_TransformCloseProc_TransformInputProc_TransformOutputProc_TransformSeekProc_TransformSetOptionProc_TransformGetOptionProc_TransformWatchProc_TransformGetFileHandleProc_TransformBlockModeProc_TransformNotifyProc_TransformWideSeekProc_ExecuteCallback_TransformChannelHandlerTimer_ResultClear_ResultInit_ResultLength_ResultCopy_ResultAdd_statProcList_accessProcList_openFileChannelProcList_NativeFreeInternalRep_NativeCreateNativeRep_NativeFilesystemSeparator_NativeFileAttrStrings_NativeFileAttrsGet_NativeFileAttrsSet_nativeFilesystemRecord_filesystemList_cwdPathPtr_cwdPathEpoch_FsThrExitProc_dataKey_cwdMutex_FsRecacheFilesystemList_FsGetFirstFilesystem_filesystemMutex_FsUpdateCwd_FsAddMountsToGlobResult_TclFSNormalizeAbsolutePath_obsoleteFsHookMutex_FSUnloadTempFile_FsListMounts_FreeFsPathInternalRep_DupFsPathInternalRep_UpdateStringOfFsPath_SetFsPathFromAny_FindSplitPos_LinkTraceProc_ObjValue_FreeListInternalRep_DupListInternalRep_UpdateStringOfList_SetListFromAny_AddLocalLiteralEntry_ExpandLocalLiteralArray_HashString_RebuildLiteralTable_firstPackagePtr_packageMutex_LoadCleanupProc_tclStartupScriptPath_mainLoopProc_StdinProc_Prompt_numNsCreated_FreeNsNameInternalRep_DupNsNameInternalRep_UpdateStringOfNsName_SetNsNameFromAny_nsMutex_NamespaceFree_InvokeImportedCmd_DeleteImportedCmd_GetNamespaceFromObj_subCmds.0_NamespaceChildrenCmd_NamespaceCodeCmd_NamespaceCurrentCmd_NamespaceDeleteCmd_NamespaceEvalCmd_NamespaceExistsCmd_NamespaceExportCmd_NamespaceForgetCmd_NamespaceImportCmd_NamespaceInscopeCmd_NamespaceOriginCmd_NamespaceParentCmd_NamespaceQualifiersCmd_NamespaceTailCmd_NamespaceWhichCmd_dataKey_listLock_firstNotifierPtr_QueueEvent_typeTableInitialized_UpdateStringOfBoolean_SetBooleanFromAny_UpdateStringOfDouble_SetDoubleFromAny_UpdateStringOfInt_SetIntFromAny_UpdateStringOfWideInt_SetWideIntFromAny_HashObjKey_CompareObjKeys_AllocObjEntry_FreeObjEntry_tclCmdNameType_FreeCmdNameInternalRep_DupCmdNameInternalRep_SetCmdNameFromAny_tableMutex_typeTable_SetIntOrWideFromAny_panicProc_platformPanicProc_charTypeTable_ParseComment_ParseTokens_CommandComplete_lexemeStrings_ParseCondExpr_ParseLorExpr_ParseLandExpr_ParseBitOrExpr_ParseBitXorExpr_ParseBitAndExpr_ParseEqualityExpr_ParseRelationalExpr_ParseShiftExpr_ParseAddExpr_ParseMultiplyExpr_ParseUnaryExpr_ParsePrimaryExpr_GetLexeme_ParseMaxDoubleLength_PrependSubExprTokens_LogSyntaxError_detList_FileForRedirect_pipeMutex_pkgOptions.0_FindPackage_CheckVersion_ComparePkgVersions_spaceAvl_inUse_PreserveExitProc_preserveMutex_refArray_ProcBodyFree_ProcBodyDup_ProcBodyUpdateString_ProcBodySetFromAny_ProcessProcResultCode_TclCompileNoOp_FreeRegexpInternalRep_DupRegexpInternalRep_SetRegexpFromAny_RegExpExecUniChar_infonames.0_CompileRegexp_dataKey_FreeRegexp_FinalizeRegexp_BumpCmdRefEpochs_SetupAppendBuffer_ResetObjResult_BuildCharSet_CharInSet_ReleaseCharSet_ValidateFormat_FreeStringInternalRep_DupStringInternalRep_UpdateStringOfString_SetStringFromAny_AppendUnicodeToUnicodeRep_AppendUnicodeToUtfRep_AppendUtfToUnicodeRep_AppendUtfToUtfRep_FillUnicodeRep_keyRecord_mutexRecord_condRecord_RememberSyncObject_ForgetSyncObject_sharedPtr_sharedCache_firstCachePtr_GetCache_listLockPtr_objLockPtr_MoveObjs_Block2Ptr_Ptr2Block_LockBucket_UnlockBucket_PutBlocks_GetBlocks_tclStubHooks_HasStubSupport_InitTimer_dataKey_TimerExitProc_TimerSetupProc_TimerCheckProc_TimerHandlerEventProc_afterSubCmds.0_GetAfterEvent_AfterProc_FreeAfterPtr_AfterCleanupProc_pageMap_groupMap_groups_totalBytes_UtfCount_precisionString_precisionFormat_UpdateStringOfEndOffset_SetEndOffsetFromAny_precisionMutex_noSuchVar_isArray_needArray_noSuchElement_danglingElement_danglingVar_badNamespace_missingName_isArrayElement_FreeLocalVarName_DupLocalVarName_UpdateLocalVarName_FreeNsVarName_DupNsVarName_FreeParsedVarName_DupParsedVarName_UpdateParsedVarName_SetArraySearchObj_arrayOptions.0_options.1_ObjMakeUpvar_DisposeTraceResult_CallVarTraces_NewVar_ParseSearchId_DeleteSearches_DeleteArray_CleanupVar_VarErrMsg_fileChannelType_FileCloseProc_FileInputProc_FileOutputProc_FileSeekProc_FileWatchProc_FileGetHandleProc_FileBlockModeProc_FileWideSeekProc_ttyChannelType_TtyCloseProc_TtySetOptionProc_TtyGetOptionProc_tcpChannelType_TcpCloseProc_TcpInputProc_TcpOutputProc_TcpGetOptionProc_TcpWatchProc_TcpGetHandleProc_TcpBlockModeProc_TtyModemStatusStr_TtyGetAttributes_TtySetAttributes_bad.0_TtyParseMode_TtyInit_WaitForConnect_CreateSocket_CreateSocketAddress_MakeTcpClientChannelMode_TcpAccept_GetGroupAttribute_SetGroupAttribute_GetOwnerAttribute_SetOwnerAttribute_GetPermissionsAttribute_SetPermissionsAttribute_DoRenameFile_DoCopyFile_CopyFile_DoCreateDirectory_DoRemoveDirectory_TraverseUnixTree_TraversalCopy_TraversalDelete_CopyFileAtts_GetModeFromPermString_NativeMatchType_pipeChannelType_PipeCloseProc_PipeInputProc_PipeOutputProc_PipeWatchProc_PipeGetHandleProc_PipeBlockModeProc_RestoreSignals_SetupStdFile_hostnameInited_hostMutex_hostname_lastTZ_tmKey_SetTZIfNecessary_tmMutex_CleanupMemory_initScript_tclPreInitScript_binaryEncoding_libraryPathEncodingFixed_defaultLibraryDir_pkgPath_localeTable_Tcl_MacOSXGetLibraryPath_masterLock_initLock_allocLock_allocLockPtr_dataKey_initialized_key_notifierCount_waitingListPtr_triggerPipe_dataKey_notifierMutex_notifierThread_notifierCV_FileHandlerEventProc_NotifierThreadProc_initialized.0_openresourcemap.1___ashldi3___ashrdi3___divdi3___fixdfdi___floatdidf___moddi3restFPsaveFP___fixunsdfdi___cmpdi2__mh_dylib_headerWishkit.app/Contents/Frameworks/Tcl.framework/Versions/Current0120755000000000000240000000000010153113663024142 28.4ustar rootstaffWishkit.app/Contents/Frameworks/Tk.framework/0040755000000000000240000000000010153074464020402 5ustar rootstaffWishkit.app/Contents/Frameworks/Tk.framework/Resources0120755000000000000240000000000010153113663027411 2Versions/Current/Resourcesustar rootstaffWishkit.app/Contents/Frameworks/Tk.framework/Tk0120755000000000000240000000000010153113663024421 2Versions/Current/Tkustar rootstaffWishkit.app/Contents/Frameworks/Tk.framework/Versions/0040755000000000000240000000000010153074423022205 5ustar rootstaffWishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/0040755000000000000240000000000010153114242022510 5ustar rootstaffWishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/0040755000000000000240000000000010153074436024474 5ustar rootstaffWishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Info.plist0100644000000000001200000000165610153074424026430 0ustar rootadmin CFBundleDevelopmentRegion English CFBundleExecutable Tk CFBundleGetInfoString Tk Library 8.4, Copyright © 2004 Tcl Core Team. MacOS X Port by Jim Ingham <jingham@apple.com> & Ian Reid, Copyright © 2001-2002, Apple Computer, Inc. CFBundleIdentifier com.tcltk.tklibrary CFBundleInfoDictionaryVersion 6.0 CFBundleName Tk Library 8.4 CFBundlePackageType FMWK CFBundleShortVersionString 8.4.8 CFBundleSignature WiSH CFBundleVersion 8.4.8 Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/0040755000000000000240000000000010153074464026124 5ustar rootstaffWishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/bgerror.tcl0100644000000000001200000002061410153074436030253 0ustar rootadmin# bgerror.tcl -- # # Implementation of the bgerror procedure. It posts a dialog box with # the error message and gives the user a chance to see a more detailed # stack trace, and possible do something more interesting with that # trace (like save it to a log). This is adapted from work done by # Donal K. Fellows. # # Copyright (c) 1998-2000 by Ajuba Solutions. # All rights reserved. # # RCS: @(#) $Id: bgerror.tcl,v 1.23.2.2 2004/04/17 03:54:10 hobbs Exp $ # $Id: bgerror.tcl,v 1.23.2.2 2004/04/17 03:54:10 hobbs Exp $ namespace eval ::tk::dialog::error { namespace import -force ::tk::msgcat::* namespace export bgerror option add *ErrorDialog.function.text [mc "Save To Log"] \ widgetDefault option add *ErrorDialog.function.command [namespace code SaveToLog] } proc ::tk::dialog::error::Return {} { variable button .bgerrorDialog.ok configure -state active -relief sunken update idletasks after 100 set button 0 } proc ::tk::dialog::error::Details {} { set w .bgerrorDialog set caption [option get $w.function text {}] set command [option get $w.function command {}] if { ($caption eq "") || ($command eq "") } { grid forget $w.function } lappend command [.bgerrorDialog.top.info.text get 1.0 end-1c] $w.function configure -text $caption -command $command grid $w.top.info - -sticky nsew -padx 3m -pady 3m } proc ::tk::dialog::error::SaveToLog {text} { if { $::tcl_platform(platform) eq "windows" } { set allFiles *.* } else { set allFiles * } set types [list \ [list [mc "Log Files"] .log] \ [list [mc "Text Files"] .txt] \ [list [mc "All Files"] $allFiles] \ ] set filename [tk_getSaveFile -title [mc "Select Log File"] \ -filetypes $types -defaultextension .log -parent .bgerrorDialog] if {![string length $filename]} { return } set f [open $filename w] puts -nonewline $f $text close $f } proc ::tk::dialog::error::Destroy {w} { if {$w eq ".bgerrorDialog"} { variable button set button -1 } } # ::tk::dialog::error::bgerror -- # This is the default version of bgerror. # It tries to execute tkerror, if that fails it posts a dialog box containing # the error message and gives the user a chance to ask to see a stack # trace. # Arguments: # err - The error message. proc ::tk::dialog::error::bgerror err { global errorInfo tcl_platform variable button set info $errorInfo set ret [catch {::tkerror $err} msg]; if {$ret != 1} {return -code $ret $msg} # Ok the application's tkerror either failed or was not found # we use the default dialog then : if {($tcl_platform(platform) eq "macintosh") || ([tk windowingsystem] eq "aqua")} { set ok [mc Ok] set messageFont system set textRelief flat set textHilight 0 } else { set ok [mc OK] set messageFont {Times -18} set textRelief sunken set textHilight 1 } # Truncate the message if it is too wide (longer than 30 characacters) or # too tall (more than 4 newlines). Truncation occurs at the first point at # which one of those conditions is met. set displayedErr "" set lines 0 foreach line [split $err \n] { if { [string length $line] > 30 } { append displayedErr "[string range $line 0 29]..." break } if { $lines > 4 } { append displayedErr "..." break } else { append displayedErr "${line}\n" } incr lines } set w .bgerrorDialog set title [mc "Application Error"] set text [mc {Error: %1$s} $err] set buttons [list ok $ok dismiss [mc "Skip Messages"] \ function [mc "Details >>"]] # 1. Create the top-level window and divide it into top # and bottom parts. catch {destroy .bgerrorDialog} toplevel .bgerrorDialog -class ErrorDialog wm withdraw .bgerrorDialog wm title .bgerrorDialog $title wm iconname .bgerrorDialog ErrorDialog wm protocol .bgerrorDialog WM_DELETE_WINDOW { } if {($tcl_platform(platform) eq "macintosh") || ([tk windowingsystem] eq "aqua")} { ::tk::unsupported::MacWindowStyle style .bgerrorDialog dBoxProc } frame .bgerrorDialog.bot frame .bgerrorDialog.top if {[tk windowingsystem] eq "x11"} { .bgerrorDialog.bot configure -relief raised -bd 1 .bgerrorDialog.top configure -relief raised -bd 1 } pack .bgerrorDialog.bot -side bottom -fill both pack .bgerrorDialog.top -side top -fill both -expand 1 set W [frame $w.top.info] text $W.text \ -bd 2 \ -yscrollcommand [list $W.scroll set]\ -setgrid true \ -width 40 \ -height 10 \ -state normal \ -relief $textRelief \ -highlightthickness $textHilight \ -wrap char scrollbar $W.scroll -relief sunken -command [list $W.text yview] pack $W.scroll -side right -fill y pack $W.text -side left -expand yes -fill both $W.text insert 0.0 "$err\n$info" $W.text mark set insert 0.0 bind $W.text { focus %W } $W.text configure -state disabled # 2. Fill the top part with bitmap and message # Max-width of message is the width of the screen... set wrapwidth [winfo screenwidth .bgerrorDialog] # ...minus the width of the icon, padding and a fudge factor for # the window manager decorations and aesthetics. set wrapwidth [expr {$wrapwidth-60-[winfo pixels .bgerrorDialog 9m]}] label .bgerrorDialog.msg -justify left -text $text -font $messageFont \ -wraplength $wrapwidth if {($tcl_platform(platform) eq "macintosh") || ([tk windowingsystem] eq "aqua")} { # On the Macintosh, use the stop bitmap label .bgerrorDialog.bitmap -bitmap stop } else { # On other platforms, make the error icon canvas .bgerrorDialog.bitmap -width 32 -height 32 -highlightthickness 0 .bgerrorDialog.bitmap create oval 0 0 31 31 -fill red -outline black .bgerrorDialog.bitmap create line 9 9 23 23 -fill white -width 4 .bgerrorDialog.bitmap create line 9 23 23 9 -fill white -width 4 } grid .bgerrorDialog.bitmap .bgerrorDialog.msg \ -in .bgerrorDialog.top \ -row 0 \ -padx 3m \ -pady 3m grid configure .bgerrorDialog.msg -sticky nsw -padx {0 3m} grid rowconfigure .bgerrorDialog.top 1 -weight 1 grid columnconfigure .bgerrorDialog.top 1 -weight 1 # 3. Create a row of buttons at the bottom of the dialog. set i 0 foreach {name caption} $buttons { button .bgerrorDialog.$name \ -text $caption \ -default normal \ -command [namespace code [list set button $i]] grid .bgerrorDialog.$name \ -in .bgerrorDialog.bot \ -column $i \ -row 0 \ -sticky ew \ -padx 10 grid columnconfigure .bgerrorDialog.bot $i -weight 1 # We boost the size of some Mac buttons for l&f if {($tcl_platform(platform) eq "macintosh") || ([tk windowingsystem] eq "aqua")} { if {($name eq "ok") || ($name eq "dismiss")} { grid columnconfigure .bgerrorDialog.bot $i -minsize 79 } } incr i } # The "OK" button is the default for this dialog. .bgerrorDialog.ok configure -default active bind .bgerrorDialog [namespace code Return] bind .bgerrorDialog [namespace code [list Destroy %W]] .bgerrorDialog.function configure -command [namespace code Details] # 6. Update all the geometry information so we know how big it wants # to be, then center the window in the display and deiconify it. ::tk::PlaceWindow .bgerrorDialog # 7. Ensure that we are topmost. raise .bgerrorDialog if {$tcl_platform(platform) eq "windows"} { # Place it topmost if we aren't at the top of the stacking # order to ensure that it's seen if {[lindex [wm stackorder .] end] ne ".bgerrorDialog"} { wm attributes .bgerrorDialog -topmost 1 } } # 8. Set a grab and claim the focus too. ::tk::SetFocusGrab .bgerrorDialog .bgerrorDialog.ok # 9. 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 [namespace which -variable button] set copy $button; # Save a copy... ::tk::RestoreFocusGrab .bgerrorDialog .bgerrorDialog.ok destroy if {$copy == 1} { return -code break } } namespace eval :: { # Fool the indexer proc bgerror err {} rename bgerror {} namespace import ::tk::dialog::error::bgerror } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/button.tcl0100644000000000001200000004047210153074436030130 0ustar rootadmin# button.tcl -- # # This file defines the default bindings for Tk label, button, # checkbutton, and radiobutton widgets and provides procedures # that help in implementing those bindings. # # RCS: @(#) $Id: button.tcl,v 1.17 2002/09/04 02:05:52 hobbs Exp $ # # Copyright (c) 1992-1994 The Regents of the University of California. # Copyright (c) 1994-1996 Sun Microsystems, Inc. # Copyright (c) 2002 ActiveState Corporation. # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # #------------------------------------------------------------------------- # The code below creates the default class bindings for buttons. #------------------------------------------------------------------------- if {[string equal [tk windowingsystem] "classic"] || [string equal [tk windowingsystem] "aqua"]} { bind Radiobutton { tk::ButtonEnter %W } bind Radiobutton <1> { tk::ButtonDown %W } bind Radiobutton { tk::ButtonUp %W } bind Checkbutton { tk::ButtonEnter %W } bind Checkbutton <1> { tk::ButtonDown %W } bind Checkbutton { tk::ButtonUp %W } } if {[string equal "windows" $tcl_platform(platform)]} { bind Checkbutton { tk::CheckRadioInvoke %W select } bind Checkbutton { tk::CheckRadioInvoke %W select } bind Checkbutton { tk::CheckRadioInvoke %W deselect } bind Checkbutton <1> { tk::CheckRadioDown %W } bind Checkbutton { tk::ButtonUp %W } bind Checkbutton { tk::CheckRadioEnter %W } bind Radiobutton <1> { tk::CheckRadioDown %W } bind Radiobutton { tk::ButtonUp %W } bind Radiobutton { tk::CheckRadioEnter %W } } if {[string equal "x11" [tk windowingsystem]]} { bind Checkbutton { if {!$tk_strictMotif} { tk::CheckRadioInvoke %W } } bind Radiobutton { if {!$tk_strictMotif} { tk::CheckRadioInvoke %W } } bind Checkbutton <1> { tk::CheckRadioInvoke %W } bind Radiobutton <1> { tk::CheckRadioInvoke %W } bind Checkbutton { tk::ButtonEnter %W } bind Radiobutton { tk::ButtonEnter %W } } bind Button { tk::ButtonInvoke %W } bind Checkbutton { tk::CheckRadioInvoke %W } bind Radiobutton { tk::CheckRadioInvoke %W } bind Button {} bind Button { tk::ButtonEnter %W } bind Button { tk::ButtonLeave %W } bind Button <1> { tk::ButtonDown %W } bind Button { tk::ButtonUp %W } bind Checkbutton {} bind Checkbutton { tk::ButtonLeave %W } bind Radiobutton {} bind Radiobutton { tk::ButtonLeave %W } if {[string equal "windows" $tcl_platform(platform)]} { ######################### # Windows implementation ######################### # ::tk::ButtonEnter -- # The procedure below is invoked when the mouse pointer enters a # button widget. It records the button we're in and changes the # state of the button to active unless the button is disabled. # # Arguments: # w - The name of the widget. proc ::tk::ButtonEnter w { variable ::tk::Priv if {[$w cget -state] ne "disabled"} { # If the mouse button is down, set the relief to sunken on entry. # Overwise, if there's an -overrelief value, set the relief to that. set Priv($w,relief) [$w cget -relief] if {$Priv(buttonWindow) eq $w} { $w configure -relief sunken -state active set Priv($w,prelief) sunken } elseif {[set over [$w cget -overrelief]] ne ""} { $w configure -relief $over set Priv($w,prelief) $over } } set Priv(window) $w } # ::tk::ButtonLeave -- # The procedure below is invoked when the mouse pointer leaves a # button widget. It changes the state of the button back to inactive. # Restore any modified relief too. # # Arguments: # w - The name of the widget. proc ::tk::ButtonLeave w { variable ::tk::Priv if {[$w cget -state] ne "disabled"} { $w configure -state normal } # Restore the original button relief if it was changed by Tk. # That is signaled by the existence of Priv($w,prelief). if {[info exists Priv($w,relief)]} { if {[info exists Priv($w,prelief)] && \ $Priv($w,prelief) eq [$w cget -relief]} { $w configure -relief $Priv($w,relief) } unset -nocomplain Priv($w,relief) Priv($w,prelief) } set Priv(window) "" } # ::tk::ButtonDown -- # The procedure below is invoked when the mouse button is pressed in # a button widget. It records the fact that the mouse is in the button, # saves the button's relief so it can be restored later, and changes # the relief to sunken. # # Arguments: # w - The name of the widget. proc ::tk::ButtonDown w { variable ::tk::Priv # Only save the button's relief if it does not yet exist. If there # is an overrelief setting, Priv($w,relief) will already have been set, # and the current value of the -relief option will be incorrect. if {![info exists Priv($w,relief)]} { set Priv($w,relief) [$w cget -relief] } if {[$w cget -state] ne "disabled"} { set Priv(buttonWindow) $w $w configure -relief sunken -state active set Priv($w,prelief) sunken # If this button has a repeatdelay set up, get it going with an after after cancel $Priv(afterId) set delay [$w cget -repeatdelay] set Priv(repeated) 0 if {$delay > 0} { set Priv(afterId) [after $delay [list tk::ButtonAutoInvoke $w]] } } } # ::tk::ButtonUp -- # The procedure below is invoked when the mouse button is released # in a button widget. It restores the button's relief and invokes # the command as long as the mouse hasn't left the button. # # Arguments: # w - The name of the widget. proc ::tk::ButtonUp w { variable ::tk::Priv if {$Priv(buttonWindow) eq $w} { set Priv(buttonWindow) "" # Restore the button's relief if it was cached. if {[info exists Priv($w,relief)]} { if {[info exists Priv($w,prelief)] && \ $Priv($w,prelief) eq [$w cget -relief]} { $w configure -relief $Priv($w,relief) } unset -nocomplain Priv($w,relief) Priv($w,prelief) } # Clean up the after event from the auto-repeater after cancel $Priv(afterId) if {$Priv(window) eq $w && [$w cget -state] ne "disabled"} { $w configure -state normal # Only invoke the command if it wasn't already invoked by the # auto-repeater functionality if { $Priv(repeated) == 0 } { uplevel #0 [list $w invoke] } } } } # ::tk::CheckRadioEnter -- # The procedure below is invoked when the mouse pointer enters a # checkbutton or radiobutton widget. It records the button we're in # and changes the state of the button to active unless the button is # disabled. # # Arguments: # w - The name of the widget. proc ::tk::CheckRadioEnter w { variable ::tk::Priv if {[$w cget -state] ne "disabled"} { if {$Priv(buttonWindow) eq $w} { $w configure -state active } if {[set over [$w cget -overrelief]] ne ""} { set Priv($w,relief) [$w cget -relief] set Priv($w,prelief) $over $w configure -relief $over } } set Priv(window) $w } # ::tk::CheckRadioDown -- # The procedure below is invoked when the mouse button is pressed in # a button widget. It records the fact that the mouse is in the button, # saves the button's relief so it can be restored later, and changes # the relief to sunken. # # Arguments: # w - The name of the widget. proc ::tk::CheckRadioDown w { variable ::tk::Priv if {![info exists Priv($w,relief)]} { set Priv($w,relief) [$w cget -relief] } if {[$w cget -state] ne "disabled"} { set Priv(buttonWindow) $w set Priv(repeated) 0 $w configure -state active } } } if {[string equal "x11" [tk windowingsystem]]} { ##################### # Unix implementation ##################### # ::tk::ButtonEnter -- # The procedure below is invoked when the mouse pointer enters a # button widget. It records the button we're in and changes the # state of the button to active unless the button is disabled. # # Arguments: # w - The name of the widget. proc ::tk::ButtonEnter {w} { variable ::tk::Priv if {[$w cget -state] ne "disabled"} { # On unix the state is active just with mouse-over $w configure -state active # If the mouse button is down, set the relief to sunken on entry. # Overwise, if there's an -overrelief value, set the relief to that. set Priv($w,relief) [$w cget -relief] if {$Priv(buttonWindow) eq $w} { $w configure -relief sunken set Priv($w,prelief) sunken } elseif {[set over [$w cget -overrelief]] ne ""} { $w configure -relief $over set Priv($w,prelief) $over } } set Priv(window) $w } # ::tk::ButtonLeave -- # The procedure below is invoked when the mouse pointer leaves a # button widget. It changes the state of the button back to inactive. # Restore any modified relief too. # # Arguments: # w - The name of the widget. proc ::tk::ButtonLeave w { variable ::tk::Priv if {[$w cget -state] ne "disabled"} { $w configure -state normal } # Restore the original button relief if it was changed by Tk. # That is signaled by the existence of Priv($w,prelief). if {[info exists Priv($w,relief)]} { if {[info exists Priv($w,prelief)] && \ $Priv($w,prelief) eq [$w cget -relief]} { $w configure -relief $Priv($w,relief) } unset -nocomplain Priv($w,relief) Priv($w,prelief) } set Priv(window) "" } # ::tk::ButtonDown -- # The procedure below is invoked when the mouse button is pressed in # a button widget. It records the fact that the mouse is in the button, # saves the button's relief so it can be restored later, and changes # the relief to sunken. # # Arguments: # w - The name of the widget. proc ::tk::ButtonDown w { variable ::tk::Priv # Only save the button's relief if it does not yet exist. If there # is an overrelief setting, Priv($w,relief) will already have been set, # and the current value of the -relief option will be incorrect. if {![info exists Priv($w,relief)]} { set Priv($w,relief) [$w cget -relief] } if {[$w cget -state] ne "disabled"} { set Priv(buttonWindow) $w $w configure -relief sunken set Priv($w,prelief) sunken # If this button has a repeatdelay set up, get it going with an after after cancel $Priv(afterId) set delay [$w cget -repeatdelay] set Priv(repeated) 0 if {$delay > 0} { set Priv(afterId) [after $delay [list tk::ButtonAutoInvoke $w]] } } } # ::tk::ButtonUp -- # The procedure below is invoked when the mouse button is released # in a button widget. It restores the button's relief and invokes # the command as long as the mouse hasn't left the button. # # Arguments: # w - The name of the widget. proc ::tk::ButtonUp w { variable ::tk::Priv if {[string equal $w $Priv(buttonWindow)]} { set Priv(buttonWindow) "" # Restore the button's relief if it was cached. if {[info exists Priv($w,relief)]} { if {[info exists Priv($w,prelief)] && \ $Priv($w,prelief) eq [$w cget -relief]} { $w configure -relief $Priv($w,relief) } unset -nocomplain Priv($w,relief) Priv($w,prelief) } # Clean up the after event from the auto-repeater after cancel $Priv(afterId) if {$Priv(window) eq $w && [$w cget -state] ne "disabled"} { # Only invoke the command if it wasn't already invoked by the # auto-repeater functionality if { $Priv(repeated) == 0 } { uplevel #0 [list $w invoke] } } } } } if {[string equal [tk windowingsystem] "classic"] || [string equal [tk windowingsystem] "aqua"]} { #################### # Mac implementation #################### # ::tk::ButtonEnter -- # The procedure below is invoked when the mouse pointer enters a # button widget. It records the button we're in and changes the # state of the button to active unless the button is disabled. # # Arguments: # w - The name of the widget. proc ::tk::ButtonEnter {w} { variable ::tk::Priv if {[$w cget -state] ne "disabled"} { # If there's an -overrelief value, set the relief to that. if {$Priv(buttonWindow) eq $w} { $w configure -state active } elseif {[set over [$w cget -overrelief]] ne ""} { set Priv($w,relief) [$w cget -relief] set Priv($w,prelief) $over $w configure -relief $over } } set Priv(window) $w } # ::tk::ButtonLeave -- # The procedure below is invoked when the mouse pointer leaves a # button widget. It changes the state of the button back to # inactive. If we're leaving the button window with a mouse button # pressed (Priv(buttonWindow) == $w), restore the relief of the # button too. # # Arguments: # w - The name of the widget. proc ::tk::ButtonLeave w { variable ::tk::Priv if {$w eq $Priv(buttonWindow)} { $w configure -state normal } # Restore the original button relief if it was changed by Tk. # That is signaled by the existence of Priv($w,prelief). if {[info exists Priv($w,relief)]} { if {[info exists Priv($w,prelief)] && \ $Priv($w,prelief) eq [$w cget -relief]} { $w configure -relief $Priv($w,relief) } unset -nocomplain Priv($w,relief) Priv($w,prelief) } set Priv(window) "" } # ::tk::ButtonDown -- # The procedure below is invoked when the mouse button is pressed in # a button widget. It records the fact that the mouse is in the button, # saves the button's relief so it can be restored later, and changes # the relief to sunken. # # Arguments: # w - The name of the widget. proc ::tk::ButtonDown w { variable ::tk::Priv if {[$w cget -state] ne "disabled"} { set Priv(buttonWindow) $w $w configure -state active # If this button has a repeatdelay set up, get it going with an after after cancel $Priv(afterId) set Priv(repeated) 0 if { ![catch {$w cget -repeatdelay} delay] } { if {$delay > 0} { set Priv(afterId) [after $delay [list tk::ButtonAutoInvoke $w]] } } } } # ::tk::ButtonUp -- # The procedure below is invoked when the mouse button is released # in a button widget. It restores the button's relief and invokes # the command as long as the mouse hasn't left the button. # # Arguments: # w - The name of the widget. proc ::tk::ButtonUp w { variable ::tk::Priv if {$Priv(buttonWindow) eq $w} { set Priv(buttonWindow) "" $w configure -state normal # Restore the button's relief if it was cached. if {[info exists Priv($w,relief)]} { if {[info exists Priv($w,prelief)] && \ $Priv($w,prelief) eq [$w cget -relief]} { $w configure -relief $Priv($w,relief) } unset -nocomplain Priv($w,relief) Priv($w,prelief) } # Clean up the after event from the auto-repeater after cancel $Priv(afterId) if {$Priv(window) eq $w && [$w cget -state] ne "disabled"} { # Only invoke the command if it wasn't already invoked by the # auto-repeater functionality if { $Priv(repeated) == 0 } { uplevel #0 [list $w invoke] } } } } } ################## # Shared routines ################## # ::tk::ButtonInvoke -- # The procedure below is called when a button is invoked through # the keyboard. It simulate a press of the button via the mouse. # # Arguments: # w - The name of the widget. proc ::tk::ButtonInvoke w { if {[$w cget -state] ne "disabled"} { set oldRelief [$w cget -relief] set oldState [$w cget -state] $w configure -state active -relief sunken update idletasks after 100 $w configure -state $oldState -relief $oldRelief uplevel #0 [list $w invoke] } } # ::tk::ButtonAutoInvoke -- # # Invoke an auto-repeating button, and set it up to continue to repeat. # # Arguments: # w button to invoke. # # Results: # None. # # Side effects: # May create an after event to call ::tk::ButtonAutoInvoke. proc ::tk::ButtonAutoInvoke {w} { variable ::tk::Priv after cancel $Priv(afterId) set delay [$w cget -repeatinterval] if {$Priv(window) eq $w} { incr Priv(repeated) uplevel #0 [list $w invoke] } if {$delay > 0} { set Priv(afterId) [after $delay [list tk::ButtonAutoInvoke $w]] } } # ::tk::CheckRadioInvoke -- # The procedure below is invoked when the mouse button is pressed in # a checkbutton or radiobutton widget, or when the widget is invoked # through the keyboard. It invokes the widget if it # isn't disabled. # # Arguments: # w - The name of the widget. # cmd - The subcommand to invoke (one of invoke, select, or deselect). proc ::tk::CheckRadioInvoke {w {cmd invoke}} { if {[$w cget -state] ne "disabled"} { uplevel #0 [list $w $cmd] } } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/choosedir.tcl0100644000000000001200000002143110153074436030566 0ustar rootadmin# choosedir.tcl -- # # Choose directory dialog implementation for Unix/Mac. # # Copyright (c) 1998-2000 by Scriptics Corporation. # All rights reserved. # # RCS: @(#) $Id: choosedir.tcl,v 1.15 2002/07/22 21:25:39 mdejong Exp $ # Make sure the tk::dialog namespace, in which all dialogs should live, exists namespace eval ::tk::dialog {} namespace eval ::tk::dialog::file {} # Make the chooseDir namespace inside the dialog namespace namespace eval ::tk::dialog::file::chooseDir { namespace import ::tk::msgcat::* } # ::tk::dialog::file::chooseDir:: -- # # Implements the TK directory selection dialog. # # Arguments: # args Options parsed by the procedure. # proc ::tk::dialog::file::chooseDir:: {args} { variable ::tk::Priv set dataName __tk_choosedir upvar ::tk::dialog::file::$dataName data ::tk::dialog::file::chooseDir::Config $dataName $args if {[string equal $data(-parent) .]} { set w .$dataName } else { set w $data(-parent).$dataName } # (re)create the dialog box if necessary # if {![winfo exists $w]} { ::tk::dialog::file::Create $w TkChooseDir } elseif {[string compare [winfo class $w] TkChooseDir]} { destroy $w ::tk::dialog::file::Create $w TkChooseDir } else { set data(dirMenuBtn) $w.f1.menu set data(dirMenu) $w.f1.menu.menu set data(upBtn) $w.f1.up set data(icons) $w.icons set data(ent) $w.f2.ent set data(okBtn) $w.f2.ok set data(cancelBtn) $w.f3.cancel } # 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) } trace variable data(selectPath) w [list ::tk::dialog::file::SetPath $w] $data(dirMenuBtn) configure \ -textvariable ::tk::dialog::file::${dataName}(selectPath) set data(filter) "*" set data(previousEntryText) "" ::tk::dialog::file::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 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(selectPath) $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 vinfo data(selectPath)] { trace vdelete data(selectPath) [lindex $trace 0] [lindex $trace 1] } $data(dirMenuBtn) configure -textvariable {} # Return value to user # return $Priv(selectFilePath) } # ::tk::dialog::file::chooseDir::Config -- # # Configures the Tk choosedir dialog according to the argument list # proc ::tk::dialog::file::chooseDir::Config {dataName argList} { upvar ::tk::dialog::file::$dataName data # 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 vinfo data(selectPath)] { trace vdelete data(selectPath) [lindex $trace 0] [lindex $trace 1] } # 1: the configuration specs # set specs { {-mustexist "" "" 0} {-initialdir "" "" ""} {-parent "" "" "."} {-title "" "" ""} } # 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] } # 3: parse the arguments # tclParseConfigSpec ::tk::dialog::file::$dataName $specs "" $argList if {$data(-title) == ""} { set data(-title) "[mc "Choose Directory"]" } # Stub out the -multiple value for the dialog; it doesn't make sense for # choose directory dialogs, but we have to have something there because we # share so much code with the file dialogs. set data(-multiple) 0 # 4: set the default directory and selection according to the -initial # settings # if {$data(-initialdir) != ""} { # 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] } } if {![winfo exists $data(-parent)]} { error "bad window path name \"$data(-parent)\"" } } # Gets called when user presses Return in the "Selection" entry or presses OK. # proc ::tk::dialog::file::chooseDir::OkCmd {w} { upvar ::tk::dialog::file::[winfo name $w] data # This is the brains behind selecting non-existant directories. Here's # the flowchart: # 1. If the icon list has a selection, join it with the current dir, # and return that value. # 1a. If the icon list does not have a selection ... # 2. If the entry is empty, do nothing. # 3. If the entry contains an invalid directory, then... # 3a. If the value is the same as last time through here, end dialog. # 3b. If the value is different than last time, save it and return. # 4. If entry contains a valid directory, then... # 4a. If the value is the same as the current directory, end dialog. # 4b. If the value is different from the current directory, change to # that directory. set selection [tk::IconList_Curselection $data(icons)] if { [llength $selection] != 0 } { set iconText [tk::IconList_Get $data(icons) [lindex $selection 0]] set iconText [file join $data(selectPath) $iconText] ::tk::dialog::file::chooseDir::Done $w $iconText } else { set text [$data(ent) get] if { [string equal $text ""] } { return } set text [eval file join [file split [string trim $text]]] if { ![file exists $text] || ![file isdirectory $text] } { # Entry contains an invalid directory. If it's the same as the # last time they came through here, reset the saved value and end # the dialog. Otherwise, save the value (so we can do this test # next time). if { [string equal $text $data(previousEntryText)] } { set data(previousEntryText) "" ::tk::dialog::file::chooseDir::Done $w $text } else { set data(previousEntryText) $text } } else { # Entry contains a valid directory. If it is the same as the # current directory, end the dialog. Otherwise, change to that # directory. if { [string equal $text $data(selectPath)] } { ::tk::dialog::file::chooseDir::Done $w $text } else { set data(selectPath) $text } } } return } proc ::tk::dialog::file::chooseDir::DblClick {w} { upvar ::tk::dialog::file::[winfo name $w] data set selection [tk::IconList_Curselection $data(icons)] if { [llength $selection] != 0 } { set filenameFragment \ [tk::IconList_Get $data(icons) [lindex $selection 0]] set file $data(selectPath) if {[file isdirectory $file]} { ::tk::dialog::file::ListInvoke $w [list $filenameFragment] return } } } # Gets called when user browses the IconList widget (dragging mouse, arrow # keys, etc) # proc ::tk::dialog::file::chooseDir::ListBrowse {w text} { upvar ::tk::dialog::file::[winfo name $w] data if {[string equal $text ""]} { return } set file [::tk::dialog::file::JoinFile $data(selectPath) $text] $data(ent) delete 0 end $data(ent) insert 0 $file } # ::tk::dialog::file::chooseDir::Done -- # # Gets called when user has input a valid filename. Pops up a # dialog box to confirm selection when necessary. Sets the # Priv(selectFilePath) variable, which will break the "vwait" # loop in tk_chooseDirectory and return the selected filename to the # script that calls tk_getOpenFile or tk_getSaveFile # proc ::tk::dialog::file::chooseDir::Done {w {selectFilePath ""}} { upvar ::tk::dialog::file::[winfo name $w] data variable ::tk::Priv if {[string equal $selectFilePath ""]} { set selectFilePath $data(selectPath) } if { $data(-mustexist) } { if { ![file exists $selectFilePath] || \ ![file isdir $selectFilePath] } { return } } set Priv(selectFilePath) $selectFilePath } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/clrpick.tcl0100644000000000001200000005156610153074436030252 0ustar rootadmin# clrpick.tcl -- # # Color selection dialog for platforms that do not support a # standard color selection dialog. # # RCS: @(#) $Id: clrpick.tcl,v 1.20 2003/02/21 14:40:26 dkf Exp $ # # Copyright (c) 1996 Sun Microsystems, Inc. # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # # ToDo: # # (1): Find out how many free colors are left in the colormap and # don't allocate too many colors. # (2): Implement HSV color selection. # # Make sure namespaces exist namespace eval ::tk {} namespace eval ::tk::dialog {} namespace eval ::tk::dialog::color { namespace import ::tk::msgcat::* } # ::tk::dialog::color:: -- # # Create a color dialog and let the user choose a color. This function # should not be called directly. It is called by the tk_chooseColor # function when a native color selector widget does not exist # proc ::tk::dialog::color:: {args} { variable ::tk::Priv set dataName __tk__color upvar ::tk::dialog::color::$dataName data set w .$dataName # The lines variables track the start and end indices of the line # elements in the colorbar canvases. set data(lines,red,start) 0 set data(lines,red,last) -1 set data(lines,green,start) 0 set data(lines,green,last) -1 set data(lines,blue,start) 0 set data(lines,blue,last) -1 # This is the actual number of lines that are drawn in each color strip. # Note that the bars may be of any width. # However, NUM_COLORBARS must be a number that evenly divides 256. # Such as 256, 128, 64, etc. set data(NUM_COLORBARS) 16 # BARS_WIDTH is the number of pixels wide the color bar portion of the # canvas is. This number must be a multiple of NUM_COLORBARS set data(BARS_WIDTH) 160 # PLGN_WIDTH is the number of pixels wide of the triangular selection # polygon. This also results in the definition of the padding on the # left and right sides which is half of PLGN_WIDTH. Make this number even. set data(PLGN_HEIGHT) 10 # PLGN_HEIGHT is the height of the selection polygon and the height of the # selection rectangle at the bottom of the color bar. No restrictions. set data(PLGN_WIDTH) 10 Config $dataName $args InitValues $dataName set sc [winfo screen $data(-parent)] set winExists [winfo exists $w] if {!$winExists || [string compare $sc [winfo screen $w]]} { if {$winExists} { destroy $w } toplevel $w -class TkColorDialog -screen $sc BuildDialog $w } # 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) } # 5. 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 and de-iconify it. ::tk::PlaceWindow $w widget $data(-parent) wm title $w $data(-title) # 6. Set a grab and claim the focus too. ::tk::SetFocusGrab $w $data(okBtn) # 7. 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(selectColor) ::tk::RestoreFocusGrab $w $data(okBtn) unset data return $Priv(selectColor) } # ::tk::dialog::color::InitValues -- # # Get called during initialization or when user resets NUM_COLORBARS # proc ::tk::dialog::color::InitValues {dataName} { upvar ::tk::dialog::color::$dataName data # IntensityIncr is the difference in color intensity between a colorbar # and its neighbors. set data(intensityIncr) [expr {256 / $data(NUM_COLORBARS)}] # ColorbarWidth is the width of each colorbar set data(colorbarWidth) \ [expr {$data(BARS_WIDTH) / $data(NUM_COLORBARS)}] # Indent is the width of the space at the left and right side of the # colorbar. It is always half the selector polygon width, because the # polygon extends into the space. set data(indent) [expr {$data(PLGN_WIDTH) / 2}] set data(colorPad) 2 set data(selPad) [expr {$data(PLGN_WIDTH) / 2}] # # minX is the x coordinate of the first colorbar # set data(minX) $data(indent) # # maxX is the x coordinate of the last colorbar # set data(maxX) [expr {$data(BARS_WIDTH) + $data(indent)-1}] # # canvasWidth is the width of the entire canvas, including the indents # set data(canvasWidth) [expr {$data(BARS_WIDTH) + $data(PLGN_WIDTH)}] # Set the initial color, specified by -initialcolor, or the # color chosen by the user the last time. set data(selection) $data(-initialcolor) set data(finalColor) $data(-initialcolor) set rgb [winfo rgb . $data(selection)] set data(red,intensity) [expr {[lindex $rgb 0]/0x100}] set data(green,intensity) [expr {[lindex $rgb 1]/0x100}] set data(blue,intensity) [expr {[lindex $rgb 2]/0x100}] } # ::tk::dialog::color::Config -- # # Parses the command line arguments to tk_chooseColor # proc ::tk::dialog::color::Config {dataName argList} { variable ::tk::Priv upvar ::tk::dialog::color::$dataName data # 1: the configuration specs # if {[info exists Priv(selectColor)] && \ [string compare $Priv(selectColor) ""]} { set defaultColor $Priv(selectColor) } else { set defaultColor [. cget -background] } set specs [list \ [list -initialcolor "" "" $defaultColor] \ [list -parent "" "" "."] \ [list -title "" "" [mc "Color"]] \ ] # 2: parse the arguments # tclParseConfigSpec ::tk::dialog::color::$dataName $specs "" $argList if {[string equal $data(-title) ""]} { set data(-title) " " } if {[catch {winfo rgb . $data(-initialcolor)} err]} { error $err } if {![winfo exists $data(-parent)]} { error "bad window path name \"$data(-parent)\"" } } # ::tk::dialog::color::BuildDialog -- # # Build the dialog. # proc ::tk::dialog::color::BuildDialog {w} { upvar ::tk::dialog::color::[winfo name $w] data # TopFrame contains the color strips and the color selection # set topFrame [frame $w.top -relief raised -bd 1] # StripsFrame contains the colorstrips and the individual RGB entries set stripsFrame [frame $topFrame.colorStrip] set maxWidth [::tk::mcmaxamp &Red &Green &Blue] set maxWidth [expr {$maxWidth<6?6:$maxWidth}] set colorList [list \ red [mc "&Red"] \ green [mc "&Green"] \ blue [mc "&Blue"] \ ] foreach {color l} $colorList { # each f frame contains an [R|G|B] entry and the equiv. color strip. set f [frame $stripsFrame.$color] # The box frame contains the label and entry widget for an [R|G|B] set box [frame $f.box] bind [::tk::AmpWidget label $box.label -text $l: -width $maxWidth \ -anchor ne] <> [list focus $box.entry] entry $box.entry -textvariable \ ::tk::dialog::color::[winfo name $w]($color,intensity) \ -width 4 pack $box.label -side left -fill y -padx 2 -pady 3 pack $box.entry -side left -anchor n -pady 0 pack $box -side left -fill both set height [expr \ {[winfo reqheight $box.entry] - \ 2*([$box.entry cget -highlightthickness] + [$box.entry cget -bd])}] canvas $f.color -height $height\ -width $data(BARS_WIDTH) -relief sunken -bd 2 canvas $f.sel -height $data(PLGN_HEIGHT) \ -width $data(canvasWidth) -highlightthickness 0 pack $f.color -expand yes -fill both pack $f.sel -expand yes -fill both pack $f -side top -fill x -padx 0 -pady 2 set data($color,entry) $box.entry set data($color,col) $f.color set data($color,sel) $f.sel bind $data($color,col) \ [list tk::dialog::color::DrawColorScale $w $color 1] bind $data($color,col) \ [list tk::dialog::color::EnterColorBar $w $color] bind $data($color,col) \ [list tk::dialog::color::LeaveColorBar $w $color] bind $data($color,sel) \ [list tk::dialog::color::EnterColorBar $w $color] bind $data($color,sel) \ [list tk::dialog::color::LeaveColorBar $w $color] bind $box.entry [list tk::dialog::color::HandleRGBEntry $w] } pack $stripsFrame -side left -fill both -padx 4 -pady 10 # The selFrame contains a frame that demonstrates the currently # selected color # set selFrame [frame $topFrame.sel] set lab [::tk::AmpWidget label $selFrame.lab -text [mc "&Selection:"] \ -anchor sw] set ent [entry $selFrame.ent \ -textvariable ::tk::dialog::color::[winfo name $w](selection) \ -width 16] set f1 [frame $selFrame.f1 -relief sunken -bd 2] set data(finalCanvas) [frame $f1.demo -bd 0 -width 100 -height 70] pack $lab $ent -side top -fill x -padx 4 -pady 2 pack $f1 -expand yes -anchor nw -fill both -padx 6 -pady 10 pack $data(finalCanvas) -expand yes -fill both bind $ent [list tk::dialog::color::HandleSelEntry $w] pack $selFrame -side left -fill none -anchor nw pack $topFrame -side top -expand yes -fill both -anchor nw # the botFrame frame contains the buttons # set botFrame [frame $w.bot -relief raised -bd 1] ::tk::AmpWidget button $botFrame.ok -text [mc "&OK"] \ -command [list tk::dialog::color::OkCmd $w] ::tk::AmpWidget button $botFrame.cancel -text [mc "&Cancel"] \ -command [list tk::dialog::color::CancelCmd $w] set data(okBtn) $botFrame.ok set data(cancelBtn) $botFrame.cancel grid x $botFrame.ok x $botFrame.cancel x -sticky ew grid configure $botFrame.ok $botFrame.cancel -padx 10 -pady 10 grid columnconfigure $botFrame {0 4} -weight 1 -uniform space grid columnconfigure $botFrame {1 3} -weight 1 -uniform button grid columnconfigure $botFrame 2 -weight 2 -uniform space pack $botFrame -side bottom -fill x # Accelerator bindings bind $lab <> [list focus $ent] bind $w [list tk::ButtonInvoke $data(cancelBtn)] bind $w [list tk::AltKeyInDialog $w %A] wm protocol $w WM_DELETE_WINDOW [list tk::dialog::color::CancelCmd $w] } # ::tk::dialog::color::SetRGBValue -- # # Sets the current selection of the dialog box # proc ::tk::dialog::color::SetRGBValue {w color} { upvar ::tk::dialog::color::[winfo name $w] data set data(red,intensity) [lindex $color 0] set data(green,intensity) [lindex $color 1] set data(blue,intensity) [lindex $color 2] RedrawColorBars $w all # Now compute the new x value of each colorbars pointer polygon foreach color [list red green blue ] { set x [RgbToX $w $data($color,intensity)] MoveSelector $w $data($color,sel) $color $x 0 } } # ::tk::dialog::color::XToRgb -- # # Converts a screen coordinate to intensity # proc ::tk::dialog::color::XToRgb {w x} { upvar ::tk::dialog::color::[winfo name $w] data set x [expr {($x * $data(intensityIncr))/ $data(colorbarWidth)}] if {$x > 255} { set x 255 } return $x } # ::tk::dialog::color::RgbToX # # Converts an intensity to screen coordinate. # proc ::tk::dialog::color::RgbToX {w color} { upvar ::tk::dialog::color::[winfo name $w] data return [expr {($color * $data(colorbarWidth)/ $data(intensityIncr))}] } # ::tk::dialog::color::DrawColorScale -- # # Draw color scale is called whenever the size of one of the color # scale canvases is changed. # proc ::tk::dialog::color::DrawColorScale {w c {create 0}} { upvar ::tk::dialog::color::[winfo name $w] data # col: color bar canvas # sel: selector canvas set col $data($c,col) set sel $data($c,sel) # First handle the case that we are creating everything for the first time. if {$create} { # First remove all the lines that already exist. if { $data(lines,$c,last) > $data(lines,$c,start)} { for {set i $data(lines,$c,start)} \ {$i <= $data(lines,$c,last)} { incr i} { $sel delete $i } } # Delete the selector if it exists if {[info exists data($c,index)]} { $sel delete $data($c,index) } # Draw the selection polygons CreateSelector $w $sel $c $sel bind $data($c,index) \ [list tk::dialog::color::StartMove $w $sel $c %x $data(selPad) 1] $sel bind $data($c,index) \ [list tk::dialog::color::MoveSelector $w $sel $c %x $data(selPad)] $sel bind $data($c,index) \ [list tk::dialog::color::ReleaseMouse $w $sel $c %x $data(selPad)] set height [winfo height $col] # Create an invisible region under the colorstrip to catch mouse clicks # that aren't on the selector. set data($c,clickRegion) [$sel create rectangle 0 0 \ $data(canvasWidth) $height -fill {} -outline {}] bind $col \ [list tk::dialog::color::StartMove $w $sel $c %x $data(colorPad)] bind $col \ [list tk::dialog::color::MoveSelector $w $sel $c %x $data(colorPad)] bind $col \ [list tk::dialog::color::ReleaseMouse $w $sel $c %x $data(colorPad)] $sel bind $data($c,clickRegion) \ [list tk::dialog::color::StartMove $w $sel $c %x $data(selPad)] $sel bind $data($c,clickRegion) \ [list tk::dialog::color::MoveSelector $w $sel $c %x $data(selPad)] $sel bind $data($c,clickRegion) \ [list tk::dialog::color::ReleaseMouse $w $sel $c %x $data(selPad)] } else { # l is the canvas index of the first colorbar. set l $data(lines,$c,start) } # Draw the color bars. set highlightW [expr {[$col cget -highlightthickness] + [$col cget -bd]}] for {set i 0} { $i < $data(NUM_COLORBARS)} { incr i} { set intensity [expr {$i * $data(intensityIncr)}] set startx [expr {$i * $data(colorbarWidth) + $highlightW}] if {[string equal $c "red"]} { set color [format "#%02x%02x%02x" \ $intensity \ $data(green,intensity) \ $data(blue,intensity)] } elseif {[string equal $c "green"]} { set color [format "#%02x%02x%02x" \ $data(red,intensity) \ $intensity \ $data(blue,intensity)] } else { set color [format "#%02x%02x%02x" \ $data(red,intensity) \ $data(green,intensity) \ $intensity] } if {$create} { set index [$col create rect $startx $highlightW \ [expr {$startx +$data(colorbarWidth)}] \ [expr {[winfo height $col] + $highlightW}]\ -fill $color -outline $color] } else { $col itemconfigure $l -fill $color -outline $color incr l } } $sel raise $data($c,index) if {$create} { set data(lines,$c,last) $index set data(lines,$c,start) [expr {$index - $data(NUM_COLORBARS) + 1}] } RedrawFinalColor $w } # ::tk::dialog::color::CreateSelector -- # # Creates and draws the selector polygon at the position # $data($c,intensity). # proc ::tk::dialog::color::CreateSelector {w sel c } { upvar ::tk::dialog::color::[winfo name $w] data set data($c,index) [$sel create polygon \ 0 $data(PLGN_HEIGHT) \ $data(PLGN_WIDTH) $data(PLGN_HEIGHT) \ $data(indent) 0] set data($c,x) [RgbToX $w $data($c,intensity)] $sel move $data($c,index) $data($c,x) 0 } # ::tk::dialog::color::RedrawFinalColor # # Combines the intensities of the three colors into the final color # proc ::tk::dialog::color::RedrawFinalColor {w} { upvar ::tk::dialog::color::[winfo name $w] data set color [format "#%02x%02x%02x" $data(red,intensity) \ $data(green,intensity) $data(blue,intensity)] $data(finalCanvas) configure -bg $color set data(finalColor) $color set data(selection) $color set data(finalRGB) [list \ $data(red,intensity) \ $data(green,intensity) \ $data(blue,intensity)] } # ::tk::dialog::color::RedrawColorBars -- # # Only redraws the colors on the color strips that were not manipulated. # Params: color of colorstrip that changed. If color is not [red|green|blue] # Then all colorstrips will be updated # proc ::tk::dialog::color::RedrawColorBars {w colorChanged} { upvar ::tk::dialog::color::[winfo name $w] data switch $colorChanged { red { DrawColorScale $w green DrawColorScale $w blue } green { DrawColorScale $w red DrawColorScale $w blue } blue { DrawColorScale $w red DrawColorScale $w green } default { DrawColorScale $w red DrawColorScale $w green DrawColorScale $w blue } } RedrawFinalColor $w } #---------------------------------------------------------------------- # Event handlers #---------------------------------------------------------------------- # ::tk::dialog::color::StartMove -- # # Handles a mousedown button event over the selector polygon. # Adds the bindings for moving the mouse while the button is # pressed. Sets the binding for the button-release event. # # Params: sel is the selector canvas window, color is the color of the strip. # proc ::tk::dialog::color::StartMove {w sel color x delta {dontMove 0}} { upvar ::tk::dialog::color::[winfo name $w] data if {!$dontMove} { MoveSelector $w $sel $color $x $delta } } # ::tk::dialog::color::MoveSelector -- # # Moves the polygon selector so that its middle point has the same # x value as the specified x. If x is outside the bounds [0,255], # the selector is set to the closest endpoint. # # Params: sel is the selector canvas, c is [red|green|blue] # x is a x-coordinate. # proc ::tk::dialog::color::MoveSelector {w sel color x delta} { upvar ::tk::dialog::color::[winfo name $w] data incr x -$delta if { $x < 0 } { set x 0 } elseif { $x > $data(BARS_WIDTH)} { set x $data(BARS_WIDTH) } set diff [expr {$x - $data($color,x)}] $sel move $data($color,index) $diff 0 set data($color,x) [expr {$data($color,x) + $diff}] # Return the x value that it was actually set at return $x } # ::tk::dialog::color::ReleaseMouse # # Removes mouse tracking bindings, updates the colorbars. # # Params: sel is the selector canvas, color is the color of the strip, # x is the x-coord of the mouse. # proc ::tk::dialog::color::ReleaseMouse {w sel color x delta} { upvar ::tk::dialog::color::[winfo name $w] data set x [MoveSelector $w $sel $color $x $delta] # Determine exactly what color we are looking at. set data($color,intensity) [XToRgb $w $x] RedrawColorBars $w $color } # ::tk::dialog::color::ResizeColorbars -- # # Completely redraws the colorbars, including resizing the # colorstrips # proc ::tk::dialog::color::ResizeColorBars {w} { upvar ::tk::dialog::color::[winfo name $w] data if { ($data(BARS_WIDTH) < $data(NUM_COLORBARS)) || (($data(BARS_WIDTH) % $data(NUM_COLORBARS)) != 0)} { set data(BARS_WIDTH) $data(NUM_COLORBARS) } InitValues [winfo name $w] foreach color [list red green blue ] { $data($color,col) configure -width $data(canvasWidth) DrawColorScale $w $color 1 } } # ::tk::dialog::color::HandleSelEntry -- # # Handles the return keypress event in the "Selection:" entry # proc ::tk::dialog::color::HandleSelEntry {w} { upvar ::tk::dialog::color::[winfo name $w] data set text [string trim $data(selection)] # Check to make sure that the color is valid if {[catch {set color [winfo rgb . $text]} ]} { set data(selection) $data(finalColor) return } set R [expr {[lindex $color 0]/0x100}] set G [expr {[lindex $color 1]/0x100}] set B [expr {[lindex $color 2]/0x100}] SetRGBValue $w "$R $G $B" set data(selection) $text } # ::tk::dialog::color::HandleRGBEntry -- # # Handles the return keypress event in the R, G or B entry # proc ::tk::dialog::color::HandleRGBEntry {w} { upvar ::tk::dialog::color::[winfo name $w] data foreach c [list red green blue] { if {[catch { set data($c,intensity) [expr {int($data($c,intensity))}] }]} { set data($c,intensity) 0 } if {$data($c,intensity) < 0} { set data($c,intensity) 0 } if {$data($c,intensity) > 255} { set data($c,intensity) 255 } } SetRGBValue $w "$data(red,intensity) \ $data(green,intensity) $data(blue,intensity)" } # mouse cursor enters a color bar # proc ::tk::dialog::color::EnterColorBar {w color} { upvar ::tk::dialog::color::[winfo name $w] data $data($color,sel) itemconfig $data($color,index) -fill red } # mouse leaves enters a color bar # proc ::tk::dialog::color::LeaveColorBar {w color} { upvar ::tk::dialog::color::[winfo name $w] data $data($color,sel) itemconfig $data($color,index) -fill black } # user hits OK button # proc ::tk::dialog::color::OkCmd {w} { variable ::tk::Priv upvar ::tk::dialog::color::[winfo name $w] data set Priv(selectColor) $data(finalColor) } # user hits Cancel button # proc ::tk::dialog::color::CancelCmd {w} { variable ::tk::Priv set Priv(selectColor) "" } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/comdlg.tcl0100644000000000001200000001702210153074436030055 0ustar rootadmin# comdlg.tcl -- # # Some functions needed for the common dialog boxes. Probably need to go # in a different file. # # RCS: @(#) $Id: comdlg.tcl,v 1.9 2003/02/21 13:32:14 dkf Exp $ # # Copyright (c) 1996 Sun Microsystems, Inc. # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # # tclParseConfigSpec -- # # Parses a list of "-option value" pairs. If all options and # values are legal, the values are stored in # $data($option). Otherwise an error message is returned. When # an error happens, the data() array may have been partially # modified, but all the modified members of the data(0 array are # guaranteed to have valid values. This is different than # Tk_ConfigureWidget() which does not modify the value of a # widget record if any error occurs. # # Arguments: # # w = widget record to modify. Must be the pathname of a widget. # # specs = { # {-commandlineswitch resourceName ResourceClass defaultValue verifier} # {....} # } # # flags = currently unused. # # argList = The list of "-option value" pairs. # proc tclParseConfigSpec {w specs flags argList} { upvar #0 $w data # 1: Put the specs in associative arrays for faster access # foreach spec $specs { if {[llength $spec] < 4} { error "\"spec\" should contain 5 or 4 elements" } set cmdsw [lindex $spec 0] set cmd($cmdsw) "" set rname($cmdsw) [lindex $spec 1] set rclass($cmdsw) [lindex $spec 2] set def($cmdsw) [lindex $spec 3] set verproc($cmdsw) [lindex $spec 4] } if {[llength $argList] & 1} { set cmdsw [lindex $argList end] if {![info exists cmd($cmdsw)]} { error "bad option \"$cmdsw\": must be [tclListValidFlags cmd]" } error "value for \"$cmdsw\" missing" } # 2: set the default values # foreach cmdsw [array names cmd] { set data($cmdsw) $def($cmdsw) } # 3: parse the argument list # foreach {cmdsw value} $argList { if {![info exists cmd($cmdsw)]} { error "bad option \"$cmdsw\": must be [tclListValidFlags cmd]" } set data($cmdsw) $value } # Done! } proc tclListValidFlags {v} { upvar $v cmd set len [llength [array names cmd]] set i 1 set separator "" set errormsg "" foreach cmdsw [lsort [array names cmd]] { append errormsg "$separator$cmdsw" incr i if {$i == $len} { set separator ", or " } else { set separator ", " } } return $errormsg } #---------------------------------------------------------------------- # # Focus Group # # Focus groups are used to handle the user's focusing actions inside a # toplevel. # # One example of using focus groups is: when the user focuses on an # entry, the text in the entry is highlighted and the cursor is put to # the end of the text. When the user changes focus to another widget, # the text in the previously focused entry is validated. # #---------------------------------------------------------------------- # ::tk::FocusGroup_Create -- # # Create a focus group. All the widgets in a focus group must be # within the same focus toplevel. Each toplevel can have only # one focus group, which is identified by the name of the # toplevel widget. # proc ::tk::FocusGroup_Create {t} { variable ::tk::Priv if {[string compare [winfo toplevel $t] $t]} { error "$t is not a toplevel window" } if {![info exists Priv(fg,$t)]} { set Priv(fg,$t) 1 set Priv(focus,$t) "" bind $t [list tk::FocusGroup_In $t %W %d] bind $t [list tk::FocusGroup_Out $t %W %d] bind $t [list tk::FocusGroup_Destroy $t %W] } } # ::tk::FocusGroup_BindIn -- # # Add a widget into the "FocusIn" list of the focus group. The $cmd will be # called when the widget is focused on by the user. # proc ::tk::FocusGroup_BindIn {t w cmd} { variable FocusIn variable ::tk::Priv if {![info exists Priv(fg,$t)]} { error "focus group \"$t\" doesn't exist" } set FocusIn($t,$w) $cmd } # ::tk::FocusGroup_BindOut -- # # Add a widget into the "FocusOut" list of the focus group. The # $cmd will be called when the widget loses the focus (User # types Tab or click on another widget). # proc ::tk::FocusGroup_BindOut {t w cmd} { variable FocusOut variable ::tk::Priv if {![info exists Priv(fg,$t)]} { error "focus group \"$t\" doesn't exist" } set FocusOut($t,$w) $cmd } # ::tk::FocusGroup_Destroy -- # # Cleans up when members of the focus group is deleted, or when the # toplevel itself gets deleted. # proc ::tk::FocusGroup_Destroy {t w} { variable FocusIn variable FocusOut variable ::tk::Priv if {[string equal $t $w]} { unset Priv(fg,$t) unset Priv(focus,$t) foreach name [array names FocusIn $t,*] { unset FocusIn($name) } foreach name [array names FocusOut $t,*] { unset FocusOut($name) } } else { if {[info exists Priv(focus,$t)] && \ [string equal $Priv(focus,$t) $w]} { set Priv(focus,$t) "" } catch { unset FocusIn($t,$w) } catch { unset FocusOut($t,$w) } } } # ::tk::FocusGroup_In -- # # Handles the event. Calls the FocusIn command for the newly # focused widget in the focus group. # proc ::tk::FocusGroup_In {t w detail} { variable FocusIn variable ::tk::Priv if {[string compare $detail NotifyNonlinear] && \ [string compare $detail NotifyNonlinearVirtual]} { # This is caused by mouse moving out&in of the window *or* # ordinary keypresses some window managers (ie: CDE [Bug: 2960]). return } if {![info exists FocusIn($t,$w)]} { set FocusIn($t,$w) "" return } if {![info exists Priv(focus,$t)]} { return } if {[string equal $Priv(focus,$t) $w]} { # This is already in focus # return } else { set Priv(focus,$t) $w eval $FocusIn($t,$w) } } # ::tk::FocusGroup_Out -- # # Handles the event. Checks if this is really a lose # focus event, not one generated by the mouse moving out of the # toplevel window. Calls the FocusOut command for the widget # who loses its focus. # proc ::tk::FocusGroup_Out {t w detail} { variable FocusOut variable ::tk::Priv if {[string compare $detail NotifyNonlinear] && \ [string compare $detail NotifyNonlinearVirtual]} { # This is caused by mouse moving out of the window return } if {![info exists Priv(focus,$t)]} { return } if {![info exists FocusOut($t,$w)]} { return } else { eval $FocusOut($t,$w) set Priv(focus,$t) "" } } # ::tk::FDGetFileTypes -- # # Process the string given by the -filetypes option of the file # dialogs. Similar to the C function TkGetFileFilters() on the Mac # and Windows platform. # proc ::tk::FDGetFileTypes {string} { foreach t $string { if {[llength $t] < 2 || [llength $t] > 3} { error "bad file type \"$t\", should be \"typeName {extension ?extensions ...?} ?{macType ?macTypes ...?}?\"" } eval lappend [list fileTypes([lindex $t 0])] [lindex $t 1] } set types {} foreach t $string { set label [lindex $t 0] set exts {} if {[info exists hasDoneType($label)]} { continue } set name "$label (" set sep "" set doAppend 1 foreach ext $fileTypes($label) { if {[string equal $ext ""]} { continue } regsub {^[.]} $ext "*." ext if {![info exists hasGotExt($label,$ext)]} { if {$doAppend} { if {[string length $sep] && [string length $name]>40} { set doAppend 0 append name $sep... } else { append name $sep$ext } } lappend exts $ext set hasGotExt($label,$ext) 1 } set sep , } append name ")" lappend types [list $name $exts] set hasDoneType($label) 1 } return $types } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/console.tcl0100644000000000001200000006454610153074436030267 0ustar rootadmin# console.tcl -- # # This code constructs the console window for an application. It # can be used by non-unix systems that do not have built-in support # for shells. # # RCS: @(#) $Id: console.tcl,v 1.22.2.1 2004/11/17 22:18:28 hobbs Exp $ # # Copyright (c) 1995-1997 Sun Microsystems, Inc. # Copyright (c) 1998-2000 Ajuba Solutions. # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # # TODO: history - remember partially written command namespace eval ::tk::console { variable blinkTime 500 ; # msecs to blink braced range for variable blinkRange 1 ; # enable blinking of the entire braced range variable magicKeys 1 ; # enable brace matching and proc/var recognition variable maxLines 600 ; # maximum # of lines buffered in console variable showMatches 1 ; # show multiple expand matches variable inPlugin [info exists embed_args] variable defaultPrompt ; # default prompt if tcl_prompt1 isn't used if {$inPlugin} { set defaultPrompt {subst {[history nextid] % }} } else { set defaultPrompt {subst {([file tail [pwd]]) [history nextid] % }} } } # simple compat function for tkcon code added for this console interp alias {} EvalAttached {} consoleinterp eval # ::tk::ConsoleInit -- # This procedure constructs and configures the console windows. # # Arguments: # None. proc ::tk::ConsoleInit {} { global tcl_platform if {![consoleinterp eval {set tcl_interactive}]} { wm withdraw . } if {[string equal $tcl_platform(platform) "macintosh"] || [string equal [tk windowingsystem] "aqua"]} { set mod "Cmd" } else { set mod "Ctrl" } if {[catch {menu .menubar} err]} { bgerror "INIT: $err" } .menubar add cascade -label File -menu .menubar.file -underline 0 .menubar add cascade -label Edit -menu .menubar.edit -underline 0 menu .menubar.file -tearoff 0 .menubar.file add command -label [mc "Source..."] \ -underline 0 -command tk::ConsoleSource .menubar.file add command -label [mc "Hide Console"] \ -underline 0 -command {wm withdraw .} .menubar.file add command -label [mc "Clear Console"] \ -underline 0 -command {.console delete 1.0 "promptEnd linestart"} if {[string equal $tcl_platform(platform) "macintosh"] || [string equal [tk windowingsystem] "aqua"]} { .menubar.file add command -label [mc "Quit"] \ -command exit -accel Cmd-Q } else { .menubar.file add command -label [mc "Exit"] \ -underline 1 -command exit } menu .menubar.edit -tearoff 0 .menubar.edit add command -label [mc "Cut"] -underline 2 \ -command { event generate .console <> } -accel "$mod+X" .menubar.edit add command -label [mc "Copy"] -underline 0 \ -command { event generate .console <> } -accel "$mod+C" .menubar.edit add command -label [mc "Paste"] -underline 1 \ -command { event generate .console <> } -accel "$mod+V" if {[string compare $tcl_platform(platform) "windows"]} { .menubar.edit add command -label [mc "Clear"] -underline 2 \ -command { event generate .console <> } } else { .menubar.edit add command -label [mc "Delete"] -underline 0 \ -command { event generate .console <> } -accel "Del" .menubar add cascade -label Help -menu .menubar.help -underline 0 menu .menubar.help -tearoff 0 .menubar.help add command -label [mc "About..."] \ -underline 0 -command tk::ConsoleAbout } . configure -menu .menubar set con [text .console -yscrollcommand [list .sb set] -setgrid true] scrollbar .sb -command [list $con yview] pack .sb -side right -fill both pack $con -fill both -expand 1 -side left switch -exact $tcl_platform(platform) { "macintosh" { $con configure -font {Monaco 9 normal} -highlightthickness 0 } "windows" { $con configure -font systemfixed } "unix" { if {[string equal [tk windowingsystem] "aqua"]} { $con configure -font {Monaco 9 normal} -highlightthickness 0 } } } ConsoleBind $con $con tag configure stderr -foreground red $con tag configure stdin -foreground blue $con tag configure prompt -foreground \#8F4433 $con tag configure proc -foreground \#008800 $con tag configure var -background \#FFC0D0 $con tag raise sel $con tag configure blink -background \#FFFF00 $con tag configure find -background \#FFFF00 focus $con wm protocol . WM_DELETE_WINDOW { wm withdraw . } wm title . [mc "Console"] flush stdout $con mark set output [$con index "end - 1 char"] tk::TextSetCursor $con end $con mark set promptEnd insert $con mark gravity promptEnd left } # ::tk::ConsoleSource -- # # Prompts the user for a file to source in the main interpreter. # # Arguments: # None. proc ::tk::ConsoleSource {} { set filename [tk_getOpenFile -defaultextension .tcl -parent . \ -title [mc "Select a file to source"] \ -filetypes [list \ [list [mc "Tcl Scripts"] .tcl] \ [list [mc "All Files"] *]]] if {[string compare $filename ""]} { set cmd [list source $filename] if {[catch {consoleinterp eval $cmd} result]} { ConsoleOutput stderr "$result\n" } } } # ::tk::ConsoleInvoke -- # Processes the command line input. If the command is complete it # is evaled in the main interpreter. Otherwise, the continuation # prompt is added and more input may be added. # # Arguments: # None. proc ::tk::ConsoleInvoke {args} { set ranges [.console tag ranges input] set cmd "" if {[llength $ranges]} { set pos 0 while {[string compare [lindex $ranges $pos] ""]} { set start [lindex $ranges $pos] set end [lindex $ranges [incr pos]] append cmd [.console get $start $end] incr pos } } if {[string equal $cmd ""]} { ConsolePrompt } elseif {[info complete $cmd]} { .console mark set output end .console tag delete input set result [consoleinterp record $cmd] if {[string compare $result ""]} { puts $result } ConsoleHistory reset ConsolePrompt } else { ConsolePrompt partial } .console yview -pickplace insert } # ::tk::ConsoleHistory -- # This procedure implements command line history for the # console. In general is evals the history command in the # main interpreter to obtain the history. The variable # ::tk::HistNum is used to store the current location in the history. # # Arguments: # cmd - Which action to take: prev, next, reset. set ::tk::HistNum 1 proc ::tk::ConsoleHistory {cmd} { variable HistNum switch $cmd { prev { incr HistNum -1 if {$HistNum == 0} { set cmd {history event [expr {[history nextid] -1}]} } else { set cmd "history event $HistNum" } if {[catch {consoleinterp eval $cmd} cmd]} { incr HistNum return } .console delete promptEnd end .console insert promptEnd $cmd {input stdin} } next { incr HistNum if {$HistNum == 0} { set cmd {history event [expr {[history nextid] -1}]} } elseif {$HistNum > 0} { set cmd "" set HistNum 1 } else { set cmd "history event $HistNum" } if {[string compare $cmd ""]} { catch {consoleinterp eval $cmd} cmd } .console delete promptEnd end .console insert promptEnd $cmd {input stdin} } reset { set HistNum 1 } } } # ::tk::ConsolePrompt -- # This procedure draws the prompt. If tcl_prompt1 or tcl_prompt2 # exists in the main interpreter it will be called to generate the # prompt. Otherwise, a hard coded default prompt is printed. # # Arguments: # partial - Flag to specify which prompt to print. proc ::tk::ConsolePrompt {{partial normal}} { set w .console if {[string equal $partial "normal"]} { set temp [$w index "end - 1 char"] $w mark set output end if {[consoleinterp eval "info exists tcl_prompt1"]} { consoleinterp eval "eval \[set tcl_prompt1\]" } else { puts -nonewline [EvalAttached $::tk::console::defaultPrompt] } } else { set temp [$w index output] $w mark set output end if {[consoleinterp eval "info exists tcl_prompt2"]} { consoleinterp eval "eval \[set tcl_prompt2\]" } else { puts -nonewline "> " } } flush stdout $w mark set output $temp ::tk::TextSetCursor $w end $w mark set promptEnd insert $w mark gravity promptEnd left ::tk::console::ConstrainBuffer $w $::tk::console::maxLines $w see end } # ::tk::ConsoleBind -- # This procedure first ensures that the default bindings for the Text # class have been defined. Then certain bindings are overridden for # the class. # # Arguments: # None. proc ::tk::ConsoleBind {w} { bindtags $w [list $w Console PostConsole [winfo toplevel $w] all] ## Get all Text bindings into Console foreach ev [bind Text] { bind Console $ev [bind Text $ev] } ## We really didn't want the newline insertion... bind Console {} ## ...or any Control-v binding (would block <>) bind Console {} # For the moment, transpose isn't enabled until the console # gets and overhaul of how it handles input -- hobbs bind Console {} # Ignore all Alt, Meta, and Control keypresses unless explicitly bound. # Otherwise, if a widget binding for one of these is defined, the bind Console {# nothing } bind Console {# nothing} bind Console {# nothing} foreach {ev key} { <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> } { event add $ev $key bind Console $key {} } bind Console <> { if {[%W compare insert > promptEnd]} {::tk::console::Expand %W} } bind Console <> { if {[%W compare insert > promptEnd]} {::tk::console::Expand %W path} } bind Console <> { if {[%W compare insert > promptEnd]} {::tk::console::Expand %W proc} } bind Console <> { if {[%W compare insert > promptEnd]} {::tk::console::Expand %W var} } bind Console <> { %W mark set insert {end - 1c} tk::ConsoleInsert %W "\n" tk::ConsoleInvoke break } bind Console { if {[string compare {} [%W tag nextrange sel 1.0 end]] \ && [%W compare sel.first >= promptEnd]} { %W delete sel.first sel.last } elseif {[%W compare insert >= promptEnd]} { %W delete insert %W see insert } } bind Console { if {[string compare {} [%W tag nextrange sel 1.0 end]] \ && [%W compare sel.first >= promptEnd]} { %W delete sel.first sel.last } elseif {[%W compare insert != 1.0] && \ [%W compare insert > promptEnd]} { %W delete insert-1c %W see insert } } bind Console [bind Console ] bind Console { if {[%W compare insert < promptEnd]} { tk::TextSetCursor %W {insert linestart} } else { tk::TextSetCursor %W promptEnd } } bind Console [bind Console ] bind Console { tk::TextSetCursor %W {insert lineend} } bind Console [bind Console ] bind Console { if {[%W compare insert < promptEnd]} break %W delete insert } bind Console <> { if {[%W compare insert < promptEnd]} break if {[%W compare insert == {insert lineend}]} { %W delete insert } else { %W delete insert {insert lineend} } } bind Console <> { ## Clear console display %W delete 1.0 "promptEnd linestart" } bind Console <> { ## Clear command line (Unix shell staple) %W delete promptEnd end } bind Console { if {[%W compare insert >= promptEnd]} { %W delete insert {insert wordend} } } bind Console { if {[%W compare {insert -1c wordstart} >= promptEnd]} { %W delete {insert -1c wordstart} insert } } bind Console { if {[%W compare insert >= promptEnd]} { %W delete insert {insert wordend} } } bind Console { if {[%W compare {insert -1c wordstart} >= promptEnd]} { %W delete {insert -1c wordstart} insert } } bind Console { if {[%W compare insert >= promptEnd]} { %W delete insert {insert wordend} } } bind Console <> { tk::ConsoleHistory prev } bind Console <> { tk::ConsoleHistory next } bind Console { catch {tk::ConsoleInsert %W [::tk::GetSelection %W PRIMARY]} } bind Console { tk::ConsoleInsert %W %A } bind Console { eval destroy [winfo child .] if {[string equal $tcl_platform(platform) "macintosh"]} { if {[catch {source [file join $tk_library console.tcl]}]} {source -rsrc console} } else { source [file join $tk_library console.tcl] } } if {[string equal $::tcl_platform(platform) "macintosh"] || [string equal [tk windowingsystem] "aqua"]} { bind Console { exit } } bind Console <> { # Same as the copy event if {![catch {set data [%W get sel.first sel.last]}]} { clipboard clear -displayof %W clipboard append -displayof %W $data } } bind Console <> { if {![catch {set data [%W get sel.first sel.last]}]} { clipboard clear -displayof %W clipboard append -displayof %W $data } } bind Console <> { catch { set clip [::tk::GetSelection %W CLIPBOARD] set list [split $clip \n\r] tk::ConsoleInsert %W [lindex $list 0] foreach x [lrange $list 1 end] { %W mark set insert {end - 1c} tk::ConsoleInsert %W "\n" tk::ConsoleInvoke tk::ConsoleInsert %W $x } } } ## ## Bindings for doing special things based on certain keys ## bind PostConsole { if {[string compare \\ [%W get insert-2c]]} { ::tk::console::MatchPair %W \( \) promptEnd } } bind PostConsole { if {[string compare \\ [%W get insert-2c]]} { ::tk::console::MatchPair %W \[ \] promptEnd } } bind PostConsole { if {[string compare \\ [%W get insert-2c]]} { ::tk::console::MatchPair %W \{ \} promptEnd } } bind PostConsole { if {[string compare \\ [%W get insert-2c]]} { ::tk::console::MatchQuote %W promptEnd } } bind PostConsole { if {"%A" != ""} { ::tk::console::TagProc %W } break } } # ::tk::ConsoleInsert -- # Insert a string into a text at the point of the insertion cursor. # If there is a selection in the text, and it covers the point of the # insertion cursor, then delete the selection before inserting. Insertion # is restricted to the prompt area. # # Arguments: # w - The text window in which to insert the string # s - The string to insert (usually just a single character) proc ::tk::ConsoleInsert {w s} { if {[string equal $s ""]} { return } catch { if {[$w compare sel.first <= insert] && [$w compare sel.last >= insert]} { $w tag remove sel sel.first promptEnd $w delete sel.first sel.last } } if {[$w compare insert < promptEnd]} { $w mark set insert end } $w insert insert $s {input stdin} $w see insert } # ::tk::ConsoleOutput -- # # This routine is called directly by ConsolePutsCmd to cause a string # to be displayed in the console. # # Arguments: # dest - The output tag to be used: either "stderr" or "stdout". # string - The string to be displayed. proc ::tk::ConsoleOutput {dest string} { set w .console $w insert output $string $dest ::tk::console::ConstrainBuffer $w $::tk::console::maxLines $w see insert } # ::tk::ConsoleExit -- # # This routine is called by ConsoleEventProc when the main window of # the application is destroyed. Don't call exit - that probably already # happened. Just delete our window. # # Arguments: # None. proc ::tk::ConsoleExit {} { destroy . } # ::tk::ConsoleAbout -- # # This routine displays an About box to show Tcl/Tk version info. # # Arguments: # None. proc ::tk::ConsoleAbout {} { tk_messageBox -type ok -message "[mc {Tcl for Windows}] Tcl $::tcl_patchLevel Tk $::tk_patchLevel" } # ::tk::console::TagProc -- # # Tags a procedure in the console if it's recognized # This procedure is not perfect. However, making it perfect wastes # too much CPU time... # # Arguments: # w - console text widget proc ::tk::console::TagProc w { if {!$::tk::console::magicKeys} { return } set exp "\[^\\\\\]\[\[ \t\n\r\;{}\"\$\]" set i [$w search -backwards -regexp $exp insert-1c promptEnd-1c] if {$i == ""} {set i promptEnd} else {append i +2c} regsub -all "\[\[\\\\\\?\\*\]" [$w get $i "insert-1c wordend"] {\\\0} c if {[llength [EvalAttached [list info commands $c]]]} { $w tag add proc $i "insert-1c wordend" } else { $w tag remove proc $i "insert-1c wordend" } if {[llength [EvalAttached [list info vars $c]]]} { $w tag add var $i "insert-1c wordend" } else { $w tag remove var $i "insert-1c wordend" } } # ::tk::console::MatchPair -- # # Blinks a matching pair of characters # c2 is assumed to be at the text index 'insert'. # This proc is really loopy and took me an hour to figure out given # all possible combinations with escaping except for escaped \'s. # It doesn't take into account possible commenting... Oh well. If # anyone has something better, I'd like to see/use it. This is really # only efficient for small contexts. # # Arguments: # w - console text widget # c1 - first char of pair # c2 - second char of pair # # Calls: ::tk::console::Blink proc ::tk::console::MatchPair {w c1 c2 {lim 1.0}} { if {!$::tk::console::magicKeys} { return } if {[string compare {} [set ix [$w search -back $c1 insert $lim]]]} { while { [string match {\\} [$w get $ix-1c]] && [string compare {} [set ix [$w search -back $c1 $ix-1c $lim]]] } {} set i1 insert-1c while {[string compare {} $ix]} { set i0 $ix set j 0 while {[string compare {} [set i0 [$w search $c2 $i0 $i1]]]} { append i0 +1c if {[string match {\\} [$w get $i0-2c]]} continue incr j } if {!$j} break set i1 $ix while {$j && [string compare {} \ [set ix [$w search -back $c1 $ix $lim]]]} { if {[string match {\\} [$w get $ix-1c]]} continue incr j -1 } } if {[string match {} $ix]} { set ix [$w index $lim] } } else { set ix [$w index $lim] } if {$::tk::console::blinkRange} { Blink $w $ix [$w index insert] } else { Blink $w $ix $ix+1c [$w index insert-1c] [$w index insert] } } # ::tk::console::MatchQuote -- # # Blinks between matching quotes. # Blinks just the quote if it's unmatched, otherwise blinks quoted string # The quote to match is assumed to be at the text index 'insert'. # # Arguments: # w - console text widget # # Calls: ::tk::console::Blink proc ::tk::console::MatchQuote {w {lim 1.0}} { if {!$::tk::console::magicKeys} { return } set i insert-1c set j 0 while {[string compare [set i [$w search -back \" $i $lim]] {}]} { if {[string match {\\} [$w get $i-1c]]} continue if {!$j} {set i0 $i} incr j } if {$j&1} { if {$::tk::console::blinkRange} { Blink $w $i0 [$w index insert] } else { Blink $w $i0 $i0+1c [$w index insert-1c] [$w index insert] } } else { Blink $w [$w index insert-1c] [$w index insert] } } # ::tk::console::Blink -- # # Blinks between n index pairs for a specified duration. # # Arguments: # w - console text widget # i1 - start index to blink region # i2 - end index of blink region # dur - duration in usecs to blink for # # Outputs: # blinks selected characters in $w proc ::tk::console::Blink {w args} { eval [list $w tag add blink] $args after $::tk::console::blinkTime [list $w] tag remove blink $args } # ::tk::console::ConstrainBuffer -- # # This limits the amount of data in the text widget # Called by Prompt and ConsoleOutput # # Arguments: # w - console text widget # size - # of lines to constrain to # # Outputs: # may delete data in console widget proc ::tk::console::ConstrainBuffer {w size} { if {[$w index end] > $size} { $w delete 1.0 [expr {int([$w index end])-$size}].0 } } # ::tk::console::Expand -- # # Arguments: # ARGS: w - text widget in which to expand str # type - type of expansion (path / proc / variable) # # Calls: ::tk::console::Expand(Pathname|Procname|Variable) # # Outputs: The string to match is expanded to the longest possible match. # If ::tk::console::showMatches is non-zero and the longest match # equaled the string to expand, then all possible matches are # output to stdout. Triggers bell if no matches are found. # # Returns: number of matches found proc ::tk::console::Expand {w {type ""}} { set exp "\[^\\\\\]\[\[ \t\n\r\\\{\"\\\\\$\]" set tmp [$w search -backwards -regexp $exp insert-1c promptEnd-1c] if {$tmp == ""} {set tmp promptEnd} else {append tmp +2c} if {[$w compare $tmp >= insert]} { return } set str [$w get $tmp insert] switch -glob $type { path* { set res [ExpandPathname $str] } proc* { set res [ExpandProcname $str] } var* { set res [ExpandVariable $str] } default { set res {} foreach t {Pathname Procname Variable} { if {![catch {Expand$t $str} res] && ($res != "")} { break } } } } set len [llength $res] if {$len} { set repl [lindex $res 0] $w delete $tmp insert $w insert $tmp $repl {input stdin} if {($len > 1) && $::tk::console::showMatches \ && [string equal $repl $str]} { puts stdout [lsort [lreplace $res 0 0]] } } else { bell } return [incr len -1] } # ::tk::console::ExpandPathname -- # # Expand a file pathname based on $str # This is based on UNIX file name conventions # # Arguments: # str - partial file pathname to expand # # Calls: ::tk::console::ExpandBestMatch # # Returns: list containing longest unique match followed by all the # possible further matches proc ::tk::console::ExpandPathname str { set pwd [EvalAttached pwd] if {[catch {EvalAttached [list cd [file dirname $str]]} err]} { return -code error $err } set dir [file tail $str] ## Check to see if it was known to be a directory and keep the trailing ## slash if so (file tail cuts it off) if {[string match */ $str]} { append dir / } if {[catch {lsort [EvalAttached [list glob $dir*]]} m]} { set match {} } else { if {[llength $m] > 1} { global tcl_platform if {[string match windows $tcl_platform(platform)]} { ## Windows is screwy because it's case insensitive set tmp [ExpandBestMatch [string tolower $m] \ [string tolower $dir]] ## Don't change case if we haven't changed the word if {[string length $dir]==[string length $tmp]} { set tmp $dir } } else { set tmp [ExpandBestMatch $m $dir] } if {[string match ?*/* $str]} { set tmp [file dirname $str]/$tmp } elseif {[string match /* $str]} { set tmp /$tmp } regsub -all { } $tmp {\\ } tmp set match [linsert $m 0 $tmp] } else { ## This may look goofy, but it handles spaces in path names eval append match $m if {[file isdir $match]} {append match /} if {[string match ?*/* $str]} { set match [file dirname $str]/$match } elseif {[string match /* $str]} { set match /$match } regsub -all { } $match {\\ } match ## Why is this one needed and the ones below aren't!! set match [list $match] } } EvalAttached [list cd $pwd] return $match } # ::tk::console::ExpandProcname -- # # Expand a tcl proc name based on $str # # Arguments: # str - partial proc name to expand # # Calls: ::tk::console::ExpandBestMatch # # Returns: list containing longest unique match followed by all the # possible further matches proc ::tk::console::ExpandProcname str { set match [EvalAttached [list info commands $str*]] if {[llength $match] == 0} { set ns [EvalAttached \ "namespace children \[namespace current\] [list $str*]"] if {[llength $ns]==1} { set match [EvalAttached [list info commands ${ns}::*]] } else { set match $ns } } if {[llength $match] > 1} { regsub -all { } [ExpandBestMatch $match $str] {\\ } str set match [linsert $match 0 $str] } else { regsub -all { } $match {\\ } match } return $match } # ::tk::console::ExpandVariable -- # # Expand a tcl variable name based on $str # # Arguments: # str - partial tcl var name to expand # # Calls: ::tk::console::ExpandBestMatch # # Returns: list containing longest unique match followed by all the # possible further matches proc ::tk::console::ExpandVariable str { if {[regexp {([^\(]*)\((.*)} $str junk ary str]} { ## Looks like they're trying to expand an array. set match [EvalAttached [list array names $ary $str*]] if {[llength $match] > 1} { set vars $ary\([ExpandBestMatch $match $str] foreach var $match {lappend vars $ary\($var\)} return $vars } elseif {[llength $match] == 1} { set match $ary\($match\) } ## Space transformation avoided for array names. } else { set match [EvalAttached [list info vars $str*]] if {[llength $match] > 1} { regsub -all { } [ExpandBestMatch $match $str] {\\ } str set match [linsert $match 0 $str] } else { regsub -all { } $match {\\ } match } } return $match } # ::tk::console::ExpandBestMatch -- # # Finds the best unique match in a list of names. # The extra $e in this argument allows us to limit the innermost loop a little # further. This improves speed as $l becomes large or $e becomes long. # # Arguments: # l - list to find best unique match in # e - currently best known unique match # # Returns: longest unique match in the list proc ::tk::console::ExpandBestMatch {l {e {}}} { set ec [lindex $l 0] if {[llength $l]>1} { set e [string length $e]; incr e -1 set ei [string length $ec]; incr ei -1 foreach l $l { while {$ei>=$e && [string first $ec $l]} { set ec [string range $ec 0 [incr ei -1]] } } } return $ec } # now initialize the console ::tk::ConsoleInit Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/dialog.tcl0100644000000000001200000001525310153074437030054 0ustar rootadmin# dialog.tcl -- # # This file defines the procedure tk_dialog, which creates a dialog # box containing a bitmap, a message, and one or more buttons. # # RCS: @(#) $Id: dialog.tcl,v 1.14.2.1 2003/10/22 15:22:07 dkf Exp $ # # Copyright (c) 1992-1993 The Regents of the University of California. # Copyright (c) 1994-1997 Sun Microsystems, Inc. # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # # # ::tk_dialog: # # This procedure displays a dialog box, waits for a button in the dialog # to be invoked, then returns the index of the selected button. If the # dialog somehow gets destroyed, -1 is returned. # # Arguments: # w - Window to use for dialog top-level. # title - Title to display in dialog's decorative frame. # text - Message to display in dialog. # bitmap - Bitmap to display in dialog (empty string means none). # default - Index of button that is to display the default ring # (-1 means none). # args - One or more strings to display in buttons across the # bottom of the dialog box. proc ::tk_dialog {w title text bitmap default args} { global tcl_platform variable ::tk::Priv # Check that $default was properly given if {[string is int $default]} { if {$default >= [llength $args]} { return -code error "default button index greater than number of\ buttons specified for tk_dialog" } } elseif {[string equal {} $default]} { set default -1 } else { set default [lsearch -exact $args $default] } # 1. Create the top-level window and divide it into top # and bottom parts. catch {destroy $w} toplevel $w -class Dialog wm title $w $title wm iconname $w Dialog wm protocol $w WM_DELETE_WINDOW { } # 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 [winfo parent $w]]] } { wm transient $w [winfo toplevel [winfo parent $w]] } if {[string equal $tcl_platform(platform) "macintosh"] || [string equal [tk windowingsystem] "aqua"]} { ::tk::unsupported::MacWindowStyle style $w dBoxProc } frame $w.bot frame $w.top if {[string equal [tk windowingsystem] "x11"]} { $w.bot configure -relief raised -bd 1 $w.top configure -relief raised -bd 1 } pack $w.bot -side bottom -fill both pack $w.top -side top -fill both -expand 1 # 2. Fill the top part with bitmap and message (use the option # database for -wraplength and -font so that they can be # overridden by the caller). option add *Dialog.msg.wrapLength 3i widgetDefault if {[string equal $tcl_platform(platform) "macintosh"] || [string equal [tk windowingsystem] "aqua"]} { option add *Dialog.msg.font system widgetDefault } else { option add *Dialog.msg.font {Times 12} widgetDefault } label $w.msg -justify left -text $text pack $w.msg -in $w.top -side right -expand 1 -fill both -padx 3m -pady 3m if {[string compare $bitmap ""]} { if {([string equal $tcl_platform(platform) "macintosh"] || [string equal [tk windowingsystem] "aqua"]) &&\ [string equal $bitmap "error"]} { set bitmap "stop" } label $w.bitmap -bitmap $bitmap pack $w.bitmap -in $w.top -side left -padx 3m -pady 3m } # 3. Create a row of buttons at the bottom of the dialog. set i 0 foreach but $args { button $w.button$i -text $but -command [list set ::tk::Priv(button) $i] if {$i == $default} { $w.button$i configure -default active } else { $w.button$i configure -default normal } grid $w.button$i -in $w.bot -column $i -row 0 -sticky ew \ -padx 10 -pady 4 grid columnconfigure $w.bot $i # We boost the size of some Mac buttons for l&f if {[string equal $tcl_platform(platform) "macintosh"] || [string equal [tk windowingsystem] "aqua"]} { set tmp [string tolower $but] if {[string equal $tmp "ok"] || [string equal $tmp "cancel"]} { grid columnconfigure $w.bot $i -minsize [expr {59 + 20}] } } incr i } # 4. Create a binding for on the dialog if there is a # default button. if {$default >= 0} { bind $w " [list $w.button$default] configure -state active -relief sunken update idletasks after 100 set ::tk::Priv(button) $default " } # 5. Create a binding for the window that sets the # button variable to -1; this is needed in case something happens # that destroys the window, such as its parent window being destroyed. bind $w {set ::tk::Priv(button) -1} # 6. 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 and de-iconify it. wm withdraw $w update idletasks set x [expr {[winfo screenwidth $w]/2 - [winfo reqwidth $w]/2 \ - [winfo vrootx [winfo parent $w]]}] set y [expr {[winfo screenheight $w]/2 - [winfo reqheight $w]/2 \ - [winfo vrooty [winfo parent $w]]}] # Make sure that the window is on the screen and set the maximum # size of the window is the size of the screen. That'll let things # fail fairly gracefully when very large messages are used. [Bug 827535] if {$x < 0} { set x 0 } if {$y < 0} { set y 0 } wm maxsize $w [winfo screenwidth $w] [winfo screenheight $w] wm geom $w +$x+$y wm deiconify $w # 7. Set a grab and claim the focus too. set oldFocus [focus] set oldGrab [grab current $w] if {[string compare $oldGrab ""]} { set grabStatus [grab status $oldGrab] } grab $w if {$default >= 0} { focus $w.button$default } else { focus $w } # 8. 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(button) catch {focus $oldFocus} catch { # It's possible that the window has already been destroyed, # hence this "catch". Delete the Destroy handler so that # Priv(button) doesn't get reset by it. bind $w {} destroy $w } if {[string compare $oldGrab ""]} { if {[string compare $grabStatus "global"]} { grab $oldGrab } else { grab -global $oldGrab } } return $Priv(button) } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/entry.tcl0100644000000000001200000004117310153074437027756 0ustar rootadmin# entry.tcl -- # # This file defines the default bindings for Tk entry widgets and provides # procedures that help in implementing those bindings. # # RCS: @(#) $Id: entry.tcl,v 1.21 2003/01/23 23:30:11 drh Exp $ # # Copyright (c) 1992-1994 The Regents of the University of California. # Copyright (c) 1994-1997 Sun Microsystems, Inc. # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # #------------------------------------------------------------------------- # Elements of tk::Priv that are used in this file: # # afterId - If non-null, it means that auto-scanning is underway # and it gives the "after" id for the next auto-scan # command to be executed. # mouseMoved - Non-zero means the mouse has moved a significant # amount since the button went down (so, for example, # start dragging out a selection). # pressX - X-coordinate at which the mouse button was pressed. # selectMode - The style of selection currently underway: # char, word, or line. # x, y - Last known mouse coordinates for scanning # and auto-scanning. # data - Used for Cut and Copy #------------------------------------------------------------------------- #------------------------------------------------------------------------- # The code below creates the default class bindings for entries. #------------------------------------------------------------------------- bind Entry <> { if {![catch {tk::EntryGetSelection %W} tk::Priv(data)]} { clipboard clear -displayof %W clipboard append -displayof %W $tk::Priv(data) %W delete sel.first sel.last unset tk::Priv(data) } } bind Entry <> { if {![catch {tk::EntryGetSelection %W} tk::Priv(data)]} { clipboard clear -displayof %W clipboard append -displayof %W $tk::Priv(data) unset tk::Priv(data) } } bind Entry <> { global tcl_platform catch { if {[string compare [tk windowingsystem] "x11"]} { catch { %W delete sel.first sel.last } } %W insert insert [::tk::GetSelection %W CLIPBOARD] tk::EntrySeeInsert %W } } bind Entry <> { %W delete sel.first sel.last } bind Entry <> { if {$tk_strictMotif || ![info exists tk::Priv(mouseMoved)] || !$tk::Priv(mouseMoved)} { tk::EntryPaste %W %x } } # Standard Motif bindings: bind Entry <1> { tk::EntryButton1 %W %x %W selection clear } bind Entry { set tk::Priv(x) %x tk::EntryMouseSelect %W %x } bind Entry { set tk::Priv(selectMode) word tk::EntryMouseSelect %W %x catch {%W icursor sel.last} } bind Entry { set tk::Priv(selectMode) line tk::EntryMouseSelect %W %x catch {%W icursor sel.last} } bind Entry { set tk::Priv(selectMode) char %W selection adjust @%x } bind Entry { set tk::Priv(selectMode) word tk::EntryMouseSelect %W %x } bind Entry { set tk::Priv(selectMode) line tk::EntryMouseSelect %W %x } bind Entry { set tk::Priv(x) %x tk::EntryAutoScan %W } bind Entry { tk::CancelRepeat } bind Entry { tk::CancelRepeat } bind Entry { %W icursor @%x } bind Entry { tk::EntrySetCursor %W [expr {[%W index insert] - 1}] } bind Entry { tk::EntrySetCursor %W [expr {[%W index insert] + 1}] } bind Entry { tk::EntryKeySelect %W [expr {[%W index insert] - 1}] tk::EntrySeeInsert %W } bind Entry { tk::EntryKeySelect %W [expr {[%W index insert] + 1}] tk::EntrySeeInsert %W } bind Entry { tk::EntrySetCursor %W [tk::EntryPreviousWord %W insert] } bind Entry { tk::EntrySetCursor %W [tk::EntryNextWord %W insert] } bind Entry { tk::EntryKeySelect %W [tk::EntryPreviousWord %W insert] tk::EntrySeeInsert %W } bind Entry { tk::EntryKeySelect %W [tk::EntryNextWord %W insert] tk::EntrySeeInsert %W } bind Entry { tk::EntrySetCursor %W 0 } bind Entry { tk::EntryKeySelect %W 0 tk::EntrySeeInsert %W } bind Entry { tk::EntrySetCursor %W end } bind Entry { tk::EntryKeySelect %W end tk::EntrySeeInsert %W } bind Entry { if {[%W selection present]} { %W delete sel.first sel.last } else { %W delete insert } } bind Entry { tk::EntryBackspace %W } bind Entry { %W selection from insert } bind Entry { tk::ListboxBeginSelect %W [%W index active] } bind Listbox { tk::ListboxBeginExtend %W [%W index active] } bind Listbox { tk::ListboxBeginExtend %W [%W index active] } bind Listbox { tk::ListboxCancel %W } bind Listbox { tk::ListboxSelectAll %W } bind Listbox { if {[string compare [%W cget -selectmode] "browse"]} { %W selection clear 0 end event generate %W <> } } # Additional Tk bindings that aren't part of the Motif look and feel: bind Listbox <2> { %W scan mark %x %y } bind Listbox { %W scan dragto %x %y } # The MouseWheel will typically only fire on Windows. However, # someone could use the "event generate" command to produce one # on other platforms. if {[string equal [tk windowingsystem] "classic"] || [string equal [tk windowingsystem] "aqua"]} { bind Listbox { %W yview scroll [expr {- (%D)}] units } bind Listbox { %W yview scroll [expr {-10 * (%D)}] units } bind Listbox { %W xview scroll [expr {- (%D)}] units } bind Listbox { %W xview scroll [expr {-10 * (%D)}] units } } else { bind Listbox { %W yview scroll [expr {- (%D / 120) * 4}] units } } if {[string equal "x11" [tk windowingsystem]]} { # Support for mousewheels on Linux/Unix commonly comes through mapping # the wheel to the extended buttons. If you have a mousewheel, find # Linux configuration info at: # http://www.inria.fr/koala/colas/mouse-wheel-scroll/ bind Listbox <4> { if {!$tk_strictMotif} { %W yview scroll -5 units } } bind Listbox <5> { if {!$tk_strictMotif} { %W yview scroll 5 units } } } # ::tk::ListboxBeginSelect -- # # This procedure is typically invoked on button-1 presses. It begins # the process of making a selection in the listbox. Its exact behavior # depends on the selection mode currently in effect for the listbox; # see the Motif documentation for details. # # Arguments: # w - The listbox widget. # el - The element for the selection operation (typically the # one under the pointer). Must be in numerical form. proc ::tk::ListboxBeginSelect {w el} { variable ::tk::Priv if {[string equal [$w cget -selectmode] "multiple"]} { if {[$w selection includes $el]} { $w selection clear $el } else { $w selection set $el } } else { $w selection clear 0 end $w selection set $el $w selection anchor $el set Priv(listboxSelection) {} set Priv(listboxPrev) $el } event generate $w <> } # ::tk::ListboxMotion -- # # This procedure is called to process mouse motion events while # button 1 is down. It may move or extend the selection, depending # on the listbox's selection mode. # # Arguments: # w - The listbox widget. # el - The element under the pointer (must be a number). proc ::tk::ListboxMotion {w el} { variable ::tk::Priv if {$el == $Priv(listboxPrev)} { return } set anchor [$w index anchor] switch [$w cget -selectmode] { browse { $w selection clear 0 end $w selection set $el set Priv(listboxPrev) $el event generate $w <> } extended { set i $Priv(listboxPrev) if {[string equal {} $i]} { set i $el $w selection set $el } if {[$w selection includes anchor]} { $w selection clear $i $el $w selection set anchor $el } else { $w selection clear $i $el $w selection clear anchor $el } if {![info exists Priv(listboxSelection)]} { set Priv(listboxSelection) [$w curselection] } while {($i < $el) && ($i < $anchor)} { if {[lsearch $Priv(listboxSelection) $i] >= 0} { $w selection set $i } incr i } while {($i > $el) && ($i > $anchor)} { if {[lsearch $Priv(listboxSelection) $i] >= 0} { $w selection set $i } incr i -1 } set Priv(listboxPrev) $el event generate $w <> } } } # ::tk::ListboxBeginExtend -- # # This procedure is typically invoked on shift-button-1 presses. It # begins the process of extending a selection in the listbox. Its # exact behavior depends on the selection mode currently in effect # for the listbox; see the Motif documentation for details. # # Arguments: # w - The listbox widget. # el - The element for the selection operation (typically the # one under the pointer). Must be in numerical form. proc ::tk::ListboxBeginExtend {w el} { if {[string equal [$w cget -selectmode] "extended"]} { if {[$w selection includes anchor]} { ListboxMotion $w $el } else { # No selection yet; simulate the begin-select operation. ListboxBeginSelect $w $el } } } # ::tk::ListboxBeginToggle -- # # This procedure is typically invoked on control-button-1 presses. It # begins the process of toggling a selection in the listbox. Its # exact behavior depends on the selection mode currently in effect # for the listbox; see the Motif documentation for details. # # Arguments: # w - The listbox widget. # el - The element for the selection operation (typically the # one under the pointer). Must be in numerical form. proc ::tk::ListboxBeginToggle {w el} { variable ::tk::Priv if {[string equal [$w cget -selectmode] "extended"]} { set Priv(listboxSelection) [$w curselection] set Priv(listboxPrev) $el $w selection anchor $el if {[$w selection includes $el]} { $w selection clear $el } else { $w selection set $el } event generate $w <> } } # ::tk::ListboxAutoScan -- # This procedure is invoked when the mouse leaves an entry window # with button 1 down. It scrolls the window up, down, left, or # right, depending on where the mouse left the window, and reschedules # itself as an "after" command so that the window continues to scroll until # the mouse moves back into the window or the mouse button is released. # # Arguments: # w - The entry window. proc ::tk::ListboxAutoScan {w} { variable ::tk::Priv if {![winfo exists $w]} return set x $Priv(x) set y $Priv(y) if {$y >= [winfo height $w]} { $w yview scroll 1 units } elseif {$y < 0} { $w yview scroll -1 units } elseif {$x >= [winfo width $w]} { $w xview scroll 2 units } elseif {$x < 0} { $w xview scroll -2 units } else { return } ListboxMotion $w [$w index @$x,$y] set Priv(afterId) [after 50 [list tk::ListboxAutoScan $w]] } # ::tk::ListboxUpDown -- # # Moves the location cursor (active element) up or down by one element, # and changes the selection if we're in browse or extended selection # mode. # # Arguments: # w - The listbox widget. # amount - +1 to move down one item, -1 to move back one item. proc ::tk::ListboxUpDown {w amount} { variable ::tk::Priv $w activate [expr {[$w index active] + $amount}] $w see active switch [$w cget -selectmode] { browse { $w selection clear 0 end $w selection set active event generate $w <> } extended { $w selection clear 0 end $w selection set active $w selection anchor active set Priv(listboxPrev) [$w index active] set Priv(listboxSelection) {} event generate $w <> } } } # ::tk::ListboxExtendUpDown -- # # Does nothing unless we're in extended selection mode; in this # case it moves the location cursor (active element) up or down by # one element, and extends the selection to that point. # # Arguments: # w - The listbox widget. # amount - +1 to move down one item, -1 to move back one item. proc ::tk::ListboxExtendUpDown {w amount} { variable ::tk::Priv if {[string compare [$w cget -selectmode] "extended"]} { return } set active [$w index active] if {![info exists Priv(listboxSelection)]} { $w selection set $active set Priv(listboxSelection) [$w curselection] } $w activate [expr {$active + $amount}] $w see active ListboxMotion $w [$w index active] } # ::tk::ListboxDataExtend # # This procedure is called for key-presses such as Shift-KEndData. # If the selection mode isn't multiple or extend then it does nothing. # Otherwise it moves the active element to el and, if we're in # extended mode, extends the selection to that point. # # Arguments: # w - The listbox widget. # el - An integer element number. proc ::tk::ListboxDataExtend {w el} { set mode [$w cget -selectmode] if {[string equal $mode "extended"]} { $w activate $el $w see $el if {[$w selection includes anchor]} { ListboxMotion $w $el } } elseif {[string equal $mode "multiple"]} { $w activate $el $w see $el } } # ::tk::ListboxCancel # # This procedure is invoked to cancel an extended selection in # progress. If there is an extended selection in progress, it # restores all of the items between the active one and the anchor # to their previous selection state. # # Arguments: # w - The listbox widget. proc ::tk::ListboxCancel w { variable ::tk::Priv if {[string compare [$w cget -selectmode] "extended"]} { return } set first [$w index anchor] set last $Priv(listboxPrev) if { [string equal $last ""] } { # Not actually doing any selection right now return } if {$first > $last} { set tmp $first set first $last set last $tmp } $w selection clear $first $last while {$first <= $last} { if {[lsearch $Priv(listboxSelection) $first] >= 0} { $w selection set $first } incr first } event generate $w <> } # ::tk::ListboxSelectAll # # This procedure is invoked to handle the "select all" operation. # For single and browse mode, it just selects the active element. # Otherwise it selects everything in the widget. # # Arguments: # w - The listbox widget. proc ::tk::ListboxSelectAll w { set mode [$w cget -selectmode] if {[string equal $mode "single"] || [string equal $mode "browse"]} { $w selection clear 0 end $w selection set active } else { $w selection set 0 end } event generate $w <> } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/menu.tcl0100644000000000001200000011076410153074437027564 0ustar rootadmin# menu.tcl -- # # This file defines the default bindings for Tk menus and menubuttons. # It also implements keyboard traversal of menus and implements a few # other utility procedures related to menus. # # RCS: @(#) $Id: menu.tcl,v 1.18.2.1 2004/02/04 00:23:04 hobbs Exp $ # # Copyright (c) 1992-1994 The Regents of the University of California. # Copyright (c) 1994-1997 Sun Microsystems, Inc. # Copyright (c) 1998-1999 by Scriptics Corporation. # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # #------------------------------------------------------------------------- # Elements of tk::Priv that are used in this file: # # cursor - Saves the -cursor option for the posted menubutton. # focus - Saves the focus during a menu selection operation. # Focus gets restored here when the menu is unposted. # grabGlobal - Used in conjunction with tk::Priv(oldGrab): if # tk::Priv(oldGrab) is non-empty, then tk::Priv(grabGlobal) # contains either an empty string or "-global" to # indicate whether the old grab was a local one or # a global one. # inMenubutton - The name of the menubutton widget containing # the mouse, or an empty string if the mouse is # not over any menubutton. # menuBar - The name of the menubar that is the root # of the cascade hierarchy which is currently # posted. This is null when there is no menu currently # being pulled down from a menu bar. # oldGrab - Window that had the grab before a menu was posted. # Used to restore the grab state after the menu # is unposted. Empty string means there was no # grab previously set. # popup - If a menu has been popped up via tk_popup, this # gives the name of the menu. Otherwise this # value is empty. # postedMb - Name of the menubutton whose menu is currently # posted, or an empty string if nothing is posted # A grab is set on this widget. # relief - Used to save the original relief of the current # menubutton. # window - When the mouse is over a menu, this holds the # name of the menu; it's cleared when the mouse # leaves the menu. # tearoff - Whether the last menu posted was a tearoff or not. # This is true always for unix, for tearoffs for Mac # and Windows. # activeMenu - This is the last active menu for use # with the <> virtual event. # activeItem - This is the last active menu item for # use with the <> virtual event. #------------------------------------------------------------------------- #------------------------------------------------------------------------- # Overall note: # This file is tricky because there are five different ways that menus # can be used: # # 1. As a pulldown from a menubutton. In this style, the variable # tk::Priv(postedMb) identifies the posted menubutton. # 2. As a torn-off menu copied from some other menu. In this style # tk::Priv(postedMb) is empty, and menu's type is "tearoff". # 3. As an option menu, triggered from an option menubutton. In this # style tk::Priv(postedMb) identifies the posted menubutton. # 4. As a popup menu. In this style tk::Priv(postedMb) is empty and # the top-level menu's type is "normal". # 5. As a pulldown from a menubar. The variable tk::Priv(menubar) has # the owning menubar, and the menu itself is of type "normal". # # The various binding procedures use the state described above to # distinguish the various cases and take different actions in each # case. #------------------------------------------------------------------------- #------------------------------------------------------------------------- # The code below creates the default class bindings for menus # and menubuttons. #------------------------------------------------------------------------- bind Menubutton {} bind Menubutton { tk::MbEnter %W } bind Menubutton { tk::MbLeave %W } bind Menubutton <1> { if {$tk::Priv(inMenubutton) ne ""} { tk::MbPost $tk::Priv(inMenubutton) %X %Y } } bind Menubutton { tk::MbMotion %W up %X %Y } bind Menubutton { tk::MbMotion %W down %X %Y } bind Menubutton { tk::MbButtonUp %W } bind Menubutton { tk::MbPost %W tk::MenuFirstEntry [%W cget -menu] } # Must set focus when mouse enters a menu, in order to allow # mixed-mode processing using both the mouse and the keyboard. # Don't set the focus if the event comes from a grab release, # though: such an event can happen after as part of unposting # a cascaded chain of menus, after the focus has already been # restored to wherever it was before menu selection started. bind Menu {} bind Menu { set tk::Priv(window) %W if {[%W cget -type] eq "tearoff"} { if {"%m" ne "NotifyUngrab"} { if {[tk windowingsystem] eq "x11"} { tk_menuSetFocus %W } } } tk::MenuMotion %W %x %y %s } bind Menu { tk::MenuLeave %W %X %Y %s } bind Menu { tk::MenuMotion %W %x %y %s } bind Menu { tk::MenuButtonDown %W } bind Menu { tk::MenuInvoke %W 1 } bind Menu { tk::MenuInvoke %W 0 } bind Menu { tk::MenuInvoke %W 0 } bind Menu { tk::MenuEscape %W } bind Menu { tk::MenuLeftArrow %W } bind Menu { tk::MenuRightArrow %W } bind Menu { tk::MenuUpArrow %W } bind Menu { tk::MenuDownArrow %W } bind Menu { tk::TraverseWithinMenu %W %A } # The following bindings apply to all windows, and are used to # implement keyboard menu traversal. if {[string equal [tk windowingsystem] "x11"]} { bind all { tk::TraverseToMenu %W %A } bind all { tk::FirstMenu %W } } else { bind Menubutton { tk::TraverseToMenu %W %A } bind Menubutton { tk::FirstMenu %W } } # ::tk::MbEnter -- # This procedure is invoked when the mouse enters a menubutton # widget. It activates the widget unless it is disabled. Note: # this procedure is only invoked when mouse button 1 is *not* down. # The procedure ::tk::MbB1Enter is invoked if the button is down. # # Arguments: # w - The name of the widget. proc ::tk::MbEnter w { variable ::tk::Priv if {[string compare $Priv(inMenubutton) ""]} { MbLeave $Priv(inMenubutton) } set Priv(inMenubutton) $w if {[string compare [$w cget -state] "disabled"]} { $w configure -state active } } # ::tk::MbLeave -- # This procedure is invoked when the mouse leaves a menubutton widget. # It de-activates the widget, if the widget still exists. # # Arguments: # w - The name of the widget. proc ::tk::MbLeave w { variable ::tk::Priv set Priv(inMenubutton) {} if {![winfo exists $w]} { return } if {[string equal [$w cget -state] "active"]} { $w configure -state normal } } # ::tk::MbPost -- # Given a menubutton, this procedure does all the work of posting # its associated menu and unposting any other menu that is currently # posted. # # Arguments: # w - The name of the menubutton widget whose menu # is to be posted. # x, y - Root coordinates of cursor, used for positioning # option menus. If not specified, then the center # of the menubutton is used for an option menu. proc ::tk::MbPost {w {x {}} {y {}}} { global errorInfo variable ::tk::Priv global tcl_platform if {[$w cget -state] eq "disabled" || $w eq $Priv(postedMb)} { return } set menu [$w cget -menu] if {[string equal $menu ""]} { return } set tearoff [expr {[tk windowingsystem] eq "x11" \ || [$menu cget -type] eq "tearoff"}] if {[string first $w $menu] != 0} { error "can't post $menu: it isn't a descendant of $w (this is a new requirement in Tk versions 3.0 and later)" } set cur $Priv(postedMb) if {[string compare $cur ""]} { MenuUnpost {} } set Priv(cursor) [$w cget -cursor] set Priv(relief) [$w cget -relief] $w configure -cursor arrow $w configure -relief raised set Priv(postedMb) $w set Priv(focus) [focus] $menu activate none GenerateMenuSelect $menu # If this looks like an option menubutton then post the menu so # that the current entry is on top of the mouse. Otherwise post # the menu just below the menubutton, as for a pull-down. update idletasks if {[catch { switch [$w cget -direction] { above { set x [winfo rootx $w] set y [expr {[winfo rooty $w] - [winfo reqheight $menu]}] # if we go offscreen to the top, show as 'below' if {$y < 0} { set y [expr {[winfo rooty $w] + [winfo height $w]}] } PostOverPoint $menu $x $y } below { set x [winfo rootx $w] set y [expr {[winfo rooty $w] + [winfo height $w]}] # if we go offscreen to the bottom, show as 'above' set mh [winfo reqheight $menu] if {($y + $mh) > [winfo screenheight $w]} { set y [expr {[winfo rooty $w] - $mh}] } PostOverPoint $menu $x $y } left { set x [expr {[winfo rootx $w] - [winfo reqwidth $menu]}] set y [expr {(2 * [winfo rooty $w] + [winfo height $w]) / 2}] set entry [MenuFindName $menu [$w cget -text]] if {[$w cget -indicatoron]} { if {$entry == [$menu index last]} { incr y [expr {-([$menu yposition $entry] \ + [winfo reqheight $menu])/2}] } else { incr y [expr {-([$menu yposition $entry] \ + [$menu yposition [expr {$entry+1}]])/2}] } } PostOverPoint $menu $x $y if {$entry ne "" \ && [$menu entrycget $entry -state] ne "disabled"} { $menu activate $entry GenerateMenuSelect $menu } } right { set x [expr {[winfo rootx $w] + [winfo width $w]}] set y [expr {(2 * [winfo rooty $w] + [winfo height $w]) / 2}] set entry [MenuFindName $menu [$w cget -text]] if {[$w cget -indicatoron]} { if {$entry == [$menu index last]} { incr y [expr {-([$menu yposition $entry] \ + [winfo reqheight $menu])/2}] } else { incr y [expr {-([$menu yposition $entry] \ + [$menu yposition [expr {$entry+1}]])/2}] } } PostOverPoint $menu $x $y if {$entry ne "" \ && [$menu entrycget $entry -state] ne "disabled"} { $menu activate $entry GenerateMenuSelect $menu } } default { if {[$w cget -indicatoron]} { if {[string equal $y {}]} { set x [expr {[winfo rootx $w] + [winfo width $w]/2}] set y [expr {[winfo rooty $w] + [winfo height $w]/2}] } PostOverPoint $menu $x $y [MenuFindName $menu [$w cget -text]] } else { PostOverPoint $menu [winfo rootx $w] [expr {[winfo rooty $w]+[winfo height $w]}] } } } } msg]} { # Error posting menu (e.g. bogus -postcommand). Unpost it and # reflect the error. set savedInfo $errorInfo MenuUnpost {} error $msg $savedInfo } set Priv(tearoff) $tearoff if {$tearoff != 0} { focus $menu if {[winfo viewable $w]} { SaveGrabInfo $w grab -global $w } } } # ::tk::MenuUnpost -- # This procedure unposts a given menu, plus all of its ancestors up # to (and including) a menubutton, if any. It also restores various # values to what they were before the menu was posted, and releases # a grab if there's a menubutton involved. Special notes: # 1. It's important to unpost all menus before releasing the grab, so # that any Enter-Leave events (e.g. from menu back to main # application) have mode NotifyGrab. # 2. Be sure to enclose various groups of commands in "catch" so that # the procedure will complete even if the menubutton or the menu # or the grab window has been deleted. # # Arguments: # menu - Name of a menu to unpost. Ignored if there # is a posted menubutton. proc ::tk::MenuUnpost menu { global tcl_platform variable ::tk::Priv set mb $Priv(postedMb) # Restore focus right away (otherwise X will take focus away when # the menu is unmapped and under some window managers (e.g. olvwm) # we'll lose the focus completely). catch {focus $Priv(focus)} set Priv(focus) "" # Unpost menu(s) and restore some stuff that's dependent on # what was posted. catch { if {[string compare $mb ""]} { set menu [$mb cget -menu] $menu unpost set Priv(postedMb) {} $mb configure -cursor $Priv(cursor) $mb configure -relief $Priv(relief) } elseif {[string compare $Priv(popup) ""]} { $Priv(popup) unpost set Priv(popup) {} } elseif {[string compare [$menu cget -type] "menubar"] \ && [string compare [$menu cget -type] "tearoff"]} { # We're in a cascaded sub-menu from a torn-off menu or popup. # Unpost all the menus up to the toplevel one (but not # including the top-level torn-off one) and deactivate the # top-level torn off menu if there is one. while {1} { set parent [winfo parent $menu] if {[string compare [winfo class $parent] "Menu"] \ || ![winfo ismapped $parent]} { break } $parent activate none $parent postcascade none GenerateMenuSelect $parent set type [$parent cget -type] if {[string equal $type "menubar"] || \ [string equal $type "tearoff"]} { break } set menu $parent } if {[string compare [$menu cget -type] "menubar"]} { $menu unpost } } } if {($Priv(tearoff) != 0) || $Priv(menuBar) ne ""} { # Release grab, if any, and restore the previous grab, if there # was one. if {[string compare $menu ""]} { set grab [grab current $menu] if {[string compare $grab ""]} { grab release $grab } } RestoreOldGrab if {$Priv(menuBar) ne ""} { $Priv(menuBar) configure -cursor $Priv(cursor) set Priv(menuBar) {} } if {[tk windowingsystem] ne "x11"} { set Priv(tearoff) 0 } } } # ::tk::MbMotion -- # This procedure handles mouse motion events inside menubuttons, and # also outside menubuttons when a menubutton has a grab (e.g. when a # menu selection operation is in progress). # # Arguments: # w - The name of the menubutton widget. # upDown - "down" means button 1 is pressed, "up" means # it isn't. # rootx, rooty - Coordinates of mouse, in (virtual?) root window. proc ::tk::MbMotion {w upDown rootx rooty} { variable ::tk::Priv if {[string equal $Priv(inMenubutton) $w]} { return } set new [winfo containing $rootx $rooty] if {[string compare $new $Priv(inMenubutton)] \ && ([string equal $new ""] \ || [string equal [winfo toplevel $new] [winfo toplevel $w]])} { if {[string compare $Priv(inMenubutton) ""]} { MbLeave $Priv(inMenubutton) } if {[string compare $new ""] \ && [string equal [winfo class $new] "Menubutton"] \ && ([$new cget -indicatoron] == 0) \ && ([$w cget -indicatoron] == 0)} { if {[string equal $upDown "down"]} { MbPost $new $rootx $rooty } else { MbEnter $new } } } } # ::tk::MbButtonUp -- # This procedure is invoked to handle button 1 releases for menubuttons. # If the release happens inside the menubutton then leave its menu # posted with element 0 activated. Otherwise, unpost the menu. # # Arguments: # w - The name of the menubutton widget. proc ::tk::MbButtonUp w { variable ::tk::Priv global tcl_platform set menu [$w cget -menu] set tearoff [expr {[tk windowingsystem] eq "x11" || \ ($menu ne "" && [$menu cget -type] eq "tearoff")}] if {($tearoff != 0) && $Priv(postedMb) eq $w \ && $Priv(inMenubutton) eq $w} { MenuFirstEntry [$Priv(postedMb) cget -menu] } else { MenuUnpost {} } } # ::tk::MenuMotion -- # This procedure is called to handle mouse motion events for menus. # It does two things. First, it resets the active element in the # menu, if the mouse is over the menu. Second, if a mouse button # is down, it posts and unposts cascade entries to match the mouse # position. # # Arguments: # menu - The menu window. # x - The x position of the mouse. # y - The y position of the mouse. # state - Modifier state (tells whether buttons are down). proc ::tk::MenuMotion {menu x y state} { variable ::tk::Priv if {[string equal $menu $Priv(window)]} { if {[string equal [$menu cget -type] "menubar"]} { if {[info exists Priv(focus)] && \ [string compare $menu $Priv(focus)]} { $menu activate @$x,$y GenerateMenuSelect $menu } } else { $menu activate @$x,$y GenerateMenuSelect $menu } } if {($state & 0x1f00) != 0} { $menu postcascade active } } # ::tk::MenuButtonDown -- # Handles button presses in menus. There are a couple of tricky things # here: # 1. Change the posted cascade entry (if any) to match the mouse position. # 2. If there is a posted menubutton, must grab to the menubutton; this # overrrides the implicit grab on button press, so that the menu # button can track mouse motions over other menubuttons and change # the posted menu. # 3. If there's no posted menubutton (e.g. because we're a torn-off menu # or one of its descendants) must grab to the top-level menu so that # we can track mouse motions across the entire menu hierarchy. # # Arguments: # menu - The menu window. proc ::tk::MenuButtonDown menu { variable ::tk::Priv global tcl_platform if {![winfo viewable $menu]} { return } $menu postcascade active if {[string compare $Priv(postedMb) ""] && \ [winfo viewable $Priv(postedMb)]} { grab -global $Priv(postedMb) } else { while {[string equal [$menu cget -type] "normal"] \ && [string equal [winfo class [winfo parent $menu]] "Menu"] \ && [winfo ismapped [winfo parent $menu]]} { set menu [winfo parent $menu] } if {[string equal $Priv(menuBar) {}]} { set Priv(menuBar) $menu set Priv(cursor) [$menu cget -cursor] $menu configure -cursor arrow } # Don't update grab information if the grab window isn't changing. # Otherwise, we'll get an error when we unpost the menus and # restore the grab, since the old grab window will not be viewable # anymore. if {[string compare $menu [grab current $menu]]} { SaveGrabInfo $menu } # Must re-grab even if the grab window hasn't changed, in order # to release the implicit grab from the button press. if {[string equal [tk windowingsystem] "x11"]} { grab -global $menu } } } # ::tk::MenuLeave -- # This procedure is invoked to handle Leave events for a menu. It # deactivates everything unless the active element is a cascade element # and the mouse is now over the submenu. # # Arguments: # menu - The menu window. # rootx, rooty - Root coordinates of mouse. # state - Modifier state. proc ::tk::MenuLeave {menu rootx rooty state} { variable ::tk::Priv set Priv(window) {} if {[string equal [$menu index active] "none"]} { return } if {[string equal [$menu type active] "cascade"] && [string equal [winfo containing $rootx $rooty] \ [$menu entrycget active -menu]]} { return } $menu activate none GenerateMenuSelect $menu } # ::tk::MenuInvoke -- # This procedure is invoked when button 1 is released over a menu. # It invokes the appropriate menu action and unposts the menu if # it came from a menubutton. # # Arguments: # w - Name of the menu widget. # buttonRelease - 1 means this procedure is called because of # a button release; 0 means because of keystroke. proc ::tk::MenuInvoke {w buttonRelease} { variable ::tk::Priv if {$buttonRelease && [string equal $Priv(window) {}]} { # Mouse was pressed over a menu without a menu button, then # dragged off the menu (possibly with a cascade posted) and # released. Unpost everything and quit. $w postcascade none $w activate none event generate $w <> MenuUnpost $w return } if {[string equal [$w type active] "cascade"]} { $w postcascade active set menu [$w entrycget active -menu] MenuFirstEntry $menu } elseif {[string equal [$w type active] "tearoff"]} { ::tk::TearOffMenu $w MenuUnpost $w } elseif {[string equal [$w cget -type] "menubar"]} { $w postcascade none set active [$w index active] set isCascade [string equal [$w type $active] "cascade"] # Only de-activate the active item if it's a cascade; this prevents # the annoying "activation flicker" you otherwise get with # checkbuttons/commands/etc. on menubars if { $isCascade } { $w activate none event generate $w <> } MenuUnpost $w # If the active item is not a cascade, invoke it. This enables # the use of checkbuttons/commands/etc. on menubars (which is legal, # but not recommended) if { !$isCascade } { uplevel #0 [list $w invoke $active] } } else { MenuUnpost $w uplevel #0 [list $w invoke active] } } # ::tk::MenuEscape -- # This procedure is invoked for the Cancel (or Escape) key. It unposts # the given menu and, if it is the top-level menu for a menu button, # unposts the menu button as well. # # Arguments: # menu - Name of the menu window. proc ::tk::MenuEscape menu { set parent [winfo parent $menu] if {[string compare [winfo class $parent] "Menu"]} { MenuUnpost $menu } elseif {[string equal [$parent cget -type] "menubar"]} { MenuUnpost $menu RestoreOldGrab } else { MenuNextMenu $menu left } } # The following routines handle arrow keys. Arrow keys behave # differently depending on whether the menu is a menu bar or not. proc ::tk::MenuUpArrow {menu} { if {[string equal [$menu cget -type] "menubar"]} { MenuNextMenu $menu left } else { MenuNextEntry $menu -1 } } proc ::tk::MenuDownArrow {menu} { if {[string equal [$menu cget -type] "menubar"]} { MenuNextMenu $menu right } else { MenuNextEntry $menu 1 } } proc ::tk::MenuLeftArrow {menu} { if {[string equal [$menu cget -type] "menubar"]} { MenuNextEntry $menu -1 } else { MenuNextMenu $menu left } } proc ::tk::MenuRightArrow {menu} { if {[string equal [$menu cget -type] "menubar"]} { MenuNextEntry $menu 1 } else { MenuNextMenu $menu right } } # ::tk::MenuNextMenu -- # This procedure is invoked to handle "left" and "right" traversal # motions in menus. It traverses to the next menu in a menu bar, # or into or out of a cascaded menu. # # Arguments: # menu - The menu that received the keyboard # event. # direction - Direction in which to move: "left" or "right" proc ::tk::MenuNextMenu {menu direction} { variable ::tk::Priv # First handle traversals into and out of cascaded menus. if {[string equal $direction "right"]} { set count 1 set parent [winfo parent $menu] set class [winfo class $parent] if {[string equal [$menu type active] "cascade"]} { $menu postcascade active set m2 [$menu entrycget active -menu] if {[string compare $m2 ""]} { MenuFirstEntry $m2 } return } else { set parent [winfo parent $menu] while {[string compare $parent "."]} { if {[string equal [winfo class $parent] "Menu"] \ && [string equal [$parent cget -type] "menubar"]} { tk_menuSetFocus $parent MenuNextEntry $parent 1 return } set parent [winfo parent $parent] } } } else { set count -1 set m2 [winfo parent $menu] if {[string equal [winfo class $m2] "Menu"]} { $menu activate none GenerateMenuSelect $menu tk_menuSetFocus $m2 $m2 postcascade none if {[string compare [$m2 cget -type] "menubar"]} { return } } } # Can't traverse into or out of a cascaded menu. Go to the next # or previous menubutton, if that makes sense. set m2 [winfo parent $menu] if {[string equal [winfo class $m2] "Menu"]} { if {[string equal [$m2 cget -type] "menubar"]} { tk_menuSetFocus $m2 MenuNextEntry $m2 -1 return } } set w $Priv(postedMb) if {[string equal $w ""]} { return } set buttons [winfo children [winfo parent $w]] set length [llength $buttons] set i [expr {[lsearch -exact $buttons $w] + $count}] while {1} { while {$i < 0} { incr i $length } while {$i >= $length} { incr i -$length } set mb [lindex $buttons $i] if {[string equal [winfo class $mb] "Menubutton"] \ && [string compare [$mb cget -state] "disabled"] \ && [string compare [$mb cget -menu] ""] \ && [string compare [[$mb cget -menu] index last] "none"]} { break } if {[string equal $mb $w]} { return } incr i $count } MbPost $mb MenuFirstEntry [$mb cget -menu] } # ::tk::MenuNextEntry -- # Activate the next higher or lower entry in the posted menu, # wrapping around at the ends. Disabled entries are skipped. # # Arguments: # menu - Menu window that received the keystroke. # count - 1 means go to the next lower entry, # -1 means go to the next higher entry. proc ::tk::MenuNextEntry {menu count} { if {[string equal [$menu index last] "none"]} { return } set length [expr {[$menu index last]+1}] set quitAfter $length set active [$menu index active] if {[string equal $active "none"]} { set i 0 } else { set i [expr {$active + $count}] } while {1} { if {$quitAfter <= 0} { # We've tried every entry in the menu. Either there are # none, or they're all disabled. Just give up. return } while {$i < 0} { incr i $length } while {$i >= $length} { incr i -$length } if {[catch {$menu entrycget $i -state} state] == 0} { if {$state ne "disabled" && \ ($i!=0 || [$menu cget -type] ne "tearoff" \ || [$menu type 0] ne "tearoff")} { break } } if {$i == $active} { return } incr i $count incr quitAfter -1 } $menu activate $i GenerateMenuSelect $menu if {[string equal [$menu type $i] "cascade"] \ && [string equal [$menu cget -type] "menubar"]} { set cascade [$menu entrycget $i -menu] if {[string compare $cascade ""]} { # Here we auto-post a cascade. This is necessary when # we traverse left/right in the menubar, but undesirable when # we traverse up/down in a menu. $menu postcascade $i MenuFirstEntry $cascade } } } # ::tk::MenuFind -- # This procedure searches the entire window hierarchy under w for # a menubutton that isn't disabled and whose underlined character # is "char" or an entry in a menubar that isn't disabled and whose # underlined character is "char". # It returns the name of that window, if found, or an # empty string if no matching window was found. If "char" is an # empty string then the procedure returns the name of the first # menubutton found that isn't disabled. # # Arguments: # w - Name of window where key was typed. # char - Underlined character to search for; # may be either upper or lower case, and # will match either upper or lower case. proc ::tk::MenuFind {w char} { set char [string tolower $char] set windowlist [winfo child $w] foreach child $windowlist { # Don't descend into other toplevels. if {[string compare [winfo toplevel $w] [winfo toplevel $child]]} { continue } if {[string equal [winfo class $child] "Menu"] && \ [string equal [$child cget -type] "menubar"]} { if {[string equal $char ""]} { return $child } set last [$child index last] for {set i [$child cget -tearoff]} {$i <= $last} {incr i} { if {[string equal [$child type $i] "separator"]} { continue } set char2 [string index [$child entrycget $i -label] \ [$child entrycget $i -underline]] if {[string equal $char [string tolower $char2]] \ || [string equal $char ""]} { if {[string compare [$child entrycget $i -state] "disabled"]} { return $child } } } } } foreach child $windowlist { # Don't descend into other toplevels. if {[string compare [winfo toplevel $w] [winfo toplevel $child]]} { continue } switch [winfo class $child] { Menubutton { set char2 [string index [$child cget -text] \ [$child cget -underline]] if {[string equal $char [string tolower $char2]] \ || [string equal $char ""]} { if {[string compare [$child cget -state] "disabled"]} { return $child } } } default { set match [MenuFind $child $char] if {[string compare $match ""]} { return $match } } } } return {} } # ::tk::TraverseToMenu -- # This procedure implements keyboard traversal of menus. Given an # ASCII character "char", it looks for a menubutton with that character # underlined. If one is found, it posts the menubutton's menu # # Arguments: # w - Window in which the key was typed (selects # a toplevel window). # char - Character that selects a menu. The case # is ignored. If an empty string, nothing # happens. proc ::tk::TraverseToMenu {w char} { variable ::tk::Priv if {[string equal $char ""]} { return } while {[string equal [winfo class $w] "Menu"]} { if {[string compare [$w cget -type] "menubar"] \ && [string equal $Priv(postedMb) ""]} { return } if {[string equal [$w cget -type] "menubar"]} { break } set w [winfo parent $w] } set w [MenuFind [winfo toplevel $w] $char] if {[string compare $w ""]} { if {[string equal [winfo class $w] "Menu"]} { tk_menuSetFocus $w set Priv(window) $w SaveGrabInfo $w grab -global $w TraverseWithinMenu $w $char } else { MbPost $w MenuFirstEntry [$w cget -menu] } } } # ::tk::FirstMenu -- # This procedure traverses to the first menubutton in the toplevel # for a given window, and posts that menubutton's menu. # # Arguments: # w - Name of a window. Selects which toplevel # to search for menubuttons. proc ::tk::FirstMenu w { variable ::tk::Priv set w [MenuFind [winfo toplevel $w] ""] if {[string compare $w ""]} { if {[string equal [winfo class $w] "Menu"]} { tk_menuSetFocus $w set Priv(window) $w SaveGrabInfo $w grab -global $w MenuFirstEntry $w } else { MbPost $w MenuFirstEntry [$w cget -menu] } } } # ::tk::TraverseWithinMenu # This procedure implements keyboard traversal within a menu. It # searches for an entry in the menu that has "char" underlined. If # such an entry is found, it is invoked and the menu is unposted. # # Arguments: # w - The name of the menu widget. # char - The character to look for; case is # ignored. If the string is empty then # nothing happens. proc ::tk::TraverseWithinMenu {w char} { if {[string equal $char ""]} { return } set char [string tolower $char] set last [$w index last] if {[string equal $last "none"]} { return } for {set i 0} {$i <= $last} {incr i} { if {[catch {set char2 [string index \ [$w entrycget $i -label] [$w entrycget $i -underline]]}]} { continue } if {[string equal $char [string tolower $char2]]} { if {[string equal [$w type $i] "cascade"]} { $w activate $i $w postcascade active event generate $w <> set m2 [$w entrycget $i -menu] if {[string compare $m2 ""]} { MenuFirstEntry $m2 } } else { MenuUnpost $w uplevel #0 [list $w invoke $i] } return } } } # ::tk::MenuFirstEntry -- # Given a menu, this procedure finds the first entry that isn't # disabled or a tear-off or separator, and activates that entry. # However, if there is already an active entry in the menu (e.g., # because of a previous call to tk::PostOverPoint) then the active # entry isn't changed. This procedure also sets the input focus # to the menu. # # Arguments: # menu - Name of the menu window (possibly empty). proc ::tk::MenuFirstEntry menu { if {[string equal $menu ""]} { return } tk_menuSetFocus $menu if {[string compare [$menu index active] "none"]} { return } set last [$menu index last] if {[string equal $last "none"]} { return } for {set i 0} {$i <= $last} {incr i} { if {([catch {set state [$menu entrycget $i -state]}] == 0) \ && [string compare $state "disabled"] \ && [string compare [$menu type $i] "tearoff"]} { $menu activate $i GenerateMenuSelect $menu # Only post the cascade if the current menu is a menubar; # otherwise, if the first entry of the cascade is a cascade, # we can get an annoying cascading effect resulting in a bunch of # menus getting posted (bug 676) if {[string equal [$menu type $i] "cascade"] && \ [string equal [$menu cget -type] "menubar"]} { set cascade [$menu entrycget $i -menu] if {[string compare $cascade ""]} { $menu postcascade $i MenuFirstEntry $cascade } } return } } } # ::tk::MenuFindName -- # Given a menu and a text string, return the index of the menu entry # that displays the string as its label. If there is no such entry, # return an empty string. This procedure is tricky because some names # like "active" have a special meaning in menu commands, so we can't # always use the "index" widget command. # # Arguments: # menu - Name of the menu widget. # s - String to look for. proc ::tk::MenuFindName {menu s} { set i "" if {![regexp {^active$|^last$|^none$|^[0-9]|^@} $s]} { catch {set i [$menu index $s]} return $i } set last [$menu index last] if {[string equal $last "none"]} { return } for {set i 0} {$i <= $last} {incr i} { if {![catch {$menu entrycget $i -label} label]} { if {[string equal $label $s]} { return $i } } } return "" } # ::tk::PostOverPoint -- # This procedure posts a given menu such that a given entry in the # menu is centered over a given point in the root window. It also # activates the given entry. # # Arguments: # menu - Menu to post. # x, y - Root coordinates of point. # entry - Index of entry within menu to center over (x,y). # If omitted or specified as {}, then the menu's # upper-left corner goes at (x,y). proc ::tk::PostOverPoint {menu x y {entry {}}} { global tcl_platform if {[string compare $entry {}]} { if {$entry == [$menu index last]} { incr y [expr {-([$menu yposition $entry] \ + [winfo reqheight $menu])/2}] } else { incr y [expr {-([$menu yposition $entry] \ + [$menu yposition [expr {$entry+1}]])/2}] } incr x [expr {-[winfo reqwidth $menu]/2}] } if {$tcl_platform(platform) == "windows"} { # We need to fix some problems with menu posting on Windows. set yoffset [expr {[winfo screenheight $menu] \ - $y - [winfo reqheight $menu]}] if {$yoffset < 0} { # The bottom of the menu is offscreen, so adjust upwards incr y $yoffset if {$y < 0} { set y 0 } } # If we're off the top of the screen (either because we were # originally or because we just adjusted too far upwards), # then make the menu popup on the top edge. if {$y < 0} { set y 0 } } $menu post $x $y if {$entry ne "" && [$menu entrycget $entry -state] ne "disabled"} { $menu activate $entry GenerateMenuSelect $menu } } # ::tk::SaveGrabInfo -- # Sets the variables tk::Priv(oldGrab) and tk::Priv(grabStatus) to record # the state of any existing grab on the w's display. # # Arguments: # w - Name of a window; used to select the display # whose grab information is to be recorded. proc tk::SaveGrabInfo w { variable ::tk::Priv set Priv(oldGrab) [grab current $w] if {$Priv(oldGrab) ne ""} { set Priv(grabStatus) [grab status $Priv(oldGrab)] } } # ::tk::RestoreOldGrab -- # Restores the grab to what it was before TkSaveGrabInfo was called. # proc ::tk::RestoreOldGrab {} { variable ::tk::Priv if {$Priv(oldGrab) ne ""} { # Be careful restoring the old grab, since it's window may not # be visible anymore. catch { if {[string equal $Priv(grabStatus) "global"]} { grab set -global $Priv(oldGrab) } else { grab set $Priv(oldGrab) } } set Priv(oldGrab) "" } } proc ::tk_menuSetFocus {menu} { variable ::tk::Priv if {![info exists Priv(focus)] || [string equal $Priv(focus) {}]} { set Priv(focus) [focus] } focus $menu } proc ::tk::GenerateMenuSelect {menu} { variable ::tk::Priv if {[string equal $Priv(activeMenu) $menu] \ && [string equal $Priv(activeItem) [$menu index active]]} { return } set Priv(activeMenu) $menu set Priv(activeItem) [$menu index active] event generate $menu <> } # ::tk_popup -- # This procedure pops up a menu and sets things up for traversing # the menu and its submenus. # # Arguments: # menu - Name of the menu to be popped up. # x, y - Root coordinates at which to pop up the # menu. # entry - Index of a menu entry to center over (x,y). # If omitted or specified as {}, then menu's # upper-left corner goes at (x,y). proc ::tk_popup {menu x y {entry {}}} { variable ::tk::Priv global tcl_platform if {$Priv(popup) ne "" || $Priv(postedMb) ne ""} { tk::MenuUnpost {} } tk::PostOverPoint $menu $x $y $entry if {[tk windowingsystem] eq "x11" && [winfo viewable $menu]} { tk::SaveGrabInfo $menu grab -global $menu set Priv(popup) $menu tk_menuSetFocus $menu } } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/mkpsenc.tcl0100644000000000001200000006517410153074437030264 0ustar rootadmin# mkpsenc.tcl -- # # Creates Postscript encoding vector for given encoding # proc ::tk::CreatePostscriptEncoding {encoding} { # now check for known. Even if it is known, it can be other # than we need. GhostScript seems to be happy with such approach set result "/CurrentEncoding \[\n" for {set i 0} {$i<256} {incr i 8} { for {set j 0} {$j<8} {incr j} { set enc [encoding convertfrom $encoding [format %c [expr {$i+$j}]]] if {[catch {format %04X [scan $enc %c]} hexcode]} {set hexcode {}} if [info exists ::tk::psglyphs($hexcode)] { append result "/$::tk::psglyphs($hexcode)" } else { append result "/space" } } append result "\n" } append result "\] def\n" return $result } # List of adobe glyph names. Converted from glyphlist.txt, downloaded # from Adobe namespace eval ::tk { array set psglyphs { 0020 space 0021 exclam 0022 quotedbl 0023 numbersign 0024 dollar 0025 percent 0026 ampersand 0027 quotesingle 0028 parenleft 0029 parenright 002A asterisk 002B plus 002C comma 002D hyphen 002E period 002F slash 0030 zero 0031 one 0032 two 0033 three 0034 four 0035 five 0036 six 0037 seven 0038 eight 0039 nine 003A colon 003B semicolon 003C less 003D equal 003E greater 003F question 0040 at 0041 A 0042 B 0043 C 0044 D 0045 E 0046 F 0047 G 0048 H 0049 I 004A J 004B K 004C L 004D M 004E N 004F O 0050 P 0051 Q 0052 R 0053 S 0054 T 0055 U 0056 V 0057 W 0058 X 0059 Y 005A Z 005B bracketleft 005C backslash 005D bracketright 005E asciicircum 005F underscore 0060 grave 0061 a 0062 b 0063 c 0064 d 0065 e 0066 f 0067 g 0068 h 0069 i 006A j 006B k 006C l 006D m 006E n 006F o 0070 p 0071 q 0072 r 0073 s 0074 t 0075 u 0076 v 0077 w 0078 x 0079 y 007A z 007B braceleft 007C bar 007D braceright 007E asciitilde 00A0 space 00A1 exclamdown 00A2 cent 00A3 sterling 00A4 currency 00A5 yen 00A6 brokenbar 00A7 section 00A8 dieresis 00A9 copyright 00AA ordfeminine 00AB guillemotleft 00AC logicalnot 00AD hyphen 00AE registered 00AF macron 00B0 degree 00B1 plusminus 00B2 twosuperior 00B3 threesuperior 00B4 acute 00B5 mu 00B6 paragraph 00B7 periodcentered 00B8 cedilla 00B9 onesuperior 00BA ordmasculine 00BB guillemotright 00BC onequarter 00BD onehalf 00BE threequarters 00BF questiondown 00C0 Agrave 00C1 Aacute 00C2 Acircumflex 00C3 Atilde 00C4 Adieresis 00C5 Aring 00C6 AE 00C7 Ccedilla 00C8 Egrave 00C9 Eacute 00CA Ecircumflex 00CB Edieresis 00CC Igrave 00CD Iacute 00CE Icircumflex 00CF Idieresis 00D0 Eth 00D1 Ntilde 00D2 Ograve 00D3 Oacute 00D4 Ocircumflex 00D5 Otilde 00D6 Odieresis 00D7 multiply 00D8 Oslash 00D9 Ugrave 00DA Uacute 00DB Ucircumflex 00DC Udieresis 00DD Yacute 00DE Thorn 00DF germandbls 00E0 agrave 00E1 aacute 00E2 acircumflex 00E3 atilde 00E4 adieresis 00E5 aring 00E6 ae 00E7 ccedilla 00E8 egrave 00E9 eacute 00EA ecircumflex 00EB edieresis 00EC igrave 00ED iacute 00EE icircumflex 00EF idieresis 00F0 eth 00F1 ntilde 00F2 ograve 00F3 oacute 00F4 ocircumflex 00F5 otilde 00F6 odieresis 00F7 divide 00F8 oslash 00F9 ugrave 00FA uacute 00FB ucircumflex 00FC udieresis 00FD yacute 00FE thorn 00FF ydieresis 0100 Amacron 0101 amacron 0102 Abreve 0103 abreve 0104 Aogonek 0105 aogonek 0106 Cacute 0107 cacute 0108 Ccircumflex 0109 ccircumflex 010A Cdotaccent 010B cdotaccent 010C Ccaron 010D ccaron 010E Dcaron 010F dcaron 0110 Dcroat 0111 dcroat 0112 Emacron 0113 emacron 0114 Ebreve 0115 ebreve 0116 Edotaccent 0117 edotaccent 0118 Eogonek 0119 eogonek 011A Ecaron 011B ecaron 011C Gcircumflex 011D gcircumflex 011E Gbreve 011F gbreve 0120 Gdotaccent 0121 gdotaccent 0122 Gcommaaccent 0123 gcommaaccent 0124 Hcircumflex 0125 hcircumflex 0126 Hbar 0127 hbar 0128 Itilde 0129 itilde 012A Imacron 012B imacron 012C Ibreve 012D ibreve 012E Iogonek 012F iogonek 0130 Idotaccent 0131 dotlessi 0132 IJ 0133 ij 0134 Jcircumflex 0135 jcircumflex 0136 Kcommaaccent 0137 kcommaaccent 0138 kgreenlandic 0139 Lacute 013A lacute 013B Lcommaaccent 013C lcommaaccent 013D Lcaron 013E lcaron 013F Ldot 0140 ldot 0141 Lslash 0142 lslash 0143 Nacute 0144 nacute 0145 Ncommaaccent 0146 ncommaaccent 0147 Ncaron 0148 ncaron 0149 napostrophe 014A Eng 014B eng 014C Omacron 014D omacron 014E Obreve 014F obreve 0150 Ohungarumlaut 0151 ohungarumlaut 0152 OE 0153 oe 0154 Racute 0155 racute 0156 Rcommaaccent 0157 rcommaaccent 0158 Rcaron 0159 rcaron 015A Sacute 015B sacute 015C Scircumflex 015D scircumflex 015E Scedilla 015F scedilla 0160 Scaron 0161 scaron 0162 Tcommaaccent 0163 tcommaaccent 0164 Tcaron 0165 tcaron 0166 Tbar 0167 tbar 0168 Utilde 0169 utilde 016A Umacron 016B umacron 016C Ubreve 016D ubreve 016E Uring 016F uring 0170 Uhungarumlaut 0171 uhungarumlaut 0172 Uogonek 0173 uogonek 0174 Wcircumflex 0175 wcircumflex 0176 Ycircumflex 0177 ycircumflex 0178 Ydieresis 0179 Zacute 017A zacute 017B Zdotaccent 017C zdotaccent 017D Zcaron 017E zcaron 017F longs 0192 florin 01A0 Ohorn 01A1 ohorn 01AF Uhorn 01B0 uhorn 01E6 Gcaron 01E7 gcaron 01FA Aringacute 01FB aringacute 01FC AEacute 01FD aeacute 01FE Oslashacute 01FF oslashacute 0218 Scommaaccent 0219 scommaaccent 021A Tcommaaccent 021B tcommaaccent 02BC afii57929 02BD afii64937 02C6 circumflex 02C7 caron 02C9 macron 02D8 breve 02D9 dotaccent 02DA ring 02DB ogonek 02DC tilde 02DD hungarumlaut 0300 gravecomb 0301 acutecomb 0303 tildecomb 0309 hookabovecomb 0323 dotbelowcomb 0384 tonos 0385 dieresistonos 0386 Alphatonos 0387 anoteleia 0388 Epsilontonos 0389 Etatonos 038A Iotatonos 038C Omicrontonos 038E Upsilontonos 038F Omegatonos 0390 iotadieresistonos 0391 Alpha 0392 Beta 0393 Gamma 0394 Delta 0395 Epsilon 0396 Zeta 0397 Eta 0398 Theta 0399 Iota 039A Kappa 039B Lambda 039C Mu 039D Nu 039E Xi 039F Omicron 03A0 Pi 03A1 Rho 03A3 Sigma 03A4 Tau 03A5 Upsilon 03A6 Phi 03A7 Chi 03A8 Psi 03A9 Omega 03AA Iotadieresis 03AB Upsilondieresis 03AC alphatonos 03AD epsilontonos 03AE etatonos 03AF iotatonos 03B0 upsilondieresistonos 03B1 alpha 03B2 beta 03B3 gamma 03B4 delta 03B5 epsilon 03B6 zeta 03B7 eta 03B8 theta 03B9 iota 03BA kappa 03BB lambda 03BC mu 03BD nu 03BE xi 03BF omicron 03C0 pi 03C1 rho 03C2 sigma1 03C3 sigma 03C4 tau 03C5 upsilon 03C6 phi 03C7 chi 03C8 psi 03C9 omega 03CA iotadieresis 03CB upsilondieresis 03CC omicrontonos 03CD upsilontonos 03CE omegatonos 03D1 theta1 03D2 Upsilon1 03D5 phi1 03D6 omega1 0401 afii10023 0402 afii10051 0403 afii10052 0404 afii10053 0405 afii10054 0406 afii10055 0407 afii10056 0408 afii10057 0409 afii10058 040A afii10059 040B afii10060 040C afii10061 040E afii10062 040F afii10145 0410 afii10017 0411 afii10018 0412 afii10019 0413 afii10020 0414 afii10021 0415 afii10022 0416 afii10024 0417 afii10025 0418 afii10026 0419 afii10027 041A afii10028 041B afii10029 041C afii10030 041D afii10031 041E afii10032 041F afii10033 0420 afii10034 0421 afii10035 0422 afii10036 0423 afii10037 0424 afii10038 0425 afii10039 0426 afii10040 0427 afii10041 0428 afii10042 0429 afii10043 042A afii10044 042B afii10045 042C afii10046 042D afii10047 042E afii10048 042F afii10049 0430 afii10065 0431 afii10066 0432 afii10067 0433 afii10068 0434 afii10069 0435 afii10070 0436 afii10072 0437 afii10073 0438 afii10074 0439 afii10075 043A afii10076 043B afii10077 043C afii10078 043D afii10079 043E afii10080 043F afii10081 0440 afii10082 0441 afii10083 0442 afii10084 0443 afii10085 0444 afii10086 0445 afii10087 0446 afii10088 0447 afii10089 0448 afii10090 0449 afii10091 044A afii10092 044B afii10093 044C afii10094 044D afii10095 044E afii10096 044F afii10097 0451 afii10071 0452 afii10099 0453 afii10100 0454 afii10101 0455 afii10102 0456 afii10103 0457 afii10104 0458 afii10105 0459 afii10106 045A afii10107 045B afii10108 045C afii10109 045E afii10110 045F afii10193 0462 afii10146 0463 afii10194 0472 afii10147 0473 afii10195 0474 afii10148 0475 afii10196 0490 afii10050 0491 afii10098 04D9 afii10846 05B0 afii57799 05B1 afii57801 05B2 afii57800 05B3 afii57802 05B4 afii57793 05B5 afii57794 05B6 afii57795 05B7 afii57798 05B8 afii57797 05B9 afii57806 05BB afii57796 05BC afii57807 05BD afii57839 05BE afii57645 05BF afii57841 05C0 afii57842 05C1 afii57804 05C2 afii57803 05C3 afii57658 05D0 afii57664 05D1 afii57665 05D2 afii57666 05D3 afii57667 05D4 afii57668 05D5 afii57669 05D6 afii57670 05D7 afii57671 05D8 afii57672 05D9 afii57673 05DA afii57674 05DB afii57675 05DC afii57676 05DD afii57677 05DE afii57678 05DF afii57679 05E0 afii57680 05E1 afii57681 05E2 afii57682 05E3 afii57683 05E4 afii57684 05E5 afii57685 05E6 afii57686 05E7 afii57687 05E8 afii57688 05E9 afii57689 05EA afii57690 05F0 afii57716 05F1 afii57717 05F2 afii57718 060C afii57388 061B afii57403 061F afii57407 0621 afii57409 0622 afii57410 0623 afii57411 0624 afii57412 0625 afii57413 0626 afii57414 0627 afii57415 0628 afii57416 0629 afii57417 062A afii57418 062B afii57419 062C afii57420 062D afii57421 062E afii57422 062F afii57423 0630 afii57424 0631 afii57425 0632 afii57426 0633 afii57427 0634 afii57428 0635 afii57429 0636 afii57430 0637 afii57431 0638 afii57432 0639 afii57433 063A afii57434 0640 afii57440 0641 afii57441 0642 afii57442 0643 afii57443 0644 afii57444 0645 afii57445 0646 afii57446 0647 afii57470 0648 afii57448 0649 afii57449 064A afii57450 064B afii57451 064C afii57452 064D afii57453 064E afii57454 064F afii57455 0650 afii57456 0651 afii57457 0652 afii57458 0660 afii57392 0661 afii57393 0662 afii57394 0663 afii57395 0664 afii57396 0665 afii57397 0666 afii57398 0667 afii57399 0668 afii57400 0669 afii57401 066A afii57381 066D afii63167 0679 afii57511 067E afii57506 0686 afii57507 0688 afii57512 0691 afii57513 0698 afii57508 06A4 afii57505 06AF afii57509 06BA afii57514 06D2 afii57519 06D5 afii57534 1E80 Wgrave 1E81 wgrave 1E82 Wacute 1E83 wacute 1E84 Wdieresis 1E85 wdieresis 1EF2 Ygrave 1EF3 ygrave 200C afii61664 200D afii301 200E afii299 200F afii300 2012 figuredash 2013 endash 2014 emdash 2015 afii00208 2017 underscoredbl 2018 quoteleft 2019 quoteright 201A quotesinglbase 201B quotereversed 201C quotedblleft 201D quotedblright 201E quotedblbase 2020 dagger 2021 daggerdbl 2022 bullet 2024 onedotenleader 2025 twodotenleader 2026 ellipsis 202C afii61573 202D afii61574 202E afii61575 2030 perthousand 2032 minute 2033 second 2039 guilsinglleft 203A guilsinglright 203C exclamdbl 2044 fraction 2070 zerosuperior 2074 foursuperior 2075 fivesuperior 2076 sixsuperior 2077 sevensuperior 2078 eightsuperior 2079 ninesuperior 207D parenleftsuperior 207E parenrightsuperior 207F nsuperior 2080 zeroinferior 2081 oneinferior 2082 twoinferior 2083 threeinferior 2084 fourinferior 2085 fiveinferior 2086 sixinferior 2087 seveninferior 2088 eightinferior 2089 nineinferior 208D parenleftinferior 208E parenrightinferior 20A1 colonmonetary 20A3 franc 20A4 lira 20A7 peseta 20AA afii57636 20AB dong 20AC Euro 2105 afii61248 2111 Ifraktur 2113 afii61289 2116 afii61352 2118 weierstrass 211C Rfraktur 211E prescription 2122 trademark 2126 Omega 212E estimated 2135 aleph 2153 onethird 2154 twothirds 215B oneeighth 215C threeeighths 215D fiveeighths 215E seveneighths 2190 arrowleft 2191 arrowup 2192 arrowright 2193 arrowdown 2194 arrowboth 2195 arrowupdn 21A8 arrowupdnbse 21B5 carriagereturn 21D0 arrowdblleft 21D1 arrowdblup 21D2 arrowdblright 21D3 arrowdbldown 21D4 arrowdblboth 2200 universal 2202 partialdiff 2203 existential 2205 emptyset 2206 Delta 2207 gradient 2208 element 2209 notelement 220B suchthat 220F product 2211 summation 2212 minus 2215 fraction 2217 asteriskmath 2219 periodcentered 221A radical 221D proportional 221E infinity 221F orthogonal 2220 angle 2227 logicaland 2228 logicalor 2229 intersection 222A union 222B integral 2234 therefore 223C similar 2245 congruent 2248 approxequal 2260 notequal 2261 equivalence 2264 lessequal 2265 greaterequal 2282 propersubset 2283 propersuperset 2284 notsubset 2286 reflexsubset 2287 reflexsuperset 2295 circleplus 2297 circlemultiply 22A5 perpendicular 22C5 dotmath 2302 house 2310 revlogicalnot 2320 integraltp 2321 integralbt 2329 angleleft 232A angleright 2500 SF100000 2502 SF110000 250C SF010000 2510 SF030000 2514 SF020000 2518 SF040000 251C SF080000 2524 SF090000 252C SF060000 2534 SF070000 253C SF050000 2550 SF430000 2551 SF240000 2552 SF510000 2553 SF520000 2554 SF390000 2555 SF220000 2556 SF210000 2557 SF250000 2558 SF500000 2559 SF490000 255A SF380000 255B SF280000 255C SF270000 255D SF260000 255E SF360000 255F SF370000 2560 SF420000 2561 SF190000 2562 SF200000 2563 SF230000 2564 SF470000 2565 SF480000 2566 SF410000 2567 SF450000 2568 SF460000 2569 SF400000 256A SF540000 256B SF530000 256C SF440000 2580 upblock 2584 dnblock 2588 block 258C lfblock 2590 rtblock 2591 ltshade 2592 shade 2593 dkshade 25A0 filledbox 25A1 H22073 25AA H18543 25AB H18551 25AC filledrect 25B2 triagup 25BA triagrt 25BC triagdn 25C4 triaglf 25CA lozenge 25CB circle 25CF H18533 25D8 invbullet 25D9 invcircle 25E6 openbullet 263A smileface 263B invsmileface 263C sun 2640 female 2642 male 2660 spade 2663 club 2665 heart 2666 diamond 266A musicalnote 266B musicalnotedbl F6BE dotlessj F6BF LL F6C0 ll F6C1 Scedilla F6C2 scedilla F6C3 commaaccent F6C4 afii10063 F6C5 afii10064 F6C6 afii10192 F6C7 afii10831 F6C8 afii10832 F6C9 Acute F6CA Caron F6CB Dieresis F6CC DieresisAcute F6CD DieresisGrave F6CE Grave F6CF Hungarumlaut F6D0 Macron F6D1 cyrBreve F6D2 cyrFlex F6D3 dblGrave F6D4 cyrbreve F6D5 cyrflex F6D6 dblgrave F6D7 dieresisacute F6D8 dieresisgrave F6D9 copyrightserif F6DA registerserif F6DB trademarkserif F6DC onefitted F6DD rupiah F6DE threequartersemdash F6DF centinferior F6E0 centsuperior F6E1 commainferior F6E2 commasuperior F6E3 dollarinferior F6E4 dollarsuperior F6E5 hypheninferior F6E6 hyphensuperior F6E7 periodinferior F6E8 periodsuperior F6E9 asuperior F6EA bsuperior F6EB dsuperior F6EC esuperior F6ED isuperior F6EE lsuperior F6EF msuperior F6F0 osuperior F6F1 rsuperior F6F2 ssuperior F6F3 tsuperior F6F4 Brevesmall F6F5 Caronsmall F6F6 Circumflexsmall F6F7 Dotaccentsmall F6F8 Hungarumlautsmall F6F9 Lslashsmall F6FA OEsmall F6FB Ogoneksmall F6FC Ringsmall F6FD Scaronsmall F6FE Tildesmall F6FF Zcaronsmall F721 exclamsmall F724 dollaroldstyle F726 ampersandsmall F730 zerooldstyle F731 oneoldstyle F732 twooldstyle F733 threeoldstyle F734 fouroldstyle F735 fiveoldstyle F736 sixoldstyle F737 sevenoldstyle F738 eightoldstyle F739 nineoldstyle F73F questionsmall F760 Gravesmall F761 Asmall F762 Bsmall F763 Csmall F764 Dsmall F765 Esmall F766 Fsmall F767 Gsmall F768 Hsmall F769 Ismall F76A Jsmall F76B Ksmall F76C Lsmall F76D Msmall F76E Nsmall F76F Osmall F770 Psmall F771 Qsmall F772 Rsmall F773 Ssmall F774 Tsmall F775 Usmall F776 Vsmall F777 Wsmall F778 Xsmall F779 Ysmall F77A Zsmall F7A1 exclamdownsmall F7A2 centoldstyle F7A8 Dieresissmall F7AF Macronsmall F7B4 Acutesmall F7B8 Cedillasmall F7BF questiondownsmall F7E0 Agravesmall F7E1 Aacutesmall F7E2 Acircumflexsmall F7E3 Atildesmall F7E4 Adieresissmall F7E5 Aringsmall F7E6 AEsmall F7E7 Ccedillasmall F7E8 Egravesmall F7E9 Eacutesmall F7EA Ecircumflexsmall F7EB Edieresissmall F7EC Igravesmall F7ED Iacutesmall F7EE Icircumflexsmall F7EF Idieresissmall F7F0 Ethsmall F7F1 Ntildesmall F7F2 Ogravesmall F7F3 Oacutesmall F7F4 Ocircumflexsmall F7F5 Otildesmall F7F6 Odieresissmall F7F8 Oslashsmall F7F9 Ugravesmall F7FA Uacutesmall F7FB Ucircumflexsmall F7FC Udieresissmall F7FD Yacutesmall F7FE Thornsmall F7FF Ydieresissmall F8E5 radicalex F8E6 arrowvertex F8E7 arrowhorizex F8E8 registersans F8E9 copyrightsans F8EA trademarksans F8EB parenlefttp F8EC parenleftex F8ED parenleftbt F8EE bracketlefttp F8EF bracketleftex F8F0 bracketleftbt F8F1 bracelefttp F8F2 braceleftmid F8F3 braceleftbt F8F4 braceex F8F5 integralex F8F6 parenrighttp F8F7 parenrightex F8F8 parenrightbt F8F9 bracketrighttp F8FA bracketrightex F8FB bracketrightbt F8FC bracerighttp F8FD bracerightmid F8FE bracerightbt FB00 ff FB01 fi FB02 fl FB03 ffi FB04 ffl FB1F afii57705 FB2A afii57694 FB2B afii57695 FB35 afii57723 FB4B afii57700 } # precalculate entire prolog when this file is loaded # (to speed things up) set ps_preamable "%%BeginProlog\n" append ps_preamable [CreatePostscriptEncoding [encoding system]] append ps_preamable { 50 dict begin % This is a standard prolog for Postscript generated by Tk's canvas % widget. % RCS: @(#) $Id: mkpsenc.tcl,v 1.3 2002/07/19 14:37:21 drh Exp $ % The definitions below just define all of the variables used in % any of the procedures here. This is needed for obscure reasons % explained on p. 716 of the Postscript manual (Section H.2.7, % "Initializing Variables," in the section on Encapsulated Postscript). /baseline 0 def /stipimage 0 def /height 0 def /justify 0 def /lineLength 0 def /spacing 0 def /stipple 0 def /strings 0 def /xoffset 0 def /yoffset 0 def /tmpstip null def /cstringshow { { dup type /stringtype eq { show } { glyphshow } ifelse } forall } bind def /cstringwidth { 0 exch 0 exch { dup type /stringtype eq { stringwidth } { currentfont /Encoding get exch 1 exch put (\001) stringwidth } ifelse exch 3 1 roll add 3 1 roll add exch } forall } bind def % font ISOEncode font % This procedure changes the encoding of a font from the default % Postscript encoding to current system encoding. It's typically invoked just % before invoking "setfont". The body of this procedure comes from % Section 5.6.1 of the Postscript book. /ISOEncode { dup length dict begin {1 index /FID ne {def} {pop pop} ifelse} forall /Encoding CurrentEncoding def currentdict end % I'm not sure why it's necessary to use "definefont" on this new % font, but it seems to be important; just use the name "Temporary" % for the font. /Temporary exch definefont } bind def % StrokeClip % % This procedure converts the current path into a clip area under % the assumption of stroking. It's a bit tricky because some Postscript % interpreters get errors during strokepath for dashed lines. If % this happens then turn off dashes and try again. /StrokeClip { {strokepath} stopped { (This Postscript printer gets limitcheck overflows when) = (stippling dashed lines; lines will be printed solid instead.) = [] 0 setdash strokepath} if clip } bind def % desiredSize EvenPixels closestSize % % The procedure below is used for stippling. Given the optimal size % of a dot in a stipple pattern in the current user coordinate system, % compute the closest size that is an exact multiple of the device's % pixel size. This allows stipple patterns to be displayed without % aliasing effects. /EvenPixels { % Compute exact number of device pixels per stipple dot. dup 0 matrix currentmatrix dtransform dup mul exch dup mul add sqrt % Round to an integer, make sure the number is at least 1, and compute % user coord distance corresponding to this. dup round dup 1 lt {pop 1} if exch div mul } bind def % width height string StippleFill -- % % Given a path already set up and a clipping region generated from % it, this procedure will fill the clipping region with a stipple % pattern. "String" contains a proper image description of the % stipple pattern and "width" and "height" give its dimensions. Each % stipple dot is assumed to be about one unit across in the current % user coordinate system. This procedure trashes the graphics state. /StippleFill { % The following code is needed to work around a NeWSprint bug. /tmpstip 1 index def % Change the scaling so that one user unit in user coordinates % corresponds to the size of one stipple dot. 1 EvenPixels dup scale % Compute the bounding box occupied by the path (which is now % the clipping region), and round the lower coordinates down % to the nearest starting point for the stipple pattern. Be % careful about negative numbers, since the rounding works % differently on them. pathbbox 4 2 roll 5 index div dup 0 lt {1 sub} if cvi 5 index mul 4 1 roll 6 index div dup 0 lt {1 sub} if cvi 6 index mul 3 2 roll % Stack now: width height string y1 y2 x1 x2 % Below is a doubly-nested for loop to iterate across this area % in units of the stipple pattern size, going up columns then % across rows, blasting out a stipple-pattern-sized rectangle at % each position 6 index exch { 2 index 5 index 3 index { % Stack now: width height string y1 y2 x y gsave 1 index exch translate 5 index 5 index true matrix tmpstip imagemask grestore } for pop } for pop pop pop pop pop } bind def % -- AdjustColor -- % Given a color value already set for output by the caller, adjusts % that value to a grayscale or mono value if requested by the CL % variable. /AdjustColor { CL 2 lt { currentgray CL 0 eq { .5 lt {0} {1} ifelse } if setgray } if } bind def % x y strings spacing xoffset yoffset justify stipple DrawText -- % This procedure does all of the real work of drawing text. The % color and font must already have been set by the caller, and the % following arguments must be on the stack: % % x, y - Coordinates at which to draw text. % strings - An array of strings, one for each line of the text item, % in order from top to bottom. % spacing - Spacing between lines. % xoffset - Horizontal offset for text bbox relative to x and y: 0 for % nw/w/sw anchor, -0.5 for n/center/s, and -1.0 for ne/e/se. % yoffset - Vertical offset for text bbox relative to x and y: 0 for % nw/n/ne anchor, +0.5 for w/center/e, and +1.0 for sw/s/se. % justify - 0 for left justification, 0.5 for center, 1 for right justify. % stipple - Boolean value indicating whether or not text is to be % drawn in stippled fashion. If text is stippled, % procedure StippleText must have been defined to call % StippleFill in the right way. % % Also, when this procedure is invoked, the color and font must already % have been set for the text. /DrawText { /stipple exch def /justify exch def /yoffset exch def /xoffset exch def /spacing exch def /strings exch def % First scan through all of the text to find the widest line. /lineLength 0 def strings { cstringwidth pop dup lineLength gt {/lineLength exch def} {pop} ifelse newpath } forall % Compute the baseline offset and the actual font height. 0 0 moveto (TXygqPZ) false charpath pathbbox dup /baseline exch def exch pop exch sub /height exch def pop newpath % Translate coordinates first so that the origin is at the upper-left % corner of the text's bounding box. Remember that x and y for % positioning are still on the stack. translate lineLength xoffset mul strings length 1 sub spacing mul height add yoffset mul translate % Now use the baseline and justification information to translate so % that the origin is at the baseline and positioning point for the % first line of text. justify lineLength mul baseline neg translate % Iterate over each of the lines to output it. For each line, % compute its width again so it can be properly justified, then % display it. strings { dup cstringwidth pop justify neg mul 0 moveto stipple { % The text is stippled, so turn it into a path and print % by calling StippledText, which in turn calls StippleFill. % Unfortunately, many Postscript interpreters will get % overflow errors if we try to do the whole string at % once, so do it a character at a time. gsave /char (X) def { dup type /stringtype eq { % This segment is a string. { char 0 3 -1 roll put currentpoint gsave char true charpath clip StippleText grestore char stringwidth translate moveto } forall } { % This segment is glyph name % Temporary override currentfont /Encoding get exch 1 exch put currentpoint gsave (\001) true charpath clip StippleText grestore (\001) stringwidth translate moveto } ifelse } forall grestore } {cstringshow} ifelse 0 spacing neg translate } forall } bind def %%EndProlog } } proc tk::ensure_psenc_is_loaded {} { } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/msgbox.tcl0100644000000000001200000003707610153074437030123 0ustar rootadmin# msgbox.tcl -- # # Implements messageboxes for platforms that do not have native # messagebox support. # # RCS: @(#) $Id: msgbox.tcl,v 1.24.2.2 2004/05/13 23:28:34 dkf Exp $ # # Copyright (c) 1994-1997 Sun Microsystems, Inc. # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # # Ensure existence of ::tk::dialog namespace # namespace eval ::tk::dialog {} image create bitmap ::tk::dialog::b1 -foreground black \ -data "#define b1_width 32\n#define b1_height 32 static unsigned char q1_bits[] = { 0x00, 0xf8, 0x1f, 0x00, 0x00, 0x07, 0xe0, 0x00, 0xc0, 0x00, 0x00, 0x03, 0x20, 0x00, 0x00, 0x04, 0x10, 0x00, 0x00, 0x08, 0x08, 0x00, 0x00, 0x10, 0x04, 0x00, 0x00, 0x20, 0x02, 0x00, 0x00, 0x40, 0x02, 0x00, 0x00, 0x40, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x02, 0x00, 0x00, 0x40, 0x02, 0x00, 0x00, 0x40, 0x04, 0x00, 0x00, 0x20, 0x08, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x08, 0x60, 0x00, 0x00, 0x04, 0x80, 0x03, 0x80, 0x03, 0x00, 0x0c, 0x78, 0x00, 0x00, 0x30, 0x04, 0x00, 0x00, 0x40, 0x04, 0x00, 0x00, 0x40, 0x04, 0x00, 0x00, 0x80, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};" image create bitmap ::tk::dialog::b2 -foreground white \ -data "#define b2_width 32\n#define b2_height 32 static unsigned char b2_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x1f, 0x00, 0x00, 0xff, 0xff, 0x00, 0xc0, 0xff, 0xff, 0x03, 0xe0, 0xff, 0xff, 0x07, 0xf0, 0xff, 0xff, 0x0f, 0xf8, 0xff, 0xff, 0x1f, 0xfc, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x3f, 0xfe, 0xff, 0xff, 0x7f, 0xfe, 0xff, 0xff, 0x7f, 0xfe, 0xff, 0xff, 0x7f, 0xfe, 0xff, 0xff, 0x7f, 0xfe, 0xff, 0xff, 0x7f, 0xfe, 0xff, 0xff, 0x7f, 0xfe, 0xff, 0xff, 0x7f, 0xfc, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x3f, 0xf8, 0xff, 0xff, 0x1f, 0xf0, 0xff, 0xff, 0x0f, 0xe0, 0xff, 0xff, 0x07, 0x80, 0xff, 0xff, 0x03, 0x00, 0xfc, 0x7f, 0x00, 0x00, 0xf0, 0x07, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};" image create bitmap ::tk::dialog::q -foreground blue \ -data "#define q_width 32\n#define q_height 32 static unsigned char q_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0x10, 0x0f, 0x00, 0x00, 0x18, 0x1e, 0x00, 0x00, 0x38, 0x1e, 0x00, 0x00, 0x38, 0x1e, 0x00, 0x00, 0x10, 0x0f, 0x00, 0x00, 0x80, 0x07, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};" image create bitmap ::tk::dialog::i -foreground blue \ -data "#define i_width 32\n#define i_height 32 static unsigned char i_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x03, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0xf0, 0x07, 0x00, 0x00, 0xf8, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};" image create bitmap ::tk::dialog::w1 -foreground black \ -data "#define w1_width 32\n#define w1_height 32 static unsigned char w1_bits[] = { 0x00, 0x80, 0x01, 0x00, 0x00, 0x40, 0x02, 0x00, 0x00, 0x20, 0x04, 0x00, 0x00, 0x10, 0x04, 0x00, 0x00, 0x10, 0x08, 0x00, 0x00, 0x08, 0x08, 0x00, 0x00, 0x08, 0x10, 0x00, 0x00, 0x04, 0x10, 0x00, 0x00, 0x04, 0x20, 0x00, 0x00, 0x02, 0x20, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x01, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x02, 0x20, 0x00, 0x00, 0x02, 0x20, 0x00, 0x00, 0x04, 0x10, 0x00, 0x00, 0x04, 0x10, 0x00, 0x00, 0x08, 0x08, 0x00, 0x00, 0x08, 0x08, 0x00, 0x00, 0x10, 0x04, 0x00, 0x00, 0x10, 0x04, 0x00, 0x00, 0x20, 0x02, 0x00, 0x00, 0x20, 0x01, 0x00, 0x00, 0x40, 0x01, 0x00, 0x00, 0x40, 0x01, 0x00, 0x00, 0x40, 0x02, 0x00, 0x00, 0x20, 0xfc, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00};" image create bitmap ::tk::dialog::w2 -foreground yellow \ -data "#define w2_width 32\n#define w2_height 32 static unsigned char w2_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xf0, 0x07, 0x00, 0x00, 0xf0, 0x0f, 0x00, 0x00, 0xf8, 0x0f, 0x00, 0x00, 0xf8, 0x1f, 0x00, 0x00, 0xfc, 0x1f, 0x00, 0x00, 0xfc, 0x3f, 0x00, 0x00, 0xfe, 0x3f, 0x00, 0x00, 0xfe, 0x7f, 0x00, 0x00, 0xff, 0x7f, 0x00, 0x00, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0x01, 0xc0, 0xff, 0xff, 0x01, 0xc0, 0xff, 0xff, 0x03, 0xe0, 0xff, 0xff, 0x03, 0xe0, 0xff, 0xff, 0x07, 0xf0, 0xff, 0xff, 0x07, 0xf0, 0xff, 0xff, 0x0f, 0xf8, 0xff, 0xff, 0x0f, 0xf8, 0xff, 0xff, 0x1f, 0xfc, 0xff, 0xff, 0x1f, 0xfe, 0xff, 0xff, 0x3f, 0xfe, 0xff, 0xff, 0x3f, 0xfe, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};" image create bitmap ::tk::dialog::w3 -foreground black \ -data "#define w3_width 32\n#define w3_height 32 static unsigned char w3_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};" # ::tk::MessageBox -- # # Pops up a messagebox with an application-supplied message with # an icon and a list of buttons. This procedure will be called # by tk_messageBox if the platform does not have native # messagebox support, or if the particular type of messagebox is # not supported natively. # # Color icons are used on Unix displays that have a color # depth of 4 or more and $tk_strictMotif is not on. # # This procedure is a private procedure shouldn't be called # directly. Call tk_messageBox instead. # # See the user documentation for details on what tk_messageBox does. # proc ::tk::MessageBox {args} { global tcl_platform tk_strictMotif variable ::tk::Priv set w ::tk::PrivMsgBox upvar $w data # # The default value of the title is space (" ") not the empty string # because for some window managers, a # wm title .foo "" # causes the window title to be "foo" instead of the empty string. # set specs { {-default "" "" ""} {-icon "" "" "info"} {-message "" "" ""} {-parent "" "" .} {-title "" "" " "} {-type "" "" "ok"} } tclParseConfigSpec $w $specs "" $args if {[lsearch -exact {info warning error question} $data(-icon)] == -1} { error "bad -icon value \"$data(-icon)\": must be error, info, question, or warning" } if {[string equal [tk windowingsystem] "classic"] || [string equal [tk windowingsystem] "aqua"]} { switch -- $data(-icon) { "error" {set data(-icon) "stop"} "warning" {set data(-icon) "caution"} "info" {set data(-icon) "note"} } } if {![winfo exists $data(-parent)]} { error "bad window path name \"$data(-parent)\"" } switch -- $data(-type) { abortretryignore { set names [list abort retry ignore] set labels [list &Abort &Retry &Ignore] } ok { set names [list ok] set labels {&OK} } okcancel { set names [list ok cancel] set labels [list &OK &Cancel] } retrycancel { set names [list retry cancel] set labels [list &Retry &Cancel] } yesno { set names [list yes no] set labels [list &Yes &No] } yesnocancel { set names [list yes no cancel] set labels [list &Yes &No &Cancel] } default { error "bad -type value \"$data(-type)\": must be\ abortretryignore, ok, okcancel, retrycancel,\ yesno, or yesnocancel" } } set buttons {} foreach name $names lab $labels { lappend buttons [list $name -text [mc $lab]] } # If no default button was specified, the default default is the # first button (Bug: 2218). if {$data(-default) == ""} { set data(-default) [lindex [lindex $buttons 0] 0] } set valid 0 foreach btn $buttons { if {[string equal [lindex $btn 0] $data(-default)]} { set valid 1 break } } if {!$valid} { error "invalid default button \"$data(-default)\"" } # 2. Set the dialog to be a child window of $parent # # if {[string compare $data(-parent) .]} { set w $data(-parent).__tk__messagebox } else { set w .__tk__messagebox } # 3. Create the top-level window and divide it into top # and bottom parts. catch {destroy $w} toplevel $w -class Dialog wm title $w $data(-title) wm iconname $w Dialog wm protocol $w WM_DELETE_WINDOW { } # There is only one background colour for the whole dialog set bg [$w cget -background] # Message boxes should be transient with respect to their parent so that # they always stay on top of the parent window. But some window managers # will simply create the child window as withdrawn if the parent is not # viewable (because it is withdrawn or iconified). This is not good for # "grab"bed windows. So only make the message box transient if the parent # is viewable. # if {[winfo viewable [winfo toplevel $data(-parent)]] } { wm transient $w $data(-parent) } if {[string equal [tk windowingsystem] "classic"] || [string equal [tk windowingsystem] "aqua"]} { unsupported::MacWindowStyle style $w dBoxProc } frame $w.bot -background $bg pack $w.bot -side bottom -fill both frame $w.top -background $bg pack $w.top -side top -fill both -expand 1 if {![string equal [tk windowingsystem] "classic"] && ![string equal [tk windowingsystem] "aqua"]} { $w.bot configure -relief raised -bd 1 $w.top configure -relief raised -bd 1 } # 4. Fill the top part with bitmap and message (use the option # database for -wraplength and -font so that they can be # overridden by the caller). option add *Dialog.msg.wrapLength 3i widgetDefault if {[string equal [tk windowingsystem] "classic"] || [string equal [tk windowingsystem] "aqua"]} { option add *Dialog.msg.font system widgetDefault } else { option add *Dialog.msg.font {Times 14} widgetDefault } label $w.msg -anchor nw -justify left -text $data(-message) \ -background $bg if {[string compare $data(-icon) ""]} { if {([string equal [tk windowingsystem] "classic"] || [string equal [tk windowingsystem] "aqua"]) || ([winfo depth $w] < 4) || $tk_strictMotif} { label $w.bitmap -bitmap $data(-icon) -background $bg } else { canvas $w.bitmap -width 32 -height 32 -highlightthickness 0 \ -background $bg switch $data(-icon) { error { $w.bitmap create oval 0 0 31 31 -fill red -outline black $w.bitmap create line 9 9 23 23 -fill white -width 4 $w.bitmap create line 9 23 23 9 -fill white -width 4 } info { $w.bitmap create image 0 0 -anchor nw \ -image ::tk::dialog::b1 $w.bitmap create image 0 0 -anchor nw \ -image ::tk::dialog::b2 $w.bitmap create image 0 0 -anchor nw \ -image ::tk::dialog::i } question { $w.bitmap create image 0 0 -anchor nw \ -image ::tk::dialog::b1 $w.bitmap create image 0 0 -anchor nw \ -image ::tk::dialog::b2 $w.bitmap create image 0 0 -anchor nw \ -image ::tk::dialog::q } default { $w.bitmap create image 0 0 -anchor nw \ -image ::tk::dialog::w1 $w.bitmap create image 0 0 -anchor nw \ -image ::tk::dialog::w2 $w.bitmap create image 0 0 -anchor nw \ -image ::tk::dialog::w3 } } } } grid $w.bitmap $w.msg -in $w.top -sticky news -padx 2m -pady 2m grid columnconfigure $w.top 1 -weight 1 grid rowconfigure $w.top 0 -weight 1 # 5. Create a row of buttons at the bottom of the dialog. set i 0 foreach but $buttons { set name [lindex $but 0] set opts [lrange $but 1 end] if {![llength $opts]} { # Capitalize the first letter of $name set capName [string toupper $name 0] set opts [list -text $capName] } eval [list tk::AmpWidget button $w.$name -padx 3m] $opts \ [list -command [list set tk::Priv(button) $name]] if {[string equal $name $data(-default)]} { $w.$name configure -default active } else { $w.$name configure -default normal } grid $w.$name -in $w.bot -row 0 -column $i -padx 3m -pady 2m -sticky ew grid columnconfigure $w.bot $i -uniform buttons incr i # create the binding for the key accelerator, based on the underline # # set underIdx [$w.$name cget -under] # if {$underIdx >= 0} { # set key [string index [$w.$name cget -text] $underIdx] # bind $w [list $w.$name invoke] # bind $w [list $w.$name invoke] # } } bind $w [list ::tk::AltKeyInDialog $w %A] if {[string compare {} $data(-default)]} { bind $w { if {[string equal Button [winfo class %W]]} { %W configure -default active } } bind $w { if {[string equal Button [winfo class %W]]} { %W configure -default normal } } } # 6. Create a binding for on the dialog bind $w { if {[string equal Button [winfo class %W]]} { tk::ButtonInvoke %W } } # 7. 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 and de-iconify it. ::tk::PlaceWindow $w widget $data(-parent) # 8. Set a grab and claim the focus too. if {[string compare $data(-default) ""]} { set focus $w.$data(-default) } else { set focus $w } ::tk::SetFocusGrab $w $focus # 9. 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(button) ::tk::RestoreFocusGrab $w $focus return $Priv(button) } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/msgs/0040755000000000000240000000000010153074437027075 5ustar rootstaffWishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/msgs/cs.msg0100644000000000001200000000736710153074437030206 0ustar rootadminnamespace eval ::tk { ::msgcat::mcset cs "&Abort" "&P\u0159eru\u0161it" ::msgcat::mcset cs "About..." "O programu..." ::msgcat::mcset cs "All Files" "V\u0161echny soubory" ::msgcat::mcset cs "Application Error" "Chyba programu" ::msgcat::mcset cs "&Blue" "&Modr\341" ::msgcat::mcset cs "&Cancel" "&Zru\u0161it" ::msgcat::mcset cs "Cannot change to the directory \"%1\$s\".\nPermission denied." "Nemohu zm\u011bnit atku\341ln\355 adres\341\u0159 na \"%1\$s\".\nP\u0159\355stup odm\355tnut." ::msgcat::mcset cs "Choose Directory" "V\375b\u011br adres\341\u0159e" ::msgcat::mcset cs "Clear" "Smazat" ::msgcat::mcset cs "Color" "Barva" ::msgcat::mcset cs "Console" "Konzole" ::msgcat::mcset cs "Copy" "Kop\355rovat" ::msgcat::mcset cs "Cut" "Vy\u0159\355znout" ::msgcat::mcset cs "Delete" "Smazat" ::msgcat::mcset cs "Details >>" "Detaily >>" ::msgcat::mcset cs "Directory \"%1\$s\" does not exist." "Adres\341\u0159 \"%1\$s\" neexistuje." ::msgcat::mcset cs "&Directory:" "&Adres\341\u0159:" ::msgcat::mcset cs "Error: %1\$s" "Chyba: %1\$s" ::msgcat::mcset cs "Exit" "Konec" ::msgcat::mcset cs "File \"%1\$s\" already exists.\n\n" "Soubor \"%1\$s\" ji\u017e existuje.\n\n" ::msgcat::mcset cs "File \"%1\$s\" already exists.\nDo you want to overwrite it?" "Soubor \"%1\$s\" ji\u017e existuje.\nChcete jej p\u0159epsat?" ::msgcat::mcset cs "File \"%1\$s\" does not exist." "Soubor \"%1\$s\" neexistuje." ::msgcat::mcset cs "File &name:" "&Jm\351no souboru:" ::msgcat::mcset cs "File &names:" "&Jm\351na soubor\u016f:" ::msgcat::mcset cs "Files of &type:" "&Typy soubor\u016f:" ::msgcat::mcset cs "Fi&les:" "Sou&bory:" ::msgcat::mcset cs "&Filter" "&Filtr" ::msgcat::mcset cs "Fil&ter:" "Fil&tr:" ::msgcat::mcset cs "&Green" "Ze&len\341" ::msgcat::mcset cs "Hi" ::msgcat::mcset cs "Hide Console" "Skr\375t konsolu" ::msgcat::mcset cs "&Ignore" "&Ignorovat" ::msgcat::mcset cs "Invalid file name \"%1\$s\"." "\u0160patn\351 jm\351no souboru \"%1\$s\"." ::msgcat::mcset cs "Log Files" "Log soubory" ::msgcat::mcset cs "&No" "&Ne" ::msgcat::mcset cs "&OK" ::msgcat::mcset cs "Ok" ::msgcat::mcset cs "Open" "Otev\u0159\355t" ::msgcat::mcset cs "&Open" "&Otev\u0159\355t" ::msgcat::mcset cs "Open Multiple Files" "Otev\u0159\355t v\355ce soubor\u016f" ::msgcat::mcset cs "Paste" "Vlo\u017eit" ::msgcat::mcset cs "Quit" "Skon\u010dit" ::msgcat::mcset cs "&Red" " \u010ce&rven\341" ::msgcat::mcset cs "Replace existing file?" "Nahradit st\341vaj\355c\355 soubor?" ::msgcat::mcset cs "&Retry" "Z&novu" ::msgcat::mcset cs "&Save" "&Ulo\u017eit" ::msgcat::mcset cs "Save As" "Ulo\u017eit jako" ::msgcat::mcset cs "Save To Log" "Ulo\u017eit do logu" ::msgcat::mcset cs "Select Log File" "Vybrat log soubor" ::msgcat::mcset cs "Select a file to source" "Vybrat soubor k nahr\341n\355" ::msgcat::mcset cs "&Selection:" "&V\375b\u011br:" ::msgcat::mcset cs "Skip Messages" "P\u0159esko\u010dit zpr\341vy" ::msgcat::mcset cs "Source..." "Nahr\341t..." ::msgcat::mcset cs "Tcl Scripts" "Tcl skripty" ::msgcat::mcset cs "Tcl for Windows" "Tcl pro Windows" ::msgcat::mcset cs "Text Files" "Textov\351 soubory" ::msgcat::mcset cs "&Yes" "&Ano" ::msgcat::mcset cs "abort" "p\u0159eru\u0161it" ::msgcat::mcset cs "blue" "modr\341" ::msgcat::mcset cs "cancel" "zru\u0161it" ::msgcat::mcset cs "extension" "p\u0159\355pona" ::msgcat::mcset cs "extensions" "p\u0159\355pony" ::msgcat::mcset cs "green" "zelen\341" ::msgcat::mcset cs "ignore" "ignorovat" ::msgcat::mcset cs "ok" ::msgcat::mcset cs "red" "\u010derven\341" ::msgcat::mcset cs "retry" "znovu" ::msgcat::mcset cs "yes" "ano" } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/msgs/de.msg0100644000000000001200000000722010153074437030155 0ustar rootadminnamespace eval ::tk { ::msgcat::mcset de "&Abort" "&Abbruch" ::msgcat::mcset de "About..." "\u00dcber..." ::msgcat::mcset de "All Files" "Alle Dateien" ::msgcat::mcset de "Application Error" "Applikationsfehler" ::msgcat::mcset de "&Blue" "&Blau" ::msgcat::mcset de "&Cancel" "&Abbruch" ::msgcat::mcset de "Cannot change to the directory \"%1\$s\".\nPermission denied." "Kann nicht in das Verzeichnis \"%1\$s\" wechseln.\nKeine Rechte vorhanden." ::msgcat::mcset de "Choose Directory" "W\u00e4hle Verzeichnis" ::msgcat::mcset de "Clear" "R\u00fccksetzen" ::msgcat::mcset de "Color" "Farbe" ::msgcat::mcset de "Console" "Konsole" ::msgcat::mcset de "Copy" "Kopieren" ::msgcat::mcset de "Cut" "Ausschneiden" ::msgcat::mcset de "Delete" "L\u00f6schen" ::msgcat::mcset de "Details >>" ::msgcat::mcset de "Directory \"%1\$s\" does not exist." "Das Verzeichnis \"%1\$s\" existiert nicht." ::msgcat::mcset de "&Directory:" "&Verzeichnis:" ::msgcat::mcset de "Error: %1\$s" "Fehler: %1\$s" ::msgcat::mcset de "Exit" "Ende" ::msgcat::mcset de "File \"%1\$s\" already exists.\nDo you want to overwrite it?" "Die Datei \"%1\$s\" ist bereits vorhanden.\nWollen sie diese Datei \u00fcberschreiben ?" ::msgcat::mcset de "File \"%1\$s\" already exists.\n\n" "Die Datei \"%1\$s\" ist bereits vorhanden.\n\n" ::msgcat::mcset de "File \"%1\$s\" does not exist." "Die Datei \"%1\$s\" existiert nicht." ::msgcat::mcset de "File &name:" "Datei&name:" ::msgcat::mcset de "File &names:" "Datei&namen:" ::msgcat::mcset de "Files of &type:" "Dateien des &Typs:" ::msgcat::mcset de "Fi&les:" "Dat&eien:" ::msgcat::mcset de "&Filter" ::msgcat::mcset de "Fil&ter:" ::msgcat::mcset de "&Green" "&Gr\u00fcn" ::msgcat::mcset de "Hi" "Hallo" ::msgcat::mcset de "Hide Console" "Konsole unsichtbar machen" ::msgcat::mcset de "&Ignore" "&Ignorieren" ::msgcat::mcset de "Invalid file name \"%1\$s\"." "Ung\u00fcltiger Dateiname \"%1\$s\"." ::msgcat::mcset de "Log Files" "Protokolldatei" ::msgcat::mcset de "&No" "&Nein" ::msgcat::mcset de "OK" ::msgcat::mcset de "Ok" ::msgcat::mcset de "Open" "\u00d6ffnen" ::msgcat::mcset de "&Open" "\u00d6&ffnen" ::msgcat::mcset de "Open Multiple Files" ::msgcat::mcset de "Paste" "Einf\u00fcgen" ::msgcat::mcset de "Quit" "Beenden" ::msgcat::mcset de "&Red" "&Rot" ::msgcat::mcset de "Replace existing file?" "Existierende Datei ersetzen?" ::msgcat::mcset de "&Retry" "&Wiederholen" ::msgcat::mcset de "&Save" "&Speichern" ::msgcat::mcset de "Save As" "Speichern unter" ::msgcat::mcset de "Save To Log" "In Protokoll speichern" ::msgcat::mcset de "Select Log File" "Protokolldatei ausw\u00e4hlen" ::msgcat::mcset de "Select a file to source" "Auszuf\u00fchrende Datei ausw\u00e4hlen" ::msgcat::mcset de "&Selection:" "Auswah&l:" ::msgcat::mcset de "Skip Messages" "Weitere Nachrichten \u00fcberspringen" ::msgcat::mcset de "Source..." "Ausf\u00fchren..." ::msgcat::mcset de "Tcl Scripts" "Tcl-Skripte" ::msgcat::mcset de "Tcl for Windows" "Tcl f\u00fcr Windows" ::msgcat::mcset de "Text Files" "Textdateien" ::msgcat::mcset de "&Yes" "&Ja" ::msgcat::mcset de "abort" "abbrechen" ::msgcat::mcset de "blue" "blau" ::msgcat::mcset de "cancel" "abbrechen" ::msgcat::mcset de "extension" "Erweiterung" ::msgcat::mcset de "extensions" "Erweiterungen" ::msgcat::mcset de "green" "gr\u00fcn" ::msgcat::mcset de "ignore" "ignorieren" ::msgcat::mcset de "ok" ::msgcat::mcset de "red" "rot" ::msgcat::mcset de "retry" "wiederholen" ::msgcat::mcset de "yes" "ja" } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/msgs/el.msg0100644000000000001200000002064210153074437030170 0ustar rootadmin## Messages for the Greek (Hellenic - "el") language. ## Please report any changes/suggestions to: ## petasis@iit.demokritos.gr namespace eval ::tk { ::msgcat::mcset el "&Abort" "\u03a4\u03b5\u03c1\u03bc\u03b1\u03c4\u03b9\u03c3\u03bc\u03cc\u03c2" ::msgcat::mcset el "About..." "\u03a3\u03c7\u03b5\u03c4\u03b9\u03ba\u03ac..." ::msgcat::mcset el "All Files" "\u038c\u03bb\u03b1 \u03c4\u03b1 \u0391\u03c1\u03c7\u03b5\u03af\u03b1" ::msgcat::mcset el "Application Error" "\u039b\u03ac\u03b8\u03bf\u03c2 \u0395\u03c6\u03b1\u03c1\u03bc\u03bf\u03b3\u03ae\u03c2" ::msgcat::mcset el "&Blue" "\u039c\u03c0\u03bb\u03b5" ::msgcat::mcset el "&Cancel" "\u0391\u03ba\u03cd\u03c1\u03c9\u03c3\u03b7" ::msgcat::mcset el \ "Cannot change to the directory \"%1\$s\".\nPermission denied." \ "\u0394\u03b5\u03bd \u03b5\u03af\u03bd\u03b1\u03b9 \u03b4\u03c5\u03bd\u03b1\u03c4\u03ae \u03b7 \u03b1\u03bb\u03bb\u03b1\u03b3\u03ae \u03ba\u03b1\u03c4\u03b1\u03bb\u03cc\u03b3\u03bf\u03c5 \u03c3\u03b5 \"%1\$s\".\n\u0397 \u03c0\u03c1\u03cc\u03c3\u03b2\u03b1\u03c3\u03b7 \u03b4\u03b5\u03bd \u03b5\u03c0\u03b9\u03c4\u03c1\u03ad\u03c0\u03b5\u03c4\u03b1\u03b9." ::msgcat::mcset el "Choose Directory" "\u0395\u03c0\u03b9\u03bb\u03bf\u03b3\u03ae \u039a\u03b1\u03c4\u03b1\u03bb\u03cc\u03b3\u03bf\u03c5" ::msgcat::mcset el "Clear" "\u039a\u03b1\u03b8\u03b1\u03c1\u03b9\u03c3\u03bc\u03cc\u03c2" ::msgcat::mcset el "Color" "\u03a7\u03c1\u03ce\u03bc\u03b1" ::msgcat::mcset el "Console" "\u039a\u03bf\u03bd\u03c3\u03cc\u03bb\u03b1" ::msgcat::mcset el "Copy" "\u0391\u03bd\u03c4\u03b9\u03b3\u03c1\u03b1\u03c6\u03ae" ::msgcat::mcset el "Cut" "\u0391\u03c0\u03bf\u03ba\u03bf\u03c0\u03ae" ::msgcat::mcset el "Delete" "\u0394\u03b9\u03b1\u03b3\u03c1\u03b1\u03c6\u03ae" ::msgcat::mcset el "Details >>" "\u039b\u03b5\u03c0\u03c4\u03bf\u03bc\u03ad\u03c1\u03b5\u03b9\u03b5\u03c2 >>" ::msgcat::mcset el "Directory \"%1\$s\" does not exist." \ "\u039f \u03ba\u03b1\u03c4\u03ac\u03bb\u03bf\u03b3\u03bf\u03c2 \"%1\$s\" \u03b4\u03b5\u03bd \u03c5\u03c0\u03ac\u03c1\u03c7\u03b5\u03b9." ::msgcat::mcset el "&Directory:" "&\u039a\u03b1\u03c4\u03ac\u03bb\u03bf\u03b3\u03bf\u03c2:" ::msgcat::mcset el "Error: %1\$s" "\u039b\u03ac\u03b8\u03bf\u03c2: %1\$s" ::msgcat::mcset el "Exit" "\u0388\u03be\u03bf\u03b4\u03bf\u03c2" ::msgcat::mcset el \ "File \"%1\$s\" already exists.\nDo you want to overwrite it?" \ "\u03a4\u03bf \u03b1\u03c1\u03c7\u03b5\u03af\u03bf \"%1\$s\" \u03ae\u03b4\u03b7 \u03c5\u03c0\u03ac\u03c1\u03c7\u03b5\u03b9.\n\u0398\u03ad\u03bb\u03b5\u03c4\u03b5 \u03bd\u03b1 \u03b5\u03c0\u03b9\u03ba\u03b1\u03bb\u03c5\u03c6\u03b8\u03b5\u03af;" ::msgcat::mcset el "File \"%1\$s\" already exists.\n\n" \ "\u03a4\u03bf \u03b1\u03c1\u03c7\u03b5\u03af\u03bf \"%1\$s\" \u03ae\u03b4\u03b7 \u03c5\u03c0\u03ac\u03c1\u03c7\u03b5\u03b9.\n\n" ::msgcat::mcset el "File \"%1\$s\" does not exist." \ "\u03a4\u03bf \u03b1\u03c1\u03c7\u03b5\u03af\u03bf \"%1\$s\" \u03b4\u03b5\u03bd \u03c5\u03c0\u03ac\u03c1\u03c7\u03b5\u03b9." ::msgcat::mcset el "File &name:" "\u038c&\u03bd\u03bf\u03bc\u03b1 \u03b1\u03c1\u03c7\u03b5\u03af\u03bf\u03c5:" ::msgcat::mcset el "File &names:" "\u038c&\u03bd\u03bf\u03bc\u03b1 \u03b1\u03c1\u03c7\u03b5\u03af\u03c9\u03bd:" ::msgcat::mcset el "Files of &type:" "\u0391\u03c1\u03c7\u03b5\u03af\u03b1 \u03c4\u03bf\u03c5 &\u03c4\u03cd\u03c0\u03bf\u03c5:" ::msgcat::mcset el "Fi&les:" "\u0391\u03c1\u03c7\u03b5\u03af\u03b1:" ::msgcat::mcset el "&Filter" "\u03a6\u03af\u03bb\u03c4\u03c1\u03bf" ::msgcat::mcset el "Fil&ter:" "\u03a6\u03af\u03bb\u03c4\u03c1\u03bf:" ::msgcat::mcset el "&Green" "\u03a0\u03c1\u03ac\u03c3\u03b9\u03bd\u03bf" ::msgcat::mcset el "Hi" "\u0393\u03b5\u03b9\u03b1" ::msgcat::mcset el "Hide Console" "\u0391\u03c0\u03cc\u03ba\u03c1\u03c5\u03c8\u03b7 \u03ba\u03bf\u03bd\u03c3\u03cc\u03bb\u03b1\u03c2" ::msgcat::mcset el "&Ignore" "\u0391\u03b3\u03bd\u03cc\u03b7\u03c3\u03b7" ::msgcat::mcset el "Invalid file name \"%1\$s\"." \ "\u0386\u03ba\u03c5\u03c1\u03bf \u03cc\u03bd\u03bf\u03bc\u03b1 \u03b1\u03c1\u03c7\u03b5\u03af\u03bf\u03c5 \"%1\$s\"." ::msgcat::mcset el "Log Files" "\u0391\u03c1\u03c7\u03b5\u03af\u03b1 \u039a\u03b1\u03c4\u03b1\u03b3\u03c1\u03b1\u03c6\u03ae\u03c2" ::msgcat::mcset el "&No" "\u038c\u03c7\u03b9" ::msgcat::mcset el "&OK" "\u0395\u03bd\u03c4\u03ac\u03be\u03b5\u03b9" ::msgcat::mcset el "&Ok" "\u0395\u03bd\u03c4\u03ac\u03be\u03b5\u03b9" ::msgcat::mcset el "Open" "\u0386\u03bd\u03bf\u03b9\u03b3\u03bc\u03b1" ::msgcat::mcset el "&Open" "\u0386\u03bd\u03bf\u03b9\u03b3\u03bc\u03b1" ::msgcat::mcset el "Open Multiple Files" \ "\u0386\u03bd\u03bf\u03b9\u03b3\u03bc\u03b1 \u03c0\u03bf\u03bb\u03bb\u03b1\u03c0\u03bb\u03ce\u03bd \u03b1\u03c1\u03c7\u03b5\u03af\u03c9\u03bd" ::msgcat::mcset el "Paste" "\u0395\u03c0\u03b9\u03ba\u03cc\u03bb\u03bb\u03b7\u03c3\u03b7" ::msgcat::mcset el "Quit" "\u0388\u03be\u03bf\u03b4\u03bf\u03c2" ::msgcat::mcset el "&Red" "\u039a\u03cc\u03ba\u03ba\u03b9\u03bd\u03bf" ::msgcat::mcset el "Replace existing file?" \ "\u0395\u03c0\u03b9\u03ba\u03ac\u03bb\u03c5\u03c8\u03b7 \u03c5\u03c0\u03ac\u03c1\u03c7\u03bf\u03bd\u03c4\u03bf\u03c2 \u03b1\u03c1\u03c7\u03b5\u03af\u03bf\u03c5;" ::msgcat::mcset el "&Retry" "\u03a0\u03c1\u03bf\u03c3\u03c0\u03ac\u03b8\u03b7\u03c3\u03b5 \u03be\u03b1\u03bd\u03ac" ::msgcat::mcset el "&Save" "\u0391\u03c0\u03bf\u03b8\u03ae\u03ba\u03b5\u03c5\u03c3\u03b7" ::msgcat::mcset el "Save As" "\u0391\u03c0\u03bf\u03b8\u03ae\u03ba\u03b5\u03c5\u03c3\u03b7 \u03c3\u03b1\u03bd" ::msgcat::mcset el "Save To Log" "\u0391\u03c0\u03bf\u03b8\u03ae\u03ba\u03b5\u03c5\u03c3\u03b7 \u03c3\u03c4\u03bf \u03b1\u03c1\u03c7\u03b5\u03af\u03bf \u03ba\u03b1\u03c4\u03b1\u03b3\u03c1\u03b1\u03c6\u03ae\u03c2" ::msgcat::mcset el "Select Log File" "\u0395\u03c0\u03b9\u03bb\u03bf\u03b3\u03ae \u03b1\u03c1\u03c7\u03b5\u03af\u03bf\u03c5 \u03ba\u03b1\u03c4\u03b1\u03b3\u03c1\u03b1\u03c6\u03ae\u03c2" ::msgcat::mcset el "Select a file to source" \ "\u0395\u03c0\u03b9\u03bb\u03ad\u03be\u03c4\u03b5 \u03b1\u03c1\u03c7\u03b5\u03af\u03bf \u03b3\u03b9\u03b1 \u03b5\u03ba\u03c4\u03ad\u03bb\u03b5\u03c3\u03b7" ::msgcat::mcset el "&Selection:" "\u0395\u03c0\u03b9\u03bb\u03bf\u03b3\u03ae:" ::msgcat::mcset el "Skip Messages" "\u0391\u03c0\u03bf\u03c6\u03c5\u03b3\u03ae \u03bc\u03c5\u03bd\u03b7\u03bc\u03ac\u03c4\u03c9\u03bd" ::msgcat::mcset el "Source..." "\u0395\u03ba\u03c4\u03ad\u03bb\u03b5\u03c3\u03b7..." ::msgcat::mcset el "Tcl Scripts" "Tcl Scripts" ::msgcat::mcset el "Tcl for Windows" "Tcl \u03b3\u03b9\u03b1 Windows" ::msgcat::mcset el "Text Files" "\u0391\u03c1\u03c7\u03b5\u03af\u03b1 \u039a\u03b5\u03b9\u03bc\u03ad\u03bd\u03bf\u03c5" ::msgcat::mcset el "&Yes" "\u039d\u03b1\u03b9" ::msgcat::mcset el "abort" "\u03c4\u03b5\u03c1\u03bc\u03b1\u03c4\u03b9\u03c3\u03bc\u03cc\u03c2" ::msgcat::mcset el "blue" "\u03bc\u03c0\u03bb\u03b5" ::msgcat::mcset el "cancel" "\u03b1\u03ba\u03cd\u03c1\u03c9\u03c3\u03b7" ::msgcat::mcset el "extension" "\u03b5\u03c0\u03ad\u03ba\u03c4\u03b1\u03c3\u03b7" ::msgcat::mcset el "extensions" "\u03b5\u03c0\u03b5\u03ba\u03c4\u03ac\u03c3\u03b5\u03b9\u03c2" ::msgcat::mcset el "green" "\u03c0\u03c1\u03ac\u03c3\u03b9\u03bd\u03bf" ::msgcat::mcset el "ignore" "\u03b1\u03b3\u03bd\u03cc\u03b7\u03c3\u03b7" ::msgcat::mcset el "ok" "\u03b5\u03bd\u03c4\u03ac\u03be\u03b5\u03b9" ::msgcat::mcset el "red" "\u03ba\u03cc\u03ba\u03ba\u03b9\u03bd\u03bf" ::msgcat::mcset el "retry" "\u03c0\u03c1\u03bf\u03c3\u03c0\u03ac\u03b8\u03b7\u03c3\u03b5 \u03be\u03b1\u03bd\u03ac" ::msgcat::mcset el "yes" "\u03bd\u03b1\u03b9" } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/msgs/en.msg0100644000000000001200000000475410153074437030200 0ustar rootadminnamespace eval ::tk { ::msgcat::mcset en "&Abort" ::msgcat::mcset en "About..." ::msgcat::mcset en "All Files" ::msgcat::mcset en "Application Error" ::msgcat::mcset en "&Blue" ::msgcat::mcset en "&Cancel" ::msgcat::mcset en "Cannot change to the directory \"%1\$s\".\nPermission denied." ::msgcat::mcset en "Choose Directory" ::msgcat::mcset en "Clear" ::msgcat::mcset en "Color" ::msgcat::mcset en "Console" ::msgcat::mcset en "Copy" ::msgcat::mcset en "Cut" ::msgcat::mcset en "Delete" ::msgcat::mcset en "Details >>" ::msgcat::mcset en "Directory \"%1\$s\" does not exist." ::msgcat::mcset en "&Directory:" ::msgcat::mcset en "Error: %1\$s" ::msgcat::mcset en "Exit" ::msgcat::mcset en "File \"%1\$s\" already exists.\nDo you want to overwrite it?" ::msgcat::mcset en "File \"%1\$s\" already exists.\n\n" ::msgcat::mcset en "File \"%1\$s\" does not exist." ::msgcat::mcset en "File &name:" ::msgcat::mcset en "File &names:" ::msgcat::mcset en "Files of &type:" ::msgcat::mcset en "Fi&les:" ::msgcat::mcset en "&Filter" ::msgcat::mcset en "Fil&ter:" ::msgcat::mcset en "&Green" ::msgcat::mcset en "Hi" ::msgcat::mcset en "Hide Console" ::msgcat::mcset en "&Ignore" ::msgcat::mcset en "Invalid file name \"%1\$s\"." ::msgcat::mcset en "Log Files" ::msgcat::mcset en "&No" ::msgcat::mcset en "&OK" ::msgcat::mcset en "Ok" ::msgcat::mcset en "Open" ::msgcat::mcset en "&Open" ::msgcat::mcset en "Open Multiple Files" ::msgcat::mcset en "Paste" ::msgcat::mcset en "Quit" ::msgcat::mcset en "&Red" ::msgcat::mcset en "Replace existing file?" ::msgcat::mcset en "&Retry" ::msgcat::mcset en "&Save" ::msgcat::mcset en "Save As" ::msgcat::mcset en "Save To Log" ::msgcat::mcset en "Select Log File" ::msgcat::mcset en "Select a file to source" ::msgcat::mcset en "&Selection:" ::msgcat::mcset en "Skip Messages" ::msgcat::mcset en "Source..." ::msgcat::mcset en "Tcl Scripts" ::msgcat::mcset en "Tcl for Windows" ::msgcat::mcset en "Text Files" ::msgcat::mcset en "&Yes" ::msgcat::mcset en "abort" ::msgcat::mcset en "blue" ::msgcat::mcset en "cancel" ::msgcat::mcset en "extension" ::msgcat::mcset en "extensions" ::msgcat::mcset en "green" ::msgcat::mcset en "ignore" ::msgcat::mcset en "ok" ::msgcat::mcset en "red" ::msgcat::mcset en "retry" ::msgcat::mcset en "yes" } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/msgs/en_gb.msg0100644000000000001200000000007710153074437030642 0ustar rootadminnamespace eval ::tk { ::msgcat::mcset en_gb Color Colour } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/msgs/eo.msg0100644000000000001200000000740510153074437030175 0ustar rootadminnamespace eval ::tk { ::msgcat::mcset eo "&Abort" "&\u0108esigo" ::msgcat::mcset eo "&About..." "Pri..." ::msgcat::mcset eo "All Files" "\u0108ioj dosieroj" ::msgcat::mcset eo "Application Error" "Aplikoerraro" ::msgcat::mcset eo "&Blue" "&Blua" ::msgcat::mcset eo "&Cancel" "&Rezignu" ::msgcat::mcset eo "Cannot change to the directory \"%1\$s\".\nPermission denied." "Neeble \u0109angi al dosierulon \"%1\$s\".\nVi ne rajtas tion." ::msgcat::mcset eo "Choose Directory" "Elektu Dosierujo" ::msgcat::mcset eo "&Clear" "&Klaru" ::msgcat::mcset eo "&Clear Console" "&Klaru konzolon" ::msgcat::mcset eo "Color" "Farbo" ::msgcat::mcset eo "Console" "Konzolo" ::msgcat::mcset eo "&Copy" "&Kopiu" ::msgcat::mcset eo "Cu&t" "&Enpo\u015digu" ::msgcat::mcset eo "&Delete" "&Forprenu" ::msgcat::mcset eo "Details >>" "Detaloj >>" ::msgcat::mcset eo "Directory \"%1\$s\" does not exist." "La dosierujo \"%1\$s\" ne ekzistas." ::msgcat::mcset eo "&Directory:" "&Dosierujo:" ::msgcat::mcset eo "&Edit" "&Redaktu" ::msgcat::mcset eo "Error: %1\$s" "Eraro: %1\$s" ::msgcat::mcset eo "E&xit" "&Eliru" ::msgcat::mcset eo "&File" "&Dosiero" ::msgcat::mcset eo "File \"%1\$s\" already exists.\nDo you want to overwrite it?" "La dosiero \"%1\$s\" jam ekzistas.\n\u0108u vi volas anstata\u00fbigi la dosieron?" ::msgcat::mcset eo "File \"%1\$s\" already exists.\n\n" "La dosiero \"%1\$s\" jam egzistas. \n\n" ::msgcat::mcset eo "File \"%1\$s\" does not exist." "La dosierp \"%1\$s\" ne estas." ::msgcat::mcset eo "File &name:" "Dosiero&nomo:" ::msgcat::mcset eo "File &names:" "Dosiero&nomoj:" ::msgcat::mcset eo "Files of &type:" "Dosieroj de &Typo:" ::msgcat::mcset eo "Fi&les:" "Do&sieroj:" ::msgcat::mcset eo "&Filter" "&Filtrilo" ::msgcat::mcset eo "Fil&ter:" "&Filtrilo:" ::msgcat::mcset eo "&Green" "&Verda" ::msgcat::mcset eo "&Help" "&Helpu" ::msgcat::mcset eo "Hi" "Saluton" ::msgcat::mcset eo "&Hide Console" "&Ka\u015du konzolon" ::msgcat::mcset eo "&Ignore" "&Ignoru" ::msgcat::mcset eo "Invalid file name \"%1\$s\"." "Malvalida dosieronomo \"%1\$s\"." ::msgcat::mcset eo "Log Files" "Protokolo" ::msgcat::mcset eo "&No" "&Ne" ::msgcat::mcset eo "OK" ::msgcat::mcset eo "Ok" ::msgcat::mcset eo "Open" "Malfermu" ::msgcat::mcset eo "&Open" "&Malfermu" ::msgcat::mcset eo "Open Multiple Files" "Melfermu multan dosierojn" ::msgcat::mcset eo "P&aste" "&Elpo\u015digi" ::msgcat::mcset eo "&Quit" "&Finigu" ::msgcat::mcset eo "&Red" "&Rosa" ::msgcat::mcset eo "Replace existing file?" "\u0108u anstata\u00fbu ekzistantan dosieron?" ::msgcat::mcset eo "&Retry" "&Ripetu" ::msgcat::mcset eo "&Save" "&Savu" ::msgcat::mcset eo "Save As" "Savu kiel" ::msgcat::mcset eo "Save To Log" "Savu en protokolon" ::msgcat::mcset eo "Select Log File" "Elektu prokolodosieron" ::msgcat::mcset eo "Select a file to source" "Elektu dosieron por interpreti" ::msgcat::mcset eo "&Selection:" "&Elekto:" ::msgcat::mcset eo "Skip Messages" "transsaltu pluajn mesa\u011dojn" ::msgcat::mcset eo "&Source..." "&Fontoprogramo..." ::msgcat::mcset eo "Tcl Scripts" "Tcl-skriptoj" ::msgcat::mcset eo "Tcl for Windows" "Tcl por vindoso" ::msgcat::mcset eo "Text Files" "Tekstodosierojn" ::msgcat::mcset eo "&Yes" "&Jes" ::msgcat::mcset eo "abort" "\u0109esigo" ::msgcat::mcset eo "blue" "blua" ::msgcat::mcset eo "cancel" "rezignu" ::msgcat::mcset eo "extension" "ekspansio" ::msgcat::mcset eo "extensions" "ekspansioj" ::msgcat::mcset eo "green" "verda" ::msgcat::mcset eo "ignore" "ignorieren" ::msgcat::mcset eo "red" "ru\u011da" ::msgcat::mcset eo "retry" "ripetu" ::msgcat::mcset eo "yes" "jes" } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/msgs/es.msg0100644000000000001200000000717010153074437030200 0ustar rootadminnamespace eval ::tk { ::msgcat::mcset es "&Abort" "&Abortar" ::msgcat::mcset es "About..." "Acerca de ..." ::msgcat::mcset es "All Files" "Todos los archivos" ::msgcat::mcset es "Application Error" "Error de la aplicaci\u00f3n" ::msgcat::mcset es "&Blue" "&Azul" ::msgcat::mcset es "&Cancel" "&Cancelar" ::msgcat::mcset es "Cannot change to the directory \"%1\$s\".\nPermission denied." "No es posible acceder al directorio \"%1\$s\".\nPermiso denegado." ::msgcat::mcset es "Choose Directory" "Elegir directorio" ::msgcat::mcset es "Clear" "Borrar" ::msgcat::mcset es "Color" "Color" ::msgcat::mcset es "Console" "Consola" ::msgcat::mcset es "Copy" "Copiar" ::msgcat::mcset es "Cut" "Cortar" ::msgcat::mcset es "Delete" "Borrar" ::msgcat::mcset es "Details >>" "Detalles >>" ::msgcat::mcset es "Directory \"%1\$s\" does not exist." "El directorio \"%1\$s\" no existe." ::msgcat::mcset es "&Directory:" "&Directorio:" ::msgcat::mcset es "Error: %1\$s" "Error: %1\$s" ::msgcat::mcset es "Exit" "Salir" ::msgcat::mcset es "File \"%1\$s\" already exists.\nDo you want to overwrite it?" "El archivo \"%1\$s\" ya existe.\nDesea sobreescribirlo?" ::msgcat::mcset es "File \"%1\$s\" already exists.\n\n" "El archivo \"%1\$s\" ya existe.\n\n" ::msgcat::mcset es "File \"%1\$s\" does not exist." "El archivo \"%1\$s\" no existe." ::msgcat::mcset es "File &name:" "&Nombre de archivo:" ::msgcat::mcset es "File &names:" "&Nombres de archivo:" ::msgcat::mcset es "Files of &type:" "Archivos de &tipo:" ::msgcat::mcset es "Fi&les:" "&Archivos:" ::msgcat::mcset es "&Filter" "&Filtro" ::msgcat::mcset es "Fil&ter:" "Fil&tro:" ::msgcat::mcset es "&Green" "&Verde" ::msgcat::mcset es "Hi" "Hola" ::msgcat::mcset es "Hide Console" "Esconder la consola" ::msgcat::mcset es "&Ignore" "&Ignorar" ::msgcat::mcset es "Invalid file name \"%1\$s\"." "Nombre de archivo inv\u00e1lido \"%1\$s\"." ::msgcat::mcset es "Log Files" "Ficheros de traza" ::msgcat::mcset es "&No" "&No" ::msgcat::mcset es "&OK" "&OK" ::msgcat::mcset es "Ok" "Ok" ::msgcat::mcset es "Open" "Abrir" ::msgcat::mcset es "&Open" "&Abrir" ::msgcat::mcset es "Open Multiple Files" "Abrir m\u00faltiples archivos" ::msgcat::mcset es "Paste" "Pegar" ::msgcat::mcset es "Quit" "Abandonar" ::msgcat::mcset es "&Red" "&Rojo" ::msgcat::mcset es "Replace existing file?" "Reemplazar el archivo existente?" ::msgcat::mcset es "&Retry" "&Reintentar" ::msgcat::mcset es "&Save" "&Salvar" ::msgcat::mcset es "Save As" "Salvar como" ::msgcat::mcset es "Save To Log" "Salvar al archivo de traza" ::msgcat::mcset es "Select Log File" "Elegir un archivo de traza" ::msgcat::mcset es "Select a file to source" "Seleccionar un archivo a evaluar" ::msgcat::mcset es "&Selection:" "&Selecci\u00f3n:" ::msgcat::mcset es "Skip Messages" "Omitir los mensajes" ::msgcat::mcset es "Source..." "Evaluar..." ::msgcat::mcset es "Tcl Scripts" "Scripts Tcl" ::msgcat::mcset es "Tcl for Windows" "Tcl para Windows" ::msgcat::mcset es "Text Files" "Archivos de texto" ::msgcat::mcset es "&Yes" "&S\u00ed" ::msgcat::mcset es "abort" "abortar" ::msgcat::mcset es "blue" "azul" ::msgcat::mcset es "cancel" "cancelar" ::msgcat::mcset es "extension" "extensi\u00f3n" ::msgcat::mcset es "extensions" "extensiones" ::msgcat::mcset es "green" "verde" ::msgcat::mcset es "ignore" "ignorar" ::msgcat::mcset es "ok" "ok" ::msgcat::mcset es "red" "rojo" ::msgcat::mcset es "retry" "reintentar" ::msgcat::mcset es "yes" "s\u00ed" } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/msgs/fr.msg0100644000000000001200000000721710153074437030202 0ustar rootadminnamespace eval ::tk { ::msgcat::mcset fr "&Abort" "&Annuler" ::msgcat::mcset fr "About..." "\u00c0 propos..." ::msgcat::mcset fr "All Files" "Tous les fichiers" ::msgcat::mcset fr "Application Error" "Erreur d'application" ::msgcat::mcset fr "&Blue" "&Bleu" ::msgcat::mcset fr "&Cancel" "&Annuler" ::msgcat::mcset fr "Cannot change to the directory \"%1\$s\".\nPermission denied." "Impossible d'acc\u00e9der au r\u00e9pertoire \"%1\$s\".\nPermission refus\u00e9e." ::msgcat::mcset fr "Choose Directory" "Choisir r\u00e9pertoire" ::msgcat::mcset fr "Clear" "Effacer" ::msgcat::mcset fr "Color" "Couleur" ::msgcat::mcset fr "Console" ::msgcat::mcset fr "Copy" "Copier" ::msgcat::mcset fr "Cut" "Couper" ::msgcat::mcset fr "Delete" "Effacer" ::msgcat::mcset fr "Details >>" "D\u00e9tails >>" ::msgcat::mcset fr "Directory \"%1\$s\" does not exist." "Le r\u00e9pertoire \"%1\$s\" n'existe pas." ::msgcat::mcset fr "&Directory:" "&R\u00e9pertoire:" ::msgcat::mcset fr "Error: %1\$s" "Erreur: %1\$s" ::msgcat::mcset fr "Exit" "Quitter" ::msgcat::mcset fr "File \"%1\$s\" already exists.\nDo you want to overwrite it?" "Le fichier \"%1\$s\" existe d\u00e9j\u00e0.\nVoulez-vous l'\u00e9craser?" ::msgcat::mcset fr "File \"%1\$s\" already exists.\n\n" "Le fichier \"%1\$s\" existe d\u00e9j\u00e0.\n\n" ::msgcat::mcset fr "File \"%1\$s\" does not exist." "Le fichier \"%1\$s\" n'existe pas." ::msgcat::mcset fr "File &name:" "&Nom de fichier:" ::msgcat::mcset fr "File &names:" "&Noms de fichiers:" ::msgcat::mcset fr "Files of &type:" "&Type de fichiers:" ::msgcat::mcset fr "Fi&les:" "Fich&iers:" ::msgcat::mcset fr "&Filter" "&Filtre" ::msgcat::mcset fr "Fil&ter:" "Fil&tre:" ::msgcat::mcset fr "&Green" "&Vert" ::msgcat::mcset fr "Hi" "Salut" ::msgcat::mcset fr "Hide Console" "Cacher la Console" ::msgcat::mcset fr "&Ignore" "&Ignorer" ::msgcat::mcset fr "Invalid file name \"%1\$s\"." "Nom de fichier invalide \"%1\$s\"." ::msgcat::mcset fr "Log Files" "Fichiers de trace" ::msgcat::mcset fr "&No" "&Non" ::msgcat::mcset fr "&OK" ::msgcat::mcset fr "Ok" ::msgcat::mcset fr "Open" "Ouvrir" ::msgcat::mcset fr "&Open" "&Ouvrir" ::msgcat::mcset fr "Open Multiple Files" "Ouvrir plusieurs fichiers" ::msgcat::mcset fr "Paste" "Coller" ::msgcat::mcset fr "Quit" "Quitter" ::msgcat::mcset fr "&Red" "&Rouge" ::msgcat::mcset fr "Replace existing file?" "Remplacer le fichier existant?" ::msgcat::mcset fr "&Retry" "&R\u00e9-essayer" ::msgcat::mcset fr "&Save" "&Sauvegarder" ::msgcat::mcset fr "Save As" "Sauvegarder sous" ::msgcat::mcset fr "Save To Log" "Sauvegarde au fichier de trace" ::msgcat::mcset fr "Select Log File" "Choisir un fichier de trace" ::msgcat::mcset fr "Select a file to source" "Choisir un fichier \u00e0 \u00e9valuer" ::msgcat::mcset fr "&Selection:" "&S\u00e9lection:" ::msgcat::mcset fr "Skip Messages" "Omettre les messages" ::msgcat::mcset fr "Source..." "\u00c9valuer..." ::msgcat::mcset fr "Tcl Scripts" "Scripts Tcl" ::msgcat::mcset fr "Tcl for Windows" "Tcl pour Windows" ::msgcat::mcset fr "Text Files" "Fichiers texte" ::msgcat::mcset fr "&Yes" "&Oui" ::msgcat::mcset fr "abort" "abandonner" ::msgcat::mcset fr "blue" "bleu" ::msgcat::mcset fr "cancel" "annuler" ::msgcat::mcset fr "extension" ::msgcat::mcset fr "extensions" ::msgcat::mcset fr "green" "vert" ::msgcat::mcset fr "ignore" "ignorer" ::msgcat::mcset fr "ok" ::msgcat::mcset fr "red" "rouge" ::msgcat::mcset fr "retry" "r\u00e9essayer" ::msgcat::mcset fr "yes" "oui" } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/msgs/it.msg0100644000000000001200000000674510153074437030214 0ustar rootadminnamespace eval ::tk { ::msgcat::mcset it "&Abort" "&Interrompi" ::msgcat::mcset it "About..." "Informazioni..." ::msgcat::mcset it "All Files" "Tutti i file" ::msgcat::mcset it "Application Error" "Errore dell' applicazione" ::msgcat::mcset it "&Blue" "&Blu" ::msgcat::mcset it "&Cancel" "&Annulla" ::msgcat::mcset it "Cannot change to the directory \"%1\$s\".\nPermission denied." "Impossibile accedere alla directory \"%1\$s\".\nPermesso negato." ::msgcat::mcset it "Choose Directory" "Scegli una directory" ::msgcat::mcset it "Clear" "Azzera" ::msgcat::mcset it "Color" "Colore" ::msgcat::mcset it "Console" ::msgcat::mcset it "Copy" "Copia" ::msgcat::mcset it "Cut" "Taglia" ::msgcat::mcset it "Delete" "Cancella" ::msgcat::mcset it "Details >>" "Dettagli >>" ::msgcat::mcset it "Directory \"%1\$s\" does not exist." "La directory \"%1\$s\" non esiste." ::msgcat::mcset it "&Directory:" ::msgcat::mcset it "Error: %1\$s" "Errore: %1\$s" ::msgcat::mcset it "Exit" "Esci" ::msgcat::mcset it "File \"%1\$s\" already exists.\nDo you want to overwrite it?" "Il file \"%1\$s\" esiste gi\u00e0.\nVuoi sovrascriverlo?" ::msgcat::mcset it "File \"%1\$s\" already exists.\n\n" "Il file \"%1\$s\" esiste gi\u00e0.\n\n" ::msgcat::mcset it "File \"%1\$s\" does not exist." "Il file \"%1\$s\" non esiste." ::msgcat::mcset it "File &name:" "&Nome del file:" ::msgcat::mcset it "File &names:" "&Nomi dei file:" ::msgcat::mcset it "Files of &type:" "File di &tipo:" ::msgcat::mcset it "Fi&les:" "Fi&le:" ::msgcat::mcset it "&Filter" "&Filtro" ::msgcat::mcset it "Fil&ter:" "Fil&tro:" ::msgcat::mcset it "&Green" "&Verde" ::msgcat::mcset it "Hi" "Salve" ::msgcat::mcset it "Hide Console" "Nascondi la console" ::msgcat::mcset it "&Ignore" "&Ignora" ::msgcat::mcset it "Invalid file name \"%1\$s\"." "Nome di file non valido \"%1\$s\"." ::msgcat::mcset it "Log Files" "File di log" ::msgcat::mcset it "&No" ::msgcat::mcset it "&OK" ::msgcat::mcset it "Ok" ::msgcat::mcset it "&Open" "A&pri" ::msgcat::mcset it "Open" "Apri" ::msgcat::mcset it "Open Multiple Files" "Apri file multipli" ::msgcat::mcset it "Paste" "Incolla" ::msgcat::mcset it "Quit" "Esci" ::msgcat::mcset it "&Red" "&Rosso" ::msgcat::mcset it "Replace existing file?" "Sostituisci il file esistente?" ::msgcat::mcset it "&Retry" "&Riprova" ::msgcat::mcset it "&Save" "&Salva" ::msgcat::mcset it "Save As" "Salva come" ::msgcat::mcset it "Save To Log" "Salva il log" ::msgcat::mcset it "Select Log File" "Scegli un file di log" ::msgcat::mcset it "Select a file to source" "Scegli un file da eseguire" ::msgcat::mcset it "&Selection:" "&Selezione:" ::msgcat::mcset it "Skip Messages" "Salta i messaggi" ::msgcat::mcset it "Source..." "Esegui..." ::msgcat::mcset it "Tcl Scripts" "Script Tcl" ::msgcat::mcset it "Tcl for Windows" "Tcl per Windows" ::msgcat::mcset it "Text Files" "File di testo" ::msgcat::mcset it "&Yes" "&S\u00ec" ::msgcat::mcset it "abort" "interrompi" ::msgcat::mcset it "blue" "blu" ::msgcat::mcset it "cancel" "annulla" ::msgcat::mcset it "extension" "estensione" ::msgcat::mcset it "extensions" "estensioni" ::msgcat::mcset it "green" "verde" ::msgcat::mcset it "ignore" "ignora" ::msgcat::mcset it "ok" ::msgcat::mcset it "red" "rosso" ::msgcat::mcset it "retry" "riprova" ::msgcat::mcset it "yes" "s\u00ec" } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/msgs/nl.msg0100644000000000001200000001566710153074437030214 0ustar rootadminnamespace eval ::tk { ::msgcat::mcset nl "\"%1\$s\" must be an absolute pathname" "\"%1\$s\" moet een absolute pad-naam zijn" ::msgcat::mcset nl "%1\$s is not a toplevel window" "%1\$s is geen toplevel window" ::msgcat::mcset nl ", or" ", of" ::msgcat::mcset nl "-default, -icon, -message, -parent, -title, or -type" "-default, -icon, -message, -parent, -title, of -type" ::msgcat::mcset nl "-initialdir, -mustexist, -parent, or -title" "-initialdir, -mustexist, -parent, of -title" ::msgcat::mcset nl "&Abort" "&Afbreken" ::msgcat::mcset nl "About..." "Over..." ::msgcat::mcset nl "All Files" "Alle Bestanden" ::msgcat::mcset nl "Application Error" "Toepassingsfout" ::msgcat::mcset nl "&Blue" "&Blauw" ::msgcat::mcset nl "&Cancel" "&Annuleren" ::msgcat::mcset nl "Cannot change to the directory \"%1\$s\".\nPermission denied." "Kan niet naar map \"%1\$s\" gaan.\nU heeft hiervoor geen toestemming." ::msgcat::mcset nl "Choose Directory" "Kies map" ::msgcat::mcset nl "Clear" "Wissen" ::msgcat::mcset nl "Clear entry, Press OK; Enter %1\$s, press OK" "Wis veld, Druk op OK; typ %1\$s in, druk op OK" ::msgcat::mcset nl "&Clear Console" "&Wis Console" ::msgcat::mcset nl "Color" "Kleur" ::msgcat::mcset nl "Console" ::msgcat::mcset nl "Copy" "Kopi\u00ebren" ::msgcat::mcset nl "Cut" "Knippen" ::msgcat::mcset nl "Delete" "Wissen" ::msgcat::mcset nl "Details" ::msgcat::mcset nl "Details >>" ::msgcat::mcset nl "Directory \"%1\$s\" does not exist." "Map \"%1\$s\" bestaat niet." ::msgcat::mcset nl "&Directory:" "&Map:" ::msgcat::mcset nl "Edit" "Bewerken" ::msgcat::mcset nl "Enter \"%1\$s\", press OK" "Typ \"%1\$s\", druk op OK" ::msgcat::mcset nl "Enter \"%1\$s\", press OK, enter \"%2\$s\", press OK" "Typ \"%1\$s\", druk op OK, typ \"%2\$s\", druk op OK" ::msgcat::mcset nl "Error: %1\$s" "Fout: %1\$s" ::msgcat::mcset nl "Exit" "Be\u00ebindigen" ::msgcat::mcset nl "File" "Bestand" ::msgcat::mcset nl "File \"%1\$s\" already exists.\n\n" "Bestand \"%1\$s\" bestaat al.\n\n" ::msgcat::mcset nl "File \"%1\$s\" already exists.\nDo you want to overwrite it?" "Bestand \"%1\$s\" bestaat al.\nWilt u het overschrijven?" ::msgcat::mcset nl "File \"%1\$s\" does not exist." "Bestand \"%1\$s\" bestaat niet." ::msgcat::mcset nl "File &name:" "Bestands&naam:" ::msgcat::mcset nl "File &names:" "Bestands&namen:" ::msgcat::mcset nl "Files of &type:" "Bestanden van het &type:" ::msgcat::mcset nl "Fi&les:" "&Bestanden:" ::msgcat::mcset nl "&Filter" ::msgcat::mcset nl "Fil&ter:" ::msgcat::mcset nl "&Green" "&Groen" ::msgcat::mcset nl "Hi" "H\u00e9" ::msgcat::mcset nl "Hide Console" "Verberg Console" ::msgcat::mcset nl "&Ignore" "&Negeren" ::msgcat::mcset nl "Invalid file name \"%1\$s\"." "Ongeldige bestandsnaam \"%1\$s\"." ::msgcat::mcset nl "Log Files" "Log Bestanden" ::msgcat::mcset nl "&No" "&Nee" ::msgcat::mcset nl "&OK" ::msgcat::mcset nl "Ok" ::msgcat::mcset nl "&Open" "&Openen" ::msgcat::mcset nl "Open" "Openen" ::msgcat::mcset nl "Open Multiple Files" "Open meerdere bestanden" ::msgcat::mcset nl "Paste" "Plakken" ::msgcat::mcset nl "Please press %1\$s" "Druk op %1\$s, A.U.B." ::msgcat::mcset nl "Please press ok" "Druk op ok, A.U.B." ::msgcat::mcset nl "Press Cancel" "Druk op Annuleren" ::msgcat::mcset nl "Press Ok" "Druk op Ok" ::msgcat::mcset nl "Quit" "Stoppen" ::msgcat::mcset nl "&Red" "&Rood" ::msgcat::mcset nl "Replace existing file?" "Vervang bestaand bestand?" ::msgcat::mcset nl "&Retry" "&Herhalen" ::msgcat::mcset nl "&Save" "Op&slaan" ::msgcat::mcset nl "Save As" "Opslaan als" ::msgcat::mcset nl "Save To Log" "Opslaan naar Log" ::msgcat::mcset nl "Select Log File" "Selecteer Log bestand" ::msgcat::mcset nl "Select a file to source" "Selecteer bronbestand" ::msgcat::mcset nl "&Selection:" "&Selectie:" ::msgcat::mcset nl "Skip Messages" "Berichten overslaan" ::msgcat::mcset nl "Source..." "Bron..." ::msgcat::mcset nl "Tcl Scripts" ::msgcat::mcset nl "Tcl for Windows" "Tcl voor Windows" ::msgcat::mcset nl "Text Files" "Tekstbestanden" ::msgcat::mcset nl "&Yes" "&Ja" ::msgcat::mcset nl "abort" "afbreken" ::msgcat::mcset nl "abort, retry, ignore, ok, cancel, no, or yes" "afbreken, opnieuw, negeren, ok, annuleren, nee, of ja" ::msgcat::mcset nl "abortretryignore, ok, okcancel, retrycancel, yesno, or yesnocancel" "abortretryignore, ok, okcancel, retrycancel, yesno, of yesnocancel" ::msgcat::mcset nl "bad %1\$s value \"%2\$s\": must be %3\$s" "verkeerde %1\$s waarde \"%2\$s\": moet zijn %3\$s" ::msgcat::mcset nl "bad file type \"%1\$s\", should be" "verkeerd bestandstype \"%1\$s\", moet zijn" ::msgcat::mcset nl "bad option \"%1\$s\": should be %2\$s" "verkeerde optie \"%1\$s\": moet zijn %2\$s" ::msgcat::mcset nl "bad window path name \"%1\$s\"" "verkeerde window-padnaam \"%1\$s\"" ::msgcat::mcset nl "blue" "blauw" ::msgcat::mcset nl "can't post %1\$s: it isn't a descendant of %2\$s (this is a new requirement in Tk versions 3.0 and later)" "kan %1\$s niet verzenden: het is geen afstammeling van %2\$s (dit is een nieuwe eis in Tk versies 3.0 en later)" ::msgcat::mcset nl "cancel" "annuleren" ::msgcat::mcset nl "default button index greater than number of buttons specified for tk_dialog" "default knop index is groter dan het aantal knoppen beschikbaar voor tk_dialog" ::msgcat::mcset nl "display name to use (current one otherwise)" "te gebruiken schermnaam (anders huidige scherm)" ::msgcat::mcset nl "error, info, question, or warning" "error, info, question, of warning" ::msgcat::mcset nl "extension" ::msgcat::mcset nl "extensions" ::msgcat::mcset nl "focus group \"%1\$s\" doesn't exist" "focusgroep \"%1\$s\" bestaat niet" ::msgcat::mcset nl "green" "groen" ::msgcat::mcset nl "history event %1\$s" ::msgcat::mcset nl "ignore" "negeren" ::msgcat::mcset nl "invalid default button \"%1\$s\"" "ongeldige default knop \"%1\$s\"" ::msgcat::mcset nl "macType" ::msgcat::mcset nl "macTypes" ::msgcat::mcset nl "must specify a background color" "een achtergrondkleur is verplicht" ::msgcat::mcset nl "name of the slave interpreter" "naam van de slaaf-interpreter" ::msgcat::mcset nl "no winfo screen . nor env(DISPLAY)" "geen winfo scherm . noch env(DISPLAY)" ::msgcat::mcset nl "ok" ::msgcat::mcset nl "red" "rood" ::msgcat::mcset nl "retry" "opnieuw" ::msgcat::mcset nl "should contain 5 or 4 elements" "moet 4 of 5 elementen bevatten" ::msgcat::mcset nl "spec" ::msgcat::mcset nl "tk_chooseDirectory command" "tk_chooseDirectory opdracht" ::msgcat::mcset nl "tk_chooseDirectory command, cancel gives null" "tk_chooseDirectory opdracht, annuleren geeft lege waarde" ::msgcat::mcset nl "tk_chooseDirectory command, initialdir" "tk_chooseDirectory opdracht, initi\u00eble map" ::msgcat::mcset nl "yes" "ja" } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/msgs/pl.msg0100644000000000001200000000755410153074437030212 0ustar rootadminnamespace eval ::tk { ::msgcat::mcset pl "&Abort" "&Anuluj" ::msgcat::mcset pl "&About..." "O Programie..." ::msgcat::mcset pl "All Files" "Wszystkie pliki" ::msgcat::mcset pl "Application Error" "Bl\u0105d w Programie" ::msgcat::mcset pl "&Blue" "&Niebieski" ::msgcat::mcset pl "&Cancel" "&Anuluj" ::msgcat::mcset pl "Cannot change to the directory \"%1\$s\".\nPermission denied." "Katalog \"%1\$s\" nie mo\u017ce zosta\u0107 odczytany lub nie istnieje." ::msgcat::mcset pl "Choose Directory" "Wybierz katalog" ::msgcat::mcset pl "&Clear" "&Wyczy\u015b\u0107" ::msgcat::mcset pl "&Clear Console" "&Wyczy\u015b\u0107 konsol\u0119" ::msgcat::mcset pl "Color" "Kolor" ::msgcat::mcset pl "Console" "Konsola" ::msgcat::mcset pl "&Copy" "&Kopiuj" ::msgcat::mcset pl "Cu&t" "&Wytnij" ::msgcat::mcset pl "&Delete" "&Usu\u0144" ::msgcat::mcset pl "Details >>" "Detale >>" ::msgcat::mcset pl "Directory \"%1\$s\" does not exist." "Katalog \"%1\$s\" nie istniej." ::msgcat::mcset pl "&Directory:" "&Katalog:" ::msgcat::mcset pl "&Edit" "&Edytuj" ::msgcat::mcset pl "Error: %1\$s" "B\u0142\u0105d: %1\$s" ::msgcat::mcset pl "E&xit" "&Zako\u0144cz" ::msgcat::mcset pl "&File" "&Plik" ::msgcat::mcset pl "File \"%1\$s\" already exists.\nDo you want to overwrite it?" "Plik \"%1\$s\" ju\u017c istnieje.\nCzy chcesz go zast\u0105pi\u0107?" ::msgcat::mcset pl "File \"%1\$s\" already exists.\n\n" "Plik \"%1\$s\" ju\u017c istnieje. \n\n" ::msgcat::mcset pl "File \"%1\$s\" does not exist." "Plik \"%1\$s\" nie istnieje." ::msgcat::mcset pl "File &name:" "Nazwa &pliku:" ::msgcat::mcset pl "File &names:" "Nazwy &plik\u00f3w:" ::msgcat::mcset pl "Files of &type:" "Pliki &typu:" ::msgcat::mcset pl "Fi&les:" "Pli&ki:" ::msgcat::mcset pl "&Filter" "&Filter" ::msgcat::mcset pl "Fil&ter:" "&Filter:" ::msgcat::mcset pl "&Green" "&Zielony" ::msgcat::mcset pl "&Help" "&Pomoc" ::msgcat::mcset pl "Hi" "Witaj" ::msgcat::mcset pl "&Hide Console" "&Schowaj konsol\u0119" ::msgcat::mcset pl "&Ignore" "&Ignoruj" ::msgcat::mcset pl "Invalid file name \"%1\$s\"." "Niew\u0142a\u015bciwa nazwa pliku \"%1\$s\"." ::msgcat::mcset pl "Log Files" "Protoko\u0142uj" ::msgcat::mcset pl "&No" "&Nie" ::msgcat::mcset pl "OK" ::msgcat::mcset pl "Ok" ::msgcat::mcset pl "Open" "Wczytaj" ::msgcat::mcset pl "&Open" "&Wczytaj" ::msgcat::mcset pl "Open Multiple Files" "Wczytuj wiele plik\u00f3w" ::msgcat::mcset pl "P&aste" "&Wklej" ::msgcat::mcset pl "&Quit" "&Zako\u0144cz" ::msgcat::mcset pl "&Red" "&Czerwonz" ::msgcat::mcset pl "Replace existing file?" "Czy zost\u0105pi\u0107 instniej\u0105cy plik?" ::msgcat::mcset pl "&Retry" "&Powt\u00f3rz" ::msgcat::mcset pl "&Save" "&Zapisz" ::msgcat::mcset pl "Save As" "Zapisz jako" ::msgcat::mcset pl "Save To Log" "Wpisz do protoko\u0142u" ::msgcat::mcset pl "Select Log File" "Wybierz plik proko\u0142u" ::msgcat::mcset pl "Select a file to source" "Wybierz plik do wykonania" ::msgcat::mcset pl "&Selection:" "&Wyb\u00f3r:" ::msgcat::mcset pl "Skip Messages" "Omi\u0144 pozosta\u0142e komunikaty" ::msgcat::mcset pl "&Source..." "&Kod \u017ar\u00f3d\u0142owy..." ::msgcat::mcset pl "Tcl Scripts" "Tcl-skrypty" ::msgcat::mcset pl "Tcl for Windows" "Tcl dla Okienek (Windows)" ::msgcat::mcset pl "Text Files" "Pliki Tekstowe" ::msgcat::mcset pl "&Yes" "&Tak" ::msgcat::mcset pl "abort" "zako\u0144cz" ::msgcat::mcset pl "blue" "niebieski" ::msgcat::mcset pl "cancel" "anuluj" ::msgcat::mcset pl "extension" "rozszerzenie" ::msgcat::mcset pl "extensions" "rozszerzenia" ::msgcat::mcset pl "green" "zielony" ::msgcat::mcset pl "ignore" "ignoruj" ::msgcat::mcset pl "red" "czerwony" ::msgcat::mcset pl "retry" "potw\u00f3rz" ::msgcat::mcset pl "yes" "tak" } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/msgs/ru.msg0100644000000000001200000001570110153074437030216 0ustar rootadminnamespace eval ::tk { ::msgcat::mcset ru "&Abort" "&\u041e\u0442\u043c\u0435\u043d\u0438\u0442\u044c" ::msgcat::mcset ru "About..." "\u041f\u0440\u043e..." ::msgcat::mcset ru "All Files" "\u0412\u0441\u0435 \u0444\u0430\u0439\u043b\u044b" ::msgcat::mcset ru "Application Error" "\u041e\u0448\u0438\u0431\u043a\u0430 \u0432 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0435" ::msgcat::mcset ru "&Blue" " &\u0413\u043e\u043b\u0443\u0431\u043e\u0439" ::msgcat::mcset ru "&Cancel" "\u041e\u0442&\u043c\u0435\u043d\u0430" ::msgcat::mcset ru "Cannot change to the directory \"%1\$s\".\nPermission denied." \ "\u041d\u0435 \u043c\u043e\u0433\u0443 \u043f\u0435\u0440\u0435\u0439\u0442\u0438 \u0432 \u043a\u0430\u0442\u0430\u043b\u043e\u0433 \"%1\$s\".\n\u041d\u0435\u0434\u043e\u0441\u0442\u0430\u0442\u043e\u0447\u043d\u043e \u043f\u0440\u0430\u0432 \u0434\u043e\u0441\u0442\u0443\u043f\u0430" ::msgcat::mcset ru "Choose Directory" "\u0412\u044b\u0431\u0435\u0440\u0438\u0442\u0435 \u043a\u0430\u0442\u0430\u043b\u043e\u0433" ::msgcat::mcset ru "Clear" "\u041e\u0447\u0438\u0441\u0442\u0438\u0442\u044c" ::msgcat::mcset ru "Color" "\u0426\u0432\u0435\u0442" ::msgcat::mcset ru "Console" "\u041a\u043e\u043d\u0441\u043e\u043b\u044c" ::msgcat::mcset ru "Copy" "\u041a\u043e\u043f\u0438\u0440\u043e\u0432\u0430\u0442\u044c" ::msgcat::mcset ru "Cut" "\u0412\u044b\u0440\u0435\u0437\u0430\u0442\u044c" ::msgcat::mcset ru "Delete" "\u0423\u0434\u0430\u043b\u0438\u0442\u044c" ::msgcat::mcset ru "Details >>" "\u041f\u043e\u0434\u0440\u043e\u0431\u043d\u0435\u0435 >>" ::msgcat::mcset ru "Directory \"%1\$s\" does not exist." "\u041a\u0430\u0442\u0430\u043b\u043e\u0433\u0430 \"%1\$s\" \u043d\u0435 \u0441\u0443\u0449\u0435\u0441\u0442\u0432\u0443\u0435\u0442." ::msgcat::mcset ru "&Directory:" "&\u041a\u0430\u0442\u0430\u043b\u043e\u0433:" ::msgcat::mcset ru "Error: %1\$s" "\u041e\u0448\u0438\u0431\u043a\u0430: %1\$s" ::msgcat::mcset ru "Exit" "\u0412\u044b\u0445\u043e\u0434" ::msgcat::mcset ru "File \"%1\$s\" already exists.\nDo you want to overwrite it?" \ "\u0424\u0430\u0439\u043b \"%1\$s\" \u0443\u0436\u0435 \u0441\u0443\u0449\u0435\u0441\u0442\u0432\u0443\u0435\u0442.\n\u0417\u0430\u043c\u0435\u043d\u0438\u0442\u044c \u0435\u0433\u043e?" ::msgcat::mcset ru "File \"%1\$s\" already exists.\n\n" "\u0424\u0430\u0439\u043b \"%1\$s\" \u0443\u0436\u0435 \u0441\u0443\u0449\u0435\u0441\u0442\u0432\u0443\u0435\u0442.\n\n" ::msgcat::mcset ru "File \"%1\$s\" does not exist." "\u0424\u0430\u0439\u043b \"%1\$s\" \u043d\u0435 \u043d\u0430\u0439\u0434\u0435\u043d." ::msgcat::mcset ru "File &name:" "&\u0418\u043c\u044f \u0444\u0430\u0439\u043b\u0430:" ::msgcat::mcset ru "File &names:" "&\u0418\u043c\u0435\u043d\u0430 \u0444\u0430\u0439\u043b\u043e\u0432:" ::msgcat::mcset ru "Files of &type:" "&\u0422\u0438\u043f \u0444\u0430\u0439\u043b\u043e\u0432:" ::msgcat::mcset ru "Fi&les:" "\u0424\u0430\u0439&\u043b\u044b:" ::msgcat::mcset ru "&Filter" "&\u0424\u0438\u043b\u044c\u0442\u0440" ::msgcat::mcset ru "Fil&ter:" "\u0424\u0438\u043b\u044c&\u0442\u0440:" ::msgcat::mcset ru "&Green" " &\u0417\u0435\u043b\u0435\u043d\u044b\u0439" ::msgcat::mcset ru "Hi" "\u041f\u0440\u0438\u0432\u0435\u0442" ::msgcat::mcset ru "Hide Console" "\u0421\u043f\u0440\u044f\u0442\u0430\u0442\u044c \u043a\u043e\u043d\u0441\u043e\u043b\u044c" ::msgcat::mcset ru "&Ignore" "&\u0418\u0433\u043d\u043e\u0440\u0438\u0440\u043e\u0432\u0430\u0442\u044c" ::msgcat::mcset ru "Invalid file name \"%1\$s\"." "\u041d\u0435\u0432\u0435\u0440\u043d\u043e\u0435 \u0438\u043c\u044f \u0444\u0430\u0439\u043b\u0430 \"%1\$s\"." ::msgcat::mcset ru "Log Files" "\u0424\u0430\u0439\u043b\u044b \u0436\u0443\u0440\u043d\u0430\u043b\u0430" ::msgcat::mcset ru "&No" "&\u041d\u0435\u0442" ::msgcat::mcset ru "&OK" "&\u041e\u041a" ::msgcat::mcset ru "Ok" "\u0414\u0430" ::msgcat::mcset ru "Open" "\u041e\u0442\u043a\u0440\u044b\u0442\u044c" ::msgcat::mcset ru "&Open" "&\u041e\u0442\u043a\u0440\u044b\u0442\u044c" ::msgcat::mcset ru "Open Multiple Files" "\u041e\u0442\u043a\u0440\u044b\u0442\u044c \u043d\u0435\u0441\u043a\u043e\u043b\u044c\u043a\u043e \u0444\u0430\u0439\u043b\u043e\u0432" ::msgcat::mcset ru "Paste" "\u0412\u0441\u0442\u0430\u0432\u0438\u0442\u044c" ::msgcat::mcset ru "Quit" "\u0412\u044b\u0445\u043e\u0434" ::msgcat::mcset ru "&Red" " &\u041a\u0440\u0430\u0441\u043d\u044b\u0439" ::msgcat::mcset ru "Replace existing file?" "\u0417\u0430\u043c\u0435\u043d\u0438\u0442\u044c \u0441\u0443\u0449\u0435\u0441\u0442\u0432\u0443\u044e\u0449\u0438\u0439 \u0444\u0430\u0439\u043b?" ::msgcat::mcset ru "&Retry" "&\u041f\u043e\u0432\u0442\u043e\u0440\u0438\u0442\u044c" ::msgcat::mcset ru "&Save" "&\u0421\u043e\u0445\u0440\u0430\u043d\u0438\u0442\u044c" ::msgcat::mcset ru "Save As" "\u0421\u043e\u0445\u0440\u0430\u043d\u0438\u0442\u044c \u043a\u0430\u043a" ::msgcat::mcset ru "Save To Log" "\u0421\u043e\u0445\u0440\u0430\u043d\u0438\u0442\u044c \u0432 \u0436\u0443\u0440\u043d\u0430\u043b" ::msgcat::mcset ru "Select Log File" "\u0412\u044b\u0431\u0440\u0430\u0442\u044c \u0436\u0443\u0440\u043d\u0430\u043b" ::msgcat::mcset ru "Select a file to source" "\u0412\u044b\u0431\u0435\u0440\u0438\u0442\u0435 \u0444\u0430\u0439\u043b \u0434\u043b\u044f \u0438\u043d\u0442\u0435\u0440\u043f\u0440\u0435\u0442\u0430\u0446\u0438\u0438" ::msgcat::mcset ru "&Selection:" "&Selection:" ::msgcat::mcset ru "Skip Messages" "\u041f\u0440\u043e\u043f\u0443\u0441\u0442\u0438\u0442\u044c \u0441\u043e\u043e\u0431\u0449\u0435\u043d\u0438\u044f" ::msgcat::mcset ru "Source..." "\u0418\u043d\u0442\u0435\u0440\u043f\u0440\u0435\u0442\u0438\u0440\u043e\u0432\u0430\u0442\u044c \u0444\u0430\u0439\u043b..." ::msgcat::mcset ru "Tcl Scripts" "\u041f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0430 \u043d\u0430 \u044f\u0437\u044b\u043a\u0435 TCL" ::msgcat::mcset ru "Tcl for Windows" "TCL \u0434\u043b\u044f Windows" ::msgcat::mcset ru "Text Files" "\u0422\u0435\u043a\u0441\u0442\u043e\u0432\u044b\u0435 \u0444\u0430\u0439\u043b\u044b" ::msgcat::mcset ru "&Yes" "&\u0414\u0430" ::msgcat::mcset ru "abort" "\u043e\u0442\u043c\u0435\u043d\u0430" ::msgcat::mcset ru "blue" " \u0433\u043e\u043b\u0443\u0431\u043e\u0439" ::msgcat::mcset ru "cancel" "\u043e\u0442\u043c\u0435\u043d\u0430" ::msgcat::mcset ru "extension" "\u0440\u0430\u0441\u0448\u0438\u0440\u0435\u043d\u0438\u0435" ::msgcat::mcset ru "extensions" "\u0440\u0430\u0441\u0448\u0438\u0440\u0435\u043d\u0438\u044f" ::msgcat::mcset ru "green" " \u0437\u0435\u043b\u0435\u043d\u044b\u0439" ::msgcat::mcset ru "ignore" "\u043f\u0440\u043e\u043f\u0443\u0441\u0442\u0438\u0442\u044c" ::msgcat::mcset ru "ok" "\u043e\u043a" ::msgcat::mcset ru "red" " \u043a\u0440\u0430\u0441\u043d\u044b\u0439" ::msgcat::mcset ru "retry" "\u043f\u043e\u0432\u0442\u043e\u0440\u0438\u0442\u044c" ::msgcat::mcset ru "yes" "\u0434\u0430" } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/obsolete.tcl0100644000000000001200000000144310153074437030425 0ustar rootadmin# obsolete.tcl -- # # This file contains obsolete procedures that people really shouldn't # be using anymore, but which are kept around for backward compatibility. # # RCS: @(#) $Id: obsolete.tcl,v 1.2 1998/09/14 18:23:24 stanton Exp $ # # Copyright (c) 1994 The Regents of the University of California. # Copyright (c) 1994 Sun Microsystems, Inc. # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # # The procedures below are here strictly for backward compatibility with # Tk version 3.6 and earlier. The procedures are no longer needed, so # they are no-ops. You should not use these procedures anymore, since # they may be removed in some future release. proc tk_menuBar args {} proc tk_bindForTraversal args {} Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/optMenu.tcl0100644000000000001200000000317310153074437030242 0ustar rootadmin# optMenu.tcl -- # # This file defines the procedure tk_optionMenu, which creates # an option button and its associated menu. # # RCS: @(#) $Id: optMenu.tcl,v 1.4 2001/08/01 16:21:11 dgp Exp $ # # Copyright (c) 1994 The Regents of the University of California. # Copyright (c) 1994 Sun Microsystems, Inc. # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # # ::tk_optionMenu -- # This procedure creates an option button named $w and an associated # menu. Together they provide the functionality of Motif option menus: # they can be used to select one of many values, and the current value # appears in the global variable varName, as well as in the text of # the option menubutton. The name of the menu is returned as the # procedure's result, so that the caller can use it to change configuration # options on the menu or otherwise manipulate it. # # Arguments: # w - The name to use for the menubutton. # varName - Global variable to hold the currently selected value. # firstValue - First of legal values for option (must be >= 1). # args - Any number of additional values. proc ::tk_optionMenu {w varName firstValue args} { upvar #0 $varName var if {![info exists var]} { set var $firstValue } menubutton $w -textvariable $varName -indicatoron 1 -menu $w.menu \ -relief raised -bd 2 -highlightthickness 2 -anchor c \ -direction flush menu $w.menu -tearoff 0 $w.menu add radiobutton -label $firstValue -variable $varName foreach i $args { $w.menu add radiobutton -label $i -variable $varName } return $w.menu } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/palette.tcl0100644000000000001200000001750410153074437030254 0ustar rootadmin# palette.tcl -- # # This file contains procedures that change the color palette used # by Tk. # # RCS: @(#) $Id: palette.tcl,v 1.8 2001/11/29 10:54:21 dkf Exp $ # # Copyright (c) 1995-1997 Sun Microsystems, Inc. # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # # ::tk_setPalette -- # Changes the default color scheme for a Tk application by setting # default colors in the option database and by modifying all of the # color options for existing widgets that have the default value. # # Arguments: # The arguments consist of either a single color name, which # will be used as the new background color (all other colors will # be computed from this) or an even number of values consisting of # option names and values. The name for an option is the one used # for the option database, such as activeForeground, not -activeforeground. proc ::tk_setPalette {args} { if {[winfo depth .] == 1} { # Just return on monochrome displays, otherwise errors will occur return } # Create an array that has the complete new palette. If some colors # aren't specified, compute them from other colors that are specified. if {[llength $args] == 1} { set new(background) [lindex $args 0] } else { array set new $args } if {![info exists new(background)]} { error "must specify a background color" } set bg [winfo rgb . $new(background)] if {![info exists new(foreground)]} { # Note that the range of each value in the triple returned by # [winfo rgb] is 0-65535, and your eyes are more sensitive to # green than to red, and more to red than to blue. foreach {r g b} $bg {break} if {$r+1.5*$g+0.5*$b > 100000} { set new(foreground) black } else { set new(foreground) white } } set fg [winfo rgb . $new(foreground)] set darkerBg [format #%02x%02x%02x [expr {(9*[lindex $bg 0])/2560}] \ [expr {(9*[lindex $bg 1])/2560}] [expr {(9*[lindex $bg 2])/2560}]] foreach i {activeForeground insertBackground selectForeground \ highlightColor} { if {![info exists new($i)]} { set new($i) $new(foreground) } } if {![info exists new(disabledForeground)]} { set new(disabledForeground) [format #%02x%02x%02x \ [expr {(3*[lindex $bg 0] + [lindex $fg 0])/1024}] \ [expr {(3*[lindex $bg 1] + [lindex $fg 1])/1024}] \ [expr {(3*[lindex $bg 2] + [lindex $fg 2])/1024}]] } if {![info exists new(highlightBackground)]} { set new(highlightBackground) $new(background) } if {![info exists new(activeBackground)]} { # Pick a default active background that islighter than the # normal background. To do this, round each color component # up by 15% or 1/3 of the way to full white, whichever is # greater. foreach i {0 1 2} { set light($i) [expr {[lindex $bg $i]/256}] set inc1 [expr {($light($i)*15)/100}] set inc2 [expr {(255-$light($i))/3}] if {$inc1 > $inc2} { incr light($i) $inc1 } else { incr light($i) $inc2 } if {$light($i) > 255} { set light($i) 255 } } set new(activeBackground) [format #%02x%02x%02x $light(0) \ $light(1) $light(2)] } if {![info exists new(selectBackground)]} { set new(selectBackground) $darkerBg } if {![info exists new(troughColor)]} { set new(troughColor) $darkerBg } if {![info exists new(selectColor)]} { set new(selectColor) #b03060 } # let's make one of each of the widgets so we know what the # defaults are currently for this platform. toplevel .___tk_set_palette wm withdraw .___tk_set_palette foreach q { button canvas checkbutton entry frame label labelframe listbox menubutton menu message radiobutton scale scrollbar spinbox text } { $q .___tk_set_palette.$q } # Walk the widget hierarchy, recoloring all existing windows. # The option database must be set according to what we do here, # but it breaks things if we set things in the database while # we are changing colors...so, ::tk::RecolorTree now returns the # option database changes that need to be made, and they # need to be evalled here to take effect. # We have to walk the whole widget tree instead of just # relying on the widgets we've created above to do the work # because different extensions may provide other kinds # of widgets that we don't currently know about, so we'll # walk the whole hierarchy just in case. eval [tk::RecolorTree . new] catch {destroy .___tk_set_palette} # Change the option database so that future windows will get the # same colors. foreach option [array names new] { option add *$option $new($option) widgetDefault } # Save the options in the variable ::tk::Palette, for use the # next time we change the options. array set ::tk::Palette [array get new] } # ::tk::RecolorTree -- # This procedure changes the colors in a window and all of its # descendants, according to information provided by the colors # argument. This looks at the defaults provided by the option # database, if it exists, and if not, then it looks at the default # value of the widget itself. # # Arguments: # w - The name of a window. This window and all its # descendants are recolored. # colors - The name of an array variable in the caller, # which contains color information. Each element # is named after a widget configuration option, and # each value is the value for that option. proc ::tk::RecolorTree {w colors} { upvar $colors c set result {} set prototype .___tk_set_palette.[string tolower [winfo class $w]] if {![winfo exists $prototype]} { unset prototype } foreach dbOption [array names c] { set option -[string tolower $dbOption] set class [string replace $dbOption 0 0 [string toupper \ [string index $dbOption 0]]] if {![catch {$w config $option} value]} { # if the option database has a preference for this # dbOption, then use it, otherwise use the defaults # for the widget. set defaultcolor [option get $w $dbOption $class] if {[string match {} $defaultcolor] || \ ([info exists prototype] && \ [$prototype cget $option] ne "$defaultcolor")} { set defaultcolor [winfo rgb . [lindex $value 3]] } else { set defaultcolor [winfo rgb . $defaultcolor] } set chosencolor [winfo rgb . [lindex $value 4]] if {[string match $defaultcolor $chosencolor]} { # Change the option database so that future windows will get # the same colors. append result ";\noption add [list \ *[winfo class $w].$dbOption $c($dbOption) 60]" $w configure $option $c($dbOption) } } } foreach child [winfo children $w] { append result ";\n[::tk::RecolorTree $child c]" } return $result } # ::tk::Darken -- # Given a color name, computes a new color value that darkens (or # brightens) the given color by a given percent. # # Arguments: # color - Name of starting color. # perecent - Integer telling how much to brighten or darken as a # percent: 50 means darken by 50%, 110 means brighten # by 10%. proc ::tk::Darken {color percent} { foreach {red green blue} [winfo rgb . $color] { set red [expr {($red/256)*$percent/100}] set green [expr {($green/256)*$percent/100}] set blue [expr {($blue/256)*$percent/100}] break } if {$red > 255} { set red 255 } if {$green > 255} { set green 255 } if {$blue > 255} { set blue 255 } return [format "#%02x%02x%02x" $red $green $blue] } # ::tk_bisque -- # Reset the Tk color palette to the old "bisque" colors. # # Arguments: # None. proc ::tk_bisque {} { tk_setPalette activeBackground #e6ceb1 activeForeground black \ background #ffe4c4 disabledForeground #b0b0b0 foreground black \ highlightBackground #ffe4c4 highlightColor black \ insertBackground black selectColor #b03060 \ selectBackground #e6ceb1 selectForeground black \ troughColor #cdb79e } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/panedwindow.tcl0100644000000000001200000001221310153074437031125 0ustar rootadmin# panedwindow.tcl -- # # This file defines the default bindings for Tk panedwindow widgets and # provides procedures that help in implementing those bindings. # # RCS: @(#) $Id: panedwindow.tcl,v 1.6.2.2 2004/05/03 19:36:56 hobbs Exp $ # bind Panedwindow { ::tk::panedwindow::MarkSash %W %x %y 1 } bind Panedwindow { ::tk::panedwindow::MarkSash %W %x %y 0 } bind Panedwindow { ::tk::panedwindow::DragSash %W %x %y 1 } bind Panedwindow { ::tk::panedwindow::DragSash %W %x %y 0 } bind Panedwindow {::tk::panedwindow::ReleaseSash %W 1} bind Panedwindow {::tk::panedwindow::ReleaseSash %W 0} bind Panedwindow { ::tk::panedwindow::Motion %W %x %y } bind Panedwindow { ::tk::panedwindow::Leave %W } # Initialize namespace namespace eval ::tk::panedwindow {} # ::tk::panedwindow::MarkSash -- # # Handle marking the correct sash for possible dragging # # Arguments: # w the widget # x widget local x coord # y widget local y coord # proxy whether this should be a proxy sash # Results: # None # proc ::tk::panedwindow::MarkSash {w x y proxy} { if {[$w cget -opaqueresize]} { set proxy 0 } set what [$w identify $x $y] if { [llength $what] == 2 } { foreach {index which} $what break if { !$::tk_strictMotif || [string equal $which "handle"] } { if {!$proxy} { $w sash mark $index $x $y } set ::tk::Priv(sash) $index foreach {sx sy} [$w sash coord $index] break set ::tk::Priv(dx) [expr {$sx-$x}] set ::tk::Priv(dy) [expr {$sy-$y}] # Do this to init the proxy location DragSash $w $x $y $proxy } } } # ::tk::panedwindow::DragSash -- # # Handle dragging of the correct sash # # Arguments: # w the widget # x widget local x coord # y widget local y coord # proxy whether this should be a proxy sash # Results: # Moves sash # proc ::tk::panedwindow::DragSash {w x y proxy} { if {[$w cget -opaqueresize]} { set proxy 0 } if { [info exists ::tk::Priv(sash)] } { if {$proxy} { $w proxy place \ [expr {$x+$::tk::Priv(dx)}] [expr {$y+$::tk::Priv(dy)}] } else { $w sash place $::tk::Priv(sash) \ [expr {$x+$::tk::Priv(dx)}] [expr {$y+$::tk::Priv(dy)}] } } } # ::tk::panedwindow::ReleaseSash -- # # Handle releasing of the sash # # Arguments: # w the widget # proxy whether this should be a proxy sash # Results: # Returns ... # proc ::tk::panedwindow::ReleaseSash {w proxy} { if {[$w cget -opaqueresize]} { set proxy 0 } if { [info exists ::tk::Priv(sash)] } { if {$proxy} { foreach {x y} [$w proxy coord] break $w sash place $::tk::Priv(sash) $x $y $w proxy forget } unset ::tk::Priv(sash) ::tk::Priv(dx) ::tk::Priv(dy) } } # ::tk::panedwindow::Motion -- # # Handle motion on the widget. This is used to change the cursor # when the user moves over the sash area. # # Arguments: # w the widget # x widget local x coord # y widget local y coord # Results: # May change the cursor. Sets up a timer to verify that we are still # over the widget. # proc ::tk::panedwindow::Motion {w x y} { variable ::tk::Priv set id [$w identify $x $y] if {([llength $id] == 2) && \ (!$::tk_strictMotif || [string equal [lindex $id 1] "handle"])} { if { ![info exists Priv($w,panecursor)] } { set Priv($w,panecursor) [$w cget -cursor] if { [string equal [$w cget -sashcursor] ""] } { if { [string equal [$w cget -orient] "horizontal"] } { $w configure -cursor sb_h_double_arrow } else { $w configure -cursor sb_v_double_arrow } } else { $w configure -cursor [$w cget -sashcursor] } if {[info exists Priv($w,pwAfterId)]} { after cancel $Priv($w,pwAfterId) } set Priv($w,pwAfterId) [after 150 \ [list ::tk::panedwindow::Cursor $w]] } return } if { [info exists Priv($w,panecursor)] } { $w configure -cursor $Priv($w,panecursor) unset Priv($w,panecursor) } } # ::tk::panedwindow::Cursor -- # # Handles returning the normal cursor when we are no longer over the # sash area. This needs to be done this way, because the panedwindow # won't see Leave events when the mouse moves from the sash to a # paned child, although the child does receive an Enter event. # # Arguments: # w the widget # Results: # May restore the default cursor, or schedule a timer to do it. # proc ::tk::panedwindow::Cursor {w} { variable ::tk::Priv if {[info exists Priv($w,panecursor)]} { if {[winfo containing [winfo pointerx $w] [winfo pointery $w]] eq $w} { set Priv($w,pwAfterId) [after 150 \ [list ::tk::panedwindow::Cursor $w]] } else { $w configure -cursor $Priv($w,panecursor) unset Priv($w,panecursor) if {[info exists Priv($w,pwAfterId)]} { after cancel $Priv($w,pwAfterId) unset Priv($w,pwAfterId) } } } } # ::tk::panedwindow::Leave -- # # Return to default cursor when leaving the pw widget. # # Arguments: # w the widget # Results: # Restores the default cursor # proc ::tk::panedwindow::Leave {w} { if {[info exists ::tk::Priv($w,panecursor)]} { $w configure -cursor $::tk::Priv($w,panecursor) unset ::tk::Priv($w,panecursor) } } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/pkgIndex.tcl0100644000000000001200000000020310153074442030347 0ustar rootadminif {[package vcompare [package provide Tcl] 8.4] != 0} { return } package ifneeded Tk 8.4 [list load [file join $dir .. .. Tk] Tk] Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/prolog.ps0100644000000000001200000002254010153074440027746 0ustar rootadmin%%BeginProlog 50 dict begin % This is a standard prolog for Postscript generated by Tk's canvas % widget. % RCS: @(#) $Id: prolog.ps,v 1.2 1999/04/16 01:51:09 stanton Exp $ % The definitions below just define all of the variables used in % any of the procedures here. This is needed for obscure reasons % explained on p. 716 of the Postscript manual (Section H.2.7, % "Initializing Variables," in the section on Encapsulated Postscript). /baseline 0 def /stipimage 0 def /height 0 def /justify 0 def /lineLength 0 def /spacing 0 def /stipple 0 def /strings 0 def /xoffset 0 def /yoffset 0 def /tmpstip null def % Define the array ISOLatin1Encoding (which specifies how characters are % encoded for ISO-8859-1 fonts), if it isn't already present (Postscript % level 2 is supposed to define it, but level 1 doesn't). systemdict /ISOLatin1Encoding known not { /ISOLatin1Encoding [ /space /space /space /space /space /space /space /space /space /space /space /space /space /space /space /space /space /space /space /space /space /space /space /space /space /space /space /space /space /space /space /space /space /exclam /quotedbl /numbersign /dollar /percent /ampersand /quoteright /parenleft /parenright /asterisk /plus /comma /minus /period /slash /zero /one /two /three /four /five /six /seven /eight /nine /colon /semicolon /less /equal /greater /question /at /A /B /C /D /E /F /G /H /I /J /K /L /M /N /O /P /Q /R /S /T /U /V /W /X /Y /Z /bracketleft /backslash /bracketright /asciicircum /underscore /quoteleft /a /b /c /d /e /f /g /h /i /j /k /l /m /n /o /p /q /r /s /t /u /v /w /x /y /z /braceleft /bar /braceright /asciitilde /space /space /space /space /space /space /space /space /space /space /space /space /space /space /space /space /space /dotlessi /grave /acute /circumflex /tilde /macron /breve /dotaccent /dieresis /space /ring /cedilla /space /hungarumlaut /ogonek /caron /space /exclamdown /cent /sterling /currency /yen /brokenbar /section /dieresis /copyright /ordfeminine /guillemotleft /logicalnot /hyphen /registered /macron /degree /plusminus /twosuperior /threesuperior /acute /mu /paragraph /periodcentered /cedillar /onesuperior /ordmasculine /guillemotright /onequarter /onehalf /threequarters /questiondown /Agrave /Aacute /Acircumflex /Atilde /Adieresis /Aring /AE /Ccedilla /Egrave /Eacute /Ecircumflex /Edieresis /Igrave /Iacute /Icircumflex /Idieresis /Eth /Ntilde /Ograve /Oacute /Ocircumflex /Otilde /Odieresis /multiply /Oslash /Ugrave /Uacute /Ucircumflex /Udieresis /Yacute /Thorn /germandbls /agrave /aacute /acircumflex /atilde /adieresis /aring /ae /ccedilla /egrave /eacute /ecircumflex /edieresis /igrave /iacute /icircumflex /idieresis /eth /ntilde /ograve /oacute /ocircumflex /otilde /odieresis /divide /oslash /ugrave /uacute /ucircumflex /udieresis /yacute /thorn /ydieresis ] def } if % font ISOEncode font % This procedure changes the encoding of a font from the default % Postscript encoding to ISOLatin1. It's typically invoked just % before invoking "setfont". The body of this procedure comes from % Section 5.6.1 of the Postscript book. /ISOEncode { dup length dict begin {1 index /FID ne {def} {pop pop} ifelse} forall /Encoding ISOLatin1Encoding def currentdict end % I'm not sure why it's necessary to use "definefont" on this new % font, but it seems to be important; just use the name "Temporary" % for the font. /Temporary exch definefont } bind def % StrokeClip % % This procedure converts the current path into a clip area under % the assumption of stroking. It's a bit tricky because some Postscript % interpreters get errors during strokepath for dashed lines. If % this happens then turn off dashes and try again. /StrokeClip { {strokepath} stopped { (This Postscript printer gets limitcheck overflows when) = (stippling dashed lines; lines will be printed solid instead.) = [] 0 setdash strokepath} if clip } bind def % desiredSize EvenPixels closestSize % % The procedure below is used for stippling. Given the optimal size % of a dot in a stipple pattern in the current user coordinate system, % compute the closest size that is an exact multiple of the device's % pixel size. This allows stipple patterns to be displayed without % aliasing effects. /EvenPixels { % Compute exact number of device pixels per stipple dot. dup 0 matrix currentmatrix dtransform dup mul exch dup mul add sqrt % Round to an integer, make sure the number is at least 1, and compute % user coord distance corresponding to this. dup round dup 1 lt {pop 1} if exch div mul } bind def % width height string StippleFill -- % % Given a path already set up and a clipping region generated from % it, this procedure will fill the clipping region with a stipple % pattern. "String" contains a proper image description of the % stipple pattern and "width" and "height" give its dimensions. Each % stipple dot is assumed to be about one unit across in the current % user coordinate system. This procedure trashes the graphics state. /StippleFill { % The following code is needed to work around a NeWSprint bug. /tmpstip 1 index def % Change the scaling so that one user unit in user coordinates % corresponds to the size of one stipple dot. 1 EvenPixels dup scale % Compute the bounding box occupied by the path (which is now % the clipping region), and round the lower coordinates down % to the nearest starting point for the stipple pattern. Be % careful about negative numbers, since the rounding works % differently on them. pathbbox 4 2 roll 5 index div dup 0 lt {1 sub} if cvi 5 index mul 4 1 roll 6 index div dup 0 lt {1 sub} if cvi 6 index mul 3 2 roll % Stack now: width height string y1 y2 x1 x2 % Below is a doubly-nested for loop to iterate across this area % in units of the stipple pattern size, going up columns then % across rows, blasting out a stipple-pattern-sized rectangle at % each position 6 index exch { 2 index 5 index 3 index { % Stack now: width height string y1 y2 x y gsave 1 index exch translate 5 index 5 index true matrix tmpstip imagemask grestore } for pop } for pop pop pop pop pop } bind def % -- AdjustColor -- % Given a color value already set for output by the caller, adjusts % that value to a grayscale or mono value if requested by the CL % variable. /AdjustColor { CL 2 lt { currentgray CL 0 eq { .5 lt {0} {1} ifelse } if setgray } if } bind def % x y strings spacing xoffset yoffset justify stipple DrawText -- % This procedure does all of the real work of drawing text. The % color and font must already have been set by the caller, and the % following arguments must be on the stack: % % x, y - Coordinates at which to draw text. % strings - An array of strings, one for each line of the text item, % in order from top to bottom. % spacing - Spacing between lines. % xoffset - Horizontal offset for text bbox relative to x and y: 0 for % nw/w/sw anchor, -0.5 for n/center/s, and -1.0 for ne/e/se. % yoffset - Vertical offset for text bbox relative to x and y: 0 for % nw/n/ne anchor, +0.5 for w/center/e, and +1.0 for sw/s/se. % justify - 0 for left justification, 0.5 for center, 1 for right justify. % stipple - Boolean value indicating whether or not text is to be % drawn in stippled fashion. If text is stippled, % procedure StippleText must have been defined to call % StippleFill in the right way. % % Also, when this procedure is invoked, the color and font must already % have been set for the text. /DrawText { /stipple exch def /justify exch def /yoffset exch def /xoffset exch def /spacing exch def /strings exch def % First scan through all of the text to find the widest line. /lineLength 0 def strings { stringwidth pop dup lineLength gt {/lineLength exch def} {pop} ifelse newpath } forall % Compute the baseline offset and the actual font height. 0 0 moveto (TXygqPZ) false charpath pathbbox dup /baseline exch def exch pop exch sub /height exch def pop newpath % Translate coordinates first so that the origin is at the upper-left % corner of the text's bounding box. Remember that x and y for % positioning are still on the stack. translate lineLength xoffset mul strings length 1 sub spacing mul height add yoffset mul translate % Now use the baseline and justification information to translate so % that the origin is at the baseline and positioning point for the % first line of text. justify lineLength mul baseline neg translate % Iterate over each of the lines to output it. For each line, % compute its width again so it can be properly justified, then % display it. strings { dup stringwidth pop justify neg mul 0 moveto stipple { % The text is stippled, so turn it into a path and print % by calling StippledText, which in turn calls StippleFill. % Unfortunately, many Postscript interpreters will get % overflow errors if we try to do the whole string at % once, so do it a character at a time. gsave /char (X) def { char 0 3 -1 roll put currentpoint gsave char true charpath clip StippleText grestore char stringwidth translate moveto } forall grestore } {show} ifelse 0 spacing neg translate } forall } bind def %%EndProlog Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/safetk.tcl0100644000000000001200000001656410153074440030072 0ustar rootadmin# safetk.tcl -- # # Support procs to use Tk in safe interpreters. # # RCS: @(#) $Id: safetk.tcl,v 1.8 2000/10/31 01:11:51 hobbs Exp $ # # Copyright (c) 1997 Sun Microsystems, Inc. # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # see safetk.n for documentation # # # Note: It is now ok to let untrusted code being executed # between the creation of the interp and the actual loading # of Tk in that interp because the C side Tk_Init will # now look up the master interp and ask its safe::TkInit # for the actual parameters to use for it's initialization (if allowed), # not relying on the slave state. # # We use opt (optional arguments parsing) package require opt 0.4.1; namespace eval ::safe { # counter for safe toplevels variable tkSafeId 0; # # tkInterpInit : prepare the slave interpreter for tk loading # most of the real job is done by loadTk # returns the slave name (tkInterpInit does) # proc ::safe::tkInterpInit {slave argv} { global env tk_library # We have to make sure that the tk_library variable uses a file # pathname that works better in Tk (of the style returned by # [file join], ie C:/path/to/tk/lib, not C:\path\to\tk\lib set tk_library [file join $tk_library] # Clear Tk's access for that interp (path). allowTk $slave $argv # there seems to be an obscure case where the tk_library # variable value is changed to point to a sym link destination # dir instead of the sym link itself, and thus where the $tk_library # would then not be anymore one of the auto_path dir, so we use # the addToAccessPath which adds if it's not already in instead # of the more conventional findInAccessPath. # Might be usefull for masters without Tk really loaded too. ::interp eval $slave [list set tk_library [::safe::interpAddToAccessPath $slave $tk_library]] return $slave } # tkInterpLoadTk : # Do additional configuration as needed (calling tkInterpInit) # and actually load Tk into the slave. # # Either contained in the specified windowId (-use) or # creating a decorated toplevel for it. # empty definition for auto_mkIndex proc ::safe::loadTk {} {} ::tcl::OptProc loadTk { {slave -interp "name of the slave interpreter"} {-use -windowId {} "window Id to use (new toplevel otherwise)"} {-display -displayName {} "display name to use (current one otherwise)"} } { set displayGiven [::tcl::OptProcArgGiven "-display"] if {!$displayGiven} { # Try to get the current display from "." # (which might not exist if the master is tk-less) if {[catch {set display [winfo screen .]}]} { if {[info exists ::env(DISPLAY)]} { set display $::env(DISPLAY) } else { Log $slave "no winfo screen . nor env(DISPLAY)" WARNING set display ":0.0" } } } if {![::tcl::OptProcArgGiven "-use"]} { # create a decorated toplevel ::tcl::Lassign [tkTopLevel $slave $display] w use # set our delete hook (slave arg is added by interpDelete) # to clean up both window related code and tkInit(slave) Set [DeleteHookName $slave] [list tkDelete {} $w] } else { # set our delete hook (slave arg is added by interpDelete) # to clean up tkInit(slave) Set [DeleteHookName $slave] [list disallowTk] # Let's be nice and also accept tk window names instead of ids if {[string match ".*" $use]} { set windowName $use set use [winfo id $windowName] set nDisplay [winfo screen $windowName] } else { # Check for a better -display value # (works only for multi screens on single host, but not # cross hosts, for that a tk window name would be better # but embeding is also usefull for non tk names) if {![catch {winfo pathname $use} name]} { set nDisplay [winfo screen $name] } else { # Can't have a better one set nDisplay $display } } if {[string compare $nDisplay $display]} { if {$displayGiven} { error "conflicting -display $display and -use\ $use -> $nDisplay" } else { set display $nDisplay } } } # Prepares the slave for tk with those parameters tkInterpInit $slave [list "-use" $use "-display" $display] load {} Tk $slave return $slave } proc ::safe::TkInit {interpPath} { variable tkInit if {[info exists tkInit($interpPath)]} { set value $tkInit($interpPath) Log $interpPath "TkInit called, returning \"$value\"" NOTICE return $value } else { Log $interpPath "TkInit called for interp with clearance:\ preventing Tk init" ERROR error "not allowed" } } # safe::allowTk -- # # Set tkInit(interpPath) to allow Tk to be initialized in # safe::TkInit. # # Arguments: # interpPath slave interpreter handle # argv arguments passed to safe::TkInterpInit # # Results: # none. proc ::safe::allowTk {interpPath argv} { variable tkInit set tkInit($interpPath) $argv return } # safe::disallowTk -- # # Unset tkInit(interpPath) to disallow Tk from getting initialized # in safe::TkInit. # # Arguments: # interpPath slave interpreter handle # # Results: # none. proc ::safe::disallowTk {interpPath} { variable tkInit # This can already be deleted by the DeleteHook of the interp if {[info exists tkInit($interpPath)]} { unset tkInit($interpPath) } return } # safe::tkDelete -- # # Clean up the window associated with the interp being deleted. # # Arguments: # interpPath slave interpreter handle # # Results: # none. proc ::safe::tkDelete {W window slave} { # we are going to be called for each widget... skip untill it's # top level Log $slave "Called tkDelete $W $window" NOTICE if {[::interp exists $slave]} { if {[catch {::safe::interpDelete $slave} msg]} { Log $slave "Deletion error : $msg" } } if {[winfo exists $window]} { Log $slave "Destroy toplevel $window" NOTICE destroy $window } # clean up tkInit(slave) disallowTk $slave return } proc ::safe::tkTopLevel {slave display} { variable tkSafeId incr tkSafeId set w ".safe$tkSafeId" if {[catch {toplevel $w -screen $display -class SafeTk} msg]} { return -code error "Unable to create toplevel for\ safe slave \"$slave\" ($msg)" } Log $slave "New toplevel $w" NOTICE set msg "Untrusted Tcl applet ($slave)" wm title $w $msg # Control frame set wc $w.fc frame $wc -bg red -borderwidth 3 -relief ridge # We will destroy the interp when the window is destroyed bindtags $wc [concat Safe$wc [bindtags $wc]] bind Safe$wc [list ::safe::tkDelete %W $w $slave] label $wc.l -text $msg -padx 2 -pady 0 -anchor w # We want the button to be the last visible item # (so be packed first) and at the right and not resizing horizontally # frame the button so it does not expand horizontally # but still have the default background instead of red one from the parent frame $wc.fb -bd 0 button $wc.fb.b -text "Delete" \ -bd 1 -padx 2 -pady 0 -highlightthickness 0 \ -command [list ::safe::tkDelete $w $w $slave] pack $wc.fb.b -side right -fill both pack $wc.fb -side right -fill both -expand 1 pack $wc.l -side left -fill both -expand 1 pack $wc -side bottom -fill x # Container frame frame $w.c -container 1 pack $w.c -fill both -expand 1 # return both the toplevel window name and the id to use for embedding list $w [winfo id $w.c] } } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/scale.tcl0100644000000000001200000001727210153074440027701 0ustar rootadmin# scale.tcl -- # # This file defines the default bindings for Tk scale widgets and provides # procedures that help in implementing the bindings. # # RCS: @(#) $Id: scale.tcl,v 1.9.2.3 2003/10/03 00:42:17 patthoyts Exp $ # # Copyright (c) 1994 The Regents of the University of California. # Copyright (c) 1994-1995 Sun Microsystems, Inc. # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # #------------------------------------------------------------------------- # The code below creates the default class bindings for entries. #------------------------------------------------------------------------- # Standard Motif bindings: bind Scale { if {$tk_strictMotif} { set tk::Priv(activeBg) [%W cget -activebackground] %W config -activebackground [%W cget -background] } tk::ScaleActivate %W %x %y } bind Scale { tk::ScaleActivate %W %x %y } bind Scale { if {$tk_strictMotif} { %W config -activebackground $tk::Priv(activeBg) } if {[string equal [%W cget -state] "active"]} { %W configure -state normal } } bind Scale <1> { tk::ScaleButtonDown %W %x %y } bind Scale { tk::ScaleDrag %W %x %y } bind Scale { } bind Scale { } bind Scale { tk::CancelRepeat tk::ScaleEndDrag %W tk::ScaleActivate %W %x %y } bind Scale <2> { tk::ScaleButton2Down %W %x %y } bind Scale { tk::ScaleDrag %W %x %y } bind Scale { } bind Scale { } bind Scale { tk::CancelRepeat tk::ScaleEndDrag %W tk::ScaleActivate %W %x %y } if {[string equal $tcl_platform(platform) "windows"]} { # On Windows do the same with button 3, as that is the right mouse button bind Scale <3> [bind Scale <2>] bind Scale [bind Scale ] bind Scale [bind Scale ] bind Scale [bind Scale ] bind Scale [bind Scale ] } bind Scale { tk::ScaleControlPress %W %x %y } bind Scale { tk::ScaleIncrement %W up little noRepeat } bind Scale { tk::ScaleIncrement %W down little noRepeat } bind Scale { tk::ScaleIncrement %W up little noRepeat } bind Scale { tk::ScaleIncrement %W down little noRepeat } bind Scale { tk::ScaleIncrement %W up big noRepeat } bind Scale { tk::ScaleIncrement %W down big noRepeat } bind Scale { tk::ScaleIncrement %W up big noRepeat } bind Scale { tk::ScaleIncrement %W down big noRepeat } bind Scale { %W set [%W cget -from] } bind Scale { %W set [%W cget -to] } # ::tk::ScaleActivate -- # This procedure is invoked to check a given x-y position in the # scale and activate the slider if the x-y position falls within # the slider. # # Arguments: # w - The scale widget. # x, y - Mouse coordinates. proc ::tk::ScaleActivate {w x y} { if {[string equal [$w cget -state] "disabled"]} { return } if {[string equal [$w identify $x $y] "slider"]} { set state active } else { set state normal } if {[string compare [$w cget -state] $state]} { $w configure -state $state } } # ::tk::ScaleButtonDown -- # This procedure is invoked when a button is pressed in a scale. It # takes different actions depending on where the button was pressed. # # Arguments: # w - The scale widget. # x, y - Mouse coordinates of button press. proc ::tk::ScaleButtonDown {w x y} { variable ::tk::Priv set Priv(dragging) 0 set el [$w identify $x $y] # save the relief set Priv($w,relief) [$w cget -sliderrelief] if {[string equal $el "trough1"]} { ScaleIncrement $w up little initial } elseif {[string equal $el "trough2"]} { ScaleIncrement $w down little initial } elseif {[string equal $el "slider"]} { set Priv(dragging) 1 set Priv(initValue) [$w get] set coords [$w coords] set Priv(deltaX) [expr {$x - [lindex $coords 0]}] set Priv(deltaY) [expr {$y - [lindex $coords 1]}] switch -exact -- $Priv($w,relief) { "raised" { $w configure -sliderrelief sunken } "ridge" { $w configure -sliderrelief groove } } } } # ::tk::ScaleDrag -- # This procedure is called when the mouse is dragged with # mouse button 1 down. If the drag started inside the slider # (i.e. the scale is active) then the scale's value is adjusted # to reflect the mouse's position. # # Arguments: # w - The scale widget. # x, y - Mouse coordinates. proc ::tk::ScaleDrag {w x y} { variable ::tk::Priv if {!$Priv(dragging)} { return } $w set [$w get [expr {$x-$Priv(deltaX)}] [expr {$y-$Priv(deltaY)}]] } # ::tk::ScaleEndDrag -- # This procedure is called to end an interactive drag of the # slider. It just marks the drag as over. # # Arguments: # w - The scale widget. proc ::tk::ScaleEndDrag {w} { variable ::tk::Priv set Priv(dragging) 0 if {[info exists Priv($w,relief)]} { $w configure -sliderrelief $Priv($w,relief) unset Priv($w,relief) } } # ::tk::ScaleIncrement -- # This procedure is invoked to increment the value of a scale and # to set up auto-repeating of the action if that is desired. The # way the value is incremented depends on the "dir" and "big" # arguments. # # Arguments: # w - The scale widget. # dir - "up" means move value towards -from, "down" means # move towards -to. # big - Size of increments: "big" or "little". # repeat - Whether and how to auto-repeat the action: "noRepeat" # means don't auto-repeat, "initial" means this is the # first action in an auto-repeat sequence, and "again" # means this is the second repetition or later. proc ::tk::ScaleIncrement {w dir big repeat} { variable ::tk::Priv if {![winfo exists $w]} return if {[string equal $big "big"]} { set inc [$w cget -bigincrement] if {$inc == 0} { set inc [expr {abs([$w cget -to] - [$w cget -from])/10.0}] } if {$inc < [$w cget -resolution]} { set inc [$w cget -resolution] } } else { set inc [$w cget -resolution] } if {([$w cget -from] > [$w cget -to]) ^ [string equal $dir "up"]} { set inc [expr {-$inc}] } $w set [expr {[$w get] + $inc}] if {[string equal $repeat "again"]} { set Priv(afterId) [after [$w cget -repeatinterval] \ [list tk::ScaleIncrement $w $dir $big again]] } elseif {[string equal $repeat "initial"]} { set delay [$w cget -repeatdelay] if {$delay > 0} { set Priv(afterId) [after $delay \ [list tk::ScaleIncrement $w $dir $big again]] } } } # ::tk::ScaleControlPress -- # This procedure handles button presses that are made with the Control # key down. Depending on the mouse position, it adjusts the scale # value to one end of the range or the other. # # Arguments: # w - The scale widget. # x, y - Mouse coordinates where the button was pressed. proc ::tk::ScaleControlPress {w x y} { set el [$w identify $x $y] if {[string equal $el "trough1"]} { $w set [$w cget -from] } elseif {[string equal $el "trough2"]} { $w set [$w cget -to] } } # ::tk::ScaleButton2Down # This procedure is invoked when button 2 is pressed over a scale. # It sets the value to correspond to the mouse position and starts # a slider drag. # # Arguments: # w - The scrollbar widget. # x, y - Mouse coordinates within the widget. proc ::tk::ScaleButton2Down {w x y} { variable ::tk::Priv if {[string equal [$w cget -state] "disabled"]} { return } $w configure -state active $w set [$w get $x $y] set Priv(dragging) 1 set Priv(initValue) [$w get] set Priv($w,relief) [$w cget -sliderrelief] set coords "$x $y" set Priv(deltaX) 0 set Priv(deltaY) 0 } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/scrlbar.tcl0100644000000000001200000002773610153074440030250 0ustar rootadmin# scrlbar.tcl -- # # This file defines the default bindings for Tk scrollbar widgets. # It also provides procedures that help in implementing the bindings. # # RCS: @(#) $Id: scrlbar.tcl,v 1.10.2.1 2004/02/17 07:17:17 das Exp $ # # Copyright (c) 1994 The Regents of the University of California. # Copyright (c) 1994-1996 Sun Microsystems, Inc. # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # #------------------------------------------------------------------------- # The code below creates the default class bindings for scrollbars. #------------------------------------------------------------------------- # Standard Motif bindings: if {[string equal [tk windowingsystem] "x11"]} { bind Scrollbar { if {$tk_strictMotif} { set tk::Priv(activeBg) [%W cget -activebackground] %W config -activebackground [%W cget -background] } %W activate [%W identify %x %y] } bind Scrollbar { %W activate [%W identify %x %y] } # The "info exists" command in the following binding handles the # situation where a Leave event occurs for a scrollbar without the Enter # event. This seems to happen on some systems (such as Solaris 2.4) for # unknown reasons. bind Scrollbar { if {$tk_strictMotif && [info exists tk::Priv(activeBg)]} { %W config -activebackground $tk::Priv(activeBg) } %W activate {} } bind Scrollbar <1> { tk::ScrollButtonDown %W %x %y } bind Scrollbar { tk::ScrollDrag %W %x %y } bind Scrollbar { tk::ScrollDrag %W %x %y } bind Scrollbar { tk::ScrollButtonUp %W %x %y } bind Scrollbar { # Prevents binding from being invoked. } bind Scrollbar { # Prevents binding from being invoked. } bind Scrollbar <2> { tk::ScrollButton2Down %W %x %y } bind Scrollbar { # Do nothing, since button 1 is already down. } bind Scrollbar { # Do nothing, since button 2 is already down. } bind Scrollbar { tk::ScrollDrag %W %x %y } bind Scrollbar { tk::ScrollButtonUp %W %x %y } bind Scrollbar { # Do nothing: B1 release will handle it. } bind Scrollbar { # Do nothing: B2 release will handle it. } bind Scrollbar { # Prevents binding from being invoked. } bind Scrollbar { # Prevents binding from being invoked. } bind Scrollbar { tk::ScrollTopBottom %W %x %y } bind Scrollbar { tk::ScrollTopBottom %W %x %y } bind Scrollbar { tk::ScrollByUnits %W v -1 } bind Scrollbar { tk::ScrollByUnits %W v 1 } bind Scrollbar { tk::ScrollByPages %W v -1 } bind Scrollbar { tk::ScrollByPages %W v 1 } bind Scrollbar { tk::ScrollByUnits %W h -1 } bind Scrollbar { tk::ScrollByUnits %W h 1 } bind Scrollbar { tk::ScrollByPages %W h -1 } bind Scrollbar { tk::ScrollByPages %W h 1 } bind Scrollbar { tk::ScrollByPages %W hv -1 } bind Scrollbar { tk::ScrollByPages %W hv 1 } bind Scrollbar { tk::ScrollToPos %W 0 } bind Scrollbar { tk::ScrollToPos %W 1 } } if {[string equal [tk windowingsystem] "classic"] || [string equal [tk windowingsystem] "aqua"]} { bind Scrollbar { tk::ScrollByUnits %W v [expr {- (%D)}] } bind Scrollbar { tk::ScrollByUnits %W v [expr {-10 * (%D)}] } bind Scrollbar { tk::ScrollByUnits %W h [expr {- (%D)}] } bind Scrollbar { tk::ScrollByUnits %W h [expr {-10 * (%D)}] } } # tk::ScrollButtonDown -- # This procedure is invoked when a button is pressed in a scrollbar. # It changes the way the scrollbar is displayed and takes actions # depending on where the mouse is. # # Arguments: # w - The scrollbar widget. # x, y - Mouse coordinates. proc tk::ScrollButtonDown {w x y} { variable ::tk::Priv set Priv(relief) [$w cget -activerelief] $w configure -activerelief sunken set element [$w identify $x $y] if {[string equal $element "slider"]} { ScrollStartDrag $w $x $y } else { ScrollSelect $w $element initial } } # ::tk::ScrollButtonUp -- # This procedure is invoked when a button is released in a scrollbar. # It cancels scans and auto-repeats that were in progress, and restores # the way the active element is displayed. # # Arguments: # w - The scrollbar widget. # x, y - Mouse coordinates. proc ::tk::ScrollButtonUp {w x y} { variable ::tk::Priv tk::CancelRepeat if {[info exists Priv(relief)]} { # Avoid error due to spurious release events $w configure -activerelief $Priv(relief) ScrollEndDrag $w $x $y $w activate [$w identify $x $y] } } # ::tk::ScrollSelect -- # This procedure is invoked when a button is pressed over the scrollbar. # It invokes one of several scrolling actions depending on where in # the scrollbar the button was pressed. # # Arguments: # w - The scrollbar widget. # element - The element of the scrollbar that was selected, such # as "arrow1" or "trough2". Shouldn't be "slider". # repeat - Whether and how to auto-repeat the action: "noRepeat" # means don't auto-repeat, "initial" means this is the # first action in an auto-repeat sequence, and "again" # means this is the second repetition or later. proc ::tk::ScrollSelect {w element repeat} { variable ::tk::Priv if {![winfo exists $w]} return switch -- $element { "arrow1" {ScrollByUnits $w hv -1} "trough1" {ScrollByPages $w hv -1} "trough2" {ScrollByPages $w hv 1} "arrow2" {ScrollByUnits $w hv 1} default {return} } if {[string equal $repeat "again"]} { set Priv(afterId) [after [$w cget -repeatinterval] \ [list tk::ScrollSelect $w $element again]] } elseif {[string equal $repeat "initial"]} { set delay [$w cget -repeatdelay] if {$delay > 0} { set Priv(afterId) [after $delay \ [list tk::ScrollSelect $w $element again]] } } } # ::tk::ScrollStartDrag -- # This procedure is called to initiate a drag of the slider. It just # remembers the starting position of the mouse and slider. # # Arguments: # w - The scrollbar widget. # x, y - The mouse position at the start of the drag operation. proc ::tk::ScrollStartDrag {w x y} { variable ::tk::Priv if {[string equal [$w cget -command] ""]} { return } set Priv(pressX) $x set Priv(pressY) $y set Priv(initValues) [$w get] set iv0 [lindex $Priv(initValues) 0] if {[llength $Priv(initValues)] == 2} { set Priv(initPos) $iv0 } elseif {$iv0 == 0} { set Priv(initPos) 0.0 } else { set Priv(initPos) [expr {(double([lindex $Priv(initValues) 2])) \ / [lindex $Priv(initValues) 0]}] } } # ::tk::ScrollDrag -- # This procedure is called for each mouse motion even when the slider # is being dragged. It notifies the associated widget if we're not # jump scrolling, and it just updates the scrollbar if we are jump # scrolling. # # Arguments: # w - The scrollbar widget. # x, y - The current mouse position. proc ::tk::ScrollDrag {w x y} { variable ::tk::Priv if {[string equal $Priv(initPos) ""]} { return } set delta [$w delta [expr {$x - $Priv(pressX)}] [expr {$y - $Priv(pressY)}]] if {[$w cget -jump]} { if {[llength $Priv(initValues)] == 2} { $w set [expr {[lindex $Priv(initValues) 0] + $delta}] \ [expr {[lindex $Priv(initValues) 1] + $delta}] } else { set delta [expr {round($delta * [lindex $Priv(initValues) 0])}] eval [list $w] set [lreplace $Priv(initValues) 2 3 \ [expr {[lindex $Priv(initValues) 2] + $delta}] \ [expr {[lindex $Priv(initValues) 3] + $delta}]] } } else { ScrollToPos $w [expr {$Priv(initPos) + $delta}] } } # ::tk::ScrollEndDrag -- # This procedure is called to end an interactive drag of the slider. # It scrolls the window if we're in jump mode, otherwise it does nothing. # # Arguments: # w - The scrollbar widget. # x, y - The mouse position at the end of the drag operation. proc ::tk::ScrollEndDrag {w x y} { variable ::tk::Priv if {[string equal $Priv(initPos) ""]} { return } if {[$w cget -jump]} { set delta [$w delta [expr {$x - $Priv(pressX)}] \ [expr {$y - $Priv(pressY)}]] ScrollToPos $w [expr {$Priv(initPos) + $delta}] } set Priv(initPos) "" } # ::tk::ScrollByUnits -- # This procedure tells the scrollbar's associated widget to scroll up # or down by a given number of units. It notifies the associated widget # in different ways for old and new command syntaxes. # # Arguments: # w - The scrollbar widget. # orient - Which kinds of scrollbars this applies to: "h" for # horizontal, "v" for vertical, "hv" for both. # amount - How many units to scroll: typically 1 or -1. proc ::tk::ScrollByUnits {w orient amount} { set cmd [$w cget -command] if {[string equal $cmd ""] || ([string first \ [string index [$w cget -orient] 0] $orient] < 0)} { return } set info [$w get] if {[llength $info] == 2} { uplevel #0 $cmd scroll $amount units } else { uplevel #0 $cmd [expr {[lindex $info 2] + $amount}] } } # ::tk::ScrollByPages -- # This procedure tells the scrollbar's associated widget to scroll up # or down by a given number of screenfuls. It notifies the associated # widget in different ways for old and new command syntaxes. # # Arguments: # w - The scrollbar widget. # orient - Which kinds of scrollbars this applies to: "h" for # horizontal, "v" for vertical, "hv" for both. # amount - How many screens to scroll: typically 1 or -1. proc ::tk::ScrollByPages {w orient amount} { set cmd [$w cget -command] if {[string equal $cmd ""] || ([string first \ [string index [$w cget -orient] 0] $orient] < 0)} { return } set info [$w get] if {[llength $info] == 2} { uplevel #0 $cmd scroll $amount pages } else { uplevel #0 $cmd [expr {[lindex $info 2] + $amount*([lindex $info 1] - 1)}] } } # ::tk::ScrollToPos -- # This procedure tells the scrollbar's associated widget to scroll to # a particular location, given by a fraction between 0 and 1. It notifies # the associated widget in different ways for old and new command syntaxes. # # Arguments: # w - The scrollbar widget. # pos - A fraction between 0 and 1 indicating a desired position # in the document. proc ::tk::ScrollToPos {w pos} { set cmd [$w cget -command] if {[string equal $cmd ""]} { return } set info [$w get] if {[llength $info] == 2} { uplevel #0 $cmd moveto $pos } else { uplevel #0 $cmd [expr {round([lindex $info 0]*$pos)}] } } # ::tk::ScrollTopBottom # Scroll to the top or bottom of the document, depending on the mouse # position. # # Arguments: # w - The scrollbar widget. # x, y - Mouse coordinates within the widget. proc ::tk::ScrollTopBottom {w x y} { variable ::tk::Priv set element [$w identify $x $y] if {[string match *1 $element]} { ScrollToPos $w 0 } elseif {[string match *2 $element]} { ScrollToPos $w 1 } # Set Priv(relief), since it's needed by tk::ScrollButtonUp. set Priv(relief) [$w cget -activerelief] } # ::tk::ScrollButton2Down # This procedure is invoked when button 2 is pressed over a scrollbar. # If the button is over the trough or slider, it sets the scrollbar to # the mouse position and starts a slider drag. Otherwise it just # behaves the same as button 1. # # Arguments: # w - The scrollbar widget. # x, y - Mouse coordinates within the widget. proc ::tk::ScrollButton2Down {w x y} { variable ::tk::Priv set element [$w identify $x $y] if {[string match {arrow[12]} $element]} { ScrollButtonDown $w $x $y return } ScrollToPos $w [$w fraction $x $y] set Priv(relief) [$w cget -activerelief] # Need the "update idletasks" below so that the widget calls us # back to reset the actual scrollbar position before we start the # slider drag. update idletasks $w configure -activerelief sunken $w activate slider ScrollStartDrag $w $x $y } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/spinbox.tcl0100644000000000001200000003546210153074440030275 0ustar rootadmin# spinbox.tcl -- # # This file defines the default bindings for Tk spinbox widgets and provides # procedures that help in implementing those bindings. The spinbox builds # off the entry widget, so it can reuse Entry bindings and procedures. # # RCS: @(#) $Id: spinbox.tcl,v 1.6 2002/08/31 06:12:28 das Exp $ # # Copyright (c) 1992-1994 The Regents of the University of California. # Copyright (c) 1994-1997 Sun Microsystems, Inc. # Copyright (c) 1999-2000 Jeffrey Hobbs # Copyright (c) 2000 Ajuba Solutions # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # #------------------------------------------------------------------------- # Elements of tk::Priv that are used in this file: # # afterId - If non-null, it means that auto-scanning is underway # and it gives the "after" id for the next auto-scan # command to be executed. # mouseMoved - Non-zero means the mouse has moved a significant # amount since the button went down (so, for example, # start dragging out a selection). # pressX - X-coordinate at which the mouse button was pressed. # selectMode - The style of selection currently underway: # char, word, or line. # x, y - Last known mouse coordinates for scanning # and auto-scanning. # data - Used for Cut and Copy #------------------------------------------------------------------------- # Initialize namespace namespace eval ::tk::spinbox {} #------------------------------------------------------------------------- # The code below creates the default class bindings for entries. #------------------------------------------------------------------------- bind Spinbox <> { if {![catch {::tk::spinbox::GetSelection %W} tk::Priv(data)]} { clipboard clear -displayof %W clipboard append -displayof %W $tk::Priv(data) %W delete sel.first sel.last unset tk::Priv(data) } } bind Spinbox <> { if {![catch {::tk::spinbox::GetSelection %W} tk::Priv(data)]} { clipboard clear -displayof %W clipboard append -displayof %W $tk::Priv(data) unset tk::Priv(data) } } bind Spinbox <> { global tcl_platform catch { if {[tk windowingsystem] ne "x11"} { catch { %W delete sel.first sel.last } } %W insert insert [::tk::GetSelection %W CLIPBOARD] ::tk::EntrySeeInsert %W } } bind Spinbox <> { %W delete sel.first sel.last } bind Spinbox <> { if {$tk_strictMotif || ![info exists tk::Priv(mouseMoved)] || !$tk::Priv(mouseMoved)} { ::tk::spinbox::Paste %W %x } } # Standard Motif bindings: bind Spinbox <1> { ::tk::spinbox::ButtonDown %W %x %y } bind Spinbox { ::tk::spinbox::Motion %W %x %y } bind Spinbox { set tk::Priv(selectMode) word ::tk::spinbox::MouseSelect %W %x sel.first } bind Spinbox { set tk::Priv(selectMode) line ::tk::spinbox::MouseSelect %W %x 0 } bind Spinbox { set tk::Priv(selectMode) char %W selection adjust @%x } bind Spinbox { set tk::Priv(selectMode) word ::tk::spinbox::MouseSelect %W %x } bind Spinbox { set tk::Priv(selectMode) line ::tk::spinbox::MouseSelect %W %x } bind Spinbox { set tk::Priv(x) %x ::tk::spinbox::AutoScan %W } bind Spinbox { tk::CancelRepeat } bind Spinbox { ::tk::spinbox::ButtonUp %W %x %y } bind Spinbox { %W icursor @%x } bind Spinbox { %W invoke buttonup } bind Spinbox { %W invoke buttondown } bind Spinbox { ::tk::EntrySetCursor %W [expr {[%W index insert] - 1}] } bind Spinbox { ::tk::EntrySetCursor %W [expr {[%W index insert] + 1}] } bind Spinbox { ::tk::EntryKeySelect %W [expr {[%W index insert] - 1}] ::tk::EntrySeeInsert %W } bind Spinbox { ::tk::EntryKeySelect %W [expr {[%W index insert] + 1}] ::tk::EntrySeeInsert %W } bind Spinbox { ::tk::EntrySetCursor %W [::tk::EntryPreviousWord %W insert] } bind Spinbox { ::tk::EntrySetCursor %W [::tk::EntryNextWord %W insert] } bind Spinbox { ::tk::EntryKeySelect %W [::tk::EntryPreviousWord %W insert] ::tk::EntrySeeInsert %W } bind Spinbox { ::tk::EntryKeySelect %W [::tk::EntryNextWord %W insert] ::tk::EntrySeeInsert %W } bind Spinbox { ::tk::EntrySetCursor %W 0 } bind Spinbox { ::tk::EntryKeySelect %W 0 ::tk::EntrySeeInsert %W } bind Spinbox { ::tk::EntrySetCursor %W end } bind Spinbox { ::tk::EntryKeySelect %W end ::tk::EntrySeeInsert %W } bind Spinbox { if {[%W selection present]} { %W delete sel.first sel.last } else { %W delete insert } } bind Spinbox { ::tk::EntryBackspace %W } bind Spinbox { %W selection from insert } bind Spinbox { %W mark set anchor insert } bind Text { set tk::Priv(selectMode) char tk::TextKeyExtend %W insert } bind Text { set tk::Priv(selectMode) char tk::TextKeyExtend %W insert } bind Text { %W tag add sel 1.0 end } bind Text { %W tag remove sel 1.0 end } bind Text <> { tk_textCut %W } bind Text <> { tk_textCopy %W } bind Text <> { tk_textPaste %W } bind Text <> { catch {%W delete sel.first sel.last} } bind Text <> { if {$tk_strictMotif || ![info exists tk::Priv(mouseMoved)] || !$tk::Priv(mouseMoved)} { tk::TextPasteSelection %W %x %y } } bind Text { catch {tk::TextInsert %W [::tk::GetSelection %W PRIMARY]} } bind Text { tk::TextInsert %W %A } # Ignore all Alt, Meta, and Control keypresses unless explicitly bound. # Otherwise, if a widget binding for one of these is defined, the # class binding will also fire and insert the character, # which is wrong. Ditto for . bind Text {# nothing } bind Text {# nothing} bind Text {# nothing} bind Text {# nothing} bind Text {# nothing} if {[string equal [tk windowingsystem] "classic"] || [string equal [tk windowingsystem] "aqua"]} { bind Text {# nothing} } # Additional emacs-like bindings: bind Text { if {!$tk_strictMotif} { tk::TextSetCursor %W {insert linestart} } } bind Text { if {!$tk_strictMotif} { tk::TextSetCursor %W insert-1c } } bind Text { if {!$tk_strictMotif} { %W delete insert } } bind Text { if {!$tk_strictMotif} { tk::TextSetCursor %W {insert lineend} } } bind Text { if {!$tk_strictMotif} { tk::TextSetCursor %W insert+1c } } bind Text { if {!$tk_strictMotif} { if {[%W compare insert == {insert lineend}]} { %W delete insert } else { %W delete insert {insert lineend} } } } bind Text { if {!$tk_strictMotif} { tk::TextSetCursor %W [tk::TextUpDownLine %W 1] } } bind Text { if {!$tk_strictMotif} { %W insert insert \n %W mark set insert insert-1c } } bind Text { if {!$tk_strictMotif} { tk::TextSetCursor %W [tk::TextUpDownLine %W -1] } } bind Text { if {!$tk_strictMotif} { tk::TextTranspose %W } } bind Text <> { catch { %W edit undo } } bind Text <> { catch { %W edit redo } } if {$tcl_platform(platform) ne "windows"} { bind Text { if {!$tk_strictMotif} { tk::TextScrollPages %W 1 } } } bind Text { if {!$tk_strictMotif} { tk::TextSetCursor %W [tk::TextPrevPos %W insert tcl_startOfPreviousWord] } } bind Text { if {!$tk_strictMotif} { %W delete insert [tk::TextNextWord %W insert] } } bind Text { if {!$tk_strictMotif} { tk::TextSetCursor %W [tk::TextNextWord %W insert] } } bind Text { if {!$tk_strictMotif} { tk::TextSetCursor %W 1.0 } } bind Text { if {!$tk_strictMotif} { tk::TextSetCursor %W end-1c } } bind Text { if {!$tk_strictMotif} { %W delete [tk::TextPrevPos %W insert tcl_startOfPreviousWord] insert } } bind Text { if {!$tk_strictMotif} { %W delete [tk::TextPrevPos %W insert tcl_startOfPreviousWord] insert } } # Macintosh only bindings: # if text black & highlight black -> text white, other text the same if {[string equal [tk windowingsystem] "classic"] || [string equal [tk windowingsystem] "aqua"]} { bind Text { %W tag configure sel -borderwidth 0 %W configure -selectbackground systemHighlight -selectforeground systemHighlightText } bind Text { %W tag configure sel -borderwidth 1 %W configure -selectbackground white -selectforeground black } bind Text { tk::TextSetCursor %W [tk::TextPrevPos %W insert tcl_startOfPreviousWord] } bind Text { tk::TextSetCursor %W [tk::TextNextWord %W insert] } bind Text { tk::TextSetCursor %W [tk::TextPrevPara %W insert] } bind Text { tk::TextSetCursor %W [tk::TextNextPara %W insert] } bind Text { tk::TextKeySelect %W [tk::TextPrevPos %W insert tcl_startOfPreviousWord] } bind Text { tk::TextKeySelect %W [tk::TextNextWord %W insert] } bind Text { tk::TextKeySelect %W [tk::TextPrevPara %W insert] } bind Text { tk::TextKeySelect %W [tk::TextNextPara %W insert] } # End of Mac only bindings } # A few additional bindings of my own. bind Text { if {!$tk_strictMotif} { if {[%W compare insert != 1.0]} { %W delete insert-1c %W see insert } } } bind Text <2> { if {!$tk_strictMotif} { tk::TextScanMark %W %x %y } } bind Text { if {!$tk_strictMotif} { tk::TextScanDrag %W %x %y } } set ::tk::Priv(prevPos) {} # The MouseWheel will typically only fire on Windows. However, # someone could use the "event generate" command to produce one # on other platforms. if {[string equal [tk windowingsystem] "classic"] || [string equal [tk windowingsystem] "aqua"]} { bind Text { %W yview scroll [expr {- (%D)}] units } bind Text { %W yview scroll [expr {-10 * (%D)}] units } bind Text { %W xview scroll [expr {- (%D)}] units } bind Text { %W xview scroll [expr {-10 * (%D)}] units } } else { bind Text { %W yview scroll [expr {- (%D / 120) * 4}] units } } if {[string equal "x11" [tk windowingsystem]]} { # Support for mousewheels on Linux/Unix commonly comes through mapping # the wheel to the extended buttons. If you have a mousewheel, find # Linux configuration info at: # http://www.inria.fr/koala/colas/mouse-wheel-scroll/ bind Text <4> { if {!$tk_strictMotif} { %W yview scroll -5 units } } bind Text <5> { if {!$tk_strictMotif} { %W yview scroll 5 units } } } # ::tk::TextClosestGap -- # Given x and y coordinates, this procedure finds the closest boundary # between characters to the given coordinates and returns the index # of the character just after the boundary. # # Arguments: # w - The text window. # x - X-coordinate within the window. # y - Y-coordinate within the window. proc ::tk::TextClosestGap {w x y} { set pos [$w index @$x,$y] set bbox [$w bbox $pos] if {[string equal $bbox ""]} { return $pos } if {($x - [lindex $bbox 0]) < ([lindex $bbox 2]/2)} { return $pos } $w index "$pos + 1 char" } # ::tk::TextButton1 -- # This procedure is invoked to handle button-1 presses in text # widgets. It moves the insertion cursor, sets the selection anchor, # and claims the input focus. # # Arguments: # w - The text window in which the button was pressed. # x - The x-coordinate of the button press. # y - The x-coordinate of the button press. proc ::tk::TextButton1 {w x y} { variable ::tk::Priv set Priv(selectMode) char set Priv(mouseMoved) 0 set Priv(pressX) $x $w mark set insert [TextClosestGap $w $x $y] $w mark set anchor insert # Allow focus in any case on Windows, because that will let the # selection be displayed even for state disabled text widgets. if {[string equal $::tcl_platform(platform) "windows"] \ || [string equal [$w cget -state] "normal"]} {focus $w} if {[$w cget -autoseparators]} {$w edit separator} } # ::tk::TextSelectTo -- # This procedure is invoked to extend the selection, typically when # dragging it with the mouse. Depending on the selection mode (character, # word, line) it selects in different-sized units. This procedure # ignores mouse motions initially until the mouse has moved from # one character to another or until there have been multiple clicks. # # Arguments: # w - The text window in which the button was pressed. # x - Mouse x position. # y - Mouse y position. proc ::tk::TextSelectTo {w x y {extend 0}} { global tcl_platform variable ::tk::Priv set cur [TextClosestGap $w $x $y] if {[catch {$w index anchor}]} { $w mark set anchor $cur } set anchor [$w index anchor] if {[$w compare $cur != $anchor] || (abs($Priv(pressX) - $x) >= 3)} { set Priv(mouseMoved) 1 } switch $Priv(selectMode) { char { if {[$w compare $cur < anchor]} { set first $cur set last anchor } else { set first anchor set last $cur } } word { if {[$w compare $cur < anchor]} { set first [TextPrevPos $w "$cur + 1c" tcl_wordBreakBefore] if { !$extend } { set last [TextNextPos $w "anchor" tcl_wordBreakAfter] } else { set last anchor } } else { set last [TextNextPos $w "$cur - 1c" tcl_wordBreakAfter] if { !$extend } { set first [TextPrevPos $w anchor tcl_wordBreakBefore] } else { set first anchor } } } line { if {[$w compare $cur < anchor]} { set first [$w index "$cur linestart"] set last [$w index "anchor - 1c lineend + 1c"] } else { set first [$w index "anchor linestart"] set last [$w index "$cur lineend + 1c"] } } } if {$Priv(mouseMoved) || $Priv(selectMode) ne "char"} { $w tag remove sel 0.0 end $w mark set insert $cur $w tag add sel $first $last $w tag remove sel $last end update idletasks } } # ::tk::TextKeyExtend -- # This procedure handles extending the selection from the keyboard, # where the point to extend to is really the boundary between two # characters rather than a particular character. # # Arguments: # w - The text window. # index - The point to which the selection is to be extended. proc ::tk::TextKeyExtend {w index} { set cur [$w index $index] if {[catch {$w index anchor}]} { $w mark set anchor $cur } set anchor [$w index anchor] if {[$w compare $cur < anchor]} { set first $cur set last anchor } else { set first anchor set last $cur } $w tag remove sel 0.0 $first $w tag add sel $first $last $w tag remove sel $last end } # ::tk::TextPasteSelection -- # This procedure sets the insertion cursor to the mouse position, # inserts the selection, and sets the focus to the window. # # Arguments: # w - The text window. # x, y - Position of the mouse. proc ::tk::TextPasteSelection {w x y} { $w mark set insert [TextClosestGap $w $x $y] if {![catch {::tk::GetSelection $w PRIMARY} sel]} { set oldSeparator [$w cget -autoseparators] if {$oldSeparator} { $w configure -autoseparators 0 $w edit separator } $w insert insert $sel if {$oldSeparator} { $w edit separator $w configure -autoseparators 1 } } if {[string equal [$w cget -state] "normal"]} {focus $w} } # ::tk::TextAutoScan -- # This procedure is invoked when the mouse leaves a text window # with button 1 down. It scrolls the window up, down, left, or right, # depending on where the mouse is (this information was saved in # ::tk::Priv(x) and ::tk::Priv(y)), and reschedules itself as an "after" # command so that the window continues to scroll until the mouse # moves back into the window or the mouse button is released. # # Arguments: # w - The text window. proc ::tk::TextAutoScan {w} { variable ::tk::Priv if {![winfo exists $w]} return if {$Priv(y) >= [winfo height $w]} { $w yview scroll 2 units } elseif {$Priv(y) < 0} { $w yview scroll -2 units } elseif {$Priv(x) >= [winfo width $w]} { $w xview scroll 2 units } elseif {$Priv(x) < 0} { $w xview scroll -2 units } else { return } TextSelectTo $w $Priv(x) $Priv(y) set Priv(afterId) [after 50 [list tk::TextAutoScan $w]] } # ::tk::TextSetCursor # Move the insertion cursor to a given position in a text. Also # clears the selection, if there is one in the text, and makes sure # that the insertion cursor is visible. Also, don't let the insertion # cursor appear on the dummy last line of the text. # # Arguments: # w - The text window. # pos - The desired new position for the cursor in the window. proc ::tk::TextSetCursor {w pos} { if {[$w compare $pos == end]} { set pos {end - 1 chars} } $w mark set insert $pos $w tag remove sel 1.0 end $w see insert if {[$w cget -autoseparators]} {$w edit separator} } # ::tk::TextKeySelect # This procedure is invoked when stroking out selections using the # keyboard. It moves the cursor to a new position, then extends # the selection to that position. # # Arguments: # w - The text window. # new - A new position for the insertion cursor (the cursor hasn't # actually been moved to this position yet). proc ::tk::TextKeySelect {w new} { if {[string equal [$w tag nextrange sel 1.0 end] ""]} { if {[$w compare $new < insert]} { $w tag add sel $new insert } else { $w tag add sel insert $new } $w mark set anchor insert } else { if {[$w compare $new < anchor]} { set first $new set last anchor } else { set first anchor set last $new } $w tag remove sel 1.0 $first $w tag add sel $first $last $w tag remove sel $last end } $w mark set insert $new $w see insert update idletasks } # ::tk::TextResetAnchor -- # Set the selection anchor to whichever end is farthest from the # index argument. One special trick: if the selection has two or # fewer characters, just leave the anchor where it is. In this # case it doesn't matter which point gets chosen for the anchor, # and for the things like Shift-Left and Shift-Right this produces # better behavior when the cursor moves back and forth across the # anchor. # # Arguments: # w - The text widget. # index - Position at which mouse button was pressed, which determines # which end of selection should be used as anchor point. proc ::tk::TextResetAnchor {w index} { if {[string equal [$w tag ranges sel] ""]} { # Don't move the anchor if there is no selection now; this makes # the widget behave "correctly" when the user clicks once, then # shift-clicks somewhere -- ie, the area between the two clicks will be # selected. [Bug: 5929]. return } set a [$w index $index] set b [$w index sel.first] set c [$w index sel.last] if {[$w compare $a < $b]} { $w mark set anchor sel.last return } if {[$w compare $a > $c]} { $w mark set anchor sel.first return } scan $a "%d.%d" lineA chA scan $b "%d.%d" lineB chB scan $c "%d.%d" lineC chC if {$lineB < $lineC+2} { set total [string length [$w get $b $c]] if {$total <= 2} { return } if {[string length [$w get $b $a]] < ($total/2)} { $w mark set anchor sel.last } else { $w mark set anchor sel.first } return } if {($lineA-$lineB) < ($lineC-$lineA)} { $w mark set anchor sel.last } else { $w mark set anchor sel.first } } # ::tk::TextInsert -- # Insert a string into a text at the point of the insertion cursor. # If there is a selection in the text, and it covers the point of the # insertion cursor, then delete the selection before inserting. # # Arguments: # w - The text window in which to insert the string # s - The string to insert (usually just a single character) proc ::tk::TextInsert {w s} { if {[string equal $s ""] || [string equal [$w cget -state] "disabled"]} { return } set compound 0 catch { if {[$w compare sel.first <= insert] \ && [$w compare sel.last >= insert]} { set oldSeparator [$w cget -autoseparators] if { $oldSeparator } { $w configure -autoseparators 0 $w edit separator set compound 1 } $w delete sel.first sel.last } } $w insert insert $s $w see insert if { $compound && $oldSeparator } { $w edit separator $w configure -autoseparators 1 } } # ::tk::TextUpDownLine -- # Returns the index of the character one line above or below the # insertion cursor. There are two tricky things here. First, # we want to maintain the original column across repeated operations, # even though some lines that will get passed through don't have # enough characters to cover the original column. Second, don't # try to scroll past the beginning or end of the text. # # Arguments: # w - The text window in which the cursor is to move. # n - The number of lines to move: -1 for up one line, # +1 for down one line. proc ::tk::TextUpDownLine {w n} { variable ::tk::Priv set i [$w index insert] scan $i "%d.%d" line char if {$Priv(prevPos) ne $i} { set Priv(char) $char } set new [$w index [expr {$line + $n}].$Priv(char)] if {[$w compare $new == end] || [$w compare $new == "insert linestart"]} { set new $i } set Priv(prevPos) $new return $new } # ::tk::TextPrevPara -- # Returns the index of the beginning of the paragraph just before a given # position in the text (the beginning of a paragraph is the first non-blank # character after a blank line). # # Arguments: # w - The text window in which the cursor is to move. # pos - Position at which to start search. proc ::tk::TextPrevPara {w pos} { set pos [$w index "$pos linestart"] while {1} { if {([string equal [$w get "$pos - 1 line"] "\n"] \ && [$w get $pos] ne "\n") || [string equal $pos 1.0]} { if {[regexp -indices {^[ ]+(.)} [$w get $pos "$pos lineend"] \ dummy index]} { set pos [$w index "$pos + [lindex $index 0] chars"] } if {[$w compare $pos != insert] || [string equal $pos 1.0]} { return $pos } } set pos [$w index "$pos - 1 line"] } } # ::tk::TextNextPara -- # Returns the index of the beginning of the paragraph just after a given # position in the text (the beginning of a paragraph is the first non-blank # character after a blank line). # # Arguments: # w - The text window in which the cursor is to move. # start - Position at which to start search. proc ::tk::TextNextPara {w start} { set pos [$w index "$start linestart + 1 line"] while {[$w get $pos] ne "\n"} { if {[$w compare $pos == end]} { return [$w index "end - 1c"] } set pos [$w index "$pos + 1 line"] } while {[$w get $pos] eq "\n"} { set pos [$w index "$pos + 1 line"] if {[$w compare $pos == end]} { return [$w index "end - 1c"] } } if {[regexp -indices {^[ ]+(.)} [$w get $pos "$pos lineend"] \ dummy index]} { return [$w index "$pos + [lindex $index 0] chars"] } return $pos } # ::tk::TextScrollPages -- # This is a utility procedure used in bindings for moving up and down # pages and possibly extending the selection along the way. It scrolls # the view in the widget by the number of pages, and it returns the # index of the character that is at the same position in the new view # as the insertion cursor used to be in the old view. # # Arguments: # w - The text window in which the cursor is to move. # count - Number of pages forward to scroll; may be negative # to scroll backwards. proc ::tk::TextScrollPages {w count} { set bbox [$w bbox insert] $w yview scroll $count pages if {[string equal $bbox ""]} { return [$w index @[expr {[winfo height $w]/2}],0] } return [$w index @[lindex $bbox 0],[lindex $bbox 1]] } # ::tk::TextTranspose -- # This procedure implements the "transpose" function for text widgets. # It tranposes the characters on either side of the insertion cursor, # unless the cursor is at the end of the line. In this case it # transposes the two characters to the left of the cursor. In either # case, the cursor ends up to the right of the transposed characters. # # Arguments: # w - Text window in which to transpose. proc ::tk::TextTranspose w { set pos insert if {[$w compare $pos != "$pos lineend"]} { set pos [$w index "$pos + 1 char"] } set new [$w get "$pos - 1 char"][$w get "$pos - 2 char"] if {[$w compare "$pos - 1 char" == 1.0]} { return } # ensure this is seen as an atomic op to undo set autosep [$w cget -autoseparators] if {$autosep} { $w configure -autoseparators 0 $w edit separator } $w delete "$pos - 2 char" $pos $w insert insert $new $w see insert if {$autosep} { $w edit separator $w configure -autoseparators $autosep } } # ::tk_textCopy -- # This procedure copies the selection from a text widget into the # clipboard. # # Arguments: # w - Name of a text widget. proc ::tk_textCopy w { if {![catch {set data [$w get sel.first sel.last]}]} { clipboard clear -displayof $w clipboard append -displayof $w $data } } # ::tk_textCut -- # This procedure copies the selection from a text widget into the # clipboard, then deletes the selection (if it exists in the given # widget). # # Arguments: # w - Name of a text widget. proc ::tk_textCut w { if {![catch {set data [$w get sel.first sel.last]}]} { clipboard clear -displayof $w clipboard append -displayof $w $data $w delete sel.first sel.last } } # ::tk_textPaste -- # This procedure pastes the contents of the clipboard to the insertion # point in a text widget. # # Arguments: # w - Name of a text widget. proc ::tk_textPaste w { global tcl_platform if {![catch {::tk::GetSelection $w CLIPBOARD} sel]} { # ensure this is seen as an atomic op to undo set oldSeparator [$w cget -autoseparators] if { $oldSeparator } { $w configure -autoseparators 0 $w edit separator } if {[tk windowingsystem] ne "x11"} { catch { $w delete sel.first sel.last } } $w insert insert $sel if { $oldSeparator } { $w edit separator $w configure -autoseparators 1 } } } # ::tk::TextNextWord -- # Returns the index of the next word position after a given position in the # text. The next word is platform dependent and may be either the next # end-of-word position or the next start-of-word position after the next # end-of-word position. # # Arguments: # w - The text window in which the cursor is to move. # start - Position at which to start search. if {[string equal $tcl_platform(platform) "windows"]} { proc ::tk::TextNextWord {w start} { TextNextPos $w [TextNextPos $w $start tcl_endOfWord] \ tcl_startOfNextWord } } else { proc ::tk::TextNextWord {w start} { TextNextPos $w $start tcl_endOfWord } } # ::tk::TextNextPos -- # Returns the index of the next position after the given starting # position in the text as computed by a specified function. # # Arguments: # w - The text window in which the cursor is to move. # start - Position at which to start search. # op - Function to use to find next position. proc ::tk::TextNextPos {w start op} { set text "" set cur $start while {[$w compare $cur < end]} { set text $text[$w get $cur "$cur lineend + 1c"] set pos [$op $text 0] if {$pos >= 0} { ## Adjust for embedded windows and images ## dump gives us 3 items per window/image set dump [$w dump -image -window $start "$start + $pos c"] if {[llength $dump]} { set pos [expr {$pos + ([llength $dump]/3)}] } return [$w index "$start + $pos c"] } set cur [$w index "$cur lineend +1c"] } return end } # ::tk::TextPrevPos -- # Returns the index of the previous position before the given starting # position in the text as computed by a specified function. # # Arguments: # w - The text window in which the cursor is to move. # start - Position at which to start search. # op - Function to use to find next position. proc ::tk::TextPrevPos {w start op} { set text "" set cur $start while {[$w compare $cur > 0.0]} { set text [$w get "$cur linestart - 1c" $cur]$text set pos [$op $text end] if {$pos >= 0} { ## Adjust for embedded windows and images ## dump gives us 3 items per window/image set dump [$w dump -image -window "$cur linestart" "$start - 1c"] if {[llength $dump]} { ## This is a hokey extra hack for control-arrow movement ## that should be in a while loop to be correct (hobbs) if {[$w compare [lindex $dump 2] > \ "$cur linestart - 1c + $pos c"]} { incr pos -1 } set pos [expr {$pos + ([llength $dump]/3)}] } return [$w index "$cur linestart - 1c + $pos c"] } set cur [$w index "$cur linestart - 1c"] } return 0.0 } # ::tk::TextScanMark -- # # Marks the start of a possible scan drag operation # # Arguments: # w - The text window from which the text to get # x - x location on screen # y - y location on screen proc ::tk::TextScanMark {w x y} { $w scan mark $x $y set ::tk::Priv(x) $x set ::tk::Priv(y) $y set ::tk::Priv(mouseMoved) 0 } # ::tk::TextScanDrag -- # # Marks the start of a possible scan drag operation # # Arguments: # w - The text window from which the text to get # x - x location on screen # y - y location on screen proc ::tk::TextScanDrag {w x y} { # Make sure these exist, as some weird situations can trigger the # motion binding without the initial press. [Bug #220269] if {![info exists ::tk::Priv(x)]} { set ::tk::Priv(x) $x } if {![info exists ::tk::Priv(y)]} { set ::tk::Priv(y) $y } if {($x != $::tk::Priv(x)) || ($y != $::tk::Priv(y))} { set ::tk::Priv(mouseMoved) 1 } if {[info exists ::tk::Priv(mouseMoved)] && $::tk::Priv(mouseMoved)} { $w scan dragto $x $y } } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/tk.tcl0100644000000000001200000004152010153074440027221 0ustar rootadmin# tk.tcl -- # # Initialization script normally executed in the interpreter for each # Tk-based application. Arranges class bindings for widgets. # # RCS: @(#) $Id: tk.tcl,v 1.46.2.2 2004/10/29 11:16:37 patthoyts Exp $ # # Copyright (c) 1992-1994 The Regents of the University of California. # Copyright (c) 1994-1996 Sun Microsystems, Inc. # Copyright (c) 1998-2000 Ajuba Solutions. # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # Insist on running with compatible versions of Tcl and Tk. package require -exact Tk 8.4 package require -exact Tcl 8.4 # Create a ::tk namespace namespace eval ::tk { # Set up the msgcat commands namespace eval msgcat { namespace export mc mcmax if {[interp issafe] || [catch {package require msgcat}]} { # The msgcat package is not available. Supply our own # minimal replacement. proc mc {src args} { return [eval [list format $src] $args] } proc mcmax {args} { set max 0 foreach string $args { set len [string length $string] if {$len>$max} { set max $len } } return $max } } else { # Get the commands from the msgcat package that Tk uses. namespace import ::msgcat::mc namespace import ::msgcat::mcmax ::msgcat::mcload [file join $::tk_library msgs] } } namespace import ::tk::msgcat::* } # Add Tk's directory to the end of the auto-load search path, if it # isn't already on the path: if {[info exists ::auto_path] && [string compare {} $::tk_library] && \ [lsearch -exact $::auto_path $::tk_library] < 0} { lappend ::auto_path $::tk_library } # Turn off strict Motif look and feel as a default. set ::tk_strictMotif 0 # Turn on useinputmethods (X Input Methods) by default. # We catch this because safe interpreters may not allow the call. catch {tk useinputmethods 1} # ::tk::PlaceWindow -- # place a toplevel at a particular position # Arguments: # toplevel name of toplevel window # ?placement? pointer ?center? ; places $w centered on the pointer # widget widgetPath ; centers $w over widget_name # defaults to placing toplevel in the middle of the screen # ?anchor? center or widgetPath # Results: # Returns nothing # proc ::tk::PlaceWindow {w {place ""} {anchor ""}} { wm withdraw $w update idletasks set checkBounds 1 if {$place eq ""} { set x [expr {([winfo screenwidth $w]-[winfo reqwidth $w])/2}] set y [expr {([winfo screenheight $w]-[winfo reqheight $w])/2}] set checkBounds 0 } elseif {[string equal -len [string length $place] $place "pointer"]} { ## place at POINTER (centered if $anchor == center) if {[string equal -len [string length $anchor] $anchor "center"]} { set x [expr {[winfo pointerx $w]-[winfo reqwidth $w]/2}] set y [expr {[winfo pointery $w]-[winfo reqheight $w]/2}] } else { set x [winfo pointerx $w] set y [winfo pointery $w] } } elseif {[string equal -len [string length $place] $place "widget"] && \ [winfo exists $anchor] && [winfo ismapped $anchor]} { ## center about WIDGET $anchor, widget must be mapped set x [expr {[winfo rootx $anchor] + \ ([winfo width $anchor]-[winfo reqwidth $w])/2}] set y [expr {[winfo rooty $anchor] + \ ([winfo height $anchor]-[winfo reqheight $w])/2}] } else { set x [expr {([winfo screenwidth $w]-[winfo reqwidth $w])/2}] set y [expr {([winfo screenheight $w]-[winfo reqheight $w])/2}] set checkBounds 0 } if {[tk windowingsystem] eq "win32"} { # Bug 533519: win32 multiple desktops may produce negative geometry. set checkBounds 0 } if {$checkBounds} { if {$x < 0} { set x 0 } elseif {$x > ([winfo screenwidth $w]-[winfo reqwidth $w])} { set x [expr {[winfo screenwidth $w]-[winfo reqwidth $w]}] } if {$y < 0} { set y 0 } elseif {$y > ([winfo screenheight $w]-[winfo reqheight $w])} { set y [expr {[winfo screenheight $w]-[winfo reqheight $w]}] } if {[tk windowingsystem] eq "macintosh" \ || [tk windowingsystem] eq "aqua"} { # Avoid the native menu bar which sits on top of everything. if {$y < 20} { set y 20 } } } wm geometry $w +$x+$y wm deiconify $w } # ::tk::SetFocusGrab -- # swap out current focus and grab temporarily (for dialogs) # Arguments: # grab new window to grab # focus window to give focus to # Results: # Returns nothing # proc ::tk::SetFocusGrab {grab {focus {}}} { set index "$grab,$focus" upvar ::tk::FocusGrab($index) data lappend data [focus] set oldGrab [grab current $grab] lappend data $oldGrab if {[winfo exists $oldGrab]} { lappend data [grab status $oldGrab] } # The "grab" command will fail if another application # already holds the grab. So catch it. catch {grab $grab} if {[winfo exists $focus]} { focus $focus } } # ::tk::RestoreFocusGrab -- # restore old focus and grab (for dialogs) # Arguments: # grab window that had taken grab # focus window that had taken focus # destroy destroy|withdraw - how to handle the old grabbed window # Results: # Returns nothing # proc ::tk::RestoreFocusGrab {grab focus {destroy destroy}} { set index "$grab,$focus" if {[info exists ::tk::FocusGrab($index)]} { foreach {oldFocus oldGrab oldStatus} $::tk::FocusGrab($index) { break } unset ::tk::FocusGrab($index) } else { set oldGrab "" } catch {focus $oldFocus} grab release $grab if {[string equal $destroy "withdraw"]} { wm withdraw $grab } else { destroy $grab } if {[winfo exists $oldGrab] && [winfo ismapped $oldGrab]} { if {[string equal $oldStatus "global"]} { grab -global $oldGrab } else { grab $oldGrab } } } # ::tk::GetSelection -- # This tries to obtain the default selection. On Unix, we first try # and get a UTF8_STRING, a type supported by modern Unix apps for # passing Unicode data safely. We fall back on the default STRING # type otherwise. On Windows, only the STRING type is necessary. # Arguments: # w The widget for which the selection will be retrieved. # Important for the -displayof property. # sel The source of the selection (PRIMARY or CLIPBOARD) # Results: # Returns the selection, or an error if none could be found # if {[string equal $tcl_platform(platform) "unix"]} { proc ::tk::GetSelection {w {sel PRIMARY}} { if {[catch {selection get -displayof $w -selection $sel \ -type UTF8_STRING} txt] \ && [catch {selection get -displayof $w -selection $sel} txt]} { return -code error "could not find default selection" } else { return $txt } } } else { proc ::tk::GetSelection {w {sel PRIMARY}} { if {[catch {selection get -displayof $w -selection $sel} txt]} { return -code error "could not find default selection" } else { return $txt } } } # ::tk::ScreenChanged -- # This procedure is invoked by the binding mechanism whenever the # "current" screen is changing. The procedure does two things. # First, it uses "upvar" to make variable "::tk::Priv" point at an # array variable that holds state for the current display. Second, # it initializes the array if it didn't already exist. # # Arguments: # screen - The name of the new screen. proc ::tk::ScreenChanged screen { set x [string last . $screen] if {$x > 0} { set disp [string range $screen 0 [expr {$x - 1}]] } else { set disp $screen } uplevel #0 upvar #0 ::tk::Priv.$disp ::tk::Priv variable ::tk::Priv global tcl_platform if {[info exists Priv]} { set Priv(screen) $screen return } array set Priv { activeMenu {} activeItem {} afterId {} buttons 0 buttonWindow {} dragging 0 focus {} grab {} initPos {} inMenubutton {} listboxPrev {} menuBar {} mouseMoved 0 oldGrab {} popup {} postedMb {} pressX 0 pressY 0 prevPos 0 selectMode char } set Priv(screen) $screen set Priv(tearoff) [string equal [tk windowingsystem] "x11"] set Priv(window) {} } # Do initial setup for Priv, so that it is always bound to something # (otherwise, if someone references it, it may get set to a non-upvar-ed # value, which will cause trouble later). tk::ScreenChanged [winfo screen .] # ::tk::EventMotifBindings -- # This procedure is invoked as a trace whenever ::tk_strictMotif is # changed. It is used to turn on or turn off the motif virtual # bindings. # # Arguments: # n1 - the name of the variable being changed ("::tk_strictMotif"). proc ::tk::EventMotifBindings {n1 dummy dummy} { upvar $n1 name if {$name} { set op delete } else { set op add } event $op <> event $op <> event $op <> event $op <> } #---------------------------------------------------------------------- # Define common dialogs on platforms where they are not implemented # using compiled code. #---------------------------------------------------------------------- if {[string equal [info commands tk_chooseColor] ""]} { proc ::tk_chooseColor {args} { return [eval tk::dialog::color:: $args] } } if {[string equal [info commands tk_getOpenFile] ""]} { proc ::tk_getOpenFile {args} { if {$::tk_strictMotif} { return [eval tk::MotifFDialog open $args] } else { return [eval ::tk::dialog::file:: open $args] } } } if {[string equal [info commands tk_getSaveFile] ""]} { proc ::tk_getSaveFile {args} { if {$::tk_strictMotif} { return [eval tk::MotifFDialog save $args] } else { return [eval ::tk::dialog::file:: save $args] } } } if {[string equal [info commands tk_messageBox] ""]} { proc ::tk_messageBox {args} { return [eval tk::MessageBox $args] } } if {[string equal [info command tk_chooseDirectory] ""]} { proc ::tk_chooseDirectory {args} { return [eval ::tk::dialog::file::chooseDir:: $args] } } #---------------------------------------------------------------------- # Define the set of common virtual events. #---------------------------------------------------------------------- switch [tk windowingsystem] { "x11" { event add <> event add <> event add <> event add <> event add <> event add <> # Some OS's define a goofy (as in, not ) keysym # that is returned when the user presses . In order for # tab traversal to work, we have to add these keysyms to the # PrevWindow event. # We use catch just in case the keysym isn't recognized. # This is needed for XFree86 systems catch { event add <> } # This seems to be correct on *some* HP systems. catch { event add <> } trace variable ::tk_strictMotif w ::tk::EventMotifBindings set ::tk_strictMotif $::tk_strictMotif } "win32" { event add <> event add <> event add <> event add <> event add <> event add <> } "aqua" { event add <> event add <> event add <> event add <> event add <> event add <> event add <> } "classic" { event add <> event add <> event add <> event add <> event add <> event add <> event add <> } } # ---------------------------------------------------------------------- # Read in files that define all of the class bindings. # ---------------------------------------------------------------------- if {$::tk_library ne ""} { if {[string equal $tcl_platform(platform) "macintosh"]} { proc ::tk::SourceLibFile {file} { if {[catch { namespace eval :: \ [list source [file join $::tk_library $file.tcl]] }]} { namespace eval :: [list source -rsrc $file] } } } else { proc ::tk::SourceLibFile {file} { namespace eval :: [list source [file join $::tk_library $file.tcl]] } } namespace eval ::tk { SourceLibFile button SourceLibFile entry SourceLibFile listbox SourceLibFile menu SourceLibFile panedwindow SourceLibFile scale SourceLibFile scrlbar SourceLibFile spinbox SourceLibFile text } } # ---------------------------------------------------------------------- # Default bindings for keyboard traversal. # ---------------------------------------------------------------------- event add <> bind all {tk::TabToWindow [tk_focusNext %W]} bind all <> {tk::TabToWindow [tk_focusPrev %W]} # ::tk::CancelRepeat -- # This procedure is invoked to cancel an auto-repeat action described # by ::tk::Priv(afterId). It's used by several widgets to auto-scroll # the widget when the mouse is dragged out of the widget with a # button pressed. # # Arguments: # None. proc ::tk::CancelRepeat {} { variable ::tk::Priv after cancel $Priv(afterId) set Priv(afterId) {} } # ::tk::TabToWindow -- # This procedure moves the focus to the given widget. If the widget # is an entry or a spinbox, it selects the entire contents of the widget. # # Arguments: # w - Window to which focus should be set. proc ::tk::TabToWindow {w} { if {[string equal [winfo class $w] Entry] \ || [string equal [winfo class $w] Spinbox]} { $w selection range 0 end $w icursor end } focus $w } # ::tk::UnderlineAmpersand -- # This procedure takes some text with ampersand and returns # text w/o ampersand and position of the ampersand. # Double ampersands are converted to single ones. # Position returned is -1 when there is no ampersand. # proc ::tk::UnderlineAmpersand {text} { set idx [string first "&" $text] if {$idx >= 0} { set underline $idx # ignore "&&" while {[string match "&" [string index $text [expr {$idx + 1}]]]} { set base [expr {$idx + 2}] set idx [string first "&" [string range $text $base end]] if {$idx < 0} { break } else { set underline [expr {$underline + $idx + 1}] incr idx $base } } } if {$idx >= 0} { regsub -all -- {&([^&])} $text {\1} text } return [list $text $idx] } # ::tk::SetAmpText -- # Given widget path and text with "magic ampersands", # sets -text and -underline options for the widget # proc ::tk::SetAmpText {widget text} { foreach {newtext under} [::tk::UnderlineAmpersand $text] { $widget configure -text $newtext -underline $under } } # ::tk::AmpWidget -- # Creates new widget, turning -text option into -text and # -underline options, returned by ::tk::UnderlineAmpersand. # proc ::tk::AmpWidget {class path args} { set wcmd [list $class $path] foreach {opt val} $args { if {[string equal $opt {-text}]} { foreach {newtext under} [::tk::UnderlineAmpersand $val] { lappend wcmd -text $newtext -underline $under } } else { lappend wcmd $opt $val } } eval $wcmd if {$class=="button"} { bind $path <> [list $path invoke] } return $path } # ::tk::FindAltKeyTarget -- # search recursively through the hierarchy of visible widgets # to find button or label which has $char as underlined character # proc ::tk::FindAltKeyTarget {path char} { switch [winfo class $path] { Button - Label { if {[string equal -nocase $char \ [string index [$path cget -text] \ [$path cget -underline]]]} {return $path} else {return {}} } default { foreach child \ [concat [grid slaves $path] \ [pack slaves $path] \ [place slaves $path] ] { if {""!=[set target [::tk::FindAltKeyTarget $child $char]]} { return $target } } } } return {} } # ::tk::AltKeyInDialog -- # event handler for standard dialogs. Sends <> # to button or label which has appropriate underlined character # proc ::tk::AltKeyInDialog {path key} { set target [::tk::FindAltKeyTarget $path $key] if { $target == ""} return event generate $target <> } # ::tk::mcmaxamp -- # Replacement for mcmax, used for texts with "magic ampersand" in it. # proc ::tk::mcmaxamp {args} { set maxlen 0 foreach arg $args { set length [string length [lindex [::tk::UnderlineAmpersand [mc $arg]] 0]] if {$length>$maxlen} { set maxlen $length } } return $maxlen } # For now, turn off the custom mdef proc for the mac: if {[string equal [tk windowingsystem] "aqua"]} { namespace eval ::tk::mac { set useCustomMDEF 0 } } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/tkfbox.tcl0100644000000000001200000014042310153074440030102 0ustar rootadmin# 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. # # RCS: @(#) $Id: tkfbox.tcl,v 1.38.2.7 2004/09/10 22:28:30 dkf Exp $ # # 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. # #---------------------------------------------------------------------- # # I C O N L I S T # # This is a pseudo-widget that implements the icon list inside the # ::tk::dialog::file:: dialog box. # #---------------------------------------------------------------------- # ::tk::IconList -- # # Creates an IconList widget. # proc ::tk::IconList {w args} { IconList_Config $w $args IconList_Create $w } proc ::tk::IconList_Index {w i} { upvar #0 ::tk::$w data upvar #0 ::tk::$w:itemList itemList if {![info exists data(list)]} {set data(list) {}} switch -regexp -- $i { "^-?[0-9]+$" { if { $i < 0 } { set i 0 } if { $i >= [llength $data(list)] } { set i [expr {[llength $data(list)] - 1}] } return $i } "^active$" { return $data(index,active) } "^anchor$" { return $data(index,anchor) } "^end$" { return [llength $data(list)] } "@-?[0-9]+,-?[0-9]+" { foreach {x y} [scan $i "@%d,%d"] { break } set item [$data(canvas) find closest $x $y] return [lindex [$data(canvas) itemcget $item -tags] 1] } } } proc ::tk::IconList_Selection {w op args} { upvar ::tk::$w data switch -exact -- $op { "anchor" { if { [llength $args] == 1 } { set data(index,anchor) [tk::IconList_Index $w [lindex $args 0]] } else { return $data(index,anchor) } } "clear" { if { [llength $args] == 2 } { foreach {first last} $args { break } } elseif { [llength $args] == 1 } { set first [set last [lindex $args 0]] } else { error "wrong # args: should be [lindex [info level 0] 0] path\ clear first ?last?" } set first [IconList_Index $w $first] set last [IconList_Index $w $last] if { $first > $last } { set tmp $first set first $last set last $tmp } set ind 0 foreach item $data(selection) { if { $item >= $first } { set first $ind break } } set ind [expr {[llength $data(selection)] - 1}] for {} {$ind >= 0} {incr ind -1} { set item [lindex $data(selection) $ind] if { $item <= $last } { set last $ind break } } if { $first > $last } { return } set data(selection) [lreplace $data(selection) $first $last] event generate $w <> IconList_DrawSelection $w } "includes" { set index [lsearch -exact $data(selection) [lindex $args 0]] return [expr {$index != -1}] } "set" { if { [llength $args] == 2 } { foreach {first last} $args { break } } elseif { [llength $args] == 1 } { set last [set first [lindex $args 0]] } else { error "wrong # args: should be [lindex [info level 0] 0] path\ set first ?last?" } set first [IconList_Index $w $first] set last [IconList_Index $w $last] if { $first > $last } { set tmp $first set first $last set last $tmp } for {set i $first} {$i <= $last} {incr i} { lappend data(selection) $i } set data(selection) [lsort -integer -unique $data(selection)] event generate $w <> IconList_DrawSelection $w } } } proc ::tk::IconList_Curselection {w} { upvar ::tk::$w data return $data(selection) } proc ::tk::IconList_DrawSelection {w} { upvar ::tk::$w data upvar ::tk::$w:itemList itemList $data(canvas) delete selection foreach item $data(selection) { set rTag [lindex [lindex $data(list) $item] 2] foreach {iTag tTag text serial} $itemList($rTag) { break } set bbox [$data(canvas) bbox $tTag] $data(canvas) create rect $bbox -fill \#a0a0ff -outline \#a0a0ff \ -tags selection } $data(canvas) lower selection return } proc ::tk::IconList_Get {w item} { upvar ::tk::$w data upvar ::tk::$w:itemList itemList set rTag [lindex [lindex $data(list) $item] 2] foreach {iTag tTag text serial} $itemList($rTag) { break } return $text } # ::tk::IconList_Config -- # # Configure the widget variables of IconList, according to the command # line arguments. # proc ::tk::IconList_Config {w argList} { # 1: the configuration specs # set specs { {-command "" "" ""} {-multiple "" "" "0"} } # 2: parse the arguments # tclParseConfigSpec ::tk::$w $specs "" $argList } # ::tk::IconList_Create -- # # Creates an IconList widget by assembling a canvas widget and a # scrollbar widget. Sets all the bindings necessary for the IconList's # operations. # proc ::tk::IconList_Create {w} { upvar ::tk::$w data frame $w set data(sbar) [scrollbar $w.sbar -orient horizontal \ -highlightthickness 0 -takefocus 0] set data(canvas) [canvas $w.canvas -bd 2 -relief sunken \ -width 400 -height 120 -takefocus 1] pack $data(sbar) -side bottom -fill x -padx 2 pack $data(canvas) -expand yes -fill both $data(sbar) config -command [list $data(canvas) xview] $data(canvas) config -xscrollcommand [list $data(sbar) set] # Initializes the max icon/text width and height and other variables # set data(maxIW) 1 set data(maxIH) 1 set data(maxTW) 1 set data(maxTH) 1 set data(numItems) 0 set data(curItem) {} set data(noScroll) 1 set data(selection) {} set data(index,anchor) "" set fg [option get $data(canvas) foreground Foreground] if {$fg eq ""} { set data(fill) black } else { set data(fill) $fg } # Creates the event bindings. # bind $data(canvas) [list tk::IconList_Arrange $w] bind $data(canvas) <1> [list tk::IconList_Btn1 $w %x %y] bind $data(canvas) [list tk::IconList_Motion1 $w %x %y] bind $data(canvas) [list tk::IconList_Leave1 $w %x %y] bind $data(canvas) [list tk::IconList_CtrlBtn1 $w %x %y] bind $data(canvas) [list tk::IconList_ShiftBtn1 $w %x %y] bind $data(canvas) [list tk::CancelRepeat] bind $data(canvas) [list tk::CancelRepeat] bind $data(canvas) \ [list tk::IconList_Double1 $w %x %y] bind $data(canvas) [list tk::IconList_UpDown $w -1] bind $data(canvas) [list tk::IconList_UpDown $w 1] bind $data(canvas) [list tk::IconList_LeftRight $w -1] bind $data(canvas) [list tk::IconList_LeftRight $w 1] bind $data(canvas) [list tk::IconList_ReturnKey $w] bind $data(canvas) [list tk::IconList_KeyPress $w %A] bind $data(canvas) ";" bind $data(canvas) ";" bind $data(canvas) [list tk::IconList_FocusIn $w] bind $data(canvas) [list tk::IconList_FocusOut $w] return $w } # ::tk::IconList_AutoScan -- # # This procedure is invoked when the mouse leaves an entry window # with button 1 down. It scrolls the window up, down, left, or # right, depending on where the mouse left the window, and reschedules # itself as an "after" command so that the window continues to scroll until # the mouse moves back into the window or the mouse button is released. # # Arguments: # w - The IconList window. # proc ::tk::IconList_AutoScan {w} { upvar ::tk::$w data variable ::tk::Priv if {![winfo exists $w]} return set x $Priv(x) set y $Priv(y) if {$data(noScroll)} { return } if {$x >= [winfo width $data(canvas)]} { $data(canvas) xview scroll 1 units } elseif {$x < 0} { $data(canvas) xview scroll -1 units } elseif {$y >= [winfo height $data(canvas)]} { # do nothing } elseif {$y < 0} { # do nothing } else { return } IconList_Motion1 $w $x $y set Priv(afterId) [after 50 [list tk::IconList_AutoScan $w]] } # Deletes all the items inside the canvas subwidget and reset the IconList's # state. # proc ::tk::IconList_DeleteAll {w} { upvar ::tk::$w data upvar ::tk::$w:itemList itemList $data(canvas) delete all catch {unset data(selected)} catch {unset data(rect)} catch {unset data(list)} catch {unset itemList} set data(maxIW) 1 set data(maxIH) 1 set data(maxTW) 1 set data(maxTH) 1 set data(numItems) 0 set data(curItem) {} set data(noScroll) 1 set data(selection) {} set data(index,anchor) "" $data(sbar) set 0.0 1.0 $data(canvas) xview moveto 0 } # Adds an icon into the IconList with the designated image and text # proc ::tk::IconList_Add {w image items} { upvar ::tk::$w data upvar ::tk::$w:itemList itemList upvar ::tk::$w:textList textList foreach text $items { set iTag [$data(canvas) create image 0 0 -image $image -anchor nw \ -tags [list icon $data(numItems) item$data(numItems)]] set tTag [$data(canvas) create text 0 0 -text $text -anchor nw \ -font $data(font) -fill $data(fill) \ -tags [list text $data(numItems) item$data(numItems)]] set rTag [$data(canvas) create rect 0 0 0 0 -fill "" -outline "" \ -tags [list rect $data(numItems) item$data(numItems)]] foreach {x1 y1 x2 y2} [$data(canvas) bbox $iTag] { break } set iW [expr {$x2 - $x1}] set iH [expr {$y2 - $y1}] if {$data(maxIW) < $iW} { set data(maxIW) $iW } if {$data(maxIH) < $iH} { set data(maxIH) $iH } foreach {x1 y1 x2 y2} [$data(canvas) bbox $tTag] { break } set tW [expr {$x2 - $x1}] set tH [expr {$y2 - $y1}] if {$data(maxTW) < $tW} { set data(maxTW) $tW } if {$data(maxTH) < $tH} { set data(maxTH) $tH } lappend data(list) [list $iTag $tTag $rTag $iW $iH $tW \ $tH $data(numItems)] set itemList($rTag) [list $iTag $tTag $text $data(numItems)] set textList($data(numItems)) [string tolower $text] incr data(numItems) } } # Places the icons in a column-major arrangement. # proc ::tk::IconList_Arrange {w} { upvar ::tk::$w data if {![info exists data(list)]} { if {[info exists data(canvas)] && [winfo exists $data(canvas)]} { set data(noScroll) 1 $data(sbar) config -command "" } return } set W [winfo width $data(canvas)] set H [winfo height $data(canvas)] set pad [expr {[$data(canvas) cget -highlightthickness] + \ [$data(canvas) cget -bd]}] if {$pad < 2} { set pad 2 } incr W -[expr {$pad*2}] incr H -[expr {$pad*2}] set dx [expr {$data(maxIW) + $data(maxTW) + 8}] if {$data(maxTH) > $data(maxIH)} { set dy $data(maxTH) } else { set dy $data(maxIH) } incr dy 2 set shift [expr {$data(maxIW) + 4}] set x [expr {$pad * 2}] set y [expr {$pad * 1}] ; # Why * 1 ? set usedColumn 0 foreach sublist $data(list) { set usedColumn 1 foreach {iTag tTag rTag iW iH tW tH} $sublist { break } set i_dy [expr {($dy - $iH)/2}] set t_dy [expr {($dy - $tH)/2}] $data(canvas) coords $iTag $x [expr {$y + $i_dy}] $data(canvas) coords $tTag [expr {$x + $shift}] [expr {$y + $t_dy}] $data(canvas) coords $rTag $x $y [expr {$x+$dx}] [expr {$y+$dy}] incr y $dy if {($y + $dy) > $H} { set y [expr {$pad * 1}] ; # *1 ? incr x $dx set usedColumn 0 } } if {$usedColumn} { set sW [expr {$x + $dx}] } else { set sW $x } if {$sW < $W} { $data(canvas) config -scrollregion [list $pad $pad $sW $H] $data(sbar) config -command "" $data(canvas) xview moveto 0 set data(noScroll) 1 } else { $data(canvas) config -scrollregion [list $pad $pad $sW $H] $data(sbar) config -command [list $data(canvas) xview] set data(noScroll) 0 } set data(itemsPerColumn) [expr {($H-$pad)/$dy}] if {$data(itemsPerColumn) < 1} { set data(itemsPerColumn) 1 } if {$data(curItem) != ""} { IconList_Select $w [lindex [lindex $data(list) $data(curItem)] 2] 0 } } # Gets called when the user invokes the IconList (usually by double-clicking # or pressing the Return key). # proc ::tk::IconList_Invoke {w} { upvar ::tk::$w data if {$data(-command) != "" && [llength $data(selection)]} { uplevel #0 $data(-command) } } # ::tk::IconList_See -- # # If the item is not (completely) visible, scroll the canvas so that # it becomes visible. proc ::tk::IconList_See {w rTag} { upvar ::tk::$w data upvar ::tk::$w:itemList itemList if {$data(noScroll)} { return } set sRegion [$data(canvas) cget -scrollregion] if {[string equal $sRegion {}]} { return } if { $rTag < 0 || $rTag >= [llength $data(list)] } { return } set bbox [$data(canvas) bbox item$rTag] set pad [expr {[$data(canvas) cget -highlightthickness] + \ [$data(canvas) cget -bd]}] set x1 [lindex $bbox 0] set x2 [lindex $bbox 2] incr x1 -[expr {$pad * 2}] incr x2 -[expr {$pad * 1}] ; # *1 ? set cW [expr {[winfo width $data(canvas)] - $pad*2}] set scrollW [expr {[lindex $sRegion 2]-[lindex $sRegion 0]+1}] set dispX [expr {int([lindex [$data(canvas) xview] 0]*$scrollW)}] set oldDispX $dispX # check if out of the right edge # if {($x2 - $dispX) >= $cW} { set dispX [expr {$x2 - $cW}] } # check if out of the left edge # if {($x1 - $dispX) < 0} { set dispX $x1 } if {$oldDispX != $dispX} { set fraction [expr {double($dispX)/double($scrollW)}] $data(canvas) xview moveto $fraction } } proc ::tk::IconList_Btn1 {w x y} { upvar ::tk::$w data focus $data(canvas) set x [expr {int([$data(canvas) canvasx $x])}] set y [expr {int([$data(canvas) canvasy $y])}] set i [IconList_Index $w @${x},${y}] if {$i==""} return IconList_Selection $w clear 0 end IconList_Selection $w set $i IconList_Selection $w anchor $i } proc ::tk::IconList_CtrlBtn1 {w x y} { upvar ::tk::$w data if { $data(-multiple) } { focus $data(canvas) set x [expr {int([$data(canvas) canvasx $x])}] set y [expr {int([$data(canvas) canvasy $y])}] set i [IconList_Index $w @${x},${y}] if {$i==""} return if { [IconList_Selection $w includes $i] } { IconList_Selection $w clear $i } else { IconList_Selection $w set $i IconList_Selection $w anchor $i } } } proc ::tk::IconList_ShiftBtn1 {w x y} { upvar ::tk::$w data if { $data(-multiple) } { focus $data(canvas) set x [expr {int([$data(canvas) canvasx $x])}] set y [expr {int([$data(canvas) canvasy $y])}] set i [IconList_Index $w @${x},${y}] if {$i==""} return set a [IconList_Index $w anchor] if { [string equal $a ""] } { set a $i } IconList_Selection $w clear 0 end IconList_Selection $w set $a $i } } # Gets called on button-1 motions # proc ::tk::IconList_Motion1 {w x y} { upvar ::tk::$w data variable ::tk::Priv set Priv(x) $x set Priv(y) $y set x [expr {int([$data(canvas) canvasx $x])}] set y [expr {int([$data(canvas) canvasy $y])}] set i [IconList_Index $w @${x},${y}] if {$i==""} return IconList_Selection $w clear 0 end IconList_Selection $w set $i } proc ::tk::IconList_Double1 {w x y} { upvar ::tk::$w data if {[llength $data(selection)]} { IconList_Invoke $w } } proc ::tk::IconList_ReturnKey {w} { IconList_Invoke $w } proc ::tk::IconList_Leave1 {w x y} { variable ::tk::Priv set Priv(x) $x set Priv(y) $y IconList_AutoScan $w } proc ::tk::IconList_FocusIn {w} { upvar ::tk::$w data if {![info exists data(list)]} { return } if {[llength $data(selection)]} { IconList_DrawSelection $w } } proc ::tk::IconList_FocusOut {w} { IconList_Selection $w clear 0 end } # ::tk::IconList_UpDown -- # # Moves the active element up or down by one element # # Arguments: # w - The IconList widget. # amount - +1 to move down one item, -1 to move back one item. # proc ::tk::IconList_UpDown {w amount} { upvar ::tk::$w data if {![info exists data(list)]} { return } set curr [tk::IconList_Curselection $w] if { [llength $curr] == 0 } { set i 0 } else { set i [tk::IconList_Index $w anchor] if {$i==""} return incr i $amount } IconList_Selection $w clear 0 end IconList_Selection $w set $i IconList_Selection $w anchor $i IconList_See $w $i } # ::tk::IconList_LeftRight -- # # Moves the active element left or right by one column # # Arguments: # w - The IconList widget. # amount - +1 to move right one column, -1 to move left one column. # proc ::tk::IconList_LeftRight {w amount} { upvar ::tk::$w data if {![info exists data(list)]} { return } set curr [IconList_Curselection $w] if { [llength $curr] == 0 } { set i 0 } else { set i [IconList_Index $w anchor] if {$i==""} return incr i [expr {$amount*$data(itemsPerColumn)}] } IconList_Selection $w clear 0 end IconList_Selection $w set $i IconList_Selection $w anchor $i IconList_See $w $i } #---------------------------------------------------------------------- # Accelerator key bindings #---------------------------------------------------------------------- # ::tk::IconList_KeyPress -- # # Gets called when user enters an arbitrary key in the listbox. # proc ::tk::IconList_KeyPress {w key} { variable ::tk::Priv append Priv(ILAccel,$w) $key IconList_Goto $w $Priv(ILAccel,$w) catch { after cancel $Priv(ILAccel,$w,afterId) } set Priv(ILAccel,$w,afterId) [after 500 [list tk::IconList_Reset $w]] } proc ::tk::IconList_Goto {w text} { upvar ::tk::$w data upvar ::tk::$w:textList textList if {![info exists data(list)]} { return } if {[string equal {} $text]} { return } if {$data(curItem) == "" || $data(curItem) == 0} { set start 0 } else { set start $data(curItem) } set text [string tolower $text] set theIndex -1 set less 0 set len [string length $text] set len0 [expr {$len-1}] set i $start # Search forward until we find a filename whose prefix is an exact match # with $text while {1} { set sub [string range $textList($i) 0 $len0] if {[string equal $text $sub]} { set theIndex $i break } incr i if {$i == $data(numItems)} { set i 0 } if {$i == $start} { break } } if {$theIndex > -1} { IconList_Selection $w clear 0 end IconList_Selection $w set $theIndex IconList_Selection $w anchor $theIndex IconList_See $w $theIndex } } proc ::tk::IconList_Reset {w} { variable ::tk::Priv catch {unset Priv(ILAccel,$w)} } #---------------------------------------------------------------------- # # F I L E D I A L O G # #---------------------------------------------------------------------- namespace eval ::tk::dialog {} namespace eval ::tk::dialog::file { namespace import -force ::tk::msgcat::* } # ::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 set dataName __tk_filedialog upvar ::tk::dialog::file::$dataName data ::tk::dialog::file::Config $dataName $type $args if {[string equal $data(-parent) .]} { set w .$dataName } else { set w $data(-parent).$dataName } # (re)create the dialog box if necessary # if {![winfo exists $w]} { ::tk::dialog::file::Create $w TkFDialog } elseif {[string compare [winfo class $w] TkFDialog]} { destroy $w ::tk::dialog::file::Create $w TkFDialog } else { set data(dirMenuBtn) $w.f1.menu set data(dirMenu) $w.f1.menu.menu set data(upBtn) $w.f1.up set data(icons) $w.icons set data(ent) $w.f2.ent set data(typeMenuLab) $w.f2.lab set data(typeMenuBtn) $w.f2.menu set data(typeMenu) $data(typeMenuBtn).m set data(okBtn) $w.f2.ok set data(cancelBtn) $w.f2.cancel ::tk::dialog::file::SetSelectMode $w $data(-multiple) } # Make sure subseqent uses of this dialog are independent [Bug 845189] catch {unset 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 variable data(selectPath) w "::tk::dialog::file::SetPath $w" $data(dirMenuBtn) configure \ -textvariable ::tk::dialog::file::${dataName}(selectPath) # Initialize the file types menu # if {[llength $data(-filetypes)]} { $data(typeMenu) delete 0 end 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] } ::tk::dialog::file::SetFilter $w [lindex $data(-filetypes) 0] $data(typeMenuBtn) config -state normal $data(typeMenuLab) config -state normal } else { set data(filter) "*" $data(typeMenuBtn) config -state disabled -takefocus 0 $data(typeMenuLab) config -state disabled } ::tk::dialog::file::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 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 vinfo data(selectPath)] { trace vdelete data(selectPath) [lindex $trace 0] [lindex $trace 1] } $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 vinfo data(selectPath)] { trace vdelete data(selectPath) [lindex $trace 0] [lindex $trace 1] } # 1: the configuration specs # set specs { {-defaultextension "" "" ""} {-filetypes "" "" ""} {-initialdir "" "" ""} {-initialfile "" "" ""} {-parent "" "" "."} {-title "" "" ""} } # The "-multiple" option is only available for the "open" file dialog. # if { [string equal $type "open"] } { lappend specs {-multiple "" "" "0"} } # 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) == ""} { if {[string equal $type "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) != ""} { # 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(-filetypes) [::tk::FDGetFileTypes $data(-filetypes)] if {![winfo exists $data(-parent)]} { error "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 {![string compare $type 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 # f1: the frame with the directory option menu # set f1 [frame $w.f1] bind [::tk::AmpWidget label $f1.lab -text "[mc "&Directory:"]" ] \ <> [list focus $f1.menu] set data(dirMenuBtn) $f1.menu set data(dirMenu) [tk_optionMenu $f1.menu [format %s(selectPath) ::tk::dialog::file::$dataName] ""] set data(upBtn) [button $f1.up] if {![info exists Priv(updirImage)]} { set Priv(updirImage) [image create bitmap -data { #define updir_width 28 #define updir_height 16 static char updir_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x80, 0x1f, 0x00, 0x00, 0x40, 0x20, 0x00, 0x00, 0x20, 0x40, 0x00, 0x00, 0xf0, 0xff, 0xff, 0x01, 0x10, 0x00, 0x00, 0x01, 0x10, 0x02, 0x00, 0x01, 0x10, 0x07, 0x00, 0x01, 0x90, 0x0f, 0x00, 0x01, 0x10, 0x02, 0x00, 0x01, 0x10, 0x02, 0x00, 0x01, 0x10, 0x02, 0x00, 0x01, 0x10, 0xfe, 0x07, 0x01, 0x10, 0x00, 0x00, 0x01, 0x10, 0x00, 0x00, 0x01, 0xf0, 0xff, 0xff, 0x01};}] } $data(upBtn) config -image $Priv(updirImage) $f1.menu config -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 { [string equal $class 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.icons \ -command $iconListCommand \ -multiple $data(-multiple)] bind $data(icons) <> \ [list ::tk::dialog::file::ListBrowse $w] # f2: the frame with the OK button, cancel button, "file name" field # and file types field. # set f2 [frame $w.f2 -bd 0] bind [::tk::AmpWidget label $f2.lab -text $fNameCaption -anchor e -pady 0]\ <> [list focus $f2.ent] set data(ent) [entry $f2.ent] # The font to use for the icons. The default Canvas font on Unix # is just deviant. set ::tk::$w.icons(font) [$data(ent) cget -font] # Make the file types bits only if this is a File Dialog if { [string equal $class TkFDialog] } { set data(typeMenuLab) [::tk::AmpWidget label $f2.lab2 \ -text $fTypeCaption -anchor e -pady [$f2.lab cget -pady]] set data(typeMenuBtn) [menubutton $f2.menu -indicatoron 1 \ -menu $f2.menu.m] set data(typeMenu) [menu $data(typeMenuBtn).m -tearoff 0] $data(typeMenuBtn) config -takefocus 1 -highlightthickness 2 \ -relief raised -bd 2 -anchor w bind $data(typeMenuLab) <> [list \ focus $data(typeMenuBtn)] } # 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 gets called; exactly # once will do). [Bug 987169] set data(okBtn) [::tk::AmpWidget button $f2.ok \ -text "[mc "&OK"]" -default active -pady 3] bind $data(okBtn) [list ::tk::dialog::file::Destroyed $w] set data(cancelBtn) [::tk::AmpWidget button $f2.cancel \ -text "[mc "&Cancel"]" -default normal -pady 3] # grid the widgets in f2 # grid $f2.lab $f2.ent $data(okBtn) -padx 4 -sticky ew grid configure $f2.ent -padx 2 if { [string equal $class TkFDialog] } { grid $data(typeMenuLab) $data(typeMenuBtn) $data(cancelBtn) \ -padx 4 -sticky ew grid configure $data(typeMenuBtn) -padx 0 } else { grid x x $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 -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) config -command [list ::tk::dialog::file::UpDirCmd $w] $data(cancelBtn) config -command [list ::tk::dialog::file::CancelCmd $w] bind $w [list tk::ButtonInvoke $data(cancelBtn)] bind $w [list tk::AltKeyInDialog $w %A] # Set up event handlers specific to File or Directory Dialogs # if { [string equal $class TkFDialog] } { bind $data(ent) [list ::tk::dialog::file::ActivateEnt $w] $data(okBtn) config -command [list ::tk::dialog::file::OkCmd $w] bind $w [format { if {[string equal [%s cget -state] "normal"]} { focus %s } } $data(typeMenuBtn) $data(typeMenuBtn)] } else { set okCmd [list ::tk::dialog::file::chooseDir::OkCmd $w] bind $data(ent) $okCmd $data(okBtn) config -command $okCmd bind $w [list focus $data(ent)] bind $w [list tk::ButtonInvoke $data(okBtn)] } # 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.f2.lab $fNameCaption ::tk::IconList_Config $data(icons) \ [list -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 } else { 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 global tk_library catch {unset data(updateId)} if {![info exists Priv(folderImage)]} { set Priv(folderImage) [image create photo -data { R0lGODlhEAAMAKEAAAD//wAAAPD/gAAAACH5BAEAAAAALAAAAAAQAAwAAAIghINhyycvVFsB QtmS3rjaH1Hg141WaT5ouprt2HHcUgAAOw==}] set Priv(fileImage) [image create photo -data { R0lGODlhDAAMAKEAALLA3AAAAP//8wAAACH5BAEAAAAALAAAAAAMAAwAAAIgRI4Ha+IfWHsO rSASvJTGhnhcV3EJlo3kh53ltF5nAhQAOw==}] } set folder $Priv(folderImage) set file $Priv(fileImage) set appPWD [pwd] if {[catch { cd $data(selectPath) }]} { # 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) config -cursor watch $w config -cursor watch update idletasks ::tk::IconList_DeleteAll $data(icons) # Make the dir list # Using -directory [pwd] is better in some VFS cases. set dirs [lsort -dictionary -unique \ [glob -tails -directory [pwd] -type d -nocomplain .* *]] set dirList {} foreach d $dirs { if {$d eq "." || $d eq ".."} { continue } lappend dirList $d } ::tk::IconList_Add $data(icons) $folder $dirList if {$class eq "TkFDialog"} { # Make the file list if this is a File Dialog, selecting all # but 'd'irectory type files. # set cmd [list glob -tails -directory [pwd] \ -type {f b c l p s} -nocomplain] if {[string equal $data(filter) *]} { lappend cmd .* * } else { eval [list lappend cmd] $data(filter) } set fileList [lsort -dictionary -unique [eval $cmd]] ::tk::IconList_Add $data(icons) $file $fileList } ::tk::IconList_Arrange $data(icons) # 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 { [string equal $class TkFDialog] } { # Restore the Open/Save Button if this is a File Dialog # if {[string equal $data(type) open]} { ::tk::SetAmpText $data(okBtn) [mc "&Open"] } else { ::tk::SetAmpText $data(okBtn) [mc "&Save"] } } # turn off the busy cursor. # $data(ent) config -cursor $entCursor $w config -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 trace vdelete data(selectPath) w [list ::tk::dialog::file::SetPath $w] set data(selectPath) $path trace variable data(selectPath) w [list ::tk::dialog::file::SetPath $w] } # 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 ::tk::dialog::file::UpdateWhenIdle $w # On directory dialogs, we keep the entry in sync with the currentdir. if { [string equal [winfo class $w] 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 upvar ::tk::$data(icons) icons set data(filter) [lindex $type 1] $data(typeMenuBtn) config -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) "" } } $icons(sbar) set 0.0 0.0 ::tk::dialog::file::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 # # 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 # # 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} { set appPWD [pwd] set path [::tk::dialog::file::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] && [string equal [file ext $path] ""]} { 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] set file [file tail $path] if {[regexp {[*]|[?]} $file]} { set flag PATTERN } else { set flag FILE } cd $appPWD } else { set directory $dirname set file [file tail $path] set flag PATH } } 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 {[string compare [$data(ent) get] ""]} { $data(ent) selection range 0 end $data(ent) icursor end } else { $data(ent) selection clear } if { [string equal [winfo class $w] TkFDialog] } { # If this is a File Dialog, make sure the buttons are labeled right. if {[string equal $data(type) 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)} { # For the multiple case we have to be careful to get the file # names as a true list, watching out for a single file with a # space in the name. Thus we query the IconList directly. set selIcos [::tk::IconList_Curselection $data(icons)] set data(selectFile) "" if {[llength $selIcos] == 0 && $text ne ""} { # This assumes the user typed something in without selecting # files - so assume they only type in a single filename. ::tk::dialog::file::VerifyFileName $w $text } else { foreach item $selIcos { ::tk::dialog::file::VerifyFileName $w \ [::tk::IconList_Get $data(icons) $item] } } } else { ::tk::dialog::file::VerifyFileName $w $text } } # Verification procedure # proc ::tk::dialog::file::VerifyFileName {w filename} { upvar ::tk::dialog::file::[winfo name $w] data set list [::tk::dialog::file::ResolveFile $data(selectPath) $filename \ $data(-defaultextension)] foreach {flag path file} $list { break } switch -- $flag { OK { if {[string equal $file ""]} { # user has entered an existing (sub)directory set data(selectPath) $path $data(ent) delete 0 end } else { ::tk::dialog::file::SetPathSilently $w $path if {$data(-multiple)} { lappend data(selectFile) $file } else { set data(selectFile) $file } ::tk::dialog::file::Done $w } } PATTERN { set data(selectPath) $path set data(filter) $file } FILE { if {[string equal $data(type) 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 { ::tk::dialog::file::SetPathSilently $w $path if {$data(-multiple)} { lappend data(selectFile) $file } else { set data(selectFile) $file } ::tk::dialog::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 -message \ "[mc "Cannot change to the directory \"%1\$s\".\nPermission denied." $path]"\ -icon warning $data(ent) selection range 0 end $data(ent) icursor end } ERROR { tk_messageBox -type ok -parent $w -message \ "[mc "Invalid file name \"%1\$s\"." $path]"\ -icon warning $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 {[string equal [$data(okBtn) cget -text] $key]} { ::tk::ButtonInvoke $data(okBtn) } } # Gets called when user presses the "parent directory" button # proc ::tk::dialog::file::UpDirCmd {w} { upvar ::tk::dialog::file::[winfo name $w] data if {[string compare $data(selectPath) "/"]} { 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 [::tk::IconList_Curselection $data(icons)] { lappend filenames [::tk::IconList_Get $data(icons) $item] } if {([llength $filenames] && !$data(-multiple)) || \ ($data(-multiple) && ([llength $filenames] == 1))} { set filename [lindex $filenames 0] set file [::tk::dialog::file::JoinFile $data(selectPath) $filename] if {[file isdirectory $file]} { ::tk::dialog::file::ListInvoke $w [list $filename] return } } ::tk::dialog::file::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) {} 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 [::tk::IconList_Curselection $data(icons)] { lappend text [::tk::IconList_Get $data(icons) $item] } if {[llength $text] == 0} { return } if { [llength $text] > 1 } { set newtext {} foreach file $text { set fullfile [::tk::dialog::file::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 [::tk::dialog::file::JoinFile $data(selectPath) $text] set isDir [file isdirectory $file] } if {!$isDir} { $data(ent) delete 0 end $data(ent) insert 0 $text if { [string equal [winfo class $w] TkFDialog] } { if {[string equal $data(type) open]} { ::tk::SetAmpText $data(okBtn) [mc "&Open"] } else { ::tk::SetAmpText $data(okBtn) [mc "&Save"] } } } else { if { [string equal [winfo class $w] 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 [::tk::dialog::file::JoinFile $data(selectPath) \ [lindex $filenames 0]] set class [winfo class $w] if {[string equal $class TkChooseDir] || [file isdirectory $file]} { set appPWD [pwd] if {[catch {cd $file}]} { tk_messageBox -type ok -parent $w -message \ "[mc "Cannot change to the directory \"%1\$s\".\nPermission denied." $file]"\ -icon warning } else { cd $appPWD set data(selectPath) $file } } else { if {$data(-multiple)} { set data(selectFile) $filenames } else { set data(selectFile) $file } ::tk::dialog::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 {[string equal $selectFilePath ""]} { if {$data(-multiple)} { set selectFilePath {} foreach f $data(selectFile) { lappend selectFilePath [::tk::dialog::file::JoinFile \ $data(selectPath) $f] } } else { set selectFilePath [::tk::dialog::file::JoinFile \ $data(selectPath) $data(selectFile)] } set Priv(selectFile) $data(selectFile) set Priv(selectPath) $data(selectPath) if {[string equal $data(type) save]} { if {[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 {[string equal $reply "no"]} { return } } } } bind $data(okBtn) {} set Priv(selectFilePath) $selectFilePath } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/unsupported.tcl0100644000000000001200000002630610153074440031200 0ustar rootadmin# unsupported.tcl -- # # Commands provided by Tk without official support. Use them at your # own risk. They may change or go away without notice. # # RCS: @(#) $Id: unsupported.tcl,v 1.4 2002/07/17 16:51:53 rmax Exp $ # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # ---------------------------------------------------------------------- # Unsupported compatibility interface for folks accessing Tk's private # commands and variable against recommended usage. # ---------------------------------------------------------------------- namespace eval ::tk::unsupported { # Map from the old global names of Tk private commands to their # new namespace-encapsulated names. variable PrivateCommands array set PrivateCommands { tkButtonAutoInvoke ::tk::ButtonAutoInvoke tkButtonDown ::tk::ButtonDown tkButtonEnter ::tk::ButtonEnter tkButtonInvoke ::tk::ButtonInvoke tkButtonLeave ::tk::ButtonLeave tkButtonUp ::tk::ButtonUp tkCancelRepeat ::tk::CancelRepeat tkCheckRadioDown ::tk::CheckRadioDown tkCheckRadioEnter ::tk::CheckRadioEnter tkCheckRadioInvoke ::tk::CheckRadioInvoke tkColorDialog ::tk::dialog::color:: tkColorDialog_BuildDialog ::tk::dialog::color::BuildDialog tkColorDialog_CancelCmd ::tk::dialog::color::CancelCmd tkColorDialog_Config ::tk::dialog::color::Config tkColorDialog_CreateSelector ::tk::dialog::color::CreateSelector tkColorDialog_DrawColorScale ::tk::dialog::color::DrawColorScale tkColorDialog_EnterColorBar ::tk::dialog::color::EnterColorBar tkColorDialog_InitValues ::tk::dialog::color::InitValues tkColorDialog_HandleRGBEntry ::tk::dialog::color::HandleRGBEntry tkColorDialog_HandleSelEntry ::tk::dialog::color::HandleSelEntry tkColorDialog_LeaveColorBar ::tk::dialog::color::LeaveColorBar tkColorDialog_MoveSelector ::tk::dialog::color::MoveSelector tkColorDialog_OkCmd ::tk::dialog::color::OkCmd tkColorDialog_RedrawColorBars ::tk::dialog::color::RedrawColorBars tkColorDialog_RedrawFinalColor ::tk::dialog::color::RedrawFinalColor tkColorDialog_ReleaseMouse ::tk::dialog::color::ReleaseMouse tkColorDialog_ResizeColorBars ::tk::dialog::color::ResizeColorBars tkColorDialog_RgbToX ::tk::dialog::color::RgbToX tkColorDialog_SetRGBValue ::tk::dialog::color::SetRGBValue tkColorDialog_StartMove ::tk::dialog::color::StartMove tkColorDialog_XToRgb ::tk::dialog::color::XToRGB tkConsoleAbout ::tk::ConsoleAbout tkConsoleBind ::tk::ConsoleBind tkConsoleExit ::tk::ConsoleExit tkConsoleHistory ::tk::ConsoleHistory tkConsoleInit ::tk::ConsoleInit tkConsoleInsert ::tk::ConsoleInsert tkConsoleInvoke ::tk::ConsoleInvoke tkConsoleOutput ::tk::ConsoleOutput tkConsolePrompt ::tk::ConsolePrompt tkConsoleSource ::tk::ConsoleSource tkDarken ::tk::Darken tkEntryAutoScan ::tk::EntryAutoScan tkEntryBackspace ::tk::EntryBackspace tkEntryButton1 ::tk::EntryButton1 tkEntryClosestGap ::tk::EntryClosestGap tkEntryGetSelection ::tk::EntryGetSelection tkEntryInsert ::tk::EntryInsert tkEntryKeySelect ::tk::EntryKeySelect tkEntryMouseSelect ::tk::EntryMouseSelect tkEntryNextWord ::tk::EntryNextWord tkEntryPaste ::tk::EntryPaste tkEntryPreviousWord ::tk::EntryPreviousWord tkEntrySeeInsert ::tk::EntrySeeInsert tkEntrySetCursor ::tk::EntrySetCursor tkEntryTranspose ::tk::EntryTranspose tkEventMotifBindings ::tk::EventMotifBindings tkFDGetFileTypes ::tk::FDGetFileTypes tkFirstMenu ::tk::FirstMenu tkFocusGroup_BindIn ::tk::FocusGroup_BindIn tkFocusGroup_BindOut ::tk::FocusGroup_BindOut tkFocusGroup_Create ::tk::FocusGroup_Create tkFocusGroup_Destroy ::tk::FocusGroup_Destroy tkFocusGroup_In ::tk::FocusGroup_In tkFocusGroup_Out ::tk::FocusGroup_Out tkFocusOK ::tk::FocusOK tkGenerateMenuSelect ::tk::GenerateMenuSelect tkIconList ::tk::IconList tkIconList_Add ::tk::IconList_Add tkIconList_Arrange ::tk::IconList_Arrange tkIconList_AutoScan ::tk::IconList_AutoScan tkIconList_Btn1 ::tk::IconList_Btn1 tkIconList_Config ::tk::IconList_Config tkIconList_Create ::tk::IconList_Create tkIconList_CtrlBtn1 ::tk::IconList_CtrlBtn1 tkIconList_Curselection ::tk::IconList_Curselection tkIconList_DeleteAll ::tk::IconList_DeleteAll tkIconList_Double1 ::tk::IconList_Double1 tkIconList_DrawSelection ::tk::IconList_DrawSelection tkIconList_FocusIn ::tk::IconList_FocusIn tkIconList_FocusOut ::tk::IconList_FocusOut tkIconList_Get ::tk::IconList_Get tkIconList_Goto ::tk::IconList_Goto tkIconList_Index ::tk::IconList_Index tkIconList_Invoke ::tk::IconList_Invoke tkIconList_KeyPress ::tk::IconList_KeyPress tkIconList_Leave1 ::tk::IconList_Leave1 tkIconList_LeftRight ::tk::IconList_LeftRight tkIconList_Motion1 ::tk::IconList_Motion1 tkIconList_Reset ::tk::IconList_Reset tkIconList_ReturnKey ::tk::IconList_ReturnKey tkIconList_See ::tk::IconList_See tkIconList_Select ::tk::IconList_Select tkIconList_Selection ::tk::IconList_Selection tkIconList_ShiftBtn1 ::tk::IconList_ShiftBtn1 tkIconList_UpDown ::tk::IconList_UpDown tkListbox ::tk::Listbox tkListboxAutoScan ::tk::ListboxAutoScan tkListboxBeginExtend ::tk::ListboxBeginExtend tkListboxBeginSelect ::tk::ListboxBeginSelect tkListboxBeginToggle ::tk::ListboxBeginToggle tkListboxCancel ::tk::ListboxCancel tkListboxDataExtend ::tk::ListboxDataExtend tkListboxExtendUpDown ::tk::ListboxExtendUpDown tkListboxKeyAccel_Goto ::tk::ListboxKeyAccel_Goto tkListboxKeyAccel_Key ::tk::ListboxKeyAccel_Key tkListboxKeyAccel_Reset ::tk::ListboxKeyAccel_Reset tkListboxKeyAccel_Set ::tk::ListboxKeyAccel_Set tkListboxKeyAccel_Unset ::tk::ListboxKeyAccel_Unxet tkListboxMotion ::tk::ListboxMotion tkListboxSelectAll ::tk::ListboxSelectAll tkListboxUpDown ::tk::ListboxUpDown tkListboxBeginToggle ::tk::ListboxBeginToggle tkMbButtonUp ::tk::MbButtonUp tkMbEnter ::tk::MbEnter tkMbLeave ::tk::MbLeave tkMbMotion ::tk::MbMotion tkMbPost ::tk::MbPost tkMenuButtonDown ::tk::MenuButtonDown tkMenuDownArrow ::tk::MenuDownArrow tkMenuDup ::tk::MenuDup tkMenuEscape ::tk::MenuEscape tkMenuFind ::tk::MenuFind tkMenuFindName ::tk::MenuFindName tkMenuFirstEntry ::tk::MenuFirstEntry tkMenuInvoke ::tk::MenuInvoke tkMenuLeave ::tk::MenuLeave tkMenuLeftArrow ::tk::MenuLeftArrow tkMenuMotion ::tk::MenuMotion tkMenuNextEntry ::tk::MenuNextEntry tkMenuNextMenu ::tk::MenuNextMenu tkMenuRightArrow ::tk::MenuRightArrow tkMenuUnpost ::tk::MenuUnpost tkMenuUpArrow ::tk::MenuUpArrow tkMessageBox ::tk::MessageBox tkMotifFDialog ::tk::MotifFDialog tkMotifFDialog_ActivateDList ::tk::MotifFDialog_ActivateDList tkMotifFDialog_ActivateFList ::tk::MotifFDialog_ActivateFList tkMotifFDialog_ActivateFEnt ::tk::MotifFDialog_ActivateFEnt tkMotifFDialog_ActivateSEnt ::tk::MotifFDialog_ActivateSEnt tkMotifFDialog ::tk::MotifFDialog tkMotifFDialog_BrowseDList ::tk::MotifFDialog_BrowseDList tkMotifFDialog_BrowseFList ::tk::MotifFDialog_BrowseFList tkMotifFDialog_BuildUI ::tk::MotifFDialog_BuildUI tkMotifFDialog_CancelCmd ::tk::MotifFDialog_CancelCmd tkMotifFDialog_Config ::tk::MotifFDialog_Config tkMotifFDialog_Create ::tk::MotifFDialog_Create tkMotifFDialog_FileTypes ::tk::MotifFDialog_FileTypes tkMotifFDialog_FilterCmd ::tk::MotifFDialog_FilterCmd tkMotifFDialog_InterpFilter ::tk::MotifFDialog_InterpFilter tkMotifFDialog_LoadFiles ::tk::MotifFDialog_LoadFiles tkMotifFDialog_MakeSList ::tk::MotifFDialog_MakeSList tkMotifFDialog_OkCmd ::tk::MotifFDialog_OkCmd tkMotifFDialog_SetFilter ::tk::MotifFDialog_SetFilter tkMotifFDialog_SetListMode ::tk::MotifFDialog_SetListMode tkMotifFDialog_Update ::tk::MotifFDialog_Update tkPostOverPoint ::tk::PostOverPoint tkRecolorTree ::tk::RecolorTree tkRestoreOldGrab ::tk::RestoreOldGrab tkSaveGrabInfo ::tk::SaveGrabInfo tkScaleActivate ::tk::ScaleActivate tkScaleButtonDown ::tk::ScaleButtonDown tkScaleButton2Down ::tk::ScaleButton2Down tkScaleControlPress ::tk::ScaleControlPress tkScaleDrag ::tk::ScaleDrag tkScaleEndDrag ::tk::ScaleEndDrag tkScaleIncrement ::tk::ScaleIncrement tkScreenChanged ::tk::ScreenChanged tkScrollButtonDown ::tk::ScrollButtonDown tkScrollButton2Down ::tk::ScrollButton2Down tkScrollButtonDrag ::tk::ScrollButtonDrag tkScrollButtonUp ::tk::ScrollButtonUp tkScrollByPages ::tk::ScrollByPages tkScrollByUnits ::tk::ScrollByUnits tkScrollEndDrag ::tk::ScrollEndDrag tkScrollSelect ::tk::ScrollSelect tkScrollStartDrag ::tk::ScrollStartDrag tkScrollTopBottom ::tk::ScrollTopBottom tkScrollToPos ::tk::ScrollToPos tkTabToWindow ::tk::TabToWindow tkTearOffMenu ::tk::TearOffMenu tkTextAutoScan ::tk::TextAutoScan tkTextButton1 ::tk::TextButton1 tkTextClosestGap ::tk::TextClosestGap tkTextInsert ::tk::TextInsert tkTextKeyExtend ::tk::TextKeyExtend tkTextKeySelect ::tk::TextKeySelect tkTextNextPara ::tk::TextNextPara tkTextNextPos ::tk::TextNextPos tkTextNextWord ::tk::TextNextWord tkTextPaste ::tk::TextPaste tkTextPrevPara ::tk::TextPrevPara tkTextPrevPos ::tk::TextPrevPos tkTextPrevWord ::tk::TextPrevWord tkTextResetAnchor ::tk::TextResetAnchor tkTextScrollPages ::tk::TextScrollPages tkTextSelectTo ::tk::TextSelectTo tkTextSetCursor ::tk::TextSetCursor tkTextTranspose ::tk::TextTranspose tkTextUpDownLine ::tk::TextUpDownLine tkTraverseToMenu ::tk::TraverseToMenu tkTraverseWithinMenu ::tk::TraverseWithinMenu unsupported1 ::tk::unsupported::MacWindowStyle } # Map from the old global names of Tk private variable to their # new namespace-encapsulated names. variable PrivateVariables array set PrivateVariables { droped_to_start ::tk::mac::Droped_to_start histNum ::tk::HistNum stub_location ::tk::mac::Stub_location tkFocusIn ::tk::FocusIn tkFocusOut ::tk::FocusOut tkPalette ::tk::Palette tkPriv ::tk::Priv tkPrivMsgBox ::tk::PrivMsgBox } } # ::tk::unsupported::ExposePrivateCommand -- # # Expose one of Tk's private commands to be visible under its # old global name # # Arguments: # cmd Global name by which the command was once known, # or a glob-style pattern. # # Results: # None. # # Side effects: # The old command name in the global namespace is aliased to the # new private name. proc ::tk::unsupported::ExposePrivateCommand {cmd} { variable PrivateCommands set cmds [array get PrivateCommands $cmd] if {[llength $cmds] == 0} { return -code error "No compatibility support for \[$cmd]" } foreach {old new} $cmds { namespace eval :: [list interp alias {} $old {}] $new } } # ::tk::unsupported::ExposePrivateVariable -- # # Expose one of Tk's private variables to be visible under its # old global name # # Arguments: # var Global name by which the variable was once known, # or a glob-style pattern. # # Results: # None. # # Side effects: # The old variable name in the global namespace is aliased to the # new private name. proc ::tk::unsupported::ExposePrivateVariable {var} { variable PrivateVariables set vars [array get PrivateVariables $var] if {[llength $vars] == 0} { return -code error "No compatibility support for \$$var" } namespace eval ::tk::mac {} foreach {old new} $vars { namespace eval :: [list upvar "#0" $new $old] } } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Scripts/xmfbox.tcl0100644000000000001200000006147310153074440030117 0ustar rootadmin# xmfbox.tcl -- # # Implements the "Motif" style file selection dialog for the # Unix platform. This implementation is used only if the # "::tk_strictMotif" flag is set. # # RCS: @(#) $Id: xmfbox.tcl,v 1.25.2.1 2004/10/27 16:37:59 dgp Exp $ # # Copyright (c) 1996 Sun Microsystems, Inc. # Copyright (c) 1998-2000 Scriptics Corporation # # 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 {} # ::tk::MotifFDialog -- # # Implements a file dialog similar to the standard Motif file # selection box. # # Arguments: # type "open" or "save" # args Options parsed by the procedure. # # Results: # When -multiple is set to 0, this returns the absolute pathname # of the selected file. (NOTE: This is not the same as a single # element list.) # # When -multiple is set to > 0, this returns a Tcl list of absolute # pathnames. The argument for -multiple is ignored, but for consistency # with Windows it defines the maximum amount of memory to allocate for # the returned filenames. proc ::tk::MotifFDialog {type args} { variable ::tk::Priv set dataName __tk_filedialog upvar ::tk::dialog::file::$dataName data set w [MotifFDialog_Create $dataName $type $args] # Set a grab and claim the focus too. ::tk::SetFocusGrab $w $data(sEnt) $data(sEnt) selection range 0 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) set result $Priv(selectFilePath) ::tk::RestoreFocusGrab $w $data(sEnt) withdraw return $result } # ::tk::MotifFDialog_Create -- # # Creates the Motif file dialog (if it doesn't exist yet) and # initialize the internal data structure associated with the # dialog. # # This procedure is used by ::tk::MotifFDialog to create the # dialog. It's also used by the test suite to test the Motif # file dialog implementation. User code shouldn't call this # procedure directly. # # Arguments: # dataName Name of the global "data" array for the file dialog. # type "Save" or "Open" # argList Options parsed by the procedure. # # Results: # Pathname of the file dialog. proc ::tk::MotifFDialog_Create {dataName type argList} { upvar ::tk::dialog::file::$dataName data MotifFDialog_Config $dataName $type $argList if {[string equal $data(-parent) .]} { set w .$dataName } else { set w $data(-parent).$dataName } # (re)create the dialog box if necessary # if {![winfo exists $w]} { MotifFDialog_BuildUI $w } elseif {[string compare [winfo class $w] TkMotifFDialog]} { destroy $w MotifFDialog_BuildUI $w } else { set data(fEnt) $w.top.f1.ent set data(dList) $w.top.f2.a.l set data(fList) $w.top.f2.b.l set data(sEnt) $w.top.f3.ent set data(okBtn) $w.bot.ok set data(filterBtn) $w.bot.filter set data(cancelBtn) $w.bot.cancel } MotifFDialog_SetListMode $w # 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) } MotifFDialog_FileTypes $w MotifFDialog_Update $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 wm title $w $data(-title) return $w } # ::tk::MotifFDialog_FileTypes -- # # Checks the -filetypes option. If present this adds a list of radio- # buttons to pick the file types from. # # Arguments: # w Pathname of the tk_get*File dialogue. # # Results: # none proc ::tk::MotifFDialog_FileTypes {w} { upvar ::tk::dialog::file::[winfo name $w] data set f $w.top.f3.types catch {destroy $f} # No file types: use "*" as the filter and display no radio-buttons if {$data(-filetypes) == ""} { set data(filter) * return } # The filetypes radiobuttons # set data(fileType) $data(-defaulttype) set data(fileType) 0 MotifFDialog_SetFilter $w [lindex $data(-filetypes) $data(fileType)] #don't produce radiobuttons for only one filetype if {[llength $data(-filetypes)] == 1} { return } frame $f set cnt 0 if {$data(-filetypes) != {}} { foreach type $data(-filetypes) { set title [lindex [lindex $type 0] 0] set filter [lindex $type 1] radiobutton $f.b$cnt \ -text $title \ -variable ::tk::dialog::file::[winfo name $w](fileType) \ -value $cnt \ -command "[list tk::MotifFDialog_SetFilter $w $type]" pack $f.b$cnt -side left incr cnt } } $f.b$data(fileType) invoke pack $f -side bottom -fill both return } # This proc gets called whenever data(filter) is set # proc ::tk::MotifFDialog_SetFilter {w type} { upvar ::tk::dialog::file::[winfo name $w] data variable ::tk::Priv set data(filter) [lindex $type 1] set Priv(selectFileType) [lindex [lindex $type 0] 0] MotifFDialog_Update $w } # ::tk::MotifFDialog_Config -- # # Iterates over the optional arguments to determine the option # values for the Motif file dialog; gives default values to # unspecified options. # # Arguments: # dataName The name of the global variable in which # data for the file dialog is stored. # type "Save" or "Open" # argList Options parsed by the procedure. proc ::tk::MotifFDialog_Config {dataName type argList} { upvar ::tk::dialog::file::$dataName data set data(type) $type # 1: the configuration specs # set specs { {-defaultextension "" "" ""} {-filetypes "" "" ""} {-initialdir "" "" ""} {-initialfile "" "" ""} {-parent "" "" "."} {-title "" "" ""} } if { [string equal $type "open"] } { lappend specs {-multiple "" "" "0"} } set data(-multiple) 0 # 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 {[string equal $data(-title) ""]} { if {[string equal $type "open"]} { if {$data(-multiple) != 0} { set data(-title) "[mc {Open Multiple Files}]" } else { 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 {[string compare $data(-initialdir) ""]} { if {[file isdirectory $data(-initialdir)]} { set data(selectPath) [lindex [glob $data(-initialdir)] 0] } else { set data(selectPath) [pwd] } # Convert the initialdir to an absolute path name. set old [pwd] cd $data(selectPath) set data(selectPath) [pwd] cd $old } set data(selectFile) $data(-initialfile) # 5. Parse the -filetypes option. It is not used by the motif # file dialog, but we check for validity of the value to make sure # the application code also runs fine with the TK file dialog. # set data(-filetypes) [::tk::FDGetFileTypes $data(-filetypes)] if {![info exists data(filter)]} { set data(filter) * } if {![winfo exists $data(-parent)]} { error "bad window path name \"$data(-parent)\"" } } # ::tk::MotifFDialog_BuildUI -- # # Builds the UI components of the Motif file dialog. # # Arguments: # w Pathname of the dialog to build. # # Results: # None. proc ::tk::MotifFDialog_BuildUI {w} { set dataName [lindex [split $w .] end] upvar ::tk::dialog::file::$dataName data # Create the dialog toplevel and internal frames. # toplevel $w -class TkMotifFDialog set top [frame $w.top -relief raised -bd 1] set bot [frame $w.bot -relief raised -bd 1] pack $w.bot -side bottom -fill x pack $w.top -side top -expand yes -fill both set f1 [frame $top.f1] set f2 [frame $top.f2] set f3 [frame $top.f3] pack $f1 -side top -fill x pack $f3 -side bottom -fill x pack $f2 -expand yes -fill both set f2a [frame $f2.a] set f2b [frame $f2.b] grid $f2a -row 0 -column 0 -rowspan 1 -columnspan 1 -padx 4 -pady 4 \ -sticky news grid $f2b -row 0 -column 1 -rowspan 1 -columnspan 1 -padx 4 -pady 4 \ -sticky news grid rowconfig $f2 0 -minsize 0 -weight 1 grid columnconfig $f2 0 -minsize 0 -weight 1 grid columnconfig $f2 1 -minsize 150 -weight 2 # The Filter box # bind [::tk::AmpWidget label $f1.lab -text [mc "Fil&ter:"] -anchor w] \ <> [list focus $f1.ent] entry $f1.ent pack $f1.lab -side top -fill x -padx 6 -pady 4 pack $f1.ent -side top -fill x -padx 4 -pady 0 set data(fEnt) $f1.ent # The file and directory lists # set data(dList) [MotifFDialog_MakeSList $w $f2a \ [mc "&Directory:"] DList] set data(fList) [MotifFDialog_MakeSList $w $f2b \ [mc "Fi&les:"] FList] # The Selection box # bind [::tk::AmpWidget label $f3.lab -text [mc "&Selection:"] -anchor w] \ <> [list focus $f3.ent] entry $f3.ent pack $f3.lab -side top -fill x -padx 6 -pady 0 pack $f3.ent -side top -fill x -padx 4 -pady 4 set data(sEnt) $f3.ent # The buttons # set maxWidth [::tk::mcmaxamp &OK &Filter &Cancel] set maxWidth [expr {$maxWidth<6?6:$maxWidth}] set data(okBtn) [::tk::AmpWidget button $bot.ok -text [mc "&OK"] \ -width $maxWidth \ -command [list tk::MotifFDialog_OkCmd $w]] set data(filterBtn) [::tk::AmpWidget button $bot.filter -text [mc "&Filter"] \ -width $maxWidth \ -command [list tk::MotifFDialog_FilterCmd $w]] set data(cancelBtn) [::tk::AmpWidget button $bot.cancel -text [mc "&Cancel"] \ -width $maxWidth \ -command [list tk::MotifFDialog_CancelCmd $w]] pack $bot.ok $bot.filter $bot.cancel -padx 10 -pady 10 -expand yes \ -side left # Create the bindings: # bind $w [list ::tk::AltKeyInDialog $w %A] bind $data(fEnt) [list tk::MotifFDialog_ActivateFEnt $w] bind $data(sEnt) [list tk::MotifFDialog_ActivateSEnt $w] bind $w [list tk::MotifFDialog_CancelCmd $w] bind $w.bot {set ::tk::Priv(selectFilePath) {}} wm protocol $w WM_DELETE_WINDOW [list tk::MotifFDialog_CancelCmd $w] } proc ::tk::MotifFDialog_SetListMode {w} { upvar ::tk::dialog::file::[winfo name $w] data if {$data(-multiple) != 0} { set selectmode extended } else { set selectmode browse } set f $w.top.f2.b $f.l configure -selectmode $selectmode } # ::tk::MotifFDialog_MakeSList -- # # Create a scrolled-listbox and set the keyboard accelerator # bindings so that the list selection follows what the user # types. # # Arguments: # w Pathname of the dialog box. # f Frame widget inside which to create the scrolled # listbox. This frame widget already exists. # label The string to display on top of the listbox. # under Sets the -under option of the label. # cmdPrefix Specifies procedures to call when the listbox is # browsed or activated. proc ::tk::MotifFDialog_MakeSList {w f label cmdPrefix} { bind [::tk::AmpWidget label $f.lab -text $label -anchor w] \ <> [list focus $f.l] listbox $f.l -width 12 -height 5 -exportselection 0\ -xscrollcommand [list $f.h set] -yscrollcommand [list $f.v set] scrollbar $f.v -orient vertical -takefocus 0 -command [list $f.l yview] scrollbar $f.h -orient horizontal -takefocus 0 -command [list $f.l xview] grid $f.lab -row 0 -column 0 -sticky news -rowspan 1 -columnspan 2 \ -padx 2 -pady 2 grid $f.l -row 1 -column 0 -rowspan 1 -columnspan 1 -sticky news grid $f.v -row 1 -column 1 -rowspan 1 -columnspan 1 -sticky news grid $f.h -row 2 -column 0 -rowspan 1 -columnspan 1 -sticky news grid rowconfig $f 0 -weight 0 -minsize 0 grid rowconfig $f 1 -weight 1 -minsize 0 grid columnconfig $f 0 -weight 1 -minsize 0 # bindings for the listboxes # set list $f.l bind $list <> [list tk::MotifFDialog_Browse$cmdPrefix $w] bind $list \ [list tk::MotifFDialog_Activate$cmdPrefix $w] bind $list "tk::MotifFDialog_Browse$cmdPrefix [list $w]; \ tk::MotifFDialog_Activate$cmdPrefix [list $w]" bindtags $list [list Listbox $list [winfo toplevel $list] all] ListBoxKeyAccel_Set $list return $f.l } # ::tk::MotifFDialog_InterpFilter -- # # Interpret the string in the filter entry into two components: # the directory and the pattern. If the string is a relative # pathname, give a warning to the user and restore the pattern # to original. # # Arguments: # w pathname of the dialog box. # # Results: # A list of two elements. The first element is the directory # specified # by the filter. The second element is the filter # pattern itself. proc ::tk::MotifFDialog_InterpFilter {w} { upvar ::tk::dialog::file::[winfo name $w] data set text [string trim [$data(fEnt) get]] # Perform tilde substitution # set badTilde 0 if {[string equal [string index $text 0] ~]} { set list [file split $text] set tilde [lindex $list 0] if {[catch {set tilde [glob $tilde]}]} { set badTilde 1 } else { set text [eval file join [concat $tilde [lrange $list 1 end]]] } } # If the string is a relative pathname, combine it # with the current selectPath. set relative 0 if {[string equal [file pathtype $text] "relative"]} { set relative 1 } elseif {$badTilde} { set relative 1 } if {$relative} { tk_messageBox -icon warning -type ok \ -message "\"$text\" must be an absolute pathname" $data(fEnt) delete 0 end $data(fEnt) insert 0 [::tk::dialog::file::JoinFile $data(selectPath) \ $data(filter)] return [list $data(selectPath) $data(filter)] } set resolved [::tk::dialog::file::JoinFile [file dirname $text] [file tail $text]] if {[file isdirectory $resolved]} { set dir $resolved set fil $data(filter) } else { set dir [file dirname $resolved] set fil [file tail $resolved] } return [list $dir $fil] } # ::tk::MotifFDialog_Update # # Load the files and synchronize the "filter" and "selection" fields # boxes. # # Arguments: # w pathname of the dialog box. # # Results: # None. proc ::tk::MotifFDialog_Update {w} { upvar ::tk::dialog::file::[winfo name $w] data $data(fEnt) delete 0 end $data(fEnt) insert 0 \ [::tk::dialog::file::JoinFile $data(selectPath) $data(filter)] $data(sEnt) delete 0 end $data(sEnt) insert 0 [::tk::dialog::file::JoinFile $data(selectPath) \ $data(selectFile)] MotifFDialog_LoadFiles $w } # ::tk::MotifFDialog_LoadFiles -- # # Loads the files and directories into the two listboxes according # to the filter setting. # # Arguments: # w pathname of the dialog box. # # Results: # None. proc ::tk::MotifFDialog_LoadFiles {w} { upvar ::tk::dialog::file::[winfo name $w] data $data(dList) delete 0 end $data(fList) delete 0 end set appPWD [pwd] if {[catch {cd $data(selectPath)}]} { cd $appPWD $data(dList) insert end ".." return } # Make the dir and file lists # # For speed we only have one glob, which reduces the file system # calls (good for slow NFS networks). # # We also do two smaller sorts (files + dirs) instead of one large sort, # which gives a small speed increase. # set top 0 set dlist "" set flist "" foreach f [glob -nocomplain .* *] { if {[file isdir ./$f]} { lappend dlist $f } else { foreach pat $data(filter) { if {[string match $pat $f]} { if {[string match .* $f]} { incr top } lappend flist $f break } } } } eval [list $data(dList) insert end] [lsort -dictionary $dlist] eval [list $data(fList) insert end] [lsort -dictionary $flist] # The user probably doesn't want to see the . files. We adjust the view # so that the listbox displays all the non-dot files $data(fList) yview $top cd $appPWD } # ::tk::MotifFDialog_BrowseDList -- # # This procedure is called when the directory list is browsed # (clicked-over) by the user. # # Arguments: # w The pathname of the dialog box. # # Results: # None. proc ::tk::MotifFDialog_BrowseDList {w} { upvar ::tk::dialog::file::[winfo name $w] data focus $data(dList) if {[string equal [$data(dList) curselection] ""]} { return } set subdir [$data(dList) get [$data(dList) curselection]] if {[string equal $subdir ""]} { return } $data(fList) selection clear 0 end set list [MotifFDialog_InterpFilter $w] set data(filter) [lindex $list 1] switch -- $subdir { . { set newSpec [::tk::dialog::file::JoinFile $data(selectPath) $data(filter)] } .. { set newSpec [::tk::dialog::file::JoinFile [file dirname $data(selectPath)] \ $data(filter)] } default { set newSpec [::tk::dialog::file::JoinFile [::tk::dialog::file::JoinFile \ $data(selectPath) $subdir] $data(filter)] } } $data(fEnt) delete 0 end $data(fEnt) insert 0 $newSpec } # ::tk::MotifFDialog_ActivateDList -- # # This procedure is called when the directory list is activated # (double-clicked) by the user. # # Arguments: # w The pathname of the dialog box. # # Results: # None. proc ::tk::MotifFDialog_ActivateDList {w} { upvar ::tk::dialog::file::[winfo name $w] data if {[string equal [$data(dList) curselection] ""]} { return } set subdir [$data(dList) get [$data(dList) curselection]] if {[string equal $subdir ""]} { return } $data(fList) selection clear 0 end switch -- $subdir { . { set newDir $data(selectPath) } .. { set newDir [file dirname $data(selectPath)] } default { set newDir [::tk::dialog::file::JoinFile $data(selectPath) $subdir] } } set data(selectPath) $newDir MotifFDialog_Update $w if {[string compare $subdir ..]} { $data(dList) selection set 0 $data(dList) activate 0 } else { $data(dList) selection set 1 $data(dList) activate 1 } } # ::tk::MotifFDialog_BrowseFList -- # # This procedure is called when the file list is browsed # (clicked-over) by the user. # # Arguments: # w The pathname of the dialog box. # # Results: # None. proc ::tk::MotifFDialog_BrowseFList {w} { upvar ::tk::dialog::file::[winfo name $w] data focus $data(fList) set data(selectFile) "" foreach item [$data(fList) curselection] { lappend data(selectFile) [$data(fList) get $item] } if {[llength $data(selectFile)] == 0} { return } $data(dList) selection clear 0 end $data(fEnt) delete 0 end $data(fEnt) insert 0 [::tk::dialog::file::JoinFile $data(selectPath) \ $data(filter)] $data(fEnt) xview end # if it's a multiple selection box, just put in the filenames # otherwise put in the full path as usual $data(sEnt) delete 0 end if {$data(-multiple) != 0} { $data(sEnt) insert 0 $data(selectFile) } else { $data(sEnt) insert 0 [::tk::dialog::file::JoinFile $data(selectPath) \ [lindex $data(selectFile) 0]] } $data(sEnt) xview end } # ::tk::MotifFDialog_ActivateFList -- # # This procedure is called when the file list is activated # (double-clicked) by the user. # # Arguments: # w The pathname of the dialog box. # # Results: # None. proc ::tk::MotifFDialog_ActivateFList {w} { upvar ::tk::dialog::file::[winfo name $w] data if {[string equal [$data(fList) curselection] ""]} { return } set data(selectFile) [$data(fList) get [$data(fList) curselection]] if {[string equal $data(selectFile) ""]} { return } else { MotifFDialog_ActivateSEnt $w } } # ::tk::MotifFDialog_ActivateFEnt -- # # This procedure is called when the user presses Return inside # the "filter" entry. It updates the dialog according to the # text inside the filter entry. # # Arguments: # w The pathname of the dialog box. # # Results: # None. proc ::tk::MotifFDialog_ActivateFEnt {w} { upvar ::tk::dialog::file::[winfo name $w] data set list [MotifFDialog_InterpFilter $w] set data(selectPath) [lindex $list 0] set data(filter) [lindex $list 1] MotifFDialog_Update $w } # ::tk::MotifFDialog_ActivateSEnt -- # # This procedure is called when the user presses Return inside # the "selection" entry. It sets the ::tk::Priv(selectFilePath) # variable so that the vwait loop in tk::MotifFDialog will be # terminated. # # Arguments: # w The pathname of the dialog box. # # Results: # None. proc ::tk::MotifFDialog_ActivateSEnt {w} { variable ::tk::Priv upvar ::tk::dialog::file::[winfo name $w] data set selectFilePath [string trim [$data(sEnt) get]] if {[string equal $selectFilePath ""]} { MotifFDialog_FilterCmd $w return } if {$data(-multiple) == 0} { set selectFilePath [list $selectFilePath] } if {[file isdirectory [lindex $selectFilePath 0]]} { set data(selectPath) [lindex [glob $selectFilePath] 0] set data(selectFile) "" MotifFDialog_Update $w return } set newFileList "" foreach item $selectFilePath { if {[string compare [file pathtype $item] "absolute"]} { set item [file join $data(selectPath) $item] } elseif {![file exists [file dirname $item]]} { tk_messageBox -icon warning -type ok \ -message [mc {Directory "%1$s" does not exist.} \ [file dirname $item]] return } if {![file exists $item]} { if {[string equal $data(type) open]} { tk_messageBox -icon warning -type ok \ -message [mc {File "%1$s" does not exist.} $item] return } } else { if {[string equal $data(type) save]} { set message [format %s%s \ [mc "File \"%1\$s\" already exists.\n\n" \ $selectFilePath] \ [mc {Replace existing file?}]] set answer [tk_messageBox -icon warning -type yesno \ -message $message] if {[string equal $answer "no"]} { return } } } lappend newFileList $item } if {$data(-multiple) != 0} { set Priv(selectFilePath) $newFileList } else { set Priv(selectFilePath) [lindex $newFileList 0] } # Set selectFile and selectPath to first item in list set Priv(selectFile) [file tail [lindex $newFileList 0]] set Priv(selectPath) [file dirname [lindex $newFileList 0]] } proc ::tk::MotifFDialog_OkCmd {w} { upvar ::tk::dialog::file::[winfo name $w] data MotifFDialog_ActivateSEnt $w } proc ::tk::MotifFDialog_FilterCmd {w} { upvar ::tk::dialog::file::[winfo name $w] data MotifFDialog_ActivateFEnt $w } proc ::tk::MotifFDialog_CancelCmd {w} { variable ::tk::Priv set Priv(selectFilePath) "" set Priv(selectFile) "" set Priv(selectPath) "" } proc ::tk::ListBoxKeyAccel_Set {w} { bind Listbox "" bind $w [list tk::ListBoxKeyAccel_Unset $w] bind $w [list tk::ListBoxKeyAccel_Key $w %A] } proc ::tk::ListBoxKeyAccel_Unset {w} { variable ::tk::Priv catch {after cancel $Priv(lbAccel,$w,afterId)} catch {unset Priv(lbAccel,$w)} catch {unset Priv(lbAccel,$w,afterId)} } # ::tk::ListBoxKeyAccel_Key-- # # This procedure maintains a list of recently entered keystrokes # over a listbox widget. It arranges an idle event to move the # selection of the listbox to the entry that begins with the # keystrokes. # # Arguments: # w The pathname of the listbox. # key The key which the user just pressed. # # Results: # None. proc ::tk::ListBoxKeyAccel_Key {w key} { variable ::tk::Priv if { $key == "" } { return } append Priv(lbAccel,$w) $key ListBoxKeyAccel_Goto $w $Priv(lbAccel,$w) catch { after cancel $Priv(lbAccel,$w,afterId) } set Priv(lbAccel,$w,afterId) [after 500 \ [list tk::ListBoxKeyAccel_Reset $w]] } proc ::tk::ListBoxKeyAccel_Goto {w string} { variable ::tk::Priv set string [string tolower $string] set end [$w index end] set theIndex -1 for {set i 0} {$i < $end} {incr i} { set item [string tolower [$w get $i]] if {[string compare $string $item] >= 0} { set theIndex $i } if {[string compare $string $item] <= 0} { set theIndex $i break } } if {$theIndex >= 0} { $w selection clear 0 end $w selection set $theIndex $theIndex $w activate $theIndex $w see $theIndex event generate $w <> } } proc ::tk::ListBoxKeyAccel_Reset {w} { variable ::tk::Priv catch {unset Priv(lbAccel,$w)} } proc ::tk_getFileType {} { variable ::tk::Priv return $Priv(selectFileType) } Wishkit.app/Contents/Frameworks/Tk.framework/Versions/8.4/Resources/Tk.rsrc0100644000000000001200000004510210153074436025726 0ustar rootadminAf@f&<(,About Tcl & Tk( OklXTcl 8.4.8 & Tk 8.4.8 2004 Tcl Core Team. Jim Ingham & Ian Reid 2001-2002 Apple Computer, Inc. Jim Ingham & Ray Johnson 1998-2000 Scriptics Inc. 1996-1997 Sun Microsystems Inc.x\@dD HHdD dDDdDHHZZ76554433f7635544337655f33310//f103//..ff10f//ff..f3--f103//3..3--3f1033//3..--10//f..3-+*))(('f+*3))((''+*))f((3''+*))((''f3GGFFfEEffGGffFFf3EEf3GG3FF3EE3f33AA3@@??CBAAf@@3??CBAA@@??fCB3AA@@??CBAAf@@3??CBAA@@??f=<3;;::f99f=<f;;ff::f399f=<3;;3::3993f=<33;;3::99=<;;f::399=|x@D~(>|x@~>|x@D`'XhP(ԯԠP(Xh'|?xxp8p8xx?D`'XhS(ԯԣS(Xh'|?xxs8s8xx?D|>>|>||>`p88pp88p`D|  8p p>`|`@p@ D @? D @?D` @DqQQQQqD @Ȁ @ DS3P0D @ @ D D ** D30#??wgD<<8pppp8<<?|>|>?D3dfIOD"c?)))+ix??????D 3p UzU6??DDBR* ~~ *RBCs;;sCDD "BB" >~~>D????????D?    !!    ???0 0 13310 0 ??D  ?;;?D <``@@ @>?8p@D <p   @>?p``8@p@@D?"D&d,48!!8,4&d"D??>|>|<<9##9<<>|>|?DGo|0HL~d$|88~?D11;;Dxp@6O~0|008?D? ˠ88>&& . & !>???>D </_Jb4 </~~< D?@ ?"A$P ??p D>c` 00 `>?DUU    UD?OgsyysgO?D  ``pD```abdodba```D  DDDETETETETDDD  D0000000 DC$Kp@@@ PxoonD@@```pppxxx|>8@??|~8 DD?x?88D?x?88DD@@@@@@@@@@@DD p 1qx0 p?x0 D@@@GD D"D"" 7777D   @@gg@@  p88p8pߟ8p8pp8D@ @?!9)9)99!!? ???????????D@@@9888 $H((0 ??? @ ??p8DȀ@  @ D3S0PD@ @ DD `    pp D D(I'0a @@D0000000 D D ` ` `p&H&JMIh @  ??o??HH }u }u]u]u&& . & !>???>HH1111O!!@!!/!/!!/!!DDDDDD`>c` 00 `>?HH:p雙e\陙ff\陙ff\5p feY\5pffz`((HHyJ!6UUc5Q533Q6UUa333333333""""x DDDDDD""""""UUUUUU wwwwww R`p @@HH@B/?R5S/25/ff33R` p 1qx0 p?x0 HH?C4?O4?_4?P_4?_4?_4?_4?_4?3P_4??O4?"ff33DDDDDDz`@ @?!9)9)99!!? ???????????HH `` 3`  wwwwwwUUUUUU""""""DDDDDD ffff `@@@9888 $H((0 ??p p0`1cc??Af@f .DLOG2DITL>PICTJCURSTVcrsrRSICN *  P'.6(CpK T ]H c t  h   @    `   8    )X - 4 A0 Mx Y d mP s { ( p    H   ! !h ! ! "@ " " # #` # # $8 $ *$ 4% @%X I% R% `&0 r&x & ' 'P ' ' (( (p ( ) )H ) ) * *h *  * %+@ .+ 7+ @, F,`L,Q- V . [/ a1P l2 t3 z5J  6H  7 9 :r ; <  ><? About Box About Boxhandbucketcancelresizeeyedrop eyedrop-fullzoom-inzoom-outX_cursorarrowbased_arrow_downbased_arrow_upboatbogositybottom_left_cornerbottom_right_corner bottom_side bottom_tee box_spiral center_ptrcircleclock coffee_mugcross