diff --git a/.gitattributes b/.gitattributes
index 4241d2f76f1d618f103cb7eb1573b8b84e004f44..808df9913cfd283a0919ef9e44cac2e042b46619 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -724,3 +724,6 @@ mplug_owl2/lib/python3.10/site-packages/scipy/sparse/_csparsetools.cpython-310-x
 openflamingo/lib/python3.10/site-packages/transformers/models/oneformer/__pycache__/modeling_oneformer.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 mplug_owl2/lib/python3.10/site-packages/matplotlib/__pycache__/figure.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 mplug_owl2/lib/python3.10/lib-dynload/_hashlib.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+mplug_owl2/lib/itcl4.2.4/libitcl4.2.4.so filter=lfs diff=lfs merge=lfs -text
+mplug_owl2/lib/sqlite3.44.2/libsqlite3.44.2.so filter=lfs diff=lfs merge=lfs -text
+mplug_owl2/lib/ossl-modules/legacy.so filter=lfs diff=lfs merge=lfs -text
diff --git a/mplug_owl2/lib/engines-3/afalg.so b/mplug_owl2/lib/engines-3/afalg.so
new file mode 100644
index 0000000000000000000000000000000000000000..fed94a8ae3bb18c739c0cfafbd1f714b6969cd1f
Binary files /dev/null and b/mplug_owl2/lib/engines-3/afalg.so differ
diff --git a/mplug_owl2/lib/engines-3/loader_attic.so b/mplug_owl2/lib/engines-3/loader_attic.so
new file mode 100644
index 0000000000000000000000000000000000000000..d21e0d99e662e90d89ad1519fefdc38837c10900
Binary files /dev/null and b/mplug_owl2/lib/engines-3/loader_attic.so differ
diff --git a/mplug_owl2/lib/itcl4.2.4/libitcl4.2.4.so b/mplug_owl2/lib/itcl4.2.4/libitcl4.2.4.so
new file mode 100644
index 0000000000000000000000000000000000000000..3ce890c00878e35983c2edc9221b0ff5c59667bd
--- /dev/null
+++ b/mplug_owl2/lib/itcl4.2.4/libitcl4.2.4.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b4dec209d072b6ea25863993f95c4fcf0023974e0d01d06a5705173db1313379
+size 318912
diff --git a/mplug_owl2/lib/ossl-modules/legacy.so b/mplug_owl2/lib/ossl-modules/legacy.so
new file mode 100644
index 0000000000000000000000000000000000000000..882bcc96544cf968ac082bdabe91f00d414c9eef
--- /dev/null
+++ b/mplug_owl2/lib/ossl-modules/legacy.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b8b8163a4a4cea7693a8d64c064788cc830bfb72e5aae56e9432fee32f5f45a0
+size 158976
diff --git a/mplug_owl2/lib/sqlite3.44.2/libsqlite3.44.2.so b/mplug_owl2/lib/sqlite3.44.2/libsqlite3.44.2.so
new file mode 100644
index 0000000000000000000000000000000000000000..3e21beb6cd11ee9666d611ad1d31657fbac66b43
--- /dev/null
+++ b/mplug_owl2/lib/sqlite3.44.2/libsqlite3.44.2.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2ccfe88e9e8b573a4d312a3cf85f51de60783ab649a4ca9a4ae69b13c3f87ef1
+size 1596704
diff --git a/mplug_owl2/lib/tcl8/8.4/platform-1.0.19.tm b/mplug_owl2/lib/tcl8/8.4/platform-1.0.19.tm
new file mode 100644
index 0000000000000000000000000000000000000000..63d4d7601c16cf5d4afd4d808934906079ddfc3e
--- /dev/null
+++ b/mplug_owl2/lib/tcl8/8.4/platform-1.0.19.tm
@@ -0,0 +1,450 @@
+# -*- tcl -*-
+# ### ### ### ######### ######### #########
+## Overview
+
+# Heuristics to assemble a platform identifier from publicly available
+# information. The identifier describes the platform of the currently
+# running tcl shell. This is a mixture of the runtime environment and
+# of build-time properties of the executable itself.
+#
+# Examples:
+# <1> A tcl shell executing on a x86_64 processor, but having a
+#   wordsize of 4 was compiled for the x86 environment, i.e. 32
+#   bit, and loaded packages have to match that, and not the
+#   actual cpu.
+#
+# <2> The hp/solaris 32/64 bit builds of the core cannot be
+#   distinguished by looking at tcl_platform. As packages have to
+#   match the 32/64 information we have to look in more places. In
+#   this case we inspect the executable itself (magic numbers,
+#   i.e. fileutil::magic::filetype).
+#
+# The basic information used comes out of the 'os' and 'machine'
+# entries of the 'tcl_platform' array. A number of general and
+# os/machine specific transformation are applied to get a canonical
+# result.
+#
+# General
+# Only the first element of 'os' is used - we don't care whether we
+# are on "Windows NT" or "Windows XP" or whatever.
+#
+# Machine specific
+# % amd64  -> x86_64
+# % arm*   -> arm
+# % sun4*  -> sparc
+# % ia32*  -> ix86
+# % intel  -> ix86
+# % i*86*  -> ix86
+# % Power* -> powerpc
+# % x86_64 + wordSize 4 => x86 code
+#
+# OS specific
+# % AIX are always powerpc machines
+# % HP-UX 9000/800 etc means parisc
+# % linux has to take glibc version into account
+# % sunos -> solaris, and keep version number
+#
+# NOTE: A platform like linux glibc 2.3, which can use glibc 2.2 stuff
+# has to provide all possible allowed platform identifiers when
+# searching search. Ditto a solaris 2.8 platform can use solaris 2.6
+# packages. Etc. This is handled by the other procedure, see below.
+
+# ### ### ### ######### ######### #########
+## Requirements
+
+namespace eval ::platform {}
+
+# ### ### ### ######### ######### #########
+## Implementation
+
+# -- platform::generic
+#
+# Assembles an identifier for the generic platform. It leaves out
+# details like kernel version, libc version, etc.
+
+proc ::platform::generic {} {
+    global tcl_platform
+
+    set plat [string tolower [lindex $tcl_platform(os) 0]]
+    set cpu  $tcl_platform(machine)
+
+    switch -glob -- $cpu {
+	sun4* {
+	    set cpu sparc
+	}
+	intel -
+	ia32* -
+	i*86* {
+	    set cpu ix86
+	}
+	x86_64 {
+	    if {$tcl_platform(wordSize) == 4} {
+		# See Example <1> at the top of this file.
+		set cpu ix86
+	    }
+	}
+	ppc -
+	"Power*" {
+	    set cpu powerpc
+	}
+	"arm*" {
+	    set cpu arm
+	}
+	ia64 {
+	    if {$tcl_platform(wordSize) == 4} {
+		append cpu _32
+	    }
+	}
+    }
+
+    switch -glob -- $plat {
+	windows {
+	    if {$tcl_platform(platform) == "unix"} {
+		set plat cygwin
+	    } else {
+		set plat win32
+	    }
+	    if {$cpu eq "amd64"} {
+		# Do not check wordSize, win32-x64 is an IL32P64 platform.
+		set cpu x86_64
+	    }
+	}
+	sunos {
+	    set plat solaris
+	    if {[string match "ix86" $cpu]} {
+		if {$tcl_platform(wordSize) == 8} {
+		    set cpu x86_64
+		}
+	    } elseif {![string match "ia64*" $cpu]} {
+		# sparc
+		if {$tcl_platform(wordSize) == 8} {
+		    append cpu 64
+		}
+	    }
+	}
+	darwin {
+	    set plat macosx
+	    # Correctly identify the cpu when running as a 64bit
+	    # process on a machine with a 32bit kernel
+	    if {$cpu eq "ix86"} {
+		if {$tcl_platform(wordSize) == 8} {
+		    set cpu x86_64
+		}
+	    }
+	}
+	aix {
+	    set cpu powerpc
+	    if {$tcl_platform(wordSize) == 8} {
+		append cpu 64
+	    }
+	}
+	hp-ux {
+	    set plat hpux
+	    if {![string match "ia64*" $cpu]} {
+		set cpu parisc
+		if {$tcl_platform(wordSize) == 8} {
+		    append cpu 64
+		}
+	    }
+	}
+	osf1 {
+	    set plat tru64
+	}
+	default {
+	    set plat [lindex [split $plat _-] 0]
+	}
+    }
+
+    return "${plat}-${cpu}"
+}
+
+# -- platform::identify
+#
+# Assembles an identifier for the exact platform, by extending the
+# generic identifier. I.e. it adds in details like kernel version,
+# libc version, etc., if they are relevant for the loading of
+# packages on the platform.
+
+proc ::platform::identify {} {
+    global tcl_platform
+
+    set id [generic]
+    regexp {^([^-]+)-([^-]+)$} $id -> plat cpu
+
+    switch -- $plat {
+	solaris {
+	    regsub {^5} $tcl_platform(osVersion) 2 text
+	    append plat $text
+	    return "${plat}-${cpu}"
+	}
+	macosx {
+	    set major [lindex [split $tcl_platform(osVersion) .] 0]
+	    if {$major > 19} {
+		set minor [lindex [split $tcl_platform(osVersion) .] 1]
+		incr major -9
+		append plat $major.[expr {$minor - 1}]
+	    } else {
+		incr major -4
+		append plat 10.$major
+		return "${plat}-${cpu}"
+	    }
+	    return "${plat}-${cpu}"
+	}
+	linux {
+	    # Look for the libc*.so and determine its version
+	    # (libc5/6, libc6 further glibc 2.X)
+
+	    set v unknown
+
+	    # Determine in which directory to look. /lib, or /lib64.
+	    # For that we use the tcl_platform(wordSize).
+	    #
+	    # We could use the 'cpu' info, per the equivalence below,
+	    # that however would be restricted to intel. And this may
+	    # be a arm, mips, etc. system. The wordsize is more
+	    # fundamental.
+	    #
+	    # ix86   <=> (wordSize == 4) <=> 32 bit ==> /lib
+	    # x86_64 <=> (wordSize == 8) <=> 64 bit ==> /lib64
+	    #
+	    # Do not look into /lib64 even if present, if the cpu
+	    # doesn't fit.
+
+	    # TODO: Determine the prefixes (i386, x86_64, ...) for
+	    # other cpus.  The path after the generic one is utterly
+	    # specific to intel right now.  Ok, on Ubuntu, possibly
+	    # other Debian systems we may apparently be able to query
+	    # the necessary CPU code. If we can't we simply use the
+	    # hardwired fallback.
+
+	    switch -exact -- $tcl_platform(wordSize) {
+		4 {
+		    lappend bases /lib
+		    if {[catch {
+			exec dpkg-architecture -qDEB_HOST_MULTIARCH
+		    } res]} {
+			lappend bases /lib/i386-linux-gnu
+		    } else {
+			# dpkg-arch returns the full tripled, not just cpu.
+			lappend bases /lib/$res
+		    }
+		}
+		8 {
+		    lappend bases /lib64
+		    if {[catch {
+			exec dpkg-architecture -qDEB_HOST_MULTIARCH
+		    } res]} {
+			lappend bases /lib/x86_64-linux-gnu
+		    } else {
+			# dpkg-arch returns the full tripled, not just cpu.
+			lappend bases /lib/$res
+		    }
+		}
+		default {
+		    return -code error "Bad wordSize $tcl_platform(wordSize), expected 4 or 8"
+		}
+	    }
+
+	    foreach base $bases {
+		if {[LibcVersion $base -> v]} break
+	    }
+
+	    append plat -$v
+	    return "${plat}-${cpu}"
+	}
+    }
+
+    return $id
+}
+
+proc ::platform::LibcVersion {base _->_ vv} {
+    upvar 1 $vv v
+    set libclist [lsort [glob -nocomplain -directory $base libc*]]
+
+    if {![llength $libclist]} { return 0 }
+
+    set libc [lindex $libclist 0]
+
+    # Try executing the library first. This should succeed
+    # for a glibc library, and return the version
+    # information.
+
+    if {![catch {
+	set vdata [lindex [split [exec $libc] \n] 0]
+    }]} {
+	regexp {version ([0-9]+(\.[0-9]+)*)} $vdata -> v
+	foreach {major minor} [split $v .] break
+	set v glibc${major}.${minor}
+	return 1
+    } else {
+	# We had trouble executing the library. We are now
+	# inspecting its name to determine the version
+	# number. This code by Larry McVoy.
+
+	if {[regexp -- {libc-([0-9]+)\.([0-9]+)} $libc -> major minor]} {
+	    set v glibc${major}.${minor}
+	    return 1
+	}
+    }
+    return 0
+}
+
+# -- platform::patterns
+#
+# Given an exact platform identifier, i.e. _not_ the generic
+# identifier it assembles a list of exact platform identifier
+# describing platform which should be compatible with the
+# input.
+#
+# I.e. packages for all platforms in the result list should be
+# loadable on the specified platform.
+
+# << Should we add the generic identifier to the list as well ? In
+#    general it is not compatible I believe. So better not. In many
+#    cases the exact identifier is identical to the generic one
+#    anyway.
+# >>
+
+proc ::platform::patterns {id} {
+    set res [list $id]
+    if {$id eq "tcl"} {return $res}
+
+    switch -glob --  $id {
+	solaris*-* {
+	    if {[regexp {solaris([^-]*)-(.*)} $id -> v cpu]} {
+		if {$v eq ""} {return $id}
+		foreach {major minor} [split $v .] break
+		incr minor -1
+		for {set j $minor} {$j >= 6} {incr j -1} {
+		    lappend res solaris${major}.${j}-${cpu}
+		}
+	    }
+	}
+	linux*-* {
+	    if {[regexp {linux-glibc([^-]*)-(.*)} $id -> v cpu]} {
+		foreach {major minor} [split $v .] break
+		incr minor -1
+		for {set j $minor} {$j >= 0} {incr j -1} {
+		    lappend res linux-glibc${major}.${j}-${cpu}
+		}
+	    }
+	}
+	macosx-powerpc {
+	    lappend res macosx-universal
+	}
+	macosx-x86_64 {
+	    lappend res macosx-i386-x86_64
+	}
+	macosx-ix86 {
+	    lappend res macosx-universal macosx-i386-x86_64
+	}
+	macosx*-*    {
+	    # 10.5+,11.0+
+	    if {[regexp {macosx([^-]*)-(.*)} $id -> v cpu]} {
+
+		switch -exact -- $cpu {
+		    ix86    {
+			lappend alt i386-x86_64
+			lappend alt universal
+		    }
+		    x86_64  {
+			if {[lindex [split $::tcl_platform(osVersion) .] 0] < 19} {
+			    set alt i386-x86_64
+			} else {
+			    set alt {}
+			}
+		    }
+		    arm  {
+			lappend alt x86_64
+		    }
+		    default { set alt {} }
+		}
+
+		if {$v ne ""} {
+		    foreach {major minor} [split $v .] break
+
+		    set res {}
+		    if {$major eq 13} {
+			# Add 13.0 to 13.minor to patterns.
+			for {set j $minor} {$j >= 0} {incr j -1} {
+			    lappend res macosx${major}.${j}-${cpu}
+			    foreach a $alt {
+				lappend res macosx${major}.${j}-$a
+			    }
+			}
+			set major 12
+			set minor 5
+		    }
+		    if {$major eq 12} {
+			# Add 12.0 to 12.minor to patterns.
+			for {set j $minor} {$j >= 0} {incr j -1} {
+			    lappend res macosx${major}.${j}-${cpu}
+			    foreach a $alt {
+				lappend res macosx${major}.${j}-$a
+			    }
+			}
+			set major 11
+			set minor 5
+		    }
+		    if {$major eq 11} {
+			# Add 11.0 to 11.minor to patterns.
+			for {set j $minor} {$j >= 0} {incr j -1} {
+			    lappend res macosx${major}.${j}-${cpu}
+			    foreach a $alt {
+				lappend res macosx${major}.${j}-$a
+			    }
+			}
+			set major 10
+			set minor 15
+		    }
+		    # Add 10.5 to 10.minor to patterns.
+		    for {set j $minor} {$j >= 5} {incr j -1} {
+			if {$cpu ne "arm"} {
+			    lappend res macosx${major}.${j}-${cpu}
+			}
+			foreach a $alt {
+			    lappend res macosx${major}.${j}-$a
+			}
+		    }
+
+		    # Add unversioned patterns for 10.3/10.4 builds.
+		    lappend res macosx-${cpu}
+		    foreach a $alt {
+			lappend res macosx-$a
+		    }
+		} else {
+		    # No version, just do unversioned patterns.
+		    foreach a $alt {
+			lappend res macosx-$a
+		    }
+		}
+	    } else {
+		# no v, no cpu ... nothing
+	    }
+	}
+    }
+    lappend res tcl ; # Pure tcl packages are always compatible.
+    return $res
+}
+
+
+# ### ### ### ######### ######### #########
+## Ready
+
+package provide platform 1.0.19
+
+# ### ### ### ######### ######### #########
+## Demo application
+
+if {[info exists argv0] && ($argv0 eq [info script])} {
+    puts ====================================
+    parray tcl_platform
+    puts ====================================
+    puts Generic\ identification:\ [::platform::generic]
+    puts Exact\ identification:\ \ \ [::platform::identify]
+    puts ====================================
+    puts Search\ patterns:
+    puts *\ [join [::platform::patterns [::platform::identify]] \n*\ ]
+    puts ====================================
+    exit 0
+}
diff --git a/mplug_owl2/lib/tcl8/8.4/platform/shell-1.1.4.tm b/mplug_owl2/lib/tcl8/8.4/platform/shell-1.1.4.tm
new file mode 100644
index 0000000000000000000000000000000000000000..1e43409f27a76b164de2302fd2fe0545b411b3e5
--- /dev/null
+++ b/mplug_owl2/lib/tcl8/8.4/platform/shell-1.1.4.tm
@@ -0,0 +1,241 @@
+
+# -*- tcl -*-
+# ### ### ### ######### ######### #########
+## Overview
+
+# Higher-level commands which invoke the functionality of this package
+# for an arbitrary tcl shell (tclsh, wish, ...). This is required by a
+# repository as while the tcl shell executing packages uses the same
+# platform in general as a repository application there can be
+# differences in detail (i.e. 32/64 bit builds).
+
+# ### ### ### ######### ######### #########
+## Requirements
+
+package require platform
+namespace eval ::platform::shell {}
+
+# ### ### ### ######### ######### #########
+## Implementation
+
+# -- platform::shell::generic
+
+proc ::platform::shell::generic {shell} {
+    # Argument is the path to a tcl shell.
+
+    CHECK $shell
+    LOCATE base out
+
+    set     code {}
+    # Forget any preexisting platform package, it might be in
+    # conflict with this one.
+    lappend code {package forget platform}
+    # Inject our platform package
+    lappend code [list source $base]
+    # Query and print the architecture
+    lappend code {puts [platform::generic]}
+    # And done
+    lappend code {exit 0}
+
+    set arch [RUN $shell [join $code \n]]
+
+    if {$out} {file delete -force $base}
+    return $arch
+}
+
+# -- platform::shell::identify
+
+proc ::platform::shell::identify {shell} {
+    # Argument is the path to a tcl shell.
+
+    CHECK $shell
+    LOCATE base out
+
+    set     code {}
+    # Forget any preexisting platform package, it might be in
+    # conflict with this one.
+    lappend code {package forget platform}
+    # Inject our platform package
+    lappend code [list source $base]
+    # Query and print the architecture
+    lappend code {puts [platform::identify]}
+    # And done
+    lappend code {exit 0}
+
+    set arch [RUN $shell [join $code \n]]
+
+    if {$out} {file delete -force $base}
+    return $arch
+}
+
+# -- platform::shell::platform
+
+proc ::platform::shell::platform {shell} {
+    # Argument is the path to a tcl shell.
+
+    CHECK $shell
+
+    set     code {}
+    lappend code {puts $tcl_platform(platform)}
+    lappend code {exit 0}
+
+    return [RUN $shell [join $code \n]]
+}
+
+# ### ### ### ######### ######### #########
+## Internal helper commands.
+
+proc ::platform::shell::CHECK {shell} {
+    if {![file exists $shell]} {
+	return -code error "Shell \"$shell\" does not exist"
+    }
+    if {![file executable $shell]} {
+	return -code error "Shell \"$shell\" is not executable (permissions)"
+    }
+    return
+}
+
+proc ::platform::shell::LOCATE {bv ov} {
+    upvar 1 $bv base $ov out
+
+    # Locate the platform package for injection into the specified
+    # shell. We are using package management to find it, wherever it
+    # is, instead of using hardwired relative paths. This allows us to
+    # install the two packages as TMs without breaking the code
+    # here. If the found package is wrapped we copy the code somewhere
+    # where the spawned shell will be able to read it.
+
+    # This code is brittle, it needs has to adapt to whatever changes
+    # are made to the TM code, i.e. the "provide" statement generated by
+    # tm.tcl
+
+    set pl [package ifneeded platform [package require platform]]
+    set base [lindex $pl end]
+
+    set out 0
+    if {[lindex [file system $base]] ne "native"} {
+	set temp [TEMP]
+	file copy -force $base $temp
+	set base $temp
+	set out 1
+    }
+    return
+}
+
+proc ::platform::shell::RUN {shell code} {
+    set     c [TEMP]
+    set    cc [open $c w]
+    puts  $cc $code
+    close $cc
+
+    set e [TEMP]
+
+    set code [catch {
+        exec $shell $c 2> $e
+    } res]
+
+    file delete $c
+
+    if {$code} {
+	append res \n[read [set chan [open $e r]]][close $chan]
+	file delete $e
+	return -code error "Shell \"$shell\" is not executable ($res)"
+    }
+
+    file delete $e
+    return $res
+}
+
+proc ::platform::shell::TEMP {} {
+    set prefix platform
+
+    # This code is copied out of Tcllib's fileutil package.
+    # (TempFile/tempfile)
+
+    set tmpdir [DIR]
+
+    set chars "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+    set nrand_chars 10
+    set maxtries 10
+    set access [list RDWR CREAT EXCL TRUNC]
+    set permission 0600
+    set channel ""
+    set checked_dir_writable 0
+    set mypid [pid]
+    for {set i 0} {$i < $maxtries} {incr i} {
+ 	set newname $prefix
+ 	for {set j 0} {$j < $nrand_chars} {incr j} {
+ 	    append newname [string index $chars \
+		    [expr {int(rand()*62)}]]
+ 	}
+	set newname [file join $tmpdir $newname]
+ 	if {[file exists $newname]} {
+ 	    after 1
+ 	} else {
+ 	    if {[catch {open $newname $access $permission} channel]} {
+ 		if {!$checked_dir_writable} {
+ 		    set dirname [file dirname $newname]
+ 		    if {![file writable $dirname]} {
+ 			return -code error "Directory $dirname is not writable"
+ 		    }
+ 		    set checked_dir_writable 1
+ 		}
+ 	    } else {
+ 		# Success
+		close $channel
+ 		return [file normalize $newname]
+ 	    }
+ 	}
+    }
+    if {$channel ne ""} {
+ 	return -code error "Failed to open a temporary file: $channel"
+    } else {
+ 	return -code error "Failed to find an unused temporary file name"
+    }
+}
+
+proc ::platform::shell::DIR {} {
+    # This code is copied out of Tcllib's fileutil package.
+    # (TempDir/tempdir)
+
+    global tcl_platform env
+
+    set attempdirs [list]
+
+    foreach tmp {TMPDIR TEMP TMP} {
+	if { [info exists env($tmp)] } {
+	    lappend attempdirs $env($tmp)
+	}
+    }
+
+    switch $tcl_platform(platform) {
+	windows {
+	    lappend attempdirs "C:\\TEMP" "C:\\TMP" "\\TEMP" "\\TMP"
+	}
+	macintosh {
+	    set tmpdir $env(TRASH_FOLDER)  ;# a better place?
+	}
+	default {
+	    lappend attempdirs \
+		[file join / tmp] \
+		[file join / var tmp] \
+		[file join / usr tmp]
+	}
+    }
+
+    lappend attempdirs [pwd]
+
+    foreach tmp $attempdirs {
+	if { [file isdirectory $tmp] && [file writable $tmp] } {
+	    return [file normalize $tmp]
+	}
+    }
+
+    # Fail if nothing worked.
+    return -code error "Unable to determine a proper directory for temporary files"
+}
+
+# ### ### ### ######### ######### #########
+## Ready
+
+package provide platform::shell 1.1.4
diff --git a/mplug_owl2/lib/tcl8/8.5/msgcat-1.6.1.tm b/mplug_owl2/lib/tcl8/8.5/msgcat-1.6.1.tm
new file mode 100644
index 0000000000000000000000000000000000000000..851ad7721bef97a40a7ffa078816756219503660
--- /dev/null
+++ b/mplug_owl2/lib/tcl8/8.5/msgcat-1.6.1.tm
@@ -0,0 +1,1210 @@
+# 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) 2010-2015 Harald Oehlmann.
+# Copyright (c) 1998-2000 Ajuba Solutions.
+# Copyright (c) 1998 Mark Harrison.
+#
+# See the file "license.terms" for information on usage and redistribution
+# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+
+package require Tcl 8.5-
+# When the version number changes, be sure to update the pkgIndex.tcl file,
+# and the installation directory in the Makefiles.
+package provide msgcat 1.6.1
+
+namespace eval msgcat {
+    namespace export mc mcexists mcload mclocale mcmax mcmset mcpreferences mcset\
+            mcunknown mcflset mcflmset mcloadedlocales mcforgetpackage\
+	    mcpackageconfig mcpackagelocale
+
+    # Records the list of locales to search
+    variable Loclist {}
+
+    # List of currently loaded locales
+    variable LoadedLocales {}
+
+    # Records the locale of the currently sourced message catalogue file
+    variable FileLocale
+
+    # Configuration values per Package (e.g. client namespace).
+    # The dict key is of the form "<option> <namespace>" and the value is the
+    # configuration option. A non-existing key is an unset option.
+    variable PackageConfig [dict create mcfolder {} loadcmd {} changecmd {}\
+	    unknowncmd {} loadedlocales {} loclist {}]
+
+    # Records the mapping between source strings and translated strings.  The
+    # dict key is of the form "<namespace> <locale> <src>", where locale and
+    # namespace should be themselves dict values and the value is
+    # the translated string.
+    variable Msgs [dict create]
+
+    # Map of language codes used in Windows registry to those of ISO-639
+    if {[info sharedlibextension] eq ".dll"} {
+	variable WinRegToISO639 [dict create  {*}{
+	    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 0818 ro_MO
+	    19 ru 0819 ru_MO
+	    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
+	    32 tn
+	    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 translated
+#	string.
+#	If no catalog item is found, mcunknown is called in the caller frame
+#	and its result is returned.
+#
+# Arguments:
+#	src	The string to translate.
+#	args	Args to pass to the format command
+#
+# Results:
+#	Returns the translated string.  Propagates errors thrown by the
+#	format command.
+
+proc msgcat::mc {src args} {
+    # this may be replaced by:
+    # return [mcget -namespace [uplevel 1 [list ::namespace current]] --\
+    #	    $src {*}$args]
+
+    # Check for the src in each namespace starting from the local and
+    # ending in the global.
+
+    variable Msgs
+    variable Loclist
+
+    set ns [uplevel 1 [list ::namespace current]]
+    set loclist [PackagePreferences $ns]
+
+    set nscur $ns
+    while {$nscur != ""} {
+	foreach loc $loclist {
+	    if {[dict exists $Msgs $nscur $loc $src]} {
+		return [DefaultUnknown "" [dict get $Msgs $nscur $loc $src]\
+			{*}$args]
+	    }
+	}
+	set nscur [namespace parent $nscur]
+    }
+    # call package local or default unknown command
+    set args [linsert $args 0 [lindex $loclist 0] $src]
+    switch -exact -- [Invoke unknowncmd $args $ns result 1] {
+	0 { return [uplevel 1 [linsert $args 0 [namespace origin mcunknown]]] }
+	1 { return [DefaultUnknown {*}$args] }
+	default { return $result }
+    }
+}
+
+# msgcat::mcexists --
+#
+#	Check if a catalog item is set or if mc would invoke mcunknown.
+#
+# Arguments:
+#	-exactnamespace		Only check the exact namespace and no
+#				parent namespaces
+#	-exactlocale		Only check the exact locale and not all members
+#				of the preferences list
+#	src			Message catalog key
+#
+# Results:
+#	true if an adequate catalog key was found
+
+proc msgcat::mcexists {args} {
+
+    variable Msgs
+    variable Loclist
+    variable PackageConfig
+
+    set ns [uplevel 1 [list ::namespace current]]
+    set loclist [PackagePreferences $ns]
+
+    while {[llength $args] != 1} {
+	set args [lassign $args option]
+	switch -glob -- $option {
+	    -exactnamespace { set exactnamespace 1 }
+	    -exactlocale { set loclist [lrange $loclist 0 0] }
+	    -* { return -code error "unknown option \"$option\"" }
+	    default {
+		return -code error "wrong # args: should be\
+			\"[lindex [info level 0] 0] ?-exactnamespace?\
+			?-exactlocale? src\""
+	    }
+	}
+    }
+    set src [lindex $args 0]
+
+    while {$ns ne ""} {
+	foreach loc $loclist {
+	    if {[dict exists $Msgs $ns $loc $src]} {
+		return 1
+	    }
+	}
+	if {[info exists exactnamespace]} {return 0}
+	set ns [namespace parent $ns]
+    }
+    return 0
+}
+
+# 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 normalized set locale.
+
+proc msgcat::mclocale {args} {
+    variable Loclist
+    variable LoadedLocales
+    set len [llength $args]
+
+    if {$len > 1} {
+	return -code error "wrong # args: should be\
+		\"[lindex [info level 0] 0] ?newLocale?\""
+    }
+
+    if {$len == 1} {
+	set newLocale [string tolower [lindex $args 0]]
+	if {$newLocale ne [file tail $newLocale]} {
+	    return -code error "invalid newLocale value \"$newLocale\":\
+		    could be path to unsafe code."
+	}
+	if {[lindex $Loclist 0] ne $newLocale} {
+	    set Loclist [GetPreferences $newLocale]
+
+	    # locale not loaded jet
+	    LoadAll $Loclist
+	    # Invoke callback
+	    Invoke changecmd $Loclist
+	}
+    }
+    return [lindex $Loclist 0]
+}
+
+# msgcat::GetPreferences --
+#
+#	Get list of locales from a locale.
+#	The first element is always the lowercase locale.
+#	Other elements have one component separated by "_" less.
+#	Multiple "_" are seen as one separator: de__ch_spec de__ch de {}
+#
+# Arguments:
+#	Locale.
+#
+# Results:
+#	Locale list
+
+proc msgcat::GetPreferences {locale} {
+    set locale [string tolower $locale]
+    set loclist [list $locale]
+    while {-1 !=[set pos [string last "_" $locale]]} {
+	set locale [string range $locale 0 $pos-1]
+	if { "_" ne [string index $locale end] } {
+	    lappend loclist $locale
+	}
+    }
+    if {"" ne [lindex $loclist end]} {
+	lappend loclist {}
+    }
+    return $loclist
+}
+
+# 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::mcloadedlocales --
+#
+#	Get or change the list of currently loaded default locales
+#
+#	The following subcommands are available:
+#	loaded
+#	    Get the current list of loaded locales
+#	clear
+#	    Remove all loaded locales not present in mcpreferences.
+#
+# Arguments:
+#	subcommand		One of loaded or clear
+#
+# Results:
+#	Empty string, if not stated differently for the subcommand
+
+proc msgcat::mcloadedlocales {subcommand} {
+    variable Loclist
+    variable LoadedLocales
+    variable Msgs
+    variable PackageConfig
+    switch -exact -- $subcommand {
+	clear {
+	    # Remove all locales not contained in Loclist
+	    # skip any packages with package locale
+	    set LoadedLocales $Loclist
+	    foreach ns [dict keys $Msgs] {
+		if {![dict exists $PackageConfig loclist $ns]} {
+		    foreach locale [dict keys [dict get $Msgs $ns]] {
+			if {$locale ni $Loclist} {
+			    dict unset Msgs $ns $locale
+			}
+		    }
+		}
+	    }
+	}
+	loaded { return $LoadedLocales }
+	default {
+	    return -code error "unknown subcommand \"$subcommand\": must be\
+		    clear, or loaded"
+	}
+    }
+    return
+}
+
+# msgcat::mcpackagelocale --
+#
+#	Get or change the package locale of the calling package.
+#
+#	The following subcommands are available:
+#	set
+#	    Set a package locale.
+#	    This may load message catalog files and may clear message catalog
+#	    items, if the former locale was the default locale.
+#	    Returns the normalized set locale.
+#	    The default locale is taken, if locale is not given.
+#	get
+#	    Get the locale valid for this package.
+#	isset
+#	    Returns true, if a package locale is set
+#	unset
+#	    Unset the package locale and activate the default locale.
+#	    This loads message catalog file which where missing in the package
+#	    locale.
+#	preferences
+#	    Return locale preference list valid for the package.
+#	loaded
+#	    Return loaded locale list valid for the current package.
+#	clear
+#	    If the current package has a package locale, remove all package
+#	    locales not containes in package mcpreferences.
+#	    It is an error to call this without a package locale set.
+#
+#	The subcommands get, preferences and loaded return the corresponding
+#	default data, if no package locale is set.
+#
+# Arguments:
+#	subcommand		see list above
+#	locale			package locale (only set subcommand)
+#
+# Results:
+#	Empty string, if not stated differently for the subcommand
+
+proc msgcat::mcpackagelocale {subcommand {locale ""}} {
+    # todo: implement using an ensemble
+    variable Loclist
+    variable LoadedLocales
+    variable Msgs
+    variable PackageConfig
+    # Check option
+    # check if required item is exactly provided
+    if {[llength [info level 0]] == 2} {
+	# locale not given
+	unset locale
+    } else {
+	# locale given
+	if {$subcommand in
+		{"get" "isset" "unset" "preferences" "loaded" "clear"} } {
+	    return -code error "wrong # args: should be\
+		    \"[lrange [info level 0] 0 1]\""
+	}
+        set locale [string tolower $locale]
+    }
+    set ns [uplevel 1 {::namespace current}]
+
+    switch -exact -- $subcommand {
+	get { return [lindex [PackagePreferences $ns] 0] }
+	preferences { return [PackagePreferences $ns] }
+	loaded { return [PackageLocales $ns] }
+	present { return [expr {$locale in [PackageLocales $ns]} ]}
+	isset { return [dict exists $PackageConfig loclist $ns] }
+	set { # set a package locale or add a package locale
+
+	    # Copy the default locale if no package locale set so far
+	    if {![dict exists $PackageConfig loclist $ns]} {
+		dict set PackageConfig loclist $ns $Loclist
+		dict set PackageConfig loadedlocales $ns $LoadedLocales
+	    }
+
+	    # Check if changed
+	    set loclist [dict get $PackageConfig loclist $ns]
+	    if {! [info exists locale] || $locale eq [lindex $loclist 0] } {
+		return [lindex $loclist 0]
+	    }
+
+	    # Change loclist
+	    set loclist [GetPreferences $locale]
+	    set locale [lindex $loclist 0]
+	    dict set PackageConfig loclist $ns $loclist
+
+	    # load eventual missing locales
+	    set loadedLocales [dict get $PackageConfig loadedlocales $ns]
+	    if {$locale in $loadedLocales} { return $locale }
+	    set loadLocales [ListComplement $loadedLocales $loclist]
+	    dict set PackageConfig loadedlocales $ns\
+		    [concat $loadedLocales $loadLocales]
+	    Load $ns $loadLocales
+	    return $locale
+	}
+	clear { # Remove all locales not contained in Loclist
+	    if {![dict exists $PackageConfig loclist $ns]} {
+		return -code error "clear only when package locale set"
+	    }
+	    set loclist [dict get $PackageConfig loclist $ns]
+	    dict set PackageConfig loadedlocales $ns $loclist
+	    if {[dict exists $Msgs $ns]} {
+		foreach locale [dict keys [dict get $Msgs $ns]] {
+		    if {$locale ni $loclist} {
+			dict unset Msgs $ns $locale
+		    }
+		}
+	    }
+	}
+	unset {	# unset package locale and restore default locales
+
+	    if { ![dict exists $PackageConfig loclist $ns] } { return }
+
+	    # unset package locale
+	    set loadLocales [ListComplement\
+		    [dict get $PackageConfig loadedlocales $ns] $LoadedLocales]
+	    dict unset PackageConfig loadedlocales $ns
+	    dict unset PackageConfig loclist $ns
+
+	    # unset keys not in global loaded locales
+	    if {[dict exists $Msgs $ns]} {
+		foreach locale [dict keys [dict get $Msgs $ns]] {
+		    if {$locale ni $LoadedLocales} {
+			dict unset Msgs $ns $locale
+		    }
+		}
+	    }
+
+	    # Add missing locales
+	    Load $ns $loadLocales
+	}
+	default {
+	    return -code error "unknown subcommand \"$subcommand\": must be\
+		    clear, get, isset, loaded, present, set, or unset"
+	}
+    }
+    return
+}
+
+# msgcat::mcforgetpackage --
+#
+#	Remove any data of the calling package from msgcat
+#
+
+proc msgcat::mcforgetpackage {} {
+    # todo: this may be implemented using an ensemble
+    variable PackageConfig
+    variable Msgs
+    set ns [uplevel 1 {::namespace current}]
+    # Remove MC items
+    dict unset Msgs $ns
+    # Remove config items
+    foreach key [dict keys $PackageConfig] {
+	dict unset PackageConfig $key $ns
+    }
+    return
+}
+
+# msgcat::mcpackageconfig --
+#
+#	Get or modify the per caller namespace (e.g. packages) config options.
+#
+#	Available subcommands are:
+#
+#	    get		get the current value or an error if not set.
+#	    isset	return true, if the option is set
+#	    set		set the value (see also distinct option).
+#			Returns the number of loaded message files.
+#	    unset	Clear option. return "".
+#
+#	Available options are:
+#
+#	mcfolder
+#	    The message catalog folder of the package.
+#	    This is automatically set by mcload.
+#	    If the value is changed using the set subcommand, an eventual
+#	    loadcmd is invoked and all message files of the package locale are
+#	    loaded.
+#
+#	loadcmd
+#	    The command gets executed before a message file would be
+#	    sourced for this module.
+#	    The command is invoked with the expanded locale list to load.
+#	    The command is not invoked if the registering package namespace
+#	    is not present.
+#	    This callback might also be used as an alternative to message
+#	    files.
+#	    If the value is changed using the set subcommand, the callback is
+#	    directly invoked with the current file locale list. No file load is
+#	    executed.
+#
+#	changecmd
+#	    The command is invoked, after an executed locale change.
+#	    Appended argument is expanded mcpreferences.
+#
+#	unknowncmd
+#	    Use a package locale mcunknown procedure instead the global one.
+#	    The appended arguments are identical to mcunknown.
+#	    A default unknown handler is used if set to the empty string.
+#	    This consists in returning the key if no arguments are given.
+#	    With given arguments, format is used to process the arguments.
+#
+# Arguments:
+#	subcommand		Operation on the package
+#	option			The package option to get or set.
+#	?value?			Eventual value for the subcommand
+#
+# Results:
+#	Depends on the subcommand and option and is described there
+
+proc msgcat::mcpackageconfig {subcommand option {value ""}} {
+    variable PackageConfig
+    # get namespace
+    set ns [uplevel 1 {::namespace current}]
+
+    if {$option ni {"mcfolder" "loadcmd" "changecmd" "unknowncmd"}} {
+	return -code error "bad option \"$option\": must be mcfolder, loadcmd,\
+		changecmd, or unknowncmd"
+    }
+
+    # check if value argument is exactly provided
+    if {[llength [info level 0]] == 4 } {
+	# value provided
+	if {$subcommand in {"get" "isset" "unset"}} {
+	    return -code error "wrong # args: should be\
+		    \"[lrange [info level 0] 0 2] value\""
+	}
+    } elseif {$subcommand eq "set"} {
+        return -code error\
+		"wrong # args: should be \"[lrange [info level 0] 0 2]\""
+    }
+
+    # Execute subcommands
+    switch -exact -- $subcommand {
+	get {	# Operation get return current value
+	    if {![dict exists $PackageConfig $option $ns]} {
+		return -code error "package option \"$option\" not set"
+	    }
+	    return [dict get $PackageConfig $option $ns]
+	}
+	isset {	return [dict exists $PackageConfig $option $ns] }
+	unset {	dict unset PackageConfig $option $ns }
+	set {	# Set option
+
+	    if {$option eq "mcfolder"} {
+		set value [file normalize $value]
+	    }
+	    # Check if changed
+	    if { [dict exists $PackageConfig $option $ns]
+		    && $value eq [dict get $PackageConfig $option $ns] } {
+		return 0
+	    }
+
+	    # set new value
+	    dict set PackageConfig $option $ns $value
+
+	    # Reload pending message catalogs
+	    switch -exact -- $option {
+		mcfolder { return [Load $ns [PackageLocales $ns]] }
+		loadcmd { return [Load $ns [PackageLocales $ns] 1] }
+	    }
+	    return 0
+	}
+	default {
+	    return -code error "unknown subcommand \"$subcommand\":\
+		    must be get, isset, set, or unset"
+	}
+    }
+    return
+}
+
+# msgcat::PackagePreferences --
+#
+#	Return eventual present package preferences or the default list if not
+#	present.
+#
+# Arguments:
+#	ns		Package namespace
+#
+# Results:
+#	locale list
+
+proc msgcat::PackagePreferences {ns} {
+    variable PackageConfig
+    if {[dict exists $PackageConfig loclist $ns]} {
+	return [dict get $PackageConfig loclist $ns]
+    }
+    variable Loclist
+    return $Loclist
+}
+
+# msgcat::PackageLocales --
+#
+#	Return eventual present package locales or the default list if not
+#	present.
+#
+# Arguments:
+#	ns		Package namespace
+#
+# Results:
+#	locale list
+
+proc msgcat::PackageLocales {ns} {
+    variable PackageConfig
+    if {[dict exists $PackageConfig loadedlocales $ns]} {
+	return [dict get $PackageConfig loadedlocales $ns]
+    }
+    variable LoadedLocales
+    return $LoadedLocales
+}
+
+# msgcat::ListComplement --
+#
+#	Build the complement of two lists.
+#	Return a list with all elements in list2 but not in list1.
+#	Optionally return the intersection.
+#
+# Arguments:
+#	list1		excluded list
+#	list2		included list
+#	inlistname	If not "", write in this variable the intersection list
+#
+# Results:
+#	list with all elements in list2 but not in list1
+
+proc msgcat::ListComplement {list1 list2 {inlistname ""}} {
+    if {"" ne $inlistname} {
+	upvar 1 $inlistname inlist
+    }
+    set inlist {}
+    set outlist {}
+    foreach item $list2 {
+	if {$item in $list1} {
+	    lappend inlist $item
+	} else {
+	    lappend outlist $item
+	}
+    }
+    return $outlist
+}
+
+# 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} {
+    return [uplevel 1 [list\
+	    [namespace origin mcpackageconfig] set mcfolder $langdir]]
+}
+
+# msgcat::LoadAll --
+#
+#	Load a list of locales for all packages not having a package locale
+#	list.
+#
+# Arguments:
+#	langdir		The directory to search.
+#
+# Results:
+#	Returns the number of message catalogs that were loaded.
+
+proc msgcat::LoadAll {locales} {
+    variable PackageConfig
+    variable LoadedLocales
+    if {0 == [llength $locales]} { return {} }
+    # filter jet unloaded locales
+    set locales [ListComplement $LoadedLocales $locales]
+    if {0 == [llength $locales]} { return {} }
+    lappend LoadedLocales {*}$locales
+
+    set packages [lsort -unique [concat\
+	    [dict keys [dict get $PackageConfig loadcmd]]\
+	    [dict keys [dict get $PackageConfig mcfolder]]]]
+    foreach ns $packages {
+	if {! [dict exists $PackageConfig loclist $ns] } {
+	    Load $ns $locales
+	}
+    }
+    return $locales
+}
+
+# msgcat::Load --
+#
+#	Invoke message load callback and load message catalog files.
+#
+# Arguments:
+#	ns		Namespace (equal package) to load the message catalog.
+#	locales		List of locales to load.
+#	callbackonly	true if only callback should be invoked
+#
+# Results:
+#	Returns the number of message catalogs that were loaded.
+
+proc msgcat::Load {ns locales {callbackonly 0}} {
+    variable FileLocale
+    variable PackageConfig
+    variable LoadedLocals
+
+    if {0 == [llength $locales]} { return 0 }
+
+    # Invoke callback
+    Invoke loadcmd $locales $ns
+
+    if {$callbackonly || ![dict exists $PackageConfig mcfolder $ns]} {
+	return 0
+    }
+
+    # Invoke file load
+    set langdir [dict get $PackageConfig mcfolder $ns]
+
+    # Save the file locale if we are recursively called
+    if {[info exists FileLocale]} {
+	set nestedFileLocale $FileLocale
+    }
+    set x 0
+    foreach p $locales {
+	if {$p eq {}} {
+	    set p ROOT
+	}
+	set langfile [file join $langdir $p.msg]
+	if {[file exists $langfile]} {
+	    incr x
+	    set FileLocale [string tolower\
+		    [file tail [file rootname $langfile]]]
+	    if {"root" eq $FileLocale} {
+		set FileLocale ""
+	    }
+	    namespace inscope $ns [list ::source -encoding utf-8 $langfile]
+	    unset FileLocale
+	}
+    }
+    if {[info exists nestedFileLocale]} {
+	set FileLocale $nestedFileLocale
+    }
+    return $x
+}
+
+# msgcat::Invoke --
+#
+#	Invoke a set of registered callbacks.
+#	The callback is only invoked, if its registered namespace exists.
+#
+# Arguments:
+#	index		Index into PackageConfig to get callback command
+#	arglist		parameters to the callback invocation
+#	ns		(Optional) package to call.
+#			If not given or empty, check all registered packages.
+#	resultname	Variable to save the callback result of the last called
+#			callback to. May be set to "" to discard the result.
+#	failerror (0)	Fail on error if true. Otherwise call bgerror.
+#
+# Results:
+#	Possible values:
+#	- 0: no valid command registered
+#	- 1: registered command was the empty string
+#	- 2: registered command called, resultname is set
+#	- 3: registered command failed
+#	If multiple commands are called, the maximum of all results is returned.
+
+proc msgcat::Invoke {index arglist {ns ""} {resultname ""} {failerror 0}} {
+    variable PackageConfig
+    variable Config
+    if {"" ne $resultname} {
+	upvar 1 $resultname result
+    }
+    if {"" eq $ns} {
+	set packageList [dict keys [dict get $PackageConfig $index]]
+    } else {
+	set packageList [list $ns]
+    }
+    set ret 0
+    foreach ns $packageList {
+	if {[dict exists $PackageConfig $index $ns] && [namespace exists $ns]} {
+	    set cmd [dict get $PackageConfig $index $ns]
+	    if {"" eq $cmd} {
+		if {$ret == 0} {set ret 1}
+	    } else {
+		if {$failerror} {
+		    set result [namespace inscope $ns $cmd {*}$arglist]
+		    set ret 2
+		} elseif {1 == [catch {
+		    set result [namespace inscope $ns $cmd {*}$arglist]
+		    if {$ret < 2} {set ret 2}
+		} err derr]} {
+		    after idle [concat [::interp bgerror ""]\
+			    [list $err $derr]]
+		    set ret 3
+		}
+	    }
+	}
+    }
+    return $ret
+}
+
+# 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 locale [string tolower $locale]
+
+    dict set Msgs $ns $locale $src $dest
+    return $dest
+}
+
+# msgcat::mcflset --
+#
+#	Set the translation for a given string in the current file locale.
+#
+# Arguments:
+#	src		The source string.
+#	dest		(Optional) The translated string.  If omitted,
+#			the source string is used.
+#
+# Results:
+#	Returns the new locale.
+
+proc msgcat::mcflset {src {dest ""}} {
+    variable FileLocale
+    variable Msgs
+
+    if {![info exists FileLocale]} {
+	return -code error "must only be used inside a message catalog loaded\
+		with ::msgcat::mcload"
+    }
+    return [uplevel 1 [list [namespace origin mcset] $FileLocale $src $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} {
+	return -code error "bad translation list:\
+		should be \"[lindex [info level 0] 0] locale {src dest ...}\""
+    }
+
+    set locale [string tolower $locale]
+    set ns [uplevel 1 [list ::namespace current]]
+
+    foreach {src dest} $pairs {
+	dict set Msgs $ns $locale $src $dest
+    }
+
+    return [expr {$length / 2}]
+}
+
+# msgcat::mcflmset --
+#
+#	Set the translation for multiple strings in the mc file locale.
+#
+# Arguments:
+#	pairs		One or more src/dest pairs (must be even length)
+#
+# Results:
+#	Returns the number of pairs processed
+
+proc msgcat::mcflmset {pairs} {
+    variable FileLocale
+    variable Msgs
+
+    if {![info exists FileLocale]} {
+	return -code error "must only be used inside a message catalog loaded\
+		with ::msgcat::mcload"
+    }
+    return [uplevel 1 [list [namespace origin mcmset] $FileLocale $pairs]]
+}
+
+# msgcat::mcunknown --
+#
+#	This routine is called by msgcat::mc if a translation cannot
+#	be found for a string and no unknowncmd is set for the current
+#	package. 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 translated 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 {args} {
+    return [uplevel 1 [list [namespace origin DefaultUnknown] {*}$args]]
+}
+
+# msgcat::DefaultUnknown --
+#
+#	This routine is called by msgcat::mc if a translation cannot
+#	be found for a string in the following circumstances:
+#	- Default global handler, if mcunknown is not redefined.
+#	- Per package handler, if the package sets unknowncmd to the empty
+#	  string.
+#	It returns the source string if the argument list is empty.
+#	If additional args are specified, the format command will be used
+#	to work them into the translated string.
+#
+# Arguments:
+#	locale		(unused) The current locale.
+#	src		The string to be translated.
+#	args		Args to pass to the format command
+#
+# Results:
+#	Returns the translated value.
+
+proc msgcat::DefaultUnknown {locale src args} {
+    if {[llength $args]} {
+	return [format $src {*}$args]
+    } else {
+	return $src
+    }
+}
+
+# msgcat::mcmax --
+#
+#	Calculates the maximum 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 {} {
+    global env
+
+    #
+    # set default locale, try to get from environment
+    #
+    foreach varName {LC_ALL LC_MESSAGES LANG} {
+	if {[info exists env($varName)] && ("" ne $env($varName))} {
+	    if {![catch {
+		mclocale [ConvertLocale $env($varName)]
+	    }]} {
+		return
+	    }
+	}
+    }
+    #
+    # On Darwin, fallback to current CFLocale identifier if available.
+    #
+    if {[info exists ::tcl::mac::locale] && $::tcl::mac::locale ne ""} {
+	if {![catch {
+	    mclocale [ConvertLocale $::tcl::mac::locale]
+	}]} {
+	    return
+	}
+    }
+    #
+    # The rest of this routine is special processing for Windows or
+    # Cygwin. All other platforms, get out now.
+    #
+    if {([info sharedlibextension] ne ".dll")
+	    || [catch {package require registry}]} {
+	mclocale C
+	return
+    }
+    #
+    # On Windows or Cygwin, try to set locale depending on registry
+    # settings, or fall back on locale of "C".
+    #
+
+    # On Vista and later:
+    # HCU/Control Panel/Desktop : PreferredUILanguages is for language packs,
+    # HCU/Control Pannel/International : localName is the default locale.
+    #
+    # They contain the local string as RFC5646, composed of:
+    # [a-z]{2,3} : language
+    # -[a-z]{4}  : script (optional, translated by table Latn->latin)
+    # -[a-z]{2}|[0-9]{3} : territory (optional, numerical region codes not used)
+    # (-.*)* : variant, extension, private use (optional, not used)
+    # Those are translated to local strings.
+    # Examples: de-CH -> de_ch, sr-Latn-CS -> sr_cs@latin, es-419 -> es
+    #
+    foreach key {{HKEY_CURRENT_USER\Control Panel\Desktop} {HKEY_CURRENT_USER\Control Panel\International}}\
+	    value {PreferredUILanguages localeName} {
+	if {![catch {registry get $key $value} localeName]
+		&& [regexp {^([a-z]{2,3})(?:-([a-z]{4}))?(?:-([a-z]{2}))?(?:-.+)?$}\
+		    [string tolower $localeName] match locale script territory]} {
+	    if {"" ne $territory} {
+		append locale _ $territory
+	    }
+	    set modifierDict [dict create latn latin cyrl cyrillic]
+	    if {[dict exists $modifierDict $script]} {
+		append locale @ [dict get $modifierDict $script]
+	    }
+	    if {![catch {mclocale [ConvertLocale $locale]}]} {
+		return
+	    }
+	}
+    }
+
+    # then check value locale which contains a numerical language ID
+    if {[catch {
+	set locale [registry get $key "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 [dict get $WinRegToISO639 $locale]]
+	}]} {
+	    return
+	}
+	set locale [string range $locale 1 end]
+    }
+    #
+    # No translation known.  Fall back on "C" locale
+    #
+    mclocale C
+}
+msgcat::Init
diff --git a/mplug_owl2/lib/tcl8/8.5/tcltest-2.5.7.tm b/mplug_owl2/lib/tcl8/8.5/tcltest-2.5.7.tm
new file mode 100644
index 0000000000000000000000000000000000000000..d5bb7fee7b6661498506413e293b780460110f1b
--- /dev/null
+++ b/mplug_owl2/lib/tcl8/8.5/tcltest-2.5.7.tm
@@ -0,0 +1,3584 @@
+# 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 © 1994-1997 Sun Microsystems, Inc.
+# Copyright © 1998-1999 Scriptics Corporation.
+# Copyright © 2000 Ajuba Solutions
+# Contributions from Don Porter, NIST, 2002.  (not subject to US copyright)
+# All rights reserved.
+
+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.5.7
+
+    # Compatibility support for dumb variables defined in tcltest 1
+    # Do not use these.  Call [package require] and [info patchlevel]
+    # yourself.  You don't need tcltest to wrap it for you.
+    variable version [package require Tcl 8.5-]
+    variable patchLevel [info patchlevel]
+
+    # Detect if we can use code points >= \U10000
+    variable fullutf [package vsatisfies $version 8.7-]
+
+##### 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)
+    if {!$fullutf} {
+	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 1 $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 preinitialized 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]} {
+	    # Preinitialized 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 preinitialized 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
+    # preexisting 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 add variable constraintsSpecified read [namespace code {
+	    set constraintsSpecified [array names testConstraints] ;#}]
+
+    # tests that use threads need to know which is the main thread
+    Default mainThread 1
+    variable mainThread
+    if {[info commands thread::id] ne {}} {
+	set mainThread [thread::id]
+    } elseif {[info commands testthread] ne {}} {
+	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 add variable workingDirectory write \
+	    [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 add variable tcltest write [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 procedures 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
+	variable fullutf
+
+	# 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] whenever 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 initial 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) -- <whew!> -- 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]
+		if {$fullutf} {
+		    fconfigure $outputChannel -profile tcl8 -encoding utf-8
+		}
+		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 {$outdir eq [temporaryDirectory]} {
+		    variable filesExisted
+		    FillFilesExisted
+		    set filename [file tail $filename]
+		    if {$filename ni $filesExisted} {
+			lappend filesExisted $filename
+		    }
+		}
+	    }
+	}
+	return $outputChannel
+    }
+
+    # errors go to stderr by default
+    Default errorChannel stderr
+    proc errorChannel { {filename ""} } {
+	variable errorChannel
+	variable ChannelsWeOpened
+	variable fullutf
+
+	# 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]
+		if {$fullutf} {
+		    fconfigure $errorChannel -profile tcl8 -encoding utf-8
+		}
+		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 {$outdir eq [temporaryDirectory]} {
+		    variable filesExisted
+		    FillFilesExisted
+		    set filename [file tail $filename]
+		    if {$filename ni $filesExisted} {
+			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 preset 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
+	variable DefaultValue
+	set Usage($option) $usage
+	set Verify($option) $verify
+	set DefaultValue($option) $value
+	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 {$option in $match} {
+		    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 add variable $varName read [namespace code {
+		    ProcessCmdLineArgs ;#}]
+	}
+    }
+
+    proc RemoveAutoConfigureTraces {} {
+	variable OptionControlledVariables
+	foreach varName [concat $OptionControlledVariables Option] {
+	    variable $varName
+	    foreach pair [trace info variable $varName] {
+		lassign $pair op cmd
+		if {($op eq "read") &&
+			[string match *ProcessCmdLineArgs* $cmd]} {
+		    trace remove variable $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 {
+	if {[llength $args] > 1} {
+	    RemoveAutoConfigureTraces
+	}
+	set code [catch {Configure {*}$args} msg]
+	return -code $code $msg
+    }
+
+    proc AcceptVerbose { level } {
+	set level [AcceptList $level]
+	set levelMap {
+	    l list
+	    p pass
+	    b body
+	    s skip
+	    t start
+	    e error
+	    l line
+	    m msec
+	    u usec
+	}
+	set levelRegexp "^([join [dict values $levelMap] |])\$"
+	if {[llength $level] == 1} {
+	    if {![regexp $levelRegexp $level]} {
+		# translate single characters abbreviations to expanded list
+		set level [string map $levelMap [split $level {}]]
+	    }
+	}
+	set valid [list]
+	foreach v $level {
+	    if {[regexp $levelRegexp $v]} {
+		lappend valid $v
+	    }
+	}
+	return $valid
+    }
+
+    proc IsVerbose {level} {
+	variable Option
+	return [expr {$level in $Option(-verbose)}]
+    }
+
+    # Default verbosity is to show bodies of failed tests
+    Option -verbose {body error} {
+	Takes any combination of the values 'p', 's', 'b', 't', 'e' and 'l'.
+	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. Source file line
+	information of failed tests is displayed if 'l' 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 add variable Option(-constraints) write \
+	    [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 {$c ni $Option(-constraints)} {
+		testConstraint $c 0
+	    }
+	}
+    }
+    Option -limitconstraints 0 {
+	whether to run only tests with the constraints
+    } AcceptBoolean limitConstraints
+    trace add variable Option(-limitconstraints) write \
+	    [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 {[workingDirectory] eq $directory} {
+		# Special exception: accept the default value
+		# even if the directory is not writable
+		return $directory
+	    }
+	    return -code error "\"$directory\" is not writable"
+	}
+	return $directory
+    }
+
+    # Directory where files should be created
+    Option -tmpdir [workingDirectory] {
+	Save temporary files in the specified directory.
+    } AcceptTemporaryDirectory temporaryDirectory
+    trace add variable Option(-tmpdir) write \
+	    [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 add variable Option(-testdir) write \
+	    [namespace code {normalizePath Option(-testdir) ;#}]
+
+    proc AcceptLoadFile { file } {
+	if {$file eq {}} {return $file}
+	set file [file join [temporaryDirectory] $file]
+	return [AcceptReadable $file]
+    }
+    proc ReadLoadScript {args} {
+	variable Option
+	variable fullutf
+
+	if {$Option(-loadfile) eq {}} {return}
+	set tmp [open $Option(-loadfile) r]
+	if {$fullutf} {
+	    fconfigure $tmp -profile tcl8 -encoding utf-8
+	}
+	loadScript [read $tmp]
+	close $tmp
+    }
+    Option -loadfile {} {
+	Read the script to load the tested commands from the specified file.
+    } AcceptLoadFile loadFile
+    trace add variable Option(-loadfile) write [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 add variable Option(-outfile) write \
+	    [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 add variable Option(-errfile) write \
+	    [namespace code {errorChannel $Option(-errfile) ;#}]
+
+    proc loadIntoChildInterpreter {child args} {
+	variable Version
+	interp eval $child [package ifneeded tcltest $Version]
+	interp eval $child "tcltest::configure {*}{$args}"
+	interp alias $child ::tcltest::ReportToParent \
+	    {} ::tcltest::ReportedFromChild
+    }
+    proc ReportedFromChild {total passed skipped failed because newfiles} {
+	variable numTests
+	variable skippedBecause
+	variable createdNewFiles
+	incr numTests(Total)   $total
+	incr numTests(Passed)  $passed
+	incr numTests(Skipped) $skipped
+	incr numTests(Failed)  $failed
+	foreach {constraint count} $because {
+	    incr skippedBecause($constraint) $count
+	}
+	foreach {testfile created} $newfiles {
+	    lappend createdNewFiles($testfile) {*}$created
+	}
+	return
+    }
+}
+
+#####################################################################
+
+# tcltest::Debug* --
+#
+#     Internal helper procedures to write out debug information
+#     dependent on the chosen level. A test shell may override
+#     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 1 $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 && 1}} msg]} {
+	return -code error $msg
+    }
+    if {[limitConstraints] && ($constraint ni $Option(-constraints))} {
+	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
+    }
+    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 {$beginningIndex ne "end"} {
+	    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 {$n2 eq {}} {return}
+    if {![info exists testConstraints($n2)]} {
+	if {[catch {testConstraint $n2 [eval [ConstraintInitializer $n2]]}]} {
+	    testConstraint $n2 0
+	}
+    }
+}
+
+# tcltest::Asciify --
+#
+#       Transforms the passed string to contain only printable ascii characters.
+#       Useful for printing to terminals. Non-printables are mapped to
+#       \x, \u or \U sequences, except \n.
+#
+# Arguments:
+#       s - string to transform
+#
+# Results:
+#       The transformed strings
+#
+# Side effects:
+#       None.
+
+proc tcltest::Asciify {s} {
+    set print ""
+    foreach c [split $s ""] {
+        if {(($c < "\x7F") && [string is print $c]) || ($c eq "\n")} {
+            append print $c
+        } elseif {$c < "\u0100"} {
+            append print \\x[format %02X [scan $c %c]]
+        } elseif {$c > "\uFFFF"} {
+            append print \\U[format %08X [scan $c %c]]
+        } else {
+            append print \\u[format %04X [scan $c %c]]
+        }
+    }
+    return $print
+}
+
+# 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 \
+	    {($::tcl_platform(platform) eq "unix") &&
+		    ($::tcl_platform(user) in {root {}})}}
+    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 {$::tcl_platform(platform) eq "macintosh"} {
+	    set code 0
+        }
+        if {$::tcl_platform(platform) eq "windows"} {
+	    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 {
+	variable fullutf
+
+	set code 0
+	if {![catch {set f [open "|[list [interpreter]]" w]}]} {
+	    if {$fullutf} {
+		fconfigure $f -profile tcl8 -encoding utf-8
+	    }
+	    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]
+	    lassign $foo x type($opt) usage($opt)
+	    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 {$option eq "-help"} {
+	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 {"-help" in $flagArray} {
+	PrintUsageInfo
+	exit 1
+    }
+
+    if {[llength $flagArray] == 0} {
+	RemoveAutoConfigureTraces
+    } else {
+	set args $flagArray
+	while {[llength $args] > 1 && [catch {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 {$option ni $moreOptions} {
+		    # 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 {[lindex $args 0] ne $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 {[lindex $args 0] eq "-nonewline"} {
+		append outData [lindex $args end]
+		return
+		# return [Puts -nonewline [lindex $args end]]
+	    } else {
+		set channel [lindex $args 0]
+		set newline \n
+	    }
+	}
+	3 {
+	    if {[lindex $args 0] eq "-nonewline"} {
+		# 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 {$channel in [list [[namespace parent]::outputChannel] stdout]} {
+	    append outData [lindex $args end]$newline
+	    return
+	} elseif {$channel in [list [[namespace parent]::errorChannel] 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 [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-separated 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 ne {}} {
+            # 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}.
+#   errorCode -         Expected error code.  This attribute is
+#                       optional; default is {*}. It is a glob pattern.
+#                       If given, returnCodes defaults to {1}.
+#   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 preregistered
+#			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
+    variable fullutf
+
+    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
+
+    # Predefine 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.
+    lassign {} constraints setup cleanup body result returnCodes errorCode match
+
+    # 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]
+
+    # Set the default error code pattern
+    set errorCode "*"
+
+    # 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 errorCode 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 \
+		-errorCode -match -output -errorOutput -constraints}
+
+	foreach flag [array names testAttributes] {
+	    if {$flag ni $validFlags} {
+		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 {$match ni [array names CustomMatch]} {
+	    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]
+	}
+        # errorCode without returnCode 1 is meaningless
+        if {$errorCode ne "*" && 1 ni $returnCodes} {
+            set returnCodes 1
+        }
+    } 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 (or a hook if it presents):
+    if {[set cmd [namespace which -command [namespace current]::SetupTest]] ne ""} {
+	set setup [list $cmd $setup]
+    }
+    set processTest 1
+    set code [catch {uplevel 1 $setup} setupMsg]
+    if {$code == 1} {
+	set errorInfo(setup) $::errorInfo
+	set errorCodeRes(setup) $::errorCode
+	if {$errorCodeRes(setup) eq "BYPASS-SKIPPED-TEST"} {
+	    _noticeSkipped $name $setupMsg
+	    set processTest [set code 0]
+	}
+    }
+    set setupFailure [expr {$code != 0}]
+
+    # Only run the test body if the setup was successful
+    if {$processTest && !$setupFailure} {
+
+	# Register startup time
+	if {[IsVerbose msec] || [IsVerbose usec]} {
+	    set timeStart [clock microseconds]
+	}
+
+	# 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]]
+	}
+	lassign $testResult actualAnswer returnCode
+	if {$returnCode == 1} {
+	    set errorInfo(body) $::errorInfo
+	    set errorCodeRes(body) $::errorCode
+	    if {$errorCodeRes(body) eq "BYPASS-SKIPPED-TEST"} {
+		_noticeSkipped $name $actualAnswer
+		set processTest [set returnCode 0]
+	    }
+	}
+    }
+
+    # check if the return code matched the expected return code
+    set codeFailure 0
+    if {$processTest && !$setupFailure && ($returnCode ni $returnCodes)} {
+	set codeFailure 1
+    }
+    set errorCodeFailure 0
+    if {$processTest && !$setupFailure && !$codeFailure && $returnCode == 1 && \
+                ![string match $errorCode $errorCodeRes(body)]} {
+	set errorCodeFailure 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 {$processTest && [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 {$processTest && [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 {!$processTest} {
+    	set scriptFailure 0
+    } elseif {$setupFailure || $codeFailure} {
+	set scriptFailure 0
+    } elseif {[set scriptCompare [catch {
+	CompareStrings $actualAnswer $result $match
+    } scriptMatch]] == 0} {
+	set scriptFailure [expr {!$scriptMatch}]
+    } else {
+	set scriptFailure 1
+    }
+
+    # Always run the cleanup script (or a hook if it presents):
+    if {[set cmd [namespace which -command [namespace current]::CleanupTest]] ne ""} {
+	set cleanup [list $cmd $cleanup]
+    }
+    set code [catch {uplevel 1 $cleanup} cleanupMsg]
+    if {$code == 1} {
+	set errorInfo(cleanup) $::errorInfo
+	set errorCodeRes(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 {$msg ne {}} {
+		    append coreMsg "\nError:\
+			Problem renaming core file: $msg"
+		}
+	    }
+	}
+    }
+
+    if {[IsVerbose msec] || [IsVerbose usec]} {
+	set t [expr {[clock microseconds] - $timeStart}]
+	if {[IsVerbose usec]} {
+	    puts [outputChannel] "++++ $name took $t \xB5s"
+	}
+	if {[IsVerbose msec]} {
+	    puts [outputChannel] "++++ $name took [expr {round($t/1000.)}] ms"
+	}
+    }
+
+    # if skipped, it is safe to return here
+    if {!$processTest} {
+	incr testLevel -1
+	return
+    }
+
+    # if we didn't experience any failures, then we passed
+    variable numTests
+    if {!($setupFailure || $cleanupFailure || $coreFailure
+	    || $outputFailure || $errorFailure || $codeFailure
+	    || $errorCodeFailure || $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"
+    if {[IsVerbose line]} {
+	if {![catch {set testFrame [info frame -1]}] &&
+		[dict get $testFrame type] eq "source"} {
+	    set testFile [dict get $testFrame file]
+	    set testLine [dict get $testFrame line]
+	} else {
+	    set testFile [file normalize [uplevel 1 {info script}]]
+	    if {[file readable $testFile]} {
+		set testFd [open $testFile r]
+		if {$fullutf} {
+		    fconfigure $testFd -profile tcl8 -encoding utf-8
+		}
+		set testLine [expr {[lsearch -regexp \
+			[split [read $testFd] "\n"] \
+			"^\[ \t\]*test [string map {. \\.} $name] "] + 1}]
+		close $testFd
+	    }
+	}
+	if {[info exists testLine]} {
+	    puts [outputChannel] "$testFile:$testLine: error: test failed:\
+		    $name [string trim $description]"
+	}
+    }
+    puts [outputChannel] "==== $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): $errorCodeRes(setup)"
+	}
+    }
+    if {$processTest && $scriptFailure} {
+	if {$scriptCompare} {
+	    puts [outputChannel] "---- Error testing result: $scriptMatch"
+	} else {
+	    if {[catch {
+		puts [outputChannel] "---- Result was:\n[Asciify $actualAnswer]"
+	    } errMsg]} {
+		puts [outputChannel] "\n---- Result was:\n<error printing result: $errMsg>"
+	    }
+	    puts [outputChannel] "---- Result should have been\
+		    ($match matching):\n[Asciify $result]"
+	}
+    }
+    if {$errorCodeFailure} {
+	puts [outputChannel] "---- Error code was: '$errorCodeRes(body)'"
+	puts [outputChannel] "---- Error code should have been: '$errorCode'"
+    }
+    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)] && (1 ni $returnCodes)} {
+		puts [outputChannel] "---- errorInfo: $errorInfo(body)"
+		puts [outputChannel] "---- errorCode: $errorCodeRes(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): $errorCodeRes(cleanup)"
+	}
+    }
+    if {$coreFailure} {
+	puts [outputChannel] "---- Core file produced while running\
+		test!  $coreMsg"
+    }
+    puts [outputChannel] "==== $name FAILED\n"
+
+    incr testLevel -1
+    return
+}
+
+# Skip --
+#
+# Skips a running test and add a reason to skipped "constraints". Can be used
+# to conditional intended abort of the test.
+#
+# Side Effects:  Maintains tally of total tests seen and tests skipped.
+#
+proc tcltest::Skip {reason} {
+    return -code error -errorcode BYPASS-SKIPPED-TEST $reason
+}
+
+proc tcltest::_noticeSkipped {name reason} {
+    variable testLevel
+    variable numTests
+
+    if {[IsVerbose skip]} {
+	puts [outputChannel] "++++ $name SKIPPED: $reason"
+    }
+
+    if {$testLevel == 1} {
+	incr numTests(Skipped)
+	AddToSkippedBecause $reason
+    }
+}
+
+
+# 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 {$constraints eq {}} {
+	# 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
+        set constraints [string trim $constraints]
+	if {[string match {*[$\[]*} $constraints] != 0} {
+	    # full expression, e.g. {$foo > [info tclversion]}
+	    catch {set doTest [uplevel #0 [list 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 [list 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} {
+	    _noticeSkipped $name $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
+    }
+
+    # run the test script (or a hook if it presents):
+    if {[set cmd [namespace which -command [namespace current]::EvalTest]] ne ""} {
+	set script [list $cmd $script]
+    }
+    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]]
+
+    # Hook to handle reporting to a parent interpreter
+    if {[llength [info commands [namespace current]::ReportToParent]]} {
+	ReportToParent $numTests(Total) $numTests(Passed) $numTests(Skipped) \
+	    $numTests(Failed) [array get skippedBecause] \
+	    [array get createdNewFiles]
+	set testSingleFile false
+    }
+
+    # 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 preexisting, 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 {$file ni $filesExisted} {
+		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 {[info exists ::tk_version] && ![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 && ($testFileName ni $failFiles)} {
+	    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)
+	    }
+	}
+	foreach index [array names originalEnv] {
+	    if {![info exists ::env($index)]} {
+		lappend removedEnv $index
+		set ::env($index) $originalEnv($index)
+	    } elseif {$::env($index) ne $originalEnv($index)} {
+		lappend changedEnv $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 {$msg ne {}} {
+		    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 {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 -types {b c f p s} \
+		    -nocomplain -- $match]]
+	}
+
+	# List files in $directory that match patterns to skip.
+	set skipFileList [list]
+	foreach skip [skipFiles] {
+	    set skipFileList [concat $skipFileList \
+		    [glob -directory $directory -types {b c f p s} \
+		    -nocomplain -- $skip]]
+	}
+
+	# Add to result list all files in match list and not in skip list
+	foreach file $matchFileList {
+	    if {$file ni $skipFileList} {
+		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] {
+	set skipDirs [concat $skipDirs [glob -directory $rootdir -types d \
+		-nocomplain -- $pattern]]
+    }
+
+    # 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 -types d -nocomplain -- \
+		$pattern] {
+	    if {$path ni $skipDirs} {
+		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 [lsort $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:
+#	Whether there were any failures.
+#
+# Side effects:
+#	None.
+
+proc tcltest::runAllTests { {shell ""} } {
+    variable testSingleFile
+    variable numTestFiles
+    variable numTests
+    variable failFiles
+    variable DefaultValue
+    variable fullutf
+
+    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]
+	    && ([lindex $result 0] ne "native")} {
+	# 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]} {
+	    if {[catch {
+		incr numTestFiles
+		uplevel 1 [list ::source $file]
+	    } msg]} {
+		puts [outputChannel] "Test file error: $msg"
+		# append the name of the test to a list to be reported
+		# later
+		lappend testFileFailures $file
+	    }
+	    if {$numTests(Failed) > 0} {
+		set failFilesSet 1
+	    }
+	} 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 {$opt eq "-outfile"} {continue}
+		set value [Configure $opt]
+		# Don't bother passing default configuration options
+		if {$value eq $DefaultValue($opt)} {
+			continue
+		}
+		lappend childargv $opt $value
+	    }
+	    set cmd [linsert $childargv 0 | $shell $file]
+	    if {[catch {
+		incr numTestFiles
+		set pipeFd [open $cmd "r"]
+		if {$fullutf} {
+		    fconfigure $pipeFd -profile tcl8 -encoding utf-8
+		}
+		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
+			    set failFilesSet 1
+			}
+		    } 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 [expr {[info exists testFileFailures] || [info exists failFilesSet]}]
+}
+
+#####################################################################
+
+# 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 {} {
+    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 {($p ni [lindex $saveState 0]) && ("[namespace current]::$p" ne
+		[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 {$p ni [lindex $saveState 1]} {
+	    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 <name>, and write <contents> 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
+    variable fullutf
+
+    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 {$fullutf} {
+	fconfigure $fd -profile tcl8 -encoding utf-8
+    }
+    if {[string index $contents end] eq "\n"} {
+	puts -nonewline $fd $contents
+    } else {
+	puts $fd $contents
+    }
+    close $fd
+
+    if {$fullName ni $filesMade} {
+	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]
+    if {$idx < 0} {
+	DebugDo 1 {
+	    Warn "removeFile removing \"$fullName\":\n  not created by makeFile"
+	}
+    } else {
+	set filesMade [lreplace $filesMade $idx $idx]
+    }
+    if {![file isfile $fullName]} {
+	DebugDo 1 {
+	    Warn "removeFile removing \"$fullName\":\n  not a file"
+	}
+    }
+    if {[catch {file delete -- $fullName} msg ]} {
+	DebugDo 1 {
+	    Warn "removeFile removing \"$fullName\":\n  failed: $msg"
+	}
+    }
+    return
+}
+
+# tcltest::makeDirectory --
+#
+# Create a new dir with the name <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 {$fullName ni $filesMade} {
+	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 < 0} {
+	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 ""}} {
+    variable fullutf
+
+    FillFilesExisted
+    if {[llength [info level 0]] == 2} {
+	set directory [temporaryDirectory]
+    }
+    set fullName [file join $directory $name]
+    set f [open $fullName]
+    if {$fullutf} {
+	fconfigure $f -profile tcl8 -encoding utf-8
+    }
+    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.
+#
+# This function doesn't work any more in Tcl 8.7, since the 'identity'
+# is gone (TIP #345)
+#
+# Arguments:
+#	string being converted
+#
+# Results:
+#	result fom encoding
+#
+# Side effects:
+#	None
+
+if {!$::tcltest::fullutf} {
+    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 {$p ni $old} {
+	    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] ne {}} {
+
+	# 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] ne {}} {
+
+	# 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 constraint 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 add variable testConstraints read [namespace code SafeFetch]
+
+    # Only initialize constraints at package load time if an
+    # [initConstraintsHook] has been predefined.  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 {[namespace current] eq
+	    [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 $options] % 2} {
+	    Warn "invalid TCLTEST_OPTIONS: \"$options\":\n  should be\
+		    -option value ?-option value ...?"
+	    return
+	}
+	if {[catch {Configure {*}$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] && ("-help" in $::argv)} {
+	    # 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 {[namespace current] eq
+		    [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
+}
diff --git a/mplug_owl2/lib/tcl8/8.6/http-2.9.8.tm b/mplug_owl2/lib/tcl8/8.6/http-2.9.8.tm
new file mode 100644
index 0000000000000000000000000000000000000000..fb256a380a6352591d8eda1410d674161361caa5
--- /dev/null
+++ b/mplug_owl2/lib/tcl8/8.6/http-2.9.8.tm
@@ -0,0 +1,3604 @@
+# 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.
+
+package require Tcl 8.6-
+# Keep this in sync with pkgIndex.tcl and with the install directories in
+# Makefiles
+package provide http 2.9.8
+
+namespace eval http {
+    # Allow resourcing to not clobber existing data
+
+    variable http
+    if {![info exists http]} {
+	array set http {
+	    -accept */*
+	    -pipeline 1
+	    -postfresh 0
+	    -proxyhost {}
+	    -proxyport {}
+	    -proxyfilter http::ProxyRequired
+	    -repost 0
+	    -urlencoding utf-8
+	    -zip 1
+	}
+	# We need a useragent string of this style or various servers will
+	# refuse to send us compressed content even when we ask for it. This
+	# follows the de-facto layout of user-agent strings in current browsers.
+	# Safe interpreters do not have ::tcl_platform(os) or
+	# ::tcl_platform(osVersion).
+	if {[interp issafe]} {
+	    set http(-useragent) "Mozilla/5.0\
+		(Windows; U;\
+		Windows NT 10.0)\
+		http/[package provide http] Tcl/[package provide Tcl]"
+	} else {
+	    set http(-useragent) "Mozilla/5.0\
+		([string totitle $::tcl_platform(platform)]; U;\
+		$::tcl_platform(os) $::tcl_platform(osVersion))\
+		http/[package provide http] Tcl/[package provide Tcl]"
+	}
+    }
+
+    proc init {} {
+	# Set up the map for quoting chars. RFC3986 Section 2.3 say percent
+	# encode all except: "... percent-encoded octets in the ranges of
+	# ALPHA (%41-%5A and %61-%7A), DIGIT (%30-%39), hyphen (%2D), period
+	# (%2E), underscore (%5F), or tilde (%7E) should not be created by URI
+	# producers ..."
+	for {set i 0} {$i <= 256} {incr i} {
+	    set c [format %c $i]
+	    if {![string match {[-._~a-zA-Z0-9]} $c]} {
+		set map($c) %[format %.2X $i]
+	    }
+	}
+	# These are handled specially
+	set map(\n) %0D%0A
+	variable formMap [array get map]
+
+	# Create a map for HTTP/1.1 open sockets
+	variable socketMapping
+	variable socketRdState
+	variable socketWrState
+	variable socketRdQueue
+	variable socketWrQueue
+	variable socketClosing
+	variable socketPlayCmd
+	if {[info exists socketMapping]} {
+	    # Close open sockets on re-init.  Do not permit retries.
+	    foreach {url sock} [array get socketMapping] {
+		unset -nocomplain socketClosing($url)
+		unset -nocomplain socketPlayCmd($url)
+		CloseSocket $sock
+	    }
+	}
+
+	# CloseSocket should have unset the socket* arrays, one element at
+	# a time.  Now unset anything that was overlooked.
+	# Traces on "unset socketRdState(*)" will call CancelReadPipeline and
+	# cancel any queued responses.
+	# Traces on "unset socketWrState(*)" will call CancelWritePipeline and
+	# cancel any queued requests.
+	array unset socketMapping
+	array unset socketRdState
+	array unset socketWrState
+	array unset socketRdQueue
+	array unset socketWrQueue
+	array unset socketClosing
+	array unset socketPlayCmd
+	array set socketMapping {}
+	array set socketRdState {}
+	array set socketWrState {}
+	array set socketRdQueue {}
+	array set socketWrQueue {}
+	array set socketClosing {}
+	array set socketPlayCmd {}
+    }
+    init
+
+    variable urlTypes
+    if {![info exists urlTypes]} {
+	set urlTypes(http) [list 80 ::socket]
+    }
+
+    variable encodings [string tolower [encoding names]]
+    # This can be changed, but iso8859-1 is the RFC standard.
+    variable defaultCharset
+    if {![info exists defaultCharset]} {
+	set defaultCharset "iso8859-1"
+    }
+
+    # Force RFC 3986 strictness in geturl url verification?
+    variable strict
+    if {![info exists strict]} {
+	set strict 1
+    }
+
+    # Let user control default keepalive for compatibility
+    variable defaultKeepalive
+    if {![info exists defaultKeepalive]} {
+	set defaultKeepalive 0
+    }
+
+    namespace export geturl config reset wait formatQuery quoteString
+    namespace export register unregister registerError
+    # - Useful, but not exported: data, size, status, code, cleanup, error,
+    #   meta, ncode, mapReply, init.  Comments suggest that "init" can be used
+    #   for re-initialisation, although the command is undocumented.
+    # - Not exported, probably should be upper-case initial letter as part
+    #   of the internals: getTextLine, make-transformation-chunked.
+}
+
+# http::Log --
+#
+#	Debugging output -- define this to observe HTTP/1.1 socket usage.
+#	Should echo any args received.
+#
+# Arguments:
+#     msg	Message to output
+#
+if {[info command http::Log] eq {}} {proc http::Log {args} {}}
+
+# http::register --
+#
+#     See documentation 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([string tolower $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
+    set lower [string tolower $proto]
+    if {![info exists urlTypes($lower)]} {
+	return -code error "unsupported url type \"$proto\""
+    }
+    set old $urlTypes($lower)
+    unset urlTypes($lower)
+    return $old
+}
+
+# http::config --
+#
+#	See documentation 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 -code error "Unknown option $flag, must be: $usage"
+	}
+	return $http($flag)
+    } else {
+	foreach {flag value} $args {
+	    if {![regexp -- $pat $flag]} {
+		return -code error "Unknown option $flag, must be: $usage"
+	    }
+	    set http($flag) $value
+	}
+    }
+}
+
+# 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:
+#        May close the socket.
+
+proc http::Finish {token {errormsg ""} {skipCB 0}} {
+    variable socketMapping
+    variable socketRdState
+    variable socketWrState
+    variable socketRdQueue
+    variable socketWrQueue
+    variable socketClosing
+    variable socketPlayCmd
+
+    variable $token
+    upvar 0 $token state
+    global errorInfo errorCode
+    set closeQueue 0
+    if {$errormsg ne ""} {
+	set state(error) [list $errormsg $errorInfo $errorCode]
+	set state(status) "error"
+    }
+    if {[info commands ${token}EventCoroutine] ne {}} {
+	rename ${token}EventCoroutine {}
+    }
+
+    # Is this an upgrade request/response?
+    set upgradeResponse \
+	[expr {    [info exists state(upgradeRequest)] && $state(upgradeRequest)
+		&& [info exists state(http)] && [ncode $token] eq {101}
+		&& [info exists state(connection)] && "upgrade" in $state(connection)
+		&& [info exists state(upgrade)] && "" ne $state(upgrade)}]
+
+    if {  ($state(status) eq "timeout")
+       || ($state(status) eq "error")
+       || ($state(status) eq "eof")
+    } {
+	set closeQueue 1
+	set connId $state(socketinfo)
+	set sock $state(sock)
+	CloseSocket $state(sock) $token
+    } elseif {$upgradeResponse} {
+	# Special handling for an upgrade request/response.
+	# - geturl ensures that this is not a "persistent" socket used for
+	#   multiple HTTP requests, so a call to KeepSocket is not needed.
+	# - Leave socket open, so a call to CloseSocket is not needed either.
+	# - Remove fileevent bindings.  The caller will set its own bindings.
+	# - THE CALLER MUST PROCESS THE UPGRADED SOCKET IN THE CALLBACK COMMAND
+	#   PASSED TO http::geturl AS -command callback.
+	catch {fileevent $state(sock) readable {}}
+	catch {fileevent $state(sock) writable {}}
+    } elseif {
+          ([info exists state(-keepalive)] && !$state(-keepalive))
+       || ([info exists state(connection)] && ("close" in $state(connection)))
+    } {
+	set closeQueue 1
+	set connId $state(socketinfo)
+	set sock $state(sock)
+	CloseSocket $state(sock) $token
+    } elseif {
+	  ([info exists state(-keepalive)] && $state(-keepalive))
+       && ([info exists state(connection)] && ("close" ni $state(connection)))
+    } {
+	KeepSocket $token
+    }
+    if {[info exists state(after)]} {
+	after cancel $state(after)
+	unset state(after)
+    }
+    if {[info exists state(-command)] && (!$skipCB)
+	    && (![info exists state(done-command-cb)])} {
+	set state(done-command-cb) yes
+	if {[catch {eval $state(-command) {$token}} err] && $errormsg eq ""} {
+	    set state(error) [list $err $errorInfo $errorCode]
+	    set state(status) error
+	}
+    }
+
+    if {    $closeQueue
+	 && [info exists socketMapping($connId)]
+	 && ($socketMapping($connId) eq $sock)
+    } {
+	http::CloseQueuedQueries $connId $token
+    }
+}
+
+# http::KeepSocket -
+#
+#	Keep a socket in the persistent sockets table and connect it to its next
+#	queued task if possible.  Otherwise leave it idle and ready for its next
+#	use.
+#
+#	If $socketClosing(*), then ("close" in $state(connection)) and therefore
+#	this command will not be called by Finish.
+#
+# Arguments:
+#	token	    Connection token.
+
+proc http::KeepSocket {token} {
+    variable http
+    variable socketMapping
+    variable socketRdState
+    variable socketWrState
+    variable socketRdQueue
+    variable socketWrQueue
+    variable socketClosing
+    variable socketPlayCmd
+
+    variable $token
+    upvar 0 $token state
+    set tk [namespace tail $token]
+
+    # Keep this socket open for another request ("Keep-Alive").
+    # React if the server half-closes the socket.
+    # Discussion is in http::geturl.
+    catch {fileevent $state(sock) readable [list http::CheckEof $state(sock)]}
+
+    # The line below should not be changed in production code.
+    # It is edited by the test suite.
+    set TEST_EOF 0
+    if {$TEST_EOF} {
+	# ONLY for testing reaction to server eof.
+	# No server timeouts will be caught.
+	catch {fileevent $state(sock) readable {}}
+    }
+
+    if {    [info exists state(socketinfo)]
+	 && [info exists socketMapping($state(socketinfo))]
+    } {
+	set connId $state(socketinfo)
+	# The value "Rready" is set only here.
+	set socketRdState($connId) Rready
+
+	if {    $state(-pipeline)
+	     && [info exists socketRdQueue($connId)]
+	     && [llength $socketRdQueue($connId)]
+	} {
+	    # The usual case for pipelined responses - if another response is
+	    # queued, arrange to read it.
+	    set token3 [lindex $socketRdQueue($connId) 0]
+	    set socketRdQueue($connId) [lrange $socketRdQueue($connId) 1 end]
+	    variable $token3
+	    upvar 0 $token3 state3
+	    set tk2 [namespace tail $token3]
+
+	    #Log pipelined, GRANT read access to $token3 in KeepSocket
+	    set socketRdState($connId) $token3
+	    ReceiveResponse $token3
+
+	    # Other pipelined cases.
+	    # - The test above ensures that, for the pipelined cases in the two
+	    #   tests below, the read queue is empty.
+	    # - In those two tests, check whether the next write will be
+	    #   nonpipeline.
+	} elseif {
+		$state(-pipeline)
+	     && [info exists socketWrState($connId)]
+	     && ($socketWrState($connId) eq "peNding")
+
+	     && [info exists socketWrQueue($connId)]
+	     && [llength $socketWrQueue($connId)]
+	     && (![set token3 [lindex $socketWrQueue($connId) 0]
+		   set ${token3}(-pipeline)
+		  ]
+		)
+	} {
+	    # This case:
+	    # - Now it the time to run the "pending" request.
+	    # - The next token in the write queue is nonpipeline, and
+	    #   socketWrState has been marked "pending" (in
+	    #   http::NextPipelinedWrite or http::geturl) so a new pipelined
+	    #   request cannot jump the queue.
+	    #
+	    # Tests:
+	    # - In this case the read queue (tested above) is empty and this
+	    #   "pending" write token is in front of the rest of the write
+	    #   queue.
+	    # - The write state is not Wready and therefore appears to be busy,
+	    #   but because it is "pending" we know that it is reserved for the
+	    #   first item in the write queue, a non-pipelined request that is
+	    #   waiting for the read queue to empty.  That has now happened: so
+	    #   give that request read and write access.
+	    variable $token3
+	    set conn [set ${token3}(tmpConnArgs)]
+	    #Log nonpipeline, GRANT r/w access to $token3 in KeepSocket
+	    set socketRdState($connId) $token3
+	    set socketWrState($connId) $token3
+	    set socketWrQueue($connId) [lrange $socketWrQueue($connId) 1 end]
+	    # Connect does its own fconfigure.
+	    fileevent $state(sock) writable [list http::Connect $token3 {*}$conn]
+	    #Log ---- $state(sock) << conn to $token3 for HTTP request (c)
+
+	} elseif {
+		$state(-pipeline)
+	     && [info exists socketWrState($connId)]
+	     && ($socketWrState($connId) eq "peNding")
+
+	} {
+	    # Should not come here.  The second block in the previous "elseif"
+	    # test should be tautologous (but was needed in an earlier
+	    # implementation) and will be removed after testing.
+	    # If we get here, the value "pending" was assigned in error.
+	    # This error would block the queue for ever.
+	    Log ^X$tk <<<<< Error in queueing of requests >>>>> - token $token
+
+	} elseif {
+		$state(-pipeline)
+	     && [info exists socketWrState($connId)]
+	     && ($socketWrState($connId) eq "Wready")
+
+	     && [info exists socketWrQueue($connId)]
+	     && [llength $socketWrQueue($connId)]
+	     && (![set token3 [lindex $socketWrQueue($connId) 0]
+		   set ${token3}(-pipeline)
+		  ]
+		)
+	} {
+	    # This case:
+	    # - The next token in the write queue is nonpipeline, and
+	    #   socketWrState is Wready.  Get the next event from socketWrQueue.
+	    # Tests:
+	    # - In this case the read state (tested above) is Rready and the
+	    #   write state (tested here) is Wready - there is no "pending"
+	    #   request.
+	    # Code:
+	    # - The code is the same as the code below for the nonpipelined
+	    #   case with a queued request.
+	    variable $token3
+	    set conn [set ${token3}(tmpConnArgs)]
+	    #Log nonpipeline, GRANT r/w access to $token3 in KeepSocket
+	    set socketRdState($connId) $token3
+	    set socketWrState($connId) $token3
+	    set socketWrQueue($connId) [lrange $socketWrQueue($connId) 1 end]
+	    # Connect does its own fconfigure.
+	    fileevent $state(sock) writable [list http::Connect $token3 {*}$conn]
+	    #Log ---- $state(sock) << conn to $token3 for HTTP request (c)
+
+	} elseif {
+		(!$state(-pipeline))
+	     && [info exists socketWrQueue($connId)]
+	     && [llength $socketWrQueue($connId)]
+	     && ("close" ni $state(connection))
+	} {
+	    # If not pipelined, (socketRdState eq Rready) tells us that we are
+	    # ready for the next write - there is no need to check
+	    # socketWrState. Write the next request, if one is waiting.
+	    # If the next request is pipelined, it receives premature read
+	    # access to the socket. This is not a problem.
+	    set token3 [lindex $socketWrQueue($connId) 0]
+	    variable $token3
+	    set conn [set ${token3}(tmpConnArgs)]
+	    #Log nonpipeline, GRANT r/w access to $token3 in KeepSocket
+	    set socketRdState($connId) $token3
+	    set socketWrState($connId) $token3
+	    set socketWrQueue($connId) [lrange $socketWrQueue($connId) 1 end]
+	    # Connect does its own fconfigure.
+	    fileevent $state(sock) writable [list http::Connect $token3 {*}$conn]
+	    #Log ---- $state(sock) << conn to $token3 for HTTP request (d)
+
+	} elseif {(!$state(-pipeline))} {
+	    set socketWrState($connId) Wready
+	    # Rready and Wready and idle: nothing to do.
+	}
+
+    } else {
+	CloseSocket $state(sock) $token
+	# There is no socketMapping($state(socketinfo)), so it does not matter
+	# that CloseQueuedQueries is not called.
+    }
+}
+
+# http::CheckEof -
+#
+#	Read from a socket and close it if eof.
+#	The command is bound to "fileevent readable" on an idle socket, and
+#	"eof" is the only event that should trigger the binding, occurring when
+#	the server times out and half-closes the socket.
+#
+#	A read is necessary so that [eof] gives a meaningful result.
+#	Any bytes sent are junk (or a bug).
+
+proc http::CheckEof {sock} {
+    set junk [read $sock]
+    set n [string length $junk]
+    if {$n} {
+	Log "WARNING: $n bytes received but no HTTP request sent"
+    }
+
+    if {[catch {eof $sock} res] || $res} {
+	# The server has half-closed the socket.
+	# If a new write has started, its transaction will fail and
+	# will then be error-handled.
+	CloseSocket $sock
+    }
+}
+
+# http::CloseSocket -
+#
+#	Close a socket and remove it from the persistent sockets table.  If
+#	possible an http token is included here but when we are called from a
+#	fileevent on remote closure we need to find the correct entry - hence
+#	the "else" block of the first "if" command.
+
+proc http::CloseSocket {s {token {}}} {
+    variable socketMapping
+    variable socketRdState
+    variable socketWrState
+    variable socketRdQueue
+    variable socketWrQueue
+    variable socketClosing
+    variable socketPlayCmd
+
+    set tk [namespace tail $token]
+
+    catch {fileevent $s readable {}}
+    set connId {}
+    if {$token ne ""} {
+	variable $token
+	upvar 0 $token state
+	if {[info exists state(socketinfo)]} {
+	    set connId $state(socketinfo)
+	}
+    } else {
+	set map [array get socketMapping]
+	set ndx [lsearch -exact $map $s]
+	if {$ndx >= 0} {
+	    incr ndx -1
+	    set connId [lindex $map $ndx]
+	}
+    }
+    if {    ($connId ne {})
+	 && [info exists socketMapping($connId)]
+	 && ($socketMapping($connId) eq $s)
+    } {
+	Log "Closing connection $connId (sock $socketMapping($connId))"
+	if {[catch {close $socketMapping($connId)} err]} {
+	    Log "Error closing connection: $err"
+	}
+	if {$token eq {}} {
+	    # Cases with a non-empty token are handled by Finish, so the tokens
+	    # are finished in connection order.
+	    http::CloseQueuedQueries $connId
+	}
+    } else {
+	Log "Closing socket $s (no connection info)"
+	if {[catch {close $s} err]} {
+	    Log "Error closing socket: $err"
+	}
+    }
+}
+
+# http::CloseQueuedQueries
+#
+#	connId  - identifier "domain:port" for the connection
+#	token   - (optional) used only for logging
+#
+# Called from http::CloseSocket and http::Finish, after a connection is closed,
+# to clear the read and write queues if this has not already been done.
+
+proc http::CloseQueuedQueries {connId {token {}}} {
+    variable socketMapping
+    variable socketRdState
+    variable socketWrState
+    variable socketRdQueue
+    variable socketWrQueue
+    variable socketClosing
+    variable socketPlayCmd
+
+    if {![info exists socketMapping($connId)]} {
+	# Command has already been called.
+	# Don't come here again - especially recursively.
+	return
+    }
+
+    # Used only for logging.
+    if {$token eq {}} {
+	set tk {}
+    } else {
+	set tk [namespace tail $token]
+    }
+
+    if {    [info exists socketPlayCmd($connId)]
+	 && ($socketPlayCmd($connId) ne {ReplayIfClose Wready {} {}})
+    } {
+	# Before unsetting, there is some unfinished business.
+	# - If the server sent "Connection: close", we have stored the command
+	#   for retrying any queued requests in socketPlayCmd, so copy that
+	#   value for execution below.  socketClosing(*) was also set.
+	# - Also clear the queues to prevent calls to Finish that would set the
+	#   state for the requests that will be retried to "finished with error
+	#   status".
+	set unfinished $socketPlayCmd($connId)
+	set socketRdQueue($connId) {}
+	set socketWrQueue($connId) {}
+    } else {
+	set unfinished {}
+    }
+
+    Unset $connId
+
+    if {$unfinished ne {}} {
+	Log ^R$tk Any unfinished transactions (excluding $token) failed \
+		- token $token
+	{*}$unfinished
+    }
+}
+
+# http::Unset
+#
+#	The trace on "unset socketRdState(*)" will call CancelReadPipeline
+#	and cancel any queued responses.
+#	The trace on "unset socketWrState(*)" will call CancelWritePipeline
+#	and cancel any queued requests.
+
+proc http::Unset {connId} {
+    variable socketMapping
+    variable socketRdState
+    variable socketWrState
+    variable socketRdQueue
+    variable socketWrQueue
+    variable socketClosing
+    variable socketPlayCmd
+
+    unset socketMapping($connId)
+    unset socketRdState($connId)
+    unset socketWrState($connId)
+    unset -nocomplain socketRdQueue($connId)
+    unset -nocomplain socketWrQueue($connId)
+    unset -nocomplain socketClosing($connId)
+    unset -nocomplain socketPlayCmd($connId)
+}
+
+# http::reset --
+#
+#	See documentation 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
+    variable defaultKeepalive
+    variable strict
+
+    # 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)]
+    ##Log Starting http::geturl - token $token
+    variable $token
+    upvar 0 $token state
+    set tk [namespace tail $token]
+    reset $token
+    Log ^A$tk URL $url - token $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	{}
+	-protocol	1.1
+	binary		0
+	state		created
+	meta		{}
+	method		{}
+	coding		{}
+	currentsize	0
+	totalsize	0
+	querylength	0
+	queryoffset	0
+	type		text/html
+	body		{}
+	status		""
+	http		""
+	connection	keep-alive
+    }
+    set state(-keepalive) $defaultKeepalive
+    set state(-strict) $strict
+    # These flags have their types verified [Bug 811170]
+    array set type {
+	-binary		boolean
+	-blocksize	integer
+	-queryblocksize integer
+	-strict		boolean
+	-timeout	integer
+	-validate	boolean
+	-headers	list
+    }
+    set state(charset)	$defaultCharset
+    set options {
+	-binary -blocksize -channel -command -handler -headers -keepalive
+	-method -myaddr -progress -protocol -query -queryblocksize
+	-querychannel -queryprogress -strict -timeout -type -validate
+    }
+    set usage [join [lsort $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)"
+	    }
+	    if {($flag eq "-headers") && ([llength $value] % 2 != 0)} {
+		unset $token
+		return -code error \
+		    "Bad value for $flag ($value), number of list elements must be even"
+	    }
+	    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.
+
+    # URLs have basically four parts.
+    # First, before the colon, is the protocol scheme (e.g. http)
+    # Second, for HTTP-like protocols, is the authority
+    #	The authority is preceded by // and lasts up to (but not including)
+    #	the following / or ? and it identifies up to four parts, of which
+    #	only one, the host, is required (if an authority is present at all).
+    #	All other parts of the authority (user name, password, port number)
+    #	are optional.
+    # Third is the resource name, which is split into two parts at a ?
+    #	The first part (from the single "/" up to "?") is the path, and the
+    #	second part (from that "?" up to "#") is the query. *HOWEVER*, we do
+    #	not need to separate them; we send the whole lot to the server.
+    #	Both, path and query are allowed to be missing, including their
+    #	delimiting character.
+    # Fourth is the fragment identifier, which is everything after the first
+    #	"#" in the URL. The fragment identifier MUST NOT be sent to the server
+    #	and indeed, we don't bother to validate it (it could be an error to
+    #	pass it in here, but it's cheap to strip).
+    #
+    # An example of a URL that has all the parts:
+    #
+    #     http://jschmoe:xyzzy@www.bogus.net:8000/foo/bar.tml?q=foo#changes
+    #
+    # The "http" is the protocol, the user is "jschmoe", the password is
+    # "xyzzy", the host is "www.bogus.net", the port is "8000", the path is
+    # "/foo/bar.tml", the query is "q=foo", and the fragment is "changes".
+    #
+    # Note that the RE actually combines the user and password parts, as
+    # recommended in RFC 3986. Indeed, that RFC states that putting passwords
+    # in URLs is a Really Bad Idea, something with which I would agree utterly.
+    #
+    # From a validation perspective, we need to ensure that the parts of the
+    # URL that are going to the server are correctly encoded.  This is only
+    # done if $state(-strict) is true (inherited from $::http::strict).
+
+    set URLmatcher {(?x)		# this is _expanded_ syntax
+	^
+	(?: (\w+) : ) ?			# <protocol scheme>
+	(?: //
+	    (?:
+		(
+		    [^@/\#?]+		# <userinfo part of authority>
+		) @
+	    )?
+	    (				# <host part of authority>
+		[^/:\#?]+ |		# host name or IPv4 address
+		\[ [^/\#?]+ \]		# IPv6 address in square brackets
+	    )
+	    (?: : (\d+) )?		# <port part of authority>
+	)?
+	( [/\?] [^\#]*)?		# <path> (including query)
+	(?: \# (.*) )?			# <fragment>
+	$
+    }
+
+    # Phase one: parse
+    if {![regexp -- $URLmatcher $url -> proto user host port srvurl]} {
+	unset $token
+	return -code error "Unsupported URL: $url"
+    }
+    # Phase two: validate
+    set host [string trim $host {[]}]; # strip square brackets from IPv6 address
+    if {$host eq ""} {
+	# Caller has to provide a host name; we do not have a "default host"
+	# that would enable us to handle relative URLs.
+	unset $token
+	return -code error "Missing host part: $url"
+	# Note that we don't check the hostname for validity here; if it's
+	# invalid, we'll simply fail to resolve it later on.
+    }
+    if {$port ne "" && $port > 65535} {
+	unset $token
+	return -code error "Invalid port number: $port"
+    }
+    # The user identification and resource identification parts of the URL can
+    # have encoded characters in them; take care!
+    if {$user ne ""} {
+	# Check for validity according to RFC 3986, Appendix A
+	set validityRE {(?xi)
+	    ^
+	    (?: [-\w.~!$&'()*+,;=:] | %[0-9a-f][0-9a-f] )+
+	    $
+	}
+	if {$state(-strict) && ![regexp -- $validityRE $user]} {
+	    unset $token
+	    # Provide a better error message in this error case
+	    if {[regexp {(?i)%(?![0-9a-f][0-9a-f]).?.?} $user bad]} {
+		return -code error \
+			"Illegal encoding character usage \"$bad\" in URL user"
+	    }
+	    return -code error "Illegal characters in URL user"
+	}
+    }
+    if {$srvurl ne ""} {
+	# RFC 3986 allows empty paths (not even a /), but servers
+	# return 400 if the path in the HTTP request doesn't start
+	# with / , so add it here if needed.
+	if {[string index $srvurl 0] ne "/"} {
+	    set srvurl /$srvurl
+	}
+	# Check for validity according to RFC 3986, Appendix A
+	set validityRE {(?xi)
+	    ^
+	    # Path part (already must start with / character)
+	    (?:	      [-\w.~!$&'()*+,;=:@/]  | %[0-9a-f][0-9a-f] )*
+	    # Query part (optional, permits ? characters)
+	    (?: \? (?: [-\w.~!$&'()*+,;=:@/?] | %[0-9a-f][0-9a-f] )* )?
+	    $
+	}
+	if {$state(-strict) && ![regexp -- $validityRE $srvurl]} {
+	    unset $token
+	    # Provide a better error message in this error case
+	    if {[regexp {(?i)%(?![0-9a-f][0-9a-f])..} $srvurl bad]} {
+		return -code error \
+		    "Illegal encoding character usage \"$bad\" in URL path"
+	    }
+	    return -code error "Illegal characters in URL path"
+	}
+	if {![regexp {^[^?#]+} $srvurl state(path)]} {
+	    set state(path) /
+	}
+    } else {
+	set srvurl /
+	set state(path) /
+    }
+    if {$proto eq ""} {
+	set proto http
+    }
+    set lower [string tolower $proto]
+    if {![info exists urlTypes($lower)]} {
+	unset $token
+	return -code error "Unsupported URL type \"$proto\""
+    }
+    set defport [lindex $urlTypes($lower) 0]
+    set defcmd [lindex $urlTypes($lower) 1]
+
+    if {$port eq ""} {
+	set port $defport
+    }
+    if {![catch {$http(-proxyfilter) $host} proxy]} {
+	set phost [lindex $proxy 0]
+	set pport [lindex $proxy 1]
+    }
+
+    # OK, now reassemble into a full URL
+    set url ${proto}://
+    if {$user ne ""} {
+	append url $user
+	append url @
+    }
+    append url $host
+    if {$port != $defport} {
+	append url : $port
+    }
+    append url $srvurl
+    # Don't append the fragment!
+    set state(url) $url
+
+    set sockopts [list -async]
+
+    # If we are using the proxy, we must pass in the full URL that includes
+    # the server name.
+
+    if {[info exists phost] && ($phost ne "")} {
+	set srvurl $url
+	set targetAddr [list $phost $pport]
+    } else {
+	set targetAddr [list $host $port]
+    }
+    # Proxy connections aren't shared among different hosts.
+    set state(socketinfo) $host:$port
+
+    # Save the accept types at this point to prevent a race condition. [Bug
+    # c11a51c482]
+    set state(accept-types) $http(-accept)
+
+    # Check whether this is an Upgrade request.
+    set connectionValues [SplitCommaSeparatedFieldValue \
+			      [GetFieldValue $state(-headers) Connection]]
+    set connectionValues [string tolower $connectionValues]
+    set upgradeValues [SplitCommaSeparatedFieldValue \
+			   [GetFieldValue $state(-headers) Upgrade]]
+    set state(upgradeRequest) [expr {    "upgrade" in $connectionValues
+				      && [llength $upgradeValues] >= 1}]
+
+    if {$isQuery || $isQueryChannel} {
+	# It's a POST.
+	# A client wishing to send a non-idempotent request SHOULD wait to send
+	# that request until it has received the response status for the
+	# previous request.
+	if {$http(-postfresh)} {
+	    # Override -keepalive for a POST.  Use a new connection, and thus
+	    # avoid the small risk of a race against server timeout.
+	    set state(-keepalive) 0
+	} else {
+	    # Allow -keepalive but do not -pipeline - wait for the previous
+	    # transaction to finish.
+	    # There is a small risk of a race against server timeout.
+	    set state(-pipeline) 0
+	}
+    } elseif {$state(upgradeRequest)} {
+	# It's an upgrade request.  Method must be GET (untested).
+	# Force -keepalive to 0 so the connection is not made over a persistent
+	# socket, i.e. one used for multiple HTTP requests.
+	set state(-keepalive) 0
+    } else {
+	# It's a non-upgrade GET or HEAD.
+	set state(-pipeline) $http(-pipeline)
+    }
+
+    # We cannot handle chunked encodings with -handler, so force HTTP/1.0
+    # until we can manage this.
+    if {[info exists state(-handler)]} {
+	set state(-protocol) 1.0
+    }
+
+    # RFC 7320 A.1 - HTTP/1.0 Keep-Alive is problematic. We do not support it.
+    if {$state(-protocol) eq "1.0"} {
+	set state(connection) close
+	set state(-keepalive) 0
+    }
+
+    # See if we are supposed to use a previously opened channel.
+    # - In principle, ANY call to http::geturl could use a previously opened
+    #   channel if it is available - the "Connection: keep-alive" header is a
+    #   request to leave the channel open AFTER completion of this call.
+    # - In fact, we try to use an existing channel only if -keepalive 1 -- this
+    #   means that at most one channel is left open for each value of
+    #   $state(socketinfo). This property simplifies the mapping of open
+    #   channels.
+    set reusing 0
+    set alreadyQueued 0
+    if {$state(-keepalive)} {
+	variable socketMapping
+	variable socketRdState
+	variable socketWrState
+	variable socketRdQueue
+	variable socketWrQueue
+	variable socketClosing
+	variable socketPlayCmd
+
+	if {[info exists socketMapping($state(socketinfo))]} {
+	    # - If the connection is idle, it has a "fileevent readable" binding
+	    #   to http::CheckEof, in case the server times out and half-closes
+	    #   the socket (http::CheckEof closes the other half).
+	    # - We leave this binding in place until just before the last
+	    #   puts+flush in http::Connected (GET/HEAD) or http::Write (POST),
+	    #   after which the HTTP response might be generated.
+
+	    if {    [info exists socketClosing($state(socketinfo))]
+		       && $socketClosing($state(socketinfo))
+	    } {
+		# socketClosing(*) is set because the server has sent a
+		# "Connection: close" header.
+		# Do not use the persistent socket again.
+		# Since we have only one persistent socket per server, and the
+		# old socket is not yet dead, add the request to the write queue
+		# of the dying socket, which will be replayed by ReplayIfClose.
+		# Also add it to socketWrQueue(*) which is used only if an error
+		# causes a call to Finish.
+		set reusing 1
+		set sock $socketMapping($state(socketinfo))
+		Log "reusing socket $sock for $state(socketinfo) - token $token"
+
+		set alreadyQueued 1
+		lassign $socketPlayCmd($state(socketinfo)) com0 com1 com2 com3
+		lappend com3 $token
+		set socketPlayCmd($state(socketinfo)) [list $com0 $com1 $com2 $com3]
+		lappend socketWrQueue($state(socketinfo)) $token
+	    } elseif {[catch {fconfigure $socketMapping($state(socketinfo))}]} {
+		# FIXME Is it still possible for this code to be executed? If
+		#       so, this could be another place to call TestForReplay,
+		#       rather than discarding the queued transactions.
+		Log "WARNING: socket for $state(socketinfo) was closed\
+			- token $token"
+		Log "WARNING - if testing, pay special attention to this\
+			case (GH) which is seldom executed - token $token"
+
+		# This will call CancelReadPipeline, CancelWritePipeline, and
+		# cancel any queued requests, responses.
+		Unset $state(socketinfo)
+	    } else {
+		# Use the persistent socket.
+		# The socket may not be ready to write: an earlier request might
+		# still be still writing (in the pipelined case) or
+		# writing/reading (in the nonpipeline case). This possibility
+		# is handled by socketWrQueue later in this command.
+		set reusing 1
+		set sock $socketMapping($state(socketinfo))
+		Log "reusing socket $sock for $state(socketinfo) - token $token"
+
+	    }
+	    # Do not automatically close the connection socket.
+	    set state(connection) keep-alive
+	}
+    }
+
+    if {$reusing} {
+	# Define state(tmpState) and state(tmpOpenCmd) for use
+	# by http::ReplayIfDead if the persistent connection has died.
+	set state(tmpState) [array get state]
+
+	# Pass -myaddr directly to the socket command
+	if {[info exists state(-myaddr)]} {
+	    lappend sockopts -myaddr $state(-myaddr)
+	}
+
+	set state(tmpOpenCmd) [list {*}$defcmd {*}$sockopts {*}$targetAddr]
+    }
+
+    set state(reusing) $reusing
+    # Excluding ReplayIfDead and the decision whether to call it, there are four
+    # places outside http::geturl where state(reusing) is used:
+    # - Connected   - if reusing and not pipelined, start the state(-timeout)
+    #                 timeout (when writing).
+    # - DoneRequest - if reusing and pipelined, send the next pipelined write
+    # - Event       - if reusing and pipelined, start the state(-timeout)
+    #                 timeout (when reading).
+    # - Event       - if (not reusing) and pipelined, send the next pipelined
+    #                 write
+
+    # See comments above re the start of this timeout in other cases.
+    if {(!$state(reusing)) && ($state(-timeout) > 0)} {
+	set state(after) [after $state(-timeout) \
+		[list http::reset $token timeout]]
+    }
+
+    if {![info exists sock]} {
+	# Pass -myaddr directly to the socket command
+	if {[info exists state(-myaddr)]} {
+	    lappend sockopts -myaddr $state(-myaddr)
+	}
+	set pre [clock milliseconds]
+	##Log pre socket opened, - token $token
+	##Log [concat $defcmd $sockopts $targetAddr] - token $token
+	if {[catch {eval $defcmd $sockopts $targetAddr} sock errdict]} {
+	    # 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 state(sock) NONE
+	    Finish $token $sock 1
+	    cleanup $token
+	    dict unset errdict -level
+	    return -options $errdict $sock
+	} else {
+	    # Initialisation of a new socket.
+	    ##Log post socket opened, - token $token
+	    ##Log socket opened, now fconfigure - token $token
+	    set delay [expr {[clock milliseconds] - $pre}]
+	    if {$delay > 3000} {
+		Log socket delay $delay - token $token
+	    }
+	    fconfigure $sock -translation {auto crlf} \
+			     -buffersize $state(-blocksize)
+	    ##Log socket opened, DONE fconfigure - token $token
+	}
+    }
+    # Command [socket] is called with -async, but takes 5s to 5.1s to return,
+    # with probability of order 1 in 10,000.  This may be a bizarre scheduling
+    # issue with my (KJN's) system (Fedora Linux).
+    # This does not cause a problem (unless the request times out when this
+    # command returns).
+
+    set state(sock) $sock
+    Log "Using $sock for $state(socketinfo) - token $token" \
+	[expr {$state(-keepalive)?"keepalive":""}]
+
+    if {    $state(-keepalive)
+	 && (![info exists socketMapping($state(socketinfo))])
+    } {
+	# Freshly-opened socket that we would like to become persistent.
+	set socketMapping($state(socketinfo)) $sock
+
+	if {![info exists socketRdState($state(socketinfo))]} {
+	    set socketRdState($state(socketinfo)) {}
+	    set varName ::http::socketRdState($state(socketinfo))
+	    trace add variable $varName unset ::http::CancelReadPipeline
+	}
+	if {![info exists socketWrState($state(socketinfo))]} {
+	    set socketWrState($state(socketinfo)) {}
+	    set varName ::http::socketWrState($state(socketinfo))
+	    trace add variable $varName unset ::http::CancelWritePipeline
+	}
+
+	if {$state(-pipeline)} {
+	    #Log new, init for pipelined, GRANT write access to $token in geturl
+	    # Also grant premature read access to the socket. This is OK.
+	    set socketRdState($state(socketinfo)) $token
+	    set socketWrState($state(socketinfo)) $token
+	} else {
+	    # socketWrState is not used by this non-pipelined transaction.
+	    # We cannot leave it as "Wready" because the next call to
+	    # http::geturl with a pipelined transaction would conclude that the
+	    # socket is available for writing.
+	    #Log new, init for nonpipeline, GRANT r/w access to $token in geturl
+	    set socketRdState($state(socketinfo)) $token
+	    set socketWrState($state(socketinfo)) $token
+	}
+
+	set socketRdQueue($state(socketinfo)) {}
+	set socketWrQueue($state(socketinfo)) {}
+	set socketClosing($state(socketinfo)) 0
+	set socketPlayCmd($state(socketinfo)) {ReplayIfClose Wready {} {}}
+    }
+
+    if {![info exists phost]} {
+	set phost ""
+    }
+    if {$reusing} {
+	# For use by http::ReplayIfDead if the persistent connection has died.
+	# Also used by NextPipelinedWrite.
+	set state(tmpConnArgs) [list $proto $phost $srvurl]
+    }
+
+    # The element socketWrState($connId) has a value which is either the name of
+    # the token that is permitted to write to the socket, or "Wready" if no
+    # token is permitted to write.
+    #
+    # The code that sets the value to Wready immediately calls
+    # http::NextPipelinedWrite, which examines socketWrQueue($connId) and
+    # processes the next request in the queue, if there is one.  The value
+    # Wready is not found when the interpreter is in the event loop unless the
+    # socket is idle.
+    #
+    # The element socketRdState($connId) has a value which is either the name of
+    # the token that is permitted to read from the socket, or "Rready" if no
+    # token is permitted to read.
+    #
+    # The code that sets the value to Rready then examines
+    # socketRdQueue($connId) and processes the next request in the queue, if
+    # there is one.  The value Rready is not found when the interpreter is in
+    # the event loop unless the socket is idle.
+
+    if {$alreadyQueued} {
+	# A write may or may not be in progress.  There is no need to set
+	# socketWrState to prevent another call stealing write access - all
+	# subsequent calls on this socket will come here because the socket
+	# will close after the current read, and its
+	# socketClosing($connId) is 1.
+	##Log "HTTP request for token $token is queued"
+
+    } elseif {    $reusing
+	       && $state(-pipeline)
+	       && ($socketWrState($state(socketinfo)) ne "Wready")
+    } {
+	##Log "HTTP request for token $token is queued for pipelined use"
+	lappend socketWrQueue($state(socketinfo)) $token
+
+    } elseif {    $reusing
+	       && (!$state(-pipeline))
+	       && ($socketWrState($state(socketinfo)) ne "Wready")
+    } {
+	# A write is queued or in progress.  Lappend to the write queue.
+	##Log "HTTP request for token $token is queued for nonpipeline use"
+	lappend socketWrQueue($state(socketinfo)) $token
+
+    } elseif {    $reusing
+	       && (!$state(-pipeline))
+	       && ($socketWrState($state(socketinfo)) eq "Wready")
+	       && ($socketRdState($state(socketinfo)) ne "Rready")
+    } {
+	# A read is queued or in progress, but not a write.  Cannot start the
+	# nonpipeline transaction, but must set socketWrState to prevent a
+	# pipelined request jumping the queue.
+	##Log "HTTP request for token $token is queued for nonpipeline use"
+	#Log re-use nonpipeline, GRANT delayed write access to $token in geturl
+
+	set socketWrState($state(socketinfo)) peNding
+	lappend socketWrQueue($state(socketinfo)) $token
+
+    } else {
+	if {$reusing && $state(-pipeline)} {
+	    #Log re-use pipelined, GRANT write access to $token in geturl
+	    set socketWrState($state(socketinfo)) $token
+
+	} elseif {$reusing} {
+	    # Cf tests above - both are ready.
+	    #Log re-use nonpipeline, GRANT r/w access to $token in geturl
+	    set socketRdState($state(socketinfo)) $token
+	    set socketWrState($state(socketinfo)) $token
+	}
+
+	# All (!$reusing) cases come here, and also some $reusing cases if the
+	# connection is ready.
+	#Log ---- $state(socketinfo) << conn to $token for HTTP request (a)
+	# Connect does its own fconfigure.
+	fileevent $sock writable \
+		[list http::Connect $token $proto $phost $srvurl]
+    }
+
+    # Wait for the connection to complete.
+    if {![info exists state(-command)]} {
+	# geturl does EVERYTHING asynchronously, so if the user
+	# calls it synchronously, we just do a wait here.
+	http::wait $token
+
+	if {![info exists state]} {
+	    # If we timed out then Finish has been called and the users
+	    # command callback may have cleaned up the token. If so we end up
+	    # here with nothing left to do.
+	    return $token
+	} elseif {$state(status) eq "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
+	}
+    }
+    ##Log Leaving http::geturl - token $token
+    return $token
+}
+
+# http::Connected --
+#
+#	Callback used when the connection to the HTTP server is actually
+#	established.
+#
+# Arguments:
+#	token	State token.
+#	proto	What protocol (http, https, etc.) was used to connect.
+#	phost	Are we using keep-alive? Non-empty if yes.
+#	srvurl	Service-local URL that we're requesting
+# Results:
+#	None.
+
+proc http::Connected {token proto phost srvurl} {
+    variable http
+    variable urlTypes
+    variable socketMapping
+    variable socketRdState
+    variable socketWrState
+    variable socketRdQueue
+    variable socketWrQueue
+    variable socketClosing
+    variable socketPlayCmd
+
+    variable $token
+    upvar 0 $token state
+    set tk [namespace tail $token]
+
+    if {$state(reusing) && (!$state(-pipeline)) && ($state(-timeout) > 0)} {
+	set state(after) [after $state(-timeout) \
+		[list http::reset $token timeout]]
+    }
+
+    # Set back the variables needed here.
+    set sock $state(sock)
+    set isQueryChannel [info exists state(-querychannel)]
+    set isQuery [info exists state(-query)]
+    regexp {^(.+):([^:]+)$} $state(socketinfo) {} host port
+
+    set lower [string tolower $proto]
+    set defport [lindex $urlTypes($lower) 0]
+
+    # Send data in cr-lf format, but accept any line terminators.
+    # Initialisation to {auto *} now done in geturl, KeepSocket and DoneRequest.
+    # We are concerned here with the request (write) not the response (read).
+    lassign [fconfigure $sock -translation] trRead trWrite
+    fconfigure $sock -translation [list $trRead 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 $sock -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 {[info exists state(-method)] && ($state(-method) ne "")} {
+	set how $state(-method)
+    }
+    set accept_types_seen 0
+
+    Log ^B$tk begin sending request - token $token
+
+    if {[catch {
+	set state(method) $how
+	puts $sock "$how $srvurl HTTP/$state(-protocol)"
+	set hostValue [GetFieldValue $state(-headers) Host]
+	if {$hostValue ne {}} {
+	    # Allow Host spoofing. [Bug 928154]
+	    regexp {^[^:]+} $hostValue state(host)
+	    puts $sock "Host: $hostValue"
+	} elseif {$port == $defport} {
+	    # Don't add port in this case, to handle broken servers. [Bug
+	    # #504508]
+	    set state(host) $host
+	    puts $sock "Host: $host"
+	} else {
+	    set state(host) $host
+	    puts $sock "Host: $host:$port"
+	}
+	puts $sock "User-Agent: $http(-useragent)"
+	if {($state(-protocol) > 1.0) && $state(-keepalive)} {
+	    # Send this header, because a 1.1 server is not compelled to treat
+	    # this as the default.
+	    puts $sock "Connection: keep-alive"
+	}
+	if {($state(-protocol) > 1.0) && !$state(-keepalive)} {
+	    puts $sock "Connection: close" ;# RFC2616 sec 8.1.2.1
+	}
+	if {($state(-protocol) < 1.1)} {
+	    # RFC7230 A.1
+	    # Some server implementations of HTTP/1.0 have a faulty
+	    # implementation of RFC 2068 Keep-Alive.
+	    # Don't leave this to chance.
+	    # For HTTP/1.0 we have already "set state(connection) close"
+	    # and "state(-keepalive) 0".
+	    puts $sock "Connection: close"
+	}
+	# RFC7230 A.1 - "clients are encouraged not to send the
+	# Proxy-Connection header field in any requests"
+	set accept_encoding_seen 0
+	set content_type_seen 0
+	foreach {key value} $state(-headers) {
+	    set value [string map [list \n "" \r ""] $value]
+	    set key [string map {" " -} [string trim $key]]
+	    if {[string equal -nocase $key "host"]} {
+		continue
+	    }
+	    if {[string equal -nocase $key "accept-encoding"]} {
+		set accept_encoding_seen 1
+	    }
+	    if {[string equal -nocase $key "accept"]} {
+		set accept_types_seen 1
+	    }
+	    if {[string equal -nocase $key "content-type"]} {
+		set content_type_seen 1
+	    }
+	    if {[string equal -nocase $key "content-length"]} {
+		set contDone 1
+		set state(querylength) $value
+	    }
+	    if {[string length $key]} {
+		puts $sock "$key: $value"
+	    }
+	}
+	# Allow overriding the Accept header on a per-connection basis. Useful
+	# for working with REST services. [Bug c11a51c482]
+	if {!$accept_types_seen} {
+	    puts $sock "Accept: $state(accept-types)"
+	}
+	if {    (!$accept_encoding_seen)
+	     && (![info exists state(-handler)])
+	     && $http(-zip)
+	} {
+	    puts $sock "Accept-Encoding: gzip,deflate,compress"
+	}
+	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 their POST data if they expect the client to read their
+	# response.
+
+	if {$isQuery || $isQueryChannel} {
+	    # POST method.
+	    if {!$content_type_seen} {
+		puts $sock "Content-Type: $state(-type)"
+	    }
+	    if {!$contDone} {
+		puts $sock "Content-Length: $state(querylength)"
+	    }
+	    puts $sock ""
+	    flush $sock
+	    # Flush flushes the error in the https case with a bad handshake:
+	    # else the socket never becomes writable again, and hangs until
+	    # timeout (if any).
+
+	    lassign [fconfigure $sock -translation] trRead trWrite
+	    fconfigure $sock -translation [list $trRead binary]
+	    fileevent $sock writable [list http::Write $token]
+	    # The http::Write command decides when to make the socket readable,
+	    # using the same test as the GET/HEAD case below.
+	} else {
+	    # GET or HEAD method.
+	    if {    (![catch {fileevent $sock readable} binding])
+		 && ($binding eq [list http::CheckEof $sock])
+	    } {
+		# Remove the "fileevent readable" binding of an idle persistent
+		# socket to http::CheckEof.  We can no longer treat bytes
+		# received as junk. The server might still time out and
+		# half-close the socket if it has not yet received the first
+		# "puts".
+		fileevent $sock readable {}
+	    }
+	    puts $sock ""
+	    flush $sock
+	    Log ^C$tk end sending request - token $token
+	    # End of writing (GET/HEAD methods).  The request has been sent.
+
+	    DoneRequest $token
+	}
+
+    } err]} {
+	# The socket probably was never connected, OR the connection dropped
+	# later, OR https handshake error, which may be discovered as late as
+	# the "flush" command above...
+	Log "WARNING - if testing, pay special attention to this\
+		case (GI) which is seldom executed - token $token"
+	if {[info exists state(reusing)] && $state(reusing)} {
+	    # The socket was closed at the server end, and closed at
+	    # this end by http::CheckEof.
+    	    if {[TestForReplay $token write $err a]} {
+		return
+	    } else {
+		Finish $token {failed to re-use socket}
+	    }
+
+	    # else:
+	    # This is NOT a persistent socket that has been closed since its
+	    # last use.
+	    # If any other requests are in flight or pipelined/queued, they will
+	    # be discarded.
+	} elseif {$state(status) eq ""} {
+	    # ...https handshake errors come here.
+	    set msg [registerError $sock]
+	    registerError $sock {}
+	    if {$msg eq {}} {
+		set msg {failed to use socket}
+	    }
+	    Finish $token $msg
+	} elseif {$state(status) ne "error"} {
+	    Finish $token $err
+	}
+    }
+}
+
+# http::registerError
+#
+#	Called (for example when processing TclTLS activity) to register
+#	an error for a connection on a specific socket.  This helps
+#	http::Connected to deliver meaningful error messages, e.g. when a TLS
+#	certificate fails verification.
+#
+#	Usage: http::registerError socket ?newValue?
+#
+#	"set" semantics, except that a "get" (a call without a new value) for a
+#	non-existent socket returns {}, not an error.
+
+proc http::registerError {sock args} {
+    variable registeredErrors
+
+    if {    ([llength $args] == 0)
+	 && (![info exists registeredErrors($sock)])
+    } {
+	return
+    } elseif {    ([llength $args] == 1)
+	       && ([lindex $args 0] eq {})
+    } {
+	unset -nocomplain registeredErrors($sock)
+	return
+    }
+    set registeredErrors($sock) {*}$args
+}
+
+# http::DoneRequest --
+#
+#	Command called when a request has been sent.  It will arrange the
+#	next request and/or response as appropriate.
+#
+#	If this command is called when $socketClosing(*), the request $token
+#	that calls it must be pipelined and destined to fail.
+
+proc http::DoneRequest {token} {
+    variable http
+    variable socketMapping
+    variable socketRdState
+    variable socketWrState
+    variable socketRdQueue
+    variable socketWrQueue
+    variable socketClosing
+    variable socketPlayCmd
+
+    variable $token
+    upvar 0 $token state
+    set tk [namespace tail $token]
+    set sock $state(sock)
+
+    # If pipelined, connect the next HTTP request to the socket.
+    if {$state(reusing) && $state(-pipeline)} {
+	# Enable next token (if any) to write.
+	# The value "Wready" is set only here, and
+	# in http::Event after reading the response-headers of a
+	# non-reusing transaction.
+	# Previous value is $token. It cannot be pending.
+	set socketWrState($state(socketinfo)) Wready
+
+	# Now ready to write the next pipelined request (if any).
+	http::NextPipelinedWrite $token
+    } else {
+	# If pipelined, this is the first transaction on this socket.  We wait
+	# for the response headers to discover whether the connection is
+	# persistent.  (If this is not done and the connection is not
+	# persistent, we SHOULD retry and then MUST NOT pipeline before knowing
+	# that we have a persistent connection
+	# (rfc2616 8.1.2.2)).
+    }
+
+    # Connect to receive the response, unless the socket is pipelined
+    # and another response is being sent.
+    # This code block is separate from the code below because there are
+    # cases where socketRdState already has the value $token.
+    if {    $state(-keepalive)
+	 && $state(-pipeline)
+	 && [info exists socketRdState($state(socketinfo))]
+	 && ($socketRdState($state(socketinfo)) eq "Rready")
+    } {
+	#Log pipelined, GRANT read access to $token in Connected
+	set socketRdState($state(socketinfo)) $token
+    }
+
+    if {    $state(-keepalive)
+	 && $state(-pipeline)
+	 && [info exists socketRdState($state(socketinfo))]
+	 && ($socketRdState($state(socketinfo)) ne $token)
+    } {
+	# Do not read from the socket until it is ready.
+	##Log "HTTP response for token $token is queued for pipelined use"
+	# If $socketClosing(*), then the caller will be a pipelined write and
+	# execution will come here.
+	# This token has already been recorded as "in flight" for writing.
+	# When the socket is closed, the read queue will be cleared in
+	# CloseQueuedQueries and so the "lappend" here has no effect.
+	lappend socketRdQueue($state(socketinfo)) $token
+    } else {
+	# In the pipelined case, connection for reading depends on the
+	# value of socketRdState.
+	# In the nonpipeline case, connection for reading always occurs.
+	ReceiveResponse $token
+    }
+}
+
+# http::ReceiveResponse
+#
+#	Connects token to its socket for reading.
+
+proc http::ReceiveResponse {token} {
+    variable $token
+    upvar 0 $token state
+    set tk [namespace tail $token]
+    set sock $state(sock)
+
+    #Log ---- $state(socketinfo) >> conn to $token for HTTP response
+    lassign [fconfigure $sock -translation] trRead trWrite
+    fconfigure $sock -translation [list auto $trWrite] \
+		     -buffersize $state(-blocksize)
+    Log ^D$tk begin receiving response - token $token
+
+    coroutine ${token}EventCoroutine http::Event $sock $token
+    if {[info exists state(-handler)] || [info exists state(-progress)]} {
+        fileevent $sock readable [list http::EventGateway $sock $token]
+    } else {
+        fileevent $sock readable ${token}EventCoroutine
+    }
+    return
+}
+
+
+# http::EventGateway
+#
+#	Bug [c2dc1da315].
+#	- Recursive launch of the coroutine can occur if a -handler or -progress
+#	  callback is used, and the callback command enters the event loop.
+#	- To prevent this, the fileevent "binding" is disabled while the
+#	  coroutine is in flight.
+#	- If a recursive call occurs despite these precautions, it is not
+#	  trapped and discarded here, because it is better to report it as a
+#	  bug.
+#	- Although this solution is believed to be sufficiently general, it is
+#	  used only if -handler or -progress is specified.  In other cases,
+#	  the coroutine is called directly.
+
+proc http::EventGateway {sock token} {
+    variable $token
+    upvar 0 $token state
+    fileevent $sock readable {}
+    catch {${token}EventCoroutine} res opts
+    if {[info commands ${token}EventCoroutine] ne {}} {
+        # The coroutine can be deleted by completion (a non-yield return), by
+        # http::Finish (when there is a premature end to the transaction), by
+        # http::reset or http::cleanup, or if the caller set option -channel
+        # but not option -handler: in the last case reading from the socket is
+        # now managed by commands ::http::Copy*, http::ReceiveChunked, and
+        # http::make-transformation-chunked.
+        #
+        # Catch in case the coroutine has closed the socket.
+        catch {fileevent $sock readable [list http::EventGateway $sock $token]}
+    }
+
+    # If there was an error, re-throw it.
+    return -options $opts $res
+}
+
+
+# http::NextPipelinedWrite
+#
+# - Connecting a socket to a token for writing is done by this command and by
+#   command KeepSocket.
+# - If another request has a pipelined write scheduled for $token's socket,
+#   and if the socket is ready to accept it, connect the write and update
+#   the queue accordingly.
+# - This command is called from http::DoneRequest and http::Event,
+#   IF $state(-pipeline) AND (the current transfer has reached the point at
+#   which the socket is ready for the next request to be written).
+# - This command is called when a token has write access and is pipelined and
+#   keep-alive, and sets socketWrState to Wready.
+# - The command need not consider the case where socketWrState is set to a token
+#   that does not yet have write access.  Such a token is waiting for Rready,
+#   and the assignment of the connection to the token will be done elsewhere (in
+#   http::KeepSocket).
+# - This command cannot be called after socketWrState has been set to a
+#   "pending" token value (that is then overwritten by the caller), because that
+#   value is set by this command when it is called by an earlier token when it
+#   relinquishes its write access, and the pending token is always the next in
+#   line to write.
+
+proc http::NextPipelinedWrite {token} {
+    variable http
+    variable socketRdState
+    variable socketWrState
+    variable socketWrQueue
+    variable socketClosing
+    variable $token
+    upvar 0 $token state
+    set connId $state(socketinfo)
+
+    if {    [info exists socketClosing($connId)]
+	 && $socketClosing($connId)
+    } {
+	# socketClosing(*) is set because the server has sent a
+	# "Connection: close" header.
+	# Behave as if the queues are empty - so do nothing.
+    } elseif {    $state(-pipeline)
+	 && [info exists socketWrState($connId)]
+	 && ($socketWrState($connId) eq "Wready")
+
+	 && [info exists socketWrQueue($connId)]
+	 && [llength $socketWrQueue($connId)]
+	 && ([set token2 [lindex $socketWrQueue($connId) 0]
+	      set ${token2}(-pipeline)
+	     ]
+	    )
+    } {
+	# - The usual case for a pipelined connection, ready for a new request.
+	#Log pipelined, GRANT write access to $token2 in NextPipelinedWrite
+	set conn [set ${token2}(tmpConnArgs)]
+	set socketWrState($connId) $token2
+	set socketWrQueue($connId) [lrange $socketWrQueue($connId) 1 end]
+	# Connect does its own fconfigure.
+	fileevent $state(sock) writable [list http::Connect $token2 {*}$conn]
+	#Log ---- $connId << conn to $token2 for HTTP request (b)
+
+	# In the tests below, the next request will be nonpipeline.
+    } elseif {    $state(-pipeline)
+	       && [info exists socketWrState($connId)]
+	       && ($socketWrState($connId) eq "Wready")
+
+	       && [info exists socketWrQueue($connId)]
+	       && [llength $socketWrQueue($connId)]
+	       && (![ set token3 [lindex $socketWrQueue($connId) 0]
+		      set ${token3}(-pipeline)
+		    ]
+		  )
+
+	       && [info exists socketRdState($connId)]
+	       && ($socketRdState($connId) eq "Rready")
+    } {
+	# The case in which the next request will be non-pipelined, and the read
+	# and write queues is ready: which is the condition for a non-pipelined
+	# write.
+	variable $token3
+	upvar 0 $token3 state3
+	set conn [set ${token3}(tmpConnArgs)]
+	#Log nonpipeline, GRANT r/w access to $token3 in NextPipelinedWrite
+	set socketRdState($connId) $token3
+	set socketWrState($connId) $token3
+	set socketWrQueue($connId) [lrange $socketWrQueue($connId) 1 end]
+	# Connect does its own fconfigure.
+	fileevent $state(sock) writable [list http::Connect $token3 {*}$conn]
+	#Log ---- $state(sock) << conn to $token3 for HTTP request (c)
+
+    } elseif {    $state(-pipeline)
+	 && [info exists socketWrState($connId)]
+	 && ($socketWrState($connId) eq "Wready")
+
+	 && [info exists socketWrQueue($connId)]
+	 && [llength $socketWrQueue($connId)]
+	 && (![set token2 [lindex $socketWrQueue($connId) 0]
+	      set ${token2}(-pipeline)
+	     ]
+	    )
+    } {
+	# - The case in which the next request will be non-pipelined, but the
+	#   read queue is NOT ready.
+	# - A read is queued or in progress, but not a write.  Cannot start the
+	#   nonpipeline transaction, but must set socketWrState to prevent a new
+	#   pipelined request (in http::geturl) jumping the queue.
+	# - Because socketWrState($connId) is not set to Wready, the assignment
+	#   of the connection to $token2 will be done elsewhere - by command
+	#   http::KeepSocket when $socketRdState($connId) is set to "Rready".
+
+	#Log re-use nonpipeline, GRANT delayed write access to $token in NextP..
+	set socketWrState($connId) peNding
+    }
+}
+
+# http::CancelReadPipeline
+#
+#	Cancel pipelined responses on a closing "Keep-Alive" socket.
+#
+#	- Called by a variable trace on "unset socketRdState($connId)".
+#	- The variable relates to a Keep-Alive socket, which has been closed.
+#	- Cancels all pipelined responses. The requests have been sent,
+#	  the responses have not yet been received.
+#	- This is a hard cancel that ends each transaction with error status,
+#	  and closes the connection. Do not use it if you want to replay failed
+#	  transactions.
+#	- N.B. Always delete ::http::socketRdState($connId) before deleting
+#	  ::http::socketRdQueue($connId), or this command will do nothing.
+#
+# Arguments
+#	As for a trace command on a variable.
+
+proc http::CancelReadPipeline {name1 connId op} {
+    variable socketRdQueue
+    ##Log CancelReadPipeline $name1 $connId $op
+    if {[info exists socketRdQueue($connId)]} {
+	set msg {the connection was closed by CancelReadPipeline}
+	foreach token $socketRdQueue($connId) {
+	    set tk [namespace tail $token]
+	    Log ^X$tk end of response "($msg)" - token $token
+	    set ${token}(status) eof
+	    Finish $token ;#$msg
+	}
+	set socketRdQueue($connId) {}
+    }
+}
+
+# http::CancelWritePipeline
+#
+#	Cancel queued events on a closing "Keep-Alive" socket.
+#
+#	- Called by a variable trace on "unset socketWrState($connId)".
+#	- The variable relates to a Keep-Alive socket, which has been closed.
+#	- In pipelined or nonpipeline case: cancels all queued requests.  The
+#	  requests have not yet been sent, the responses are not due.
+#	- This is a hard cancel that ends each transaction with error status,
+#	  and closes the connection. Do not use it if you want to replay failed
+#	  transactions.
+#	- N.B. Always delete ::http::socketWrState($connId) before deleting
+#	  ::http::socketWrQueue($connId), or this command will do nothing.
+#
+# Arguments
+#	As for a trace command on a variable.
+
+proc http::CancelWritePipeline {name1 connId op} {
+    variable socketWrQueue
+
+    ##Log CancelWritePipeline $name1 $connId $op
+    if {[info exists socketWrQueue($connId)]} {
+	set msg {the connection was closed by CancelWritePipeline}
+	foreach token $socketWrQueue($connId) {
+	    set tk [namespace tail $token]
+	    Log ^X$tk end of response "($msg)" - token $token
+	    set ${token}(status) eof
+	    Finish $token ;#$msg
+	}
+	set socketWrQueue($connId) {}
+    }
+}
+
+# http::ReplayIfDead --
+#
+# - A query on a re-used persistent socket failed at the earliest opportunity,
+#   because the socket had been closed by the server.  Keep the token, tidy up,
+#   and try to connect on a fresh socket.
+# - The connection is monitored for eof by the command http::CheckEof.  Thus
+#   http::ReplayIfDead is needed only when a server event (half-closing an
+#   apparently idle connection), and a client event (sending a request) occur at
+#   almost the same time, and neither client nor server detects the other's
+#   action before performing its own (an "asynchronous close event").
+# - To simplify testing of http::ReplayIfDead, set TEST_EOF 1 in
+#   http::KeepSocket, and then http::ReplayIfDead will be called if http::geturl
+#   is called at any time after the server timeout.
+#
+# Arguments:
+#	token	Connection token.
+#
+# Side Effects:
+#	Use the same token, but try to open a new socket.
+
+proc http::ReplayIfDead {tokenArg doing} {
+    variable socketMapping
+    variable socketRdState
+    variable socketWrState
+    variable socketRdQueue
+    variable socketWrQueue
+    variable socketClosing
+    variable socketPlayCmd
+
+    variable $tokenArg
+    upvar 0 $tokenArg stateArg
+
+    Log running http::ReplayIfDead for $tokenArg $doing
+
+    # 1. Merge the tokens for transactions in flight, the read (response) queue,
+    #    and the write (request) queue.
+
+    set InFlightR {}
+    set InFlightW {}
+
+    # Obtain the tokens for transactions in flight.
+    if {$stateArg(-pipeline)} {
+	# Two transactions may be in flight.  The "read" transaction was first.
+	# It is unlikely that the server would close the socket if a response
+	# was pending; however, an earlier request (as well as the present
+	# request) may have been sent and ignored if the socket was half-closed
+	# by the server.
+
+	if {    [info exists socketRdState($stateArg(socketinfo))]
+	     && ($socketRdState($stateArg(socketinfo)) ne "Rready")
+	} {
+	    lappend InFlightR $socketRdState($stateArg(socketinfo))
+	} elseif {($doing eq "read")} {
+	    lappend InFlightR $tokenArg
+	}
+
+	if {    [info exists socketWrState($stateArg(socketinfo))]
+	     && $socketWrState($stateArg(socketinfo)) ni {Wready peNding}
+	} {
+	    lappend InFlightW $socketWrState($stateArg(socketinfo))
+	} elseif {($doing eq "write")} {
+	    lappend InFlightW $tokenArg
+	}
+
+	# Report any inconsistency of $tokenArg with socket*state.
+	if {    ($doing eq "read")
+	     && [info exists socketRdState($stateArg(socketinfo))]
+	     && ($tokenArg ne $socketRdState($stateArg(socketinfo)))
+	} {
+	    Log WARNING - ReplayIfDead pipelined tokenArg $tokenArg $doing \
+		    ne socketRdState($stateArg(socketinfo)) \
+		      $socketRdState($stateArg(socketinfo))
+
+	} elseif {
+		($doing eq "write")
+	     && [info exists socketWrState($stateArg(socketinfo))]
+	     && ($tokenArg ne $socketWrState($stateArg(socketinfo)))
+	} {
+	    Log WARNING - ReplayIfDead pipelined tokenArg $tokenArg $doing \
+		    ne socketWrState($stateArg(socketinfo)) \
+		      $socketWrState($stateArg(socketinfo))
+	}
+    } else {
+	# One transaction should be in flight.
+	# socketRdState, socketWrQueue are used.
+	# socketRdQueue should be empty.
+
+	# Report any inconsistency of $tokenArg with socket*state.
+	if {$tokenArg ne $socketRdState($stateArg(socketinfo))} {
+	    Log WARNING - ReplayIfDead nonpipeline tokenArg $tokenArg $doing \
+		    ne socketRdState($stateArg(socketinfo)) \
+		      $socketRdState($stateArg(socketinfo))
+	}
+
+	# Report the inconsistency that socketRdQueue is non-empty.
+	if {    [info exists socketRdQueue($stateArg(socketinfo))]
+	     && ($socketRdQueue($stateArg(socketinfo)) ne {})
+	} {
+	    Log WARNING - ReplayIfDead nonpipeline tokenArg $tokenArg $doing \
+		    has read queue socketRdQueue($stateArg(socketinfo)) \
+		    $socketRdQueue($stateArg(socketinfo)) ne {}
+	}
+
+	lappend InFlightW $socketRdState($stateArg(socketinfo))
+	set socketRdQueue($stateArg(socketinfo)) {}
+    }
+
+    set newQueue {}
+    lappend newQueue {*}$InFlightR
+    lappend newQueue {*}$socketRdQueue($stateArg(socketinfo))
+    lappend newQueue {*}$InFlightW
+    lappend newQueue {*}$socketWrQueue($stateArg(socketinfo))
+
+
+    # 2. Tidy up tokenArg.  This is a cut-down form of Finish/CloseSocket.
+    #    Do not change state(status).
+    #    No need to after cancel stateArg(after) - either this is done in
+    #    ReplayCore/ReInit, or Finish is called.
+
+    catch {close $stateArg(sock)}
+
+    # 2a. Tidy the tokens in the queues - this is done in ReplayCore/ReInit.
+    # - Transactions, if any, that are awaiting responses cannot be completed.
+    #   They are listed for re-sending in newQueue.
+    # - All tokens are preserved for re-use by ReplayCore, and their variables
+    #   will be re-initialised by calls to ReInit.
+    # - The relevant element of socketMapping, socketRdState, socketWrState,
+    #   socketRdQueue, socketWrQueue, socketClosing, socketPlayCmd will be set
+    #   to new values in ReplayCore.
+
+    ReplayCore $newQueue
+}
+
+# http::ReplayIfClose --
+#
+#	A request on a socket that was previously "Connection: keep-alive" has
+#	received a "Connection: close" response header.  The server supplies
+#	that response correctly, but any later requests already queued on this
+#	connection will be lost when the socket closes.
+#
+#	This command takes arguments that represent the socketWrState,
+#	socketRdQueue and socketWrQueue for this connection.  The socketRdState
+#	is not needed because the server responds in full to the request that
+#	received the "Connection: close" response header.
+#
+#	Existing request tokens $token (::http::$n) are preserved.  The caller
+#	will be unaware that the request was processed this way.
+
+proc http::ReplayIfClose {Wstate Rqueue Wqueue} {
+    Log running http::ReplayIfClose for $Wstate $Rqueue $Wqueue
+
+    if {$Wstate in $Rqueue || $Wstate in $Wqueue} {
+	Log WARNING duplicate token in http::ReplayIfClose - token $Wstate
+	set Wstate Wready
+    }
+
+    # 1. Create newQueue
+    set InFlightW {}
+    if {$Wstate ni {Wready peNding}} {
+	lappend InFlightW $Wstate
+    }
+
+    set newQueue {}
+    lappend newQueue {*}$Rqueue
+    lappend newQueue {*}$InFlightW
+    lappend newQueue {*}$Wqueue
+
+    # 2. Cleanup - none needed, done by the caller.
+
+    ReplayCore $newQueue
+}
+
+# http::ReInit --
+#
+#	Command to restore a token's state to a condition that
+#	makes it ready to replay a request.
+#
+#	Command http::geturl stores extra state in state(tmp*) so
+#	we don't need to do the argument processing again.
+#
+#	The caller must:
+#	- Set state(reusing) and state(sock) to their new values after calling
+#	  this command.
+#	- Unset state(tmpState), state(tmpOpenCmd) if future calls to ReplayCore
+#	  or ReInit are inappropriate for this token. Typically only one retry
+#	  is allowed.
+#	The caller may also unset state(tmpConnArgs) if this value (and the
+#	token) will be used immediately.  The value is needed by tokens that
+#	will be stored in a queue.
+#
+# Arguments:
+#	token	Connection token.
+#
+# Return Value: (boolean) true iff the re-initialisation was successful.
+
+proc http::ReInit {token} {
+    variable $token
+    upvar 0 $token state
+
+    if {!(
+	      [info exists state(tmpState)]
+	   && [info exists state(tmpOpenCmd)]
+	   && [info exists state(tmpConnArgs)]
+	 )
+    } {
+	Log FAILED in http::ReInit via ReplayCore - NO tmp vars for $token
+	return 0
+    }
+
+    if {[info exists state(after)]} {
+	after cancel $state(after)
+	unset state(after)
+    }
+
+    # Don't alter state(status) - this would trigger http::wait if it is in use.
+    set tmpState    $state(tmpState)
+    set tmpOpenCmd  $state(tmpOpenCmd)
+    set tmpConnArgs $state(tmpConnArgs)
+    foreach name [array names state] {
+	if {$name ne "status"} {
+	    unset state($name)
+	}
+    }
+
+    # Don't alter state(status).
+    # Restore state(tmp*) - the caller may decide to unset them.
+    # Restore state(tmpConnArgs) which is needed for connection.
+    # state(tmpState), state(tmpOpenCmd) are needed only for retries.
+
+    dict unset tmpState status
+    array set state $tmpState
+    set state(tmpState)    $tmpState
+    set state(tmpOpenCmd)  $tmpOpenCmd
+    set state(tmpConnArgs) $tmpConnArgs
+
+    return 1
+}
+
+# http::ReplayCore --
+#
+#	Command to replay a list of requests, using existing connection tokens.
+#
+#	Abstracted from http::geturl which stores extra state in state(tmp*) so
+#	we don't need to do the argument processing again.
+#
+# Arguments:
+#	newQueue	List of connection tokens.
+#
+# Side Effects:
+#	Use existing tokens, but try to open a new socket.
+
+proc http::ReplayCore {newQueue} {
+    variable socketMapping
+    variable socketRdState
+    variable socketWrState
+    variable socketRdQueue
+    variable socketWrQueue
+    variable socketClosing
+    variable socketPlayCmd
+
+    if {[llength $newQueue] == 0} {
+	# Nothing to do.
+	return
+    }
+
+    ##Log running ReplayCore for {*}$newQueue
+    set newToken [lindex $newQueue 0]
+    set newQueue [lrange $newQueue 1 end]
+
+    # 3. Use newToken, and restore its values of state(*).  Do not restore
+    #    elements tmp* - we try again only once.
+
+    set token $newToken
+    variable $token
+    upvar 0 $token state
+
+    if {![ReInit $token]} {
+	Log FAILED in http::ReplayCore - NO tmp vars
+	Finish $token {cannot send this request again}
+	return
+    }
+
+    set tmpState    $state(tmpState)
+    set tmpOpenCmd  $state(tmpOpenCmd)
+    set tmpConnArgs $state(tmpConnArgs)
+    unset state(tmpState)
+    unset state(tmpOpenCmd)
+    unset state(tmpConnArgs)
+
+    set state(reusing) 0
+
+    if {$state(-timeout) > 0} {
+	set resetCmd [list http::reset $token timeout]
+	set state(after) [after $state(-timeout) $resetCmd]
+    }
+
+    set pre [clock milliseconds]
+    ##Log pre socket opened, - token $token
+    ##Log $tmpOpenCmd - token $token
+    # 4. Open a socket.
+    if {[catch {eval $tmpOpenCmd} sock]} {
+	# Something went wrong while trying to establish the connection.
+	Log FAILED - $sock
+	set state(sock) NONE
+	Finish $token $sock
+	return
+    }
+    ##Log post socket opened, - token $token
+    set delay [expr {[clock milliseconds] - $pre}]
+    if {$delay > 3000} {
+	Log socket delay $delay - token $token
+    }
+    # Command [socket] is called with -async, but takes 5s to 5.1s to return,
+    # with probability of order 1 in 10,000.  This may be a bizarre scheduling
+    # issue with my (KJN's) system (Fedora Linux).
+    # This does not cause a problem (unless the request times out when this
+    # command returns).
+
+    # 5. Configure the persistent socket data.
+    if {$state(-keepalive)} {
+	set socketMapping($state(socketinfo)) $sock
+
+	if {![info exists socketRdState($state(socketinfo))]} {
+	    set socketRdState($state(socketinfo)) {}
+	    set varName ::http::socketRdState($state(socketinfo))
+	    trace add variable $varName unset ::http::CancelReadPipeline
+	}
+
+	if {![info exists socketWrState($state(socketinfo))]} {
+	    set socketWrState($state(socketinfo)) {}
+	    set varName ::http::socketWrState($state(socketinfo))
+	    trace add variable $varName unset ::http::CancelWritePipeline
+	}
+
+	if {$state(-pipeline)} {
+	    #Log new, init for pipelined, GRANT write acc to $token ReplayCore
+	    set socketRdState($state(socketinfo)) $token
+	    set socketWrState($state(socketinfo)) $token
+	} else {
+	    #Log new, init for nonpipeline, GRANT r/w acc to $token ReplayCore
+	    set socketRdState($state(socketinfo)) $token
+	    set socketWrState($state(socketinfo)) $token
+	}
+
+	set socketRdQueue($state(socketinfo)) {}
+	set socketWrQueue($state(socketinfo)) $newQueue
+	set socketClosing($state(socketinfo)) 0
+	set socketPlayCmd($state(socketinfo)) {ReplayIfClose Wready {} {}}
+    }
+
+    ##Log pre newQueue ReInit, - token $token
+    # 6. Configure sockets in the queue.
+    foreach tok $newQueue {
+	if {[ReInit $tok]} {
+	    set ${tok}(reusing) 1
+	    set ${tok}(sock) $sock
+	} else {
+	    set ${tok}(reusing) 1
+	    set ${tok}(sock) NONE
+	    Finish $token {cannot send this request again}
+	}
+    }
+
+    # 7. Configure the socket for newToken to send a request.
+    set state(sock) $sock
+    Log "Using $sock for $state(socketinfo) - token $token" \
+	[expr {$state(-keepalive)?"keepalive":""}]
+
+    # Initialisation of a new socket.
+    ##Log socket opened, now fconfigure - token $token
+    fconfigure $sock -translation {auto crlf} -buffersize $state(-blocksize)
+    ##Log socket opened, DONE fconfigure - token $token
+
+    # Connect does its own fconfigure.
+    fileevent $sock writable [list http::Connect $token {*}$tmpConnArgs]
+    #Log ---- $sock << conn to $token for HTTP request (e)
+}
+
+# Data access functions:
+# Data - the URL data
+# Status - the transaction status: ok, reset, eof, timeout, error
+# 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} {
+    if {![info exists $token]} {
+	return "error"
+    }
+    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::meta {token} {
+    variable $token
+    upvar 0 $token state
+    return $state(meta)
+}
+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 commands ${token}EventCoroutine] ne {}} {
+	rename ${token}EventCoroutine {}
+    }
+    if {[info exists state(after)]} {
+	after cancel $state(after)
+	unset state(after)
+    }
+    if {[info exists state]} {
+	unset state
+    }
+}
+
+# http::Connect
+#
+#	This callback is made when an asynchronous 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 proto phost srvurl} {
+    variable $token
+    upvar 0 $token state
+    set tk [namespace tail $token]
+    set err "due to unexpected EOF"
+    if {
+	[eof $state(sock)] ||
+	[set err [fconfigure $state(sock) -error]] ne ""
+    } {
+	Log "WARNING - if testing, pay special attention to this\
+		case (GJ) which is seldom executed - token $token"
+	if {[info exists state(reusing)] && $state(reusing)} {
+	    # The socket was closed at the server end, and closed at
+	    # this end by http::CheckEof.
+	    if {[TestForReplay $token write $err b]} {
+		return
+	    }
+
+	    # else:
+	    # This is NOT a persistent socket that has been closed since its
+	    # last use.
+	    # If any other requests are in flight or pipelined/queued, they will
+	    # be discarded.
+	}
+	Finish $token "connect failed $err"
+    } else {
+	set state(state) connecting
+	fileevent $state(sock) writable {}
+	::http::Connected $token $proto $phost $srvurl
+    }
+}
+
+# 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 http
+    variable socketMapping
+    variable socketRdState
+    variable socketWrState
+    variable socketRdQueue
+    variable socketWrQueue
+    variable socketClosing
+    variable socketPlayCmd
+
+    variable $token
+    upvar 0 $token state
+    set tk [namespace tail $token]
+    set sock $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.
+	    if {    $state(queryoffset) + $state(-queryblocksize)
+		 >= $state(querylength)
+	    } {
+		# This will be the last puts for the request-body.
+		if {    (![catch {fileevent $sock readable} binding])
+		     && ($binding eq [list http::CheckEof $sock])
+		} {
+		    # Remove the "fileevent readable" binding of an idle
+		    # persistent socket to http::CheckEof.  We can no longer
+		    # treat bytes received as junk. The server might still time
+		    # out and half-close the socket if it has not yet received
+		    # the first "puts".
+		    fileevent $sock readable {}
+		}
+	    }
+	    puts -nonewline $sock \
+		[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)]
+	    if {[eof $state(-querychannel)]} {
+		# This will be the last puts for the request-body.
+		if {    (![catch {fileevent $sock readable} binding])
+		     && ($binding eq [list http::CheckEof $sock])
+		} {
+		    # Remove the "fileevent readable" binding of an idle
+		    # persistent socket to http::CheckEof.  We can no longer
+		    # treat bytes received as junk. The server might still time
+		    # out and half-close the socket if it has not yet received
+		    # the first "puts".
+		    fileevent $sock readable {}
+		}
+	    }
+	    puts -nonewline $sock $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 $sock}
+	fileevent $sock writable {}
+	Log ^C$tk end sending request - token $token
+	# End of writing (POST method).  The request has been sent.
+
+	DoneRequest $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. This command is the core of
+#	the coroutine commands ${token}EventCoroutine that are
+#	bound to "fileevent $sock readable" and process input.
+#
+# Arguments
+#	sock	The socket receiving input.
+#	token	The token returned from http::geturl
+#
+# Side Effects
+#	Read the socket and handle callbacks.
+
+proc http::Event {sock token} {
+    variable http
+    variable socketMapping
+    variable socketRdState
+    variable socketWrState
+    variable socketRdQueue
+    variable socketWrQueue
+    variable socketClosing
+    variable socketPlayCmd
+
+    variable $token
+    upvar 0 $token state
+    set tk [namespace tail $token]
+    while 1 {
+	yield
+	##Log Event call - token $token
+
+	if {![info exists state]} {
+	    Log "Event $sock with invalid token '$token' - remote close?"
+	    if {![eof $sock]} {
+		if {[set d [read $sock]] ne ""} {
+		    Log "WARNING: additional data left on closed socket\
+			    - token $token"
+		}
+	    }
+	    Log ^X$tk end of response (token error) - token $token
+	    CloseSocket $sock
+	    return
+	}
+	if {$state(state) eq "connecting"} {
+	    ##Log - connecting - token $token
+	    if {    $state(reusing)
+		 && $state(-pipeline)
+		 && ($state(-timeout) > 0)
+		 && (![info exists state(after)])
+	    } {
+		set state(after) [after $state(-timeout) \
+			[list http::reset $token timeout]]
+	    }
+
+	    if {[catch {gets $sock state(http)} nsl]} {
+		Log "WARNING - if testing, pay special attention to this\
+			case (GK) which is seldom executed - token $token"
+		if {[info exists state(reusing)] && $state(reusing)} {
+		    # The socket was closed at the server end, and closed at
+		    # this end by http::CheckEof.
+
+		    if {[TestForReplay $token read $nsl c]} {
+			return
+		    }
+
+		    # else:
+		    # This is NOT a persistent socket that has been closed since
+		    # its last use.
+		    # If any other requests are in flight or pipelined/queued,
+		    # they will be discarded.
+		} else {
+		    Log ^X$tk end of response (error) - token $token
+		    Finish $token $nsl
+		    return
+		}
+	    } elseif {$nsl >= 0} {
+		##Log - connecting 1 - token $token
+		set state(state) "header"
+	    } elseif {    [eof $sock]
+		       && [info exists state(reusing)]
+		       && $state(reusing)
+	    } {
+		# The socket was closed at the server end, and we didn't notice.
+		# This is the first read - where the closure is usually first
+		# detected.
+
+		if {[TestForReplay $token read {} d]} {
+		    return
+		}
+
+		# else:
+		# This is NOT a persistent socket that has been closed since its
+		# last use.
+		# If any other requests are in flight or pipelined/queued, they
+		# will be discarded.
+	    }
+	} elseif {$state(state) eq "header"} {
+	    if {[catch {gets $sock line} nhl]} {
+		##Log header failed - token $token
+		Log ^X$tk end of response (error) - token $token
+		Finish $token $nhl
+		return
+	    } elseif {$nhl == 0} {
+		##Log header done - token $token
+		Log ^E$tk end of response headers - token $token
+		# We have now read all headers
+		# We ignore HTTP/1.1 100 Continue returns. RFC2616 sec 8.2.3
+		if {    ($state(http) == "")
+		     || ([regexp {^\S+\s(\d+)} $state(http) {} x] && $x == 100)
+		} {
+		    set state(state) "connecting"
+		    continue
+		    # This was a "return" in the pre-coroutine code.
+		}
+
+		if {    ([info exists state(connection)])
+		     && ([info exists socketMapping($state(socketinfo))])
+		     && ("keep-alive" in $state(connection))
+		     && ($state(-keepalive))
+		     && (!$state(reusing))
+		     && ($state(-pipeline))
+		} {
+		    # Response headers received for first request on a
+		    # persistent socket.  Now ready for pipelined writes (if
+		    # any).
+		    # Previous value is $token. It cannot be "pending".
+		    set socketWrState($state(socketinfo)) Wready
+		    http::NextPipelinedWrite $token
+		}
+
+		# Once a "close" has been signaled, the client MUST NOT send any
+		# more requests on that connection.
+		#
+		# If either the client or the server sends the "close" token in
+		# the Connection header, that request becomes the last one for
+		# the connection.
+
+		if {    ([info exists state(connection)])
+		     && ([info exists socketMapping($state(socketinfo))])
+		     && ("close" in $state(connection))
+		     && ($state(-keepalive))
+		} {
+		    # The server warns that it will close the socket after this
+		    # response.
+		    ##Log WARNING - socket will close after response for $token
+		    # Prepare data for a call to ReplayIfClose.
+		    if {    ($socketRdQueue($state(socketinfo)) ne {})
+			 || ($socketWrQueue($state(socketinfo)) ne {})
+			 || ($socketWrState($state(socketinfo)) ni
+						[list Wready peNding $token])
+		    } {
+			set InFlightW $socketWrState($state(socketinfo))
+			if {$InFlightW in [list Wready peNding $token]} {
+			    set InFlightW Wready
+			} else {
+			    set msg "token ${InFlightW} is InFlightW"
+			    ##Log $msg - token $token
+			}
+
+			set socketPlayCmd($state(socketinfo)) \
+				[list ReplayIfClose $InFlightW \
+				$socketRdQueue($state(socketinfo)) \
+				$socketWrQueue($state(socketinfo))]
+
+			# - All tokens are preserved for re-use by ReplayCore.
+			# - Queues are preserved in case of Finish with error,
+			#   but are not used for anything else because
+			#   socketClosing(*) is set below.
+			# - Cancel the state(after) timeout events.
+			foreach tokenVal $socketRdQueue($state(socketinfo)) {
+			    if {[info exists ${tokenVal}(after)]} {
+				after cancel [set ${tokenVal}(after)]
+				unset ${tokenVal}(after)
+			    }
+			}
+
+		    } else {
+			set socketPlayCmd($state(socketinfo)) \
+				{ReplayIfClose Wready {} {}}
+		    }
+
+		    # Do not allow further connections on this socket.
+		    set socketClosing($state(socketinfo)) 1
+		}
+
+		set state(state) body
+
+		# According to
+		# https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Connection
+		# any comma-separated "Connection:" list implies keep-alive, but I
+		# don't see this in the RFC so we'll play safe and
+		# scan any list for "close".
+		# Done here to support combining duplicate header field's values.
+		if {   [info exists state(connection)]
+		    && ("close" ni $state(connection))
+		    && ("keep-alive" ni $state(connection))
+		} {
+		    lappend state(connection) "keep-alive"
+		}
+
+		# If doing a HEAD, then we won't get any body
+		if {$state(-validate)} {
+		    Log ^F$tk end of response for HEAD request - token $token
+		    set state(state) complete
+		    Eot $token
+		    return
+		}
+
+		# - For non-chunked transfer we may have no body - in this case
+		#   we may get no further file event if the connection doesn't
+		#   close and no more data is sent. We can tell and must finish
+		#   up now - not later - the alternative would be to wait until
+		#   the server times out.
+		# - In this case, the server has NOT told the client it will
+		#   close the connection, AND it has NOT indicated the resource
+		#   length EITHER by setting the Content-Length (totalsize) OR
+		#   by using chunked Transfer-Encoding.
+		# - Do not worry here about the case (Connection: close) because
+		#   the server should close the connection.
+		# - IF (NOT Connection: close) AND (NOT chunked encoding) AND
+		#      (totalsize == 0).
+
+		if {    (!(    [info exists state(connection)]
+			    && ("close" in $state(connection))
+			  )
+			)
+		     && (![info exists state(transfer)])
+		     && ($state(totalsize) == 0)
+		} {
+		    set msg {body size is 0 and no events likely - complete}
+		    Log "$msg - token $token"
+		    set msg {(length unknown, set to 0)}
+		    Log ^F$tk end of response body {*}$msg - token $token
+		    set state(state) complete
+		    Eot $token
+		    return
+		}
+
+		# We have to use binary translation to count bytes properly.
+		lassign [fconfigure $sock -translation] trRead trWrite
+		fconfigure $sock -translation [list binary $trWrite]
+
+		if {
+		    $state(-binary) || [IsBinaryContentType $state(type)]
+		} {
+		    # Turn off conversions for non-text data.
+		    set state(binary) 1
+		}
+		if {[info exists state(-channel)]} {
+		    if {$state(binary) || [llength [ContentEncoding $token]]} {
+			fconfigure $state(-channel) -translation binary
+		    }
+		    if {![info exists state(-handler)]} {
+			# Initiate a sequence of background fcopies.
+			fileevent $sock readable {}
+			rename ${token}EventCoroutine {}
+			CopyStart $sock $token
+			return
+		    }
+		}
+	    } elseif {$nhl > 0} {
+		# Process header lines.
+		##Log header - token $token - $line
+		if {[regexp -nocase {^([^:]+):(.+)$} $line x key value]} {
+		    switch -- [string tolower $key] {
+			content-type {
+			    set state(type) [string trim [string tolower $value]]
+			    # Grab the optional charset information.
+			    if {[regexp -nocase \
+				    {charset\s*=\s*\"((?:[^""]|\\\")*)\"} \
+				    $state(type) -> cs]} {
+				set state(charset) [string map {{\"} \"} $cs]
+			    } else {
+				regexp -nocase {charset\s*=\s*(\S+?);?} \
+					$state(type) -> state(charset)
+			    }
+			}
+			content-length {
+			    set state(totalsize) [string trim $value]
+			}
+			content-encoding {
+			    set state(coding) [string trim $value]
+			}
+			transfer-encoding {
+			    set state(transfer) \
+				    [string trim [string tolower $value]]
+			}
+			proxy-connection -
+			connection {
+			    # RFC 7230 Section 6.1 states that a comma-separated
+			    # list is an acceptable value.
+			    foreach el [SplitCommaSeparatedFieldValue $value] {
+				lappend state(connection) [string tolower $el]
+			    }
+			}
+			upgrade {
+			    set state(upgrade) [string trim $value]
+			}
+		    }
+		    lappend state(meta) $key [string trim $value]
+		}
+	    }
+	} else {
+	    # Now reading body
+	    ##Log body - token $token
+	    if {[catch {
+		if {[info exists state(-handler)]} {
+		    set n [eval $state(-handler) [list $sock $token]]
+		    ##Log handler $n - token $token
+		    # N.B. the protocol has been set to 1.0 because the -handler
+		    # logic is not expected to handle chunked encoding.
+		    # FIXME Allow -handler with 1.1 on dechunked stacked chan.
+		    if {$state(totalsize) == 0} {
+			# We know the transfer is complete only when the server
+			# closes the connection - i.e. eof is not an error.
+			set state(state) complete
+		    }
+		    if {![string is integer -strict $n]} {
+			if 1 {
+			    # Do not tolerate bad -handler - fail with error
+			    # status.
+			    set msg {the -handler command for http::geturl must\
+				    return an integer (the number of bytes\
+				    read)}
+			    Log ^X$tk end of response (handler error) -\
+				    token $token
+			    Eot $token $msg
+			} else {
+			    # Tolerate the bad -handler, and continue.  The
+			    # penalty:
+			    # (a) Because the handler returns nonsense, we know
+			    #     the transfer is complete only when the server
+			    #     closes the connection - i.e. eof is not an
+			    #     error.
+			    # (b) http::size will not be accurate.
+			    # (c) The transaction is already downgraded to 1.0
+			    #     to avoid chunked transfer encoding.  It MUST
+			    #     also be forced to "Connection: close" or the
+			    #     HTTP/1.0 equivalent; or it MUST fail (as
+			    #     above) if the server sends
+			    #     "Connection: keep-alive" or the HTTP/1.0
+			    #     equivalent.
+			    set n 0
+			    set state(state) complete
+			}
+		    }
+		} elseif {[info exists state(transfer_final)]} {
+		    # This code forgives EOF in place of the final CRLF.
+		    set line [getTextLine $sock]
+		    set n [string length $line]
+		    set state(state) complete
+		    if {$n > 0} {
+			# - HTTP trailers (late response headers) are permitted
+			#   by Chunked Transfer-Encoding, and can be safely
+			#   ignored.
+			# - Do not count these bytes in the total received for
+			#   the response body.
+			Log "trailer of $n bytes after final chunk -\
+				token $token"
+			append state(transfer_final) $line
+			set n 0
+		    } else {
+			Log ^F$tk end of response body (chunked) - token $token
+			Log "final chunk part - token $token"
+			Eot $token
+		    }
+		} elseif {    [info exists state(transfer)]
+			   && ($state(transfer) eq "chunked")
+		} {
+		    ##Log chunked - token $token
+		    set size 0
+		    set hexLenChunk [getTextLine $sock]
+		    #set ntl [string length $hexLenChunk]
+		    if {[string trim $hexLenChunk] ne ""} {
+			scan $hexLenChunk %x size
+			if {$size != 0} {
+			    ##Log chunk-measure $size - token $token
+			    set chunk [BlockingRead $sock $size]
+			    set n [string length $chunk]
+			    if {$n >= 0} {
+				append state(body) $chunk
+				incr state(log_size) [string length $chunk]
+				##Log chunk $n cumul $state(log_size) -\
+					token $token
+			    }
+			    if {$size != [string length $chunk]} {
+				Log "WARNING: mis-sized chunk:\
+				    was [string length $chunk], should be\
+				    $size - token $token"
+				set n 0
+				set state(connection) close
+				Log ^X$tk end of response (chunk error) \
+					- token $token
+				set msg {error in chunked encoding - fetch\
+					terminated}
+				Eot $token $msg
+			    }
+			    # CRLF that follows chunk.
+			    # If eof, this is handled at the end of this proc.
+			    getTextLine $sock
+			} else {
+			    set n 0
+			    set state(transfer_final) {}
+			}
+		    } else {
+			# Line expected to hold chunk length is empty, or eof.
+			##Log bad-chunk-measure - token $token
+			set n 0
+			set state(connection) close
+			Log ^X$tk end of response (chunk error) - token $token
+			Eot $token {error in chunked encoding -\
+				fetch terminated}
+		    }
+		} else {
+		    ##Log unchunked - token $token
+		    if {$state(totalsize) == 0} {
+			# We know the transfer is complete only when the server
+			# closes the connection.
+			set state(state) complete
+			set reqSize $state(-blocksize)
+		    } else {
+			# Ask for the whole of the unserved response-body.
+			# This works around a problem with a tls::socket - for
+			# https in keep-alive mode, and a request for
+			# $state(-blocksize) bytes, the last part of the
+			# resource does not get read until the server times out.
+			set reqSize [expr {  $state(totalsize)
+					   - $state(currentsize)}]
+
+			# The workaround fails if reqSize is
+			# capped at $state(-blocksize).
+			# set reqSize [expr {min($reqSize, $state(-blocksize))}]
+		    }
+		    set c $state(currentsize)
+		    set t $state(totalsize)
+		    ##Log non-chunk currentsize $c of totalsize $t -\
+			    token $token
+		    set block [read $sock $reqSize]
+		    set n [string length $block]
+		    if {$n >= 0} {
+			append state(body) $block
+			##Log non-chunk [string length $state(body)] -\
+				token $token
+		    }
+		}
+		# This calculation uses n from the -handler, chunked, or
+		# unchunked case as appropriate.
+		if {[info exists state]} {
+		    if {$n >= 0} {
+			incr state(currentsize) $n
+			set c $state(currentsize)
+			set t $state(totalsize)
+			##Log another $n currentsize $c totalsize $t -\
+				token $token
+		    }
+		    # If Content-Length - check for end of data.
+		    if {
+			   ($state(totalsize) > 0)
+			&& ($state(currentsize) >= $state(totalsize))
+		    } {
+			Log ^F$tk end of response body (unchunked) -\
+				token $token
+			set state(state) complete
+			Eot $token
+		    }
+		}
+	    } err]} {
+		Log ^X$tk end of response (error ${err}) - token $token
+		Finish $token $err
+		return
+	    } else {
+		if {[info exists state(-progress)]} {
+		    eval $state(-progress) \
+			[list $token $state(totalsize) $state(currentsize)]
+		}
+	    }
+	}
+
+	# catch as an Eot above may have closed the socket already
+	# $state(state) may be connecting, header, body, or complete
+	if {![set cc [catch {eof $sock} eof]] && $eof} {
+	    ##Log eof - token $token
+	    if {[info exists $token]} {
+		set state(connection) close
+		if {$state(state) eq "complete"} {
+		    # This includes all cases in which the transaction
+		    # can be completed by eof.
+		    # The value "complete" is set only in http::Event, and it is
+		    # used only in the test above.
+		    Log ^F$tk end of response body (unchunked, eof) -\
+			    token $token
+		    Eot $token
+		} else {
+		    # Premature eof.
+		    Log ^X$tk end of response (unexpected eof) - token $token
+		    Eot $token eof
+		}
+	    } else {
+		# open connection closed on a token that has been cleaned up.
+		Log ^X$tk end of response (token error) - token $token
+		CloseSocket $sock
+	    }
+	} elseif {$cc} {
+	    return
+	}
+    }
+}
+
+# http::TestForReplay
+#
+#	Command called if eof is discovered when a socket is first used for a
+#	new transaction.  Typically this occurs if a persistent socket is used
+#	after a period of idleness and the server has half-closed the socket.
+#
+# token  - the connection token returned by http::geturl
+# doing  - "read" or "write"
+# err    - error message, if any
+# caller - code to identify the caller - used only in logging
+#
+# Return Value: boolean, true iff the command calls http::ReplayIfDead.
+
+proc http::TestForReplay {token doing err caller} {
+    variable http
+    variable $token
+    upvar 0 $token state
+    set tk [namespace tail $token]
+    if {$doing eq "read"} {
+	set code Q
+	set action response
+	set ing reading
+    } else {
+	set code P
+	set action request
+	set ing writing
+    }
+
+    if {$err eq {}} {
+	set err "detect eof when $ing (server timed out?)"
+    }
+
+    if {$state(method) eq "POST" && !$http(-repost)} {
+	# No Replay.
+	# The present transaction will end when Finish is called.
+	# That call to Finish will abort any other transactions
+	# currently in the write queue.
+	# For calls from http::Event this occurs when execution
+	# reaches the code block at the end of that proc.
+	set msg {no retry for POST with http::config -repost 0}
+	Log reusing socket failed "($caller)" - $msg - token $token
+	Log error - $err - token $token
+	Log ^X$tk end of $action (error) - token $token
+	return 0
+    } else {
+	# Replay.
+	set msg {try a new socket}
+	Log reusing socket failed "($caller)" - $msg - token $token
+	Log error - $err - token $token
+	Log ^$code$tk Any unfinished (incl this one) failed - token $token
+	ReplayIfDead $token $doing
+	return 1
+    }
+}
+
+# http::IsBinaryContentType --
+#
+#	Determine if the content-type means that we should definitely transfer
+#	the data as binary. [Bug 838e99a76d]
+#
+# Arguments
+#	type	The content-type of the data.
+#
+# Results:
+#	Boolean, true if we definitely should be binary.
+
+proc http::IsBinaryContentType {type} {
+    lassign [split [string tolower $type] "/;"] major minor
+    if {$major eq "text"} {
+	return false
+    }
+    # There's a bunch of XML-as-application-format things about. See RFC 3023
+    # and so on.
+    if {$major eq "application"} {
+	set minor [string trimright $minor]
+	if {$minor in {"json" "xml" "xml-external-parsed-entity" "xml-dtd"}} {
+	    return false
+	}
+    }
+    # Not just application/foobar+xml but also image/svg+xml, so let us not
+    # restrict things for now...
+    if {[string match "*+xml" $minor]} {
+	return false
+    }
+    return true
+}
+
+# http::getTextLine --
+#
+#	Get one line with the stream in crlf mode.
+#	Used if Transfer-Encoding is chunked.
+#	Empty line is not distinguished from eof.  The caller must
+#	be able to handle this.
+#
+# Arguments
+#	sock	The socket receiving input.
+#
+# Results:
+#	The line of text, without trailing newline
+
+proc http::getTextLine {sock} {
+    set tr [fconfigure $sock -translation]
+    lassign $tr trRead trWrite
+    fconfigure $sock -translation [list crlf $trWrite]
+    set r [BlockingGets $sock]
+    fconfigure $sock -translation $tr
+    return $r
+}
+
+# http::BlockingRead
+#
+#	Replacement for a blocking read.
+#	The caller must be a coroutine.
+
+proc http::BlockingRead {sock size} {
+    if {$size < 1} {
+	return
+    }
+    set result {}
+    while 1 {
+	set need [expr {$size - [string length $result]}]
+	set block [read $sock $need]
+	set eof [eof $sock]
+	append result $block
+	if {[string length $result] >= $size || $eof} {
+	    return $result
+	} else {
+	    yield
+	}
+    }
+}
+
+# http::BlockingGets
+#
+#	Replacement for a blocking gets.
+#	The caller must be a coroutine.
+#	Empty line is not distinguished from eof.  The caller must
+#	be able to handle this.
+
+proc http::BlockingGets {sock} {
+    while 1 {
+	set count [gets $sock line]
+	set eof [eof $sock]
+	if {$count >= 0 || $eof} {
+	    return $line
+	} else {
+	    yield
+	}
+    }
+}
+
+# http::CopyStart
+#
+#	Error handling wrapper around fcopy
+#
+# Arguments
+#	sock	The socket to copy from
+#	token	The token returned from http::geturl
+#
+# Side Effects
+#	This closes the connection upon error
+
+proc http::CopyStart {sock token {initial 1}} {
+    upvar #0 $token state
+    if {[info exists state(transfer)] && $state(transfer) eq "chunked"} {
+	foreach coding [ContentEncoding $token] {
+	    lappend state(zlib) [zlib stream $coding]
+	}
+	make-transformation-chunked $sock [namespace code [list CopyChunk $token]]
+    } else {
+	if {$initial} {
+	    foreach coding [ContentEncoding $token] {
+		zlib push $coding $sock
+	    }
+	}
+	if {[catch {
+	    # FIXME Keep-Alive on https tls::socket with unchunked transfer
+	    # hangs until the server times out. A workaround is possible, as for
+	    # the case without -channel, but it does not use the neat "fcopy"
+	    # solution.
+	    fcopy $sock $state(-channel) -size $state(-blocksize) -command \
+		[list http::CopyDone $token]
+	} err]} {
+	    Finish $token $err
+	}
+    }
+}
+
+proc http::CopyChunk {token chunk} {
+    upvar 0 $token state
+    if {[set count [string length $chunk]]} {
+	incr state(currentsize) $count
+	if {[info exists state(zlib)]} {
+	    foreach stream $state(zlib) {
+		set chunk [$stream add $chunk]
+	    }
+	}
+	puts -nonewline $state(-channel) $chunk
+	if {[info exists state(-progress)]} {
+	    eval [linsert $state(-progress) end \
+		      $token $state(totalsize) $state(currentsize)]
+	}
+    } else {
+	Log "CopyChunk Finish - token $token"
+	if {[info exists state(zlib)]} {
+	    set excess ""
+	    foreach stream $state(zlib) {
+		catch {set excess [$stream add -finalize $excess]}
+	    }
+	    puts -nonewline $state(-channel) $excess
+	    foreach stream $state(zlib) { $stream close }
+	    unset state(zlib)
+	}
+	Eot $token ;# FIX ME: pipelining.
+    }
+}
+
+# http::CopyDone
+#
+#	fcopy completion callback
+#
+# Arguments
+#	token	The token returned from http::geturl
+#	count	The amount transferred
+#
+# Side Effects
+#	Invokes callbacks
+
+proc http::CopyDone {token count {error {}}} {
+    variable $token
+    upvar 0 $token state
+    set sock $state(sock)
+    incr state(currentsize) $count
+    if {[info exists state(-progress)]} {
+	eval $state(-progress) \
+	    [list $token $state(totalsize) $state(currentsize)]
+    }
+    # At this point the token may have been reset.
+    if {[string length $error]} {
+	Finish $token $error
+    } elseif {[catch {eof $sock} iseof] || $iseof} {
+	Eot $token
+    } else {
+	CopyStart $sock $token 0
+    }
+}
+
+# http::Eot
+#
+#	Called when either:
+#	a. An eof condition is detected on the socket.
+#	b. The client decides that the response is complete.
+#	c. The client detects an inconsistency and aborts the transaction.
+#
+#	Does:
+#	1. Set state(status)
+#	2. Reverse any Content-Encoding
+#	3. Convert charset encoding and line ends if necessary
+#	4. Call http::Finish
+#
+# Arguments
+#	token	The token returned from http::geturl
+#	force	(previously) optional, has no effect
+#	reason	- "eof" means premature EOF (not EOF as the natural end of
+#		  the response)
+#		- "" means completion of response, with or without EOF
+#		- anything else describes an error condition other than
+#		  premature EOF.
+#
+# Side Effects
+#	Clean up the socket
+
+proc http::Eot {token {reason {}}} {
+    variable $token
+    upvar 0 $token state
+    if {$reason eq "eof"} {
+	# Premature eof.
+	set state(status) eof
+	set reason {}
+    } elseif {$reason ne ""} {
+	# Abort the transaction.
+	set state(status) $reason
+    } else {
+	# The response is complete.
+	set state(status) ok
+    }
+
+    if {[string length $state(body)] > 0} {
+	if {[catch {
+	    foreach coding [ContentEncoding $token] {
+		set state(body) [zlib $coding $state(body)]
+	    }
+	} err]} {
+	    Log "error doing decompression for token $token: $err"
+	    Finish $token $err
+	    return
+	}
+
+	if {!$state(binary)} {
+	    # 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 enc [CharsetToEncoding $state(charset)]
+	    if {$enc ne "binary"} {
+		set state(body) [encoding convertfrom $enc $state(body)]
+	    }
+
+	    # Translate text line endings.
+	    set state(body) [string map {\r\n \n \r \n} $state(body)]
+	}
+    }
+    Finish $token $reason
+}
+
+# http::wait --
+#
+#	See documentation 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)] || $state(status) eq ""} {
+	# We must wait on the original variable name, not the upvar alias
+	vwait ${token}(status)
+    }
+
+    return [status $token]
+}
+
+# http::formatQuery --
+#
+#	See documentation 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} {
+    if {[llength $args] % 2} {
+        return \
+            -code error \
+            -errorcode [list HTTP BADARGCNT $args] \
+            {Incorrect number of arguments, must be an even number.}
+    }
+    set result ""
+    set sep ""
+    foreach i $args {
+	append result $sep [mapReply $i]
+	if {$sep eq "="} {
+	    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
+
+    # The spec says: "non-alphanumeric characters are replaced by '%HH'". Use
+    # a pre-computed map and [string map] to do the conversion (much faster
+    # than [regsub]/[subst]). [Bug 1020491]
+
+    if {$http(-urlencoding) ne ""} {
+	set string [encoding convertto $http(-urlencoding) $string]
+	return [string map $formMap $string]
+    }
+    set converted [string map $formMap $string]
+    if {[string match "*\[\u0100-\uffff\]*" $converted]} {
+	regexp "\[\u0100-\uffff\]" $converted badChar
+	# Return this error message for maximum compatibility... :^/
+	return -code error \
+	    "can't read \"formMap($badChar)\": no such element in array"
+    }
+    return $converted
+}
+interp alias {} http::quoteString {} http::mapReply
+
+# 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)]
+    }
+}
+
+# http::CharsetToEncoding --
+#
+#	Tries to map a given IANA charset to a tcl encoding.  If no encoding
+#	can be found, returns binary.
+#
+
+proc http::CharsetToEncoding {charset} {
+    variable encodings
+
+    set charset [string tolower $charset]
+    if {[regexp {iso-?8859-([0-9]+)} $charset -> num]} {
+	set encoding "iso8859-$num"
+    } elseif {[regexp {iso-?2022-(jp|kr)} $charset -> ext]} {
+	set encoding "iso2022-$ext"
+    } elseif {[regexp {shift[-_]?jis} $charset]} {
+	set encoding "shiftjis"
+    } elseif {[regexp {(?:windows|cp)-?([0-9]+)} $charset -> num]} {
+	set encoding "cp$num"
+    } elseif {$charset eq "us-ascii"} {
+	set encoding "ascii"
+    } elseif {[regexp {(?:iso-?)?lat(?:in)?-?([0-9]+)} $charset -> num]} {
+	switch -- $num {
+	    5 {set encoding "iso8859-9"}
+	    1 - 2 - 3 {
+		set encoding "iso8859-$num"
+	    }
+	    default {
+		set encoding "binary"
+	    }
+	}
+    } else {
+	# other charset, like euc-xx, utf-8,...  may directly map to encoding
+	set encoding $charset
+    }
+    set idx [lsearch -exact $encodings $encoding]
+    if {$idx >= 0} {
+	return $encoding
+    } else {
+	return "binary"
+    }
+}
+
+# Return the list of content-encoding transformations we need to do in order.
+proc http::ContentEncoding {token} {
+    upvar 0 $token state
+    set r {}
+    if {[info exists state(coding)]} {
+	foreach coding [split $state(coding) ,] {
+	    switch -exact -- $coding {
+		deflate { lappend r inflate }
+		gzip - x-gzip { lappend r gunzip }
+		compress - x-compress { lappend r decompress }
+		identity {}
+		br {
+		    return -code error\
+			    "content-encoding \"br\" not implemented"
+		}
+		default {
+		    Log "unknown content-encoding \"$coding\" ignored"
+		}
+	    }
+	}
+    }
+    return $r
+}
+
+proc http::ReceiveChunked {chan command} {
+    set data ""
+    set size -1
+    yield
+    while {1} {
+	chan configure $chan -translation {crlf binary}
+	while {[gets $chan line] < 1} { yield }
+	chan configure $chan -translation {binary binary}
+	if {[scan $line %x size] != 1} {
+	    return -code error "invalid size: \"$line\""
+	}
+	set chunk ""
+	while {$size && ![chan eof $chan]} {
+	    set part [chan read $chan $size]
+	    incr size -[string length $part]
+	    append chunk $part
+	}
+	if {[catch {
+	    uplevel #0 [linsert $command end $chunk]
+	}]} {
+	    http::Log "Error in callback: $::errorInfo"
+	}
+	if {[string length $chunk] == 0} {
+	    # channel might have been closed in the callback
+	    catch {chan event $chan readable {}}
+	    return
+	}
+    }
+}
+
+# http::SplitCommaSeparatedFieldValue --
+# 	Return the individual values of a comma-separated field value.
+#
+# Arguments:
+#	fieldValue	Comma-separated header field value.
+#
+# Results:
+#       List of values.
+proc http::SplitCommaSeparatedFieldValue {fieldValue} {
+    set r {}
+    foreach el [split $fieldValue ,] {
+	lappend r [string trim $el]
+    }
+    return $r
+}
+
+
+# http::GetFieldValue --
+# 	Return the value of a header field.
+#
+# Arguments:
+#	headers	Headers key-value list
+#	fieldName	Name of header field whose value to return.
+#
+# Results:
+#       The value of the fieldName header field
+#
+# Field names are matched case-insensitively (RFC 7230 Section 3.2).
+#
+# If the field is present multiple times, it is assumed that the field is
+# defined as a comma-separated list and the values are combined (by separating
+# them with commas, see RFC 7230 Section 3.2.2) and returned at once.
+proc http::GetFieldValue {headers fieldName} {
+    set r {}
+    foreach {field value} $headers {
+	if {[string equal -nocase $fieldName $field]} {
+	    if {$r eq {}} {
+		set r $value
+	    } else {
+		append r ", $value"
+	    }
+	}
+    }
+    return $r
+}
+
+proc http::make-transformation-chunked {chan command} {
+    coroutine [namespace current]::dechunk$chan ::http::ReceiveChunked $chan $command
+    chan event $chan readable [namespace current]::dechunk$chan
+}
+
+# Local variables:
+# indent-tabs-mode: t
+# End:
diff --git a/mplug_owl2/lib/tcl8/8.6/tdbc/sqlite3-1.1.7.tm b/mplug_owl2/lib/tcl8/8.6/tdbc/sqlite3-1.1.7.tm
new file mode 100644
index 0000000000000000000000000000000000000000..a8b8955b7874aa9bb76e2526391dc8513ff44cc9
--- /dev/null
+++ b/mplug_owl2/lib/tcl8/8.6/tdbc/sqlite3-1.1.7.tm
@@ -0,0 +1,723 @@
+# tdbcsqlite3.tcl --
+#
+#    SQLite3 database driver for TDBC
+#
+# Copyright (c) 2008 by Kevin B. Kenny.
+# See the file "license.terms" for information on usage and redistribution
+# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+#
+# RCS: @(#) $Id: tdbcodbc.tcl,v 1.47 2008/02/27 02:08:27 kennykb Exp $
+#
+#------------------------------------------------------------------------------
+
+package require tdbc
+package require sqlite3
+
+package provide tdbc::sqlite3 1.1.7
+
+namespace eval tdbc::sqlite3 {
+    namespace export connection
+}
+
+#------------------------------------------------------------------------------
+#
+# tdbc::sqlite3::connection --
+#
+#	Class representing a SQLite3 database connection
+#
+#------------------------------------------------------------------------------
+
+::oo::class create ::tdbc::sqlite3::connection {
+
+    superclass ::tdbc::connection
+
+    variable timeout
+    variable keepcase
+
+    # The constructor accepts a database name and opens the database.
+
+    constructor {databaseName args} {
+	set timeout 0
+	set keepcase 0
+	if {[llength $args] % 2 != 0} {
+	    set cmd [lrange [info level 0] 0 end-[llength $args]]
+	    return -code error \
+		-errorcode {TDBC GENERAL_ERROR HY000 SQLITE3 WRONGNUMARGS} \
+		"wrong # args, should be \"$cmd ?-option value?...\""
+	}
+	next
+	sqlite3 [namespace current]::db $databaseName
+	if {[llength $args] > 0} {
+	    my configure {*}$args
+	}
+	db nullvalue \ufffd
+    }
+
+    # The 'statementCreate' method forwards to the constructor of the
+    # statement class
+
+    forward statementCreate ::tdbc::sqlite3::statement create
+
+    # The 'configure' method queries and sets options to the database
+
+    method configure args {
+	if {[llength $args] == 0} {
+
+	    # Query all configuration options
+
+	    set result {-encoding utf-8}
+	    lappend result -isolation
+	    if {[db onecolumn {PRAGMA read_uncommitted}]} {
+		lappend result readuncommitted
+	    } else {
+		lappend result serializable
+	    }
+	    lappend result -keepcase $keepcase
+	    lappend result -readonly 0
+	    lappend result -timeout $timeout
+	    return $result
+
+	} elseif {[llength $args] == 1} {
+
+	    # Query a single option
+
+	    set option [lindex $args 0]
+	    if {[catch {::tcl::prefix match -message "option" {
+		-encoding -isolation -keepcase -readonly -timeout
+	    } $option} opt]} {
+		return -code error \
+			-errorcode [list TDBC GENERAL_ERROR HY000 SQLITE3 \
+					BADOPTION $option] $opt
+	    }
+	    switch -exact -- $opt {
+ 		-encoding {
+		    return utf-8
+		}
+		-isolation {
+		    if {[db onecolumn {PRAGMA read_uncommitted}]} {
+			return readuncommitted
+		    } else {
+			return serializable
+		    }
+		}
+		-keepcase {
+		    return $keepcase
+		}
+		-readonly {
+		    return 0
+		}
+		-timeout {
+		    return $timeout
+		}
+	    }
+
+	} elseif {[llength $args] % 2 != 0} {
+
+	    # Syntax error
+
+	    set cmd [lrange [info level 0] 0 end-[llength $args]]
+	    return -code error \
+		-errorcode [list TDBC GENERAL_ERROR HY000 \
+				SQLITE3 WRONGNUMARGS] \
+		"wrong # args, should be \" $cmd ?-option value?...\""
+	}
+
+	# Set one or more options
+
+	foreach {option value} $args {
+	    if {[catch {::tcl::prefix match -message "option" {
+		-encoding -isolation -keepcase -readonly -timeout
+	    } $option} opt]} {
+		return -code error \
+			-errorcode [list TDBC GENERAL_ERROR HY000 SQLITE3 \
+					BADOPTION $option] $opt
+	    }
+
+	    switch -exact -- $opt {
+		-encoding {
+		    if {$value ne {utf-8}} {
+			return -code error \
+			    -errorcode [list TDBC FEATURE_NOT_SUPPORTED 0A000 \
+					    SQLITE3 ENCODING] \
+			    "-encoding not supported. SQLite3 is always\
+                             Unicode."
+		    }
+		}
+		-isolation {
+		    if {[catch {::tcl::prefix match -message "isolation level" {
+			readuncommitted readcommitted repeatableread
+			serializable readonly
+		    } $value} val]} {
+			return -code error \
+			    -errorcode [list TDBC GENERAL_ERROR HY000 \
+					    SQLITE3 BADISOLATION $value] \
+			    $val
+		    }
+		    switch -exact -- $val {
+			readuncommitted {
+			    db eval {PRAGMA read_uncommitted = 1}
+			}
+			readcommitted -
+			repeatableread -
+			serializable -
+			readonly {
+			    db eval {PRAGMA read_uncommitted = 0}
+			}
+		    }
+		}
+		-keepcase {
+		    if {![string is boolean -strict $value]} {
+			return -code error \
+			    -errorcode [list TDBC DATA_EXCEPTION 22018 \
+					    SQLITE3 $value] \
+			    "expected boolean but got \"$value\""
+		    }
+		    # Normalize boolean value to 0/1
+		    set keepcase [expr {bool($value)}]
+		}
+		-readonly {
+		    if {$value} {
+			return -code error \
+			    -errorcode [list TDBC FEATURE_NOT_SUPPORTED 0A000 \
+					    SQLITE3 READONLY] \
+			    "SQLite3's Tcl API does not support read-only\
+                             access"
+		    }
+		}
+		-timeout {
+		    if {![string is integer -strict $value]} {
+			return -code error \
+			    -errorcode [list TDBC DATA_EXCEPTION 22018 \
+					    SQLITE3 $value] \
+			    "expected integer but got \"$value\""
+		    }
+		    db timeout $value
+		    set timeout $value
+		}
+	    }
+	}
+	return
+    }
+
+    # The 'tables' method introspects on the tables in the database.
+
+    method tables {{pattern %}} {
+	set retval {}
+	my foreach row {
+	    SELECT * from sqlite_master
+	    WHERE type IN ('table', 'view')
+	    AND name LIKE :pattern
+	} {
+	    if {!$keepcase} {
+		dict set row name [string tolower [dict get $row name]]
+	    }
+	    dict set retval [dict get $row name] $row
+	}
+	return $retval
+    }
+
+    # The 'columns' method introspects on columns of a table.
+
+    method columns {table {pattern %}} {
+	regsub -all ' $table '' table
+	set retval {}
+	set pattern [string map [list \
+				     * {[*]} \
+				     ? {[?]} \
+				     \[ \\\[ \
+				     \] \\\[ \
+				     _ ? \
+				     % *] [string tolower $pattern]]
+	my foreach origrow "PRAGMA table_info('$table')" {
+	    set row {}
+	    dict for {key value} $origrow {
+		dict set row [string tolower $key] $value
+	    }
+	    if {!$keepcase} {
+		dict set row name [string tolower [dict get $row name]]
+	    }
+	    if {![string match $pattern \
+		      [string tolower [dict get $row name]]]} {
+		continue
+	    }
+	    switch -regexp -matchvar info [dict get $row type] {
+		{^(.+)\(\s*([[:digit:]]+)\s*,\s*([[:digit:]]+)\s*\)\s*$} {
+		    dict set row type \
+			    [string trim [string tolower [lindex $info 1]]]
+		    dict set row precision [lindex $info 2]
+		    dict set row scale [lindex $info 3]
+		}
+		{^(.+)\(\s*([[:digit:]]+)\s*\)\s*$} {
+		    dict set row type [string tolower [lindex $info 1]]
+		    dict set row precision [lindex $info 2]
+		    dict set row scale 0
+		}
+		default {
+		    dict set row type [string tolower [dict get $row type]]
+		    dict set row precision 0
+		    dict set row scale 0
+		}
+	    }
+	    dict set row nullable [expr {![dict get $row notnull]}]
+	    dict set retval [dict get $row name] $row
+	}
+	return $retval
+    }
+
+    # The 'primarykeys' method enumerates the primary keys on a table.
+
+    method primarykeys {table} {
+	set result {}
+	my foreach row "PRAGMA table_info($table)" {
+	    if {[dict get $row pk]} {
+		lappend result [dict create ordinalPosition \
+				    [expr {[dict get $row cid]+1}] \
+				    columnName \
+				    [dict get $row name]]
+	    }
+	}
+	return $result
+    }
+
+    # The 'foreignkeys' method enumerates the foreign keys that are
+    # declared in a table or that refer to a given table.
+
+    method foreignkeys {args} {
+
+	variable ::tdbc::generalError
+
+	# Check arguments
+
+	set argdict {}
+	if {[llength $args] % 2 != 0} {
+	    set errorcode $generalError
+	    lappend errorcode wrongNumArgs
+	    return -code error -errorcode $errorcode \
+		"wrong # args: should be [lrange [info level 0] 0 1]\
+                 ?-option value?..."
+	}
+	foreach {key value} $args {
+	    if {$key ni {-primary -foreign}} {
+		set errorcode $generalError
+		lappend errorcode badOption
+		return -code error -errorcode $errorcode \
+		    "bad option \"$key\", must be -primary or -foreign"
+	    }
+	    set key [string range $key 1 end]
+	    if {[dict exists $argdict $key]} {
+		set errorcode $generalError
+		lappend errorcode dupOption
+		return -code error -errorcode $errorcode \
+		    "duplicate option \"$key\" supplied"
+	    }
+	    dict set argdict $key $value
+	}
+
+	# If we know the table with the foreign key, search just its
+	# foreign keys. Otherwise, iterate over all the tables in the
+	# database.
+
+	if {[dict exists $argdict foreign]} {
+	    return [my ForeignKeysForTable [dict get $argdict foreign] \
+			$argdict]
+	} else {
+	    set result {}
+	    foreach foreignTable [dict keys [my tables]] {
+		lappend result {*}[my ForeignKeysForTable \
+				       $foreignTable $argdict]
+	    }
+	    return $result
+	}
+
+    }
+
+    # The private ForeignKeysForTable method enumerates the foreign keys
+    # in a specific table.
+    #
+    # Parameters:
+    #
+    #	foreignTable - Name of the table containing foreign keys.
+    #   argdict - Dictionary that may or may not contain a key,
+    #             'primary', whose value is the name of a table that
+    #             must hold the primary key corresponding to the foreign
+    #             key. If the 'primary' key is absent, all tables are
+    #             candidates.
+    # Results:
+    #
+    # 	Returns the list of foreign keys that meed the specified
+    # 	conditions, as a list of dictionaries, each containing the
+    # 	keys, foreignConstraintName, foreignTable, foreignColumn,
+    # 	primaryTable, primaryColumn, and ordinalPosition.  Note that the
+    #   foreign constraint name is constructed arbitrarily, since SQLite3
+    #   does not report this information.
+
+    method ForeignKeysForTable {foreignTable argdict} {
+
+	set result {}
+	set n 0
+
+	# Go through the foreign keys in the given table, looking for
+	# ones that refer to the primary table (if one is given), or
+	# for any primary keys if none is given.
+	my foreach row "PRAGMA foreign_key_list($foreignTable)" {
+	    if {(![dict exists $argdict primary])
+		|| ([string tolower [dict get $row table]]
+		    eq [string tolower [dict get $argdict primary]])} {
+
+		# Construct a dictionary for each key, translating
+		# SQLite names to TDBC ones and converting sequence
+		# numbers to 1-based indexing.
+
+		set rrow [dict create foreignTable $foreignTable \
+			      foreignConstraintName \
+			      ?$foreignTable?[dict get $row id]]
+		if {[dict exists $row seq]} {
+		    dict set rrow ordinalPosition \
+			[expr {1 + [dict get $row seq]}]
+		}
+		foreach {to from} {
+		    foreignColumn from
+		    primaryTable table
+		    primaryColumn to
+		    deleteAction on_delete
+		    updateAction on_update
+		} {
+		    if {[dict exists $row $from]} {
+			dict set rrow $to [dict get $row $from]
+		    }
+		}
+
+		# Add the newly-constucted dictionary to the result list
+
+		lappend result $rrow
+	    }
+	}
+
+	return $result
+    }
+
+    # The 'preparecall' method prepares a call to a stored procedure.
+    # SQLite3 does not have stored procedures, since it's an in-process
+    # server.
+
+    method preparecall {call} {
+	return -code error \
+	    -errorcode [list TDBC FEATURE_NOT_SUPPORTED 0A000 \
+			    SQLITE3 PREPARECALL] \
+	    {SQLite3 does not support stored procedures}
+    }
+
+    # The 'begintransaction' method launches a database transaction
+
+    method begintransaction {} {
+	db eval {BEGIN TRANSACTION}
+    }
+
+    # The 'commit' method commits a database transaction
+
+    method commit {} {
+	db eval {COMMIT}
+    }
+
+    # The 'rollback' method abandons a database transaction
+
+    method rollback {} {
+	db eval {ROLLBACK}
+    }
+
+    # The 'transaction' method executes a script as a single transaction.
+    # We override the 'transaction' method of the base class, since SQLite3
+    # has a faster implementation of the same thing. (The base class's generic
+    # method should also work.)
+    # (Don't overload the base class method, because 'break', 'continue'
+    # and 'return' in the transaction body don't work!)
+
+    #method transaction {script} {
+    #	uplevel 1 [list {*}[namespace code db] transaction $script]
+    #}
+
+    method prepare {sqlCode} {
+	set result [next $sqlCode]
+	return $result
+    }
+
+    method getDBhandle {} {
+	return [namespace which db]
+    }
+}
+
+#------------------------------------------------------------------------------
+#
+# tdbc::sqlite3::statement --
+#
+#	Class representing a statement to execute against a SQLite3 database
+#
+#------------------------------------------------------------------------------
+
+::oo::class create ::tdbc::sqlite3::statement {
+
+    superclass ::tdbc::statement
+
+    variable Params db sql
+
+    # The constructor accepts the handle to the connection and the SQL
+    # code for the statement to prepare.  All that it does is to parse the
+    # statement and store it.  The parse is used to support the
+    # 'params' and 'paramtype' methods.
+
+    constructor {connection sqlcode} {
+	next
+	set Params {}
+	set db [$connection getDBhandle]
+	set sql $sqlcode
+	foreach token [::tdbc::tokenize $sqlcode] {
+	    if {[string index $token 0] in {$ : @}} {
+		dict set Params [string range $token 1 end] \
+		    {type Tcl_Obj precision 0 scale 0 nullable 1 direction in}
+	    }
+	}
+    }
+
+    # The 'resultSetCreate' method relays to the result set constructor
+
+    forward resultSetCreate ::tdbc::sqlite3::resultset create
+
+    # The 'params' method returns descriptions of the parameters accepted
+    # by the statement
+
+    method params {} {
+	return $Params
+    }
+
+    # The 'paramtype' method need do nothing; Sqlite3 uses manifest typing.
+
+    method paramtype args {;}
+
+    method getDBhandle {} {
+	return $db
+    }
+
+    method getSql {} {
+	return $sql
+    }
+
+}
+
+#-------------------------------------------------------------------------------
+#
+# tdbc::sqlite3::resultset --
+#
+#	Class that represents a SQLlite result set in Tcl
+#
+#-------------------------------------------------------------------------------
+
+::oo::class create ::tdbc::sqlite3::resultset {
+
+    superclass ::tdbc::resultset
+
+    # The variables of this class all have peculiar names. The reason is
+    # that the RunQuery method needs to execute with an activation record
+    # that has no local variables whose names could conflict with names
+    # in the SQL query. We start the variable names with hyphens because
+    # they can't be bind variables.
+
+    variable -set {*}{
+	-columns -db -needcolumns -resultArray
+	-results -sql -Cursor -RowCount -END
+    }
+
+    constructor {statement args} {
+	next
+	set -db [$statement getDBhandle]
+	set -sql [$statement getSql]
+	set -columns {}
+	set -results {}
+	${-db} trace [namespace code {my RecordStatement}]
+	if {[llength $args] == 0} {
+
+	    # Variable substitutions are evaluated in caller's context
+
+	    uplevel 1 [list ${-db} eval ${-sql} \
+			   [namespace which -variable -resultArray] \
+			   [namespace code {my RecordResult}]]
+
+	} elseif {[llength $args] == 1} {
+
+	    # Variable substitutions are in the dictionary at [lindex $args 0].
+
+	    set -paramDict [lindex $args 0]
+
+	    # At this point, the activation record must contain no variables
+	    # that might be bound within the query.  All variables at this point
+	    # begin with hyphens so that they are syntactically incorrect
+	    # as bound variables in SQL.
+
+	    unset args
+	    unset statement
+
+	    dict with -paramDict {
+		${-db} eval ${-sql} -resultArray {
+		    my RecordResult
+		}
+	    }
+
+	} else {
+
+	    ${-db} trace {}
+
+	    # Too many args
+
+	    return -code error \
+		-errorcode [list TDBC GENERAL_ERROR HY000 \
+				SQLITE3 WRONGNUMARGS] \
+		"wrong # args: should be\
+                 [lrange [info level 0] 0 1] statement ?dictionary?"
+
+	}
+	${-db} trace {}
+	set -Cursor 0
+	if {${-Cursor} < [llength ${-results}]
+	    && [lindex ${-results} ${-Cursor}] eq {statement}} {
+	    incr -Cursor 2
+	}
+	if {${-Cursor} < [llength ${-results}]
+	    && [lindex ${-results} ${-Cursor}] eq {columns}} {
+	    incr -Cursor
+	    set -columns [lindex ${-results} ${-Cursor}]
+	    incr -Cursor
+	}
+	set -RowCount [${-db} changes]
+    }
+
+    # Record the start of a SQL statement
+
+    method RecordStatement {stmt} {
+	set -needcolumns 1
+	lappend -results statement {}
+    }
+
+    # Record one row of results from a query by appending it as a dictionary
+    # to the 'results' list.  As a side effect, set 'columns' to a list
+    # comprising the names of the columns of the result.
+
+    method RecordResult {} {
+	set columns ${-resultArray(*)}
+	if {[info exists -needcolumns]} {
+	    lappend -results columns $columns
+	    unset -needcolumns
+	}
+	set dict {}
+	foreach key $columns {
+	    if {[set -resultArray($key)] ne "\ufffd"} {
+		dict set dict $key [set -resultArray($key)]
+	    }
+	}
+	lappend -results row $dict
+    }
+
+    # Advance to the next result set
+
+    method nextresults {} {
+	set have 0
+	while {${-Cursor} < [llength ${-results}]} {
+	    if {[lindex ${-results} ${-Cursor}] eq {statement}} {
+		set have 1
+		incr -Cursor 2
+		break
+	    }
+	    incr -Cursor 2
+	}
+	if {!$have} {
+	    set -END {}
+	}
+	if {${-Cursor} >= [llength ${-results}]} {
+	    set -columns {}
+	} elseif {[lindex ${-results} ${-Cursor}] eq {columns}} {
+	    incr -Cursor
+	    set -columns [lindex ${-results} ${-Cursor}]
+	    incr -Cursor
+	} else {
+	    set -columns {}
+	}
+	return $have
+    }
+
+    method getDBhandle {} {
+	return ${-db}
+    }
+
+    # Return a list of the columns
+
+    method columns {} {
+	if {[info exists -END]} {
+	    return -code error \
+		-errorcode {TDBC GENERAL_ERROR HY010 SQLITE3 FUNCTIONSEQ} \
+		"Function sequence error: result set is exhausted."
+	}
+	return ${-columns}
+    }
+
+    # Return the next row of the result set as a list
+
+    method nextlist var {
+
+	upvar 1 $var row
+
+	if {[info exists -END]} {
+	    return -code error \
+		-errorcode {TDBC GENERAL_ERROR HY010 SQLITE3 FUNCTIONSEQ} \
+		"Function sequence error: result set is exhausted."
+	}
+	if {${-Cursor} >= [llength ${-results}]
+	    || [lindex ${-results} ${-Cursor}] ne {row}} {
+	    return 0
+	} else {
+	    set row {}
+	    incr -Cursor
+	    set d [lindex ${-results} ${-Cursor}]
+	    incr -Cursor
+	    foreach key ${-columns} {
+		if {[dict exists $d $key]} {
+		    lappend row [dict get $d $key]
+		} else {
+		    lappend row {}
+		}
+	    }
+	}
+	return 1
+    }
+
+    # Return the next row of the result set as a dict
+
+    method nextdict var {
+
+	upvar 1 $var row
+
+	if {[info exists -END]} {
+	    return -code error \
+		-errorcode {TDBC GENERAL_ERROR HY010 SQLITE3 FUNCTIONSEQ} \
+		"Function sequence error: result set is exhausted."
+	}
+	if {${-Cursor} >= [llength ${-results}]
+	    || [lindex ${-results} ${-Cursor}] ne {row}} {
+	    return 0
+	} else {
+	    incr -Cursor
+	    set row [lindex ${-results} ${-Cursor}]
+	    incr -Cursor
+	}
+	return 1
+    }
+
+    # Return the number of rows affected by a statement
+
+    method rowcount {} {
+	if {[info exists -END]} {
+	    return -code error \
+		-errorcode {TDBC GENERAL_ERROR HY010 SQLITE3 FUNCTIONSEQ} \
+		"Function sequence error: result set is exhausted."
+	}
+	return ${-RowCount}
+    }
+
+}
diff --git a/mplug_owl2/lib/tdbc1.1.7/tdbc.tcl b/mplug_owl2/lib/tdbc1.1.7/tdbc.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..f536131e80e1e126c31bd07c8591ec287af618d5
--- /dev/null
+++ b/mplug_owl2/lib/tdbc1.1.7/tdbc.tcl
@@ -0,0 +1,922 @@
+# tdbc.tcl --
+#
+#	Definitions of base classes from which TDBC drivers' connections,
+#	statements and result sets may inherit.
+#
+# Copyright (c) 2008 by Kevin B. Kenny
+# See the file "license.terms" for information on usage and redistribution
+# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+#
+# RCS: @(#) $Id$
+#
+#------------------------------------------------------------------------------
+
+package require TclOO
+
+namespace eval ::tdbc {
+    namespace export connection statement resultset
+    variable generalError [list TDBC GENERAL_ERROR HY000 {}]
+}
+
+#------------------------------------------------------------------------------
+#
+# tdbc::ParseConvenienceArgs --
+#
+#	Parse the convenience arguments to a TDBC 'execute',
+#	'executewithdictionary', or 'foreach' call.
+#
+# Parameters:
+#	argv - Arguments to the call
+#	optsVar -- Name of a variable in caller's scope that will receive
+#		   a dictionary of the supplied options
+#
+# Results:
+#	Returns any args remaining after parsing the options.
+#
+# Side effects:
+#	Sets the 'opts' dictionary to the options.
+#
+#------------------------------------------------------------------------------
+
+proc tdbc::ParseConvenienceArgs {argv optsVar} {
+
+    variable generalError
+    upvar 1 $optsVar opts
+
+    set opts [dict create -as dicts]
+    set i 0
+
+    # Munch keyword options off the front of the command arguments
+
+    foreach {key value} $argv {
+	if {[string index $key 0] eq {-}} {
+	    switch -regexp -- $key {
+		-as? {
+		    if {$value ne {dicts} && $value ne {lists}} {
+			set errorcode $generalError
+			lappend errorcode badVarType $value
+			return -code error \
+			    -errorcode $errorcode \
+			    "bad variable type \"$value\":\
+                             must be lists or dicts"
+		    }
+		    dict set opts -as $value
+		}
+		-c(?:o(?:l(?:u(?:m(?:n(?:s(?:v(?:a(?:r(?:i(?:a(?:b(?:le?)?)?)?)?)?)?)?)?)?)?)?)?) {
+		    dict set opts -columnsvariable $value
+		}
+		-- {
+		    incr i
+		    break
+		}
+		default {
+		    set errorcode $generalError
+		    lappend errorcode badOption $key
+		    return -code error \
+			-errorcode $errorcode \
+			"bad option \"$key\":\
+                             must be -as or -columnsvariable"
+		}
+	    }
+	} else {
+	    break
+	}
+	incr i 2
+    }
+
+    return [lrange $argv[set argv {}] $i end]
+
+}
+
+
+
+#------------------------------------------------------------------------------
+#
+# tdbc::connection --
+#
+#	Class that represents a generic connection to a database.
+#
+#-----------------------------------------------------------------------------
+
+oo::class create ::tdbc::connection {
+
+    # statementSeq is the sequence number of the last statement created.
+    # statementClass is the name of the class that implements the
+    #	'statement' API.
+    # primaryKeysStatement is the statement that queries primary keys
+    # foreignKeysStatement is the statement that queries foreign keys
+
+    variable statementSeq primaryKeysStatement foreignKeysStatement
+
+    # The base class constructor accepts no arguments.  It sets up the
+    # machinery to do the bookkeeping to keep track of what statements
+    # are associated with the connection.  The derived class constructor
+    # is expected to set the variable, 'statementClass' to the name
+    # of the class that represents statements, so that the 'prepare'
+    # method can invoke it.
+
+    constructor {} {
+	set statementSeq 0
+	namespace eval Stmt {}
+    }
+
+    # The 'close' method is simply an alternative syntax for destroying
+    # the connection.
+
+    method close {} {
+	my destroy
+    }
+
+    # The 'prepare' method creates a new statement against the connection,
+    # giving its constructor the current statement and the SQL code to
+    # prepare.  It uses the 'statementClass' variable set by the constructor
+    # to get the class to instantiate.
+
+    method prepare {sqlcode} {
+	return [my statementCreate Stmt::[incr statementSeq] [self] $sqlcode]
+    }
+
+    # The 'statementCreate' method delegates to the constructor
+    # of the class specified by the 'statementClass' variable. It's
+    # intended for drivers designed before tdbc 1.0b10. Current ones
+    # should forward this method to the constructor directly.
+
+    method statementCreate {name instance sqlcode} {
+	my variable statementClass
+	return [$statementClass create $name $instance $sqlcode]
+    }
+
+    # Derived classes are expected to implement the 'prepareCall' method,
+    # and have it call 'prepare' as needed (or do something else and
+    # install the resulting statement)
+
+    # The 'statements' method lists the statements active against this
+    # connection.
+
+    method statements {} {
+	info commands Stmt::*
+    }
+
+    # The 'resultsets' method lists the result sets active against this
+    # connection.
+
+    method resultsets {} {
+	set retval {}
+	foreach statement [my statements] {
+	    foreach resultset [$statement resultsets] {
+		lappend retval $resultset
+	    }
+	}
+	return $retval
+    }
+
+    # The 'transaction' method executes a block of Tcl code as an
+    # ACID transaction against the database.
+
+    method transaction {script} {
+	my begintransaction
+	set status [catch {uplevel 1 $script} result options]
+	if {$status in {0 2 3 4}} {
+	    set status2 [catch {my commit} result2 options2]
+	    if {$status2 == 1} {
+		set status 1
+		set result $result2
+		set options $options2
+	    }
+	}
+	switch -exact -- $status {
+	    0 {
+		# do nothing
+	    }
+	    2 - 3 - 4 {
+		set options [dict merge {-level 1} $options[set options {}]]
+		dict incr options -level
+	    }
+	    default {
+		my rollback
+	    }
+	}
+	return -options $options $result
+    }
+
+    # The 'allrows' method prepares a statement, then executes it with
+    # a given set of substituents, returning a list of all the rows
+    # that the statement returns. Optionally, it stores the names of
+    # the columns in '-columnsvariable'.
+    # Usage:
+    #     $db allrows ?-as lists|dicts? ?-columnsvariable varName? ?--?
+    #	      sql ?dictionary?
+
+    method allrows args {
+
+	variable ::tdbc::generalError
+
+	# Grab keyword-value parameters
+
+	set args [::tdbc::ParseConvenienceArgs $args[set args {}] opts]
+
+	# Check postitional parameters
+
+	set cmd [list [self] prepare]
+	if {[llength $args] == 1} {
+	    set sqlcode [lindex $args 0]
+	} elseif {[llength $args] == 2} {
+	    lassign $args sqlcode dict
+	} else {
+	    set errorcode $generalError
+	    lappend errorcode wrongNumArgs
+	    return -code error -errorcode $errorcode \
+		"wrong # args: should be [lrange [info level 0] 0 1]\
+                 ?-option value?... ?--? sqlcode ?dictionary?"
+	}
+	lappend cmd $sqlcode
+
+	# Prepare the statement
+
+	set stmt [uplevel 1 $cmd]
+
+	# Delegate to the statement to accumulate the results
+
+	set cmd [list $stmt allrows {*}$opts --]
+	if {[info exists dict]} {
+	    lappend cmd $dict
+	}
+	set status [catch {
+	    uplevel 1 $cmd
+	} result options]
+
+	# Destroy the statement
+
+	catch {
+	    $stmt close
+	}
+
+	return -options $options $result
+    }
+
+    # The 'foreach' method prepares a statement, then executes it with
+    # a supplied set of substituents.  For each row of the result,
+    # it sets a variable to the row and invokes a script in the caller's
+    # scope.
+    #
+    # Usage:
+    #     $db foreach ?-as lists|dicts? ?-columnsVariable varName? ?--?
+    #         varName sql ?dictionary? script
+
+    method foreach args {
+
+	variable ::tdbc::generalError
+
+	# Grab keyword-value parameters
+
+	set args [::tdbc::ParseConvenienceArgs $args[set args {}] opts]
+
+	# Check postitional parameters
+
+	set cmd [list [self] prepare]
+	if {[llength $args] == 3} {
+	    lassign $args varname sqlcode script
+	} elseif {[llength $args] == 4} {
+	    lassign $args varname sqlcode dict script
+	} else {
+	    set errorcode $generalError
+	    lappend errorcode wrongNumArgs
+	    return -code error -errorcode $errorcode \
+		"wrong # args: should be [lrange [info level 0] 0 1]\
+                 ?-option value?... ?--? varname sqlcode ?dictionary? script"
+	}
+	lappend cmd $sqlcode
+
+	# Prepare the statement
+
+	set stmt [uplevel 1 $cmd]
+
+	# Delegate to the statement to iterate over the results
+
+	set cmd [list $stmt foreach {*}$opts -- $varname]
+	if {[info exists dict]} {
+	    lappend cmd $dict
+	}
+	lappend cmd $script
+	set status [catch {
+	    uplevel 1 $cmd
+	} result options]
+
+	# Destroy the statement
+
+	catch {
+	    $stmt close
+	}
+
+	# Adjust return level in the case that the script [return]s
+
+	if {$status == 2} {
+	    set options [dict merge {-level 1} $options[set options {}]]
+	    dict incr options -level
+	}
+	return -options $options $result
+    }
+
+    # The 'BuildPrimaryKeysStatement' method builds a SQL statement to
+    # retrieve the primary keys from a database. (It executes once the
+    # first time the 'primaryKeys' method is executed, and retains the
+    # prepared statement for reuse.)
+
+    method BuildPrimaryKeysStatement {} {
+
+	# On some databases, CONSTRAINT_CATALOG is always NULL and
+	# JOINing to it fails. Check for this case and include that
+	# JOIN only if catalog names are supplied.
+
+	set catalogClause {}
+	if {[lindex [set count [my allrows -as lists {
+	    SELECT COUNT(*)
+            FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS
+            WHERE CONSTRAINT_CATALOG IS NOT NULL}]] 0 0] != 0} {
+	    set catalogClause \
+		{AND xtable.CONSTRAINT_CATALOG = xcolumn.CONSTRAINT_CATALOG}
+	}
+	set primaryKeysStatement [my prepare "
+	     SELECT xtable.TABLE_SCHEMA AS \"tableSchema\",
+                 xtable.TABLE_NAME AS \"tableName\",
+                 xtable.CONSTRAINT_CATALOG AS \"constraintCatalog\",
+                 xtable.CONSTRAINT_SCHEMA AS \"constraintSchema\",
+                 xtable.CONSTRAINT_NAME AS \"constraintName\",
+                 xcolumn.COLUMN_NAME AS \"columnName\",
+                 xcolumn.ORDINAL_POSITION AS \"ordinalPosition\"
+             FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS xtable
+             INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE xcolumn
+                     ON xtable.CONSTRAINT_SCHEMA = xcolumn.CONSTRAINT_SCHEMA
+                    AND xtable.TABLE_NAME = xcolumn.TABLE_NAME
+                    AND xtable.CONSTRAINT_NAME = xcolumn.CONSTRAINT_NAME
+	            $catalogClause
+             WHERE xtable.TABLE_NAME = :tableName
+               AND xtable.CONSTRAINT_TYPE = 'PRIMARY KEY'
+  	"]
+    }
+
+    # The default implementation of the 'primarykeys' method uses the
+    # SQL INFORMATION_SCHEMA to retrieve primary key information. Databases
+    # that might not have INFORMATION_SCHEMA must overload this method.
+
+    method primarykeys {tableName} {
+	if {![info exists primaryKeysStatement]} {
+	    my BuildPrimaryKeysStatement
+	}
+	tailcall $primaryKeysStatement allrows [list tableName $tableName]
+    }
+
+    # The 'BuildForeignKeysStatements' method builds a SQL statement to
+    # retrieve the foreign keys from a database. (It executes once the
+    # first time the 'foreignKeys' method is executed, and retains the
+    # prepared statements for reuse.)
+
+    method BuildForeignKeysStatement {} {
+
+	# On some databases, CONSTRAINT_CATALOG is always NULL and
+	# JOINing to it fails. Check for this case and include that
+	# JOIN only if catalog names are supplied.
+
+	set catalogClause1 {}
+	set catalogClause2 {}
+	if {[lindex [set count [my allrows -as lists {
+	    SELECT COUNT(*)
+            FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS
+            WHERE CONSTRAINT_CATALOG IS NOT NULL}]] 0 0] != 0} {
+	    set catalogClause1 \
+		{AND fkc.CONSTRAINT_CATALOG = rc.CONSTRAINT_CATALOG}
+	    set catalogClause2 \
+		{AND pkc.CONSTRAINT_CATALOG = rc.CONSTRAINT_CATALOG}
+	}
+
+	foreach {exists1 clause1} {
+	    0 {}
+	    1 { AND pkc.TABLE_NAME = :primary}
+	} {
+	    foreach {exists2 clause2} {
+		0 {}
+		1 { AND fkc.TABLE_NAME = :foreign}
+	    } {
+		set stmt [my prepare "
+	     SELECT rc.CONSTRAINT_CATALOG AS \"foreignConstraintCatalog\",
+                    rc.CONSTRAINT_SCHEMA AS \"foreignConstraintSchema\",
+                    rc.CONSTRAINT_NAME AS \"foreignConstraintName\",
+                    rc.UNIQUE_CONSTRAINT_CATALOG
+                        AS \"primaryConstraintCatalog\",
+                    rc.UNIQUE_CONSTRAINT_SCHEMA AS \"primaryConstraintSchema\",
+                    rc.UNIQUE_CONSTRAINT_NAME AS \"primaryConstraintName\",
+                    rc.UPDATE_RULE AS \"updateAction\",
+		    rc.DELETE_RULE AS \"deleteAction\",
+                    pkc.TABLE_CATALOG AS \"primaryCatalog\",
+                    pkc.TABLE_SCHEMA AS \"primarySchema\",
+                    pkc.TABLE_NAME AS \"primaryTable\",
+                    pkc.COLUMN_NAME AS \"primaryColumn\",
+                    fkc.TABLE_CATALOG AS \"foreignCatalog\",
+                    fkc.TABLE_SCHEMA AS \"foreignSchema\",
+                    fkc.TABLE_NAME AS \"foreignTable\",
+                    fkc.COLUMN_NAME AS \"foreignColumn\",
+                    pkc.ORDINAL_POSITION AS \"ordinalPosition\"
+             FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS rc
+             INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE fkc
+                     ON fkc.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
+                    AND fkc.CONSTRAINT_SCHEMA = rc.CONSTRAINT_SCHEMA
+                    $catalogClause1
+             INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE pkc
+                     ON pkc.CONSTRAINT_NAME = rc.UNIQUE_CONSTRAINT_NAME
+                     AND pkc.CONSTRAINT_SCHEMA = rc.UNIQUE_CONSTRAINT_SCHEMA
+                     $catalogClause2
+                     AND pkc.ORDINAL_POSITION = fkc.ORDINAL_POSITION
+             WHERE 1=1
+                 $clause1
+                 $clause2
+             ORDER BY \"foreignConstraintCatalog\", \"foreignConstraintSchema\", \"foreignConstraintName\", \"ordinalPosition\"
+"]
+		dict set foreignKeysStatement $exists1 $exists2 $stmt
+	    }
+	}
+    }
+
+    # The default implementation of the 'foreignkeys' method uses the
+    # SQL INFORMATION_SCHEMA to retrieve primary key information. Databases
+    # that might not have INFORMATION_SCHEMA must overload this method.
+
+    method foreignkeys {args} {
+
+	variable ::tdbc::generalError
+
+	# Check arguments
+
+	set argdict {}
+	if {[llength $args] % 2 != 0} {
+	    set errorcode $generalError
+	    lappend errorcode wrongNumArgs
+	    return -code error -errorcode $errorcode \
+		"wrong # args: should be [lrange [info level 0] 0 1]\
+                 ?-option value?..."
+	}
+	foreach {key value} $args {
+	    if {$key ni {-primary -foreign}} {
+		set errorcode $generalError
+		lappend errorcode badOption
+		return -code error -errorcode $errorcode \
+		    "bad option \"$key\", must be -primary or -foreign"
+	    }
+	    set key [string range $key 1 end]
+	    if {[dict exists $argdict $key]} {
+		set errorcode $generalError
+		lappend errorcode dupOption
+		return -code error -errorcode $errorcode \
+		    "duplicate option \"$key\" supplied"
+	    }
+	    dict set argdict $key $value
+	}
+
+	# Build the statements that query foreign keys. There are four
+	# of them, one for each combination of whether -primary
+	# and -foreign is specified.
+
+	if {![info exists foreignKeysStatement]} {
+	    my BuildForeignKeysStatement
+	}
+	set stmt [dict get $foreignKeysStatement \
+		      [dict exists $argdict primary] \
+		      [dict exists $argdict foreign]]
+	tailcall $stmt allrows $argdict
+    }
+
+    # Derived classes are expected to implement the 'begintransaction',
+    # 'commit', and 'rollback' methods.
+
+    # Derived classes are expected to implement 'tables' and 'columns' method.
+
+}
+
+#------------------------------------------------------------------------------
+#
+# Class: tdbc::statement
+#
+#	Class that represents a SQL statement in a generic database
+#
+#------------------------------------------------------------------------------
+
+oo::class create tdbc::statement {
+
+    # resultSetSeq is the sequence number of the last result set created.
+    # resultSetClass is the name of the class that implements the 'resultset'
+    #	API.
+
+    variable resultSetClass resultSetSeq
+
+    # The base class constructor accepts no arguments.  It initializes
+    # the machinery for tracking the ownership of result sets. The derived
+    # constructor is expected to invoke the base constructor, and to
+    # set a variable 'resultSetClass' to the fully-qualified name of the
+    # class that represents result sets.
+
+    constructor {} {
+	set resultSetSeq 0
+	namespace eval ResultSet {}
+    }
+
+    # The 'execute' method on a statement runs the statement with
+    # a particular set of substituted variables.  It actually works
+    # by creating the result set object and letting that objects
+    # constructor do the work of running the statement.  The creation
+    # is wrapped in an [uplevel] call because the substitution proces
+    # may need to access variables in the caller's scope.
+
+    # WORKAROUND: Take out the '0 &&' from the next line when
+    # Bug 2649975 is fixed
+    if {0 && [package vsatisfies [package provide Tcl] 8.6]} {
+	method execute args {
+	    tailcall my resultSetCreate \
+		[namespace current]::ResultSet::[incr resultSetSeq]  \
+		[self] {*}$args
+	}
+    } else {
+	method execute args {
+	    return \
+		[uplevel 1 \
+		     [list \
+			  [self] resultSetCreate \
+			  [namespace current]::ResultSet::[incr resultSetSeq] \
+			  [self] {*}$args]]
+	}
+    }
+
+    # The 'ResultSetCreate' method is expected to be a forward to the
+    # appropriate result set constructor. If it's missing, the driver must
+    # have been designed for tdbc 1.0b9 and earlier, and the 'resultSetClass'
+    # variable holds the class name.
+
+    method resultSetCreate {name instance args} {
+	return [uplevel 1 [list $resultSetClass create \
+			       $name $instance {*}$args]]
+    }
+
+    # The 'resultsets' method returns a list of result sets produced by
+    # the current statement
+
+    method resultsets {} {
+	info commands ResultSet::*
+    }
+
+    # The 'allrows' method executes a statement with a given set of
+    # substituents, and returns a list of all the rows that the statement
+    # returns.  Optionally, it stores the names of columns in
+    # '-columnsvariable'.
+    #
+    # Usage:
+    #	$statement allrows ?-as lists|dicts? ?-columnsvariable varName? ?--?
+    #		?dictionary?
+
+
+    method allrows args {
+
+	variable ::tdbc::generalError
+
+	# Grab keyword-value parameters
+
+	set args [::tdbc::ParseConvenienceArgs $args[set args {}] opts]
+
+	# Check postitional parameters
+
+	set cmd [list [self] execute]
+	if {[llength $args] == 0} {
+	    # do nothing
+	} elseif {[llength $args] == 1} {
+	    lappend cmd [lindex $args 0]
+	} else {
+	    set errorcode $generalError
+	    lappend errorcode wrongNumArgs
+	    return -code error -errorcode $errorcode \
+		"wrong # args: should be [lrange [info level 0] 0 1]\
+                 ?-option value?... ?--? ?dictionary?"
+	}
+
+	# Get the result set
+
+	set resultSet [uplevel 1 $cmd]
+
+	# Delegate to the result set's [allrows] method to accumulate
+	# the rows of the result.
+
+	set cmd [list $resultSet allrows {*}$opts]
+	set status [catch {
+	    uplevel 1 $cmd
+	} result options]
+
+	# Destroy the result set
+
+	catch {
+	    rename $resultSet {}
+	}
+
+	# Adjust return level in the case that the script [return]s
+
+	if {$status == 2} {
+	    set options [dict merge {-level 1} $options[set options {}]]
+	    dict incr options -level
+	}
+	return -options $options $result
+    }
+
+    # The 'foreach' method executes a statement with a given set of
+    # substituents.  It runs the supplied script, substituting the supplied
+    # named variable. Optionally, it stores the names of columns in
+    # '-columnsvariable'.
+    #
+    # Usage:
+    #	$statement foreach ?-as lists|dicts? ?-columnsvariable varName? ?--?
+    #		variableName ?dictionary? script
+
+    method foreach args {
+
+	variable ::tdbc::generalError
+
+	# Grab keyword-value parameters
+
+	set args [::tdbc::ParseConvenienceArgs $args[set args {}] opts]
+
+	# Check positional parameters
+
+	set cmd [list [self] execute]
+	if {[llength $args] == 2} {
+	    lassign $args varname script
+	} elseif {[llength $args] == 3} {
+	    lassign $args varname dict script
+	    lappend cmd $dict
+	} else {
+	    set errorcode $generalError
+	    lappend errorcode wrongNumArgs
+	    return -code error -errorcode $errorcode \
+		"wrong # args: should be [lrange [info level 0] 0 1]\
+                 ?-option value?... ?--? varName ?dictionary? script"
+	}
+
+	# Get the result set
+
+	set resultSet [uplevel 1 $cmd]
+
+	# Delegate to the result set's [foreach] method to evaluate
+	# the script for each row of the result.
+
+	set cmd [list $resultSet foreach {*}$opts -- $varname $script]
+	set status [catch {
+	    uplevel 1 $cmd
+	} result options]
+
+	# Destroy the result set
+
+	catch {
+	    rename $resultSet {}
+	}
+
+	# Adjust return level in the case that the script [return]s
+
+	if {$status == 2} {
+	    set options [dict merge {-level 1} $options[set options {}]]
+	    dict incr options -level
+	}
+	return -options $options $result
+    }
+
+    # The 'close' method is syntactic sugar for invoking the destructor
+
+    method close {} {
+	my destroy
+    }
+
+    # Derived classes are expected to implement their own constructors,
+    # plus the following methods:
+
+    # paramtype paramName ?direction? type ?scale ?precision??
+    #     Declares the type of a parameter in the statement
+
+}
+
+#------------------------------------------------------------------------------
+#
+# Class: tdbc::resultset
+#
+#	Class that represents a result set in a generic database.
+#
+#------------------------------------------------------------------------------
+
+oo::class create tdbc::resultset {
+
+    constructor {} { }
+
+    # The 'allrows' method returns a list of all rows that a given
+    # result set returns.
+
+    method allrows args {
+
+	variable ::tdbc::generalError
+
+	# Parse args
+
+	set args [::tdbc::ParseConvenienceArgs $args[set args {}] opts]
+	if {[llength $args] != 0} {
+	    set errorcode $generalError
+	    lappend errorcode wrongNumArgs
+	    return -code error -errorcode $errorcode \
+		"wrong # args: should be [lrange [info level 0] 0 1]\
+                 ?-option value?... ?--? varName script"
+	}
+
+	# Do -columnsvariable if requested
+
+	if {[dict exists $opts -columnsvariable]} {
+	    upvar 1 [dict get $opts -columnsvariable] columns
+	}
+
+	# Assemble the results
+
+	if {[dict get $opts -as] eq {lists}} {
+	    set delegate nextlist
+	} else {
+	    set delegate nextdict
+	}
+	set results [list]
+	while {1} {
+	    set columns [my columns]
+	    while {[my $delegate row]} {
+		lappend results $row
+	    }
+	    if {![my nextresults]} break
+	}
+	return $results
+
+    }
+
+    # The 'foreach' method runs a script on each row from a result set.
+
+    method foreach args {
+
+	variable ::tdbc::generalError
+
+	# Grab keyword-value parameters
+
+	set args [::tdbc::ParseConvenienceArgs $args[set args {}] opts]
+
+	# Check positional parameters
+
+	if {[llength $args] != 2} {
+	    set errorcode $generalError
+	    lappend errorcode wrongNumArgs
+	    return -code error -errorcode $errorcode \
+		"wrong # args: should be [lrange [info level 0] 0 1]\
+                 ?-option value?... ?--? varName script"
+	}
+
+	# Do -columnsvariable if requested
+
+	if {[dict exists $opts -columnsvariable]} {
+	    upvar 1 [dict get $opts -columnsvariable] columns
+	}
+
+	# Iterate over the groups of results
+	while {1} {
+
+	    # Export column names to caller
+
+	    set columns [my columns]
+
+	    # Iterate over the rows of one group of results
+
+	    upvar 1 [lindex $args 0] row
+	    if {[dict get $opts -as] eq {lists}} {
+		set delegate nextlist
+	    } else {
+		set delegate nextdict
+	    }
+	    while {[my $delegate row]} {
+		set status [catch {
+		    uplevel 1 [lindex $args 1]
+		} result options]
+		switch -exact -- $status {
+		    0 - 4 {	# OK or CONTINUE
+		    }
+		    2 {		# RETURN
+			set options \
+			    [dict merge {-level 1} $options[set options {}]]
+			dict incr options -level
+			return -options $options $result
+		    }
+		    3 {		# BREAK
+			set broken 1
+			break
+		    }
+		    default {	# ERROR or unknown status
+			return -options $options $result
+		    }
+		}
+	    }
+
+	    # Advance to the next group of results if there is one
+
+	    if {[info exists broken] || ![my nextresults]} {
+		break
+	    }
+	}
+
+	return
+    }
+
+
+    # The 'nextrow' method retrieves a row in the form of either
+    # a list or a dictionary.
+
+    method nextrow {args} {
+
+	variable ::tdbc::generalError
+
+	set opts [dict create -as dicts]
+	set i 0
+
+	# Munch keyword options off the front of the command arguments
+
+	foreach {key value} $args {
+	    if {[string index $key 0] eq {-}} {
+		switch -regexp -- $key {
+		    -as? {
+			dict set opts -as $value
+		    }
+		    -- {
+			incr i
+			break
+		    }
+		    default {
+			set errorcode $generalError
+			lappend errorcode badOption $key
+			return -code error -errorcode $errorcode \
+			    "bad option \"$key\":\
+                             must be -as or -columnsvariable"
+		    }
+		}
+	    } else {
+		break
+	    }
+	    incr i 2
+	}
+
+	set args [lrange $args $i end]
+	if {[llength $args] != 1} {
+	    set errorcode $generalError
+	    lappend errorcode wrongNumArgs
+	    return -code error -errorcode $errorcode \
+		"wrong # args: should be [lrange [info level 0] 0 1]\
+                 ?-option value?... ?--? varName"
+	}
+	upvar 1 [lindex $args 0] row
+	if {[dict get $opts -as] eq {lists}} {
+	    set delegate nextlist
+	} else {
+	    set delegate nextdict
+	}
+	return [my $delegate row]
+    }
+
+    # Derived classes must override 'nextresults' if a single
+    # statement execution can yield multiple sets of results
+
+    method nextresults {} {
+	return 0
+    }
+
+    # Derived classes must override 'outputparams' if statements can
+    # have output parameters.
+
+    method outputparams {} {
+	return {}
+    }
+
+    # The 'close' method is syntactic sugar for destroying the result set.
+
+    method close {} {
+	my destroy
+    }
+
+    # Derived classes are expected to implement the following methods:
+
+    # constructor and destructor.
+    #        Constructor accepts a statement and an optional
+    #        a dictionary of substituted parameters  and
+    #        executes the statement against the database. If
+    #	     the dictionary is not supplied, then the default
+    #	     is to get params from variables in the caller's scope).
+    # columns
+    #     -- Returns a list of the names of the columns in the result.
+    # nextdict variableName
+    #     -- Stores the next row of the result set in the given variable
+    #        in caller's scope, in the form of a dictionary that maps
+    #	     column names to values.
+    # nextlist variableName
+    #     -- Stores the next row of the result set in the given variable
+    #        in caller's scope, in the form of a list of cells.
+    # rowcount
+    #     -- Returns a count of rows affected by the statement, or -1
+    #        if the count of rows has not been determined.
+
+}
\ No newline at end of file
diff --git a/mplug_owl2/lib/tdbcodbc1.1.7/libtdbcodbc1.1.7.so b/mplug_owl2/lib/tdbcodbc1.1.7/libtdbcodbc1.1.7.so
new file mode 100644
index 0000000000000000000000000000000000000000..855dafac0a266eeae7195b1aaf703cdf45cec4cd
Binary files /dev/null and b/mplug_owl2/lib/tdbcodbc1.1.7/libtdbcodbc1.1.7.so differ
diff --git a/mplug_owl2/lib/tdbcodbc1.1.7/pkgIndex.tcl b/mplug_owl2/lib/tdbcodbc1.1.7/pkgIndex.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..f5d50949d8f3d4e4fd6e79ecb038d6e4d62fbc5f
--- /dev/null
+++ b/mplug_owl2/lib/tdbcodbc1.1.7/pkgIndex.tcl
@@ -0,0 +1,14 @@
+# Index file to load the TDBC ODBC package.
+
+if {![package vsatisfies [package provide Tcl] 8.6-]} {
+    return
+}
+if {[package vsatisfies [package provide Tcl] 9.0-]} {
+    package ifneeded tdbc::odbc 1.1.7 \
+	    "[list source [file join $dir tdbcodbc.tcl]]\;\
+	    [list load [file join $dir libtcl9tdbcodbc1.1.7.so] [string totitle tdbcodbc]]"
+} else {
+    package ifneeded tdbc::odbc 1.1.7 \
+	    "[list source [file join $dir tdbcodbc.tcl]]\;\
+	    [list load [file join $dir libtdbcodbc1.1.7.so] [string totitle tdbcodbc]]"
+}
diff --git a/mplug_owl2/lib/tdbcodbc1.1.7/tdbcodbc.tcl b/mplug_owl2/lib/tdbcodbc1.1.7/tdbcodbc.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..7bc68ba32343029fdc90be290c857e2f420351c5
--- /dev/null
+++ b/mplug_owl2/lib/tdbcodbc1.1.7/tdbcodbc.tcl
@@ -0,0 +1,554 @@
+# tdbcodbc.tcl --
+#
+#	Class definitions and Tcl-level methods for the tdbc::odbc bridge.
+#
+# Copyright (c) 2008 by Kevin B. Kenny
+# See the file "license.terms" for information on usage and redistribution
+# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+#
+# RCS: @(#) $Id: tdbcodbc.tcl,v 1.47 2008/02/27 02:08:27 kennykb Exp $
+#
+#------------------------------------------------------------------------------
+
+package require tdbc
+
+::namespace eval ::tdbc::odbc {
+
+    namespace export connection datasources drivers
+
+    # Data types that are predefined in ODBC
+
+    variable sqltypes [dict create \
+			   1 char \
+			   2 numeric \
+			   3 decimal \
+			   4 integer \
+			   5 smallint \
+			   6 float \
+			   7 real \
+			   8 double \
+			   9 datetime \
+			   12 varchar \
+			   91 date \
+			   92 time \
+			   93 timestamp \
+			   -1 longvarchar \
+			   -2 binary \
+			   -3 varbinary \
+			   -4 longvarbinary \
+			   -5 bigint \
+			   -6 tinyint \
+			   -7 bit \
+			   -8 wchar \
+			   -9 wvarchar \
+			   -10 wlongvarchar \
+			   -11 guid]
+}
+
+#------------------------------------------------------------------------------
+#
+# tdbc::odbc::connection --
+#
+#	Class representing a connection to a database through ODBC.
+#
+#-------------------------------------------------------------------------------
+
+::oo::class create ::tdbc::odbc::connection {
+
+    superclass ::tdbc::connection
+
+    variable statementSeq typemap
+
+    # The constructor is written in C. It takes the connection string
+    # as its argument It sets up a namespace to hold the statements
+    # associated with the connection, and then delegates to the 'init'
+    # method (written in C) to do the actual work of attaching to the
+    # database. When that comes back, it sets up a statement to query
+    # the support types, makes a dictionary to enumerate them, and
+    # calls back to set a flag if WVARCHAR is seen (If WVARCHAR is
+    # seen, the database supports Unicode.)
+
+    # The 'statementCreate' method forwards to the constructor of the
+    # statement class
+
+    forward statementCreate ::tdbc::odbc::statement create
+
+    # The 'tables' method returns a dictionary describing the tables
+    # in the database
+
+    method tables {{pattern %}} {
+	set stmt [::tdbc::odbc::tablesStatement create \
+		      Stmt::[incr statementSeq] [self] $pattern]
+       	set status [catch {
+	    set retval {}
+	    $stmt foreach -as dicts row {
+		if {[dict exists $row TABLE_NAME]} {
+		    dict set retval [dict get $row TABLE_NAME] $row
+		}
+	    }
+	    set retval
+	} result options]
+	catch {rename $stmt {}}
+	return -level 0 -options $options $result
+    }
+
+    # The 'columns' method returns a dictionary describing the tables
+    # in the database
+
+    method columns {table {pattern %}} {
+	# Make sure that the type map is initialized
+	my typemap
+
+	# Query the columns from the database
+
+	set stmt [::tdbc::odbc::columnsStatement create \
+		      Stmt::[incr statementSeq] [self] $table $pattern]
+	set status [catch {
+	    set retval {}
+	    $stmt foreach -as dicts origrow {
+
+		# Map the type, precision, scale and nullable indicators
+		# to tdbc's notation
+
+		set row {}
+		dict for {key value} $origrow {
+		    dict set row [string tolower $key] $value
+		}
+		if {[dict exists $row column_name]} {
+		    if {[dict exists $typemap \
+			     [dict get $row data_type]]} {
+			dict set row type \
+			    [dict get $typemap \
+				 [dict get $row data_type]]
+		    } else {
+			dict set row type [dict get $row type_name]
+		    }
+		    if {[dict exists $row column_size]} {
+			dict set row precision \
+			    [dict get $row column_size]
+		    }
+		    if {[dict exists $row decimal_digits]} {
+			dict set row scale \
+			    [dict get $row decimal_digits]
+		    }
+		    if {![dict exists $row nullable]} {
+			dict set row nullable \
+			    [expr {!![string trim [dict get $row is_nullable]]}]
+		    }
+		    dict set retval [dict get $row column_name] $row
+		}
+	    }
+	    set retval
+	} result options]
+	catch {rename $stmt {}}
+	return -level 0 -options $options $result
+    }
+
+    # The 'primarykeys' method returns a dictionary describing the primary
+    # keys of a table
+
+    method primarykeys {tableName} {
+	set stmt [::tdbc::odbc::primarykeysStatement create \
+		      Stmt::[incr statementSeq] [self] $tableName]
+       	set status [catch {
+	    set retval {}
+	    $stmt foreach -as dicts row {
+		foreach {odbcKey tdbcKey} {
+		    TABLE_CAT		tableCatalog
+		    TABLE_SCHEM		tableSchema
+		    TABLE_NAME		tableName
+		    COLUMN_NAME		columnName
+		    KEY_SEQ		ordinalPosition
+		    PK_NAME		constraintName
+		} {
+		    if {[dict exists $row $odbcKey]} {
+			dict set row $tdbcKey [dict get $row $odbcKey]
+			dict unset row $odbcKey
+		    }
+		}
+		lappend retval $row
+	    }
+	    set retval
+	} result options]
+	catch {rename $stmt {}}
+	return -level 0 -options $options $result
+    }
+
+    # The 'foreignkeys' method returns a dictionary describing the foreign
+    # keys of a table
+
+    method foreignkeys {args} {
+	set stmt [::tdbc::odbc::foreignkeysStatement create \
+		      Stmt::[incr statementSeq] [self] {*}$args]
+       	set status [catch {
+	    set fkseq 0
+	    set retval {}
+	    $stmt foreach -as dicts row {
+		foreach {odbcKey tdbcKey} {
+		    PKTABLE_CAT		primaryCatalog
+		    PKTABLE_SCHEM	primarySchema
+		    PKTABLE_NAME	primaryTable
+		    PKCOLUMN_NAME	primaryColumn
+		    FKTABLE_CAT		foreignCatalog
+		    FKTABLE_SCHEM	foreignSchema
+		    FKTABLE_NAME	foreignTable
+		    FKCOLUMN_NAME	foreignColumn
+		    UPDATE_RULE		updateRule
+		    DELETE_RULE		deleteRule
+		    DEFERRABILITY	deferrable
+		    KEY_SEQ		ordinalPosition
+		    FK_NAME		foreignConstraintName
+		} {
+		    if {[dict exists $row $odbcKey]} {
+			dict set row $tdbcKey [dict get $row $odbcKey]
+			dict unset row $odbcKey
+		    }
+		}
+		# Horrible kludge: If the driver doesn't report FK_NAME,
+		# make one up.
+		if {![dict exists $row foreignConstraintName]} {
+		    if {![dict exists $row ordinalPosition]
+			|| [dict get $row ordinalPosition] == 1} {
+			set fkname ?[dict get $row foreignTable]?[incr fkseq]
+		    }
+		    dict set row foreignConstraintName $fkname
+		}
+		lappend retval $row
+	    }
+	    set retval
+	} result options]
+	catch {rename $stmt {}}
+	return -level 0 -options $options $result
+    }
+
+    # The 'evaldirect' evaluates driver-native SQL code without preparing it,
+    # and returns a list of dicts (similar to '$connection allrows -as dicts').
+
+    method evaldirect {sqlStatement} {
+	set stmt [::tdbc::odbc::evaldirectStatement create \
+		      Stmt::[incr statementSeq] [self] $sqlStatement]
+       	set status [catch {
+	    $stmt allrows -as dicts
+	} result options]
+	catch {rename $stmt {}}
+	return -level 0 -options $options $result
+    }
+
+    # The 'prepareCall' method gives a portable interface to prepare
+    # calls to stored procedures.  It delegates to 'prepare' to do the
+    # actual work.
+
+    method preparecall {call} {
+
+	regexp {^[[:space:]]*(?:([A-Za-z_][A-Za-z_0-9]*)[[:space:]]*=)?(.*)} \
+	    $call -> varName rest
+	if {$varName eq {}} {
+	    my prepare \\{CALL $rest\\}
+	} else {
+	    my prepare \\{:$varName=CALL $rest\\}
+	}
+
+	if 0 {
+	# Kevin thinks this is going to be
+
+	if {![regexp -expanded {
+	    ^\s*				   # leading whitespace
+	    (?::([[:alpha:]_][[:alnum:]_]*)\s*=\s*) # possible variable name
+	    (?:(?:([[:alpha:]_][[:alnum:]_]*)\s*[.]\s*)?   # catalog
+	       ([[:alpha:]_][[:alnum:]_]*)\s*[.]\s*)?      # schema
+	    ([[:alpha:]_][[:alnum:]_]*)\s*		   # procedure
+	    (.*)$					   # argument list
+	} $call -> varName catalog schema procedure arglist]} {
+	    return -code error \
+		-errorCode [list TDBC \
+				SYNTAX_ERROR_OR_ACCESS_RULE_VIOLATION \
+				42000 ODBC -1] \
+		"Syntax error in stored procedure call"
+	} else {
+	    my PrepareCall $varName $catalog $schema $procedure $arglist
+	}
+
+	# at least if making all parameters 'inout' doesn't work.
+
+        }
+
+    }
+
+    # The 'typemap' method returns the type map
+
+    method typemap {} {
+	if {![info exists typemap]} {
+	    set typemap $::tdbc::odbc::sqltypes
+	    set typesStmt [tdbc::odbc::typesStatement new [self]]
+	    $typesStmt foreach row {
+		set typeNum [dict get $row DATA_TYPE]
+		if {![dict exists $typemap $typeNum]} {
+		    dict set typemap $typeNum [string tolower \
+						   [dict get $row TYPE_NAME]]
+		}
+		switch -exact -- $typeNum {
+		    -9 {
+			[self] HasWvarchar 1
+		    }
+		    -5 {
+			[self] HasBigint 1
+		    }
+		}
+	    }
+	    rename $typesStmt {}
+	}
+	return $typemap
+    }
+
+    # The 'begintransaction', 'commit' and 'rollback' methods are
+    # implemented in C.
+
+}
+
+#-------------------------------------------------------------------------------
+#
+# tdbc::odbc::statement --
+#
+#	The class 'tdbc::odbc::statement' models one statement against a
+#       database accessed through an ODBC connection
+#
+#-------------------------------------------------------------------------------
+
+::oo::class create ::tdbc::odbc::statement {
+
+    superclass ::tdbc::statement
+
+    # The constructor is implemented in C. It accepts the handle to
+    # the connection and the SQL code for the statement to prepare.
+    # It creates a subordinate namespace to hold the statement's
+    # active result sets, and then delegates to the 'init' method,
+    # written in C, to do the actual work of preparing the statement.
+
+    # The 'resultSetCreate' method forwards to the result set constructor
+
+    forward resultSetCreate ::tdbc::odbc::resultset create
+
+    # The 'params' method describes the parameters to the statement
+
+    method params {} {
+	set typemap [[my connection] typemap]
+	set result {}
+	foreach {name flags typeNum precision scale nullable} [my ParamList] {
+	    set lst [dict create \
+			 name $name \
+			 direction [lindex {unknown in out inout} \
+					[expr {($flags & 0x06) >> 1}]] \
+			 type [dict get $typemap $typeNum] \
+			 precision $precision \
+			 scale $scale]
+	    if {$nullable in {0 1}} {
+		dict set list nullable $nullable
+	    }
+	    dict set result $name $lst
+	}
+	return $result
+    }
+
+    # Methods implemented in C:
+    # init statement ?dictionary?
+    #     Does the heavy lifting for the constructor
+    # connection
+    #	Returns the connection handle to which this statement belongs
+    # paramtype paramname ?direction? type ?precision ?scale??
+    #     Declares the type of a parameter in the statement
+
+}
+
+#------------------------------------------------------------------------------
+#
+# tdbc::odbc::tablesStatement --
+#
+#	The class 'tdbc::odbc::tablesStatement' represents the special
+#	statement that queries the tables in a database through an ODBC
+#	connection.
+#
+#------------------------------------------------------------------------------
+
+oo::class create ::tdbc::odbc::tablesStatement {
+
+    superclass ::tdbc::statement
+
+    # The constructor is written in C. It accepts the handle to the
+    # connection and a pattern to match table names.  It works in all
+    # ways like the constructor of the 'statement' class except that
+    # its 'init' method sets up to enumerate tables and not run a SQL
+    # query.
+
+    # The 'resultSetCreate' method forwards to the result set constructor
+
+    forward resultSetCreate ::tdbc::odbc::resultset create
+
+}
+
+#------------------------------------------------------------------------------
+#
+# tdbc::odbc::columnsStatement --
+#
+#	The class 'tdbc::odbc::tablesStatement' represents the special
+#	statement that queries the columns of a table or view
+#	in a database through an ODBC connection.
+#
+#------------------------------------------------------------------------------
+
+oo::class create ::tdbc::odbc::columnsStatement {
+
+    superclass ::tdbc::statement
+
+    # The constructor is written in C. It accepts the handle to the
+    # connection, a table name, and a pattern to match column
+    # names. It works in all ways like the constructor of the
+    # 'statement' class except that its 'init' method sets up to
+    # enumerate tables and not run a SQL query.
+
+    # The 'resultSetCreate' class forwards to the constructor of the
+    # result set
+
+    forward resultSetCreate ::tdbc::odbc::resultset create
+
+}
+
+#------------------------------------------------------------------------------
+#
+# tdbc::odbc::primarykeysStatement --
+#
+#	The class 'tdbc::odbc::primarykeysStatement' represents the special
+#	statement that queries the primary keys on a table through an ODBC
+#	connection.
+#
+#------------------------------------------------------------------------------
+
+oo::class create ::tdbc::odbc::primarykeysStatement {
+
+    superclass ::tdbc::statement
+
+    # The constructor is written in C. It accepts the handle to the
+    # connection and a table name.  It works in all
+    # ways like the constructor of the 'statement' class except that
+    # its 'init' method sets up to enumerate primary keys and not run a SQL
+    # query.
+
+    # The 'resultSetCreate' method forwards to the result set constructor
+
+    forward resultSetCreate ::tdbc::odbc::resultset create
+
+}
+
+#------------------------------------------------------------------------------
+#
+# tdbc::odbc::foreignkeysStatement --
+#
+#	The class 'tdbc::odbc::foreignkeysStatement' represents the special
+#	statement that queries the foreign keys on a table through an ODBC
+#	connection.
+#
+#------------------------------------------------------------------------------
+
+oo::class create ::tdbc::odbc::foreignkeysStatement {
+
+    superclass ::tdbc::statement
+
+    # The constructor is written in C. It accepts the handle to the
+    # connection and the -primary and -foreign options.  It works in all
+    # ways like the constructor of the 'statement' class except that
+    # its 'init' method sets up to enumerate foreign keys and not run a SQL
+    # query.
+
+    # The 'resultSetCreate' method forwards to the result set constructor
+
+    forward resultSetCreate ::tdbc::odbc::resultset create
+
+}
+
+#------------------------------------------------------------------------------
+#
+# tdbc::odbc::evaldirectStatement --
+#
+#	The class 'tdbc::odbc::evaldirectStatement' provides a mechanism to
+#	execute driver-name SQL code through an ODBC connection.  The SQL code
+#	is not prepared and no tokenization or variable substitution is done.
+#
+#------------------------------------------------------------------------------
+
+oo::class create ::tdbc::odbc::evaldirectStatement {
+
+    superclass ::tdbc::statement
+
+    # The constructor is written in C. It accepts the handle to the
+    # connection and a SQL statement.  It works in all
+    # ways like the constructor of the 'statement' class except that
+    # its 'init' method does not tokenize or prepare the SQL statement, and
+    # sets up to run the SQL query without performing variable substitution.
+
+    # The 'resultSetCreate' method forwards to the result set constructor
+
+    forward resultSetCreate ::tdbc::odbc::resultset create
+
+}
+
+#------------------------------------------------------------------------------
+#
+# tdbc::odbc::typesStatement --
+#
+#	The class 'tdbc::odbc::typesStatement' represents the special
+#	statement that queries the types available in a database through
+#	an ODBC connection.
+#
+#------------------------------------------------------------------------------
+
+
+oo::class create ::tdbc::odbc::typesStatement {
+
+    superclass ::tdbc::statement
+
+    # The constructor is written in C. It accepts the handle to the
+    # connection, and (optionally) a data type number. It works in all
+    # ways like the constructor of the 'statement' class except that
+    # its 'init' method sets up to enumerate types and not run a SQL
+    # query.
+
+    # The 'resultSetCreate' method forwards to the constructor of result sets
+
+    forward resultSetCreate ::tdbc::odbc::resultset create
+
+    # The C code contains a variant implementation of the 'init' method.
+
+}
+
+#------------------------------------------------------------------------------
+#
+# tdbc::odbc::resultset --
+#
+#	The class 'tdbc::odbc::resultset' models the result set that is
+#	produced by executing a statement against an ODBC database.
+#
+#------------------------------------------------------------------------------
+
+::oo::class create ::tdbc::odbc::resultset {
+
+    superclass ::tdbc::resultset
+
+    # Methods implemented in C include:
+
+    # constructor statement ?dictionary?
+    #     -- Executes the statement against the database, optionally providing
+    #        a dictionary of substituted parameters (default is to get params
+    #        from variables in the caller's scope).
+    # columns
+    #     -- Returns a list of the names of the columns in the result.
+    # nextdict
+    #     -- Stores the next row of the result set in the given variable in
+    #        the caller's scope as a dictionary whose keys are
+    #        column names and whose values are column values.
+    # nextlist
+    #     -- Stores the next row of the result set in the given variable in
+    #        the caller's scope as a list of cells.
+    # rowcount
+    #     -- Returns a count of rows affected by the statement, or -1
+    #        if the count of rows has not been determined.
+
+}
diff --git a/mplug_owl2/lib/tk8.6/bgerror.tcl b/mplug_owl2/lib/tk8.6/bgerror.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..fe8dfe0410e2bc53a64dc89aa8b6c4f6542552f4
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/bgerror.tcl
@@ -0,0 +1,272 @@
+# 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.
+# Copyright (c) 2007 by ActiveState Software Inc.
+# Copyright (c) 2007 Daniel A. Steffen <das@users.sourceforge.net>
+# Copyright (c) 2009 Pat Thoyts <patthoyts@users.sourceforge.net>
+
+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]
+    option add *ErrorDialog*Label.font TkCaptionFont widgetDefault
+    if {[tk windowingsystem] eq "aqua"} {
+	option add *ErrorDialog*background systemAlertBackgroundActive \
+		widgetDefault
+	option add *ErrorDialog*info.text.background \
+	        systemTextBackgroundColor widgetDefault
+	option add *ErrorDialog*Button.highlightBackground \
+		systemAlertBackgroundActive widgetDefault
+    }
+}
+
+proc ::tk::dialog::error::Return {which code} {
+    variable button
+
+    .bgerrorDialog.$which state {active selected focus}
+    update idletasks
+    after 100
+    set button $code
+}
+
+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 [$w.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 {$filename ne {}} {
+        set f [open $filename w]
+        puts -nonewline $f $text
+        close $f
+    }
+    return
+}
+
+proc ::tk::dialog::error::Destroy {w} {
+    if {$w eq ".bgerrorDialog"} {
+	variable button
+	set button -1
+    }
+}
+
+proc ::tk::dialog::error::DeleteByProtocol {} {
+    variable button
+    set button 1
+}
+
+proc ::tk::dialog::error::ReturnInDetails w {
+    bind $w <Return> {}; # Remove this binding
+    $w invoke
+    return -code break
+}
+
+# ::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 {flag 1}} {
+    global errorInfo
+    variable button
+
+    set info $errorInfo
+
+    set ret [catch {::tkerror $err} msg];
+    if {$ret != 1} {return -code $ret $msg}
+
+    # The application's tkerror either failed or was not found
+    # so we use the default dialog.  But on Aqua we cannot display
+    # the dialog if the background error occurs in an idle task
+    # being processed inside of [NSView drawRect].  In that case
+    # we post the dialog as an after task instead.
+    set windowingsystem [tk windowingsystem]
+    if {$windowingsystem eq "aqua"} {
+	if $flag {
+	    set errorInfo $info
+	    after 500 [list bgerror "$err" 0]
+	    return
+	}
+    }
+
+    set ok [mc OK]
+    # Truncate the message if it is too wide (>maxLine characters) or
+    # too tall (>4 lines).  Truncation occurs at the first point at
+    # which one of those conditions is met.
+    set displayedErr ""
+    set lines 0
+    set maxLine 45
+    foreach line [split $err \n] {
+	if {[string length $line] > $maxLine} {
+	    append displayedErr "[string range $line 0 $maxLine-3]..."
+	    break
+	}
+	if {$lines > 4} {
+	    append displayedErr "..."
+	    break
+	} else {
+	    append displayedErr "${line}\n"
+	}
+	incr lines
+    }
+
+    set title [mc "Application Error"]
+    set text [mc "Error: %1\$s" $displayedErr]
+    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.
+
+    set dlg .bgerrorDialog
+    set bg [ttk::style lookup . -background]
+    destroy $dlg
+    toplevel $dlg -class ErrorDialog -background $bg
+    wm withdraw $dlg
+    wm title $dlg $title
+    wm iconname $dlg ErrorDialog
+    wm protocol $dlg WM_DELETE_WINDOW [namespace code DeleteByProtocol]
+
+    if {$windowingsystem eq "aqua"} {
+	::tk::unsupported::MacWindowStyle style $dlg moveableAlert {}
+    } elseif {$windowingsystem eq "x11"} {
+	wm attributes $dlg -type dialog
+    }
+
+    ttk::frame $dlg.bot
+    ttk::frame $dlg.top
+    pack $dlg.bot -side bottom -fill both
+    pack $dlg.top -side top -fill both -expand 1
+
+    set W [ttk::frame $dlg.top.info]
+    text $W.text -setgrid true -height 10 -wrap char \
+	-yscrollcommand [list $W.scroll set]
+    if {$windowingsystem ne "aqua"} {
+	$W.text configure -width 40
+    }
+
+    ttk::scrollbar $W.scroll -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 <Button-1> {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 $dlg]
+    # ...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 $dlg 9m]}]
+    ttk::label $dlg.msg -justify left -text $text -wraplength $wrapwidth
+    ttk::label $dlg.bitmap -image ::tk::icons::error
+
+    grid $dlg.bitmap $dlg.msg -in $dlg.top -row 0 -padx 3m -pady 3m
+    grid configure       $dlg.bitmap -sticky ne
+    grid configure	 $dlg.msg -sticky nsw -padx {0 3m}
+    grid rowconfigure	 $dlg.top 1 -weight 1
+    grid columnconfigure $dlg.top 1 -weight 1
+
+    # 3. Create a row of buttons at the bottom of the dialog.
+
+    set i 0
+    foreach {name caption} $buttons {
+	ttk::button $dlg.$name -text $caption -default normal \
+	    -command [namespace code [list set button $i]]
+	grid $dlg.$name -in $dlg.bot -column $i -row 0 -sticky ew -padx 10
+	grid columnconfigure $dlg.bot $i -weight 1
+	# We boost the size of some Mac buttons for l&f
+	if {$windowingsystem eq "aqua"} {
+	    if {($name eq "ok") || ($name eq "dismiss")} {
+		grid columnconfigure $dlg.bot $i -minsize 90
+	    }
+	    grid configure $dlg.$name -pady 7
+	}
+	incr i
+    }
+    # The "OK" button is the default for this dialog.
+    $dlg.ok configure -default active
+
+    bind $dlg <Return>	[namespace code {Return ok 0}]
+    bind $dlg <Escape>	[namespace code {Return dismiss 1}]
+    bind $dlg <Destroy>	[namespace code {Destroy %W}]
+    bind $dlg.function <Return>	[namespace code {ReturnInDetails %W}]
+    $dlg.function configure -command [namespace code Details]
+
+    # 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 (Motif style) and de-iconify it.
+
+    ::tk::PlaceWindow $dlg
+
+    # 7. Set a grab and claim the focus too.
+
+    ::tk::SetFocusGrab $dlg $dlg.ok
+
+    # 8. Ensure that we are topmost.
+
+    raise $dlg
+    if {[tk windowingsystem] eq "win32"} {
+	# 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 "$dlg"} {
+	    wm attributes $dlg -topmost 1
+        }
+    }
+
+    # 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 $dlg $dlg.ok destroy
+
+    if {$copy == 1} {
+	return -code break
+    }
+}
+
+namespace eval :: {
+    # Fool the indexer
+    proc bgerror err {}
+    rename bgerror {}
+    namespace import ::tk::dialog::error::bgerror
+}
diff --git a/mplug_owl2/lib/tk8.6/button.tcl b/mplug_owl2/lib/tk8.6/button.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..9b13607710a078ed34458ad8179f1d80c2a2d9c5
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/button.tcl
@@ -0,0 +1,782 @@
+# 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.
+#
+# 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 {[tk windowingsystem] eq "aqua"} {
+
+    bind Radiobutton <Enter> {
+	tk::ButtonEnter %W
+    }
+    bind Radiobutton <1> {
+	tk::ButtonDown %W
+    }
+    bind Radiobutton <ButtonRelease-1> {
+	tk::ButtonUp %W
+    }
+    bind Checkbutton <Enter> {
+	tk::ButtonEnter %W
+    }
+    bind Checkbutton <1> {
+	tk::ButtonDown %W
+    }
+    bind Checkbutton <ButtonRelease-1> {
+	tk::ButtonUp %W
+    }
+    bind Checkbutton <Leave> {
+	tk::ButtonLeave %W
+    }
+}
+if {"win32" eq [tk windowingsystem]} {
+    bind Checkbutton <equal> {
+	tk::CheckRadioInvoke %W select
+    }
+    bind Checkbutton <plus> {
+	tk::CheckRadioInvoke %W select
+    }
+    bind Checkbutton <minus> {
+	tk::CheckRadioInvoke %W deselect
+    }
+    bind Checkbutton <1> {
+	tk::CheckRadioDown %W
+    }
+    bind Checkbutton <ButtonRelease-1> {
+	tk::ButtonUp %W
+    }
+    bind Checkbutton <Enter> {
+	tk::CheckRadioEnter %W
+    }
+    bind Checkbutton <Leave> {
+	tk::ButtonLeave %W
+    }
+
+    bind Radiobutton <1> {
+	tk::CheckRadioDown %W
+    }
+    bind Radiobutton <ButtonRelease-1> {
+	tk::ButtonUp %W
+    }
+    bind Radiobutton <Enter> {
+	tk::CheckRadioEnter %W
+    }
+}
+if {"x11" eq [tk windowingsystem]} {
+    bind Checkbutton <Return> {
+	if {!$tk_strictMotif} {
+	    tk::CheckInvoke %W
+	}
+    }
+    bind Radiobutton <Return> {
+	if {!$tk_strictMotif} {
+	    tk::CheckRadioInvoke %W
+	}
+    }
+    bind Checkbutton <1> {
+	tk::CheckInvoke %W
+    }
+    bind Radiobutton <1> {
+	tk::CheckRadioInvoke %W
+    }
+    bind Checkbutton <Enter> {
+	tk::CheckEnter %W
+    }
+    bind Radiobutton <Enter> {
+	tk::ButtonEnter %W
+    }
+    bind Checkbutton <Leave> {
+	tk::CheckLeave %W
+    }
+}
+
+bind Button <space> {
+    tk::ButtonInvoke %W
+}
+bind Checkbutton <space> {
+    tk::CheckRadioInvoke %W
+}
+bind Radiobutton <space> {
+    tk::CheckRadioInvoke %W
+}
+bind Button <<Invoke>> {
+    tk::ButtonInvoke %W
+}
+bind Checkbutton <<Invoke>> {
+    tk::CheckRadioInvoke %W
+}
+bind Radiobutton <<Invoke>> {
+    tk::CheckRadioInvoke %W
+}
+
+bind Button <FocusIn> {}
+bind Button <Enter> {
+    tk::ButtonEnter %W
+}
+bind Button <Leave> {
+    tk::ButtonLeave %W
+}
+bind Button <1> {
+    tk::ButtonDown %W
+}
+bind Button <ButtonRelease-1> {
+    tk::ButtonUp %W
+}
+
+bind Checkbutton <FocusIn> {}
+
+bind Radiobutton <FocusIn> {}
+bind Radiobutton <Leave> {
+    tk::ButtonLeave %W
+}
+
+if {"win32" eq [tk windowingsystem]} {
+
+#########################
+# 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 {"x11" eq [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 {$w eq $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 {[tk windowingsystem] eq "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 {[winfo exists $w] && [$w cget -state] ne "disabled"} {
+	set oldRelief [$w cget -relief]
+	set oldState [$w cget -state]
+	$w configure -state active -relief sunken
+	after 100 [list ::tk::ButtonInvokeEnd $w $oldState $oldRelief]
+    }
+}
+
+# ::tk::ButtonInvokeEnd --
+# The procedure below is called after a button is invoked through
+# the keyboard.  It simulate a release of the button via the mouse.
+#
+# Arguments:
+# w -         The name of the widget.
+# oldState -  Old state to be set back.
+# oldRelief - Old relief to be set back.
+
+proc ::tk::ButtonInvokeEnd {w oldState oldRelief} {
+    if {[winfo exists $w]} {
+	$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]
+    }
+}
+
+# Special versions of the handlers for checkbuttons on Unix that do the magic
+# to make things work right when the checkbutton indicator is hidden;
+# radiobuttons don't need this complexity.
+
+# ::tk::CheckInvoke --
+# The procedure below invokes the checkbutton, like ButtonInvoke, but handles
+# what to do when the checkbutton indicator is missing. Only used on Unix.
+#
+# Arguments:
+# w -		The name of the widget.
+
+proc ::tk::CheckInvoke {w} {
+    variable ::tk::Priv
+    if {[$w cget -state] ne "disabled"} {
+	# Additional logic to switch the "selected" colors around if necessary
+	# (when we're indicator-less).
+
+	if {![$w cget -indicatoron] && [info exist Priv($w,selectcolor)]} {
+	    if {[$w cget -selectcolor] eq $Priv($w,aselectcolor)} {
+		$w configure -selectcolor $Priv($w,selectcolor)
+	    } else {
+		$w configure -selectcolor $Priv($w,aselectcolor)
+	    }
+	}
+	uplevel #0 [list $w invoke]
+    }
+}
+
+# ::tk::CheckEnter --
+# The procedure below enters the checkbutton, like ButtonEnter, but handles
+# what to do when the checkbutton indicator is missing. Only used on Unix.
+#
+# Arguments:
+# w -		The name of the widget.
+
+proc ::tk::CheckEnter {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
+	}
+
+	# Compute what the "selected and active" color should be.
+
+	if {![$w cget -indicatoron] && [$w cget -selectcolor] ne ""} {
+	    set Priv($w,selectcolor) [$w cget -selectcolor]
+	    lassign [winfo rgb $w [$w cget -selectcolor]]      r1 g1 b1
+	    lassign [winfo rgb $w [$w cget -activebackground]] r2 g2 b2
+	    set Priv($w,aselectcolor) \
+		[format "#%04x%04x%04x" [expr {($r1+$r2)/2}] \
+		     [expr {($g1+$g2)/2}] [expr {($b1+$b2)/2}]]
+	    # use uplevel to work with other var resolvers
+	    if {[uplevel #0 [list set [$w cget -variable]]]
+		 eq [$w cget -onvalue]} {
+		$w configure -selectcolor $Priv($w,aselectcolor)
+	    }
+	}
+    }
+    set Priv(window) $w
+}
+
+# ::tk::CheckLeave --
+# The procedure below leaves the checkbutton, like ButtonLeave, but handles
+# what to do when the checkbutton indicator is missing. Only used on Unix.
+#
+# Arguments:
+# w -		The name of the widget.
+
+proc ::tk::CheckLeave {w} {
+    variable ::tk::Priv
+    if {[$w cget -state] ne "disabled"} {
+	$w configure -state normal
+    }
+
+    # Restore the original button "selected" color; but only if the user
+    # has not changed it in the meantime.
+
+    if {![$w cget -indicatoron] && [info exist Priv($w,selectcolor)]} {
+        if {[$w cget -selectcolor] eq $Priv($w,selectcolor)
+                || ([info exist Priv($w,aselectcolor)] &&
+                    [$w cget -selectcolor] eq $Priv($w,aselectcolor))} {
+	    $w configure -selectcolor $Priv($w,selectcolor)
+	}
+    }
+    unset -nocomplain Priv($w,selectcolor) Priv($w,aselectcolor)
+
+    # 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) ""
+}
+
+return
+
+# Local Variables:
+# mode: tcl
+# fill-column: 78
+# End:
diff --git a/mplug_owl2/lib/tk8.6/choosedir.tcl b/mplug_owl2/lib/tk8.6/choosedir.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..33a66b19b3d9a77b8d794c1eb95e86e8ecd01bc2
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/choosedir.tcl
@@ -0,0 +1,310 @@
+# choosedir.tcl --
+#
+#	Choose directory dialog implementation for Unix/Mac.
+#
+# Copyright (c) 1998-2000 by Scriptics Corporation.
+# All rights reserved.
+
+# 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 -force ::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
+    Config $dataName $args
+
+    if {$data(-parent) eq "."} {
+        set w .$dataName
+    } else {
+        set w $data(-parent).$dataName
+    }
+
+    # (re)create the dialog box if necessary
+    #
+    if {![winfo exists $w]} {
+	::tk::dialog::file::Create $w TkChooseDir
+    } elseif {[winfo class $w] ne "TkChooseDir"} {
+	destroy $w
+	::tk::dialog::file::Create $w TkChooseDir
+    } else {
+	set data(dirMenuBtn) $w.contents.f1.menu
+	set data(dirMenu) $w.contents.f1.menu.menu
+	set data(upBtn) $w.contents.f1.up
+	set data(icons) $w.contents.icons
+	set data(ent) $w.contents.f2.ent
+	set data(okBtn) $w.contents.f2.ok
+	set data(cancelBtn) $w.contents.f2.cancel
+	set data(hiddenBtn) $w.contents.f2.hidden
+    }
+    if {$::tk::dialog::file::showHiddenBtn} {
+	$data(hiddenBtn) configure -state normal
+	grid $data(hiddenBtn)
+    } else {
+	$data(hiddenBtn) configure -state disabled
+	grid remove $data(hiddenBtn)
+    }
+
+    # When using -mustexist, manage the OK button state for validity
+    $data(okBtn) configure -state normal
+    if {$data(-mustexist)} {
+	$data(ent) configure -validate key \
+	    -validatecommand [list ::tk::dialog::file::chooseDir::IsOK? $w %P]
+    } else {
+	$data(ent) configure -validate none
+    }
+
+    # 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 add variable data(selectPath) write \
+	    [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 (Motif style) and de-iconify it.
+
+    ::tk::PlaceWindow $w widget $data(-parent)
+    wm title $w $data(-title)
+
+    # Set a grab and claim the focus too.
+
+    ::tk::SetFocusGrab $w $data(ent)
+    $data(ent) delete 0 end
+    $data(ent) insert 0 $data(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 info variable data(selectPath)] {
+	trace remove variable data(selectPath) [lindex $trace 0] [lindex $trace 1]
+    }
+    if {[winfo exists $data(dirMenuBtn)]} {
+	$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 info variable data(selectPath)] {
+	trace remove variable 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) eq ""} {
+	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) ne ""} {
+	# Ensure that initialdir is an absolute path name.
+	if {[file isdirectory $data(-initialdir)]} {
+	    set old [pwd]
+	    cd $data(-initialdir)
+	    set data(selectPath) [pwd]
+	    cd $old
+	} else {
+	    set data(selectPath) [pwd]
+	}
+    }
+
+    if {![winfo exists $data(-parent)]} {
+	return -code error -errorcode [list TK LOOKUP WINDOW $data(-parent)] \
+	    "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 [$data(icons) selection get]
+    if {[llength $selection] != 0} {
+	set iconText [$data(icons) get [lindex $selection 0]]
+	set iconText [file join $data(selectPath) $iconText]
+	Done $w $iconText
+    } else {
+	set text [$data(ent) get]
+	if {$text eq ""} {
+	    return
+	}
+	set text [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 {$text eq $data(previousEntryText)} {
+		set data(previousEntryText) ""
+		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 {$text eq $data(selectPath)} {
+		Done $w $text
+	    } else {
+		set data(selectPath) $text
+	    }
+	}
+    }
+    return
+}
+
+# Change state of OK button to match -mustexist correctness of entry
+#
+proc ::tk::dialog::file::chooseDir::IsOK? {w text} {
+    upvar ::tk::dialog::file::[winfo name $w] data
+
+    set ok [file isdirectory $text]
+    $data(okBtn) configure -state [expr {$ok ? "normal" : "disabled"}]
+
+    # always return 1
+    return 1
+}
+
+proc ::tk::dialog::file::chooseDir::DblClick {w} {
+    upvar ::tk::dialog::file::[winfo name $w] data
+    set selection [$data(icons) selection get]
+    if {[llength $selection] != 0} {
+	set filenameFragment [$data(icons) get [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 {$text eq ""} {
+	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 {$selectFilePath eq ""} {
+	set selectFilePath $data(selectPath)
+    }
+    if {$data(-mustexist) && ![file isdirectory $selectFilePath]} {
+	return
+    }
+    set Priv(selectFilePath) $selectFilePath
+}
diff --git a/mplug_owl2/lib/tk8.6/clrpick.tcl b/mplug_owl2/lib/tk8.6/clrpick.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..cc38005c74fa4a9067520b85e4460ec0e4a71bb0
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/clrpick.tcl
@@ -0,0 +1,694 @@
+# clrpick.tcl --
+#
+#	Color selection dialog for platforms that do not support a
+#	standard color selection dialog.
+#
+# 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 || $sc ne [winfo screen $w]} {
+	if {$winExists} {
+	    destroy $w
+	}
+	toplevel $w -class TkColorDialog -screen $sc
+	if {[tk windowingsystem] eq "x11"} {wm attributes $w -type dialog}
+	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 (Motif style) 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)
+    set result $Priv(selectColor)
+    ::tk::RestoreFocusGrab $w $data(okBtn)
+    unset data
+
+    return $result
+}
+
+# ::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)] && $Priv(selectColor) ne ""} {
+	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 {$data(-title) eq ""} {
+	set data(-title) " "
+    }
+    if {[catch {winfo rgb . $data(-initialcolor)} err]} {
+	return -code error -errorcode [list TK LOOKUP COLOR $data(-initialcolor)] \
+	    $err
+    }
+
+    if {![winfo exists $data(-parent)]} {
+	return -code error -errorcode [list TK LOOKUP WINDOW $data(-parent)] \
+	    "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 {
+	red   "&Red"
+	green "&Green"
+	blue  "&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]
+
+	::tk::AmpWidget label $box.label -text "[mc $l]:" \
+		-width $maxWidth -anchor ne
+	bind $box.label <<AltUnderlined>> [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) <Configure> \
+		[list tk::dialog::color::DrawColorScale $w $color 1]
+	bind $data($color,col) <Enter> \
+		[list tk::dialog::color::EnterColorBar $w $color]
+	bind $data($color,col) <Leave> \
+		[list tk::dialog::color::LeaveColorBar $w $color]
+
+	bind $data($color,sel) <Enter> \
+		[list tk::dialog::color::EnterColorBar $w $color]
+	bind $data($color,sel) <Leave> \
+		[list tk::dialog::color::LeaveColorBar $w $color]
+
+	bind $box.entry <Return> [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 <Return> [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 <<AltUnderlined>> [list focus $ent]
+    bind $w <Escape> [list tk::ButtonInvoke $data(cancelBtn)]
+    bind $w <Alt-Key> [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 {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) <Button-1> \
+		[list tk::dialog::color::StartMove $w $sel $c %x $data(selPad) 1]
+	$sel bind $data($c,index) <B1-Motion> \
+		[list tk::dialog::color::MoveSelector $w $sel $c %x $data(selPad)]
+	$sel bind $data($c,index) <ButtonRelease-1> \
+		[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 <Button-1> \
+		[list tk::dialog::color::StartMove $w $sel $c %x $data(colorPad)]
+	bind $col <B1-Motion> \
+		[list tk::dialog::color::MoveSelector $w $sel $c %x $data(colorPad)]
+	bind $col <ButtonRelease-1> \
+		[list tk::dialog::color::ReleaseMouse $w $sel $c %x $data(colorPad)]
+
+	$sel bind $data($c,clickRegion) <Button-1> \
+		[list tk::dialog::color::StartMove $w $sel $c %x $data(selPad)]
+	$sel bind $data($c,clickRegion) <B1-Motion> \
+		[list tk::dialog::color::MoveSelector $w $sel $c %x $data(selPad)]
+	$sel bind $data($c,clickRegion) <ButtonRelease-1> \
+		[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 {$c eq "red"} {
+	    set color [format "#%02x%02x%02x" \
+		    $intensity $data(green,intensity) $data(blue,intensity)]
+	} elseif {$c eq "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)
+    } then {
+	set data(BARS_WIDTH) $data(NUM_COLORBARS)
+    }
+    InitValues [winfo name $w]
+    foreach color {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 {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) itemconfigure $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) itemconfigure $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 or destroys window
+#
+proc ::tk::dialog::color::CancelCmd {w} {
+    variable ::tk::Priv
+    set Priv(selectColor) ""
+}
diff --git a/mplug_owl2/lib/tk8.6/comdlg.tcl b/mplug_owl2/lib/tk8.6/comdlg.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..b4d89785423050c49045b453893ca51316072ac5
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/comdlg.tcl
@@ -0,0 +1,322 @@
+# comdlg.tcl --
+#
+#	Some functions needed for the common dialog boxes. Probably need to go
+#	in a different file.
+#
+# 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 = a list of flags. Currently supported flags are:
+#     DONTSETDEFAULTS = skip default values setting
+#
+# 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} {
+	    return -code error -errorcode {TK VALUE CONFIG_SPEC} \
+		"\"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)]} {
+	    return -code error -errorcode [list TK LOOKUP OPTION $cmdsw] \
+		"bad option \"$cmdsw\": must be [tclListValidFlags cmd]"
+	}
+	return -code error -errorcode {TK VALUE_MISSING} \
+	    "value for \"$cmdsw\" missing"
+    }
+
+    # 2: set the default values
+    #
+    if {"DONTSETDEFAULTS" ni $flags} {
+        foreach cmdsw [array names cmd] {
+	    set data($cmdsw) $def($cmdsw)
+        }
+    }
+
+    # 3: parse the argument list
+    #
+    foreach {cmdsw value} $argList {
+	if {![info exists cmd($cmdsw)]} {
+	    return -code error -errorcode [list TK LOOKUP OPTION $cmdsw] \
+		"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 {[winfo toplevel $t] ne $t} {
+	return -code error -errorcode [list TK LOOKUP TOPLEVEL $t] \
+	    "$t is not a toplevel window"
+    }
+    if {![info exists Priv(fg,$t)]} {
+	set Priv(fg,$t) 1
+	set Priv(focus,$t) ""
+	bind $t <FocusIn>  [list tk::FocusGroup_In  $t %W %d]
+	bind $t <FocusOut> [list tk::FocusGroup_Out $t %W %d]
+	bind $t <Destroy>  [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)]} {
+	return -code error -errorcode [list TK LOOKUP FOCUS_GROUP $t] \
+	    "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)]} {
+	return -code error -errorcode [list TK LOOKUP FOCUS_GROUP $t] \
+	    "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 {$t eq $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)] && ($Priv(focus,$t) eq $w)} {
+	    set Priv(focus,$t) ""
+	}
+	unset -nocomplain FocusIn($t,$w) FocusOut($t,$w)
+    }
+}
+
+# ::tk::FocusGroup_In --
+#
+#	Handles the <FocusIn> 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 {$detail ne "NotifyNonlinear" && $detail ne "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 {$Priv(focus,$t) eq $w} {
+	# This is already in focus
+	#
+	return
+    } else {
+	set Priv(focus,$t) $w
+	eval $FocusIn($t,$w)
+    }
+}
+
+# ::tk::FocusGroup_Out --
+#
+#	Handles the <FocusOut> 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 {$detail ne "NotifyNonlinear" && $detail ne "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} {
+	    return -code error -errorcode {TK VALUE FILE_TYPE} \
+		"bad file type \"$t\", should be \"typeName {extension ?extensions ...?} ?{macType ?macTypes ...?}?\""
+	}
+	lappend 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
+	}
+
+	# Validate each macType.  This is to agree with the
+	# behaviour of TkGetFileFilters().  This list may be
+	# empty.
+	foreach macType [lindex $t 2] {
+	    if {[string length $macType] != 4} {
+		return -code error -errorcode {TK VALUE MAC_TYPE} \
+		    "bad Macintosh file type \"$macType\""
+	    }
+	}
+
+	set name "$label \("
+	set sep ""
+	set doAppend 1
+	foreach ext $fileTypes($label) {
+	    if {$ext eq ""} {
+		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
+}
diff --git a/mplug_owl2/lib/tk8.6/console.tcl b/mplug_owl2/lib/tk8.6/console.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..d73b2f5c81b883d391367d8c4059ad9d04e4541a
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/console.tcl
@@ -0,0 +1,1154 @@
+# 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.
+#
+# Copyright (c) 1995-1997 Sun Microsystems, Inc.
+# Copyright (c) 1998-2000 Ajuba Solutions.
+# Copyright (c) 2007-2008 Daniel A. Steffen <das@users.sourceforge.net>
+#
+# 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 useFontchooser [llength [info command ::tk::fontchooser]]
+    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 {} {
+    if {![consoleinterp eval {set tcl_interactive}]} {
+	wm withdraw .
+    }
+
+    if {[tk windowingsystem] eq "aqua"} {
+	set mod "Cmd"
+    } else {
+	set mod "Ctrl"
+    }
+
+    if {[catch {menu .menubar} err]} {
+	bgerror "INIT: $err"
+    }
+    AmpMenuArgs .menubar add cascade -label [mc &File] -menu .menubar.file
+    AmpMenuArgs .menubar add cascade -label [mc &Edit] -menu .menubar.edit
+
+    menu .menubar.file -tearoff 0
+    AmpMenuArgs .menubar.file add command -label [mc "&Source..."] \
+	    -command {tk::ConsoleSource}
+    AmpMenuArgs .menubar.file add command -label [mc "&Hide Console"] \
+	    -command {wm withdraw .}
+    AmpMenuArgs .menubar.file add command -label [mc "&Clear Console"] \
+	    -command {.console delete 1.0 "promptEnd linestart"}
+    if {[tk windowingsystem] ne "aqua"} {
+	AmpMenuArgs .menubar.file add command -label [mc E&xit] -command {exit}
+    }
+
+    menu .menubar.edit -tearoff 0
+    AmpMenuArgs	.menubar.edit add command -label [mc Cu&t]   -accel "$mod+X"\
+	    -command {event generate .console <<Cut>>}
+    AmpMenuArgs	.menubar.edit add command -label [mc &Copy]  -accel "$mod+C"\
+	    -command {event generate .console <<Copy>>}
+    AmpMenuArgs	.menubar.edit add command -label [mc P&aste] -accel "$mod+V"\
+	    -command {event generate .console <<Paste>>}
+
+    if {[tk windowingsystem] ne "win32"} {
+	AmpMenuArgs .menubar.edit add command -label [mc Cl&ear] \
+		-command {event generate .console <<Clear>>}
+    } else {
+	AmpMenuArgs .menubar.edit add command -label [mc &Delete] \
+		-command {event generate .console <<Clear>>} -accel "Del"
+
+	AmpMenuArgs .menubar add cascade -label [mc &Help] -menu .menubar.help
+	menu .menubar.help -tearoff 0
+	AmpMenuArgs .menubar.help add command -label [mc &About...] \
+		-command tk::ConsoleAbout
+    }
+
+    AmpMenuArgs .menubar.edit add separator
+    if {$::tk::console::useFontchooser} {
+	if {[tk windowingsystem] eq "aqua"} {
+	    .menubar.edit add command -label tk_choose_font_marker
+	    set index [.menubar.edit index tk_choose_font_marker]
+	    .menubar.edit entryconfigure $index \
+		-label [mc "Show Fonts"]\
+		-accelerator "$mod-T"\
+		-command [list ::tk::console::FontchooserToggle]
+	    bind Console <<TkFontchooserVisibility>> \
+		[list ::tk::console::FontchooserVisibility $index]
+	    ::tk::console::FontchooserVisibility $index
+	} else {
+	    AmpMenuArgs .menubar.edit add command -label [mc "&Font..."] \
+		-command [list ::tk::console::FontchooserToggle]
+	}
+	bind Console <FocusIn>  [list ::tk::console::FontchooserFocus %W 1]
+	bind Console <FocusOut> [list ::tk::console::FontchooserFocus %W 0]
+    }
+    AmpMenuArgs .menubar.edit add command -label [mc "&Increase Font Size"] \
+	-accel "$mod++" -command {event generate .console <<Console_FontSizeIncr>>}
+    AmpMenuArgs .menubar.edit add command -label [mc "&Decrease Font Size"] \
+	-accel "$mod+-" -command {event generate .console <<Console_FontSizeDecr>>}
+    AmpMenuArgs .menubar.edit add command -label [mc "Fit To Screen Width"] \
+	-command {event generate .console <<Console_FitScreenWidth>>}
+
+    if {[tk windowingsystem] eq "aqua"} {
+	.menubar add cascade -label [mc Window] -menu [menu .menubar.window]
+	.menubar add cascade -label [mc Help] -menu [menu .menubar.help]
+    }
+
+    . configure -menu .menubar
+
+    # See if we can find a better font than the TkFixedFont
+    catch {font create TkConsoleFont {*}[font configure TkFixedFont]}
+    set families [font families]
+    switch -exact -- [tk windowingsystem] {
+	aqua { set preferred {Monaco 10} }
+	win32 { set preferred {ProFontWindows 8 Consolas 8} }
+	default { set preferred {} }
+    }
+    foreach {family size} $preferred {
+	if {$family in $families} {
+	    font configure TkConsoleFont -family $family -size $size
+	    break
+	}
+    }
+
+    # Provide the right border for the text widget (platform dependent).
+    ::ttk::style layout ConsoleFrame {
+	Entry.field -sticky news -border 1 -children {
+	    ConsoleFrame.padding -sticky news
+	}
+    }
+    ::ttk::frame .consoleframe -style ConsoleFrame
+
+    set con [text .console -yscrollcommand [list .sb set] -setgrid true \
+		 -borderwidth 0 -highlightthickness 0 -font TkConsoleFont]
+    if {[tk windowingsystem] eq "aqua"} {
+	scrollbar .sb -command [list $con yview]
+    } else {
+	::ttk::scrollbar .sb -command [list $con yview]
+    }
+    pack .sb  -in .consoleframe -fill both -side right -padx 1 -pady 1
+    pack $con -in .consoleframe -fill both -expand 1 -side left -padx 1 -pady 1
+    pack .consoleframe -fill both -expand 1 -side left
+
+    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
+
+    # Avoid listing this console in [winfo interps]
+    if {[info command ::send] eq "::send"} {rename ::send {}}
+
+    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
+
+    # A variant of ConsolePrompt to avoid a 'puts' call
+    set w $con
+    set temp [$w index "end - 1 char"]
+    $w mark set output end
+    if {![consoleinterp eval "info exists tcl_prompt1"]} {
+	set string [EvalAttached $::tk::console::defaultPrompt]
+	$w insert output $string stdout
+    }
+    $w mark set output $temp
+    ::tk::TextSetCursor $w end
+    $w mark set promptEnd insert
+    $w mark gravity promptEnd left
+
+    if {[tk windowingsystem] ne "aqua"} {
+	# Subtle work-around to erase the '% ' that tclMain.c prints out
+	after idle [subst -nocommand {
+	    if {[$con get 1.0 output] eq "% "} { $con delete 1.0 output }
+	}]
+    }
+}
+
+# ::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 {$filename ne ""} {
+	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 {[lindex $ranges $pos] ne ""} {
+	    set start [lindex $ranges $pos]
+	    set end [lindex $ranges [incr pos]]
+	    append cmd [.console get $start $end]
+	    incr pos
+	}
+    }
+    if {$cmd eq ""} {
+	ConsolePrompt
+    } elseif {[info complete $cmd]} {
+	.console mark set output end
+	.console tag delete input
+	set result [consoleinterp record $cmd]
+	if {$result ne ""} {
+	    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}
+	    .console see end
+	}
+	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 {$cmd ne ""} {
+		catch {consoleinterp eval $cmd} cmd
+	    }
+	    .console delete promptEnd end
+	    .console insert promptEnd $cmd {input stdin}
+	    .console see end
+	}
+	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 {$partial eq "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
+}
+
+# Copy selected text from the console
+proc ::tk::console::Copy {w} {
+    if {![catch {set data [$w get sel.first sel.last]}]} {
+	clipboard clear -displayof $w
+	clipboard append -displayof $w $data
+    }
+}
+# Copies selected text. If the selection is within the current active edit
+# region then it will be cut, if not it is only copied.
+proc ::tk::console::Cut {w} {
+    if {![catch {set data [$w get sel.first sel.last]}]} {
+	clipboard clear -displayof $w
+	clipboard append -displayof $w $data
+	if {[$w compare sel.first >= output]} {
+	    $w delete sel.first sel.last
+	}
+    }
+}
+# Paste text from the clipboard
+proc ::tk::console::Paste {w} {
+    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
+	}
+    }
+}
+
+# Fit TkConsoleFont to window width
+proc ::tk::console::FitScreenWidth {w} {
+    set width [winfo screenwidth $w]
+    set cwidth [$w cget -width]
+    set s -50
+    set fit 0
+    array set fi [font configure TkConsoleFont]
+    while {$s < 0} {
+	set fi(-size) $s
+	set f [font create {*}[array get fi]]
+	set c [font measure $f "eM"]
+	font delete $f
+	if {$c * $cwidth < 1.667 * $width} {
+	    font configure TkConsoleFont -size $s
+	    break
+	}
+	incr s 2
+    }
+}
+
+# ::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 <Control-o> {}
+    ## ...or any Control-v binding (would block <<Paste>>)
+    bind Console <Control-v> {}
+
+    # For the moment, transpose isn't enabled until the console
+    # gets and overhaul of how it handles input -- hobbs
+    bind Console <Control-t> {}
+
+    # Ignore all Alt, Meta, and Control keypresses unless explicitly bound.
+    # Otherwise, if a widget binding for one of these is defined, the
+    # <Keypress> class binding will also fire and insert the character
+    # which is wrong.
+
+    bind Console <Alt-Key> {# nothing }
+    bind Console <Meta-Key> {# nothing}
+    bind Console <Control-Key> {# nothing}
+    if {[tk windowingsystem] eq "aqua"} {
+	bind Console <Command-Key> {# nothing}
+	bind Console <Mod4-Key> {# nothing}
+    }
+
+    foreach {ev key} {
+	<<Console_NextImmediate>>	<Control-n>
+	<<Console_PrevImmediate>>	<Control-p>
+	<<Console_PrevSearch>>		<Control-r>
+	<<Console_NextSearch>>		<Control-s>
+
+	<<Console_Expand>>		<Tab>
+	<<Console_Expand>>		<Escape>
+	<<Console_ExpandFile>>		<Control-Shift-F>
+	<<Console_ExpandProc>>		<Control-Shift-P>
+	<<Console_ExpandVar>>		<Control-Shift-V>
+	<<Console_Tab>>			<Control-i>
+	<<Console_Tab>>			<Meta-i>
+	<<Console_Eval>>		<Return>
+	<<Console_Eval>>		<KP_Enter>
+
+	<<Console_Clear>>		<Control-l>
+	<<Console_KillLine>>		<Control-k>
+	<<Console_Transpose>>		<Control-t>
+	<<Console_ClearLine>>		<Control-u>
+	<<Console_SaveCommand>>		<Control-z>
+	<<Console_FontSizeIncr>>	<Control-plus>
+	<<Console_FontSizeDecr>>	<Control-minus>
+    } {
+	event add $ev $key
+	bind Console $key {}
+    }
+    if {[tk windowingsystem] eq "aqua"} {
+	foreach {ev key} {
+	    <<Console_FontSizeIncr>>	<Command-plus>
+	    <<Console_FontSizeDecr>>	<Command-minus>
+	} {
+	    event add $ev $key
+	    bind Console $key {}
+	}
+	if {$::tk::console::useFontchooser} {
+	    bind Console <Command-t> [list ::tk::console::FontchooserToggle]
+	}
+    }
+    bind Console <<Console_Expand>> {
+	if {[%W compare insert > promptEnd]} {
+	    ::tk::console::Expand %W
+	}
+    }
+    bind Console <<Console_ExpandFile>> {
+	if {[%W compare insert > promptEnd]} {
+	    ::tk::console::Expand %W path
+	}
+    }
+    bind Console <<Console_ExpandProc>> {
+	if {[%W compare insert > promptEnd]} {
+	    ::tk::console::Expand %W proc
+	}
+    }
+    bind Console <<Console_ExpandVar>> {
+	if {[%W compare insert > promptEnd]} {
+	    ::tk::console::Expand %W var
+	}
+    }
+    bind Console <<Console_Eval>> {
+	%W mark set insert {end - 1c}
+	tk::ConsoleInsert %W "\n"
+	tk::ConsoleInvoke
+	break
+    }
+    bind Console <Delete> {
+	if {{} ne [%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 <BackSpace> {
+	if {{} ne [%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 <Control-h> [bind Console <BackSpace>]
+
+    bind Console <<LineStart>> {
+	if {[%W compare insert < promptEnd]} {
+	    tk::TextSetCursor %W {insert linestart}
+	} else {
+	    tk::TextSetCursor %W promptEnd
+	}
+    }
+    bind Console <<LineEnd>> {
+	tk::TextSetCursor %W {insert lineend}
+    }
+    bind Console <Control-d> {
+	if {[%W compare insert < promptEnd]} {
+	    break
+	}
+	%W delete insert
+    }
+    bind Console <<Console_KillLine>> {
+	if {[%W compare insert < promptEnd]} {
+	    break
+	}
+	if {[%W compare insert == {insert lineend}]} {
+	    %W delete insert
+	} else {
+	    %W delete insert {insert lineend}
+	}
+    }
+    bind Console <<Console_Clear>> {
+	## Clear console display
+	%W delete 1.0 "promptEnd linestart"
+    }
+    bind Console <<Console_ClearLine>> {
+	## Clear command line (Unix shell staple)
+	%W delete promptEnd end
+    }
+    bind Console <Meta-d> {
+	if {[%W compare insert >= promptEnd]} {
+	    %W delete insert {insert wordend}
+	}
+    }
+    bind Console <Meta-BackSpace> {
+	if {[%W compare {insert -1c wordstart} >= promptEnd]} {
+	    %W delete {insert -1c wordstart} insert
+	}
+    }
+    bind Console <Meta-d> {
+	if {[%W compare insert >= promptEnd]} {
+	    %W delete insert {insert wordend}
+	}
+    }
+    bind Console <Meta-BackSpace> {
+	if {[%W compare {insert -1c wordstart} >= promptEnd]} {
+	    %W delete {insert -1c wordstart} insert
+	}
+    }
+    bind Console <Meta-Delete> {
+	if {[%W compare insert >= promptEnd]} {
+	    %W delete insert {insert wordend}
+	}
+    }
+    bind Console <<PrevLine>> {
+	tk::ConsoleHistory prev
+    }
+    bind Console <<NextLine>> {
+	tk::ConsoleHistory next
+    }
+    bind Console <Insert> {
+	catch {tk::ConsoleInsert %W [::tk::GetSelection %W PRIMARY]}
+    }
+    bind Console <Key> {
+	tk::ConsoleInsert %W %A
+    }
+    bind Console <F9> {
+	destroy {*}[winfo children .]
+	source -encoding utf-8 [file join $tk_library console.tcl]
+    }
+    if {[tk windowingsystem] eq "aqua"} {
+	bind Console <Command-q> {
+	    exit
+	}
+    }
+    bind Console <<Cut>> { ::tk::console::Cut %W }
+    bind Console <<Copy>> { ::tk::console::Copy %W }
+    bind Console <<Paste>> { ::tk::console::Paste %W }
+
+    bind Console <<Console_FontSizeIncr>> {
+	set size [font configure TkConsoleFont -size]
+	if {$size < 0} {set sign -1} else {set sign 1}
+	set size [expr {(abs($size) + 1) * $sign}]
+	font configure TkConsoleFont -size $size
+	if {$::tk::console::useFontchooser} {
+	    tk fontchooser configure -font TkConsoleFont
+	}
+    }
+    bind Console <<Console_FontSizeDecr>> {
+	set size [font configure TkConsoleFont -size]
+	if {abs($size) < 2} { return }
+	if {$size < 0} {set sign -1} else {set sign 1}
+	set size [expr {(abs($size) - 1) * $sign}]
+	font configure TkConsoleFont -size $size
+	if {$::tk::console::useFontchooser} {
+	    tk fontchooser configure -font TkConsoleFont
+	}
+    }
+    bind Console <<Console_FitScreenWidth>> {
+	::tk::console::FitScreenWidth %W
+    }
+
+    ##
+    ## Bindings for doing special things based on certain keys
+    ##
+    bind PostConsole <parenright> {
+	if {"\\" ne [%W get insert-2c]} {
+	    ::tk::console::MatchPair %W \( \) promptEnd
+	}
+    }
+    bind PostConsole <bracketright> {
+	if {"\\" ne [%W get insert-2c]} {
+	    ::tk::console::MatchPair %W \[ \] promptEnd
+	}
+    }
+    bind PostConsole <braceright> {
+	if {"\\" ne [%W get insert-2c]} {
+	    ::tk::console::MatchPair %W \{ \} promptEnd
+	}
+    }
+    bind PostConsole <quotedbl> {
+	if {"\\" ne [%W get insert-2c]} {
+	    ::tk::console::MatchQuote %W promptEnd
+	}
+    }
+
+    bind PostConsole <Key> {
+	if {"%A" ne ""} {
+	    ::tk::console::TagProc %W
+	}
+    }
+}
+
+# ::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 {$s eq ""} {
+	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::Fontchooser* --
+# 	Let the user select the console font (TIP 324).
+
+proc ::tk::console::FontchooserToggle {} {
+    if {[tk fontchooser configure -visible]} {
+	tk fontchooser hide
+    } else {
+	tk fontchooser show
+    }
+}
+proc ::tk::console::FontchooserVisibility {index} {
+    if {[tk fontchooser configure -visible]} {
+	.menubar.edit entryconfigure $index -label [::tk::msgcat::mc "Hide Fonts"]
+    } else {
+	.menubar.edit entryconfigure $index -label [::tk::msgcat::mc "Show Fonts"]
+    }
+}
+proc ::tk::console::FontchooserFocus {w isFocusIn} {
+    if {$isFocusIn} {
+	tk fontchooser configure -parent $w -font TkConsoleFont \
+		-command [namespace code [list FontchooserApply]]
+    } else {
+	tk fontchooser configure -parent $w -font {} -command {}
+    }
+}
+proc ::tk::console::FontchooserApply {font args} {
+    catch {font configure TkConsoleFont {*}[font actual $font]}
+}
+
+# ::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 eq ""} {
+	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 {{} ne [set ix [$w search -back $c1 insert $lim]]} {
+	while {
+	    [string match {\\} [$w get $ix-1c]] &&
+	    [set ix [$w search -back $c1 $ix-1c $lim]] ne {}
+	} {}
+	set i1 insert-1c
+	while {$ix ne {}} {
+	    set i0 $ix
+	    set j 0
+	    while {[set i0 [$w search $c2 $i0 $i1]] ne {}} {
+		append i0 +1c
+		if {[string match {\\} [$w get $i0-2c]]} {
+		    continue
+		}
+		incr j
+	    }
+	    if {!$j} {
+		break
+	    }
+	    set i1 $ix
+	    while {$j && [set ix [$w search -back $c1 $ix $lim]] ne {}} {
+		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 {[set i [$w search -back \" $i $lim]] ne {}} {
+	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 eq ""} {
+	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 ne "")} {
+		    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) && ($repl eq $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 opt]} {
+	return -options $opt $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} {
+	    if { $::tcl_platform(platform) eq "windows" } {
+		## 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 -> 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 [expr {[string length $e] - 1}]
+	set ei [expr {[string length $ec] - 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
diff --git a/mplug_owl2/lib/tk8.6/dialog.tcl b/mplug_owl2/lib/tk8.6/dialog.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..a099d90036028ddee2782e505b728c3a7aea7a12
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/dialog.tcl
@@ -0,0 +1,175 @@
+# dialog.tcl --
+#
+# This file defines the procedure tk_dialog, which creates a dialog
+# box containing a bitmap, a message, and one or more buttons.
+#
+# 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} {
+    variable ::tk::Priv
+
+    # Check that $default was properly given
+    if {[string is integer -strict $default]} {
+	if {$default >= [llength $args]} {
+	    return -code error -errorcode {TK DIALOG BAD_DEFAULT} \
+		"default button index greater than number of buttons\
+		specified for tk_dialog"
+	}
+    } elseif {"" eq $default} {
+	set default -1
+    } else {
+	set default [lsearch -exact $args $default]
+    }
+
+    set windowingsystem [tk windowingsystem]
+
+    # 1. Create the top-level window and divide it into top
+    # and bottom parts.
+
+    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 {$windowingsystem eq "aqua"} {
+	::tk::unsupported::MacWindowStyle style $w moveableModal {}
+    } elseif {$windowingsystem eq "x11"} {
+	wm attributes $w -type dialog
+    }
+
+    frame $w.bot
+    frame $w.top
+    if {$windowingsystem eq "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
+    grid anchor $w.bot center
+
+    # 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
+    option add *Dialog.msg.font TkCaptionFont 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 {$bitmap ne ""} {
+	if {$windowingsystem eq "aqua" && $bitmap eq "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 {$windowingsystem eq "aqua"} {
+	    set tmp [string tolower $but]
+	    if {$tmp eq "ok" || $tmp eq "cancel"} {
+		grid columnconfigure $w.bot $i -minsize 90
+	    }
+	    grid configure $w.button$i -pady 7
+	}
+	incr i
+    }
+
+    # 4. Create a binding for <Return> on the dialog if there is a
+    # default button.
+    # Convention also dictates that if the keyboard focus moves among the
+    # the buttons that the <Return> binding affects the button with the focus.
+
+    if {$default >= 0} {
+	bind $w <Return> [list $w.button$default invoke]
+    }
+    bind $w <<PrevWindow>> [list bind $w <Return> {[tk_focusPrev %W] invoke}]
+    bind $w <<NextWindow>> [list bind $w <Return> {[tk_focusNext %W] invoke}]
+
+    # 5. Create a <Destroy> 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 <Destroy> {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 (Motif style) and de-iconify it.
+
+    ::tk::PlaceWindow $w
+    tkwait visibility $w
+
+    # 7. Set a grab and claim the focus too.
+
+    if {$default >= 0} {
+        set focus $w.button$default
+    } else {
+        set focus $w
+    }
+    tk::SetFocusGrab $w $focus
+
+    # 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 {
+	# 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> {}
+    }
+    tk::RestoreFocusGrab $w $focus
+    return $Priv(button)
+}
diff --git a/mplug_owl2/lib/tk8.6/entry.tcl b/mplug_owl2/lib/tk8.6/entry.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..5cb5ab912d75742d697f877dda44bdf016265f17
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/entry.tcl
@@ -0,0 +1,699 @@
+# entry.tcl --
+#
+# This file defines the default bindings for Tk entry widgets and provides
+# procedures that help in implementing those bindings.
+#
+# 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 <<Cut>> {
+    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 <<Copy>> {
+    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 <<Paste>> {
+    catch {
+	if {[tk windowingsystem] ne "x11"} {
+	    catch {
+		%W delete sel.first sel.last
+	    }
+	}
+	%W insert insert [::tk::GetSelection %W CLIPBOARD]
+	tk::EntrySeeInsert %W
+    }
+}
+bind Entry <<Clear>> {
+    # ignore if there is no selection
+    catch {%W delete sel.first sel.last}
+}
+bind Entry <<PasteSelection>> {
+    if {$tk_strictMotif || ![info exists tk::Priv(mouseMoved)]
+	|| !$tk::Priv(mouseMoved)} {
+	tk::EntryPaste %W %x
+    }
+}
+
+bind Entry <<TraverseIn>> {
+    %W selection range 0 end
+    %W icursor end
+}
+
+# Standard Motif bindings:
+
+bind Entry <Button-1> {
+    tk::EntryButton1 %W %x
+    %W selection clear
+}
+bind Entry <B1-Motion> {
+    set tk::Priv(x) %x
+    tk::EntryMouseSelect %W %x
+}
+bind Entry <Double-Button-1> {
+    set tk::Priv(selectMode) word
+    tk::EntryMouseSelect %W %x
+    catch {%W icursor sel.last}
+}
+bind Entry <Triple-Button-1> {
+    set tk::Priv(selectMode) line
+    tk::EntryMouseSelect %W %x
+    catch {%W icursor sel.last}
+}
+bind Entry <Shift-Button-1> {
+    set tk::Priv(selectMode) char
+    %W selection adjust @%x
+}
+bind Entry <Double-Shift-Button-1>	{
+    set tk::Priv(selectMode) word
+    tk::EntryMouseSelect %W %x
+}
+bind Entry <Triple-Shift-Button-1>	{
+    set tk::Priv(selectMode) line
+    tk::EntryMouseSelect %W %x
+}
+bind Entry <B1-Leave> {
+    set tk::Priv(x) %x
+    tk::EntryAutoScan %W
+}
+bind Entry <B1-Enter> {
+    tk::CancelRepeat
+}
+bind Entry <ButtonRelease-1> {
+    tk::CancelRepeat
+}
+bind Entry <Control-Button-1> {
+    %W icursor @%x
+}
+
+bind Entry <<PrevChar>> {
+    tk::EntrySetCursor %W [expr {[%W index insert]-1}]
+}
+bind Entry <<NextChar>> {
+    tk::EntrySetCursor %W [expr {[%W index insert]+1}]
+}
+bind Entry <<SelectPrevChar>> {
+    tk::EntryKeySelect %W [expr {[%W index insert]-1}]
+    tk::EntrySeeInsert %W
+}
+bind Entry <<SelectNextChar>> {
+    tk::EntryKeySelect %W [expr {[%W index insert]+1}]
+    tk::EntrySeeInsert %W
+}
+bind Entry <<PrevWord>> {
+    tk::EntrySetCursor %W [tk::EntryPreviousWord %W insert]
+}
+bind Entry <<NextWord>> {
+    tk::EntrySetCursor %W [tk::EntryNextWord %W insert]
+}
+bind Entry <<SelectPrevWord>> {
+    tk::EntryKeySelect %W [tk::EntryPreviousWord %W insert]
+    tk::EntrySeeInsert %W
+}
+bind Entry <<SelectNextWord>> {
+    tk::EntryKeySelect %W [tk::EntryNextWord %W insert]
+    tk::EntrySeeInsert %W
+}
+bind Entry <<LineStart>> {
+    tk::EntrySetCursor %W 0
+}
+bind Entry <<SelectLineStart>> {
+    tk::EntryKeySelect %W 0
+    tk::EntrySeeInsert %W
+}
+bind Entry <<LineEnd>> {
+    tk::EntrySetCursor %W end
+}
+bind Entry <<SelectLineEnd>> {
+    tk::EntryKeySelect %W end
+    tk::EntrySeeInsert %W
+}
+
+bind Entry <Delete> {
+    if {[%W selection present]} {
+	%W delete sel.first sel.last
+    } else {
+	%W delete insert
+    }
+}
+bind Entry <BackSpace> {
+    tk::EntryBackspace %W
+}
+
+bind Entry <Control-space> {
+    %W selection from insert
+}
+bind Entry <Select> {
+    %W selection from insert
+}
+bind Entry <Control-Shift-space> {
+    %W selection adjust insert
+}
+bind Entry <Shift-Select> {
+    %W selection adjust insert
+}
+bind Entry <<SelectAll>> {
+    %W selection range 0 end
+}
+bind Entry <<SelectNone>> {
+    %W selection clear
+}
+bind Entry <Key> {
+    tk::CancelRepeat
+    tk::EntryInsert %W %A
+}
+
+# Ignore all Alt, Meta, and Control keypresses unless explicitly bound.
+# Otherwise, if a widget binding for one of these is defined, the
+# <Key> class binding will also fire and insert the character,
+# which is wrong.  Ditto for Escape, Return, and Tab.
+
+bind Entry <Alt-Key> {# nothing}
+bind Entry <Meta-Key> {# nothing}
+bind Entry <Control-Key> {# nothing}
+bind Entry <Escape> {# nothing}
+bind Entry <Return> {# nothing}
+bind Entry <KP_Enter> {# nothing}
+bind Entry <Tab> {# nothing}
+bind Entry <Prior> {# nothing}
+bind Entry <Next> {# nothing}
+if {[tk windowingsystem] eq "aqua"} {
+    bind Entry <Command-Key> {# nothing}
+    bind Entry <Mod4-Key> {# nothing}
+}
+# Tk-on-Cocoa generates characters for these two keys. [Bug 2971663]
+bind Entry <<NextLine>> {# nothing}
+bind Entry <<PrevLine>> {# nothing}
+
+# On Windows, paste is done using Shift-Insert.  Shift-Insert already
+# generates the <<Paste>> event, so we don't need to do anything here.
+if {[tk windowingsystem] ne "win32"} {
+    bind Entry <Insert> {
+	catch {tk::EntryInsert %W [::tk::GetSelection %W PRIMARY]}
+    }
+}
+
+# Additional emacs-like bindings:
+
+bind Entry <Control-d> {
+    if {!$tk_strictMotif} {
+	%W delete insert
+    }
+}
+bind Entry <Control-h> {
+    if {!$tk_strictMotif} {
+	tk::EntryBackspace %W
+    }
+}
+bind Entry <Control-k> {
+    if {!$tk_strictMotif} {
+	%W delete insert end
+    }
+}
+bind Entry <Control-t> {
+    if {!$tk_strictMotif} {
+	tk::EntryTranspose %W
+    }
+}
+bind Entry <Meta-b> {
+    if {!$tk_strictMotif} {
+	tk::EntrySetCursor %W [tk::EntryPreviousWord %W insert]
+    }
+}
+bind Entry <Meta-d> {
+    if {!$tk_strictMotif} {
+	%W delete insert [tk::EntryNextWord %W insert]
+    }
+}
+bind Entry <Meta-f> {
+    if {!$tk_strictMotif} {
+	tk::EntrySetCursor %W [tk::EntryNextWord %W insert]
+    }
+}
+bind Entry <Meta-BackSpace> {
+    if {!$tk_strictMotif} {
+	%W delete [tk::EntryPreviousWord %W insert] insert
+    }
+}
+bind Entry <Meta-Delete> {
+    if {!$tk_strictMotif} {
+	%W delete [tk::EntryPreviousWord %W insert] insert
+    }
+}
+
+# Bindings for IME text input and accents.
+
+bind Entry <<TkStartIMEMarkedText>> {
+    dict set ::tk::Priv(IMETextMark) "%W" [%W index insert]
+}
+bind Entry <<TkEndIMEMarkedText>> {
+    if {[catch {dict get $::tk::Priv(IMETextMark) "%W"} mark]} {
+	bell
+    } else {
+	%W selection range $mark insert
+    }
+}
+bind Entry <<TkClearIMEMarkedText>> {
+    %W delete [dict get $::tk::Priv(IMETextMark) "%W"] [%W index insert]
+}
+bind Entry <<TkAccentBackspace>> {
+    tk::EntryBackspace %W
+}
+
+# A few additional bindings of my own.
+
+if {[tk windowingsystem] ne "aqua"} {
+    bind Entry <Button-2> {
+        if {!$tk_strictMotif} {
+        ::tk::EntryScanMark %W %x
+        }
+    }
+    bind Entry <B2-Motion> {
+        if {!$tk_strictMotif} {
+        ::tk::EntryScanDrag %W %x
+        }
+    }
+} else {
+    bind Entry <Button-3> {
+        if {!$tk_strictMotif} {
+        ::tk::EntryScanMark %W %x
+        }
+    }
+    bind Entry <B3-Motion> {
+        if {!$tk_strictMotif} {
+        ::tk::EntryScanDrag %W %x
+        }
+    }
+}
+
+# ::tk::EntryClosestGap --
+# 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 entry window.
+# x -		X-coordinate within the window.
+
+proc ::tk::EntryClosestGap {w x} {
+    set pos [$w index @$x]
+    set bbox [$w bbox $pos]
+    if {($x - [lindex $bbox 0]) < ([lindex $bbox 2]/2)} {
+	return $pos
+    }
+    incr pos
+}
+
+# ::tk::EntryButton1 --
+# This procedure is invoked to handle button-1 presses in entry
+# widgets.  It moves the insertion cursor, sets the selection anchor,
+# and claims the input focus.
+#
+# Arguments:
+# w -		The entry window in which the button was pressed.
+# x -		The x-coordinate of the button press.
+
+proc ::tk::EntryButton1 {w x} {
+    variable ::tk::Priv
+
+    set Priv(selectMode) char
+    set Priv(mouseMoved) 0
+    set Priv(pressX) $x
+    $w icursor [EntryClosestGap $w $x]
+    $w selection from insert
+    if {"disabled" ne [$w cget -state]} {
+	focus $w
+    }
+}
+
+# ::tk::EntryMouseSelect --
+# This procedure is invoked when dragging out a selection 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 entry window in which the button was pressed.
+# x -		The x-coordinate of the mouse.
+
+proc ::tk::EntryMouseSelect {w x} {
+    variable ::tk::Priv
+
+    set cur [EntryClosestGap $w $x]
+    set anchor [$w index anchor]
+    if {($cur != $anchor) || (abs($Priv(pressX) - $x) >= 3)} {
+	set Priv(mouseMoved) 1
+    }
+    switch $Priv(selectMode) {
+	char {
+	    if {$Priv(mouseMoved)} {
+		if {$cur < $anchor} {
+		    $w selection range $cur $anchor
+		} elseif {$cur > $anchor} {
+		    $w selection range $anchor $cur
+		} else {
+		    $w selection clear
+		}
+	    }
+	}
+	word {
+	    if {$cur < $anchor} {
+		set before [tcl_wordBreakBefore [$w get] $cur]
+		set after [tcl_wordBreakAfter [$w get] $anchor-1]
+	    } elseif {$cur > $anchor} {
+		set before [tcl_wordBreakBefore [$w get] $anchor]
+		set after [tcl_wordBreakAfter [$w get] $cur-1]
+	    } else {
+		if {[$w index @$Priv(pressX)] < $anchor} {
+		      incr anchor -1
+		}
+		set before [tcl_wordBreakBefore [$w get] $anchor]
+		set after [tcl_wordBreakAfter [$w get] $anchor]
+	    }
+	    if {$before < 0} {
+		set before 0
+	    }
+	    if {$after < 0} {
+		set after end
+	    }
+	    $w selection range $before $after
+	}
+	line {
+	    $w selection range 0 end
+	}
+    }
+    if {$Priv(mouseMoved)} {
+        $w icursor $cur
+    }
+    update idletasks
+}
+
+# ::tk::EntryPaste --
+# This procedure sets the insertion cursor to the current mouse position,
+# pastes the selection there, and sets the focus to the window.
+#
+# Arguments:
+# w -		The entry window.
+# x -		X position of the mouse.
+
+proc ::tk::EntryPaste {w x} {
+    $w icursor [EntryClosestGap $w $x]
+    catch {$w insert insert [::tk::GetSelection $w PRIMARY]}
+    if {"disabled" ne [$w cget -state]} {
+	focus $w
+    }
+}
+
+# ::tk::EntryAutoScan --
+# This procedure is invoked when the mouse leaves an entry window
+# with button 1 down.  It scrolls the window left or right,
+# depending on where the mouse is, 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::EntryAutoScan {w} {
+    variable ::tk::Priv
+    set x $Priv(x)
+    if {![winfo exists $w]} {
+	return
+    }
+    if {$x >= [winfo width $w]} {
+	$w xview scroll 2 units
+	EntryMouseSelect $w $x
+    } elseif {$x < 0} {
+	$w xview scroll -2 units
+	EntryMouseSelect $w $x
+    }
+    set Priv(afterId) [after 50 [list tk::EntryAutoScan $w]]
+}
+
+# ::tk::EntryKeySelect --
+# 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 entry window.
+# new -		A new position for the insertion cursor (the cursor hasn't
+#		actually been moved to this position yet).
+
+proc ::tk::EntryKeySelect {w new} {
+    if {![$w selection present]} {
+	$w selection from insert
+	$w selection to $new
+    } else {
+	$w selection adjust $new
+    }
+    $w icursor $new
+}
+
+# ::tk::EntryInsert --
+# Insert a string into an entry at the point of the insertion cursor.
+# If there is a selection in the entry, and it covers the point of the
+# insertion cursor, then delete the selection before inserting.
+#
+# Arguments:
+# w -		The entry window in which to insert the string
+# s -		The string to insert (usually just a single character)
+
+proc ::tk::EntryInsert {w s} {
+    if {$s eq ""} {
+	return
+    }
+    catch {
+	set insert [$w index insert]
+	if {([$w index sel.first] <= $insert)
+		&& ([$w index sel.last] >= $insert)} {
+	    $w delete sel.first sel.last
+	}
+    }
+    $w insert insert $s
+    EntrySeeInsert $w
+}
+
+# ::tk::EntryBackspace --
+# Backspace over the character just before the insertion cursor.
+# If backspacing would move the cursor off the left edge of the
+# window, reposition the cursor at about the middle of the window.
+#
+# Arguments:
+# w -		The entry window in which to backspace.
+
+proc ::tk::EntryBackspace w {
+    if {[$w selection present]} {
+	$w delete sel.first sel.last
+    } else {
+	set x [$w index insert]
+	if {$x > 0} {
+	    $w delete [expr {$x-1}]
+	}
+	if {[$w index @0] >= [$w index insert]} {
+	    set range [$w xview]
+	    set left [lindex $range 0]
+	    set right [lindex $range 1]
+	    $w xview moveto [expr {$left - ($right - $left)/2.0}]
+	}
+    }
+}
+
+# ::tk::EntrySeeInsert --
+# Make sure that the insertion cursor is visible in the entry window.
+# If not, adjust the view so that it is.
+#
+# Arguments:
+# w -		The entry window.
+
+proc ::tk::EntrySeeInsert w {
+    set c [$w index insert]
+    if {($c < [$w index @0]) || ($c > [$w index @[winfo width $w]])} {
+	$w xview $c
+    }
+}
+
+# ::tk::EntrySetCursor -
+# Move the insertion cursor to a given position in an entry.  Also
+# clears the selection, if there is one in the entry, and makes sure
+# that the insertion cursor is visible.
+#
+# Arguments:
+# w -		The entry window.
+# pos -		The desired new position for the cursor in the window.
+
+proc ::tk::EntrySetCursor {w pos} {
+    $w icursor $pos
+    $w selection clear
+    EntrySeeInsert $w
+}
+
+# ::tk::EntryTranspose -
+# This procedure implements the "transpose" function for entry 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 -		The entry window.
+
+proc ::tk::EntryTranspose w {
+    set i [$w index insert]
+    if {$i < [$w index end]} {
+	incr i
+    }
+    if {$i < 2} {
+	return
+    }
+    set first [expr {$i-2}]
+    set data [$w get]
+    set new [string index $data $i-1][string index $data $first]
+    $w delete $first $i
+    $w insert insert $new
+    EntrySeeInsert $w
+}
+
+# ::tk::EntryNextWord --
+# Returns the index of the next word position after a given position in the
+# entry.  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 entry window in which the cursor is to move.
+# start -	Position at which to start search.
+
+if {[tk windowingsystem] eq "win32"}  {
+    proc ::tk::EntryNextWord {w start} {
+        # the check on [winfo class] is because the spinbox also uses this proc
+        if {[winfo class $w] eq "Entry" && [$w cget -show] ne ""} {
+	    return end
+	}
+	set pos [tcl_endOfWord [$w get] [$w index $start]]
+	if {$pos >= 0} {
+	    set pos [tcl_startOfNextWord [$w get] $pos]
+	}
+	if {$pos < 0} {
+	    return end
+	}
+	return $pos
+    }
+} else {
+    proc ::tk::EntryNextWord {w start} {
+        # the check on [winfo class] is because the spinbox also uses this proc
+        if {[winfo class $w] eq "Entry" && [$w cget -show] ne ""} {
+	    return end
+	}
+	set pos [tcl_endOfWord [$w get] [$w index $start]]
+	if {$pos < 0} {
+	    return end
+	}
+	return $pos
+    }
+}
+
+# ::tk::EntryPreviousWord --
+#
+# Returns the index of the previous word position before a given
+# position in the entry.
+#
+# Arguments:
+# w -		The entry window in which the cursor is to move.
+# start -	Position at which to start search.
+
+proc ::tk::EntryPreviousWord {w start} {
+    # the check on [winfo class] is because the spinbox also uses this proc
+    if {[winfo class $w] eq "Entry" && [$w cget -show] ne ""} {
+	return 0
+    }
+    set pos [tcl_startOfPreviousWord [$w get] [$w index $start]]
+    if {$pos < 0} {
+	return 0
+    }
+    return $pos
+}
+
+# ::tk::EntryScanMark --
+#
+# Marks the start of a possible scan drag operation
+#
+# Arguments:
+# w -	The entry window from which the text to get
+# x -	x location on screen
+
+proc ::tk::EntryScanMark {w x} {
+    $w scan mark $x
+    set ::tk::Priv(x) $x
+    set ::tk::Priv(y) 0 ; # not used
+    set ::tk::Priv(mouseMoved) 0
+}
+
+# ::tk::EntryScanDrag --
+#
+# Marks the start of a possible scan drag operation
+#
+# Arguments:
+# w -	The entry window from which the text to get
+# x -	x location on screen
+
+proc ::tk::EntryScanDrag {w x} {
+    # 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}
+    # allow for a delta
+    if {abs($x-$::tk::Priv(x)) > 2} {
+	set ::tk::Priv(mouseMoved) 1
+    }
+    $w scan dragto $x
+}
+
+# ::tk::EntryGetSelection --
+#
+# Returns the selected text of the entry with respect to the -show option.
+#
+# Arguments:
+# w -         The entry window from which the text to get
+
+proc ::tk::EntryGetSelection {w} {
+    set entryString [string range [$w get] [$w index sel.first] \
+	    [$w index sel.last]-1]
+    if {[$w cget -show] ne ""} {
+	return [string repeat [string index [$w cget -show] 0] \
+		[string length $entryString]]
+    }
+    return $entryString
+}
diff --git a/mplug_owl2/lib/tk8.6/focus.tcl b/mplug_owl2/lib/tk8.6/focus.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..640406e4dddd421a59be2718b13b28142415f22a
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/focus.tcl
@@ -0,0 +1,178 @@
+# focus.tcl --
+#
+# This file defines several procedures for managing the input
+# focus.
+#
+# 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.
+#
+
+# ::tk_focusNext --
+# This procedure returns the name of the next window after "w" in
+# "focus order" (the window that should receive the focus next if
+# Tab is typed in w).  "Next" is defined by a pre-order search
+# of a top-level and its non-top-level descendants, with the stacking
+# order determining the order of siblings.  The "-takefocus" options
+# on windows determine whether or not they should be skipped.
+#
+# Arguments:
+# w -		Name of a window.
+
+proc ::tk_focusNext w {
+    set cur $w
+    while {1} {
+
+	# Descend to just before the first child of the current widget.
+
+	set parent $cur
+	set children [winfo children $cur]
+	set i -1
+
+	# Look for the next sibling that isn't a top-level.
+
+	while {1} {
+	    incr i
+	    if {$i < [llength $children]} {
+		set cur [lindex $children $i]
+		if {[winfo toplevel $cur] eq $cur} {
+		    continue
+		} else {
+		    break
+		}
+	    }
+
+	    # No more siblings, so go to the current widget's parent.
+	    # If it's a top-level, break out of the loop, otherwise
+	    # look for its next sibling.
+
+	    set cur $parent
+	    if {[winfo toplevel $cur] eq $cur} {
+		break
+	    }
+	    set parent [winfo parent $parent]
+	    set children [winfo children $parent]
+	    set i [lsearch -exact $children $cur]
+	}
+	if {$w eq $cur || [tk::FocusOK $cur]} {
+	    return $cur
+	}
+    }
+}
+
+# ::tk_focusPrev --
+# This procedure returns the name of the previous window before "w" in
+# "focus order" (the window that should receive the focus next if
+# Shift-Tab is typed in w).  "Next" is defined by a pre-order search
+# of a top-level and its non-top-level descendants, with the stacking
+# order determining the order of siblings.  The "-takefocus" options
+# on windows determine whether or not they should be skipped.
+#
+# Arguments:
+# w -		Name of a window.
+
+proc ::tk_focusPrev w {
+    set cur $w
+    while {1} {
+
+	# Collect information about the current window's position
+	# among its siblings.  Also, if the window is a top-level,
+	# then reposition to just after the last child of the window.
+
+	if {[winfo toplevel $cur] eq $cur}  {
+	    set parent $cur
+	    set children [winfo children $cur]
+	    set i [llength $children]
+	} else {
+	    set parent [winfo parent $cur]
+	    set children [winfo children $parent]
+	    set i [lsearch -exact $children $cur]
+	}
+
+	# Go to the previous sibling, then descend to its last descendant
+	# (highest in stacking order.  While doing this, ignore top-levels
+	# and their descendants.  When we run out of descendants, go up
+	# one level to the parent.
+
+	while {$i > 0} {
+	    incr i -1
+	    set cur [lindex $children $i]
+	    if {[winfo toplevel $cur] eq $cur} {
+		continue
+	    }
+	    set parent $cur
+	    set children [winfo children $parent]
+	    set i [llength $children]
+	}
+	set cur $parent
+	if {$w eq $cur || [tk::FocusOK $cur]} {
+	    return $cur
+	}
+    }
+}
+
+# ::tk::FocusOK --
+#
+# This procedure is invoked to decide whether or not to focus on
+# a given window.  It returns 1 if it's OK to focus on the window,
+# 0 if it's not OK.  The code first checks whether the window is
+# viewable.  If not, then it never focuses on the window.  Then it
+# checks the -takefocus option for the window and uses it if it's
+# set.  If there's no -takefocus option, the procedure checks to
+# see if (a) the widget isn't disabled, and (b) it has some key
+# bindings.  If all of these are true, then 1 is returned.
+#
+# Arguments:
+# w -		Name of a window.
+
+proc ::tk::FocusOK w {
+    set code [catch {$w cget -takefocus} value]
+    if {($code == 0) && ($value ne "")} {
+	if {$value == 0} {
+	    return 0
+	} elseif {$value == 1} {
+	    return [winfo viewable $w]
+	} else {
+	    set value [uplevel #0 $value [list $w]]
+	    if {$value ne ""} {
+		return $value
+	    }
+	}
+    }
+    if {![winfo viewable $w]} {
+	return 0
+    }
+    set code [catch {$w cget -state} value]
+    if {($code == 0) && $value eq "disabled"} {
+	return 0
+    }
+    regexp Key|Focus "[bind $w] [bind [winfo class $w]]"
+}
+
+# ::tk_focusFollowsMouse --
+#
+# If this procedure is invoked, Tk will enter "focus-follows-mouse"
+# mode, where the focus is always on whatever window contains the
+# mouse.  If this procedure isn't invoked, then the user typically
+# has to click on a window to give it the focus.
+#
+# Arguments:
+# None.
+
+proc ::tk_focusFollowsMouse {} {
+    set old [bind all <Enter>]
+    set script {
+	if {"%d" eq "NotifyAncestor" || "%d" eq "NotifyNonlinear" \
+		|| "%d" eq "NotifyInferior"} {
+	    if {[tk::FocusOK %W]} {
+		focus %W
+	    }
+	}
+    }
+    if {$old ne ""} {
+	bind all <Enter> "$old; $script"
+    } else {
+	bind all <Enter> $script
+    }
+}
diff --git a/mplug_owl2/lib/tk8.6/fontchooser.tcl b/mplug_owl2/lib/tk8.6/fontchooser.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..8c036adb9473641658217cfea1ee7ad6e6498f8a
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/fontchooser.tcl
@@ -0,0 +1,515 @@
+# fontchooser.tcl -
+#
+#	A themeable Tk font selection dialog. See TIP #324.
+#
+# Copyright (C) 2008 Keith Vetter
+# Copyright (C) 2008 Pat Thoyts <patthoyts@users.sourceforge.net>
+#
+# See the file "license.terms" for information on usage and redistribution
+# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+
+namespace eval ::tk::fontchooser {
+    variable S
+
+    set S(W) .__tk__fontchooser
+    set S(fonts) [lsort -dictionary -unique [font families]]
+    set S(styles) [list \
+            [::msgcat::mc Regular] \
+            [::msgcat::mc Italic] \
+            [::msgcat::mc Bold] \
+            [::msgcat::mc {Bold Italic}] \
+    ]
+    set S(sizes) {8 9 10 11 12 14 16 18 20 22 24 26 28 36 48 72}
+    set S(strike) 0
+    set S(under) 0
+    set S(first) 1
+    set S(-parent) .
+    set S(-title) {}
+    set S(-command) ""
+    set S(-font) TkDefaultFont
+    set S(bad) [list ]
+}
+
+proc ::tk::fontchooser::Canonical {} {
+    variable S
+
+    foreach style $S(styles) {
+        lappend S(styles,lcase) [string tolower $style]
+    }
+    set S(sizes,lcase) $S(sizes)
+    set S(sampletext) [::msgcat::mc "AaBbYyZz01"]
+
+    # Canonical versions of font families, styles, etc. for easier searching
+    set S(fonts,lcase) {}
+    foreach font $S(fonts) {
+        lappend S(fonts,lcase) [string tolower $font]
+    }
+    set S(styles,lcase) {}
+    foreach style $S(styles) {
+        lappend S(styles,lcase) [string tolower $style]
+    }
+}
+
+proc ::tk::fontchooser::Setup {} {
+    variable S
+
+    Canonical
+
+    ::ttk::style layout FontchooserFrame {
+        Entry.field -sticky news -border true -children {
+            FontchooserFrame.padding -sticky news
+        }
+    }
+    bind [winfo class .] <<ThemeChanged>> \
+            [list +ttk::style layout FontchooserFrame \
+                    [ttk::style layout FontchooserFrame]]
+
+    namespace ensemble create -map {
+        show ::tk::fontchooser::Show
+        hide ::tk::fontchooser::Hide
+        configure ::tk::fontchooser::Configure
+    }
+}
+::tk::fontchooser::Setup
+
+proc ::tk::fontchooser::Show {} {
+    variable S
+
+    Canonical
+
+    if {![winfo exists $S(W)]} {
+        Create
+        wm transient $S(W) [winfo toplevel $S(-parent)]
+        tk::PlaceWindow $S(W) widget $S(-parent)
+        if {[string trim $S(-title)] eq ""} {
+            wm title $S(W) [::msgcat::mc "Font"]
+        } else {
+            wm title $S(W) $S(-title)
+        }
+    }
+    set S(fonts) [lsort -dictionary -unique [font families]]
+    set S(fonts,lcase) {}
+    foreach font $S(fonts) {
+        lappend S(fonts,lcase) [string tolower $font]
+    }
+    wm deiconify $S(W)
+}
+
+proc ::tk::fontchooser::Hide {} {
+    variable S
+    wm withdraw $S(W)
+}
+
+proc ::tk::fontchooser::Configure {args} {
+    variable S
+
+    set specs {
+        {-parent  "" "" . }
+        {-title   "" "" ""}
+        {-font    "" "" ""}
+        {-command "" "" ""}
+    }
+
+    if {[llength $args] == 0} {
+        set result {}
+        foreach spec $specs {
+            foreach {name xx yy default} $spec break
+            lappend result $name \
+                    [expr {[info exists S($name)] ? $S($name) : $default}]
+        }
+        lappend result -visible \
+                [expr {[winfo exists $S(W)] && [winfo ismapped $S(W)]}]
+        return $result
+    }
+    if {[llength $args] == 1} {
+        set option [lindex $args 0]
+        if {[string equal $option "-visible"]} {
+            return [expr {[winfo exists $S(W)] && [winfo ismapped $S(W)]}]
+        } elseif {[info exists S($option)]} {
+            return $S($option)
+        }
+        return -code error -errorcode [list TK LOOKUP OPTION $option] \
+                "bad option \"$option\": must be\
+                -command, -font, -parent, -title or -visible"
+    }
+    set cache [dict create -parent $S(-parent) -title $S(-title) \
+            -font $S(-font) -command $S(-command)]
+    set r [tclParseConfigSpec [namespace which -variable S] $specs DONTSETDEFAULTS $args]
+    if {![winfo exists $S(-parent)]} {
+        set code [list TK LOOKUP WINDOW $S(-parent)]
+        set err "bad window path name \"$S(-parent)\""
+        array set S $cache
+        return -code error -errorcode $code $err
+    }
+
+    if {[winfo exists $S(W)]} {
+        if {{-font} in $args} {
+            Init $S(-font)
+            event generate $S(-parent) <<TkFontchooserFontChanged>>
+        }
+
+        if {[string trim $S(-title)] eq {}} {
+            wm title $S(W) [::msgcat::mc Font]
+        } else {
+            wm title $S(W) $S(-title)
+        }
+        $S(W).ok configure -state $S(nstate)
+        $S(W).apply configure -state $S(nstate)
+    }
+    return $r
+}
+
+proc ::tk::fontchooser::Create {} {
+    variable S
+    set windowName __tk__fontchooser
+    if {$S(-parent) eq "."} {
+        set S(W) .$windowName
+    } else {
+        set S(W) $S(-parent).$windowName
+    }
+
+    # Now build the dialog
+    if {![winfo exists $S(W)]} {
+        toplevel $S(W) -class TkFontDialog
+        if {[package provide tcltest] ne {}} {
+            set ::tk_dialog $S(W)
+        }
+        wm withdraw $S(W)
+        wm title $S(W) $S(-title)
+        wm transient $S(W) [winfo toplevel $S(-parent)]
+
+        set scaling [tk scaling]
+        set sizeWidth [expr {int([string length [::msgcat::mc "&Size:"]] * $scaling)}]
+
+        set outer [::ttk::frame $S(W).outer -padding {10 10}]
+        ::tk::AmpWidget ::ttk::label $S(W).font -text [::msgcat::mc "&Font:"]
+        ::tk::AmpWidget ::ttk::label $S(W).style -text [::msgcat::mc "Font st&yle:"]
+        ::tk::AmpWidget ::ttk::label $S(W).size -text [::msgcat::mc "&Size:"] -width $sizeWidth
+        ttk::entry $S(W).efont -width 18 \
+                -textvariable [namespace which -variable S](font)
+        ttk::entry $S(W).estyle -width 10 \
+                -textvariable [namespace which -variable S](style)
+        ttk::entry $S(W).esize -textvariable [namespace which -variable S](size) \
+                -width 3 -validate key -validatecommand {regexp -- {^-*[0-9]*$} %P}
+
+        ttk_slistbox $S(W).lfonts -height 7 -exportselection 0 \
+                -selectmode browse -activestyle none \
+                -listvariable [namespace which -variable S](fonts)
+        ttk_slistbox $S(W).lstyles -width 5 -height 7 -exportselection 0 \
+                -selectmode browse -activestyle none \
+                -listvariable [namespace which -variable S](styles)
+        ttk_slistbox $S(W).lsizes -width 4 -height 7 -exportselection 0 \
+                -selectmode browse -activestyle none \
+                -listvariable [namespace which -variable S](sizes)
+
+        set WE $S(W).effects
+        ::ttk::labelframe $WE -text [::msgcat::mc "Effects"]
+        ::tk::AmpWidget ::ttk::checkbutton $WE.strike \
+                -variable [namespace which -variable S](strike) \
+                -text [::msgcat::mc "Stri&keout"] \
+                -command [namespace code [list Click strike]]
+        ::tk::AmpWidget ::ttk::checkbutton $WE.under \
+                -variable [namespace which -variable S](under) \
+                -text [::msgcat::mc "&Underline"] \
+                -command [namespace code [list Click under]]
+
+        set bbox [::ttk::frame $S(W).bbox]
+        ::ttk::button $S(W).ok -text [::msgcat::mc OK] -default active\
+                -command [namespace code [list Done 1]]
+        ::ttk::button $S(W).cancel -text [::msgcat::mc Cancel] \
+                -command [namespace code [list Done 0]]
+        ::tk::AmpWidget ::ttk::button $S(W).apply -text [::msgcat::mc "&Apply"] \
+                -command [namespace code [list Apply]]
+        wm protocol $S(W) WM_DELETE_WINDOW [namespace code [list Done 0]]
+
+        # Calculate minimum sizes
+        ttk::scrollbar $S(W).tmpvs
+        set scroll_width [winfo reqwidth $S(W).tmpvs]
+        destroy $S(W).tmpvs
+        set minsize(gap) 10
+        set minsize(bbox) [winfo reqwidth $S(W).ok]
+        set minsize(fonts) \
+                [expr {[font measure TkDefaultFont "Helvetica"] + $scroll_width}]
+        set minsize(styles) \
+                [expr {[font measure TkDefaultFont "Bold Italic"] + $scroll_width}]
+        set minsize(sizes) \
+                [expr {[font measure TkDefaultFont "-99"] + $scroll_width}]
+        set min [expr {$minsize(gap) * 4}]
+        foreach {what width} [array get minsize] {
+            incr min $width
+        }
+        wm minsize $S(W) $min 260
+
+        bind $S(W) <Return> [namespace code [list Done 1]]
+        bind $S(W) <Escape> [namespace code [list Done 0]]
+        bind $S(W) <Map> [namespace code [list Visibility %W 1]]
+        bind $S(W) <Unmap> [namespace code [list Visibility %W 0]]
+        bind $S(W) <Destroy> [namespace code [list Visibility %W 0]]
+        bind $S(W).lfonts.list <<ListboxSelect>> [namespace code [list Click font]]
+        bind $S(W).lstyles.list <<ListboxSelect>> [namespace code [list Click style]]
+        bind $S(W).lsizes.list <<ListboxSelect>> [namespace code [list Click size]]
+        bind $S(W) <Alt-Key> [list ::tk::AltKeyInDialog $S(W) %A]
+        bind $S(W).font <<AltUnderlined>> [list ::focus $S(W).efont]
+        bind $S(W).style <<AltUnderlined>> [list ::focus $S(W).estyle]
+        bind $S(W).size <<AltUnderlined>> [list ::focus $S(W).esize]
+        bind $S(W).apply <<AltUnderlined>> [namespace code [list Apply]]
+        bind $WE.strike <<AltUnderlined>> [list $WE.strike invoke]
+        bind $WE.under <<AltUnderlined>> [list $WE.under invoke]
+
+        set WS $S(W).sample
+        ::ttk::labelframe $WS -text [::msgcat::mc "Sample"]
+        ::ttk::label $WS.sample -relief sunken -anchor center \
+                -textvariable [namespace which -variable S](sampletext)
+        set S(sample) $WS.sample
+        grid $WS.sample -sticky news -padx 6 -pady 4
+        grid rowconfigure $WS 0 -weight 1
+        grid columnconfigure $WS 0 -weight 1
+        grid propagate $WS 0
+
+        grid $S(W).ok     -in $bbox -sticky new -pady {0 2}
+        grid $S(W).cancel -in $bbox -sticky new -pady 2
+        grid $S(W).apply  -in $bbox -sticky new -pady 2
+        grid columnconfigure $bbox 0 -weight 1
+
+        grid $WE.strike -sticky w -padx 10
+        grid $WE.under -sticky w -padx 10 -pady {0 30}
+        grid columnconfigure $WE 1 -weight 1
+
+        grid $S(W).font   x $S(W).style   x $S(W).size   x       -in $outer -sticky w
+        grid $S(W).efont  x $S(W).estyle  x $S(W).esize  x $bbox -in $outer -sticky ew
+        grid $S(W).lfonts x $S(W).lstyles x $S(W).lsizes x ^     -in $outer -sticky news
+        grid $WE          x $WS           - -            x ^     -in $outer -sticky news -pady {15 30}
+        grid configure $bbox -sticky n
+        grid rowconfigure $outer 2 -weight 1
+        grid columnconfigure $outer {1 3 5} -minsize $minsize(gap)
+        grid columnconfigure $outer {0 2 4} -weight 1
+        grid columnconfigure $outer 0 -minsize $minsize(fonts)
+        grid columnconfigure $outer 2 -minsize $minsize(styles)
+        grid columnconfigure $outer 4 -minsize $minsize(sizes)
+        grid columnconfigure $outer 6 -minsize $minsize(bbox)
+
+        grid $outer -sticky news
+        grid rowconfigure $S(W) 0 -weight 1
+        grid columnconfigure $S(W) 0 -weight 1
+
+        Init $S(-font)
+
+        trace add variable [namespace which -variable S](size) \
+                write [namespace code [list Tracer]]
+        trace add variable [namespace which -variable S](style) \
+                write [namespace code [list Tracer]]
+        trace add variable [namespace which -variable S](font) \
+                write [namespace code [list Tracer]]
+        trace add variable [namespace which -variable S](strike) \
+                write [namespace code [list Tracer]]
+        trace add variable [namespace which -variable S](under) \
+                write [namespace code [list Tracer]]
+    }
+
+    Init $S(-font)
+
+    return
+}
+
+# ::tk::fontchooser::Done --
+#
+#       Handles teardown of the dialog, calling -command if needed
+#
+# Arguments:
+#       ok              true if user pressed OK
+#
+proc ::tk::fontchooser::Done {ok} {
+    variable S
+
+    if {! $ok} {
+        set S(result) ""
+    }
+    trace remove variable S(size) write [namespace code [list Tracer]]
+    trace remove variable S(style) write [namespace code [list Tracer]]
+    trace remove variable S(font) write [namespace code [list Tracer]]
+    trace remove variable S(strike) write [namespace code [list Tracer]]
+    trace remove variable S(under) write [namespace code [list Tracer]]
+    destroy $S(W)
+    if {$ok} {
+        if {$S(-command) ne ""} {
+            uplevel #0 $S(-command) [list $S(result)]
+        }
+        event generate $S(-parent) <<TkFontchooserFontChanged>>
+    }
+}
+
+# ::tk::fontchooser::Apply --
+#
+#	Call the -command procedure appending the current font
+#	Errors are reported via the background error mechanism
+#
+proc ::tk::fontchooser::Apply {} {
+    variable S
+    if {$S(-command) ne ""} {
+        if {[catch {uplevel #0 $S(-command) [list $S(result)]} err]} {
+            ::bgerror $err
+        }
+    }
+    event generate $S(-parent) <<TkFontchooserFontChanged>>
+}
+
+# ::tk::fontchooser::Init --
+#
+#       Initializes dialog to a default font
+#
+# Arguments:
+#       defaultFont     font to use as the default
+#
+proc ::tk::fontchooser::Init {{defaultFont ""}} {
+    variable S
+
+    if {$S(first) || $defaultFont ne ""} {
+        Canonical
+        if {$defaultFont eq ""} {
+            set defaultFont [[entry .___e] cget -font]
+            destroy .___e
+        }
+        array set F [font actual $defaultFont]
+        set S(font) $F(-family)
+        set S(style) [::msgcat::mc "Regular"]
+        set S(size) $F(-size)
+        set S(strike) $F(-overstrike)
+        set S(under) $F(-underline)
+        if {$F(-weight) eq "bold" && $F(-slant) eq "italic"} {
+            set S(style) [::msgcat::mc "Bold Italic"]
+        } elseif {$F(-weight) eq "bold"} {
+            set S(style) [::msgcat::mc "Bold"]
+        } elseif {$F(-slant) eq "italic"} {
+            set S(style) [::msgcat::mc "Italic"]
+        }
+        set S(first) 0
+    }
+}
+
+# ::tk::fontchooser::Click --
+#
+#       Handles all button clicks, updating the appropriate widgets
+#
+# Arguments:
+#       who             which widget got pressed
+#
+proc ::tk::fontchooser::Click {who} {
+    variable S
+    if {$who eq "font"} {
+        set S(font) [$S(W).lfonts get [$S(W).lfonts curselection]]
+    } elseif {$who eq "style"} {
+        set S(style) [$S(W).lstyles get [$S(W).lstyles curselection]]
+    } elseif {$who eq "size"} {
+        set S(size) [$S(W).lsizes get [$S(W).lsizes curselection]]
+    }
+}
+
+# ::tk::fontchooser::Tracer --
+#
+#       Handles traces on key variables, updating the appropriate widgets
+#
+# Arguments:
+#       standard trace arguments (not used)
+#
+proc ::tk::fontchooser::Tracer {var1 var2 op} {
+    variable S
+    # We don't need to process strike and under
+    if {$var2 ni [list strike under]} {
+        # Make selection in listbox
+        set value [string tolower $S($var2)]
+        $S(W).l${var2}s selection clear 0 end
+        set n [lsearch -exact $S(${var2}s,lcase) $value]
+        $S(W).l${var2}s selection set $n
+        if {$n >= 0} {
+            set S($var2) [lindex $S(${var2}s) $n]
+            $S(W).e$var2 icursor end
+            $S(W).e$var2 selection clear
+            if {[set i [lsearch $S(bad) $var2]] >= 0} {
+                set S(bad) [lreplace $S(bad) $i $i]
+            }
+        } else {
+            # No match, try prefix
+            set n [lsearch -glob $S(${var2}s,lcase) "$value*"]
+            if {$var2 ne "size" || !([regexp -- {^(-[0-9]+|[0-9]+)$} $value] && $value >= -4096 && $value <= 4096)} {
+                 if {[lsearch $S(bad) $var2] < 0} {
+                     lappend S(bad) $var2
+                 }
+            } else {
+                if {[set i [lsearch $S(bad) $var2]] >= 0} {
+                    set S(bad) [lreplace $S(bad) $i $i]
+                }
+            }
+        }
+        $S(W).l${var2}s see $n
+    }
+    if {[llength $S(bad)] == 0} {
+        set S(nstate) normal
+        Update
+    } else {
+        set S(nstate) disabled
+    }
+    $S(W).ok configure -state $S(nstate)
+    $S(W).apply configure -state $S(nstate)
+}
+
+# ::tk::fontchooser::Update --
+#
+#       Shows a sample of the currently selected font
+#
+proc ::tk::fontchooser::Update {} {
+    variable S
+
+    set S(result) [list $S(font) $S(size)]
+    if {$S(style) eq [::msgcat::mc "Bold"]} {
+        lappend S(result) bold
+    }
+    if {$S(style) eq [::msgcat::mc "Italic"]} {
+        lappend S(result) italic
+    }
+    if {$S(style) eq [::msgcat::mc "Bold Italic"]} {
+        lappend S(result) bold italic
+    }
+    if {$S(strike)} {
+        lappend S(result) overstrike
+    }
+    if {$S(under)} {
+        lappend S(result) underline
+    }
+
+    $S(sample) configure -font $S(result)
+    set S(-font) $S(result)
+}
+
+# ::tk::fontchooser::Visibility --
+#
+#	Notify the parent when the dialog visibility changes
+#
+proc ::tk::fontchooser::Visibility {w visible} {
+    variable S
+    if {$w eq $S(W)} {
+        event generate $S(-parent) <<TkFontchooserVisibility>>
+    }
+}
+
+# ::tk::fontchooser::ttk_slistbox --
+#
+#	Create a properly themed scrolled listbox.
+#	This is exactly right on XP but may need adjusting on other platforms.
+#
+proc ::tk::fontchooser::ttk_slistbox {w args} {
+    set f [ttk::frame $w -style FontchooserFrame -padding 2]
+    if {[catch {
+        listbox $f.list -relief flat -highlightthickness 0 -borderwidth 0 {*}$args
+        ttk::scrollbar $f.vs -command [list $f.list yview]
+        $f.list configure -yscrollcommand [list $f.vs set]
+        grid $f.list $f.vs -sticky news
+        grid rowconfigure $f 0 -weight 1
+        grid columnconfigure $f 0 -weight 1
+        interp hide {} $w
+        interp alias {} $w {} $f.list
+    } err opt]} {
+        destroy $f
+        return -options $opt $err
+    }
+    return $w
+}
diff --git a/mplug_owl2/lib/tk8.6/iconlist.tcl b/mplug_owl2/lib/tk8.6/iconlist.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..75a0741c175d10dcf0173964c28577b0d293edc8
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/iconlist.tcl
@@ -0,0 +1,715 @@
+# iconlist.tcl
+#
+#	Implements the icon-list megawidget used in the "Tk" standard file
+#	selection dialog boxes.
+#
+# Copyright (c) 1994-1998 Sun Microsystems, Inc.
+# Copyright (c) 2009 Donal K. Fellows
+#
+# See the file "license.terms" for information on usage and redistribution of
+# this file, and for a DISCLAIMER OF ALL WARRANTIES.
+#
+# API Summary:
+#	tk::IconList <path> ?<option> <value>? ...
+#	<path> add <imageName> <itemList>
+#	<path> cget <option>
+#	<path> configure ?<option>? ?<value>? ...
+#	<path> deleteall
+#	<path> destroy
+#	<path> get <itemIndex>
+#	<path> index <index>
+#	<path> invoke
+#	<path> see <index>
+#	<path> selection anchor ?<int>?
+#	<path> selection clear <first> ?<last>?
+#	<path> selection get
+#	<path> selection includes <item>
+#	<path> selection set <first> ?<last>?
+
+package require Tk
+
+::tk::Megawidget create ::tk::IconList ::tk::FocusableWidget {
+    variable w canvas sbar accel accelCB fill font index \
+	itemList itemsPerColumn list maxIH maxIW maxTH maxTW noScroll \
+	numItems oldX oldY options rect selected selection textList
+    constructor args {
+	next {*}$args
+	set accelCB {}
+    }
+    destructor {
+	my Reset
+	next
+    }
+
+    method GetSpecs {} {
+	concat [next] {
+	    {-command "" "" ""}
+	    {-font "" "" "TkIconFont"}
+	    {-multiple "" "" "0"}
+	}
+    }
+
+    # ----------------------------------------------------------------------
+
+    method index i {
+	if {![info exist list]} {
+	    set list {}
+	}
+	switch -regexp -- $i {
+	    "^-?[0-9]+$" {
+		if {$i < 0} {
+		    set i 0
+		}
+		if {$i >= [llength $list]} {
+		    set i [expr {[llength $list] - 1}]
+		}
+		return $i
+	    }
+	    "^anchor$" {
+		return $index(anchor)
+	    }
+	    "^end$" {
+		return [llength $list]
+	    }
+	    "@-?[0-9]+,-?[0-9]+" {
+		scan $i "@%d,%d" x y
+		set item [$canvas find closest \
+			[$canvas canvasx $x] [$canvas canvasy $y]]
+		return [lindex [$canvas itemcget $item -tags] 1]
+	    }
+	}
+    }
+
+    method selection {op args} {
+	switch -exact -- $op {
+	    anchor {
+		if {[llength $args] == 1} {
+		    set index(anchor) [$w index [lindex $args 0]]
+		} else {
+		    return $index(anchor)
+		}
+	    }
+	    clear {
+		switch [llength $args] {
+		    2 {
+			lassign $args first last
+		    }
+		    1 {
+			set first [set last [lindex $args 0]]
+		    }
+		    default {
+			return -code error -errorcode {TCL WRONGARGS} \
+			    "wrong # args: should be\
+			    \"[lrange [info level 0] 0 1] first ?last?\""
+		    }
+		}
+
+		set first [$w index $first]
+		set last [$w index $last]
+		if {$first > $last} {
+		    set tmp $first
+		    set first $last
+		    set last $tmp
+		}
+		set ind 0
+		foreach item $selection {
+		    if {$item >= $first} {
+			set first $ind
+			break
+		    }
+		    incr ind
+		}
+		set ind [expr {[llength $selection] - 1}]
+		for {} {$ind >= 0} {incr ind -1} {
+		    set item [lindex $selection $ind]
+		    if {$item <= $last} {
+			set last $ind
+			break
+		    }
+		}
+
+		if {$first > $last} {
+		    return
+		}
+		set selection [lreplace $selection $first $last]
+		event generate $w <<ListboxSelect>>
+		my DrawSelection
+	    }
+	    get {
+		return $selection
+	    }
+	    includes {
+		return [expr {[lindex $args 0] in $selection}]
+	    }
+	    set {
+		switch [llength $args] {
+		    2 {
+			lassign $args first last
+		    }
+		    1 {
+			set first [set last [lindex $args 0]]
+		    }
+		    default {
+			return -code error -errorcode {TCL WRONGARGS} \
+			    "wrong # args: should be\
+			    \"[lrange [info level 0] 0 1] first ?last?\""
+		    }
+		}
+
+		set first [$w index $first]
+		set last [$w index $last]
+		if {$first > $last} {
+		    set tmp $first
+		    set first $last
+		    set last $tmp
+		}
+
+		for {set i $first} {$i <= $last} {incr i} {
+		    lappend selection $i
+		}
+		set selection [lsort -integer -unique $selection]
+		event generate $w <<ListboxSelect>>
+		my DrawSelection
+	    }
+	}
+    }
+
+    method get item {
+	set rTag [lindex $list $item 2]
+	lassign $itemList($rTag) iTag tTag text serial
+	return $text
+    }
+
+    #	Deletes all the items inside the canvas subwidget and reset the
+    #	iconList's state.
+    #
+    method deleteall {} {
+	$canvas delete all
+	unset -nocomplain selected rect list itemList
+	set maxIW 1
+	set maxIH 1
+	set maxTW 1
+	set maxTH 1
+	set numItems 0
+	set noScroll 1
+	set selection {}
+	set index(anchor) ""
+	$sbar set 0.0 1.0
+	$canvas xview moveto 0
+    }
+
+    #	Adds an icon into the IconList with the designated image and text
+    #
+    method add {image items} {
+	foreach text $items {
+	    set iID item$numItems
+	    set iTag [$canvas create image 0 0 -image $image -anchor nw \
+			  -tags [list icon $numItems $iID]]
+	    set tTag [$canvas create text  0 0 -text  $text  -anchor nw \
+			  -font $options(-font) -fill $fill \
+			  -tags [list text $numItems $iID]]
+	    set rTag [$canvas create rect  0 0 0 0 -fill "" -outline "" \
+			  -tags [list rect $numItems $iID]]
+
+	    lassign [$canvas bbox $iTag] x1 y1 x2 y2
+	    set iW [expr {$x2 - $x1}]
+	    set iH [expr {$y2 - $y1}]
+	    if {$maxIW < $iW} {
+		set maxIW $iW
+	    }
+	    if {$maxIH < $iH} {
+		set maxIH $iH
+	    }
+
+	    lassign [$canvas bbox $tTag] x1 y1 x2 y2
+	    set tW [expr {$x2 - $x1}]
+	    set tH [expr {$y2 - $y1}]
+	    if {$maxTW < $tW} {
+		set maxTW $tW
+	    }
+	    if {$maxTH < $tH} {
+		set maxTH $tH
+	    }
+
+	    lappend list [list $iTag $tTag $rTag $iW $iH $tW $tH $numItems]
+	    set itemList($rTag) [list $iTag $tTag $text $numItems]
+	    set textList($numItems) [string tolower $text]
+	    incr numItems
+	}
+	my WhenIdle Arrange
+	return
+    }
+
+    #	Gets called when the user invokes the IconList (usually by
+    #	double-clicking or pressing the Return key).
+    #
+    method invoke {} {
+	if {$options(-command) ne "" && [llength $selection]} {
+	    uplevel #0 $options(-command)
+	}
+    }
+
+    #	If the item is not (completely) visible, scroll the canvas so that it
+    #	becomes visible.
+    #
+    method see rTag {
+	if {$noScroll} {
+	    return
+	}
+	set sRegion [$canvas cget -scrollregion]
+	if {$sRegion eq ""} {
+	    return
+	}
+
+	if {$rTag < 0 || $rTag >= [llength $list]} {
+	    return
+	}
+
+	set bbox [$canvas bbox item$rTag]
+	set pad [expr {[$canvas cget -highlightthickness]+[$canvas cget -bd]}]
+
+	set x1 [lindex $bbox 0]
+	set x2 [lindex $bbox 2]
+	incr x1 [expr {$pad * -2}]
+	incr x2 [expr {$pad * -1}]
+
+	set cW [expr {[winfo width $canvas] - $pad*2}]
+
+	set scrollW [expr {[lindex $sRegion 2]-[lindex $sRegion 0]+1}]
+	set dispX [expr {int([lindex [$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 ne $dispX} {
+	    set fraction [expr {double($dispX) / double($scrollW)}]
+	    $canvas xview moveto $fraction
+	}
+    }
+
+    # ----------------------------------------------------------------------
+
+    #	Places the icons in a column-major arrangement.
+    #
+    method Arrange {} {
+	if {![info exists list]} {
+	    if {[info exists canvas] && [winfo exists $canvas]} {
+		set noScroll 1
+		$sbar configure -command ""
+	    }
+	    return
+	}
+
+	set W [winfo width  $canvas]
+	set H [winfo height $canvas]
+	set pad [expr {[$canvas cget -highlightthickness]+[$canvas cget -bd]}]
+	if {$pad < 2} {
+	    set pad 2
+	}
+
+	incr W [expr {$pad*-2}]
+	incr H [expr {$pad*-2}]
+
+	set dx [expr {$maxIW + $maxTW + 8}]
+	if {$maxTH > $maxIH} {
+	    set dy $maxTH
+	} else {
+	    set dy $maxIH
+	}
+	incr dy 2
+	set shift [expr {$maxIW + 4}]
+
+	set x [expr {$pad * 2}]
+	set y [expr {$pad * 1}] ; # Why * 1 ?
+	set usedColumn 0
+	foreach sublist $list {
+	    set usedColumn 1
+	    lassign $sublist iTag tTag rTag iW iH tW tH
+
+	    set i_dy [expr {($dy - $iH)/2}]
+	    set t_dy [expr {($dy - $tH)/2}]
+
+	    $canvas coords $iTag $x [expr {$y + $i_dy}]
+	    $canvas coords $tTag [expr {$x + $shift}] [expr {$y + $t_dy}]
+	    $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} {
+	    $canvas configure -scrollregion [list $pad $pad $sW $H]
+	    $sbar configure -command ""
+	    $canvas xview moveto 0
+	    set noScroll 1
+	} else {
+	    $canvas configure -scrollregion [list $pad $pad $sW $H]
+	    $sbar configure -command [list $canvas xview]
+	    set noScroll 0
+	}
+
+	set itemsPerColumn [expr {($H-$pad) / $dy}]
+	if {$itemsPerColumn < 1} {
+	    set itemsPerColumn 1
+	}
+
+	my DrawSelection
+    }
+
+    method DrawSelection {} {
+	$canvas delete selection
+	$canvas itemconfigure selectionText -fill $fill
+	$canvas dtag selectionText
+	set cbg [ttk::style lookup TEntry -selectbackground focus]
+	set cfg [ttk::style lookup TEntry -selectforeground focus]
+	foreach item $selection {
+	    set rTag [lindex $list $item 2]
+	    foreach {iTag tTag text serial} $itemList($rTag) {
+		break
+	    }
+
+	    set bbox [$canvas bbox $tTag]
+	    $canvas create rect $bbox -fill $cbg -outline $cbg \
+		-tags selection
+	    $canvas itemconfigure $tTag -fill $cfg -tags selectionText
+	}
+	$canvas lower selection
+	return
+    }
+
+    #	Creates an IconList widget by assembling a canvas widget and a
+    #	scrollbar widget. Sets all the bindings necessary for the IconList's
+    #	operations.
+    #
+    method Create {} {
+	variable hull
+	set sbar [ttk::scrollbar $hull.sbar -orient horizontal -takefocus 0]
+	catch {$sbar configure -highlightthickness 0}
+	set canvas [canvas $hull.canvas -highlightthick 0 -takefocus 1 \
+			-width 400 -height 120 -background white]
+	pack $sbar -side bottom -fill x -padx 2 -pady {0 2}
+	pack $canvas -expand yes -fill both -padx 2 -pady {2 0}
+
+	$sbar configure -command [list $canvas xview]
+	$canvas configure -xscrollcommand [list $sbar set]
+
+	# Initializes the max icon/text width and height and other variables
+	#
+	set maxIW 1
+	set maxIH 1
+	set maxTW 1
+	set maxTH 1
+	set numItems 0
+	set noScroll 1
+	set selection {}
+	set index(anchor) ""
+	set fill black
+
+	# Creates the event bindings.
+	#
+	bind $canvas <Configure>	[namespace code {my WhenIdle Arrange}]
+
+	bind $canvas <Button-1>		[namespace code {my Btn1 %x %y}]
+	bind $canvas <B1-Motion>	[namespace code {my Motion1 %x %y}]
+	bind $canvas <B1-Leave>		[namespace code {my Leave1 %x %y}]
+	bind $canvas <Control-Button-1>	[namespace code {my CtrlBtn1 %x %y}]
+	bind $canvas <Shift-Button-1>	[namespace code {my ShiftBtn1 %x %y}]
+	bind $canvas <B1-Enter>		[list tk::CancelRepeat]
+	bind $canvas <ButtonRelease-1>	[list tk::CancelRepeat]
+	bind $canvas <Double-ButtonRelease-1> \
+	    [namespace code {my Double1 %x %y}]
+
+	bind $canvas <Control-B1-Motion> {;}
+	bind $canvas <Shift-B1-Motion>	[namespace code {my ShiftMotion1 %x %y}]
+
+	if {[tk windowingsystem] eq "aqua"} {
+	    bind $canvas <Shift-MouseWheel>	[namespace code {my MouseWheel [expr {40 * (%D)}]}]
+	    bind $canvas <Option-Shift-MouseWheel>	[namespace code {my MouseWheel [expr {400 * (%D)}]}]
+	    bind $canvas <Command-Key> 	{# nothing}
+	    bind $canvas <Mod4-Key>	{# nothing}
+	} else {
+	    bind $canvas <Shift-MouseWheel>	[namespace code {my MouseWheel %D}]
+	}
+	if {[tk windowingsystem] eq "x11"} {
+	    bind $canvas <Shift-Button-4>	[namespace code {my MouseWheel 120}]
+	    bind $canvas <Shift-Button-5>	[namespace code {my MouseWheel -120}]
+	}
+
+	bind $canvas <<PrevLine>>	[namespace code {my UpDown -1}]
+	bind $canvas <<NextLine>>	[namespace code {my UpDown  1}]
+	bind $canvas <<PrevChar>>	[namespace code {my LeftRight -1}]
+	bind $canvas <<NextChar>>	[namespace code {my LeftRight  1}]
+	bind $canvas <Return>		[namespace code {my ReturnKey}]
+	bind $canvas <Key>		[namespace code {my KeyPress %A}]
+	bind $canvas <Alt-Key>		{# nothing}
+	bind $canvas <Meta-Key> 	{# nothing}
+	bind $canvas <Control-Key> 	{# nothing}
+
+	bind $canvas <FocusIn>		[namespace code {my FocusIn}]
+	bind $canvas <FocusOut>		[namespace code {my FocusOut}]
+
+	return $w
+    }
+
+    #	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.
+    #
+    method AutoScan {} {
+	if {![winfo exists $w]} return
+	set x $oldX
+	set y $oldY
+	if {$noScroll} {
+	    return
+	}
+	if {$x >= [winfo width $canvas]} {
+	    $canvas xview scroll 1 units
+	} elseif {$x < 0} {
+	    $canvas xview scroll -1 units
+	} elseif {$y >= [winfo height $canvas]} {
+	    # do nothing
+	} elseif {$y < 0} {
+	    # do nothing
+	} else {
+	    return
+	}
+	my Motion1 $x $y
+	set ::tk::Priv(afterId) [after 50 [namespace code {my AutoScan}]]
+    }
+
+    # ----------------------------------------------------------------------
+
+    # Event handlers
+    method MouseWheel {amount} {
+	if {$noScroll || $::tk_strictMotif} {
+	    return
+	}
+	if {$amount > 0} {
+	    $canvas xview scroll [expr {(-119-$amount) / 120}] units
+	} else {
+	    $canvas xview scroll [expr {-($amount / 120)}] units
+	}
+    }
+    method Btn1 {x y} {
+	focus $canvas
+	set i [$w index @$x,$y]
+	if {$i eq ""} {
+	    return
+	}
+	$w selection clear 0 end
+	$w selection set $i
+	$w selection anchor $i
+    }
+    method CtrlBtn1 {x y} {
+	if {$options(-multiple)} {
+	    focus $canvas
+	    set i [$w index @$x,$y]
+	    if {$i eq ""} {
+		return
+	    }
+	    if {[$w selection includes $i]} {
+		$w selection clear $i
+	    } else {
+		$w selection set $i
+		$w selection anchor $i
+	    }
+	}
+    }
+    method ShiftBtn1 {x y} {
+	if {$options(-multiple)} {
+	    focus $canvas
+	    set i [$w index @$x,$y]
+	    if {$i eq ""} {
+		return
+	    }
+	    if {[$w index anchor] eq ""} {
+		$w selection anchor $i
+	    }
+	    $w selection clear 0 end
+	    $w selection set anchor $i
+	}
+    }
+
+    #	Gets called on button-1 motions
+    #
+    method Motion1 {x y} {
+	set oldX $x
+	set oldY $y
+	set i [$w index @$x,$y]
+	if {$i eq ""} {
+	    return
+	}
+	$w selection clear 0 end
+	$w selection set $i
+    }
+    method ShiftMotion1 {x y} {
+	set oldX $x
+	set oldY $y
+	set i [$w index @$x,$y]
+	if {$i eq ""} {
+	    return
+	}
+	$w selection clear 0 end
+	$w selection set anchor $i
+    }
+    method Double1 {x y} {
+	if {[llength $selection]} {
+	    $w invoke
+	}
+    }
+    method ReturnKey {} {
+	$w invoke
+    }
+    method Leave1 {x y} {
+	set oldX $x
+	set oldY $y
+	my AutoScan
+    }
+    method FocusIn {} {
+	$w state focus
+	if {![info exists list]} {
+	    return
+	}
+	if {[llength $selection]} {
+	    my DrawSelection
+	}
+    }
+    method FocusOut {} {
+	$w state !focus
+	$w selection clear 0 end
+    }
+
+    #	Moves the active element up or down by one element
+    #
+    # Arguments:
+    #	amount -	+1 to move down one item, -1 to move back one item.
+    #
+    method UpDown amount {
+	if {![info exists list]} {
+	    return
+	}
+	set curr [$w selection get]
+	if {[llength $curr] == 0} {
+	    set i 0
+	} else {
+	    set i [$w index anchor]
+	    if {$i eq ""} {
+		return
+	    }
+	    incr i $amount
+	}
+	$w selection clear 0 end
+	$w selection set $i
+	$w selection anchor $i
+	$w see $i
+    }
+
+    #	Moves the active element left or right by one column
+    #
+    # Arguments:
+    #	amount -	+1 to move right one column, -1 to move left one
+    #			column
+    #
+    method LeftRight amount {
+	if {![info exists list]} {
+	    return
+	}
+	set curr [$w selection get]
+	if {[llength $curr] == 0} {
+	    set i 0
+	} else {
+	    set i [$w index anchor]
+	    if {$i eq ""} {
+		return
+	    }
+	    incr i [expr {$amount * $itemsPerColumn}]
+	}
+	$w selection clear 0 end
+	$w selection set $i
+	$w selection anchor $i
+	$w see $i
+    }
+
+    #	Gets called when user enters an arbitrary key in the listbox.
+    #
+    method KeyPress key {
+	append accel $key
+	my Goto $accel
+	after cancel $accelCB
+	set accelCB [after 500 [namespace code {my Reset}]]
+    }
+
+    method Goto text {
+	if {![info exists list]} {
+	    return
+	}
+	if {$text eq "" || $numItems == 0} {
+	    return
+	}
+
+	if {[llength [$w selection get]]} {
+	    set start [$w index anchor]
+	} else {
+	    set start 0
+	}
+	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 a
+	# case-insensitive match with $text
+	while {1} {
+	    if {[string equal -nocase -length $len0 $textList($i) $text]} {
+		set theIndex $i
+		break
+	    }
+	    incr i
+	    if {$i == $numItems} {
+		set i 0
+	    }
+	    if {$i == $start} {
+		break
+	    }
+	}
+
+	if {$theIndex >= 0} {
+	    $w selection clear 0 end
+	    $w selection set $theIndex
+	    $w selection anchor $theIndex
+	    $w see $theIndex
+	}
+    }
+    method Reset {} {
+	unset -nocomplain accel
+    }
+}
+
+return
+
+# Local Variables:
+# mode: tcl
+# fill-column: 78
+# End:
diff --git a/mplug_owl2/lib/tk8.6/icons.tcl b/mplug_owl2/lib/tk8.6/icons.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..87af75a41d243816e8930d4aa6f99b6a3e67467a
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/icons.tcl
@@ -0,0 +1,153 @@
+# icons.tcl --
+#
+#	A set of stock icons for use in Tk dialogs. The icons used here
+#	were provided by the Tango Desktop project which provides a
+#	unified set of high quality icons licensed under the
+#	Creative Commons Attribution Share-Alike license
+#	(https://creativecommons.org/licenses/by-sa/3.0/)
+#
+#	See http://tango.freedesktop.org/Tango_Desktop_Project
+#
+# Copyright (c) 2009 Pat Thoyts <patthoyts@users.sourceforge.net>
+
+namespace eval ::tk::icons {}
+
+image create photo ::tk::icons::warning -data {
+    iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABHNCSVQICAgIfAhkiAAABSZJREFU
+    WIXll1toVEcYgL+Zc87u2Yu7MYmrWRuTJuvdiMuqiJd4yYKXgMQKVkSjFR80kFIVJfWCWlvpg4h9
+    8sXGWGof8iKNICYSo6JgkCBEJRG8ImYThNrNxmaTeM7pQ5IlJkabi0/9YZhhZv7///4z/8zPgf+7
+    KCNRLgdlJijXwRyuDTlcxV9hbzv8nQmxMjg+XDtiOEplkG9PSfkztGmTgmFQd+FCVzwa3fYN/PHZ
+    AcpBaReicW5xcbb64IEQqko8Lc26d/58cxS+/BY6hmJvyEfQBoUpwWCmW1FErKaGWHU13uRk4QkE
+    UtxQNFR7QwIoB4eiKD9PWbVKbb10CZmaCqmpxCormRYO26QQx85B0mcD+AeK0xYvHqu1tNDx+DH6
+    gQM4jh0j3tCA3tGBLyfHLuD7zwJwAcYqun44sHy51nr5MsqsWWj5+djCYdS5c4ldvUr24sU2qarf
+    lUL6qAN0wqH0vDy7+fAhXZEI+v79CNmt7igpofPVK5SmJvyhkJBwYlQBSiHd7vUWZ86bp8WqqtCW
+    LkVbuBAhBEIItGAQ2+rVxG7cICMY1KTDsekc5IwagIQTmStXis47dzBiMfR9+xCi+wb39s79+zFi
+    MczGRjLmzTMlnBoVgLMwyzF+/Cb/lClq2/Xr2AoKUKdPxzAMWltbiUajmKaJkpGBY8sW3tbW4g8E
+    VNXrXVEKK0YMoMKp7Px8K15Tg2VZOHbvBiASiRAMBgkGg0QiEYQQOIuLsRSFrnv3yJo/HxVOW594
+    7D4KUAa57qysvNSUFOVtbS32rVuRfj9CCFwuV2Kfy+VCCIFMScFVVET7/fukJidLm883rQy+HhaA
+    BUII8cvUNWt4W1WFcLvRd+5MnHl/AOjOB+eOHchx44jX1ZEdCqkSTpaDbcgA5+GrpNmzc9ymKdvr
+    67Hv2oVMSko4cjgcKIqCoijoup64EdLpxLV3Lx1PnuCVUrgmTfK9hV1DAjgKqlSUk1PCYdl25QrS
+    70cvLEw4SWS+04nT6XxvXgiBc8MGtKlTaa+rIysnR1Ok/OF38PxngAzY4VuwYKL99WvR8fQpjj17
+    kLqeiL6393g8eDyeAWBSVfEcOkRXczOOaBRvVpZuDPJEDwD4DVyKrv+UlZurxSorUWfMQC8oGOBc
+    CDHgC/Rdc4TD2BctIl5fT+bkyTahaXvOw8RPApiwd2Ju7hjZ2EhXSwvOkhKQcoADgIqKCioqKgYc
+    QW9LOnIEIxZDbWpiXCCABT9+FKAUxtm83pKMUEiLVVejLVqEtmTJB50LIdi2bRuFPbnRd7232efM
+    wbVuHR2PHjHR77dJXS8sg5mDAihweFJenmrevYvR1oazpGTQ6IQQaJqG7ClI/dd655IOHsSyLMSL
+    F6QFAib9nugEQClk2Xy+orTsbK3t1i3sa9ei5eQMGr0QgvLyci5evDiocyEEtsxMPNu30/nsGRO8
+    XlVzu8NlkNvrV+0T/fHMZcusrtu3MeNx9PXrobUVq8cYQrw3TrRub1h9+v573Bs3Ej1zBvP5c/zp
+    6dbLhoaTwPy+ANKCfF92thq7dg2A6JYt/fNlxGK8eUNSerryHEJHQT8K8V4A5ztojty8OeaLzZul
+    1DSwLCzDANPEMozusWFgmWZ33288YK3/nGlixuM0v3xpWfDX0Z4i1VupXEWwIgRnJfhGPfQ+YsLr
+    +7DzNFwCuvqWyiRg7DSYoIBu9smPkYqEd4AwIN4ITUAL0A4Da7UC6ICdEfy2fUBMoAvo7GnWKNoe
+    mfwLcAuinuFNL7QAAAAASUVORK5CYII=
+}
+
+image create photo ::tk::icons::error -data {
+    iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABHNCSVQICAgIfAhkiAAABiRJREFU
+    WIXFl11sHFcVgL97Z/bX693sbtd2ipOqCU7sQKukFYUigQgv/a+hoZGoqipvfQKpAsEDD0hIvCHE
+    j/pQ3sIDUdOiIqUyqXioEFSUhqit7cRJFJpEruxs1mt77Z3d2Z259/KwM5vZXTtOERJXOrozZ+6e
+    852fuXcW/s9D3O3Cs1Bow1Nx234BKQ9qpYpK6yFLSseScsVoveApdUrAzNOw9j8DOAMTtmX9RsM3
+    SqOjevcXDqUzu8dI5AvEc8O0axu4q6s4yzdZvnCxUSmXLWHMXzxjXpmGq/81wGmIZ6T8NXDi8w8d
+    id//+GPS8j1YWQXHgVYbfA/sGCRiMDQExTzKtvn3zDv6k9m5FsacXNT6+y+D95kAZqCEEO/cMzIy
+    9eBLLybjyodrN6DpDqw1/dfpFNw3TtuSfPz7P7irlZUL2pjHn4GVuwJ4G/JCiLl9U1OjB58/ZnP5
+    Mqxv3NGpMWZAz64cHNzHlTf/5N9YuHzTMeaLx6HW78+K3pwGKynEu/snJycOHPuWzdw81BuDUQZO
+    dfQ+MmvAuC1MdY3i178izUo15VZXj07DyTf6OGX0Jivlz0vFwgMTz3/bNnMXO0ZCo8b0iIk4C0WF
+    zsP1TRc1e4l9x56N5YuFwxkpf9afgW4J/gi7M1IuHH3lezm5uAQbmwOpjc79ujArA2uMgWwGMz7K
+    P377u/WW1pPTUB7IQFrKXx44NJWRbQ9d2+hGqbeRMEoTZEQFJdERfVgmvVFH+D57Jw9k4lL+YqAE
+    pyGnjZm+95knLHVjcVvHA6WIPgtLE+hVH4i6vsS9T3zTVsY8NwPZHoAUPFUs5JVQCt1q9zqORKm3
+    iLKrF6IjkfSHOiUlqu0hhCSXHdYePNYDEBPiu6MT+zOquo6JGNGhESkxUnYNmkCnLQtjWRgpMRG9
+    CtZ3JdD7axsU9+3N2EK8EALYQcNMpvfuQTcaXUMIAa+/Hi0Xgs9weASjefx4p5mFQDdbpD63G/HR
+    hakeAA2l+EgJU652iIMMyO2sRoYxBq1191oIgZQSITqooT0A7fnEirswUAp/LwG0MZlYIY9WqpPa
+    IHU7Da01Sqluo4UQSil830dr3emVsBeMIZbLoI0Z7gGQQtTbjoOOxW/XewcApVQ38jsBNs6fx6tW
+    O70Si+GWKwghNsM1NoCAW81KJTeUjKNbrR2N7uS4B7TRwJ+fR6TTxO4fxzUeAio9AMCl+tVrE0NH
+    DmM2nU4DAu6JE53UGoNfLuNdv45xnO4OF/ZKz+4X2T179I6D5To0NupouNgD4Btzqjx/8WjpS0cy
+    PU1Tr6MqFfylpc4bss1W26/rBwyfybECtcvXNrUxp3oAXJjZ2Kxb7cVP8P61gDGgWy2M624Z5d1E
+    3wNkDDKdwMQkjtuygbMhgAQ4DjUhxFvL/5z15X1jeLUaynW7p1u484WiuL3V9m/NoV6F50Ogjx3Y
+    Q/mDBV8a3piGzR4AAFfrHy4vlesmm0bks7edRQ6aAafcPoZVH2AUXOYzkI5TvbVa9+FHREYX4Bgs
+    I8RrV9/9oJF4eBKTjO8YvdoCJgqujcGkEqQemmDxb7OOFOLV6FHcAwBQ1/onTtOd/fTvH3rJRx/A
+    pBIDqd0q+p5sRaInnWDoywdZem+u7bbaH9W1/il9Y2Brfwt22TBfKOVHxr92JOacv4S/UuttuC06
+    PKoHsEs5hg7vZ/m9eW+zWltuwoNbfRNuebacgXsEnE2lkof2Hn04ZRouzQvXUU5z29cwFGs4TWpy
+    HJGK8+lfP256bnuuDU8+B9WtfG17uL0GsTF4VQrxYn60kBh55JDEbdG6uYq/7qDdFtpTELOQyQRW
+    Lk1sLI+MW9w6d8Wv3Vrz2nDyJPzgDDS287MVgAAywBCQ+Q5MTsOPs/BIMpVQ2bFCKlnMYg+nsYeS
+    eE6TVq1Be3WD9ZtrTc9tWetw7k341dtwBagDTmTeESAdAAxH5z0w9iQ8ehi+moWxBGRsiPvguVBf
+    h8qH8P6f4dxSp9PrdN73cN6k859R3U0J0nS+28JMpIM5FUgCiNP5X2ECox7gAk06KQ8ldLzZ7/xO
+    ANHnscBhCkgGjuOB3gb8CEAbaAWO3UA34DQ6/gPnmhBFs5mqXAAAAABJRU5ErkJggg==
+}
+
+image create photo ::tk::icons::information -data {
+    iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABmJLR0QA/wD/AP+gvaeTAAAACXBI
+    WXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH1gUdFDM4pWaDogAABwNJREFUWMPFlltsVNcVhv+199ln
+    bh7PjAdfMGNDcA04EKMkJlIsBVJVbRqlEVUrqyW0QAtFTVWpjVpFfamUF6K+tCTKQyXn0jaiShOr
+    bRqRoHJpEEoIEBucENuk2OViPB5f5j5zrvuc3YcMFQ8FPBFVj7S0paN91v+tf1/OAv7PD9UzeeCp
+    p0KRCrYyHtymoPrgySYAANdyBBr2Peu1agP+NrR/v3nHAb6/52d7wfivWlet11NdvZG21laEwzo0
+    RvA9F4uLi7h08bxxaWLUVp78xSsv/XrwjgAMDDyjRxPWUGOy5Uu9/VsjEA3I5KvIVQ240gHIh9CA
+    5YkwelIJRATw94NvGpnpK0fL+eDA0NAzzq3ya7cDjCbsoWWr1j+y4f4vB/41Z8JTeaxqE7hndSNi
+    EeELzn3LkapQdfzJTE5JV/GBb28LHz327lcnzp4ZAvB1AOpmAvyWtv/g6R9GW1c+uf6Bx0Kfzpjo
+    TmnYtDaKtkTAj4aEFBqTnJPUOfciIeG3N4XVQtmyzl/JuY8/fH9wOjO/smvVmuy5s+8P1w2wa9dP
+    46SLN3sf2ha7uiixaU0Qna06NA6PMXIZQRJBMiIXRBKABygv3hBQV+bK1dmcoR7d3Bc5c/pk/8YN
+    fYOjo6es/6bDbgbAdLa9uXNj2PYF2pOEloQGAiRIuUTkME42J7IZweYES+NkckZWWNfseEPAKJtO
+    oWxLu69/c5jpbPtNdW7qPwvsbO1cF8pVLKxs0+HD94gpl0AOQTlEsDkjizFmMk4WESyNM4NzMgOC
+    VYI6q17OlIp9992ngek769+EvtfVEI3jWqaKgAgAIAlFLuOwGZHDiTnElGQgF4DvM1LKV7Bdz2NE
+    xaCuhQpVm1Y0p5qhvNV1AyjlRTWhwVM2TMdzgkJzieAQyGGMbMZgfwZBEiBPA3xX+VSouAvBAFeM
+    yDddD7rgpHw/WjcAMa0EZScZk5heqFrxiO4BzCGCzYgsBrI4I5sYcxlBKl/5WdOdd6S0gxoLEZEi
+    Iq4AnzGq1r0HiPhYuZRFU1R3FgqWkS1aZQA2gWzOyGQcJudkaAwVR3qz8yXzvCXlzJoViaagrlWC
+    jJnLm8Jarli2GNMm6wbwPPO31y6Ollc2N3pcI+fyYjW/8a5EKqQTz5WtdLHsTi1W7Im5vDlcMdxx
+    wVk2Ys9/pTI3+WhAaIauM+MLbYnlH46MVKVyX6v7Hhg9e2ps3doN32ld0Rlrb1nmmK4stCdCSCUj
+    Le1NwW6uXJ08m/t2OarBXh0ie0syHu0plKtTFGw8n4o33q1z1XngD7+X3C/uHBkZces7hoAi1946
+    fPSvtpDlYFdLPDI8mR03HC87frXwFpgqLYuFuzrbkg8m49EeDsqDa+cizXcNpppia5ui+sYXnn+O
+    29LbOTg4aHzun9GOPT/pDemhf3xzx25DicjkiqaAIs4zhumMRUJaPhzgJZ0LQ5C7gXjQL1kS0YD+
+    o337nhWlYvHJV178zZ9vlZ/dDuDVl57/2HWt755894hINoYSmZx11TYKCUZKCs4cnQuDmGtfvDiR
+    dD3n04aA6J4YHzeLhfLg7cSXBAAA5NPpufS1WFjwkFSelZ6ZLWfn0kliTDJdue8dO9qenp2d1DVR
+    4cTarlyZJgV5dim5lwTw8sv7c1L6H89cm6FlDcHVhlOJffThsa9d+ud72y5+cnTn2PjJJ1avjOoE
+    SnBiPadOfRDTGT5YSm5tqR2R7Zp7//L6gRPf27NjVaolqS9MCzh28W6mgDXdKxCNRb/oOlV18O3D
+    1xzXGXpx8LnZO94Tbt/x+MFYouexh7dsQU/PWjRGI+BcAyMgm1vAO28fxvj4xOX5jL7u0KEX7Dvq
+    AAC0Nucf2rLZhq8Y3njjT8gulOBKDw0NAQjNQT435eQWL3iHDk3YS81ZF0B6psI/GbuAXbu+gQf7
+    H4ArPeQWC5jLZKCUhQvjWb2QD3bVk5PVM9nz5LML8waOH38fekBHIhFDqqMFXd0pnDhxGmMTU3Bd
+    9/X/GQDntO/eezswMPBjaFwAABxH4sKFq+jt7cX6ni6EQuJbdeWsZ3J3d/PTmqaEYUyhXDZBTEOh
+    WIIQwOi5jzA1eRnZXPFSPO7/bmbGlLfqhus5BVotRH9/x7rGxtBeIQJPACrMOYNSPpRiUIpnlTIO
+    nzmT+eX8fLH8WZMKF4Csje7ncUAHEKhFcHq6ZE5OZoc7O3tlc3N33+7dP9c2bXoE09NlO52uHDhy
+    ZOTVatUWte+otsTXg2pQSwagG6r/jwsAQul0erqjo+OesbGx1tHRUT+fz48dP378j57neQD8mtB1
+    B1TtnV9zo64loJqoXhtFDUQHEGhvb2/2fZ9nMpliTcAFYNdC1sIBYN1sCeq5Ca9bqtWcu9Fe3FDl
+    9Uqvu3HLjfhvTUo85WzjhogAAAAASUVORK5CYII=
+}
+
+image create photo ::tk::icons::question -data {
+    iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABHNCSVQICAgIfAhkiAAACG5JREFU
+    WIXFl3twVdUVxn97n3Nubm7euZcghEdeBBICEQUFIgVECqIo1uJMp3WodqyjMzpjZ7TTh20cK31N
+    /2jL2FYdKXaqRcbnDKGpoBFaAY1BHgHMgyRKQkJy87yv3Nyzd/84594k1RlppzPumTXn3Dl3r/Wd
+    b31rrbPhS17iSv+4bl2t2ZFhrRGI7QKxRkMAyHEfjwgYEOgjNnpfcXjiSENDbeL/AqBoW22uGE/7
+    MYL7yubN4MYVpVkrquaKqwJZ+LPTARgcjdIbHKOx+aI+9EH7WGvnZdA8q9PGf9b5eu3w/wygaPPO
+    h6Uhntxcsyj9/q+vtMrnBa6Is7ZPgzzzyvGJ/YfPRpWWj3fWff93/xWAonW1Xu3z/nVx6cxNTz74
+    1YzK4gIQjuN/nfyEEx9fIjgaYXAkhhAQyE3Hn5PBsvJZrF46l5I5+QB83NnP40+/FT7d1ltPOPrN
+    zoba2BcCWLy91hMOp72/bX1VxU/u3+BJ91i0fhrkuTcaaTzbjTQkhpQIIZBSIBApL1prtNYsryhk
+    xy1XUzonn1g8wVPPvh1/5dDpcz5f7LrmfbXxqfGM6eG1yCw+9uq2G6tW7nxoU5plGrzecJYnnnub
+    SwMhTNPAmmKmYWCaBoYpMQyJaRhIQ3IpGOKt4+1k+dKoLJ7BjStKjb6hcN7JloFrhlsO7oUnPh9A
+    8Rbvo6uuLrr3N4/ckm4Ykt/vPcqe/R9hGAamaWJZbnDL+W2axqRJA8NlxzAkAI3newhF4lxbMZs1
+    y4rNM+19c0PZ++NDLQff+0wKCu/Y6c/UVsubv/12/ryZubxUf5Ln3vgQ0zKnvK1kadkMlpQUUFEU
+    oCDPR25WOuPxBH2DYZpa+qg/3kEoGsdWCttWJGzF3ZuXcuf6Ci5eHmXrw7sHR4mXd7/2w+A0Bvyl
+    N+265/bl19+8eqE8c6GPn+85jGkYWC4Ay3Luf/3AV1g038+MXB8+rwfDkKR5TPKyvCyan8+qqtmc
+    au8nFrcdnQCn2vuoLptJSWEeE7bynDjdXTDUcvBNAAmweF1tpmXKu+65bYWh0Ty97zhSyGkUO0BM
+    hBAI4RAXTyjiCYWUEukKMz/Ly/b1C7EsE49lYlkmhjTYvf8jNHD3lmsM0zTuWryuNhPABIj4vFvW
+    Xl0s87PTOdXWS8snQTwec4ro3DSYBglbcfx8P+8199I7FMEQgg3L53N7TWkKXOV8Px7LJCFtXKx0
+    dA9zrnOAyqIAa68tkQePtm4BXpaO9vWOm65b4EPAkY+6HDEZTt4NN/dJML946QSv/fMCA6PjpHks
+    LI/F2a5BtNYpMUtJirGpLL7f3A3AxpXlPiHFjhQDaJZVlc0EoPWT4DQ1m8ZkKizTJDRuY1mmC04i
+    pWDNksJUD9Bac7E/jGUZrmuN1qCU5sKlIQAqSwrQWi+bBCDwF+RnAk5fl27wqeYAkZM9wLWaxVex
+    qnJmKritFO+e7sMyDdBOc1JKYxiSkdA4CMGM3Aw02j+VAfLcwTIWibuiEpNApJMSw208ydJcu3QW
+    axZPCW7bHGjspmcwimkYTmAlMWzHTyTmDMiczLRU/ctkNxgajboPvUghppuUGFJMY6O6OJ/ViwIo
+    pVBKYds2dR9e4uPuMbc7Tm9MUgqyM70AjITHUy1IAghNsH8oDEAgz4cQOIqWjkkpEC4rSYfXL/Sn
+    giulONYyRFd/1GXKAZxkUrgvkp/tAAgORxAQnAQg5InmC5cBWDgv4NS5EAhAINzyIlVmUgiy040U
+    9Uop2voiKYakEAiRvDp7EYKS2XkAnOvsR0h5IqUBrfWeQ8fb1t2xvtJXs3QuB462TfZokbxMGZxC
+    8If6DtI8Fh6PhcdjojSpBuXin7Kc3csXzQLgrWOtEWWrPSkAvkis7kjTBTU8FqOypIAF8/x09Y6Q
+    FGjyTdHJstLsWDsnNZIBXj7Wj1LKYSS5B412nRTNymHBnHxGQ+O8836r8kVidakUNDfUhhIJtfcv
+    dU22AO69dRlCCNeZU8fJe6U0ylZYBlgGmNKx+ESCiYRNwlYoWzn/UxqtHOB3ra8AAX/7x0nbttXe
+    5oba0GQVAPGE9dju1z4Y7u4fY9F8P9/YWOUEV06O7eTVnXBTBaiUIj4xwcSETSJhk7BtbNtOPdta
+    U0ZpYS59wRB/2ndsOBa3HkvGTU3D0fb6aE7ZBt3RM1yzuabcqiwKEI5N0N495ChaSKcihJPRa0pz
+    sbUmYTugPmgbJmErB4DLxETC5oYlhWxdXUrCVvxgV32krav/qa4Djx76D4kllxalt/7q9e2bqjf9
+    9Lsb0oQQHGrsYO+hc0gp3emW/Bhxm5NbZlqD0g79CTcFt60u4YYlhWhg5/MN4y/WNdW3vfnoNhD6
+    Mww46wlmV9/w6snzA1sHRqKBVUvnGQvm+qkuKyA4GqVvKOJAdrcn8zz14yNh2ywozOVbGyuoKg4w
+    PmHzyxcOx1+sazqTlhbZ3H92vT29Pj5nzVn1SLqVH3ipunzOxqceutlX6n7lXrw8yqn2flq7hxgL
+    TzAWiyOFICfTS44vjbLCXKqK/cwOOHOl49IwP9r192hT84V3e4+9cF90sC0IRL8QAOADsgvXfu9B
+    b3bgkTs3LPN+52srzPlX5V7RUerTy6M8/0Zj4uUDH45Hg13PdB/9425gzLUhQH0RgDQgC8hKLyid
+    7a/c9oCV4d9WVTpLbF5TmX5tRaGYkecjJ8MLAkZD4wyMRGg636PrDjfHzrT26NhYT33w1Kt/Hh/u
+    6XUDh4BBIHwlDIBTohlANpBhWb6s7PKNK30FCzZa6dnVYORoIX2OExVF26Px8NCZSN/5d0bb3mlK
+    JGIhHLpDwLAL4jPnxSs9nBqABXhddrw4XdRygSrABuKuxYBx9/6KDqlf2vo3PYe56vmkuwMAAAAA
+    SUVORK5CYII=
+}
diff --git a/mplug_owl2/lib/tk8.6/listbox.tcl b/mplug_owl2/lib/tk8.6/listbox.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..44abfb9452c601917a66ff4fc4379997c98f1cab
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/listbox.tcl
@@ -0,0 +1,560 @@
+# listbox.tcl --
+#
+# This file defines the default bindings for Tk listbox widgets
+# and provides procedures that help in implementing those bindings.
+#
+# Copyright (c) 1994 The Regents of the University of California.
+# Copyright (c) 1994-1995 Sun Microsystems, Inc.
+# Copyright (c) 1998 by Scriptics Corporation.
+#
+# See the file "license.terms" for information on usage and redistribution
+# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+
+#--------------------------------------------------------------------------
+# tk::Priv elements used in this file:
+#
+# afterId -		Token returned by "after" for autoscanning.
+# listboxPrev -	The last element to be selected or deselected
+#			during a selection operation.
+# listboxSelection -	All of the items that were selected before the
+#			current selection operation (such as a mouse
+#			drag) started;  used to cancel an operation.
+#--------------------------------------------------------------------------
+
+#-------------------------------------------------------------------------
+# The code below creates the default class bindings for listboxes.
+#-------------------------------------------------------------------------
+
+# Note: the check for existence of %W below is because this binding
+# is sometimes invoked after a window has been deleted (e.g. because
+# there is a double-click binding on the widget that deletes it).  Users
+# can put "break"s in their bindings to avoid the error, but this check
+# makes that unnecessary.
+
+bind Listbox <1> {
+    if {[winfo exists %W]} {
+	tk::ListboxBeginSelect %W [%W index @%x,%y] 1
+    }
+}
+
+# Ignore double clicks so that users can define their own behaviors.
+# Among other things, this prevents errors if the user deletes the
+# listbox on a double click.
+
+bind Listbox <Double-1> {
+    # Empty script
+}
+
+bind Listbox <B1-Motion> {
+    set tk::Priv(x) %x
+    set tk::Priv(y) %y
+    tk::ListboxMotion %W [%W index @%x,%y]
+}
+bind Listbox <ButtonRelease-1> {
+    tk::CancelRepeat
+    %W activate @%x,%y
+}
+bind Listbox <Shift-1> {
+    tk::ListboxBeginExtend %W [%W index @%x,%y]
+}
+bind Listbox <Control-1> {
+    tk::ListboxBeginToggle %W [%W index @%x,%y]
+}
+bind Listbox <B1-Leave> {
+    set tk::Priv(x) %x
+    set tk::Priv(y) %y
+    tk::ListboxAutoScan %W
+}
+bind Listbox <B1-Enter> {
+    tk::CancelRepeat
+}
+
+bind Listbox <<PrevLine>> {
+    tk::ListboxUpDown %W -1
+}
+bind Listbox <<SelectPrevLine>> {
+    tk::ListboxExtendUpDown %W -1
+}
+bind Listbox <<NextLine>> {
+    tk::ListboxUpDown %W 1
+}
+bind Listbox <<SelectNextLine>> {
+    tk::ListboxExtendUpDown %W 1
+}
+bind Listbox <<PrevChar>> {
+    %W xview scroll -1 units
+}
+bind Listbox <<PrevWord>> {
+    %W xview scroll -1 pages
+}
+bind Listbox <<NextChar>> {
+    %W xview scroll 1 units
+}
+bind Listbox <<NextWord>> {
+    %W xview scroll 1 pages
+}
+bind Listbox <Prior> {
+    %W yview scroll -1 pages
+    %W activate @0,0
+}
+bind Listbox <Next> {
+    %W yview scroll 1 pages
+    %W activate @0,0
+}
+bind Listbox <Control-Prior> {
+    %W xview scroll -1 pages
+}
+bind Listbox <Control-Next> {
+    %W xview scroll 1 pages
+}
+bind Listbox <<LineStart>> {
+    %W xview moveto 0
+}
+bind Listbox <<LineEnd>> {
+    %W xview moveto 1
+}
+bind Listbox <Control-Home> {
+    %W activate 0
+    %W see 0
+    %W selection clear 0 end
+    %W selection set 0
+    tk::FireListboxSelectEvent %W
+}
+bind Listbox <Control-Shift-Home> {
+    tk::ListboxDataExtend %W 0
+}
+bind Listbox <Control-End> {
+    %W activate end
+    %W see end
+    %W selection clear 0 end
+    %W selection set end
+    tk::FireListboxSelectEvent %W
+}
+bind Listbox <Control-Shift-End> {
+    tk::ListboxDataExtend %W [%W index end]
+}
+bind Listbox <<Copy>> {
+    if {[selection own -displayof %W] eq "%W"} {
+	clipboard clear -displayof %W
+	clipboard append -displayof %W [selection get -displayof %W]
+    }
+}
+bind Listbox <space> {
+    tk::ListboxBeginSelect %W [%W index active]
+}
+bind Listbox <<Invoke>> {
+    tk::ListboxBeginSelect %W [%W index active]
+}
+bind Listbox <Select> {
+    tk::ListboxBeginSelect %W [%W index active]
+}
+bind Listbox <Control-Shift-space> {
+    tk::ListboxBeginExtend %W [%W index active]
+}
+bind Listbox <Shift-Select> {
+    tk::ListboxBeginExtend %W [%W index active]
+}
+bind Listbox <Escape> {
+    tk::ListboxCancel %W
+}
+bind Listbox <<SelectAll>> {
+    tk::ListboxSelectAll %W
+}
+bind Listbox <<SelectNone>> {
+    if {[%W cget -selectmode] ne "browse"} {
+	%W selection clear 0 end
+        tk::FireListboxSelectEvent %W
+    }
+}
+
+# Additional Tk bindings that aren't part of the Motif look and feel:
+
+bind Listbox <2> {
+    %W scan mark %x %y
+}
+bind Listbox <B2-Motion> {
+    %W scan dragto %x %y
+}
+
+# The MouseWheel will typically only fire on Windows and Mac OS X.
+# However, someone could use the "event generate" command to produce
+# one on other platforms.
+
+if {[tk windowingsystem] eq "aqua"} {
+    bind Listbox <MouseWheel> {
+        %W yview scroll [expr {-(%D)}] units
+    }
+    bind Listbox <Option-MouseWheel> {
+        %W yview scroll [expr {-10 * (%D)}] units
+    }
+    bind Listbox <Shift-MouseWheel> {
+        %W xview scroll [expr {-(%D)}] units
+    }
+    bind Listbox <Shift-Option-MouseWheel> {
+        %W xview scroll [expr {-10 * (%D)}] units
+    }
+} else {
+    bind Listbox <MouseWheel> {
+	if {%D >= 0} {
+	    %W yview scroll [expr {-%D/30}] units
+	} else {
+	    %W yview scroll [expr {(29-%D)/30}] units
+	}
+    }
+    bind Listbox <Shift-MouseWheel> {
+	if {%D >= 0} {
+	    %W xview scroll [expr {-%D/30}] units
+	} else {
+	    %W xview scroll [expr {(29-%D)/30}] units
+	}
+    }
+}
+
+if {[tk windowingsystem] eq "x11"} {
+    # 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:
+    #	https://linuxreviews.org/HOWTO_change_the_mouse_speed_in_X
+    bind Listbox <4> {
+	if {!$tk_strictMotif} {
+	    %W yview scroll -5 units
+	}
+    }
+    bind Listbox <Shift-4> {
+	if {!$tk_strictMotif} {
+	    %W xview scroll -5 units
+	}
+    }
+    bind Listbox <5> {
+	if {!$tk_strictMotif} {
+	    %W yview scroll 5 units
+	}
+    }
+    bind Listbox <Shift-5> {
+	if {!$tk_strictMotif} {
+	    %W xview 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 {focus 1}} {
+    variable ::tk::Priv
+    if {[$w cget -selectmode] eq "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
+    }
+    tk::FireListboxSelectEvent $w
+    # check existence as ListboxSelect may destroy us
+    if {$focus && [winfo exists $w] && [$w cget -state] eq "normal"} {
+	focus $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
+	    tk::FireListboxSelectEvent $w
+	}
+	extended {
+	    set i $Priv(listboxPrev)
+	    if {$i < 0} {
+		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 {$i in $Priv(listboxSelection)} {
+		    $w selection set $i
+		}
+		incr i
+	    }
+	    while {($i > $el) && ($i > $anchor)} {
+		if {$i in $Priv(listboxSelection)} {
+		    $w selection set $i
+		}
+		incr i -1
+	    }
+	    set Priv(listboxPrev) $el
+	    tk::FireListboxSelectEvent $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 {[$w cget -selectmode] eq "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 {[$w cget -selectmode] eq "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
+	}
+	tk::FireListboxSelectEvent $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
+	    tk::FireListboxSelectEvent $w
+	}
+	extended {
+	    $w selection clear 0 end
+	    $w selection set active
+	    $w selection anchor active
+	    set Priv(listboxPrev) [$w index active]
+	    set Priv(listboxSelection) {}
+	    tk::FireListboxSelectEvent $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 {[$w cget -selectmode] ne "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 {$mode eq "extended"} {
+	$w activate $el
+	$w see $el
+        if {[$w selection includes anchor]} {
+	    ListboxMotion $w $el
+	}
+    } elseif {$mode eq "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 {[$w cget -selectmode] ne "extended"} {
+	return
+    }
+    set first [$w index anchor]
+    set last $Priv(listboxPrev)
+    if {$last eq ""} {
+	# 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 {$first in $Priv(listboxSelection)} {
+	    $w selection set $first
+	}
+	incr first
+    }
+    tk::FireListboxSelectEvent $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 {$mode eq "single" || $mode eq "browse"} {
+	$w selection clear 0 end
+	$w selection set active
+    } else {
+	$w selection set 0 end
+    }
+    tk::FireListboxSelectEvent $w
+}
+
+# ::tk::FireListboxSelectEvent
+#
+# Fire the <<ListboxSelect>> event if the listbox is not in disabled
+# state.
+#
+# Arguments:
+# w -		The listbox widget.
+
+proc ::tk::FireListboxSelectEvent w {
+    if {[$w cget -state] eq "normal"} {
+        event generate $w <<ListboxSelect>>
+    }
+}
diff --git a/mplug_owl2/lib/tk8.6/megawidget.tcl b/mplug_owl2/lib/tk8.6/megawidget.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..ec9f469adfe50c03d8ffa4449809704a892f64cc
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/megawidget.tcl
@@ -0,0 +1,297 @@
+# megawidget.tcl
+#
+#	Basic megawidget support classes. Experimental for any use other than
+#	the ::tk::IconList megawdget, which is itself only designed for use in
+#	the Unix file dialogs.
+#
+# Copyright (c) 2009-2010 Donal K. Fellows
+#
+# See the file "license.terms" for information on usage and redistribution of
+# this file, and for a DISCLAIMER OF ALL WARRANTIES.
+#
+
+package require Tk
+
+::oo::class create ::tk::Megawidget {
+    superclass ::oo::class
+    method unknown {w args} {
+	if {[string match .* $w]} {
+	    [self] create $w {*}$args
+	    return $w
+	}
+	next $w {*}$args
+    }
+    unexport new unknown
+    self method create {name superclasses body} {
+	next $name [list \
+		superclass ::tk::MegawidgetClass {*}$superclasses]\;$body
+    }
+}
+
+::oo::class create ::tk::MegawidgetClass {
+    variable w hull options IdleCallbacks
+    constructor args {
+	# Extract the "widget name" from the object name
+	set w [namespace tail [self]]
+
+	# Configure things
+	tclParseConfigSpec [my varname options] [my GetSpecs] "" $args
+
+	# Move the object out of the way of the hull widget
+	rename [self] _tmp
+
+	# Make the hull widget(s)
+	my CreateHull
+	bind $hull <Destroy> [list [namespace which my] destroy]
+
+	# Rename things into their final places
+	rename ::$w theWidget
+	rename [self] ::$w
+
+	# Make the contents
+	my Create
+    }
+    destructor {
+	foreach {name cb} [array get IdleCallbacks] {
+	    after cancel $cb
+	    unset IdleCallbacks($name)
+	}
+	if {[winfo exists $w]} {
+	    bind $hull <Destroy> {}
+	    destroy $w
+	}
+    }
+
+    ####################################################################
+    #
+    # MegawidgetClass::configure --
+    #
+    #	Implementation of 'configure' for megawidgets. Emulates the operation
+    #	of the standard Tk configure method fairly closely, which makes things
+    #	substantially more complex than they otherwise would be.
+    #
+    #	This method assumes that the 'GetSpecs' method returns a description
+    #	of all the specifications of the options (i.e., as Tk returns except
+    #	with the actual values removed). It also assumes that the 'options'
+    #	array in the class holds all options; it is up to subclasses to set
+    #	traces on that array if they want to respond to configuration changes.
+    #
+    #	TODO: allow unambiguous abbreviations.
+    #
+    method configure args {
+	# Configure behaves differently depending on the number of arguments
+	set argc [llength $args]
+	if {$argc == 0} {
+	    return [lmap spec [my GetSpecs] {
+		lappend spec $options([lindex $spec 0])
+	    }]
+	} elseif {$argc == 1} {
+	    set opt [lindex $args 0]
+	    if {[info exists options($opt)]} {
+		set spec [lsearch -inline -index 0 -exact [my GetSpecs] $opt]
+		return [linsert $spec end $options($opt)]
+	    }
+	} elseif {$argc == 2} {
+	    # Special case for where we're setting a single option. This
+	    # avoids some of the costly operations. We still do the [array
+	    # get] as this gives a sufficiently-consistent trace.
+	    set opt [lindex $args 0]
+	    if {[dict exists [array get options] $opt]} {
+		# Actually set the new value of the option. Use a catch to
+		# allow a megawidget user to throw an error from a write trace
+		# on the options array to reject invalid values.
+		try {
+		    array set options $args
+		} on error {ret info} {
+		    # Rethrow the error to get a clean stack trace
+		    return -code error -errorcode [dict get $info -errorcode] $ret
+		}
+		return
+	    }
+	} elseif {$argc % 2 == 0} {
+	    # Check that all specified options exist. Any unknown option will
+	    # cause the merged dictionary to be bigger than the options array
+	    set merge [dict merge [array get options] $args]
+	    if {[dict size $merge] == [array size options]} {
+		# Actually set the new values of the options. Use a catch to
+		# allow a megawidget user to throw an error from a write trace
+		# on the options array to reject invalid values
+		try {
+		    array set options $args
+		} on error {ret info} {
+		    # Rethrow the error to get a clean stack trace
+		    return -code error -errorcode [dict get $info -errorcode] $ret
+		}
+		return
+	    }
+	    # Due to the order of the merge, the unknown options will be at
+	    # the end of the dict. This makes the first unknown option easy to
+	    # find.
+	    set opt [lindex [dict keys $merge] [array size options]]
+	} else {
+	    set opt [lindex $args end]
+	    return -code error -errorcode [list TK VALUE_MISSING] \
+		"value for \"$opt\" missing"
+	}
+	return -code error -errorcode [list TK LOOKUP OPTION $opt] \
+	    "bad option \"$opt\": must be [tclListValidFlags options]"
+    }
+
+    ####################################################################
+    #
+    # MegawidgetClass::cget --
+    #
+    #	Implementation of 'cget' for megawidgets. Emulates the operation of
+    #	the standard Tk cget method fairly closely.
+    #
+    #	This method assumes that the 'options' array in the class holds all
+    #	options; it is up to subclasses to set traces on that array if they
+    #	want to respond to configuration reads.
+    #
+    #	TODO: allow unambiguous abbreviations.
+    #
+    method cget option {
+	return $options($option)
+    }
+
+    ####################################################################
+    #
+    # MegawidgetClass::TraceOption --
+    #
+    #	Sets up the tracing of an element of the options variable.
+    #
+    method TraceOption {option method args} {
+	set callback [list my $method {*}$args]
+	trace add variable options($option) write [namespace code $callback]
+    }
+
+    ####################################################################
+    #
+    # MegawidgetClass::GetSpecs --
+    #
+    #	Return a list of descriptions of options supported by this
+    #	megawidget. Each option is described by the 4-tuple list, consisting
+    #	of the name of the option, the "option database" name, the "option
+    #	database" class-name, and the default value of the option. These are
+    #	the same values returned by calling the configure method of a widget,
+    #	except without the current values of the options.
+    #
+    method GetSpecs {} {
+	return {
+	    {-takefocus takeFocus TakeFocus {}}
+	}
+    }
+
+    ####################################################################
+    #
+    # MegawidgetClass::CreateHull --
+    #
+    #	Creates the real main widget of the megawidget. This is often a frame
+    #	or toplevel widget, but isn't always (lightweight megawidgets might
+    #	use a content widget directly).
+    #
+    #	The name of the hull widget is given by the 'w' instance variable. The
+    #	name should be written into the 'hull' instance variable. The command
+    #	created by this method will be renamed.
+    #
+    method CreateHull {} {
+	return -code error -errorcode {TCL OO ABSTRACT_METHOD} \
+	    "method must be overridden"
+    }
+
+    ####################################################################
+    #
+    # MegawidgetClass::Create --
+    #
+    #	Creates the content of the megawidget. The name of the widget to
+    #	create the content in will be in the 'hull' instance variable.
+    #
+    method Create {} {
+	return -code error -errorcode {TCL OO ABSTRACT_METHOD} \
+	    "method must be overridden"
+    }
+
+    ####################################################################
+    #
+    # MegawidgetClass::WhenIdle --
+    #
+    #	Arrange for a method to be called on the current instance when Tk is
+    #	idle. Only one such method call per method will be queued; subsequent
+    #	queuing actions before the callback fires will be silently ignored.
+    #	The additional args will be passed to the callback, and the callbacks
+    #	will be properly cancelled if the widget is destroyed.
+    #
+    method WhenIdle {method args} {
+	if {![info exists IdleCallbacks($method)]} {
+	    set IdleCallbacks($method) [after idle [list \
+		    [namespace which my] DoWhenIdle $method $args]]
+	}
+    }
+    method DoWhenIdle {method arguments} {
+	unset IdleCallbacks($method)
+	tailcall my $method {*}$arguments
+    }
+}
+
+####################################################################
+#
+# tk::SimpleWidget --
+#
+#	Simple megawidget class that makes it easy create widgets that behave
+#	like a ttk widget. It creates the hull as a ttk::frame and maps the
+#	state manipulation methods of the overall megawidget to the equivalent
+#	operations on the ttk::frame.
+#
+::tk::Megawidget create ::tk::SimpleWidget {} {
+    variable w hull options
+    method GetSpecs {} {
+	return {
+	    {-cursor cursor Cursor {}}
+	    {-takefocus takeFocus TakeFocus {}}
+	}
+    }
+    method CreateHull {} {
+	set hull [::ttk::frame $w -cursor $options(-cursor)]
+	my TraceOption -cursor UpdateCursorOption
+    }
+    method UpdateCursorOption args {
+	$hull configure -cursor $options(-cursor)
+    }
+    # Not fixed names, so can't forward
+    method state args {
+	tailcall $hull state {*}$args
+    }
+    method instate args {
+	tailcall $hull instate {*}$args
+    }
+}
+
+####################################################################
+#
+# tk::FocusableWidget --
+#
+#	Simple megawidget class that makes a ttk-like widget that has a focus
+#	ring.
+#
+::tk::Megawidget create ::tk::FocusableWidget ::tk::SimpleWidget {
+    variable w hull options
+    method GetSpecs {} {
+	return {
+	    {-cursor cursor Cursor {}}
+	    {-takefocus takeFocus TakeFocus ::ttk::takefocus}
+	}
+    }
+    method CreateHull {} {
+	ttk::frame $w
+	set hull [ttk::entry $w.cHull -takefocus 0 -cursor $options(-cursor)]
+	pack $hull -expand yes -fill both -ipadx 2 -ipady 2
+	my TraceOption -cursor UpdateCursorOption
+    }
+}
+
+return
+
+# Local Variables:
+# mode: tcl
+# fill-column: 78
+# End:
diff --git a/mplug_owl2/lib/tk8.6/menu.tcl b/mplug_owl2/lib/tk8.6/menu.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..f6ec29ad0d7c99ca21e0a9cd11e5ca90169739d3
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/menu.tcl
@@ -0,0 +1,1387 @@
+# 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.
+#
+# Copyright (c) 1992-1994 The Regents of the University of California.
+# Copyright (c) 1994-1997 Sun Microsystems, Inc.
+# Copyright (c) 1998-1999 Scriptics Corporation.
+# Copyright (c) 2007 Daniel A. Steffen <das@users.sourceforge.net>
+#
+# 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 <<MenuSelect>> virtual event.
+# activeItem -		This is the last active menu item for
+#			use with the <<MenuSelect>> 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 <FocusIn> {}
+bind Menubutton <Enter> {
+    tk::MbEnter %W
+}
+bind Menubutton <Leave> {
+    tk::MbLeave %W
+}
+bind Menubutton <Button-1> {
+    if {$tk::Priv(inMenubutton) ne ""} {
+	tk::MbPost $tk::Priv(inMenubutton) %X %Y
+    }
+}
+bind Menubutton <Motion> {
+    tk::MbMotion %W up %X %Y
+}
+bind Menubutton <B1-Motion> {
+    tk::MbMotion %W down %X %Y
+}
+bind Menubutton <ButtonRelease-1> {
+    tk::MbButtonUp %W
+}
+bind Menubutton <space> {
+    tk::MbPost %W
+    tk::MenuFirstEntry [%W cget -menu]
+}
+bind Menubutton <<Invoke>> {
+    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 <FocusIn> {}
+
+bind Menu <Enter> {
+    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 <Leave> {
+    tk::MenuLeave %W %X %Y %s
+}
+bind Menu <Motion> {
+    tk::MenuMotion %W %x %y %s
+}
+bind Menu <Button> {
+    tk::MenuButtonDown %W
+}
+bind Menu <ButtonRelease> {
+   tk::MenuInvoke %W 1
+}
+bind Menu <space> {
+    tk::MenuInvoke %W 0
+}
+bind Menu <<Invoke>> {
+    tk::MenuInvoke %W 0
+}
+bind Menu <Return> {
+    tk::MenuInvoke %W 0
+}
+bind Menu <Escape> {
+    tk::MenuEscape %W
+}
+bind Menu <<PrevChar>> {
+    tk::MenuLeftArrow %W
+}
+bind Menu <<NextChar>> {
+    tk::MenuRightArrow %W
+}
+bind Menu <<PrevLine>> {
+    tk::MenuUpArrow %W
+}
+bind Menu <<NextLine>> {
+    tk::MenuDownArrow %W
+}
+bind Menu <Key> {
+    tk::TraverseWithinMenu %W %A
+    break
+}
+
+# The following bindings apply to all windows, and are used to
+# implement keyboard menu traversal.
+
+if {[tk windowingsystem] eq "x11"} {
+    bind all <Alt-Key> {
+	tk::TraverseToMenu %W %A
+    }
+
+    bind all <F10> {
+	tk::FirstMenu %W
+    }
+} else {
+    bind Menubutton <Alt-Key> {
+	tk::TraverseToMenu %W %A
+    }
+
+    bind Menubutton <F10> {
+	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 {$Priv(inMenubutton) ne ""} {
+	MbLeave $Priv(inMenubutton)
+    }
+    set Priv(inMenubutton) $w
+    if {[$w cget -state] ne "disabled" && [tk windowingsystem] ne "aqua"} {
+	$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 {[$w cget -state] eq "active" && [tk windowingsystem] ne "aqua"} {
+	$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
+
+    if {[$w cget -state] eq "disabled" || $w eq $Priv(postedMb)} {
+	return
+    }
+    set menu [$w cget -menu]
+    if {$menu eq ""} {
+	return
+    }
+    set tearoff [expr {[tk windowingsystem] eq "x11" \
+	    || [$menu cget -type] eq "tearoff"}]
+    if {[string first $w $menu] != 0} {
+	return -code error -errorcode {TK MENUBUTTON POST_NONCHILD} \
+	    "can't post $menu: it isn't a descendant of $w"
+    }
+    set cur $Priv(postedMb)
+    if {$cur ne ""} {
+	MenuUnpost {}
+    }
+    if {$::tk_strictMotif} {
+	set Priv(cursor) [$w cget -cursor]
+	$w configure -cursor arrow
+    }
+    if {[tk windowingsystem] ne "aqua"} {
+	set Priv(relief) [$w cget -relief]
+	$w configure -relief raised
+    } else {
+	$w configure -state active
+    }
+
+    set Priv(postedMb) $w
+    set Priv(focus) [focus]
+    $menu activate none
+    GenerateMenuSelect $menu
+    update idletasks
+
+    if {[catch {PostMenubuttonMenu $w $menu $x $y} msg opt]} {
+	# Error posting menu (e.g. bogus -postcommand). Unpost it and
+	# reflect the error.
+	MenuUnpost {}
+	return -options $opt $msg
+    }
+
+    set Priv(tearoff) $tearoff
+    if {$tearoff != 0 && [tk windowingsystem] ne "aqua"} {
+	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 {
+    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.
+
+    after cancel [array get Priv menuActivatedTimer]
+    unset -nocomplain Priv(menuActivated)
+    after cancel [array get Priv menuDeactivatedTimer]
+    unset -nocomplain Priv(menuDeactivated)
+
+    catch {
+	if {$mb ne ""} {
+	    set menu [$mb cget -menu]
+	    $menu unpost
+	    set Priv(postedMb) {}
+	    if {$::tk_strictMotif} {
+		$mb configure -cursor $Priv(cursor)
+	    }
+	    if {[tk windowingsystem] ne "aqua"} {
+		$mb configure -relief $Priv(relief)
+	    } else {
+		$mb configure -state normal
+	    }
+	} elseif {$Priv(popup) ne ""} {
+	    $Priv(popup) unpost
+	    set Priv(popup) {}
+	} elseif {[$menu cget -type] ne "menubar" && [$menu cget -type] ne "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 {[winfo class $parent] ne "Menu" || ![winfo ismapped $parent]} {
+		    break
+		}
+		$parent activate none
+		$parent postcascade none
+		GenerateMenuSelect $parent
+		set type [$parent cget -type]
+		if {$type eq "menubar" || $type eq "tearoff"} {
+		    break
+		}
+		set menu $parent
+	    }
+	    if {[$menu cget -type] ne "menubar"} {
+		$menu unpost
+	    }
+	}
+    }
+
+    if {($Priv(tearoff) != 0) || $Priv(menuBar) ne ""} {
+	# Release grab, if any, and restore the previous grab, if there
+	# was one.
+	if {$menu ne ""} {
+	    set grab [grab current $menu]
+	    if {$grab ne ""} {
+		grab release $grab
+	    }
+	}
+	RestoreOldGrab
+	if {$Priv(menuBar) ne ""} {
+	    if {$::tk_strictMotif} {
+		$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 {$Priv(inMenubutton) eq $w} {
+	return
+    }
+    set new [winfo containing $rootx $rooty]
+    if {$new ne $Priv(inMenubutton) \
+	    && ($new eq "" || [winfo toplevel $new] eq [winfo toplevel $w])} {
+	if {$Priv(inMenubutton) ne ""} {
+	    MbLeave $Priv(inMenubutton)
+	}
+	if {$new ne "" \
+		&& [winfo class $new] eq "Menubutton" \
+		&& ([$new cget -indicatoron] == 0) \
+		&& ([$w cget -indicatoron] == 0)} {
+	    if {$upDown eq "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
+
+    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 {$menu eq $Priv(window)} {
+	set activeindex [$menu index active]
+	if {[$menu cget -type] eq "menubar"} {
+	    if {[info exists Priv(focus)] && $menu ne $Priv(focus)} {
+		$menu activate @$x,$y
+		GenerateMenuSelect $menu
+	    }
+	} else {
+	    $menu activate @$x,$y
+	    GenerateMenuSelect $menu
+	}
+	set index [$menu index @$x,$y]
+	if {[info exists Priv(menuActivated)] \
+		&& $index ne "none" \
+		&& $index >= 0 \
+		&& $index ne $activeindex} {
+	    set mode [option get $menu clickToFocus ClickToFocus]
+	    if {[string is false $mode]} {
+		set delay [expr {[$menu cget -type] eq "menubar" ? 0 : 50}]
+		if {[$menu type $index] eq "cascade"} {
+		    # Catch these postcascade commands since the menu could be
+		    # destroyed before they run.
+		    set Priv(menuActivatedTimer) \
+			[after $delay [list catch [list \
+			    $menu postcascade active]]]
+		} else {
+		    set Priv(menuDeactivatedTimer) \
+			[after $delay [list catch [list
+			    $menu postcascade none]]]
+		}
+	    }
+	}
+    }
+}
+
+# ::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
+
+    if {![winfo viewable $menu]} {
+	return
+    }
+    set activeindex [$menu index active]
+    if {($activeindex eq "none") || ($activeindex < 0)} {
+	if {[$menu cget -type] ne "menubar" } {
+	    set Priv(window) {}
+	}
+	return
+    }
+    $menu postcascade active
+    if {$Priv(postedMb) ne "" && [winfo viewable $Priv(postedMb)]} {
+	grab -global $Priv(postedMb)
+    } else {
+	while {[$menu cget -type] eq "normal" \
+		&& [winfo class [winfo parent $menu]] eq "Menu" \
+		&& [winfo ismapped [winfo parent $menu]]} {
+	    set menu [winfo parent $menu]
+	}
+
+	if {$Priv(menuBar) eq {}} {
+	    set Priv(menuBar) $menu
+	    if {$::tk_strictMotif} {
+		set Priv(cursor) [$menu cget -cursor]
+		$menu configure -cursor arrow
+	    }
+	    if {[$menu type active] eq "cascade"} {
+		set Priv(menuActivated) 1
+	    }
+	}
+
+	# 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 {$menu ne [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 {[tk windowingsystem] eq "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) {}
+    set activeindex [$menu index active]
+    if {($activeindex eq "none") || ($activeindex < 0)} {
+	return
+    }
+    if {[$menu type active] eq "cascade" \
+	    && [winfo containing $rootx $rooty] eq \
+		[$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 && $Priv(window) eq ""} {
+	# 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 <<MenuSelect>>
+	MenuUnpost $w
+	return
+    }
+    if {[$w type active] eq "cascade"} {
+	$w postcascade active
+	set menu [$w entrycget active -menu]
+	MenuFirstEntry $menu
+    } elseif {[$w type active] eq "tearoff"} {
+	::tk::TearOffMenu $w
+	MenuUnpost $w
+    } elseif {[$w cget -type] eq "menubar"} {
+	$w postcascade none
+	set activeindex [$w index active]
+	set isCascade [string equal [$w type $activeindex] "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 <<MenuSelect>>
+	}
+
+	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 $activeindex]
+	}
+    } else {
+	set activeindex [$w index active]
+	if {($Priv(popup) eq "") || (($activeindex ne "none") && ($activeindex >= 0))} {
+	    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 {[winfo class $parent] ne "Menu"} {
+	MenuUnpost $menu
+    } elseif {[$parent cget -type] eq "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 {[$menu cget -type] eq "menubar"} {
+	MenuNextMenu $menu left
+    } else {
+	MenuNextEntry $menu -1
+    }
+}
+
+proc ::tk::MenuDownArrow {menu} {
+    if {[$menu cget -type] eq "menubar"} {
+	MenuNextMenu $menu right
+    } else {
+	MenuNextEntry $menu 1
+    }
+}
+
+proc ::tk::MenuLeftArrow {menu} {
+    if {[$menu cget -type] eq "menubar"} {
+	MenuNextEntry $menu -1
+    } else {
+	MenuNextMenu $menu left
+    }
+}
+
+proc ::tk::MenuRightArrow {menu} {
+    if {[$menu cget -type] eq "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 {$direction eq "right"} {
+	set count 1
+	set parent [winfo parent $menu]
+	set class [winfo class $parent]
+	if {[$menu type active] eq "cascade"} {
+	    $menu postcascade active
+	    set m2 [$menu entrycget active -menu]
+	    if {$m2 ne ""} {
+		MenuFirstEntry $m2
+	    }
+	    return
+	} else {
+	    set parent [winfo parent $menu]
+	    while {$parent ne "."} {
+		if {[winfo class $parent] eq "Menu" \
+			&& [$parent cget -type] eq "menubar"} {
+		    tk_menuSetFocus $parent
+		    MenuNextEntry $parent 1
+		    return
+		}
+		set parent [winfo parent $parent]
+	    }
+	}
+    } else {
+	set count -1
+	set m2 [winfo parent $menu]
+	if {[winfo class $m2] eq "Menu"} {
+	    $menu activate none
+	    GenerateMenuSelect $menu
+	    tk_menuSetFocus $m2
+
+	    $m2 postcascade none
+
+	    if {[$m2 cget -type] ne "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 {[winfo class $m2] eq "Menu" && [$m2 cget -type] eq "menubar"} {
+	tk_menuSetFocus $m2
+	MenuNextEntry $m2 -1
+	return
+    }
+
+    set w $Priv(postedMb)
+    if {$w eq ""} {
+	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 {[winfo class $mb] eq "Menubutton" \
+		&& [$mb cget -state] ne "disabled" \
+		&& [$mb cget -menu] ne "" \
+		&& [[$mb cget -menu] index last] ne "none" \
+		&& [[$mb cget -menu] index last] >= 0} {
+	    break
+	}
+	if {$mb eq $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} {
+    set last [$menu index last]
+    if {($last eq "none") || ($last < 0)} {
+	return
+    }
+    set length [expr {$last+1}]
+    set quitAfter $length
+    set activeindex [$menu index active]
+    if {($activeindex eq "none") || ($activeindex < 0)} {
+	set i 0
+    } else {
+	set i [expr {$activeindex + $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 == $activeindex} {
+	    return
+	}
+	incr i $count
+	incr quitAfter -1
+    }
+    $menu activate $i
+    GenerateMenuSelect $menu
+
+    if {[$menu type $i] eq "cascade" && [$menu cget -type] eq "menubar"} {
+	set cascade [$menu entrycget $i -menu]
+	if {$cascade ne ""} {
+	    # 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 {[winfo toplevel $w] ne [winfo toplevel $child]} {
+	    continue
+	}
+	if {[winfo class $child] eq "Menu" && \
+		[$child cget -type] eq "menubar"} {
+	    if {$char eq ""} {
+		return $child
+	    }
+	    set last [$child index last]
+	    for {set i [$child cget -tearoff]} {$i <= $last} {incr i} {
+		if {([$child type $i] eq "separator") || ([$child entrycget $i -state] eq "disabled")} {
+		    continue
+		}
+		set underline [$child entrycget $i -underline]
+		if {$underline >= 0} {
+		    if {$char eq [string tolower [string index [$child entrycget $i -label] $underline]]} {
+			return $child
+		    }
+		}
+	    }
+	}
+    }
+
+    foreach child $windowlist {
+	# Don't descend into other toplevels.
+	if {[winfo toplevel $w] ne [winfo toplevel $child]} {
+	    continue
+	}
+	switch -- [winfo class $child] {
+	    Menubutton {
+		set char2 [string index [$child cget -text] \
+			[$child cget -underline]]
+		if {$char eq [string tolower $char2] || $char eq ""} {
+		    if {[$child cget -state] ne "disabled"} {
+			return $child
+		    }
+		}
+	    }
+
+	    default {
+		set match [MenuFind $child $char]
+		if {$match ne ""} {
+		    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 {![winfo exists $w] || $char eq ""} {
+	return
+    }
+    while {[winfo class $w] eq "Menu"} {
+	if {[$w cget -type] eq "menubar"} {
+	    break
+	} elseif {$Priv(postedMb) eq ""} {
+	    return
+	}
+	set w [winfo parent $w]
+    }
+    set w [MenuFind [winfo toplevel $w] $char]
+    if {$w ne ""} {
+	if {[winfo class $w] eq "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 {$w ne ""} {
+	if {[winfo class $w] eq "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 {$char eq ""} {
+	return
+    }
+    set char [string tolower $char]
+    set last [$w index last]
+    if {$last eq "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 {$char eq [string tolower $char2]} {
+	    if {[$w type $i] eq "cascade"} {
+		$w activate $i
+		$w postcascade active
+		event generate $w <<MenuSelect>>
+		set m2 [$w entrycget $i -menu]
+		if {$m2 ne ""} {
+		    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 {$menu eq ""} {
+	return
+    }
+    tk_menuSetFocus $menu
+    set activeindex [$menu index active]
+    if {($activeindex ne "none") && ($activeindex >= 0)} {
+	return
+    }
+    set last [$menu index last]
+    if {$last eq "none"} {
+	return
+    }
+    for {set i 0} {$i <= $last} {incr i} {
+	if {([catch {set state [$menu entrycget $i -state]}] == 0) \
+		&& $state ne "disabled" && [$menu type $i] ne "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 {[$menu type $i] eq "cascade" && [$menu cget -type] eq "menubar"} {
+		set cascade [$menu entrycget $i -menu]
+		if {$cascade ne ""} {
+		    $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 {$last eq "none"} {
+	return ""
+    }
+    for {set i 0} {$i <= $last} {incr i} {
+	if {![catch {$menu entrycget $i -label} label]} {
+	    if {$label eq $s} {
+		return $i
+	    }
+	}
+    }
+    return ""
+}
+
+# ::tk::PostMenubuttonMenu --
+#
+# Given a menubutton and a menu, this procedure posts the menu at the
+# appropriate location.  If the menubutton looks like an option
+# menubutton, meaning that the indicator is on and the direction is
+# neither above nor below, then the menu is posted so that the current
+# entry is vertically aligned with the menubutton.  On the Mac this
+# will expose a small amount of the blue indicator on the right hand
+# side.  On other platforms the entry is centered over the button.
+
+if {[tk windowingsystem] eq "aqua"} {
+    proc ::tk::PostMenubuttonMenu {button menu cx cy} {
+	set entry ""
+	if {[$button cget -indicatoron]} {
+	    set entry [MenuFindName $menu [$button cget -text]]
+	    if {$entry eq ""} {
+		set entry 0
+	    }
+	}
+	set x [winfo rootx $button]
+	set y [expr {2 + [winfo rooty $button]}]
+	switch [$button cget -direction] {
+	    above {
+		set entry ""
+		incr y [expr {4 - [winfo reqheight $menu]}]
+	    }
+	    below {
+		set entry ""
+		incr y [expr {2 + [winfo height $button]}]
+	    }
+	    left {
+		incr x [expr {-[winfo reqwidth $menu]}]
+	    }
+	    right {
+		incr x [winfo width $button]
+	    }
+	    default {  # flush
+		incr x [expr {[winfo width $button] - [winfo reqwidth $menu] - 5}]
+	    }
+	}
+	PostOverPoint $menu $x $y $entry
+    }
+} else {
+    proc ::tk::PostMenubuttonMenu {button menu cx cy} {
+	set entry ""
+	if {[$button cget -indicatoron]} {
+	    set entry [MenuFindName $menu [$button cget -text]]
+	    if {$entry eq ""} {
+		set entry 0
+	    }
+	}
+	set x [winfo rootx $button]
+	set y [winfo rooty $button]
+	switch [$button cget -direction] {
+	    above {
+		incr y [expr {-[winfo reqheight $menu]}]
+		# if we go offscreen to the top, show as 'below'
+		if {$y < [winfo vrooty $button]} {
+		    set y [expr {[winfo vrooty $button] + [winfo rooty $button]\
+			   + [winfo reqheight $button]}]
+		}
+		set entry {}
+	    }
+	    below {
+		incr y [winfo height $button]
+		# if we go offscreen to the bottom, show as 'above'
+		set mh [winfo reqheight $menu]
+		if {($y + $mh) > ([winfo vrooty $button] + [winfo vrootheight $button])} {
+		    set y [expr {[winfo vrooty $button] + [winfo vrootheight $button] \
+			   + [winfo rooty $button] - $mh}]
+		}
+		set entry {}
+	    }
+	    left {
+		incr x [expr {- [winfo reqwidth $menu]}]
+	    }
+	    right {
+		incr x [expr {[winfo width $button]}]
+	    }
+	    default {  # flush
+                if {[$button cget -indicatoron]} {
+                    if {$cx ne ""} {
+                        set x [expr {$cx - [winfo reqwidth $menu] / 2}]
+                        set l [font metrics [$menu cget -font] -linespace]
+                        set y [expr {$cy - $l/2 - 2}]
+                    } else {
+                        incr x [expr {([winfo width $button] - \
+				[winfo reqwidth $menu])/ 2}]
+                    }
+                } else {
+                    incr y [winfo height $button]
+                }
+	    }
+	}
+	PostOverPoint $menu $x $y $entry
+    }
+}
+
+# ::tk::PostOverPoint --
+#
+# This procedure posts a menu on the screen so that a given entry in
+# the menu is positioned with its upper left corner at a given point
+# in the root window.  The procedure also activates that entry.  If no
+# entry is specified the upper left corner of the entire menu is
+# placed at the point.
+#
+# 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).
+
+if {[tk windowingsystem] ne "win32"} {
+    proc ::tk::PostOverPoint {menu x y {entry {}}}  {
+	if {$entry ne ""} {
+	    $menu post $x $y $entry
+	    if {[$menu type $entry] ni {separator tearoff} &&
+		[$menu entrycget $entry -state] ne "disabled"} {
+		$menu activate $entry
+		GenerateMenuSelect $menu
+	    }
+	} else {
+	    $menu post $x $y
+	}
+	return
+    }
+} else {
+    proc ::tk::PostOverPoint {menu x y {entry {}}}  {
+	if {$entry ne ""} {
+	    incr y [expr {-[$menu yposition $entry]}]
+	}
+	# osVersion is not available in safe interps
+	set ver 5
+	if {[info exists ::tcl_platform(osVersion)]} {
+	    scan $::tcl_platform(osVersion) %d ver
+	}
+
+	# We need to fix some problems with menu posting on Windows,
+	# where, if the menu would overlap top or bottom of screen,
+	# Windows puts it in the wrong place for us.  We must also
+	# subtract an extra amount for half the height of the current
+	# entry.  To be safe we subtract an extra 10.
+	# NOTE: this issue appears to have been resolved in the Window
+	# manager provided with Vista and Windows 7.
+	if {$ver < 6} {
+	    set yoffset [expr {[winfo screenheight $menu] \
+				   - $y - [winfo reqheight $menu] - 10}]
+	    if {$yoffset < [winfo vrooty $menu]} {
+		# The bottom of the menu is offscreen, so adjust upwards
+		incr y [expr {$yoffset - [winfo vrooty $menu]}]
+	    }
+	    # 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 < [winfo vrooty $menu]} {
+		set y [winfo vrooty $menu]
+	    }
+	}
+	$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 {$Priv(grabStatus) eq "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)] || $Priv(focus) eq ""} {
+	set Priv(focus) [focus]
+    }
+    focus $menu
+}
+
+proc ::tk::GenerateMenuSelect {menu} {
+    variable ::tk::Priv
+
+    if {$Priv(activeMenu) ne $menu \
+	    || $Priv(activeItem) ne [$menu index active]} {
+	set Priv(activeMenu) $menu
+	set Priv(activeItem) [$menu index active]
+	event generate $menu <<MenuSelect>>
+    }
+}
+
+# ::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
+    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
+	set Priv(window) $menu
+	set Priv(menuActivated) 1
+	tk_menuSetFocus $menu
+    }
+}
diff --git a/mplug_owl2/lib/tk8.6/mkpsenc.tcl b/mplug_owl2/lib/tk8.6/mkpsenc.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..b3fd13d953c3b6ce7f223888e9ff886a27777f33
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/mkpsenc.tcl
@@ -0,0 +1,1488 @@
+# mkpsenc.tcl --
+#
+# This file generates the postscript prolog used by Tk.
+
+namespace eval ::tk {
+    # Creates Postscript encoding vector for ISO-8859-1 (could theoretically
+    # handle any 8-bit encoding, but Tk never generates characters outside
+    # ASCII).
+    #
+    proc CreatePostscriptEncoding {} {
+	variable psglyphs
+	# 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 "\[\n"
+	for {set i 0} {$i<256} {incr i 8} {
+	    for {set j 0} {$j<8} {incr j} {
+		set enc [encoding convertfrom "iso8859-1" \
+			[format %c [expr {$i+$j}]]]
+		catch {
+		    set hexcode {}
+		    set hexcode [format %04X [scan $enc %c]]
+		}
+		if {[info exists psglyphs($hexcode)]} {
+		    append result "/$psglyphs($hexcode)"
+		} else {
+		    append result "/space"
+		}
+	    }
+	    append result "\n"
+	}
+	append result "\]"
+	return $result
+    }
+
+    # List of adobe glyph names. Converted from glyphlist.txt, downloaded from
+    # Adobe.
+
+    variable psglyphs
+    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
+    }
+
+    variable ps_preamble {}
+
+    namespace eval ps {
+	namespace ensemble create
+	namespace export {[a-z]*}
+	proc literal {string} {
+	    upvar 0 ::tk::ps_preamble preamble
+	    foreach line [split $string \n] {
+		set line [string trim $line]
+		if {$line eq ""} continue
+		append preamble $line \n
+	    }
+	    return
+	}
+	proc variable {name value} {
+	    upvar 0 ::tk::ps_preamble preamble
+	    append preamble "/$name $value def\n"
+	    return
+	}
+	proc function {name body} {
+	    upvar 0 ::tk::ps_preamble preamble
+	    append preamble "/$name \{"
+	    foreach line [split $body \n] {
+		set line [string trim $line]
+		# Strip blank lines and comments from the bodies of functions
+		if {$line eq "" } continue
+		if {[string match {[%#]*} $line]} continue
+		append preamble $line " "
+	    }
+	    append preamble "\} bind def\n"
+	    return
+	}
+    }
+
+    ps literal {
+	%%BeginProlog
+	% This is a standard prolog for Postscript generated by Tk's canvas
+	% widget.
+    }
+    ps variable CurrentEncoding [CreatePostscriptEncoding]
+    ps literal {50 dict begin}
+
+    # 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).
+    ps variable baseline 0
+    ps variable stipimage 0
+    ps variable height 0
+    ps variable justify 0
+    ps variable lineLength 0
+    ps variable spacing 0
+    ps variable stipple 0
+    ps variable strings 0
+    ps variable xoffset 0
+    ps variable yoffset 0
+    ps variable tmpstip null
+    ps variable baselineSampler "( TXygqPZ)"
+    # Put an extra-tall character in; done this way to avoid encoding trouble
+    ps literal {baselineSampler 0 196 put}
+
+    ps function cstringshow {
+	{
+	    dup type /stringtype eq
+	    { show } { glyphshow }
+	    ifelse
+	} forall
+    }
+
+    ps function 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
+    }
+
+    # 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.
+    ps function 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
+    }
+
+    # 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.
+    ps function StrokeClip {
+	{strokepath} stopped {
+	    (This Postscript printer gets limitcheck overflows when) =
+	    (stippling dashed lines;  lines will be printed solid instead.) =
+	    [] 0 setdash strokepath} if
+	clip
+    }
+
+    # 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.
+    ps function 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
+    }
+
+    # 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.
+    ps function 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
+    }
+
+    # -- 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.
+    ps function AdjustColor {
+	CL 2 lt {
+	    currentgray
+	    CL 0 eq {
+		.5 lt {0} {1} ifelse
+	    } if
+	    setgray
+	} if
+    }
+
+    # 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, function 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.
+    ps function 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 baselineSampler false charpath
+	pathbbox dup /baseline exch def
+	exch pop exch sub /height exch def pop
+	newpath
+	% Translate and rotate coordinates first so that the origin is at
+	% the upper-left corner of the text's bounding box. Remember that
+	% angle for rotating, and x and y for positioning are still on the
+	% stack.
+	translate
+	rotate
+	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
+    }
+
+    # Define the "TkPhoto" function variants, which are modified versions
+    # of the original "transparentimage" function posted by ian@five-d.com
+    # (Ian Kemmish) to comp.lang.postscript. For a monochrome colorLevel
+    # this is a slightly different version that uses the imagemask command
+    # instead of image.
+
+    ps function TkPhotoColor {
+	gsave
+	32 dict begin
+	/tinteger exch def
+	/transparent 1 string def
+	transparent 0 tinteger put
+	/olddict exch def
+	olddict /DataSource get dup type /filetype ne {
+	    olddict /DataSource 3 -1 roll
+	    0 () /SubFileDecode filter put
+	} {
+	    pop
+	} ifelse
+	/newdict olddict maxlength dict def
+	olddict newdict copy pop
+	/w newdict /Width get def
+	/crpp newdict /Decode get length 2 idiv def
+	/str w string def
+	/pix w crpp mul string def
+	/substrlen 2 w log 2 log div floor exp cvi def
+	/substrs [ {
+	    substrlen string
+	    0 1 substrlen 1 sub {
+		1 index exch tinteger put
+	    } for
+	    /substrlen substrlen 2 idiv def
+	    substrlen 0 eq {exit} if
+	} loop ] def
+	/h newdict /Height get def
+	1 w div 1 h div matrix scale
+	olddict /ImageMatrix get exch matrix concatmatrix
+	matrix invertmatrix concat
+	newdict /Height 1 put
+	newdict /DataSource pix put
+	/mat [w 0 0 h 0 0] def
+	newdict /ImageMatrix mat put
+	0 1 h 1 sub {
+	    mat 5 3 -1 roll neg put
+	    olddict /DataSource get str readstring pop pop
+	    /tail str def
+	    /x 0 def
+	    olddict /DataSource get pix readstring pop pop
+	    {
+		tail transparent search dup /done exch not def
+		{exch pop exch pop} if
+		/w1 exch length def
+		w1 0 ne {
+		    newdict /DataSource
+		    pix x crpp mul w1 crpp mul getinterval put
+		    newdict /Width w1 put
+		    mat 4 x neg put
+		    /x x w1 add def
+		    newdict image
+		    /tail tail w1 tail length w1 sub getinterval def
+		} if
+		done {exit} if
+		tail substrs {
+		    anchorsearch {pop} if
+		} forall
+		/tail exch def
+		tail length 0 eq {exit} if
+		/x w tail length sub def
+	    } loop
+	} for
+	end
+	grestore
+    }
+    ps function TkPhotoMono {
+	gsave
+	32 dict begin
+	/dummyInteger exch def
+	/olddict exch def
+	olddict /DataSource get dup type /filetype ne {
+	    olddict /DataSource 3 -1 roll
+	    0 () /SubFileDecode filter put
+	} {
+	    pop
+	} ifelse
+	/newdict olddict maxlength dict def
+	olddict newdict copy pop
+	/w newdict /Width get def
+	/pix w 7 add 8 idiv string def
+	/h newdict /Height get def
+	1 w div 1 h div matrix scale
+	olddict /ImageMatrix get exch matrix concatmatrix
+	matrix invertmatrix concat
+	newdict /Height 1 put
+	newdict /DataSource pix put
+	/mat [w 0 0 h 0 0] def
+	newdict /ImageMatrix mat put
+	0 1 h 1 sub {
+	    mat 5 3 -1 roll neg put
+	    0.000 0.000 0.000 setrgbcolor
+	    olddict /DataSource get pix readstring pop pop
+	    newdict /DataSource pix put
+	    newdict imagemask
+	    1.000 1.000 1.000 setrgbcolor
+	    olddict /DataSource get pix readstring pop pop
+	    newdict /DataSource pix put
+	    newdict imagemask
+	} for
+	end
+	grestore
+    }
+
+    ps literal %%EndProlog
+}
+
+proc tk::ensure_psenc_is_loaded {} {
+}
diff --git a/mplug_owl2/lib/tk8.6/msgbox.tcl b/mplug_owl2/lib/tk8.6/msgbox.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..646c1434e0847ed0154ea06199e58bd7e207cd13
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/msgbox.tcl
@@ -0,0 +1,427 @@
+# msgbox.tcl --
+#
+#	Implements messageboxes for platforms that do not have native
+#	messagebox support.
+#
+# 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 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 "" "" ""}
+	{-detail "" "" ""}
+        {-icon "" "" "info"}
+        {-message "" "" ""}
+        {-parent "" "" .}
+        {-title "" "" " "}
+        {-type "" "" "ok"}
+    }
+
+    tclParseConfigSpec $w $specs "" $args
+
+    if {$data(-icon) ni {info warning error question}} {
+	return -code error -errorcode [list TK LOOKUP ICON $data(-icon)] \
+	    "bad -icon value \"$data(-icon)\": must be error, info, question, or warning"
+    }
+    set windowingsystem [tk windowingsystem]
+    if {$windowingsystem eq "aqua"} {
+	switch -- $data(-icon) {
+	    "error"     {set data(-icon) "stop"}
+	    "warning"   {set data(-icon) "caution"}
+	    "info"      {set data(-icon) "note"}
+	}
+    }
+
+    if {![winfo exists $data(-parent)]} {
+	return -code error -errorcode [list TK LOOKUP WINDOW $data(-parent)] \
+	    "bad window path name \"$data(-parent)\""
+    }
+
+    switch -- $data(-type) {
+	abortretryignore {
+	    set names [list abort retry ignore]
+	    set labels [list &Abort &Retry &Ignore]
+	    set cancel abort
+	}
+	ok {
+	    set names [list ok]
+	    set labels {&OK}
+	    set cancel ok
+	}
+	okcancel {
+	    set names [list ok cancel]
+	    set labels [list &OK &Cancel]
+	    set cancel cancel
+	}
+	retrycancel {
+	    set names [list retry cancel]
+	    set labels [list &Retry &Cancel]
+	    set cancel cancel
+	}
+	yesno {
+	    set names [list yes no]
+	    set labels [list &Yes &No]
+	    set cancel no
+	}
+	yesnocancel {
+	    set names [list yes no cancel]
+	    set labels [list &Yes &No &Cancel]
+	    set cancel cancel
+	}
+	default {
+	    return -code error -errorcode [list TK LOOKUP DLG_TYPE $data(-type)] \
+		"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) eq ""} {
+	set data(-default) [lindex [lindex $buttons 0] 0]
+    }
+
+    set valid 0
+    foreach btn $buttons {
+	if {[lindex $btn 0] eq $data(-default)} {
+	    set valid 1
+	    break
+	}
+    }
+    if {!$valid} {
+	return -code error -errorcode {TK MSGBOX DEFAULT} \
+	    "bad -default value \"$data(-default)\": must be\
+	    abort, retry, ignore, ok, cancel, no, or yes"
+    }
+
+    # 2. Set the dialog to be a child window of $parent
+    #
+    #
+    if {$data(-parent) ne "."} {
+	set w $data(-parent).__tk__messagebox
+    } else {
+	set w .__tk__messagebox
+    }
+
+    # There is only one background colour for the whole dialog
+    set bg [ttk::style lookup . -background]
+
+    # 3. Create the top-level window and divide it into top
+    # and bottom parts.
+
+    catch {destroy $w}
+    toplevel $w -class Dialog -bg $bg
+    wm title $w $data(-title)
+    wm iconname $w Dialog
+    wm protocol $w WM_DELETE_WINDOW [list $w.$cancel invoke]
+
+    # 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 {$windowingsystem eq "aqua"} {
+	::tk::unsupported::MacWindowStyle style $w moveableModal {}
+    } elseif {$windowingsystem eq "x11"} {
+        wm attributes $w -type dialog
+    }
+
+    ttk::frame $w.bot
+    grid anchor $w.bot center
+    pack $w.bot -side bottom -fill both
+    ttk::frame $w.top
+    pack $w.top -side top -fill both -expand 1
+
+    # 4. Fill the top part with bitmap, message and detail (use the
+    # option database for -wraplength and -font so that they can be
+    # overridden by the caller).
+
+    option add *Dialog.msg.wrapLength 3i widgetDefault
+    option add *Dialog.dtl.wrapLength 3i widgetDefault
+    option add *Dialog.msg.font TkCaptionFont widgetDefault
+    option add *Dialog.dtl.font TkDefaultFont widgetDefault
+
+    ttk::label $w.msg -anchor nw -justify left -text $data(-message)
+    if {$data(-detail) ne ""} {
+	ttk::label $w.dtl -anchor nw -justify left -text $data(-detail)
+    }
+    if {$data(-icon) ne ""} {
+	if {([winfo depth $w] < 4) || $tk_strictMotif} {
+	    # ttk::label has no -bitmap option
+	    label $w.bitmap -bitmap $data(-icon) -background $bg
+	} else {
+	    switch $data(-icon) {
+                error {
+                    ttk::label $w.bitmap -image ::tk::icons::error
+                }
+                info {
+                    ttk::label $w.bitmap -image ::tk::icons::information
+                }
+                question {
+                    ttk::label $w.bitmap -image ::tk::icons::question
+                }
+                default {
+                    ttk::label $w.bitmap -image ::tk::icons::warning
+                }
+	    }
+	}
+    }
+    grid $w.bitmap $w.msg -in $w.top -sticky news -padx 2m -pady 2m
+    grid configure $w.bitmap -sticky nw
+    grid columnconfigure $w.top 1 -weight 1
+    if {$data(-detail) ne ""} {
+	grid ^ $w.dtl -in $w.top -sticky news -padx 2m -pady {0 2m}
+	grid rowconfigure $w.top 1 -weight 1
+    } else {
+	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 ttk::button $w.$name] $opts \
+		[list -command [list set tk::Priv(button) $name]]
+
+	if {$name eq $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
+	# We boost the size of some Mac buttons for l&f
+	if {$windowingsystem eq "aqua"} {
+	    set tmp [string tolower $name]
+	    if {$tmp eq "ok" || $tmp eq "cancel" || $tmp eq "yes" ||
+		    $tmp eq "no" || $tmp eq "abort" || $tmp eq "retry" ||
+		    $tmp eq "ignore"} {
+		grid columnconfigure $w.bot $i -minsize 90
+	    }
+	    grid configure $w.$name -pady 7
+	}
+        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 <Alt-[string tolower $key]>  [list $w.$name invoke]
+        #     bind $w <Alt-[string toupper $key]>  [list $w.$name invoke]
+        # }
+    }
+    bind $w <Alt-Key> [list ::tk::AltKeyInDialog $w %A]
+
+    if {$data(-default) ne ""} {
+	bind $w <FocusIn> {
+	    if {[winfo class %W] in "Button TButton"} {
+		%W configure -default active
+	    }
+	}
+	bind $w <FocusOut> {
+	    if {[winfo class %W] in "Button TButton"} {
+		%W configure -default normal
+	    }
+	}
+    }
+
+    # 6. Create bindings for <Return>, <Escape> and <Destroy> on the dialog
+
+    bind $w <Return> {
+	if {[winfo class %W] in "Button TButton"} {
+	    %W invoke
+	}
+    }
+
+    # Invoke the designated cancelling operation
+    bind $w <Escape> [list $w.$cancel invoke]
+
+    # At <Destroy> the buttons have vanished, so must do this directly.
+    bind $w.msg <Destroy> [list set tk::Priv(button) $cancel]
+
+    # 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 (Motif style) and de-iconify it.
+
+    ::tk::PlaceWindow $w widget $data(-parent)
+
+    # 8. Set a grab and claim the focus too.
+
+    if {$data(-default) ne ""} {
+	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)
+    # Copy the result now so any <Destroy> that happens won't cause
+    # trouble
+    set result $Priv(button)
+
+    ::tk::RestoreFocusGrab $w $focus
+
+    return $result
+}
diff --git a/mplug_owl2/lib/tk8.6/obsolete.tcl b/mplug_owl2/lib/tk8.6/obsolete.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..3ee7f28616fd5ba98db8f52ae3ae6260208f01f1
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/obsolete.tcl
@@ -0,0 +1,178 @@
+# obsolete.tcl --
+#
+# This file contains obsolete procedures that people really shouldn't
+# be using anymore, but which are kept around for backward compatibility.
+#
+# 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 {}
+
+# ::tk::classic::restore --
+#
+# Restore the pre-8.5 (Tk classic) look as the widget defaults for classic
+# Tk widgets.
+#
+# The value following an 'option add' call is the new 8.5 value.
+#
+namespace eval ::tk::classic {
+    # This may need to be adjusted for some window managers that are
+    # more aggressive with their own Xdefaults (like KDE and CDE)
+    variable prio "widgetDefault"
+}
+
+proc ::tk::classic::restore {args} {
+    # Restore classic (8.4) look to classic Tk widgets
+    variable prio
+
+    if {[llength $args]} {
+	foreach what $args {
+	    ::tk::classic::restore_$what
+	}
+    } else {
+	foreach cmd [info procs restore_*] {
+	    $cmd
+	}
+    }
+}
+
+proc ::tk::classic::restore_font {args} {
+    # Many widgets were adjusted from hard-coded defaults to using the
+    # TIP#145 fonts defined in fonts.tcl (eg TkDefaultFont, TkFixedFont, ...)
+    # For restoring compatibility, we only correct size and weighting changes,
+    # as the fonts themselves remained mostly the same.
+    if {[tk windowingsystem] eq "x11"} {
+	font configure TkDefaultFont -weight bold ; # normal
+	font configure TkFixedFont -size -12 ; # -10
+    }
+    # Add these with prio 21 to override value in dialog/msgbox.tcl
+    if {[tk windowingsystem] eq "aqua"} {
+	option add *Dialog.msg.font system 21; # TkCaptionFont
+	option add *Dialog.dtl.font system 21; # TkCaptionFont
+	option add *ErrorDialog*Label.font system 21; # TkCaptionFont
+    } else {
+	option add *Dialog.msg.font {Times 12} 21; # TkCaptionFont
+	option add *Dialog.dtl.font {Times 10} 21; # TkCaptionFont
+	option add *ErrorDialog*Label.font {Times -18} 21; # TkCaptionFont
+    }
+}
+
+proc ::tk::classic::restore_button {args} {
+    variable prio
+    if {[tk windowingsystem] eq "x11"} {
+	foreach cls {Button Radiobutton Checkbutton} {
+	    option add *$cls.borderWidth 2 $prio; # 1
+	}
+    }
+}
+
+proc ::tk::classic::restore_entry {args} {
+    variable prio
+    # Entry and Spinbox share core defaults
+    foreach cls {Entry Spinbox} {
+	if {[tk windowingsystem] ne "aqua"} {
+	    option add *$cls.borderWidth	2 $prio; # 1
+	}
+	if {[tk windowingsystem] eq "x11"} {
+	    option add *$cls.background		"#d9d9d9" $prio; # "white"
+	    option add *$cls.selectBorderWidth	1 $prio; # 0
+	}
+    }
+}
+
+proc ::tk::classic::restore_listbox {args} {
+    variable prio
+    if {[tk windowingsystem] ne "win32"} {
+	option add *Listbox.background		"#d9d9d9" $prio; # "white"
+	option add *Listbox.activeStyle		"underline" $prio; # "dotbox"
+    }
+    if {[tk windowingsystem] ne "aqua"} {
+	option add *Listbox.borderWidth		2 $prio; # 1
+    }
+    if {[tk windowingsystem] eq "x11"} {
+	option add *Listbox.selectBorderWidth	1 $prio; # 0
+    }
+    # Remove focus into Listbox added for 8.5
+    bind Listbox <1> {
+	if {[winfo exists %W]} {
+	    tk::ListboxBeginSelect %W [%W index @%x,%y]
+	}
+    }
+}
+
+proc ::tk::classic::restore_menu {args} {
+    variable prio
+    if {[tk windowingsystem] eq "x11"} {
+	option add *Menu.activeBorderWidth	2 $prio; # 1
+	option add *Menu.borderWidth		2 $prio; # 1
+        option add *Menu.clickToFocus		true $prio
+        option add *Menu.useMotifHelp		true $prio
+    }
+    if {[tk windowingsystem] ne "aqua"} {
+	option add *Menu.font		"TkDefaultFont" $prio; # "TkMenuFont"
+    }
+}
+
+proc ::tk::classic::restore_menubutton {args} {
+    variable prio
+    option add *Menubutton.borderWidth	2 $prio; # 1
+}
+
+proc ::tk::classic::restore_message {args} {
+    variable prio
+    option add *Message.borderWidth	2 $prio; # 1
+}
+
+proc ::tk::classic::restore_panedwindow {args} {
+    variable prio
+    option add *Panedwindow.borderWidth	2 $prio; # 1
+    option add *Panedwindow.sashWidth	2 $prio; # 3
+    option add *Panedwindow.sashPad	2 $prio; # 0
+    option add *Panedwindow.sashRelief	raised $prio; # flat
+    option add *Panedwindow.opaqueResize	0 $prio; # 1
+    if {[tk windowingsystem] ne "win32"} {
+	option add *Panedwindow.showHandle	1 $prio; # 0
+    }
+}
+
+proc ::tk::classic::restore_scale {args} {
+    variable prio
+    option add *Scale.borderWidth	2 $prio; # 1
+    if {[tk windowingsystem] eq "x11"} {
+	option add *Scale.troughColor	"#c3c3c3" $prio; # "#b3b3b3"
+    }
+}
+
+proc ::tk::classic::restore_scrollbar {args} {
+    variable prio
+    if {[tk windowingsystem] eq "x11"} {
+	option add *Scrollbar.borderWidth	2 $prio; # 1
+	option add *Scrollbar.highlightThickness 1 $prio; # 0
+	option add *Scrollbar.width		15 $prio; # 11
+	option add *Scrollbar.troughColor	"#c3c3c3" $prio; # "#b3b3b3"
+    }
+}
+
+proc ::tk::classic::restore_text {args} {
+    variable prio
+    if {[tk windowingsystem] ne "aqua"} {
+	option add *Text.borderWidth	2 $prio; # 1
+    }
+    if {[tk windowingsystem] eq "win32"} {
+	option add *Text.font		"TkDefaultFont" $prio; # "TkFixedFont"
+    }
+    if {[tk windowingsystem] eq "x11"} {
+	option add *Text.background		"#d9d9d9" $prio; # white
+	option add *Text.selectBorderWidth	1 $prio; # 0
+    }
+}
diff --git a/mplug_owl2/lib/tk8.6/optMenu.tcl b/mplug_owl2/lib/tk8.6/optMenu.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..7cfdaa021f3d4a780e12aa3899f9b14efec45fa1
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/optMenu.tcl
@@ -0,0 +1,43 @@
+# optMenu.tcl --
+#
+# This file defines the procedure tk_optionMenu, which creates
+# an option button and its associated menu.
+#
+# 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 -highlightthickness 1 -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
+}
diff --git a/mplug_owl2/lib/tk8.6/palette.tcl b/mplug_owl2/lib/tk8.6/palette.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..42c6a907e478a34ac969eee0f790a6dbb77825a3
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/palette.tcl
@@ -0,0 +1,244 @@
+# palette.tcl --
+#
+# This file contains procedures that change the color palette used
+# by Tk.
+#
+# 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)]} {
+	return -code error -errorcode {TK SET_PALETTE BACKGROUND} \
+	    "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
+	}
+    }
+    lassign [winfo rgb . $new(foreground)] fg_r fg_g fg_b
+    lassign $bg bg_r bg_g bg_b
+    set darkerBg [format #%02x%02x%02x [expr {(9*$bg_r)/2560}] \
+	    [expr {(9*$bg_g)/2560}] [expr {(9*$bg_b)/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*$bg_r + $fg_r)/1024}] \
+		[expr {(3*$bg_g + $fg_g)/1024}] \
+		[expr {(3*$bg_b + $fg_b)/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} color $bg {
+	    set light($i) [expr {$color/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
+    }
+
+    # 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]
+
+    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 configure $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 {$defaultcolor eq "" || \
+		    ([info exists prototype] && \
+		    [$prototype cget $option] ne "$defaultcolor")} {
+		set defaultcolor [lindex $value 3]
+	    }
+	    if {$defaultcolor ne ""} {
+		set defaultcolor [winfo rgb . $defaultcolor]
+	    }
+	    set chosencolor [lindex $value 4]
+	    if {$chosencolor ne ""} {
+		set chosencolor [winfo rgb . $chosencolor]
+	    }
+	    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.
+# percent -	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} {
+    if {$percent < 0} {
+        return #000000
+    } elseif {$percent > 200} {
+        return #ffffff
+    } elseif {$percent <= 100} {
+        lassign [winfo rgb . $color] r g b
+        set r [expr {($r/256)*$percent/100}]
+        set g [expr {($g/256)*$percent/100}]
+        set b [expr {($b/256)*$percent/100}]
+    } elseif {$percent > 100} {
+        lassign [winfo rgb . $color] r g b
+        set r [expr {255 - ((65535-$r)/256)*(200-$percent)/100}]
+        set g [expr {255 - ((65535-$g)/256)*(200-$percent)/100}]
+        set b [expr {255 - ((65535-$b)/256)*(200-$percent)/100}]
+    }
+    return [format #%02x%02x%02x $r $g $b]
+}
+
+# ::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 \
+	    selectBackground #e6ceb1 selectForeground black \
+	    troughColor #cdb79e
+}
diff --git a/mplug_owl2/lib/tk8.6/panedwindow.tcl b/mplug_owl2/lib/tk8.6/panedwindow.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..d3dfabc643c245d9c9d35bd7f4a49e953a0918df
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/panedwindow.tcl
@@ -0,0 +1,194 @@
+# panedwindow.tcl --
+#
+# This file defines the default bindings for Tk panedwindow widgets and
+# provides procedures that help in implementing those bindings.
+
+bind Panedwindow <Button-1> { ::tk::panedwindow::MarkSash %W %x %y 1 }
+bind Panedwindow <Button-2> { ::tk::panedwindow::MarkSash %W %x %y 0 }
+
+bind Panedwindow <B1-Motion> { ::tk::panedwindow::DragSash %W %x %y 1 }
+bind Panedwindow <B2-Motion> { ::tk::panedwindow::DragSash %W %x %y 0 }
+
+bind Panedwindow <ButtonRelease-1> {::tk::panedwindow::ReleaseSash %W 1}
+bind Panedwindow <ButtonRelease-2> {::tk::panedwindow::ReleaseSash %W 0}
+
+bind Panedwindow <Motion> { ::tk::panedwindow::Motion %W %x %y }
+
+bind Panedwindow <Leave> { ::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} {
+    variable ::tk::Priv
+    if {[$w cget -opaqueresize]} {
+	set proxy 0
+    }
+    set what [$w identify $x $y]
+    if { [llength $what] == 2 } {
+	lassign $what index which
+	if {!$::tk_strictMotif || $which eq "handle"} {
+	    if {!$proxy} {
+		$w sash mark $index $x $y
+	    }
+	    set Priv(sash) $index
+	    lassign [$w sash coord $index] sx sy
+	    set Priv(dx) [expr {$sx-$x}]
+	    set 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} {
+    variable ::tk::Priv
+    if {[$w cget -opaqueresize]} {
+	set proxy 0
+    }
+    if {[info exists Priv(sash)]} {
+	if {$proxy} {
+	    $w proxy place [expr {$x+$Priv(dx)}] [expr {$y+$Priv(dy)}]
+	} else {
+	    $w sash place $Priv(sash) \
+		    [expr {$x+$Priv(dx)}] [expr {$y+$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} {
+    variable ::tk::Priv
+    if {[$w cget -opaqueresize]} {
+	set proxy 0
+    }
+    if {[info exists Priv(sash)]} {
+	if {$proxy} {
+	    lassign [$w proxy coord] x y
+	    $w sash place $Priv(sash) $x $y
+	    $w proxy forget
+	}
+	unset Priv(sash) Priv(dx) 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 || [lindex $id 1] eq "handle")} {
+	if {![info exists Priv($w,panecursor)]} {
+	    set Priv($w,panecursor) [$w cget -cursor]
+	    if {[$w cget -sashcursor] ne ""} {
+		$w configure -cursor [$w cget -sashcursor]
+	    } elseif {[$w cget -orient] eq "horizontal"} {
+		$w configure -cursor sb_h_double_arrow
+	    } else {
+		$w configure -cursor sb_v_double_arrow
+	    }
+	    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
+    # Make sure to check window existence in case it is destroyed.
+    if {[info exists Priv($w,panecursor)] && [winfo exists $w]} {
+	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} {
+    variable ::tk::Priv
+    if {[info exists Priv($w,panecursor)]} {
+        $w configure -cursor $Priv($w,panecursor)
+        unset Priv($w,panecursor)
+    }
+}
diff --git a/mplug_owl2/lib/tk8.6/pkgIndex.tcl b/mplug_owl2/lib/tk8.6/pkgIndex.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..f8b29d42eba0e83a87a8f302c5755bd6c0bd30c3
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/pkgIndex.tcl
@@ -0,0 +1,2 @@
+if {![package vsatisfies [package provide Tcl] 8.6.0]} return
+package ifneeded Tk 8.6.14 [list load [file normalize [file join $dir .. libtk8.6.so]]]
diff --git a/mplug_owl2/lib/tk8.6/safetk.tcl b/mplug_owl2/lib/tk8.6/safetk.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..9e71cc65bf431e94f9419ca7e430b0f602130f27
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/safetk.tcl
@@ -0,0 +1,262 @@
+# safetk.tcl --
+#
+# Support procs to use Tk in safe interpreters.
+#
+# 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 parent interp and ask its safe::TkInit
+#       for the actual parameters to use for it's initialization (if allowed),
+#       not relying on the child 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 child interpreter for tk loading
+#                most of the real job is done by loadTk
+# returns the child name (tkInterpInit does)
+#
+proc ::safe::tkInterpInit {child argv} {
+    global env tk_library
+
+    # We have to make sure that the tk_library variable is normalized.
+    set tk_library [file normalize $tk_library]
+
+    # Clear Tk's access for that interp (path).
+    allowTk $child $argv
+
+    # Ensure tk_library and subdirs (eg, ttk) are on the access path
+    ::interp eval $child [list set tk_library [::safe::interpAddToAccessPath $child $tk_library]]
+    foreach subdir [::safe::AddSubDirs [list $tk_library]] {
+	::safe::interpAddToAccessPath $child $subdir
+    }
+    return $child
+}
+
+
+# tkInterpLoadTk:
+# Do additional configuration as needed (calling tkInterpInit)
+# and actually load Tk into the child.
+#
+# Either contained in the specified windowId (-use) or
+# creating a decorated toplevel for it.
+
+# empty definition for auto_mkIndex
+proc ::safe::loadTk {} {}
+
+::tcl::OptProc ::safe::loadTk {
+    {child -interp "name of the child 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 parent is tk-less)
+	if {[catch {set display [winfo screen .]}]} {
+	    if {[info exists ::env(DISPLAY)]} {
+		set display $::env(DISPLAY)
+	    } else {
+		Log $child "no winfo screen . nor env(DISPLAY)" WARNING
+		set display ":0.0"
+	    }
+	}
+    }
+
+    # Get state for access to the cleanupHook.
+    namespace upvar ::safe S$child state
+
+    if {![::tcl::OptProcArgGiven "-use"]} {
+	# create a decorated toplevel
+	lassign [tkTopLevel $child $display] w use
+
+	# set our delete hook (child arg is added by interpDelete)
+	# to clean up both window related code and tkInit(child)
+	set state(cleanupHook) [list tkDelete {} $w]
+    } else {
+	# set our delete hook (child arg is added by interpDelete)
+	# to clean up tkInit(child)
+	set state(cleanupHook) [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 {$nDisplay ne $display} {
+	    if {$displayGiven} {
+		return -code error -errorcode {TK DISPLAY SAFE} \
+		    "conflicting -display $display and -use $use -> $nDisplay"
+	    } else {
+		set display $nDisplay
+	    }
+	}
+    }
+
+    # Prepares the child for tk with those parameters
+    tkInterpInit $child [list "-use" $use "-display" $display]
+
+    load {} Tk $child
+
+    return $child
+}
+
+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
+	return -code error -errorcode {TK SAFE PERMISSION} "not allowed"
+    }
+}
+
+# safe::allowTk --
+#
+#	Set tkInit(interpPath) to allow Tk to be initialized in
+#	safe::TkInit.
+#
+# Arguments:
+#	interpPath	child 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	child 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	child interpreter handle
+#
+# Results:
+#	none.
+
+proc ::safe::tkDelete {W window child} {
+
+    # we are going to be called for each widget... skip untill it's
+    # top level
+
+    Log $child "Called tkDelete $W $window" NOTICE
+    if {[::interp exists $child]} {
+	if {[catch {::safe::interpDelete $child} msg]} {
+	    Log $child "Deletion error : $msg"
+	}
+    }
+    if {[winfo exists $window]} {
+	Log $child "Destroy toplevel $window" NOTICE
+	destroy $window
+    }
+
+    # clean up tkInit(child)
+    disallowTk $child
+    return
+}
+
+proc ::safe::tkTopLevel {child display} {
+    variable tkSafeId
+    incr tkSafeId
+    set w ".safe$tkSafeId"
+    if {[catch {toplevel $w -screen $display -class SafeTk} msg]} {
+	return -code error -errorcode {TK TOPLEVEL SAFE} \
+	    "Unable to create toplevel for \"$child\" ($msg)"
+    }
+    Log $child "New toplevel $w" NOTICE
+
+    set msg "Untrusted Tcl applet ($child)"
+    wm title $w $msg
+
+    # Control frame (we must create a style for it)
+    ttk::style layout TWarningFrame {WarningFrame.border -sticky nswe}
+    ttk::style configure TWarningFrame -background red
+
+    set wc $w.fc
+    ttk::frame $wc -relief ridge -borderwidth 4 -style TWarningFrame
+
+    # We will destroy the interp when the window is destroyed
+    bindtags $wc [concat Safe$wc [bindtags $wc]]
+    bind Safe$wc <Destroy> [list ::safe::tkDelete %W $w $child]
+
+    ttk::label $wc.l -text $msg -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
+    ttk::frame  $wc.fb -borderwidth 0
+    ttk::button $wc.fb.b -text "Delete" \
+	    -command [list ::safe::tkDelete $w $w $child]
+    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 -ipady 2
+    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]
+}
diff --git a/mplug_owl2/lib/tk8.6/scale.tcl b/mplug_owl2/lib/tk8.6/scale.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..466a3ce6aade863de25fb2b0e357e72f2c77ba6b
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/scale.tcl
@@ -0,0 +1,307 @@
+# scale.tcl --
+#
+# This file defines the default bindings for Tk scale widgets and provides
+# procedures that help in implementing the bindings.
+#
+# 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 <Enter> {
+    if {$tk_strictMotif} {
+	set tk::Priv(activeBg) [%W cget -activebackground]
+	%W configure -activebackground [%W cget -background]
+    }
+    tk::ScaleActivate %W %x %y
+}
+bind Scale <Motion> {
+    tk::ScaleActivate %W %x %y
+}
+bind Scale <Leave> {
+    if {$tk_strictMotif} {
+	%W configure -activebackground $tk::Priv(activeBg)
+    }
+    if {[%W cget -state] eq "active"} {
+	%W configure -state normal
+    }
+}
+bind Scale <1> {
+    tk::ScaleButtonDown %W %x %y
+}
+bind Scale <B1-Motion> {
+    tk::ScaleDrag %W %x %y
+}
+bind Scale <B1-Leave> { }
+bind Scale <B1-Enter> { }
+bind Scale <ButtonRelease-1> {
+    tk::CancelRepeat
+    tk::ScaleEndDrag %W
+    tk::ScaleActivate %W %x %y
+}
+bind Scale <2> {
+    tk::ScaleButton2Down %W %x %y
+}
+bind Scale <B2-Motion> {
+    tk::ScaleDrag %W %x %y
+}
+bind Scale <B2-Leave> { }
+bind Scale <B2-Enter> { }
+bind Scale <ButtonRelease-2> {
+    tk::CancelRepeat
+    tk::ScaleEndDrag %W
+    tk::ScaleActivate %W %x %y
+}
+if {[tk windowingsystem] eq "win32"} {
+    # On Windows do the same with button 3, as that is the right mouse button
+    bind Scale <3>		[bind Scale <2>]
+    bind Scale <B3-Motion>	[bind Scale <B2-Motion>]
+    bind Scale <B3-Leave>	[bind Scale <B2-Leave>]
+    bind Scale <B3-Enter>	[bind Scale <B2-Enter>]
+    bind Scale <ButtonRelease-3> [bind Scale <ButtonRelease-2>]
+}
+bind Scale <Control-1> {
+    tk::ScaleControlPress %W %x %y
+}
+bind Scale <<PrevLine>> {
+    tk::ScaleIncrement %W up little noRepeat
+}
+bind Scale <<NextLine>> {
+    tk::ScaleIncrement %W down little noRepeat
+}
+bind Scale <<PrevChar>> {
+    tk::ScaleIncrement %W up little noRepeat
+}
+bind Scale <<NextChar>> {
+    tk::ScaleIncrement %W down little noRepeat
+}
+bind Scale <<PrevPara>> {
+    tk::ScaleIncrement %W up big noRepeat
+}
+bind Scale <<NextPara>> {
+    tk::ScaleIncrement %W down big noRepeat
+}
+bind Scale <<PrevWord>> {
+    tk::ScaleIncrement %W up big noRepeat
+}
+bind Scale <<NextWord>> {
+    tk::ScaleIncrement %W down big noRepeat
+}
+bind Scale <<LineStart>> {
+    %W set [%W cget -from]
+}
+bind Scale <<LineEnd>> {
+    %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 {[$w cget -state] eq "disabled"} {
+	return
+    }
+    if {[$w identify $x $y] eq "slider"} {
+	set state active
+    } else {
+	set state normal
+    }
+    if {[$w cget -state] ne $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 {$el eq "trough1"} {
+	ScaleIncrement $w up little initial
+    } elseif {$el eq "trough2"} {
+	ScaleIncrement $w down little initial
+    } elseif {$el eq "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
+
+    # give the cancel callback a chance to be serviced if the execution time of
+    # the -command script lasts longer than -repeatdelay
+    set clockms [clock milliseconds]
+    if {$repeat eq "again" &&
+            [expr {$clockms - $Priv(clockms)}] > [expr {[$w cget -repeatinterval] * 1.1}]} {
+        set Priv(clockms) $clockms
+	set Priv(afterId) [after [$w cget -repeatinterval] \
+		[list tk::ScaleIncrement $w $dir $big again]]
+	return
+    }
+
+    if {$big eq "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]) ^ ($dir eq "up")} {
+        if {$inc > 0} {
+            set inc [expr {-$inc}]
+        }
+    } else {
+        if {$inc < 0} {
+            set inc [expr {-$inc}]
+        }
+    }
+    # this will run the -command script (if any) during the redrawing
+    # of the scale at idle time
+    $w set [expr {[$w get] + $inc}]
+
+    if {$repeat eq "again"} {
+        set Priv(clockms) $clockms
+	set Priv(afterId) [after [$w cget -repeatinterval] \
+		[list tk::ScaleIncrement $w $dir $big again]]
+    } elseif {$repeat eq "initial"} {
+	set delay [$w cget -repeatdelay]
+	if {$delay > 0} {
+	    set Priv(clockms) $clockms
+	    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 {$el eq "trough1"} {
+	$w set [$w cget -from]
+    } elseif {$el eq "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 {[$w cget -state] eq "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
+}
diff --git a/mplug_owl2/lib/tk8.6/scrlbar.tcl b/mplug_owl2/lib/tk8.6/scrlbar.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..a1c43982029238e28e91ad27d02c0d3ddbe8adf9
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/scrlbar.tcl
@@ -0,0 +1,456 @@
+# scrlbar.tcl --
+#
+# This file defines the default bindings for Tk scrollbar widgets.
+# It also provides procedures that help in implementing the bindings.
+#
+# 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 {[tk windowingsystem] eq "x11" || [tk windowingsystem] eq "aqua"} {
+
+bind Scrollbar <Enter> {
+    if {$tk_strictMotif} {
+	set tk::Priv(activeBg) [%W cget -activebackground]
+	%W configure -activebackground [%W cget -background]
+    }
+    %W activate [%W identify %x %y]
+}
+bind Scrollbar <Motion> {
+    %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 <Leave> {
+    if {$tk_strictMotif && [info exists tk::Priv(activeBg)]} {
+	%W configure -activebackground $tk::Priv(activeBg)
+    }
+    %W activate {}
+}
+bind Scrollbar <1> {
+    tk::ScrollButtonDown %W %x %y
+}
+bind Scrollbar <B1-Motion> {
+    tk::ScrollDrag %W %x %y
+}
+bind Scrollbar <B1-B2-Motion> {
+    tk::ScrollDrag %W %x %y
+}
+bind Scrollbar <ButtonRelease-1> {
+    tk::ScrollButtonUp %W %x %y
+}
+bind Scrollbar <B1-Leave> {
+    # Prevents <Leave> binding from being invoked.
+}
+bind Scrollbar <B1-Enter> {
+    # Prevents <Enter> binding from being invoked.
+}
+bind Scrollbar <2> {
+    tk::ScrollButton2Down %W %x %y
+}
+bind Scrollbar <B1-2> {
+    # Do nothing, since button 1 is already down.
+}
+bind Scrollbar <B2-1> {
+    # Do nothing, since button 2 is already down.
+}
+bind Scrollbar <B2-Motion> {
+    tk::ScrollDrag %W %x %y
+}
+bind Scrollbar <ButtonRelease-2> {
+    tk::ScrollButtonUp %W %x %y
+}
+bind Scrollbar <B1-ButtonRelease-2> {
+    # Do nothing:  B1 release will handle it.
+}
+bind Scrollbar <B2-ButtonRelease-1> {
+    # Do nothing:  B2 release will handle it.
+}
+bind Scrollbar <B2-Leave> {
+    # Prevents <Leave> binding from being invoked.
+}
+bind Scrollbar <B2-Enter> {
+    # Prevents <Enter> binding from being invoked.
+}
+bind Scrollbar <Control-1> {
+    tk::ScrollTopBottom %W %x %y
+}
+bind Scrollbar <Control-2> {
+    tk::ScrollTopBottom %W %x %y
+}
+
+bind Scrollbar <<PrevLine>> {
+    tk::ScrollByUnits %W v -1
+}
+bind Scrollbar <<NextLine>> {
+    tk::ScrollByUnits %W v 1
+}
+bind Scrollbar <<PrevPara>> {
+    tk::ScrollByPages %W v -1
+}
+bind Scrollbar <<NextPara>> {
+    tk::ScrollByPages %W v 1
+}
+bind Scrollbar <<PrevChar>> {
+    tk::ScrollByUnits %W h -1
+}
+bind Scrollbar <<NextChar>> {
+    tk::ScrollByUnits %W h 1
+}
+bind Scrollbar <<PrevWord>> {
+    tk::ScrollByPages %W h -1
+}
+bind Scrollbar <<NextWord>> {
+    tk::ScrollByPages %W h 1
+}
+bind Scrollbar <Prior> {
+    tk::ScrollByPages %W hv -1
+}
+bind Scrollbar <Next> {
+    tk::ScrollByPages %W hv 1
+}
+bind Scrollbar <<LineStart>> {
+    tk::ScrollToPos %W 0
+}
+bind Scrollbar <<LineEnd>> {
+    tk::ScrollToPos %W 1
+}
+}
+
+if {[tk windowingsystem] eq "aqua"} {
+    bind Scrollbar <MouseWheel> {
+	tk::ScrollByUnits %W v [expr {-(%D)}]
+    }
+    bind Scrollbar <Option-MouseWheel> {
+	tk::ScrollByUnits %W v [expr {-10 * (%D)}]
+    }
+    bind Scrollbar <Shift-MouseWheel> {
+	tk::ScrollByUnits %W h [expr {-(%D)}]
+    }
+    bind Scrollbar <Shift-Option-MouseWheel> {
+	tk::ScrollByUnits %W h [expr {-10 * (%D)}]
+    }
+} else {
+    bind Scrollbar <MouseWheel> {
+	if {%D >= 0} {
+	    tk::ScrollByUnits %W v [expr {-%D/30}]
+	} else {
+	    tk::ScrollByUnits %W v [expr {(29-%D)/30}]
+	}
+    }
+    bind Scrollbar <Shift-MouseWheel> {
+	if {%D >= 0} {
+	    tk::ScrollByUnits %W h [expr {-%D/30}]
+	} else {
+	    tk::ScrollByUnits %W h [expr {(29-%D)/30}]
+	}
+    }
+}
+
+if {[tk windowingsystem] eq "x11"} {
+    bind Scrollbar <4> {tk::ScrollByUnits %W v -5}
+    bind Scrollbar <5> {tk::ScrollByUnits %W v 5}
+    bind Scrollbar <Shift-4> {tk::ScrollByUnits %W h -5}
+    bind Scrollbar <Shift-5> {tk::ScrollByUnits %W h 5}
+}
+
+# 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 {$element eq "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 {$repeat eq "again"} {
+	set Priv(afterId) [after [$w cget -repeatinterval] \
+		[list tk::ScrollSelect $w $element again]]
+    } elseif {$repeat eq "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 {[$w cget -command] eq ""} {
+	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 {$Priv(initPos) eq ""} {
+	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 {$Priv(initPos) eq ""} {
+	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 {$cmd eq "" || ([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 {$cmd eq "" || ([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 {$cmd eq ""} {
+	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
+    if {![winfo exists $w]} {
+        return
+    }
+    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
+    if {[winfo exists $w]} {
+        $w configure -activerelief sunken
+        $w activate slider
+        ScrollStartDrag $w $x $y
+    }
+}
diff --git a/mplug_owl2/lib/tk8.6/spinbox.tcl b/mplug_owl2/lib/tk8.6/spinbox.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..0e26644a7eda74c444ce6b00533457f63f614421
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/spinbox.tcl
@@ -0,0 +1,594 @@
+# 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.
+#
+# 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 <<Cut>> {
+    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 <<Copy>> {
+    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 <<Paste>> {
+    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 <<Clear>> {
+    %W delete sel.first sel.last
+}
+bind Spinbox <<PasteSelection>> {
+    if {$tk_strictMotif || ![info exists tk::Priv(mouseMoved)]
+	|| !$tk::Priv(mouseMoved)} {
+	::tk::spinbox::Paste %W %x
+    }
+}
+
+bind Spinbox <<TraverseIn>> {
+    %W selection range 0 end
+    %W icursor end
+}
+
+# Standard Motif bindings:
+
+bind Spinbox <1> {
+    ::tk::spinbox::ButtonDown %W %x %y
+}
+bind Spinbox <B1-Motion> {
+    ::tk::spinbox::Motion %W %x %y
+}
+bind Spinbox <Double-1> {
+    ::tk::spinbox::ArrowPress %W %x %y
+    set tk::Priv(selectMode) word
+    ::tk::spinbox::MouseSelect %W %x sel.first
+}
+bind Spinbox <Triple-1> {
+    ::tk::spinbox::ArrowPress %W %x %y
+    set tk::Priv(selectMode) line
+    ::tk::spinbox::MouseSelect %W %x 0
+}
+bind Spinbox <Shift-1> {
+    set tk::Priv(selectMode) char
+    %W selection adjust @%x
+}
+bind Spinbox <Double-Shift-1> {
+    set tk::Priv(selectMode) word
+    ::tk::spinbox::MouseSelect %W %x
+}
+bind Spinbox <Triple-Shift-1> {
+    set tk::Priv(selectMode) line
+    ::tk::spinbox::MouseSelect %W %x
+}
+bind Spinbox <B1-Leave> {
+    set tk::Priv(x) %x
+    ::tk::spinbox::AutoScan %W
+}
+bind Spinbox <B1-Enter> {
+    tk::CancelRepeat
+}
+bind Spinbox <ButtonRelease-1> {
+    ::tk::spinbox::ButtonUp %W %x %y
+}
+bind Spinbox <Control-1> {
+    %W icursor @%x
+}
+
+bind Spinbox <<PrevLine>> {
+    %W invoke buttonup
+}
+bind Spinbox <<NextLine>> {
+    %W invoke buttondown
+}
+
+bind Spinbox <<PrevChar>> {
+    ::tk::EntrySetCursor %W [expr {[%W index insert] - 1}]
+}
+bind Spinbox <<NextChar>> {
+    ::tk::EntrySetCursor %W [expr {[%W index insert] + 1}]
+}
+bind Spinbox <<SelectPrevChar>> {
+    ::tk::EntryKeySelect %W [expr {[%W index insert] - 1}]
+    ::tk::EntrySeeInsert %W
+}
+bind Spinbox <<SelectNextChar>> {
+    ::tk::EntryKeySelect %W [expr {[%W index insert] + 1}]
+    ::tk::EntrySeeInsert %W
+}
+bind Spinbox <<PrevWord>> {
+    ::tk::EntrySetCursor %W [::tk::EntryPreviousWord %W insert]
+}
+bind Spinbox <<NextWord>> {
+    ::tk::EntrySetCursor %W [::tk::EntryNextWord %W insert]
+}
+bind Spinbox <<SelectPrevWord>> {
+    ::tk::EntryKeySelect %W [::tk::EntryPreviousWord %W insert]
+    ::tk::EntrySeeInsert %W
+}
+bind Spinbox <<SelectNextWord>> {
+    ::tk::EntryKeySelect %W [::tk::EntryNextWord %W insert]
+    ::tk::EntrySeeInsert %W
+}
+bind Spinbox <<LineStart>> {
+    ::tk::EntrySetCursor %W 0
+}
+bind Spinbox <<SelectLineStart>> {
+    ::tk::EntryKeySelect %W 0
+    ::tk::EntrySeeInsert %W
+}
+bind Spinbox <<LineEnd>> {
+    ::tk::EntrySetCursor %W end
+}
+bind Spinbox <<SelectLineEnd>> {
+    ::tk::EntryKeySelect %W end
+    ::tk::EntrySeeInsert %W
+}
+
+bind Spinbox <Delete> {
+    if {[%W selection present]} {
+	%W delete sel.first sel.last
+    } else {
+	%W delete insert
+    }
+}
+bind Spinbox <BackSpace> {
+    ::tk::EntryBackspace %W
+}
+
+bind Spinbox <Control-space> {
+    %W selection from insert
+}
+bind Spinbox <Select> {
+    %W selection from insert
+}
+bind Spinbox <Control-Shift-space> {
+    %W selection adjust insert
+}
+bind Spinbox <Shift-Select> {
+    %W selection adjust insert
+}
+bind Spinbox <<SelectAll>> {
+    %W selection range 0 end
+}
+bind Spinbox <<SelectNone>> {
+    %W selection clear
+}
+bind Spinbox <Key> {
+    ::tk::EntryInsert %W %A
+}
+
+# Ignore all Alt, Meta, Control, and Mod4 keypresses unless explicitly bound.
+# Otherwise, if a widget binding for one of these is defined, the
+# <Key> class binding will also fire and insert the character,
+# which is wrong.  Ditto for Escape, Return, and Tab.
+
+bind Spinbox <Alt-Key> {# nothing}
+bind Spinbox <Meta-Key> {# nothing}
+bind Spinbox <Control-Key> {# nothing}
+bind Spinbox <Escape> {# nothing}
+bind Spinbox <Return> {# nothing}
+bind Spinbox <KP_Enter> {# nothing}
+bind Spinbox <Tab> {# nothing}
+bind Spinbox <Prior> {# nothing}
+bind Spinbox <Next> {# nothing}
+if {[tk windowingsystem] eq "aqua"} {
+    bind Spinbox <Command-Key> {# nothing}
+    bind Spinbox <Mod4-Key> {# nothing}
+}
+
+# On Windows, paste is done using Shift-Insert.  Shift-Insert already
+# generates the <<Paste>> event, so we don't need to do anything here.
+if {[tk windowingsystem] ne "win32"} {
+    bind Spinbox <Insert> {
+	catch {::tk::EntryInsert %W [::tk::GetSelection %W PRIMARY]}
+    }
+}
+
+# Additional emacs-like bindings:
+
+bind Spinbox <Control-d> {
+    if {!$tk_strictMotif} {
+	%W delete insert
+    }
+}
+bind Spinbox <Control-h> {
+    if {!$tk_strictMotif} {
+	::tk::EntryBackspace %W
+    }
+}
+bind Spinbox <Control-k> {
+    if {!$tk_strictMotif} {
+	%W delete insert end
+    }
+}
+bind Spinbox <Control-t> {
+    if {!$tk_strictMotif} {
+	::tk::EntryTranspose %W
+    }
+}
+bind Spinbox <Meta-b> {
+    if {!$tk_strictMotif} {
+	::tk::EntrySetCursor %W [::tk::EntryPreviousWord %W insert]
+    }
+}
+bind Spinbox <Meta-d> {
+    if {!$tk_strictMotif} {
+	%W delete insert [::tk::EntryNextWord %W insert]
+    }
+}
+bind Spinbox <Meta-f> {
+    if {!$tk_strictMotif} {
+	::tk::EntrySetCursor %W [::tk::EntryNextWord %W insert]
+    }
+}
+bind Spinbox <Meta-BackSpace> {
+    if {!$tk_strictMotif} {
+	%W delete [::tk::EntryPreviousWord %W insert] insert
+    }
+}
+bind Spinbox <Meta-Delete> {
+    if {!$tk_strictMotif} {
+	%W delete [::tk::EntryPreviousWord %W insert] insert
+    }
+}
+
+# A few additional bindings of my own.
+
+if {[tk windowingsystem] ne "aqua"} {
+    bind Spinbox <2> {
+        if {!$tk_strictMotif} {
+        ::tk::EntryScanMark %W %x
+        }
+    }
+    bind Spinbox <B2-Motion> {
+        if {!$tk_strictMotif} {
+        ::tk::EntryScanDrag %W %x
+        }
+    }
+} else {
+    bind Spinbox <3> {
+        if {!$tk_strictMotif} {
+        ::tk::EntryScanMark %W %x
+        }
+    }
+    bind Spinbox <B3-Motion> {
+        if {!$tk_strictMotif} {
+        ::tk::EntryScanDrag %W %x
+        }
+    }
+}
+
+# ::tk::spinbox::Invoke --
+# Invoke an element of the spinbox
+#
+# Arguments:
+# w -		The spinbox window.
+# elem -	Element to invoke
+
+proc ::tk::spinbox::Invoke {w elem} {
+    variable ::tk::Priv
+
+    if {![winfo exists $w]} {
+      return
+    }
+
+    if {![info exists Priv(outsideElement)]} {
+	$w invoke $elem
+	incr Priv(repeated)
+    }
+    set delay [$w cget -repeatinterval]
+    if {$delay > 0} {
+	set Priv(afterId) [after $delay \
+		[list ::tk::spinbox::Invoke $w $elem]]
+    }
+}
+
+# ::tk::spinbox::ClosestGap --
+# 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 spinbox window.
+# x -		X-coordinate within the window.
+
+proc ::tk::spinbox::ClosestGap {w x} {
+    set pos [$w index @$x]
+    set bbox [$w bbox $pos]
+    if {($x - [lindex $bbox 0]) < ([lindex $bbox 2]/2)} {
+	return $pos
+    }
+    incr pos
+}
+
+# ::tk::spinbox::ArrowPress --
+# This procedure is invoked to handle button-1 presses in buttonup
+# or buttondown elements of spinbox widgets.
+#
+# Arguments:
+# w -		The spinbox window in which the button was pressed.
+# x -		The x-coordinate of the button press.
+# y -		The y-coordinate of the button press.
+
+proc ::tk::spinbox::ArrowPress {w x y} {
+    variable ::tk::Priv
+
+    if {[$w cget -state] ne "disabled" && \
+            [string match "button*" $Priv(element)]} {
+        $w selection element $Priv(element)
+        set Priv(repeated) 0
+        set Priv(relief) [$w cget -$Priv(element)relief]
+        catch {after cancel $Priv(afterId)}
+        set delay [$w cget -repeatdelay]
+        if {$delay > 0} {
+            set Priv(afterId) [after $delay \
+                    [list ::tk::spinbox::Invoke $w $Priv(element)]]
+        }
+        if {[info exists Priv(outsideElement)]} {
+            unset Priv(outsideElement)
+        }
+    }
+}
+
+# ::tk::spinbox::ButtonDown --
+# This procedure is invoked to handle button-1 presses in spinbox
+# widgets.  It moves the insertion cursor, sets the selection anchor,
+# and claims the input focus.
+#
+# Arguments:
+# w -		The spinbox window in which the button was pressed.
+# x -		The x-coordinate of the button press.
+# y -		The y-coordinate of the button press.
+
+proc ::tk::spinbox::ButtonDown {w x y} {
+    variable ::tk::Priv
+
+    # Get the element that was clicked in.  If we are not directly over
+    # the spinbox, default to entry.  This is necessary for spinbox grabs.
+    #
+    set Priv(element) [$w identify $x $y]
+    if {$Priv(element) eq ""} {
+	set Priv(element) "entry"
+    }
+
+    switch -exact $Priv(element) {
+	"buttonup" - "buttondown" {
+	    ::tk::spinbox::ArrowPress $w $x $y
+	}
+	"entry" {
+	    set Priv(selectMode) char
+	    set Priv(mouseMoved) 0
+	    set Priv(pressX) $x
+	    $w icursor [::tk::spinbox::ClosestGap $w $x]
+	    $w selection from insert
+	    if {"disabled" ne [$w cget -state]} {focus $w}
+	    $w selection clear
+	}
+	default {
+	    return -code error -errorcode {TK SPINBOX UNKNOWN_ELEMENT} \
+		"unknown spinbox element \"$Priv(element)\""
+	}
+    }
+}
+
+# ::tk::spinbox::ButtonUp --
+# This procedure is invoked to handle button-1 releases in spinbox
+# widgets.
+#
+# Arguments:
+# w -		The spinbox window in which the button was pressed.
+# x -		The x-coordinate of the button press.
+# y -		The y-coordinate of the button press.
+
+proc ::tk::spinbox::ButtonUp {w x y} {
+    variable ::tk::Priv
+
+    ::tk::CancelRepeat
+
+    # Priv(relief) may not exist if the ButtonUp is not paired with
+    # a preceding ButtonDown
+    if {[info exists Priv(element)] && [info exists Priv(relief)] && \
+	    [string match "button*" $Priv(element)]} {
+	if {[info exists Priv(repeated)] && !$Priv(repeated)} {
+	    $w invoke $Priv(element)
+	}
+	$w configure -$Priv(element)relief $Priv(relief)
+	$w selection element none
+    }
+}
+
+# ::tk::spinbox::MouseSelect --
+# This procedure is invoked when dragging out a selection 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 spinbox window in which the button was pressed.
+# x -		The x-coordinate of the mouse.
+# cursor -	optional place to set cursor.
+
+proc ::tk::spinbox::MouseSelect {w x {cursor {}}} {
+    variable ::tk::Priv
+
+    if {$Priv(element) ne "entry"} {
+	# The ButtonUp command triggered by ButtonRelease-1 handles
+	# invoking one of the spinbuttons.
+	return
+    }
+    set cur [::tk::spinbox::ClosestGap $w $x]
+    set anchor [$w index anchor]
+    if {($cur ne $anchor) || (abs($Priv(pressX) - $x) >= 3)} {
+	set Priv(mouseMoved) 1
+    }
+    switch $Priv(selectMode) {
+	char {
+	    if {$Priv(mouseMoved)} {
+		if {$cur < $anchor} {
+		    $w selection range $cur $anchor
+		} elseif {$cur > $anchor} {
+		    $w selection range $anchor $cur
+		} else {
+		    $w selection clear
+		}
+	    }
+	}
+	word {
+	    if {$cur < [$w index anchor]} {
+		set before [tcl_wordBreakBefore [$w get] $cur]
+		set after [tcl_wordBreakAfter [$w get] $anchor-1]
+	    } else {
+		set before [tcl_wordBreakBefore [$w get] $anchor]
+		set after [tcl_wordBreakAfter [$w get] $cur-1]
+	    }
+	    if {$before < 0} {
+		set before 0
+	    }
+	    if {$after < 0} {
+		set after end
+	    }
+	    $w selection range $before $after
+	}
+	line {
+	    $w selection range 0 end
+	}
+    }
+    if {$cursor ne {} && $cursor ne "ignore"} {
+	catch {$w icursor $cursor}
+    }
+    update idletasks
+}
+
+# ::tk::spinbox::Paste --
+# This procedure sets the insertion cursor to the current mouse position,
+# pastes the selection there, and sets the focus to the window.
+#
+# Arguments:
+# w -		The spinbox window.
+# x -		X position of the mouse.
+
+proc ::tk::spinbox::Paste {w x} {
+    $w icursor [::tk::spinbox::ClosestGap $w $x]
+    catch {$w insert insert [::tk::GetSelection $w PRIMARY]}
+    if {"disabled" eq [$w cget -state]} {
+	focus $w
+    }
+}
+
+# ::tk::spinbox::Motion --
+# This procedure is invoked when the mouse moves in a spinbox window
+# with button 1 down.
+#
+# Arguments:
+# w -		The spinbox window.
+# x -		The x-coordinate of the mouse.
+# y -		The y-coordinate of the mouse.
+
+proc ::tk::spinbox::Motion {w x y} {
+    variable ::tk::Priv
+
+    if {![info exists Priv(element)]} {
+	set Priv(element) [$w identify $x $y]
+    }
+
+    set Priv(x) $x
+    if {"entry" eq $Priv(element)} {
+	::tk::spinbox::MouseSelect $w $x ignore
+    } elseif {[$w identify $x $y] ne $Priv(element)} {
+	if {![info exists Priv(outsideElement)]} {
+	    # We've wandered out of the spin button
+	    # setting outside element will cause ::tk::spinbox::Invoke to
+	    # loop without doing anything
+	    set Priv(outsideElement) ""
+	    $w selection element none
+	}
+    } elseif {[info exists Priv(outsideElement)]} {
+	unset Priv(outsideElement)
+	$w selection element $Priv(element)
+    }
+}
+
+# ::tk::spinbox::AutoScan --
+# This procedure is invoked when the mouse leaves an spinbox window
+# with button 1 down.  It scrolls the window left or right,
+# depending on where the mouse is, 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 spinbox window.
+
+proc ::tk::spinbox::AutoScan {w} {
+    variable ::tk::Priv
+
+    set x $Priv(x)
+    if {$x >= [winfo width $w]} {
+	$w xview scroll 2 units
+	::tk::spinbox::MouseSelect $w $x ignore
+    } elseif {$x < 0} {
+	$w xview scroll -2 units
+	::tk::spinbox::MouseSelect $w $x ignore
+    }
+    set Priv(afterId) [after 50 [list ::tk::spinbox::AutoScan $w]]
+}
+
+# ::tk::spinbox::GetSelection --
+#
+# Returns the selected text of the spinbox.  Differs from entry in that
+# a spinbox has no -show option to obscure contents.
+#
+# Arguments:
+# w -         The spinbox window from which the text to get
+
+proc ::tk::spinbox::GetSelection {w} {
+    return [string range [$w get] [$w index sel.first] \
+	    [expr {[$w index sel.last] - 1}]]
+}
diff --git a/mplug_owl2/lib/tk8.6/tclIndex b/mplug_owl2/lib/tk8.6/tclIndex
new file mode 100644
index 0000000000000000000000000000000000000000..b3f37facd6113e4f14958060be70bcda1f8b1db0
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/tclIndex
@@ -0,0 +1,253 @@
+# 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(::tk::dialog::error::Return) [list source [file join $dir bgerror.tcl]]
+set auto_index(::tk::dialog::error::Details) [list source [file join $dir bgerror.tcl]]
+set auto_index(::tk::dialog::error::SaveToLog) [list source [file join $dir bgerror.tcl]]
+set auto_index(::tk::dialog::error::Destroy) [list source [file join $dir bgerror.tcl]]
+set auto_index(::tk::dialog::error::bgerror) [list source [file join $dir bgerror.tcl]]
+set auto_index(bgerror) [list source [file join $dir bgerror.tcl]]
+set auto_index(::tk::ButtonInvoke) [list source [file join $dir button.tcl]]
+set auto_index(::tk::ButtonAutoInvoke) [list source [file join $dir button.tcl]]
+set auto_index(::tk::CheckRadioInvoke) [list source [file join $dir button.tcl]]
+set auto_index(::tk::dialog::file::chooseDir::) [list source [file join $dir choosedir.tcl]]
+set auto_index(::tk::dialog::file::chooseDir::Config) [list source [file join $dir choosedir.tcl]]
+set auto_index(::tk::dialog::file::chooseDir::OkCmd) [list source [file join $dir choosedir.tcl]]
+set auto_index(::tk::dialog::file::chooseDir::DblClick) [list source [file join $dir choosedir.tcl]]
+set auto_index(::tk::dialog::file::chooseDir::ListBrowse) [list source [file join $dir choosedir.tcl]]
+set auto_index(::tk::dialog::file::chooseDir::Done) [list source [file join $dir choosedir.tcl]]
+set auto_index(::tk::dialog::color::) [list source [file join $dir clrpick.tcl]]
+set auto_index(::tk::dialog::color::InitValues) [list source [file join $dir clrpick.tcl]]
+set auto_index(::tk::dialog::color::Config) [list source [file join $dir clrpick.tcl]]
+set auto_index(::tk::dialog::color::BuildDialog) [list source [file join $dir clrpick.tcl]]
+set auto_index(::tk::dialog::color::SetRGBValue) [list source [file join $dir clrpick.tcl]]
+set auto_index(::tk::dialog::color::XToRgb) [list source [file join $dir clrpick.tcl]]
+set auto_index(::tk::dialog::color::RgbToX) [list source [file join $dir clrpick.tcl]]
+set auto_index(::tk::dialog::color::DrawColorScale) [list source [file join $dir clrpick.tcl]]
+set auto_index(::tk::dialog::color::CreateSelector) [list source [file join $dir clrpick.tcl]]
+set auto_index(::tk::dialog::color::RedrawFinalColor) [list source [file join $dir clrpick.tcl]]
+set auto_index(::tk::dialog::color::RedrawColorBars) [list source [file join $dir clrpick.tcl]]
+set auto_index(::tk::dialog::color::StartMove) [list source [file join $dir clrpick.tcl]]
+set auto_index(::tk::dialog::color::MoveSelector) [list source [file join $dir clrpick.tcl]]
+set auto_index(::tk::dialog::color::ReleaseMouse) [list source [file join $dir clrpick.tcl]]
+set auto_index(::tk::dialog::color::ResizeColorBars) [list source [file join $dir clrpick.tcl]]
+set auto_index(::tk::dialog::color::HandleSelEntry) [list source [file join $dir clrpick.tcl]]
+set auto_index(::tk::dialog::color::HandleRGBEntry) [list source [file join $dir clrpick.tcl]]
+set auto_index(::tk::dialog::color::EnterColorBar) [list source [file join $dir clrpick.tcl]]
+set auto_index(::tk::dialog::color::LeaveColorBar) [list source [file join $dir clrpick.tcl]]
+set auto_index(::tk::dialog::color::OkCmd) [list source [file join $dir clrpick.tcl]]
+set auto_index(::tk::dialog::color::CancelCmd) [list source [file join $dir clrpick.tcl]]
+set auto_index(tclParseConfigSpec) [list source [file join $dir comdlg.tcl]]
+set auto_index(tclListValidFlags) [list source [file join $dir comdlg.tcl]]
+set auto_index(::tk::FocusGroup_Create) [list source [file join $dir comdlg.tcl]]
+set auto_index(::tk::FocusGroup_BindIn) [list source [file join $dir comdlg.tcl]]
+set auto_index(::tk::FocusGroup_BindOut) [list source [file join $dir comdlg.tcl]]
+set auto_index(::tk::FocusGroup_Destroy) [list source [file join $dir comdlg.tcl]]
+set auto_index(::tk::FocusGroup_In) [list source [file join $dir comdlg.tcl]]
+set auto_index(::tk::FocusGroup_Out) [list source [file join $dir comdlg.tcl]]
+set auto_index(::tk::FDGetFileTypes) [list source [file join $dir comdlg.tcl]]
+set auto_index(::tk::ConsoleInit) [list source [file join $dir console.tcl]]
+set auto_index(::tk::ConsoleSource) [list source [file join $dir console.tcl]]
+set auto_index(::tk::ConsoleInvoke) [list source [file join $dir console.tcl]]
+set auto_index(::tk::ConsoleHistory) [list source [file join $dir console.tcl]]
+set auto_index(::tk::ConsolePrompt) [list source [file join $dir console.tcl]]
+set auto_index(::tk::ConsoleBind) [list source [file join $dir console.tcl]]
+set auto_index(::tk::ConsoleInsert) [list source [file join $dir console.tcl]]
+set auto_index(::tk::ConsoleOutput) [list source [file join $dir console.tcl]]
+set auto_index(::tk::ConsoleExit) [list source [file join $dir console.tcl]]
+set auto_index(::tk::ConsoleAbout) [list source [file join $dir console.tcl]]
+set auto_index(tk_dialog) [list source [file join $dir dialog.tcl]]
+set auto_index(::tk::EntryClosestGap) [list source [file join $dir entry.tcl]]
+set auto_index(::tk::EntryButton1) [list source [file join $dir entry.tcl]]
+set auto_index(::tk::EntryMouseSelect) [list source [file join $dir entry.tcl]]
+set auto_index(::tk::EntryPaste) [list source [file join $dir entry.tcl]]
+set auto_index(::tk::EntryAutoScan) [list source [file join $dir entry.tcl]]
+set auto_index(::tk::EntryKeySelect) [list source [file join $dir entry.tcl]]
+set auto_index(::tk::EntryInsert) [list source [file join $dir entry.tcl]]
+set auto_index(::tk::EntryBackspace) [list source [file join $dir entry.tcl]]
+set auto_index(::tk::EntrySeeInsert) [list source [file join $dir entry.tcl]]
+set auto_index(::tk::EntrySetCursor) [list source [file join $dir entry.tcl]]
+set auto_index(::tk::EntryTranspose) [list source [file join $dir entry.tcl]]
+set auto_index(::tk::EntryPreviousWord) [list source [file join $dir entry.tcl]]
+set auto_index(::tk::EntryGetSelection) [list source [file join $dir entry.tcl]]
+set auto_index(tk_focusNext) [list source [file join $dir focus.tcl]]
+set auto_index(tk_focusPrev) [list source [file join $dir focus.tcl]]
+set auto_index(::tk::FocusOK) [list source [file join $dir focus.tcl]]
+set auto_index(tk_focusFollowsMouse) [list source [file join $dir focus.tcl]]
+set auto_index(::tk::IconList) [list source [file join $dir iconlist.tcl]]
+set auto_index(::tk::ListboxBeginSelect) [list source [file join $dir listbox.tcl]]
+set auto_index(::tk::ListboxMotion) [list source [file join $dir listbox.tcl]]
+set auto_index(::tk::ListboxBeginExtend) [list source [file join $dir listbox.tcl]]
+set auto_index(::tk::ListboxBeginToggle) [list source [file join $dir listbox.tcl]]
+set auto_index(::tk::ListboxAutoScan) [list source [file join $dir listbox.tcl]]
+set auto_index(::tk::ListboxUpDown) [list source [file join $dir listbox.tcl]]
+set auto_index(::tk::ListboxExtendUpDown) [list source [file join $dir listbox.tcl]]
+set auto_index(::tk::ListboxDataExtend) [list source [file join $dir listbox.tcl]]
+set auto_index(::tk::ListboxCancel) [list source [file join $dir listbox.tcl]]
+set auto_index(::tk::ListboxSelectAll) [list source [file join $dir listbox.tcl]]
+set auto_index(::tk::Megawidget) [list source [file join $dir megawidget.tcl]]
+set auto_index(::tk::MbEnter) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::MbLeave) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::MbPost) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::MenuUnpost) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::MbMotion) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::MbButtonUp) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::MenuMotion) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::MenuButtonDown) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::MenuLeave) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::MenuInvoke) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::MenuEscape) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::MenuUpArrow) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::MenuDownArrow) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::MenuLeftArrow) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::MenuRightArrow) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::MenuNextMenu) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::MenuNextEntry) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::MenuFind) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::TraverseToMenu) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::FirstMenu) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::TraverseWithinMenu) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::MenuFirstEntry) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::MenuFindName) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::PostOverPoint) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::SaveGrabInfo) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::RestoreOldGrab) [list source [file join $dir menu.tcl]]
+set auto_index(tk_menuSetFocus) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::GenerateMenuSelect) [list source [file join $dir menu.tcl]]
+set auto_index(tk_popup) [list source [file join $dir menu.tcl]]
+set auto_index(::tk::ensure_psenc_is_loaded) [list source [file join $dir mkpsenc.tcl]]
+set auto_index(::tk::MessageBox) [list source [file join $dir msgbox.tcl]]
+set auto_index(tk_menuBar) [list source [file join $dir obsolete.tcl]]
+set auto_index(tk_bindForTraversal) [list source [file join $dir obsolete.tcl]]
+set auto_index(::tk::classic::restore) [list source [file join $dir obsolete.tcl]]
+set auto_index(tk_optionMenu) [list source [file join $dir optMenu.tcl]]
+set auto_index(tk_setPalette) [list source [file join $dir palette.tcl]]
+set auto_index(::tk::RecolorTree) [list source [file join $dir palette.tcl]]
+set auto_index(::tk::Darken) [list source [file join $dir palette.tcl]]
+set auto_index(tk_bisque) [list source [file join $dir palette.tcl]]
+set auto_index(::safe::tkInterpInit) [list source [file join $dir safetk.tcl]]
+set auto_index(::safe::loadTk) [list source [file join $dir safetk.tcl]]
+set auto_index(::safe::TkInit) [list source [file join $dir safetk.tcl]]
+set auto_index(::safe::allowTk) [list source [file join $dir safetk.tcl]]
+set auto_index(::safe::disallowTk) [list source [file join $dir safetk.tcl]]
+set auto_index(::safe::tkDelete) [list source [file join $dir safetk.tcl]]
+set auto_index(::safe::tkTopLevel) [list source [file join $dir safetk.tcl]]
+set auto_index(::tk::ScaleActivate) [list source [file join $dir scale.tcl]]
+set auto_index(::tk::ScaleButtonDown) [list source [file join $dir scale.tcl]]
+set auto_index(::tk::ScaleDrag) [list source [file join $dir scale.tcl]]
+set auto_index(::tk::ScaleEndDrag) [list source [file join $dir scale.tcl]]
+set auto_index(::tk::ScaleIncrement) [list source [file join $dir scale.tcl]]
+set auto_index(::tk::ScaleControlPress) [list source [file join $dir scale.tcl]]
+set auto_index(::tk::ScaleButton2Down) [list source [file join $dir scale.tcl]]
+set auto_index(::tk::ScrollButtonDown) [list source [file join $dir scrlbar.tcl]]
+set auto_index(::tk::ScrollButtonUp) [list source [file join $dir scrlbar.tcl]]
+set auto_index(::tk::ScrollSelect) [list source [file join $dir scrlbar.tcl]]
+set auto_index(::tk::ScrollStartDrag) [list source [file join $dir scrlbar.tcl]]
+set auto_index(::tk::ScrollDrag) [list source [file join $dir scrlbar.tcl]]
+set auto_index(::tk::ScrollEndDrag) [list source [file join $dir scrlbar.tcl]]
+set auto_index(::tk::ScrollByUnits) [list source [file join $dir scrlbar.tcl]]
+set auto_index(::tk::ScrollByPages) [list source [file join $dir scrlbar.tcl]]
+set auto_index(::tk::ScrollToPos) [list source [file join $dir scrlbar.tcl]]
+set auto_index(::tk::ScrollTopBottom) [list source [file join $dir scrlbar.tcl]]
+set auto_index(::tk::ScrollButton2Down) [list source [file join $dir scrlbar.tcl]]
+set auto_index(::tk::spinbox::Invoke) [list source [file join $dir spinbox.tcl]]
+set auto_index(::tk::spinbox::ClosestGap) [list source [file join $dir spinbox.tcl]]
+set auto_index(::tk::spinbox::ButtonDown) [list source [file join $dir spinbox.tcl]]
+set auto_index(::tk::spinbox::ButtonUp) [list source [file join $dir spinbox.tcl]]
+set auto_index(::tk::spinbox::MouseSelect) [list source [file join $dir spinbox.tcl]]
+set auto_index(::tk::spinbox::Paste) [list source [file join $dir spinbox.tcl]]
+set auto_index(::tk::spinbox::Motion) [list source [file join $dir spinbox.tcl]]
+set auto_index(::tk::spinbox::AutoScan) [list source [file join $dir spinbox.tcl]]
+set auto_index(::tk::spinbox::KeySelect) [list source [file join $dir spinbox.tcl]]
+set auto_index(::tk::spinbox::Insert) [list source [file join $dir spinbox.tcl]]
+set auto_index(::tk::spinbox::Backspace) [list source [file join $dir spinbox.tcl]]
+set auto_index(::tk::spinbox::SeeInsert) [list source [file join $dir spinbox.tcl]]
+set auto_index(::tk::spinbox::SetCursor) [list source [file join $dir spinbox.tcl]]
+set auto_index(::tk::spinbox::Transpose) [list source [file join $dir spinbox.tcl]]
+set auto_index(::tk::spinbox::PreviousWord) [list source [file join $dir spinbox.tcl]]
+set auto_index(::tk::spinbox::GetSelection) [list source [file join $dir spinbox.tcl]]
+set auto_index(::tk::TearOffMenu) [list source [file join $dir tearoff.tcl]]
+set auto_index(::tk::MenuDup) [list source [file join $dir tearoff.tcl]]
+set auto_index(::tk::TextClosestGap) [list source [file join $dir text.tcl]]
+set auto_index(::tk::TextButton1) [list source [file join $dir text.tcl]]
+set auto_index(::tk::TextSelectTo) [list source [file join $dir text.tcl]]
+set auto_index(::tk::TextKeyExtend) [list source [file join $dir text.tcl]]
+set auto_index(::tk::TextPaste) [list source [file join $dir text.tcl]]
+set auto_index(::tk::TextAutoScan) [list source [file join $dir text.tcl]]
+set auto_index(::tk::TextSetCursor) [list source [file join $dir text.tcl]]
+set auto_index(::tk::TextKeySelect) [list source [file join $dir text.tcl]]
+set auto_index(::tk::TextResetAnchor) [list source [file join $dir text.tcl]]
+set auto_index(::tk::TextInsert) [list source [file join $dir text.tcl]]
+set auto_index(::tk::TextUpDownLine) [list source [file join $dir text.tcl]]
+set auto_index(::tk::TextPrevPara) [list source [file join $dir text.tcl]]
+set auto_index(::tk::TextNextPara) [list source [file join $dir text.tcl]]
+set auto_index(::tk::TextScrollPages) [list source [file join $dir text.tcl]]
+set auto_index(::tk::TextTranspose) [list source [file join $dir text.tcl]]
+set auto_index(tk_textCopy) [list source [file join $dir text.tcl]]
+set auto_index(tk_textCut) [list source [file join $dir text.tcl]]
+set auto_index(tk_textPaste) [list source [file join $dir text.tcl]]
+set auto_index(::tk::TextNextPos) [list source [file join $dir text.tcl]]
+set auto_index(::tk::TextPrevPos) [list source [file join $dir text.tcl]]
+set auto_index(::tk::PlaceWindow) [list source [file join $dir tk.tcl]]
+set auto_index(::tk::SetFocusGrab) [list source [file join $dir tk.tcl]]
+set auto_index(::tk::RestoreFocusGrab) [list source [file join $dir tk.tcl]]
+set auto_index(::tk::ScreenChanged) [list source [file join $dir tk.tcl]]
+set auto_index(::tk::EventMotifBindings) [list source [file join $dir tk.tcl]]
+set auto_index(::tk::CancelRepeat) [list source [file join $dir tk.tcl]]
+set auto_index(::tk::TabToWindow) [list source [file join $dir tk.tcl]]
+set auto_index(::tk::dialog::file::) [list source [file join $dir tkfbox.tcl]]
+set auto_index(::tk::dialog::file::Config) [list source [file join $dir tkfbox.tcl]]
+set auto_index(::tk::dialog::file::Create) [list source [file join $dir tkfbox.tcl]]
+set auto_index(::tk::dialog::file::SetSelectMode) [list source [file join $dir tkfbox.tcl]]
+set auto_index(::tk::dialog::file::UpdateWhenIdle) [list source [file join $dir tkfbox.tcl]]
+set auto_index(::tk::dialog::file::Update) [list source [file join $dir tkfbox.tcl]]
+set auto_index(::tk::dialog::file::SetPathSilently) [list source [file join $dir tkfbox.tcl]]
+set auto_index(::tk::dialog::file::SetPath) [list source [file join $dir tkfbox.tcl]]
+set auto_index(::tk::dialog::file::SetFilter) [list source [file join $dir tkfbox.tcl]]
+set auto_index(::tk::dialog::file::ResolveFile) [list source [file join $dir tkfbox.tcl]]
+set auto_index(::tk::dialog::file::EntFocusIn) [list source [file join $dir tkfbox.tcl]]
+set auto_index(::tk::dialog::file::EntFocusOut) [list source [file join $dir tkfbox.tcl]]
+set auto_index(::tk::dialog::file::ActivateEnt) [list source [file join $dir tkfbox.tcl]]
+set auto_index(::tk::dialog::file::VerifyFileName) [list source [file join $dir tkfbox.tcl]]
+set auto_index(::tk::dialog::file::InvokeBtn) [list source [file join $dir tkfbox.tcl]]
+set auto_index(::tk::dialog::file::UpDirCmd) [list source [file join $dir tkfbox.tcl]]
+set auto_index(::tk::dialog::file::JoinFile) [list source [file join $dir tkfbox.tcl]]
+set auto_index(::tk::dialog::file::OkCmd) [list source [file join $dir tkfbox.tcl]]
+set auto_index(::tk::dialog::file::CancelCmd) [list source [file join $dir tkfbox.tcl]]
+set auto_index(::tk::dialog::file::ListBrowse) [list source [file join $dir tkfbox.tcl]]
+set auto_index(::tk::dialog::file::ListInvoke) [list source [file join $dir tkfbox.tcl]]
+set auto_index(::tk::dialog::file::Done) [list source [file join $dir tkfbox.tcl]]
+set auto_index(::tk::MotifFDialog) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::MotifFDialog_Create) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::MotifFDialog_FileTypes) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::MotifFDialog_SetFilter) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::MotifFDialog_Config) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::MotifFDialog_BuildUI) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::MotifFDialog_SetListMode) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::MotifFDialog_MakeSList) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::MotifFDialog_InterpFilter) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::MotifFDialog_Update) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::MotifFDialog_LoadFiles) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::MotifFDialog_BrowseDList) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::MotifFDialog_ActivateDList) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::MotifFDialog_BrowseFList) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::MotifFDialog_ActivateFList) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::MotifFDialog_ActivateFEnt) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::MotifFDialog_ActivateSEnt) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::MotifFDialog_OkCmd) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::MotifFDialog_FilterCmd) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::MotifFDialog_CancelCmd) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::ListBoxKeyAccel_Set) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::ListBoxKeyAccel_Unset) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::ListBoxKeyAccel_Key) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::ListBoxKeyAccel_Goto) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::ListBoxKeyAccel_Reset) [list source [file join $dir xmfbox.tcl]]
+set auto_index(tk_getFileType) [list source [file join $dir xmfbox.tcl]]
+set auto_index(::tk::unsupported::ExposePrivateCommand) [list source [file join $dir unsupported.tcl]]
+set auto_index(::tk::unsupported::ExposePrivateVariable) [list source [file join $dir unsupported.tcl]]
+set auto_index(::tk::fontchooser) [list source [file join $dir fontchooser.tcl]]
diff --git a/mplug_owl2/lib/tk8.6/tearoff.tcl b/mplug_owl2/lib/tk8.6/tearoff.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..e52a45754b8f1ac9e0b4b83ac4e20341bb3844a9
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/tearoff.tcl
@@ -0,0 +1,157 @@
+# tearoff.tcl --
+#
+# This file contains procedures that implement tear-off menus.
+#
+# Copyright (c) 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.
+#
+
+# ::tk::TearoffMenu --
+# Given the name of a menu, this procedure creates a torn-off menu
+# that is identical to the given menu (including nested submenus).
+# The new torn-off menu exists as a toplevel window managed by the
+# window manager.  The return value is the name of the new menu.
+# The window is created at the point specified by x and y
+#
+# Arguments:
+# w -			The menu to be torn-off (duplicated).
+# x -			x coordinate where window is created
+# y -			y coordinate where window is created
+
+proc ::tk::TearOffMenu {w {x 0} {y 0}} {
+    # Find a unique name to use for the torn-off menu.  Find the first
+    # ancestor of w that is a toplevel but not a menu, and use this as
+    # the parent of the new menu.  This guarantees that the torn off
+    # menu will be on the same screen as the original menu.  By making
+    # it a child of the ancestor, rather than a child of the menu, it
+    # can continue to live even if the menu is deleted;  it will go
+    # away when the toplevel goes away.
+
+    if {$x == 0} {
+	set x [winfo rootx $w]
+    }
+    if {$y == 0} {
+	set y [winfo rooty $w]
+	if {[tk windowingsystem] eq "aqua"} {
+	    # Shift by height of tearoff entry minus height of window titlebar
+	    catch {incr y [expr {[$w yposition 1] - 16}]}
+	    # Avoid the native menu bar which sits on top of everything.
+	    if {$y < 22} {set y 22}
+	}
+    }
+
+    set parent [winfo parent $w]
+    while {[winfo toplevel $parent] ne $parent \
+	    || [winfo class $parent] eq "Menu"} {
+	set parent [winfo parent $parent]
+    }
+    if {$parent eq "."} {
+	set parent ""
+    }
+    for {set i 1} 1 {incr i} {
+	set menu $parent.tearoff$i
+	if {![winfo exists $menu]} {
+	    break
+	}
+    }
+
+    $w clone $menu tearoff
+
+    # Pick a title for the new menu by looking at the parent of the
+    # original: if the parent is a menu, then use the text of the active
+    # entry.  If it's a menubutton then use its text.
+
+    set parent [winfo parent $w]
+    if {[$menu cget -title] ne ""} {
+	wm title $menu [$menu cget -title]
+    } else {
+	switch -- [winfo class $parent] {
+	    Menubutton {
+		wm title $menu [$parent cget -text]
+	    }
+	    Menu {
+		wm title $menu [$parent entrycget active -label]
+	    }
+	}
+    }
+
+    if {[tk windowingsystem] eq "win32"} {
+	# [Bug 3181181]: Find the toplevel window for the menu
+	set parent [winfo toplevel $parent]
+	while {[winfo class $parent] eq "Menu"} {
+	    set parent [winfo toplevel [winfo parent $parent]]
+	}
+	wm transient $menu [winfo toplevel $parent]
+	wm attributes $menu -toolwindow 1
+    }
+
+    $menu post $x $y
+
+    if {[winfo exists $menu] == 0} {
+	return ""
+    }
+
+    # Set tk::Priv(focus) on entry:  otherwise the focus will get lost
+    # after keyboard invocation of a sub-menu (it will stay on the
+    # submenu).
+
+    bind $menu <Enter> {
+	set tk::Priv(focus) %W
+    }
+
+    # If there is a -tearoffcommand option for the menu, invoke it
+    # now.
+
+    set cmd [$w cget -tearoffcommand]
+    if {$cmd ne ""} {
+	uplevel #0 $cmd [list $w $menu]
+    }
+    return $menu
+}
+
+# ::tk::MenuDup --
+# Given a menu (hierarchy), create a duplicate menu (hierarchy)
+# in a given window.
+#
+# Arguments:
+# src -			Source window.  Must be a menu.  It and its
+#			menu descendants will be duplicated at dst.
+# dst -			Name to use for topmost menu in duplicate
+#			hierarchy.
+
+proc ::tk::MenuDup {src dst type} {
+    set cmd [list menu $dst -type $type]
+    foreach option [$src configure] {
+	if {[llength $option] == 2} {
+	    continue
+	}
+	if {[lindex $option 0] eq "-type"} {
+	    continue
+	}
+	lappend cmd [lindex $option 0] [lindex $option 4]
+    }
+    eval $cmd
+
+    # Copy the meny entries, if any
+
+    set last [$src index last]
+    if {$last ne "none"} {
+	for {set i [$src cget -tearoff]} {$i <= $last} {incr i} {
+	    set cmd [list $dst add [$src type $i]]
+	    foreach option [$src entryconfigure $i]  {
+		lappend cmd [lindex $option 0] [lindex $option 4]
+	    }
+	    eval $cmd
+	}
+    }
+
+    # Duplicate the binding tags from the source menu, replacing src with dst
+
+    set tags [bindtags $src]
+    set x [lsearch -exact $tags $src]
+    if {$x >= 0} {lset tags $x $dst}
+    bindtags $dst $tags
+}
diff --git a/mplug_owl2/lib/tk8.6/text.tcl b/mplug_owl2/lib/tk8.6/text.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..60eab4178e6f7fcfa5a1cd3e00bc4329138ced0c
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/text.tcl
@@ -0,0 +1,1242 @@
+# text.tcl --
+#
+# This file defines the default bindings for Tk text widgets and provides
+# procedures that help in implementing the bindings.
+#
+# Copyright (c) 1992-1994 The Regents of the University of California.
+# Copyright (c) 1994-1997 Sun Microsystems, Inc.
+# Copyright (c) 1998 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:
+#
+# 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.
+# char -		Character position on the line;  kept in order
+#			to allow moving up or down past short lines while
+#			still remembering the desired position.
+# mouseMoved -		Non-zero means the mouse has moved a significant
+#			amount since the button went down (so, for example,
+#			start dragging out a selection).
+# prevPos -		Used when moving up or down lines via the keyboard.
+#			Keeps track of the previous insert position, so
+#			we can distinguish a series of ups and downs, all
+#			in a row, from a new up or down.
+# selectMode -		The style of selection currently underway:
+#			char, word, or line.
+# x, y -		Last known mouse coordinates for scanning
+#			and auto-scanning.
+#
+#-------------------------------------------------------------------------
+
+#-------------------------------------------------------------------------
+# The code below creates the default class bindings for text widgets.
+#-------------------------------------------------------------------------
+
+
+
+# Standard Motif bindings:
+
+bind Text <1> {
+    tk::TextButton1 %W %x %y
+    %W tag remove sel 0.0 end
+}
+bind Text <B1-Motion> {
+    set tk::Priv(x) %x
+    set tk::Priv(y) %y
+    tk::TextSelectTo %W %x %y
+}
+bind Text <Double-1> {
+    set tk::Priv(selectMode) word
+    tk::TextSelectTo %W %x %y
+    catch {%W mark set insert sel.first}
+}
+bind Text <Triple-1> {
+    set tk::Priv(selectMode) line
+    tk::TextSelectTo %W %x %y
+    catch {%W mark set insert sel.first}
+}
+bind Text <Shift-1> {
+    tk::TextResetAnchor %W @%x,%y
+    set tk::Priv(selectMode) char
+    tk::TextSelectTo %W %x %y
+}
+bind Text <Double-Shift-1>	{
+    set tk::Priv(selectMode) word
+    tk::TextSelectTo %W %x %y 1
+}
+bind Text <Triple-Shift-1>	{
+    set tk::Priv(selectMode) line
+    tk::TextSelectTo %W %x %y
+}
+bind Text <B1-Leave> {
+    set tk::Priv(x) %x
+    set tk::Priv(y) %y
+    tk::TextAutoScan %W
+}
+bind Text <B1-Enter> {
+    tk::CancelRepeat
+}
+bind Text <ButtonRelease-1> {
+    tk::CancelRepeat
+}
+
+bind Text <Control-1> {
+    %W mark set insert @%x,%y
+    # An operation that moves the insert mark without making it
+    # one end of the selection must insert an autoseparator
+    if {[%W cget -autoseparators]} {
+	%W edit separator
+    }
+}
+# stop an accidental double click triggering <Double-Button-1>
+bind Text <Double-Control-1> { # nothing }
+# stop an accidental movement triggering <B1-Motion>
+bind Text <Control-B1-Motion> { # nothing }
+bind Text <<PrevChar>> {
+    tk::TextSetCursor %W insert-1displayindices
+}
+bind Text <<NextChar>> {
+    tk::TextSetCursor %W insert+1displayindices
+}
+bind Text <<PrevLine>> {
+    tk::TextSetCursor %W [tk::TextUpDownLine %W -1]
+}
+bind Text <<NextLine>> {
+    tk::TextSetCursor %W [tk::TextUpDownLine %W 1]
+}
+bind Text <<SelectPrevChar>> {
+    tk::TextKeySelect %W [%W index {insert - 1displayindices}]
+}
+bind Text <<SelectNextChar>> {
+    tk::TextKeySelect %W [%W index {insert + 1displayindices}]
+}
+bind Text <<SelectPrevLine>> {
+    tk::TextKeySelect %W [tk::TextUpDownLine %W -1]
+}
+bind Text <<SelectNextLine>> {
+    tk::TextKeySelect %W [tk::TextUpDownLine %W 1]
+}
+bind Text <<PrevWord>> {
+    tk::TextSetCursor %W [tk::TextPrevPos %W insert tcl_startOfPreviousWord]
+}
+bind Text <<NextWord>> {
+    tk::TextSetCursor %W [tk::TextNextWord %W insert]
+}
+bind Text <<PrevPara>> {
+    tk::TextSetCursor %W [tk::TextPrevPara %W insert]
+}
+bind Text <<NextPara>> {
+    tk::TextSetCursor %W [tk::TextNextPara %W insert]
+}
+bind Text <<SelectPrevWord>> {
+    tk::TextKeySelect %W [tk::TextPrevPos %W insert tcl_startOfPreviousWord]
+}
+bind Text <<SelectNextWord>> {
+    tk::TextKeySelect %W [tk::TextNextWord %W insert]
+}
+bind Text <<SelectPrevPara>> {
+    tk::TextKeySelect %W [tk::TextPrevPara %W insert]
+}
+bind Text <<SelectNextPara>> {
+    tk::TextKeySelect %W [tk::TextNextPara %W insert]
+}
+bind Text <Prior> {
+    tk::TextSetCursor %W [tk::TextScrollPages %W -1]
+}
+bind Text <Shift-Prior> {
+    tk::TextKeySelect %W [tk::TextScrollPages %W -1]
+}
+bind Text <Next> {
+    tk::TextSetCursor %W [tk::TextScrollPages %W 1]
+}
+bind Text <Shift-Next> {
+    tk::TextKeySelect %W [tk::TextScrollPages %W 1]
+}
+bind Text <Control-Prior> {
+    %W xview scroll -1 page
+}
+bind Text <Control-Next> {
+    %W xview scroll 1 page
+}
+
+bind Text <<LineStart>> {
+    tk::TextSetCursor %W {insert display linestart}
+}
+bind Text <<SelectLineStart>> {
+    tk::TextKeySelect %W {insert display linestart}
+}
+bind Text <<LineEnd>> {
+    tk::TextSetCursor %W {insert display lineend}
+}
+bind Text <<SelectLineEnd>> {
+    tk::TextKeySelect %W {insert display lineend}
+}
+bind Text <Control-Home> {
+    tk::TextSetCursor %W 1.0
+}
+bind Text <Control-Shift-Home> {
+    tk::TextKeySelect %W 1.0
+}
+bind Text <Control-End> {
+    tk::TextSetCursor %W {end - 1 indices}
+}
+bind Text <Control-Shift-End> {
+    tk::TextKeySelect %W {end - 1 indices}
+}
+
+bind Text <Tab> {
+    if {[%W cget -state] eq "normal"} {
+	tk::TextInsert %W \t
+	focus %W
+	break
+    }
+}
+bind Text <Shift-Tab> {
+    # Needed only to keep <Tab> binding from triggering;  doesn't
+    # have to actually do anything.
+    break
+}
+bind Text <Control-Tab> {
+    focus [tk_focusNext %W]
+}
+bind Text <Control-Shift-Tab> {
+    focus [tk_focusPrev %W]
+}
+bind Text <Control-i> {
+    tk::TextInsert %W \t
+}
+bind Text <Return> {
+    tk::TextInsert %W \n
+    if {[%W cget -autoseparators]} {
+	%W edit separator
+    }
+}
+bind Text <Delete> {
+    if {[tk::TextCursorInSelection %W]} {
+	%W delete sel.first sel.last
+    } else {
+	if {[%W compare end != insert+1c]} {
+	    %W delete insert
+	}
+	%W see insert
+    }
+}
+bind Text <BackSpace> {
+    if {[tk::TextCursorInSelection %W]} {
+	%W delete sel.first sel.last
+    } else {
+	if {[%W compare insert != 1.0]} {
+	    %W delete insert-1c
+	}
+	%W see insert
+    }
+}
+
+bind Text <Control-space> {
+    %W mark set [tk::TextAnchor %W] insert
+}
+bind Text <Select> {
+    %W mark set [tk::TextAnchor %W] insert
+}
+bind Text <Control-Shift-space> {
+    set tk::Priv(selectMode) char
+    tk::TextKeyExtend %W insert
+}
+bind Text <Shift-Select> {
+    set tk::Priv(selectMode) char
+    tk::TextKeyExtend %W insert
+}
+bind Text <<SelectAll>> {
+    %W tag add sel 1.0 end
+}
+bind Text <<SelectNone>> {
+    %W tag remove sel 1.0 end
+    # An operation that clears the selection must insert an autoseparator,
+    # because the selection operation may have moved the insert mark
+    if {[%W cget -autoseparators]} {
+	%W edit separator
+    }
+}
+bind Text <<Cut>> {
+    tk_textCut %W
+}
+bind Text <<Copy>> {
+    tk_textCopy %W
+}
+bind Text <<Paste>> {
+    tk_textPaste %W
+}
+bind Text <<Clear>> {
+    # Make <<Clear>> an atomic operation on the Undo stack,
+    # i.e. separate it from other delete operations on either side
+    if {[%W cget -autoseparators]} {
+	%W edit separator
+    }
+    catch {%W delete sel.first sel.last}
+    if {[%W cget -autoseparators]} {
+	%W edit separator
+    }
+}
+bind Text <<PasteSelection>> {
+    if {$tk_strictMotif || ![info exists tk::Priv(mouseMoved)]
+	    || !$tk::Priv(mouseMoved)} {
+	tk::TextPasteSelection %W %x %y
+    }
+}
+bind Text <Insert> {
+    catch {tk::TextInsert %W [::tk::GetSelection %W PRIMARY]}
+}
+bind Text <Key> {
+    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
+# <Key> class binding will also fire and insert the character,
+# which is wrong.  Ditto for <Escape>.
+
+bind Text <Alt-Key> {# nothing }
+bind Text <Meta-Key> {# nothing}
+bind Text <Control-Key> {# nothing}
+bind Text <Escape> {# nothing}
+bind Text <KP_Enter> {# nothing}
+if {[tk windowingsystem] eq "aqua"} {
+    bind Text <Command-Key> {# nothing}
+    bind Text <Mod4-Key> {# nothing}
+}
+
+# Additional emacs-like bindings:
+
+bind Text <Control-d> {
+    if {!$tk_strictMotif && [%W compare end != insert+1c]} {
+	%W delete insert
+    }
+}
+bind Text <Control-k> {
+    if {!$tk_strictMotif && [%W compare end != insert+1c]} {
+	if {[%W compare insert == {insert lineend}]} {
+	    %W delete insert
+	} else {
+	    %W delete insert {insert lineend}
+	}
+    }
+}
+bind Text <Control-o> {
+    if {!$tk_strictMotif} {
+	%W insert insert \n
+	%W mark set insert insert-1c
+    }
+}
+bind Text <Control-t> {
+    if {!$tk_strictMotif} {
+	tk::TextTranspose %W
+    }
+}
+
+bind Text <<Undo>> {
+    # An Undo operation may remove the separator at the top of the Undo stack.
+    # Then the item at the top of the stack gets merged with the subsequent changes.
+    # Place separators before and after Undo to prevent this.
+    if {[%W cget -autoseparators]} {
+	%W edit separator
+    }
+    catch { %W edit undo }
+    if {[%W cget -autoseparators]} {
+	%W edit separator
+    }
+}
+
+bind Text <<Redo>> {
+    catch { %W edit redo }
+}
+
+bind Text <Meta-b> {
+    if {!$tk_strictMotif} {
+	tk::TextSetCursor %W [tk::TextPrevPos %W insert tcl_startOfPreviousWord]
+    }
+}
+bind Text <Meta-d> {
+    if {!$tk_strictMotif && [%W compare end != insert+1c]} {
+	%W delete insert [tk::TextNextWord %W insert]
+    }
+}
+bind Text <Meta-f> {
+    if {!$tk_strictMotif} {
+	tk::TextSetCursor %W [tk::TextNextWord %W insert]
+    }
+}
+bind Text <Meta-less> {
+    if {!$tk_strictMotif} {
+	tk::TextSetCursor %W 1.0
+    }
+}
+bind Text <Meta-greater> {
+    if {!$tk_strictMotif} {
+	tk::TextSetCursor %W end-1c
+    }
+}
+bind Text <Meta-BackSpace> {
+    if {!$tk_strictMotif} {
+	%W delete [tk::TextPrevPos %W insert tcl_startOfPreviousWord] insert
+    }
+}
+bind Text <Meta-Delete> {
+    if {!$tk_strictMotif} {
+	%W delete [tk::TextPrevPos %W insert tcl_startOfPreviousWord] insert
+    }
+}
+
+# Bindings for IME text input.
+
+bind Text <<TkStartIMEMarkedText>> {
+    dict set ::tk::Priv(IMETextMark) "%W" [%W index insert]
+}
+bind Text <<TkEndIMEMarkedText>> {
+    if { [catch {dict get $::tk::Priv(IMETextMark) "%W"} mark] } {
+	bell
+    } else {
+	%W tag add IMEmarkedtext $mark insert
+	%W tag configure IMEmarkedtext -underline on
+    }
+}
+bind Text <<TkClearIMEMarkedText>> {
+    %W delete IMEmarkedtext.first IMEmarkedtext.last
+}
+bind Text <<TkAccentBackspace>> {
+    %W delete insert-1c
+}
+
+# Macintosh only bindings:
+
+if {[tk windowingsystem] eq "aqua"} {
+bind Text <Control-v> {
+    tk::TextScrollPages %W 1
+}
+
+# End of Mac only bindings
+}
+
+# A few additional bindings of my own.
+
+bind Text <Control-h> {
+    if {!$tk_strictMotif && [%W compare insert != 1.0]} {
+	%W delete insert-1c
+	%W see insert
+    }
+}
+if {[tk windowingsystem] ne "aqua"} {
+    bind Text <2> {
+        if {!$tk_strictMotif} {
+        tk::TextScanMark %W %x %y
+        }
+    }
+    bind Text <B2-Motion> {
+        if {!$tk_strictMotif} {
+        tk::TextScanDrag %W %x %y
+        }
+    }
+} else {
+    bind Text <3> {
+        if {!$tk_strictMotif} {
+        tk::TextScanMark %W %x %y
+        }
+    }
+    bind Text <B3-Motion> {
+        if {!$tk_strictMotif} {
+        tk::TextScanDrag %W %x %y
+        }
+    }
+}
+set ::tk::Priv(prevPos) {}
+
+# The MouseWheel will typically only fire on Windows and MacOS X.
+# However, someone could use the "event generate" command to produce one
+# on other platforms.  We must be careful not to round -ve values of %D
+# down to zero.
+
+if {[tk windowingsystem] eq "aqua"} {
+    bind Text <MouseWheel> {
+        %W yview scroll [expr {-15 * (%D)}] pixels
+    }
+    bind Text <Option-MouseWheel> {
+        %W yview scroll [expr {-150 * (%D)}] pixels
+    }
+    bind Text <Shift-MouseWheel> {
+        %W xview scroll [expr {-15 * (%D)}] pixels
+    }
+    bind Text <Shift-Option-MouseWheel> {
+        %W xview scroll [expr {-150 * (%D)}] pixels
+    }
+} else {
+    # We must make sure that positive and negative movements are rounded
+    # equally to integers, avoiding the problem that
+    #     (int)1/3 = 0,
+    # but
+    #     (int)-1/3 = -1
+    # The following code ensure equal +/- behaviour.
+    bind Text <MouseWheel> {
+	if {%D >= 0} {
+	    %W yview scroll [expr {-%D/3}] pixels
+	} else {
+	    %W yview scroll [expr {(2-%D)/3}] pixels
+	}
+    }
+    bind Text <Shift-MouseWheel> {
+	if {%D >= 0} {
+	    %W xview scroll [expr {-%D/3}] pixels
+	} else {
+	    %W xview scroll [expr {(2-%D)/3}] pixels
+	}
+    }
+}
+
+if {[tk windowingsystem] eq "x11"} {
+    # 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:
+    #	https://linuxreviews.org/HOWTO_change_the_mouse_speed_in_X
+    bind Text <4> {
+	if {!$tk_strictMotif} {
+	    %W yview scroll -50 pixels
+	}
+    }
+    bind Text <5> {
+	if {!$tk_strictMotif} {
+	    %W yview scroll 50 pixels
+	}
+    }
+    bind Text <Shift-4> {
+	if {!$tk_strictMotif} {
+	    %W xview scroll -50 pixels
+	}
+    }
+    bind Text <Shift-5> {
+	if {!$tk_strictMotif} {
+	    %W xview scroll 50 pixels
+	}
+    }
+}
+
+# ::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 {$bbox eq ""} {
+	return $pos
+    }
+    # The check on y coord of the line bbox with dlineinfo is to fix
+    # [a9cf210a42] to properly handle selecting and moving the mouse
+    # out of the widget.
+    if {$y < [lindex [$w dlineinfo $pos] 1] ||
+            $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
+    set anchorname [tk::TextAnchor $w]
+    $w mark set insert [TextClosestGap $w $x $y]
+    $w mark set $anchorname insert
+    # Set the anchor mark's gravity depending on the click position
+    # relative to the gap
+    set bbox [$w bbox [$w index $anchorname]]
+    if {$x > [lindex $bbox 0]} {
+	$w mark gravity $anchorname right
+    } else {
+	$w mark gravity $anchorname left
+    }
+    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.
+#
+# Note that the 'anchor' is implemented programmatically using
+# a text widget mark, and uses a name that will be unique for each
+# text widget (even when there are multiple peers).  Currently the
+# anchor is considered private to Tk, hence the name 'tk::anchor$w'.
+#
+# Arguments:
+# w -		The text window in which the button was pressed.
+# x -		Mouse x position.
+# y - 		Mouse y position.
+
+set ::tk::Priv(textanchoruid) 0
+
+proc ::tk::TextAnchor {w} {
+    variable Priv
+    if {![info exists Priv(textanchor,$w)]} {
+        set Priv(textanchor,$w) tk::anchor[incr Priv(textanchoruid)]
+    }
+    return $Priv(textanchor,$w)
+}
+
+proc ::tk::TextSelectTo {w x y {extend 0}} {
+    variable ::tk::Priv
+
+    set anchorname [tk::TextAnchor $w]
+    set cur [TextClosestGap $w $x $y]
+    if {[catch {$w index $anchorname}]} {
+	$w mark set $anchorname $cur
+    }
+    set anchor [$w index $anchorname]
+    if {[$w compare $cur != $anchor] || (abs($Priv(pressX) - $x) >= 3)} {
+	set Priv(mouseMoved) 1
+    }
+    switch -- $Priv(selectMode) {
+	char {
+	    if {[$w compare $cur < $anchorname]} {
+		set first $cur
+		set last $anchorname
+	    } else {
+		set first $anchorname
+		set last $cur
+	    }
+	}
+	word {
+	    # Set initial range based only on the anchor (1 char min width)
+	    if {[$w mark gravity $anchorname] eq "right"} {
+		set first $anchorname
+		set last "$anchorname + 1c"
+	    } else {
+		set first "$anchorname - 1c"
+		set last $anchorname
+	    }
+	    # Extend range (if necessary) based on the current point
+	    if {[$w compare $cur < $first]} {
+		set first $cur
+	    } elseif {[$w compare $cur > $last]} {
+		set last $cur
+	    }
+
+	    # Now find word boundaries
+	    set first [TextPrevPos $w "$first + 1c" tcl_wordBreakBefore]
+	    set last [TextNextPos $w "$last - 1c" tcl_wordBreakAfter]
+	}
+	line {
+	    # Set initial range based only on the anchor
+	    set first "$anchorname linestart"
+	    set last "$anchorname lineend"
+
+	    # Extend range (if necessary) based on the current point
+	    if {[$w compare $cur < $first]} {
+		set first "$cur linestart"
+	    } elseif {[$w compare $cur > $last]} {
+		set last "$cur lineend"
+	    }
+	    set first [$w index $first]
+	    set last [$w index "$last + 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 anchorname [tk::TextAnchor $w]
+    set cur [$w index $index]
+    if {[catch {$w index $anchorname}]} {
+	$w mark set $anchorname $cur
+    }
+    set anchor [$w index $anchorname]
+    if {[$w compare $cur < $anchorname]} {
+	set first $cur
+	set last $anchorname
+    } else {
+	set first $anchorname
+	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 {[$w cget -state] eq "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 [expr {1 + $Priv(y) - [winfo height $w]}] pixels
+    } elseif {$Priv(y) < 0} {
+	$w yview scroll [expr {-1 + $Priv(y)}] pixels
+    } 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} {
+    set anchorname [tk::TextAnchor $w]
+    if {[$w tag nextrange sel 1.0 end] eq ""} {
+	if {[$w compare $new < insert]} {
+	    $w tag add sel $new insert
+	} else {
+	    $w tag add sel insert $new
+	}
+	$w mark set $anchorname insert
+    } else {
+        if {[catch {$w index $anchorname}]} {
+            $w mark set $anchorname insert
+        }
+	if {[$w compare $new < $anchorname]} {
+	    set first $new
+	    set last $anchorname
+	} else {
+	    set first $anchorname
+	    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 {[$w tag ranges sel] eq ""} {
+	# 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 anchorname [tk::TextAnchor $w]
+    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 $anchorname sel.last
+	return
+    }
+    if {[$w compare $a > $c]} {
+	$w mark set $anchorname 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 $anchorname sel.last
+	} else {
+	    $w mark set $anchorname sel.first
+	}
+	return
+    }
+    if {($lineA-$lineB) < ($lineC-$lineA)} {
+	$w mark set $anchorname sel.last
+    } else {
+	$w mark set $anchorname sel.first
+    }
+}
+
+# ::tk::TextCursorInSelection --
+# Check whether the selection exists and contains the insertion cursor. Note
+# that it assumes that the selection is contiguous.
+#
+# Arguments:
+# w -		The text widget whose selection is to be checked
+
+proc ::tk::TextCursorInSelection {w} {
+    expr {
+	[llength [$w tag ranges sel]]
+	&& [$w compare sel.first <= insert]
+	&& [$w compare sel.last >= insert]
+    }
+}
+
+# ::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 {$s eq "" || [$w cget -state] eq "disabled"} {
+	return
+    }
+    set compound 0
+    if {[TextCursorInSelection $w]} {
+	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 display line above or below the
+# insertion cursor.  There is a tricky thing here: we want to maintain the
+# original x position across repeated operations, even though some lines
+# that will get passed through don't have enough characters to cover the
+# original column.
+#
+# Arguments:
+# w -		The text window in which the cursor is to move.
+# n -		The number of display 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]
+    if {$Priv(prevPos) ne $i} {
+	set Priv(textPosOrig) $i
+    }
+    set lines [$w count -displaylines $Priv(textPosOrig) $i]
+    set new [$w index \
+	    "$Priv(textPosOrig) + [expr {$lines + $n}] displaylines"]
+    set Priv(prevPos) $new
+    if {[$w compare $new == "end display lineend"] \
+            || [$w compare $new == "insert display linestart"]} {
+        set Priv(textPosOrig) $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 {([$w get "$pos - 1 line"] eq "\n" && ([$w get $pos] ne "\n")) \
+		|| $pos eq "1.0"} {
+	    if {[regexp -indices -- {^[ \t]+(.)} \
+		    [$w get $pos "$pos lineend"] -> index]} {
+		set pos [$w index "$pos + [lindex $index 0] chars"]
+	    }
+	    if {[$w compare $pos != insert] || [lindex [split $pos .] 0]==1} {
+		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 -- {^[ \t]+(.)} \
+	    [$w get $pos "$pos lineend"] -> 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 {$bbox eq ""} {
+	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]}]} {
+        # make <<Cut>> an atomic operation on the Undo stack,
+        # i.e. separate it from other delete operations on either side
+	set oldSeparator [$w cget -autoseparators]
+	if {([$w cget -state] eq "normal") && $oldSeparator} {
+	    $w edit separator
+	}
+	clipboard clear -displayof $w
+	clipboard append -displayof $w $data
+	$w delete sel.first sel.last
+	if {([$w cget -state] eq "normal") && $oldSeparator} {
+	    $w edit separator
+	}
+    }
+}
+
+# ::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 {
+    if {![catch {::tk::GetSelection $w CLIPBOARD} sel]} {
+	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 {[tk windowingsystem] eq "win32"}  {
+    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 -displaychars $cur "$cur lineend + 1c"]
+	set pos [$op $text 0]
+	if {$pos >= 0} {
+	    return [$w index "$start + $pos display chars"]
+	}
+	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 -displaychars "$cur linestart - 1c" $cur]$text
+	set pos [$op $text end]
+	if {$pos >= 0} {
+	    return [$w index "$cur linestart - 1c + $pos display chars"]
+	}
+	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} {
+    variable ::tk::Priv
+    $w scan mark $x $y
+    set Priv(x) $x
+    set Priv(y) $y
+    set 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} {
+    variable ::tk::Priv
+    # Make sure these exist, as some weird situations can trigger the
+    # motion binding without the initial press.  [Bug #220269]
+    if {![info exists Priv(x)]} {
+	set Priv(x) $x
+    }
+    if {![info exists Priv(y)]} {
+	set Priv(y) $y
+    }
+    if {($x != $Priv(x)) || ($y != $Priv(y))} {
+	set Priv(mouseMoved) 1
+    }
+    if {[info exists Priv(mouseMoved)] && $Priv(mouseMoved)} {
+	$w scan dragto $x $y
+    }
+}
diff --git a/mplug_owl2/lib/tk8.6/tk.tcl b/mplug_owl2/lib/tk8.6/tk.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..7a7c29e922f4028a150118cad947070a05adf859
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/tk.tcl
@@ -0,0 +1,708 @@
+# tk.tcl --
+#
+# Initialization script normally executed in the interpreter for each Tk-based
+# application.  Arranges class bindings for widgets.
+#
+# 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.
+
+# Verify that we have Tk binary and script components from the same release
+package require -exact Tk  8.6.14
+
+# 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 [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::*
+}
+# and a ::ttk namespace
+namespace eval ::ttk {
+    if {$::tk_library ne ""} {
+	# avoid file join to work in safe interps, but this is also x-plat ok
+	variable library $::tk_library/ttk
+    }
+}
+
+# Add Ttk & 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] && ($::tk_library ne "")
+    && ($::tk_library ni $::auto_path)
+} then {
+    lappend ::auto_path $::tk_library $::ttk::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 -length [string length $place] $place "pointer"]} {
+	## place at POINTER (centered if $anchor == center)
+	if {[string equal -length [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 -length [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 {$checkBounds} {
+	if {$x < [winfo vrootx $w]} {
+	    set x [winfo vrootx $w]
+	} elseif {$x > ([winfo vrootx $w]+[winfo vrootwidth $w]-[winfo reqwidth $w])} {
+	    set x [expr {[winfo vrootx $w]+[winfo vrootwidth $w]-[winfo reqwidth $w]}]
+	}
+	if {$y < [winfo vrooty $w]} {
+	    set y [winfo vrooty $w]
+	} elseif {$y > ([winfo vrooty $w]+[winfo vrootheight $w]-[winfo reqheight $w])} {
+	    set y [expr {[winfo vrooty $w]+[winfo vrootheight $w]-[winfo reqheight $w]}]
+	}
+	if {[tk windowingsystem] eq "aqua"} {
+	    # Avoid the native menu bar which sits on top of everything.
+	    if {$y < 22} {
+		set y 22
+	    }
+	}
+    }
+    wm maxsize $w [winfo vrootwidth $w] [winfo vrootheight $w]
+    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 {[winfo exists $grab]} {
+	if {$destroy eq "withdraw"} {
+	    wm withdraw $grab
+	} else {
+	    destroy $grab
+	}
+    }
+    if {[winfo exists $oldGrab] && [winfo ismapped $oldGrab]} {
+	# The "grab" command will fail if another application
+	# already holds the grab on a window with the same name.
+	# So catch it. See [7447ed20ec] for an example.
+	if {$oldStatus eq "global"} {
+	    catch {grab -global $oldGrab}
+	} else {
+	    catch {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 {[tk windowingsystem] ne "win32"} {
+    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]} then {
+	    return -code error -errorcode {TK SELECTION NONE} \
+		"could not find default selection"
+	} else {
+	    return $txt
+	}
+    }
+} else {
+    proc ::tk::GetSelection {w {sel PRIMARY}} {
+	if {[catch {
+	    selection get -displayof $w -selection $sel
+	} txt]} then {
+	    return -code error -errorcode {TK SELECTION NONE} \
+		"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 {
+    # Extract the display name.
+    set disp [string range $screen 0 [string last . $screen]-1]
+
+    # Ensure that namespace separators never occur in the display name (as
+    # they cause problems in variable names). Double-colons exist in some VNC
+    # display names. [Bug 2912473]
+    set disp [string map {:: _doublecolon_} $disp]
+
+    uplevel #0 [list upvar #0 ::tk::Priv.$disp ::tk::Priv]
+    variable ::tk::Priv
+
+    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 <<Cut>> <Control-Key-w> <Control-Lock-Key-W> <Shift-Key-Delete>
+    event $op <<Copy>> <Meta-Key-w> <Meta-Lock-Key-W> <Control-Key-Insert>
+    event $op <<Paste>> <Control-Key-y> <Control-Lock-Key-Y> <Shift-Key-Insert>
+    event $op <<PrevChar>> <Control-Key-b> <Control-Lock-Key-B>
+    event $op <<NextChar>> <Control-Key-f> <Control-Lock-Key-F>
+    event $op <<PrevLine>> <Control-Key-p> <Control-Lock-Key-P>
+    event $op <<NextLine>> <Control-Key-n> <Control-Lock-Key-N>
+    event $op <<LineStart>> <Control-Key-a> <Control-Lock-Key-A>
+    event $op <<LineEnd>> <Control-Key-e> <Control-Lock-Key-E>
+    event $op <<SelectPrevChar>> <Control-Key-B> <Control-Lock-Key-b>
+    event $op <<SelectNextChar>> <Control-Key-F> <Control-Lock-Key-f>
+    event $op <<SelectPrevLine>> <Control-Key-P> <Control-Lock-Key-p>
+    event $op <<SelectNextLine>> <Control-Key-N> <Control-Lock-Key-n>
+    event $op <<SelectLineStart>> <Control-Key-A> <Control-Lock-Key-a>
+    event $op <<SelectLineEnd>> <Control-Key-E> <Control-Lock-Key-e>
+}
+
+#----------------------------------------------------------------------
+# Define common dialogs on platforms where they are not implemented
+# using compiled code.
+#----------------------------------------------------------------------
+
+if {![llength [info commands tk_chooseColor]]} {
+    proc ::tk_chooseColor {args} {
+	return [::tk::dialog::color:: {*}$args]
+    }
+}
+if {![llength [info commands tk_getOpenFile]]} {
+    proc ::tk_getOpenFile {args} {
+	if {$::tk_strictMotif} {
+	    return [::tk::MotifFDialog open {*}$args]
+	} else {
+	    return [::tk::dialog::file:: open {*}$args]
+	}
+    }
+}
+if {![llength [info commands tk_getSaveFile]]} {
+    proc ::tk_getSaveFile {args} {
+	if {$::tk_strictMotif} {
+	    return [::tk::MotifFDialog save {*}$args]
+	} else {
+	    return [::tk::dialog::file:: save {*}$args]
+	}
+    }
+}
+if {![llength [info commands tk_messageBox]]} {
+    proc ::tk_messageBox {args} {
+	return [::tk::MessageBox {*}$args]
+    }
+}
+if {![llength [info command tk_chooseDirectory]]} {
+    proc ::tk_chooseDirectory {args} {
+	return [::tk::dialog::file::chooseDir:: {*}$args]
+    }
+}
+
+#----------------------------------------------------------------------
+# Define the set of common virtual events.
+#----------------------------------------------------------------------
+
+switch -exact -- [tk windowingsystem] {
+    "x11" {
+	event add <<Cut>>		<Control-Key-x> <Key-F20> <Control-Lock-Key-X>
+	event add <<Copy>>		<Control-Key-c> <Key-F16> <Control-Lock-Key-C>
+	event add <<Paste>>		<Control-Key-v> <Key-F18> <Control-Lock-Key-V>
+	event add <<PasteSelection>>	<ButtonRelease-2>
+	event add <<Undo>>		<Control-Key-z> <Control-Lock-Key-Z>
+	event add <<Redo>>		<Control-Key-Z> <Control-Lock-Key-z>
+	event add <<ContextMenu>>	<Button-3>
+	# On Darwin/Aqua, buttons from left to right are 1,3,2.  On Darwin/X11 with recent
+	# XQuartz as the X server, they are 1,2,3; other X servers may differ.
+
+	event add <<SelectAll>>		<Control-Key-slash>
+	event add <<SelectNone>>	<Control-Key-backslash>
+	event add <<NextChar>>		<Right>
+	event add <<SelectNextChar>>	<Shift-Right>
+	event add <<PrevChar>>		<Left>
+	event add <<SelectPrevChar>>	<Shift-Left>
+	event add <<NextWord>>		<Control-Right>
+	event add <<SelectNextWord>>	<Control-Shift-Right>
+	event add <<PrevWord>>		<Control-Left>
+	event add <<SelectPrevWord>>	<Control-Shift-Left>
+	event add <<LineStart>>		<Home>
+	event add <<SelectLineStart>>	<Shift-Home>
+	event add <<LineEnd>>		<End>
+	event add <<SelectLineEnd>>	<Shift-End>
+	event add <<PrevLine>>		<Up>
+	event add <<NextLine>>		<Down>
+	event add <<SelectPrevLine>>	<Shift-Up>
+	event add <<SelectNextLine>>	<Shift-Down>
+	event add <<PrevPara>>		<Control-Up>
+	event add <<NextPara>>		<Control-Down>
+	event add <<SelectPrevPara>>	<Control-Shift-Up>
+	event add <<SelectNextPara>>	<Control-Shift-Down>
+	event add <<ToggleSelection>>	<Control-Button-1>
+
+	# Some OS's define a goofy (as in, not <Shift-Tab>) keysym that is
+	# returned when the user presses <Shift-Tab>. 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 <<PrevWindow>> <ISO_Left_Tab> }
+	# This seems to be correct on *some* HP systems.
+	catch { event add <<PrevWindow>> <hpBackTab> }
+
+	trace add variable ::tk_strictMotif write ::tk::EventMotifBindings
+	set ::tk_strictMotif $::tk_strictMotif
+	# On unix, we want to always display entry/text selection,
+	# regardless of which window has focus
+	set ::tk::AlwaysShowSelection 1
+    }
+    "win32" {
+	event add <<Cut>>		<Control-Key-x> <Shift-Key-Delete> <Control-Lock-Key-X>
+	event add <<Copy>>		<Control-Key-c> <Control-Key-Insert> <Control-Lock-Key-C>
+	event add <<Paste>>		<Control-Key-v> <Shift-Key-Insert> <Control-Lock-Key-V>
+	event add <<PasteSelection>>	<ButtonRelease-2>
+  	event add <<Undo>>		<Control-Key-z> <Control-Lock-Key-Z>
+	event add <<Redo>>		<Control-Key-y> <Control-Lock-Key-Y>
+	event add <<ContextMenu>>	<Button-3>
+
+	event add <<SelectAll>>		<Control-Key-slash> <Control-Key-a> <Control-Lock-Key-A>
+	event add <<SelectNone>>	<Control-Key-backslash>
+	event add <<NextChar>>		<Right>
+	event add <<SelectNextChar>>	<Shift-Right>
+	event add <<PrevChar>>		<Left>
+	event add <<SelectPrevChar>>	<Shift-Left>
+	event add <<NextWord>>		<Control-Right>
+	event add <<SelectNextWord>>	<Control-Shift-Right>
+	event add <<PrevWord>>		<Control-Left>
+	event add <<SelectPrevWord>>	<Control-Shift-Left>
+	event add <<LineStart>>		<Home>
+	event add <<SelectLineStart>>	<Shift-Home>
+	event add <<LineEnd>>		<End>
+	event add <<SelectLineEnd>>	<Shift-End>
+	event add <<PrevLine>>		<Up>
+	event add <<NextLine>>		<Down>
+	event add <<SelectPrevLine>>	<Shift-Up>
+	event add <<SelectNextLine>>	<Shift-Down>
+	event add <<PrevPara>>		<Control-Up>
+	event add <<NextPara>>		<Control-Down>
+	event add <<SelectPrevPara>>	<Control-Shift-Up>
+	event add <<SelectNextPara>>	<Control-Shift-Down>
+	event add <<ToggleSelection>>	<Control-Button-1>
+    }
+    "aqua" {
+	event add <<Cut>>		<Command-Key-x> <Key-F2> <Command-Lock-Key-X>
+	event add <<Copy>>		<Command-Key-c> <Key-F3> <Command-Lock-Key-C>
+	event add <<Paste>>		<Command-Key-v> <Key-F4> <Command-Lock-Key-V>
+	event add <<PasteSelection>>	<ButtonRelease-3>
+	event add <<Clear>>		<Clear>
+	event add <<ContextMenu>>	<Button-2>
+
+	# Official bindings
+	# See https://support.apple.com/en-us/HT201236
+	event add <<SelectAll>>		<Command-Key-a>
+	event add <<Undo>>		<Command-Key-z> <Command-Lock-Key-Z>
+	event add <<Redo>>		<Shift-Command-Key-z> <Shift-Command-Lock-Key-z>
+	event add <<NextChar>>		<Right> <Control-Key-f> <Control-Lock-Key-F>
+	event add <<SelectNextChar>>	<Shift-Right> <Shift-Control-Key-F> <Shift-Control-Lock-Key-F>
+	event add <<PrevChar>>		<Left> <Control-Key-b> <Control-Lock-Key-B>
+	event add <<SelectPrevChar>>	<Shift-Left> <Shift-Control-Key-B> <Shift-Control-Lock-Key-B>
+	event add <<NextWord>>		<Option-Right>
+	event add <<SelectNextWord>>	<Shift-Option-Right>
+	event add <<PrevWord>>		<Option-Left>
+	event add <<SelectPrevWord>>	<Shift-Option-Left>
+	event add <<LineStart>>		<Home> <Command-Left> <Control-Key-a> <Control-Lock-Key-A>
+	event add <<SelectLineStart>>	<Shift-Home> <Shift-Command-Left> <Shift-Control-Key-A> <Shift-Control-Lock-Key-A>
+	event add <<LineEnd>>		<End> <Command-Right> <Control-Key-e> <Control-Lock-Key-E>
+	event add <<SelectLineEnd>>	<Shift-End> <Shift-Command-Right> <Shift-Control-Key-E> <Shift-Control-Lock-Key-E>
+	event add <<PrevLine>>		<Up> <Control-Key-p> <Control-Lock-Key-P>
+	event add <<SelectPrevLine>>	<Shift-Up> <Shift-Control-Key-P> <Shift-Control-Lock-Key-P>
+	event add <<NextLine>>		<Down> <Control-Key-n> <Control-Lock-Key-N>
+	event add <<SelectNextLine>>	<Shift-Down> <Shift-Control-Key-N> <Shift-Control-Lock-Key-N>
+	# Not official, but logical extensions of above. Also derived from
+	# bindings present in MS Word on OSX.
+	event add <<PrevPara>>		<Option-Up>
+	event add <<NextPara>>		<Option-Down>
+	event add <<SelectPrevPara>>	<Shift-Option-Up>
+	event add <<SelectNextPara>>	<Shift-Option-Down>
+	event add <<ToggleSelection>>	<Command-Button-1>
+    }
+}
+
+# ----------------------------------------------------------------------
+# Read in files that define all of the class bindings.
+# ----------------------------------------------------------------------
+
+if {$::tk_library ne ""} {
+    proc ::tk::SourceLibFile {file} {
+        namespace eval :: [list source -encoding utf-8 [file join $::tk_library $file.tcl]]
+    }
+    namespace eval ::tk {
+	SourceLibFile icons
+	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 <<PrevWindow>> <Shift-Tab>
+event add <<NextWindow>> <Tab>
+bind all <<NextWindow>> {tk::TabToWindow [tk_focusNext %W]}
+bind all <<PrevWindow>> {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.
+# It sends a <<TraverseOut>> virtual event to the previous focus window,
+# if any, before changing the focus, and a <<TraverseIn>> event
+# to the new focus window afterwards.
+#
+# Arguments:
+# w - Window to which focus should be set.
+
+proc ::tk::TabToWindow {w} {
+    set focus [focus]
+    if {$focus ne ""} {
+	event generate $focus <<TraverseOut>>
+    }
+    focus $w
+    event generate $w <<TraverseIn>>
+}
+
+# ::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 s [string map {&& & & \ufeff} $text]
+    set idx [string first \ufeff $s]
+    return [list [string map {\ufeff {}} $s] $idx]
+}
+
+# ::tk::SetAmpText --
+#	Given widget path and text with "magic ampersands", sets -text and
+#	-underline options for the widget
+#
+proc ::tk::SetAmpText {widget text} {
+    lassign [UnderlineAmpersand $text] newtext under
+    $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 options {}
+    foreach {opt val} $args {
+	if {$opt eq "-text"} {
+	    lassign [UnderlineAmpersand $val] newtext under
+	    lappend options -text $newtext -underline $under
+	} else {
+	    lappend options $opt $val
+	}
+    }
+    set result [$class $path {*}$options]
+    if {[string match "*button" $class]} {
+	bind $path <<AltUnderlined>> [list $path invoke]
+    }
+    return $result
+}
+
+# ::tk::AmpMenuArgs --
+#	Processes arguments for a menu entry, turning -label option into
+#	-label and -underline options, returned by ::tk::UnderlineAmpersand.
+#      The cmd argument is supposed to be either "add" or "entryconfigure"
+#
+proc ::tk::AmpMenuArgs {widget cmd type args} {
+    set options {}
+    foreach {opt val} $args {
+	if {$opt eq "-label"} {
+	    lassign [UnderlineAmpersand $val] newlabel under
+	    lappend options -label $newlabel -underline $under
+	} else {
+	    lappend options $opt $val
+	}
+    }
+    $widget $cmd $type {*}$options
+}
+
+# ::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} {
+    set class [winfo class $path]
+    if {$class in {
+	Button Checkbutton Label Radiobutton
+	TButton TCheckbutton TLabel TRadiobutton
+    } && [string equal -nocase $char \
+	    [string index [$path cget -text] [$path cget -underline]]]} {
+	return $path
+    }
+    set subwins [concat [grid slaves $path] [pack slaves $path] \
+	    [place slaves $path]]
+    if {$class eq "Canvas"} {
+	foreach item [$path find all] {
+	    if {[$path type $item] eq "window"} {
+		set w [$path itemcget $item -window]
+		if {$w ne ""} {lappend subwins $w}
+	    }
+	}
+    } elseif {$class eq "Text"} {
+	lappend subwins {*}[$path window names]
+    }
+    foreach child $subwins {
+	set target [FindAltKeyTarget $child $char]
+	if {$target ne ""} {
+	    return $target
+	}
+    }
+}
+
+# ::tk::AltKeyInDialog --
+#	<Alt-Key> event handler for standard dialogs. Sends <<AltUnderlined>>
+#	to button or label which has appropriate underlined character.
+#
+proc ::tk::AltKeyInDialog {path key} {
+    set target [FindAltKeyTarget $path $key]
+    if {$target ne ""} {
+	event generate $target <<AltUnderlined>>
+    }
+}
+
+# ::tk::mcmaxamp --
+#	Replacement for mcmax, used for texts with "magic ampersand" in it.
+#
+
+proc ::tk::mcmaxamp {args} {
+    set maxlen 0
+    foreach arg $args {
+	# Should we run [mc] in caller's namespace?
+	lassign [UnderlineAmpersand [mc $arg]] msg
+	set length [string length $msg]
+	if {$length > $maxlen} {
+	    set maxlen $length
+	}
+    }
+    return $maxlen
+}
+
+if {[tk windowingsystem] eq "aqua"} {
+    #stub procedures to respond to "do script" Apple Events
+    proc ::tk::mac::DoScriptFile {file} {
+	uplevel #0 $file
+    	source -encoding utf-8 $file
+    }
+    proc ::tk::mac::DoScriptText {script} {
+	uplevel #0 $script
+    	eval $script
+    }
+}
+
+# Create a dictionary to store the starting index of the IME marked
+# text in an Entry or Text widget.
+
+set ::tk::Priv(IMETextMark) [dict create]
+
+# Run the Ttk themed widget set initialization
+if {$::ttk::library ne ""} {
+    uplevel \#0 [list source -encoding utf-8 $::ttk::library/ttk.tcl]
+}
+
+# Local Variables:
+# mode: tcl
+# fill-column: 78
+# End:
diff --git a/mplug_owl2/lib/tk8.6/tkAppInit.c b/mplug_owl2/lib/tk8.6/tkAppInit.c
new file mode 100644
index 0000000000000000000000000000000000000000..1a2421c7f19831d546f02eea8a45182c120c8105
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/tkAppInit.c
@@ -0,0 +1,177 @@
+/*
+ * tkAppInit.c --
+ *
+ *	Provides a default version of the main program and Tcl_AppInit
+ *	procedure for wish and other Tk-based applications.
+ *
+ * Copyright (c) 1993 The Regents of the University of California.
+ * Copyright (c) 1994-1997 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.
+ */
+
+#undef BUILD_tk
+#undef STATIC_BUILD
+#include "tk.h"
+#include "tkPort.h"
+#if TCL_MAJOR_VERSION < 9 && TCL_MINOR_VERSION < 7
+#   define Tcl_LibraryInitProc Tcl_PackageInitProc
+#   define Tcl_StaticLibrary Tcl_StaticPackage
+#endif
+
+#ifdef TK_TEST
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern Tcl_LibraryInitProc Tktest_Init;
+#ifdef __cplusplus
+}
+#endif
+#endif /* TK_TEST */
+
+/*
+ * The following #if block allows you to change the AppInit function by using
+ * a #define of TCL_LOCAL_APPINIT instead of rewriting this entire file. The
+ * #if checks for that #define and uses Tcl_AppInit if it doesn't exist.
+ */
+
+#ifndef TK_LOCAL_APPINIT
+#define TK_LOCAL_APPINIT Tcl_AppInit
+#endif
+#ifndef MODULE_SCOPE
+#   ifdef __cplusplus
+#	define MODULE_SCOPE extern "C"
+#   else
+#	define MODULE_SCOPE extern
+#   endif
+#endif
+MODULE_SCOPE int TK_LOCAL_APPINIT(Tcl_Interp *);
+MODULE_SCOPE int main(int, char **);
+
+/*
+ * The following #if block allows you to change how Tcl finds the startup
+ * script, prime the library or encoding paths, fiddle with the argv, etc.,
+ * without needing to rewrite Tk_Main()
+ */
+
+#ifdef TK_LOCAL_MAIN_HOOK
+MODULE_SCOPE int TK_LOCAL_MAIN_HOOK(int *argc, char ***argv);
+#endif
+
+/* Make sure the stubbed variants of those are never used. */
+#undef Tcl_ObjSetVar2
+#undef Tcl_NewStringObj
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * main --
+ *
+ *	This is the main program for the application.
+ *
+ * Results:
+ *	None: Tk_Main never returns here, so this procedure never returns
+ *	either.
+ *
+ * Side effects:
+ *	Just about anything, since from here we call arbitrary Tcl code.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+main(
+    int argc,			/* Number of command-line arguments. */
+    char **argv)		/* Values of command-line arguments. */
+{
+#ifdef TK_LOCAL_MAIN_HOOK
+    TK_LOCAL_MAIN_HOOK(&argc, &argv);
+#endif
+
+    Tk_Main(argc, argv, TK_LOCAL_APPINIT);
+    return 0;			/* Needed only to prevent compiler warning. */
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_AppInit --
+ *
+ *	This procedure performs application-specific initialization. Most
+ *	applications, especially those that incorporate additional packages,
+ *	will have their own version of this procedure.
+ *
+ * Results:
+ *	Returns a standard Tcl completion code, and leaves an error message in
+ *	the interp's result if an error occurs.
+ *
+ * Side effects:
+ *	Depends on the startup script.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_AppInit(
+    Tcl_Interp *interp)		/* Interpreter for application. */
+{
+    if ((Tcl_Init)(interp) == TCL_ERROR) {
+	return TCL_ERROR;
+    }
+
+    if (Tk_Init(interp) == TCL_ERROR) {
+	return TCL_ERROR;
+    }
+    Tcl_StaticLibrary(interp, "Tk", Tk_Init, Tk_SafeInit);
+
+#if defined(USE_CUSTOM_EXIT_PROC)
+    if (TkpWantsExitProc()) {
+	Tcl_SetExitProc(TkpExitProc);
+    }
+#endif
+
+#ifdef TK_TEST
+    if (Tktest_Init(interp) == TCL_ERROR) {
+	return TCL_ERROR;
+    }
+    Tcl_StaticLibrary(interp, "Tktest", Tktest_Init, 0);
+#endif /* TK_TEST */
+
+    /*
+     * Call the init procedures for included packages. Each call should look
+     * like this:
+     *
+     * if (Mod_Init(interp) == TCL_ERROR) {
+     *     return TCL_ERROR;
+     * }
+     *
+     * where "Mod" is the name of the module. (Dynamically-loadable packages
+     * should have the same entry-point name.)
+     */
+
+    /*
+     * Call Tcl_CreateObjCommand for application-specific commands, if they
+     * weren't already created by the init procedures called above.
+     */
+
+    /*
+     * Specify a user-specific startup file to invoke if the application is
+     * run interactively. Typically the startup file is "~/.apprc" where "app"
+     * is the name of the application. If this line is deleted then no user-
+     * specific startup file will be run under any conditions.
+     */
+
+    Tcl_ObjSetVar2(interp, Tcl_NewStringObj("tcl_rcFileName", -1), NULL,
+	    Tcl_NewStringObj("~/.wishrc", -1), TCL_GLOBAL_ONLY);
+    return TCL_OK;
+}
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/mplug_owl2/lib/tk8.6/tkfbox.tcl b/mplug_owl2/lib/tk8.6/tkfbox.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..f034778822c1d3c674ad61a56a1135ca5fe90c86
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/tkfbox.tcl
@@ -0,0 +1,1241 @@
+# tkfbox.tcl --
+#
+#	Implements the "TK" standard file selection dialog box.  This dialog
+#	box is used on the Unix platforms whenever the tk_strictMotif flag is
+#	not set.
+#
+#	The "TK" standard file selection dialog box is similar to the file
+#	selection dialog box on Win95(TM).  The user can navigate the
+#	directories by clicking on the folder icons or by selecting the
+#	"Directory" option menu.  The user can select files by clicking on the
+#	file icons or by entering a filename in the "Filename:" entry.
+#
+# Copyright (c) 1994-1998 Sun Microsystems, Inc.
+#
+# See the file "license.terms" for information on usage and redistribution
+# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+#
+
+namespace eval ::tk::dialog {}
+namespace eval ::tk::dialog::file {
+    namespace import -force ::tk::msgcat::*
+    variable showHiddenBtn 0
+    variable showHiddenVar 1
+
+    # Create the images if they did not already exist.
+    if {![info exists ::tk::Priv(updirImage)]} {
+	set ::tk::Priv(updirImage) [image create photo -data {
+	    iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABmJLR0QA/gD+AP7rGN
+	    SCAAAACXBIWXMAAA3WAAAN1gGQb3mcAAAACXZwQWcAAAAWAAAAFgDcxelYAAAENUlE
+	    QVQ4y7WUbWiVZRjHf/f9POcc9+Kc5bC2aIq5sGG0XnTzNU13zAIlFMNc9CEhTCKwCC
+	    JIgt7AglaR0RcrolAKg14+GBbiGL6xZiYyy63cmzvu7MVznnOe537rw7bDyvlBoT/c
+	    n+6L3/3nf13XLZLJJP+HfICysjKvqqpq+rWKysvLR1tbW+11g+fPn/+bEGIe4KYqCs
+	    Owu66u7oG2trah6wJrrRc0NTVhjME5h7Vj5pxzCCE4duxYZUdHx/aGhoZmgJ+yb+wF
+	    uCO19RmAffv25f8LFslkktraWtvU1CS6u7vRWmOtxVpbAPu+T0tLS04pFU/J34Wd3S
+	    cdFtlfZWeZBU4IcaS5uXn1ZLAEMMY4ay1aa4wx/zpKKYIgoL6+vmjxqoXe5ZLTcsPq
+	    bTyycjODpe1y3WMrvDAMV14jCuW0VhhjiJQpOJ5w7Zwjk8/y9R+vsHHNNq6oFMrkeX
+	    BxI+8d2sktap3YvOPD0lRQrH+Z81fE7t3WB4gihVKazsuaA20aKSUgAG/seQdy2l6W
+	    37+EyopqTv39I6HJUT2zlnlza2jLdgiTaxwmDov6alLHcZUTzXPGGAauWJbfO4dHl9
+	    bgJs3HyfNf0N4ZsOa+jbT3/ownY/hO09p1kBULtjBw+Tvq7xzwauds4dWPDleAcP5E
+	    xlprgtBRUZRgYCRPTzoHwEi2g6OnX+eFrW/RM9qBE4p43CeTz5ATaU6nDrFm2cPs/+
+	    E1SopqkZ7MFJqntXZaa7IKppckwIEvJbg8LWd28OT6nVihCPQQ8UScWCLGqO4hXuQx
+	    qDtJ204eWrqWb1ufRspwtABWaqx5gRKUFSdwDnxPcuLcyyxbuIyaqntIBV34MY9YzC
+	    Owg+S9YeJFkniRpGPkCLMrZzG3+jbktA/KClMxFoUhiKC0OAbAhd79CO8i6xe/STyW
+	    4O7KVRgUJ/sP0heeJV4kEVKw/vZd40sFKxat4mLvp6VLdvnb/XHHGGPIKwBBpC1/9n
+	    3DpfRZnn9/AwCxRII9O79kVPdjvByxuET6Ai8mePeTt4lyheXzhOSpCcdWa00uckTG
+	    kckbGu76nEhbIm2xznH4VB3OWYaiXqQn8GKSWGIMHuXyPL76LBcupmhp69pz4uMnXi
+	    w4VloTGcdQRtGdzmHs1f+RdYZslMZJhzUOHVnceN1ooEiP5JUzdqCQMWCD0JCIeQzn
+	    NNpO+clhrCYf5rC+A2cxWmDUWG2oHEOZMEKIwclgMnnLrTeXUV7sUzpNXgU9DmijWV
+	    v9LEKCkAIhKIBnlvpks6F21qUZ31u/sbExPa9h0/RzwzMov2nGlG5TmW1YOzzlnSfL
+	    mVnyGf19Q7lwZHBp+1fPtflAIgiC7389n9qkihP+lWyeqfUO15ZwQTqlw9H+o2cOvN
+	    QJCAHEgEqgYnI0NyALjAJdyWQy7wMa6AEujUdzo3LjcAXwD/XCTKIRjWytAAAAJXRF
+	    WHRjcmVhdGUtZGF0ZQAyMDA5LTA0LTA2VDIxOjI1OjQxLTAzOjAw8s+uCAAAACV0RV
+	    h0bW9kaWZ5LWRhdGUAMjAwOC0wMS0wM1QxNTowODoyMS0wMjowMJEc/44AAAAZdEVY
+	    dFNvZnR3YXJlAHd3dy5pbmtzY2FwZS5vcmeb7jwaAAAAAElFTkSuQmCC
+	}]
+    }
+    if {![info exists ::tk::Priv(folderImage)]} {
+	set ::tk::Priv(folderImage) [image create photo -data {
+	    iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABHNCSVQICAgIfAhkiA
+	    AAAAlwSFlzAAAN1wAADdcBQiibeAAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBl
+	    Lm9yZ5vuPBoAAAHCSURBVDiNpZAxa5NRFIafc+9XLCni4BC6FBycMnbrLpkcgtDVX6
+	    C70D/g4lZX/4coxLlgxFkpiiSSUGm/JiXfveee45AmNlhawXc53HvPee55X+l2u/yP
+	    qt3d3Tfu/viatwt3fzIYDI5uBJhZr9fr3TMzzAx3B+D09PR+v98/7HQ6z5fNOWdCCG
+	    U4HH6s67oAVDlnV1UmkwmllBUkhMD29nYHeLuEAkyn06qU8qqu64MrgIyqYmZrkHa7
+	    3drc3KTVahFjJITAaDRiPB4/XFlQVVMtHH5IzJo/P4EA4MyB+erWPQB7++zs7ccYvl
+	    U5Z08pMW2cl88eIXLZeDUpXzsBkNQ5eP1+p0opmaoCTgzw6fjs6gLLsp58FB60t0Dc
+	    K1Ul54yIEIMQ43Uj68pquDmCeJVztpwzuBNE2LgBoMVpslHMCUEAFgDVxQbzVAiA+a
+	    K5uGPmmDtZF3VpoUm2ArhqQaRiUjcMf81p1G60UEVhcjZfAFTVUkrgkS+jc06mDX9n
+	    vq4YhJ9nlxZExMwMEaHJRutOdWuIIsJFUoBSuTvHJ4YIfP46unV4qdlsjsBRZRtb/X
+	    fHd5+C8+P7+J8BIoxFwovfRxYhnhxjpzEAAAAASUVORK5CYII=
+	}]
+    }
+    if {![info exists ::tk::Priv(fileImage)]} {
+	set ::tk::Priv(fileImage)   [image create photo -data {
+	    iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QA/wD/AP+gva
+	    eTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH1QQWFA84umAmQgAAANpJREFU
+	    OMutkj1uhDAQhb8HSLtbISGfgZ+zbJkix0HmFhwhUdocBnMBGvqtTIqIFSReWKK8ai
+	    x73nwzHrVt+zEMwwvH9FrX9TsA1trpqKy10+yUzME4jnjvAZB0LzXHkojjmDRNVyh3
+	    A+89zrlVwlKSqKrqVy/J8lAUxSZBSMny4ZLgp54iyPM8UPHGNJ2IomibAKDv+9VlWZ
+	    bABbgB5/0WQgSSkC4PF2JF4JzbHN430c4vhAm0TyCJruuClefph4yCBCGT3T3Isoy/
+	    KDHGfDZNcz2SZIx547/0BVRRX7n8uT/sAAAAAElFTkSuQmCC
+	}]
+    }
+}
+
+# ::tk::dialog::file:: --
+#
+#	Implements the TK file selection dialog.  This dialog is used when the
+#	tk_strictMotif flag is set to false.  This procedure shouldn't be
+#	called directly.  Call tk_getOpenFile or tk_getSaveFile instead.
+#
+# Arguments:
+#	type		"open" or "save"
+#	args		Options parsed by the procedure.
+#
+
+proc ::tk::dialog::file:: {type args} {
+    variable ::tk::Priv
+    variable showHiddenBtn
+    set dataName __tk_filedialog
+    upvar ::tk::dialog::file::$dataName data
+
+    Config $dataName $type $args
+
+    if {$data(-parent) eq "."} {
+	set w .$dataName
+    } else {
+	set w $data(-parent).$dataName
+    }
+
+    # (re)create the dialog box if necessary
+    #
+    if {![winfo exists $w]} {
+	Create $w TkFDialog
+    } elseif {[winfo class $w] ne "TkFDialog"} {
+	destroy $w
+	Create $w TkFDialog
+    } else {
+	set data(dirMenuBtn) $w.contents.f1.menu
+	set data(dirMenu) $w.contents.f1.menu.menu
+	set data(upBtn) $w.contents.f1.up
+	set data(icons) $w.contents.icons
+	set data(ent) $w.contents.f2.ent
+	set data(typeMenuLab) $w.contents.f2.lab2
+	set data(typeMenuBtn) $w.contents.f2.menu
+	set data(typeMenu) $data(typeMenuBtn).m
+	set data(okBtn) $w.contents.f2.ok
+	set data(cancelBtn) $w.contents.f2.cancel
+	set data(hiddenBtn) $w.contents.f2.hidden
+	SetSelectMode $w $data(-multiple)
+    }
+    if {$showHiddenBtn} {
+	$data(hiddenBtn) configure -state normal
+	grid $data(hiddenBtn)
+    } else {
+	$data(hiddenBtn) configure -state disabled
+	grid remove $data(hiddenBtn)
+    }
+
+    # Make sure subseqent uses of this dialog are independent [Bug 845189]
+    unset -nocomplain data(extUsed)
+
+    # Dialog boxes should be transient with respect to their parent, so that
+    # they will always stay on top of their parent window.  However, some
+    # window managers will create the window as withdrawn if the parent window
+    # is withdrawn or iconified.  Combined with the grab we put on the window,
+    # this can hang the entire application.  Therefore we only make the dialog
+    # transient if the parent is viewable.
+
+    if {[winfo viewable [winfo toplevel $data(-parent)]]} {
+	wm transient $w $data(-parent)
+    }
+
+    # Add traces on the selectPath variable
+    #
+
+    trace add variable data(selectPath) write \
+	    [list ::tk::dialog::file::SetPath $w]
+    $data(dirMenuBtn) configure \
+	    -textvariable ::tk::dialog::file::${dataName}(selectPath)
+
+    # Cleanup previous menu
+    #
+    $data(typeMenu) delete 0 end
+    $data(typeMenuBtn) configure -state normal -text ""
+
+    # Initialize the file types menu
+    #
+    if {[llength $data(-filetypes)]} {
+	# Default type and name to first entry
+	set initialtype     [lindex $data(-filetypes) 0]
+	set initialTypeName [lindex $initialtype 0]
+	if {$data(-typevariable) ne ""} {
+	    upvar #0 $data(-typevariable) typeVariable
+	    if {[info exists typeVariable]} {
+		set initialTypeName $typeVariable
+	    }
+	}
+	foreach type $data(-filetypes) {
+	    set title  [lindex $type 0]
+	    set filter [lindex $type 1]
+	    $data(typeMenu) add command -label $title \
+		-command [list ::tk::dialog::file::SetFilter $w $type]
+	    # [string first] avoids glob-pattern char issues
+	    if {[string first ${initialTypeName} $title] == 0} {
+		set initialtype $type
+	    }
+	}
+	SetFilter $w $initialtype
+	$data(typeMenuBtn) configure -state normal
+	$data(typeMenuLab) configure -state normal
+    } else {
+	set data(filter) "*"
+	$data(typeMenuBtn) configure -state disabled -takefocus 0
+	$data(typeMenuLab) configure -state disabled
+    }
+    UpdateWhenIdle $w
+
+    # Withdraw the window, then update all the geometry information
+    # so we know how big it wants to be, then center the window in the
+    # display (Motif style) and de-iconify it.
+
+    ::tk::PlaceWindow $w widget $data(-parent)
+    wm title $w $data(-title)
+
+    # Set a grab and claim the focus too.
+
+    ::tk::SetFocusGrab $w $data(ent)
+    $data(ent) delete 0 end
+    $data(ent) insert 0 $data(selectFile)
+    $data(ent) selection range 0 end
+    $data(ent) icursor end
+
+    # Wait for the user to respond, then restore the focus and return the
+    # index of the selected button.  Restore the focus before deleting the
+    # window, since otherwise the window manager may take the focus away so we
+    # can't redirect it.  Finally, restore any grab that was in effect.
+
+    vwait ::tk::Priv(selectFilePath)
+
+    ::tk::RestoreFocusGrab $w $data(ent) withdraw
+
+    # Cleanup traces on selectPath variable
+    #
+
+    foreach trace [trace info variable data(selectPath)] {
+	trace remove variable data(selectPath) {*}$trace
+    }
+    if {[winfo exists $data(dirMenuBtn)]} {
+	$data(dirMenuBtn) configure -textvariable {}
+    }
+
+    return $Priv(selectFilePath)
+}
+
+# ::tk::dialog::file::Config --
+#
+#	Configures the TK filedialog according to the argument list
+#
+proc ::tk::dialog::file::Config {dataName type argList} {
+    upvar ::tk::dialog::file::$dataName data
+
+    set data(type) $type
+
+    # 0: Delete all variable that were set on data(selectPath) the
+    # last time the file dialog is used. The traces may cause troubles
+    # if the dialog is now used with a different -parent option.
+
+    foreach trace [trace info variable data(selectPath)] {
+	trace remove variable data(selectPath) {*}$trace
+    }
+
+    # 1: the configuration specs
+    #
+    set specs {
+	{-defaultextension "" "" ""}
+	{-filetypes "" "" ""}
+	{-initialdir "" "" ""}
+	{-initialfile "" "" ""}
+	{-parent "" "" "."}
+	{-title "" "" ""}
+	{-typevariable "" "" ""}
+    }
+
+    # The "-multiple" option is only available for the "open" file dialog.
+    #
+    if {$type eq "open"} {
+	lappend specs {-multiple "" "" "0"}
+    }
+
+    # The "-confirmoverwrite" option is only for the "save" file dialog.
+    #
+    if {$type eq "save"} {
+	lappend specs {-confirmoverwrite "" "" "1"}
+    }
+
+    # 2: default values depending on the type of the dialog
+    #
+    if {![info exists data(selectPath)]} {
+	# first time the dialog has been popped up
+	set data(selectPath) [pwd]
+	set data(selectFile) ""
+    }
+
+    # 3: parse the arguments
+    #
+    tclParseConfigSpec ::tk::dialog::file::$dataName $specs "" $argList
+
+    if {$data(-title) eq ""} {
+	if {$type eq "open"} {
+	    set data(-title) [mc "Open"]
+	} else {
+	    set data(-title) [mc "Save As"]
+	}
+    }
+
+    # 4: set the default directory and selection according to the -initial
+    #    settings
+    #
+    if {$data(-initialdir) ne ""} {
+	# Ensure that initialdir is an absolute path name.
+	if {[file isdirectory $data(-initialdir)]} {
+	    set old [pwd]
+	    cd $data(-initialdir)
+	    set data(selectPath) [pwd]
+	    cd $old
+	} else {
+	    set data(selectPath) [pwd]
+	}
+    }
+    set data(selectFile) $data(-initialfile)
+
+    # 5. Parse the -filetypes option
+    #
+    set data(origfiletypes) $data(-filetypes)
+    set data(-filetypes) [::tk::FDGetFileTypes $data(-filetypes)]
+
+    if {![winfo exists $data(-parent)]} {
+	return -code error -errorcode [list TK LOOKUP WINDOW $data(-parent)] \
+	    "bad window path name \"$data(-parent)\""
+    }
+
+    # Set -multiple to a one or zero value (not other boolean types like
+    # "yes") so we can use it in tests more easily.
+    if {$type eq "save"} {
+	set data(-multiple) 0
+    } elseif {$data(-multiple)} {
+	set data(-multiple) 1
+    } else {
+	set data(-multiple) 0
+    }
+}
+
+proc ::tk::dialog::file::Create {w class} {
+    set dataName [lindex [split $w .] end]
+    upvar ::tk::dialog::file::$dataName data
+    variable ::tk::Priv
+    global tk_library
+
+    toplevel $w -class $class
+    if {[tk windowingsystem] eq "x11"} {wm attributes $w -type dialog}
+    pack [ttk::frame $w.contents] -expand 1 -fill both
+    #set w $w.contents
+
+    # f1: the frame with the directory option menu
+    #
+    set f1 [ttk::frame $w.contents.f1]
+    bind [::tk::AmpWidget ttk::label $f1.lab -text [mc "&Directory:"]] \
+	    <<AltUnderlined>> [list focus $f1.menu]
+
+    set data(dirMenuBtn) $f1.menu
+    if {![info exists data(selectPath)]} {
+	set data(selectPath) ""
+    }
+    set data(dirMenu) $f1.menu.menu
+    ttk::menubutton $f1.menu -menu $data(dirMenu) -direction flush \
+	    -textvariable [format %s(selectPath) ::tk::dialog::file::$dataName]
+    menu $data(dirMenu) -tearoff 0
+    $data(dirMenu) add radiobutton -label "" -variable \
+	    [format %s(selectPath) ::tk::dialog::file::$dataName]
+    set data(upBtn) [ttk::button $f1.up]
+    $data(upBtn) configure -image $Priv(updirImage)
+
+    $f1.menu configure -takefocus 1;# -highlightthickness 2
+
+    pack $data(upBtn) -side right -padx 4 -fill both
+    pack $f1.lab -side left -padx 4 -fill both
+    pack $f1.menu -expand yes -fill both -padx 4
+
+    # data(icons): the IconList that list the files and directories.
+    #
+    if {$class eq "TkFDialog"} {
+	if { $data(-multiple) } {
+	    set fNameCaption [mc "File &names:"]
+	} else {
+	    set fNameCaption [mc "File &name:"]
+	}
+	set fTypeCaption [mc "Files of &type:"]
+	set iconListCommand [list ::tk::dialog::file::OkCmd $w]
+    } else {
+	set fNameCaption [mc "&Selection:"]
+	set iconListCommand [list ::tk::dialog::file::chooseDir::DblClick $w]
+    }
+    set data(icons) [::tk::IconList $w.contents.icons \
+	    -command $iconListCommand -multiple $data(-multiple)]
+    bind $data(icons) <<ListboxSelect>> \
+	    [list ::tk::dialog::file::ListBrowse $w]
+
+    # f2: the frame with the OK button, cancel button, "file name" field
+    #     and file types field.
+    #
+    set f2 [ttk::frame $w.contents.f2]
+    bind [::tk::AmpWidget ttk::label $f2.lab -text $fNameCaption -anchor e]\
+	    <<AltUnderlined>> [list focus $f2.ent]
+    # -pady 0
+    set data(ent) [ttk::entry $f2.ent]
+
+    # The font to use for the icons. The default Canvas font on Unix is just
+    # deviant.
+    set ::tk::$w.contents.icons(font) [$data(ent) cget -font]
+
+    # Make the file types bits only if this is a File Dialog
+    if {$class eq "TkFDialog"} {
+	set data(typeMenuLab) [::tk::AmpWidget ttk::label $f2.lab2 \
+		-text $fTypeCaption -anchor e]
+	# -pady [$f2.lab cget -pady]
+	set data(typeMenuBtn) [ttk::menubutton $f2.menu \
+		-menu $f2.menu.m]
+	# -indicatoron 1
+	set data(typeMenu) [menu $data(typeMenuBtn).m -tearoff 0]
+	# $data(typeMenuBtn) configure -takefocus 1 -relief raised -anchor w
+	bind $data(typeMenuLab) <<AltUnderlined>> [list \
+		focus $data(typeMenuBtn)]
+    }
+
+    # The hidden button is displayed when ::tk::dialog::file::showHiddenBtn is
+    # true.  Create it disabled so the binding doesn't trigger if it isn't
+    # shown.
+    if {$class eq "TkFDialog"} {
+	set text [mc "Show &Hidden Files and Directories"]
+    } else {
+	set text [mc "Show &Hidden Directories"]
+    }
+    set data(hiddenBtn) [::tk::AmpWidget ttk::checkbutton $f2.hidden \
+	    -text $text -state disabled \
+	    -variable ::tk::dialog::file::showHiddenVar \
+	    -command [list ::tk::dialog::file::UpdateWhenIdle $w]]
+# -anchor w -padx 3
+
+    # the okBtn is created after the typeMenu so that the keyboard traversal
+    # is in the right order, and add binding so that we find out when the
+    # dialog is destroyed by the user (added here instead of to the overall
+    # window so no confusion about how much <Destroy> gets called; exactly
+    # once will do). [Bug 987169]
+
+    set data(okBtn)     [::tk::AmpWidget ttk::button $f2.ok \
+	    -text [mc "&OK"]     -default active];# -pady 3]
+    bind $data(okBtn) <Destroy> [list ::tk::dialog::file::Destroyed $w]
+    set data(cancelBtn) [::tk::AmpWidget ttk::button $f2.cancel \
+	    -text [mc "&Cancel"] -default normal];# -pady 3]
+
+    # grid the widgets in f2
+    #
+    grid $f2.lab $f2.ent $data(okBtn) -padx 4 -pady 3 -sticky ew
+    grid configure $f2.ent -padx 2
+    if {$class eq "TkFDialog"} {
+	grid $data(typeMenuLab) $data(typeMenuBtn) $data(cancelBtn) \
+		-padx 4 -sticky ew
+	grid configure $data(typeMenuBtn) -padx 0
+	grid $data(hiddenBtn) -columnspan 2 -padx 4 -sticky ew
+    } else {
+	grid $data(hiddenBtn) - $data(cancelBtn) -padx 4 -sticky ew
+    }
+    grid columnconfigure $f2 1 -weight 1
+
+    # Pack all the frames together. We are done with widget construction.
+    #
+    pack $f1 -side top -fill x -pady 4
+    pack $f2 -side bottom -pady 4 -fill x
+    pack $data(icons) -expand yes -fill both -padx 4 -pady 1
+
+    # Set up the event handlers that are common to Directory and File Dialogs
+    #
+
+    wm protocol $w WM_DELETE_WINDOW [list ::tk::dialog::file::CancelCmd $w]
+    $data(upBtn)     configure -command [list ::tk::dialog::file::UpDirCmd $w]
+    $data(cancelBtn) configure -command [list ::tk::dialog::file::CancelCmd $w]
+    bind $w <Escape> [list $data(cancelBtn) invoke]
+    bind $w <Alt-Key> [list tk::AltKeyInDialog $w %A]
+
+    # Set up event handlers specific to File or Directory Dialogs
+    #
+    if {$class eq "TkFDialog"} {
+	bind $data(ent) <Return> [list ::tk::dialog::file::ActivateEnt $w]
+	$data(okBtn)     configure -command [list ::tk::dialog::file::OkCmd $w]
+	bind $w <Alt-t> [format {
+	    if {[%s cget -state] eq "normal"} {
+		focus %s
+	    }
+	} $data(typeMenuBtn) $data(typeMenuBtn)]
+    } else {
+	set okCmd [list ::tk::dialog::file::chooseDir::OkCmd $w]
+	bind $data(ent) <Return> $okCmd
+	$data(okBtn) configure -command $okCmd
+	bind $w <Alt-s> [list focus $data(ent)]
+	bind $w <Alt-o> [list $data(okBtn) invoke]
+    }
+    bind $w <Alt-h> [list $data(hiddenBtn) invoke]
+    bind $data(ent) <Tab> [list ::tk::dialog::file::CompleteEnt $w]
+
+    # Build the focus group for all the entries
+    #
+    ::tk::FocusGroup_Create $w
+    ::tk::FocusGroup_BindIn $w  $data(ent) [list \
+	    ::tk::dialog::file::EntFocusIn $w]
+    ::tk::FocusGroup_BindOut $w $data(ent) [list \
+	    ::tk::dialog::file::EntFocusOut $w]
+}
+
+# ::tk::dialog::file::SetSelectMode --
+#
+#	Set the select mode of the dialog to single select or multi-select.
+#
+# Arguments:
+#	w		The dialog path.
+#	multi		1 if the dialog is multi-select; 0 otherwise.
+#
+# Results:
+#	None.
+
+proc ::tk::dialog::file::SetSelectMode {w multi} {
+    set dataName __tk_filedialog
+    upvar ::tk::dialog::file::$dataName data
+    if { $multi } {
+	set fNameCaption [mc "File &names:"]
+    } else {
+	set fNameCaption [mc "File &name:"]
+    }
+    set iconListCommand [list ::tk::dialog::file::OkCmd $w]
+    ::tk::SetAmpText $w.contents.f2.lab $fNameCaption
+    $data(icons) configure -multiple $multi -command $iconListCommand
+    return
+}
+
+# ::tk::dialog::file::UpdateWhenIdle --
+#
+#	Creates an idle event handler which updates the dialog in idle time.
+#	This is important because loading the directory may take a long time
+#	and we don't want to load the same directory for multiple times due to
+#	multiple concurrent events.
+#
+proc ::tk::dialog::file::UpdateWhenIdle {w} {
+    upvar ::tk::dialog::file::[winfo name $w] data
+
+    if {[info exists data(updateId)]} {
+	return
+    }
+    set data(updateId) [after idle [list ::tk::dialog::file::Update $w]]
+}
+
+# ::tk::dialog::file::Update --
+#
+#	Loads the files and directories into the IconList widget. Also sets up
+#	the directory option menu for quick access to parent directories.
+#
+proc ::tk::dialog::file::Update {w} {
+    # This proc may be called within an idle handler. Make sure that the
+    # window has not been destroyed before this proc is called
+    if {![winfo exists $w]} {
+	return
+    }
+    set class [winfo class $w]
+    if {($class ne "TkFDialog") && ($class ne "TkChooseDir")} {
+	return
+    }
+
+    set dataName [winfo name $w]
+    upvar ::tk::dialog::file::$dataName data
+    variable ::tk::Priv
+    variable showHiddenVar
+    global tk_library
+    unset -nocomplain data(updateId)
+
+    set folder $Priv(folderImage)
+    set file   $Priv(fileImage)
+
+    set appPWD [pwd]
+    if {[catch {
+	cd $data(selectPath)
+    }]} then {
+	# We cannot change directory to $data(selectPath). $data(selectPath)
+	# should have been checked before ::tk::dialog::file::Update is
+	# called, so we normally won't come to here. Anyways, give an error
+	# and abort action.
+	tk_messageBox -type ok -parent $w -icon warning -message [mc \
+	       "Cannot change to the directory \"%1\$s\".\nPermission denied."\
+		$data(selectPath)]
+	cd $appPWD
+	return
+    }
+
+    # Turn on the busy cursor. BUG?? We haven't disabled X events, though,
+    # so the user may still click and cause havoc ...
+    #
+    set entCursor [$data(ent) cget -cursor]
+    set dlgCursor [$w cget -cursor]
+    $data(ent) configure -cursor watch
+    $w configure -cursor watch
+    update idletasks
+
+    $data(icons) deleteall
+
+    set showHidden $showHiddenVar
+
+    # Make the dir list. Note that using an explicit [pwd] (instead of '.') is
+    # better in some VFS cases.
+    $data(icons) add $folder [GlobFiltered [pwd] d 1]
+
+    if {$class eq "TkFDialog"} {
+	# Make the file list if this is a File Dialog, selecting all but
+	# 'd'irectory type files.
+	#
+	$data(icons) add $file [GlobFiltered [pwd] {f b c l p s}]
+    }
+
+    # Update the Directory: option menu
+    #
+    set list ""
+    set dir ""
+    foreach subdir [file split $data(selectPath)] {
+	set dir [file join $dir $subdir]
+	lappend list $dir
+    }
+
+    $data(dirMenu) delete 0 end
+    set var [format %s(selectPath) ::tk::dialog::file::$dataName]
+    foreach path $list {
+	$data(dirMenu) add command -label $path -command [list set $var $path]
+    }
+
+    # Restore the PWD to the application's PWD
+    #
+    cd $appPWD
+
+    if {$class eq "TkFDialog"} {
+	# Restore the Open/Save Button if this is a File Dialog
+	#
+	if {$data(type) eq "open"} {
+	    ::tk::SetAmpText $data(okBtn) [mc "&Open"]
+	} else {
+	    ::tk::SetAmpText $data(okBtn) [mc "&Save"]
+	}
+    }
+
+    # turn off the busy cursor.
+    #
+    $data(ent) configure -cursor $entCursor
+    $w configure -cursor $dlgCursor
+}
+
+# ::tk::dialog::file::SetPathSilently --
+#
+# 	Sets data(selectPath) without invoking the trace procedure
+#
+proc ::tk::dialog::file::SetPathSilently {w path} {
+    upvar ::tk::dialog::file::[winfo name $w] data
+
+    set cb [list ::tk::dialog::file::SetPath $w]
+    trace remove variable data(selectPath) write $cb
+    set data(selectPath) $path
+    trace add variable data(selectPath) write $cb
+}
+
+
+# This proc gets called whenever data(selectPath) is set
+#
+proc ::tk::dialog::file::SetPath {w name1 name2 op} {
+    if {[winfo exists $w]} {
+	upvar ::tk::dialog::file::[winfo name $w] data
+	UpdateWhenIdle $w
+	# On directory dialogs, we keep the entry in sync with the currentdir.
+	if {[winfo class $w] eq "TkChooseDir"} {
+	    $data(ent) delete 0 end
+	    $data(ent) insert end $data(selectPath)
+	}
+    }
+}
+
+# This proc gets called whenever data(filter) is set
+#
+proc ::tk::dialog::file::SetFilter {w type} {
+    upvar ::tk::dialog::file::[winfo name $w] data
+
+    set data(filterType) $type
+    set data(filter) [lindex $type 1]
+    $data(typeMenuBtn) configure -text [lindex $type 0] ;#-indicatoron 1
+
+    # If we aren't using a default extension, use the one suppled by the
+    # filter.
+    if {![info exists data(extUsed)]} {
+	if {[string length $data(-defaultextension)]} {
+	    set data(extUsed) 1
+	} else {
+	    set data(extUsed) 0
+	}
+    }
+
+    if {!$data(extUsed)} {
+	# Get the first extension in the list that matches {^\*\.\w+$} and
+	# remove all * from the filter.
+	set index [lsearch -regexp $data(filter) {^\*\.\w+$}]
+	if {$index >= 0} {
+	    set data(-defaultextension) \
+		    [string trimleft [lindex $data(filter) $index] "*"]
+	} else {
+	    # Couldn't find anything!  Reset to a safe default...
+	    set data(-defaultextension) ""
+	}
+    }
+
+    $data(icons) see 0
+
+    UpdateWhenIdle $w
+}
+
+# tk::dialog::file::ResolveFile --
+#
+#	Interpret the user's text input in a file selection dialog.  Performs:
+#
+#	(1) ~ substitution
+#	(2) resolve all instances of . and ..
+#	(3) check for non-existent files/directories
+#	(4) check for chdir permissions
+#	(5) conversion of environment variable references to their
+#	    contents (once only)
+#
+# Arguments:
+#	context:  the current directory you are in
+#	text:	  the text entered by the user
+#	defaultext: the default extension to add to files with no extension
+#	expandEnv: whether to expand environment variables (yes by default)
+#
+# Return vaue:
+#	[list $flag $directory $file]
+#
+#	 flag = OK	: valid input
+#	      = PATTERN	: valid directory/pattern
+#	      = PATH	: the directory does not exist
+#	      = FILE	: the directory exists by the file doesn't exist
+#	      = CHDIR	: Cannot change to the directory
+#	      = ERROR	: Invalid entry
+#
+#	 directory      : valid only if flag = OK or PATTERN or FILE
+#	 file           : valid only if flag = OK or PATTERN
+#
+#	directory may not be the same as context, because text may contain a
+#	subdirectory name
+#
+proc ::tk::dialog::file::ResolveFile {context text defaultext {expandEnv 1}} {
+    set appPWD [pwd]
+
+    set path [JoinFile $context $text]
+
+    # If the file has no extension, append the default.  Be careful not to do
+    # this for directories, otherwise typing a dirname in the box will give
+    # back "dirname.extension" instead of trying to change dir.
+    if {
+	![file isdirectory $path] && ([file ext $path] eq "") &&
+	![string match {$*} [file tail $path]]
+    } then {
+	set path "$path$defaultext"
+    }
+
+    if {[catch {file exists $path}]} {
+	# This "if" block can be safely removed if the following code stop
+	# generating errors.
+	#
+	#	file exists ~nonsuchuser
+	#
+	return [list ERROR $path ""]
+    }
+
+    if {[file exists $path]} {
+	if {[file isdirectory $path]} {
+	    if {[catch {cd $path}]} {
+		return [list CHDIR $path ""]
+	    }
+	    set directory [pwd]
+	    set file ""
+	    set flag OK
+	    cd $appPWD
+	} else {
+	    if {[catch {cd [file dirname $path]}]} {
+		return [list CHDIR [file dirname $path] ""]
+	    }
+	    set directory [pwd]
+	    set file [file tail $path]
+	    set flag OK
+	    cd $appPWD
+	}
+    } else {
+	set dirname [file dirname $path]
+	if {[file exists $dirname]} {
+	    if {[catch {cd $dirname}]} {
+		return [list CHDIR $dirname ""]
+	    }
+	    set directory [pwd]
+	    cd $appPWD
+	    set file [file tail $path]
+	    # It's nothing else, so check to see if it is an env-reference
+	    if {$expandEnv && [string match {$*} $file]} {
+		set var [string range $file 1 end]
+		if {[info exist ::env($var)]} {
+		    return [ResolveFile $context $::env($var) $defaultext 0]
+		}
+	    }
+	    if {[regexp {[*?]} $file]} {
+		set flag PATTERN
+	    } else {
+		set flag FILE
+	    }
+	} else {
+	    set directory $dirname
+	    set file [file tail $path]
+	    set flag PATH
+	    # It's nothing else, so check to see if it is an env-reference
+	    if {$expandEnv && [string match {$*} $file]} {
+		set var [string range $file 1 end]
+		if {[info exist ::env($var)]} {
+		    return [ResolveFile $context $::env($var) $defaultext 0]
+		}
+	    }
+	}
+    }
+
+    return [list $flag $directory $file]
+}
+
+
+# Gets called when the entry box gets keyboard focus. We clear the selection
+# from the icon list . This way the user can be certain that the input in the
+# entry box is the selection.
+#
+proc ::tk::dialog::file::EntFocusIn {w} {
+    upvar ::tk::dialog::file::[winfo name $w] data
+
+    if {[$data(ent) get] ne ""} {
+	$data(ent) selection range 0 end
+	$data(ent) icursor end
+    } else {
+	$data(ent) selection clear
+    }
+
+    if {[winfo class $w] eq "TkFDialog"} {
+	# If this is a File Dialog, make sure the buttons are labeled right.
+	if {$data(type) eq "open"} {
+	    ::tk::SetAmpText $data(okBtn) [mc "&Open"]
+	} else {
+	    ::tk::SetAmpText $data(okBtn) [mc "&Save"]
+	}
+    }
+}
+
+proc ::tk::dialog::file::EntFocusOut {w} {
+    upvar ::tk::dialog::file::[winfo name $w] data
+
+    $data(ent) selection clear
+}
+
+
+# Gets called when user presses Return in the "File name" entry.
+#
+proc ::tk::dialog::file::ActivateEnt {w} {
+    upvar ::tk::dialog::file::[winfo name $w] data
+
+    set text [$data(ent) get]
+    if {$data(-multiple)} {
+	foreach t $text {
+	    VerifyFileName $w $t
+	}
+    } else {
+	VerifyFileName $w $text
+    }
+}
+
+# Verification procedure
+#
+proc ::tk::dialog::file::VerifyFileName {w filename} {
+    upvar ::tk::dialog::file::[winfo name $w] data
+
+    set list [ResolveFile $data(selectPath) $filename $data(-defaultextension)]
+    foreach {flag path file} $list {
+	break
+    }
+
+    switch -- $flag {
+	OK {
+	    if {$file eq ""} {
+		# user has entered an existing (sub)directory
+		set data(selectPath) $path
+		$data(ent) delete 0 end
+	    } else {
+		SetPathSilently $w $path
+		if {$data(-multiple)} {
+		    lappend data(selectFile) $file
+		} else {
+		    set data(selectFile) $file
+		}
+		Done $w
+	    }
+	}
+	PATTERN {
+	    set data(selectPath) $path
+	    set data(filter) $file
+	}
+	FILE {
+	    if {$data(type) eq "open"} {
+		tk_messageBox -icon warning -type ok -parent $w \
+			-message [mc "File \"%1\$s\"  does not exist." \
+			[file join $path $file]]
+		$data(ent) selection range 0 end
+		$data(ent) icursor end
+	    } else {
+		SetPathSilently $w $path
+		if {$data(-multiple)} {
+		    lappend data(selectFile) $file
+		} else {
+		    set data(selectFile) $file
+		}
+		Done $w
+	    }
+	}
+	PATH {
+	    tk_messageBox -icon warning -type ok -parent $w -message \
+		    [mc "Directory \"%1\$s\" does not exist." $path]
+	    $data(ent) selection range 0 end
+	    $data(ent) icursor end
+	}
+	CHDIR {
+	    tk_messageBox -type ok -parent $w -icon warning -message  \
+		    [mc "Cannot change to the directory\
+			\"%1\$s\".\nPermission denied." $path]
+	    $data(ent) selection range 0 end
+	    $data(ent) icursor end
+	}
+	ERROR {
+	    tk_messageBox -type ok -parent $w -icon warning -message \
+		    [mc "Invalid file name \"%1\$s\"." $path]
+	    $data(ent) selection range 0 end
+	    $data(ent) icursor end
+	}
+    }
+}
+
+# Gets called when user presses the Alt-s or Alt-o keys.
+#
+proc ::tk::dialog::file::InvokeBtn {w key} {
+    upvar ::tk::dialog::file::[winfo name $w] data
+
+    if {[$data(okBtn) cget -text] eq $key} {
+	$data(okBtn) invoke
+    }
+}
+
+# Gets called when user presses the "parent directory" button
+#
+proc ::tk::dialog::file::UpDirCmd {w} {
+    upvar ::tk::dialog::file::[winfo name $w] data
+
+    if {$data(selectPath) ne "/"} {
+	set data(selectPath) [file dirname $data(selectPath)]
+    }
+}
+
+# Join a file name to a path name. The "file join" command will break if the
+# filename begins with ~
+#
+proc ::tk::dialog::file::JoinFile {path file} {
+    if {[string match {~*} $file] && [file exists $path/$file]} {
+	return [file join $path ./$file]
+    } else {
+	return [file join $path $file]
+    }
+}
+
+# Gets called when user presses the "OK" button
+#
+proc ::tk::dialog::file::OkCmd {w} {
+    upvar ::tk::dialog::file::[winfo name $w] data
+
+    set filenames {}
+    foreach item [$data(icons) selection get] {
+	lappend filenames [$data(icons) get $item]
+    }
+
+    if {
+	([llength $filenames] && !$data(-multiple)) ||
+	($data(-multiple) && ([llength $filenames] == 1))
+    } then {
+	set filename [lindex $filenames 0]
+	set file [JoinFile $data(selectPath) $filename]
+	if {[file isdirectory $file]} {
+	    ListInvoke $w [list $filename]
+	    return
+	}
+    }
+
+    ActivateEnt $w
+}
+
+# Gets called when user presses the "Cancel" button
+#
+proc ::tk::dialog::file::CancelCmd {w} {
+    upvar ::tk::dialog::file::[winfo name $w] data
+    variable ::tk::Priv
+
+    bind $data(okBtn) <Destroy> {}
+    set Priv(selectFilePath) ""
+}
+
+# Gets called when user destroys the dialog directly [Bug 987169]
+#
+proc ::tk::dialog::file::Destroyed {w} {
+    upvar ::tk::dialog::file::[winfo name $w] data
+    variable ::tk::Priv
+
+    set Priv(selectFilePath) ""
+}
+
+# Gets called when user browses the IconList widget (dragging mouse, arrow
+# keys, etc)
+#
+proc ::tk::dialog::file::ListBrowse {w} {
+    upvar ::tk::dialog::file::[winfo name $w] data
+
+    set text {}
+    foreach item [$data(icons) selection get] {
+	lappend text [$data(icons) get $item]
+    }
+    if {[llength $text] == 0} {
+	return
+    }
+    if {$data(-multiple)} {
+	set newtext {}
+	foreach file $text {
+	    set fullfile [JoinFile $data(selectPath) $file]
+	    if { ![file isdirectory $fullfile] } {
+		lappend newtext $file
+	    }
+	}
+	set text $newtext
+	set isDir 0
+    } else {
+	set text [lindex $text 0]
+	set file [JoinFile $data(selectPath) $text]
+	set isDir [file isdirectory $file]
+    }
+    if {!$isDir} {
+	$data(ent) delete 0 end
+	$data(ent) insert 0 $text
+
+	if {[winfo class $w] eq "TkFDialog"} {
+	    if {$data(type) eq "open"} {
+		::tk::SetAmpText $data(okBtn) [mc "&Open"]
+	    } else {
+		::tk::SetAmpText $data(okBtn) [mc "&Save"]
+	    }
+	}
+    } elseif {[winfo class $w] eq "TkFDialog"} {
+	::tk::SetAmpText $data(okBtn) [mc "&Open"]
+    }
+}
+
+# Gets called when user invokes the IconList widget (double-click, Return key,
+# etc)
+#
+proc ::tk::dialog::file::ListInvoke {w filenames} {
+    upvar ::tk::dialog::file::[winfo name $w] data
+
+    if {[llength $filenames] == 0} {
+	return
+    }
+
+    set file [JoinFile $data(selectPath) [lindex $filenames 0]]
+
+    set class [winfo class $w]
+    if {$class eq "TkChooseDir" || [file isdirectory $file]} {
+	set appPWD [pwd]
+	if {[catch {cd $file}]} {
+	    tk_messageBox -type ok -parent $w -icon warning -message \
+		    [mc "Cannot change to the directory \"%1\$s\".\nPermission denied." $file]
+	} else {
+	    cd $appPWD
+	    set data(selectPath) $file
+	}
+    } else {
+	if {$data(-multiple)} {
+	    set data(selectFile) $filenames
+	} else {
+	    set data(selectFile) $file
+	}
+	Done $w
+    }
+}
+
+# ::tk::dialog::file::Done --
+#
+#	Gets called when user has input a valid filename.  Pops up a dialog
+#	box to confirm selection when necessary.  Sets the
+#	tk::Priv(selectFilePath) variable, which will break the "vwait" loop
+#	in ::tk::dialog::file:: and return the selected filename to the script
+#	that calls tk_getOpenFile or tk_getSaveFile
+#
+proc ::tk::dialog::file::Done {w {selectFilePath ""}} {
+    upvar ::tk::dialog::file::[winfo name $w] data
+    variable ::tk::Priv
+
+    if {$selectFilePath eq ""} {
+	if {$data(-multiple)} {
+	    set selectFilePath {}
+	    foreach f $data(selectFile) {
+		lappend selectFilePath [JoinFile $data(selectPath) $f]
+	    }
+	} else {
+	    set selectFilePath [JoinFile $data(selectPath) $data(selectFile)]
+	}
+
+	set Priv(selectFile) $data(selectFile)
+	set Priv(selectPath) $data(selectPath)
+
+	if {($data(type) eq "save") && $data(-confirmoverwrite) && [file exists $selectFilePath]} {
+	    set reply [tk_messageBox -icon warning -type yesno -parent $w \
+		    -message [mc "File \"%1\$s\" already exists.\nDo you want\
+		    to overwrite it?" $selectFilePath]]
+	    if {$reply eq "no"} {
+		return
+	    }
+	}
+	if {
+	    [info exists data(-typevariable)] && $data(-typevariable) ne ""
+	    && [info exists data(-filetypes)] && [llength $data(-filetypes)]
+	    && [info exists data(filterType)] && $data(filterType) ne ""
+	} then {
+	    upvar #0 $data(-typevariable) typeVariable
+	    set typeVariable [lindex $data(origfiletypes) \
+		    [lsearch -exact $data(-filetypes) $data(filterType)] 0]
+	}
+    }
+    bind $data(okBtn) <Destroy> {}
+    set Priv(selectFilePath) $selectFilePath
+}
+
+# ::tk::dialog::file::GlobFiltered --
+#
+#	Gets called to do globbing, returning the results and filtering them
+#	according to the current filter (and removing the entries for '.' and
+#	'..' which are never shown). Deals with evil cases such as where the
+#	user is supplying a filter which is an invalid list or where it has an
+#	unbalanced brace. The resulting list will be dictionary sorted.
+#
+#	Arguments:
+#	  dir		 Which directory to search
+#	  type		 List of filetypes to look for ('d' or 'f b c l p s')
+#	  overrideFilter Whether to ignore the filter for this search.
+#
+#	NB: Assumes that the caller has mapped the state variable to 'data'.
+#
+proc ::tk::dialog::file::GlobFiltered {dir type {overrideFilter 0}} {
+    variable showHiddenVar
+    upvar 1 data(filter) filter
+
+    if {$filter eq "*" || $overrideFilter} {
+	set patterns [list *]
+	if {$showHiddenVar} {
+	    lappend patterns .*
+	}
+    } elseif {[string is list $filter]} {
+	set patterns $filter
+    } else {
+	# Invalid list; assume we can use non-whitespace sequences as words
+	set patterns [regexp -inline -all {\S+} $filter]
+    }
+
+    set opts [list -tails -directory $dir -type $type -nocomplain]
+
+    set result {}
+    catch {
+	# We have a catch because we might have a really bad pattern (e.g.,
+	# with an unbalanced brace); even [glob -nocomplain] doesn't like it.
+	# Using a catch ensures that it just means we match nothing instead of
+	# throwing a nasty error at the user...
+	foreach f [glob {*}$opts -- {*}$patterns] {
+	    if {$f eq "." || $f eq ".."} {
+		continue
+	    }
+	    # See ticket [1641721], $f might be a link pointing to a dir
+	    if {$type != "d" && [file isdir [file join $dir $f]]} {
+		continue
+	    }
+	    lappend result $f
+	}
+    }
+    return [lsort -dictionary -unique $result]
+}
+
+proc ::tk::dialog::file::CompleteEnt {w} {
+    upvar ::tk::dialog::file::[winfo name $w] data
+    set f [$data(ent) get]
+    if {$data(-multiple)} {
+	if {![string is list $f] || [llength $f] != 1} {
+	    return -code break
+	}
+	set f [lindex $f 0]
+    }
+
+    # Get list of matching filenames and dirnames
+    set files [if {[winfo class $w] eq "TkFDialog"} {
+	GlobFiltered $data(selectPath) {f b c l p s}
+    }]
+    set dirs2 {}
+    foreach d [GlobFiltered $data(selectPath) d] {lappend dirs2 $d/}
+
+    set targets [concat \
+	    [lsearch -glob -all -inline $files $f*] \
+	    [lsearch -glob -all -inline $dirs2 $f*]]
+
+    if {[llength $targets] == 1} {
+	# We have a winner!
+	set f [lindex $targets 0]
+    } elseif {$f in $targets || [llength $targets] == 0} {
+	if {[string length $f] > 0} {
+	    bell
+	}
+	return
+    } elseif {[llength $targets] > 1} {
+	# Multiple possibles
+	if {[string length $f] == 0} {
+	    return
+	}
+	set t0 [lindex $targets 0]
+	for {set len [string length $t0]} {$len>0} {} {
+	    set allmatch 1
+	    foreach s $targets {
+		if {![string equal -length $len $s $t0]} {
+		    set allmatch 0
+		    break
+		}
+	    }
+	    incr len -1
+	    if {$allmatch} break
+	}
+	set f [string range $t0 0 $len]
+    }
+
+    if {$data(-multiple)} {
+	set f [list $f]
+    }
+    $data(ent) delete 0 end
+    $data(ent) insert 0 $f
+    return -code break
+}
diff --git a/mplug_owl2/lib/tk8.6/ttk/combobox.tcl b/mplug_owl2/lib/tk8.6/ttk/combobox.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..e339f97a65cca7e1f5e1a76e6145d5560ed15db9
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/ttk/combobox.tcl
@@ -0,0 +1,448 @@
+#
+# Combobox bindings.
+#
+# <<NOTE-WM-TRANSIENT>>:
+#
+#	Need to set [wm transient] just before mapping the popdown
+#	instead of when it's created, in case a containing frame
+#	has been reparented [#1818441].
+#
+#	On Windows: setting [wm transient] prevents the parent
+#	toplevel from becoming inactive when the popdown is posted
+#	(Tk 8.4.8+)
+#
+#	On X11: WM_TRANSIENT_FOR on override-redirect windows
+#	may be used by compositing managers and by EWMH-aware
+#	window managers (even though the older ICCCM spec says
+#	it's meaningless).
+#
+#	On OSX: [wm transient] does utterly the wrong thing.
+#	Instead, we use [MacWindowStyle "help" "noActivates hideOnSuspend"].
+#	The "noActivates" attribute prevents the parent toplevel
+#	from deactivating when the popdown is posted, and is also
+#	necessary for "help" windows to receive mouse events.
+#	"hideOnSuspend" makes the popdown disappear (resp. reappear)
+#	when the parent toplevel is deactivated (resp. reactivated).
+#	(see [#1814778]).  Also set [wm resizable 0 0], to prevent
+#	TkAqua from shrinking the scrollbar to make room for a grow box
+#	that isn't there.
+#
+#	In order to work around other platform quirks in TkAqua,
+#	[grab] and [focus] are set in <Map> bindings instead of
+#	immediately after deiconifying the window.
+#
+
+namespace eval ttk::combobox {
+    variable Values	;# Values($cb) is -listvariable of listbox widget
+    variable State
+    set State(entryPress) 0
+}
+
+### Combobox bindings.
+#
+# Duplicate the Entry bindings, override if needed:
+#
+
+ttk::copyBindings TEntry TCombobox
+
+bind TCombobox <Down> 			{ ttk::combobox::Post %W }
+bind TCombobox <Escape> 		{ ttk::combobox::Unpost %W }
+
+bind TCombobox <Button-1> 		{ ttk::combobox::Press "" %W %x %y }
+bind TCombobox <Shift-Button-1>		{ ttk::combobox::Press "s" %W %x %y }
+bind TCombobox <Double-Button-1> 	{ ttk::combobox::Press "2" %W %x %y }
+bind TCombobox <Triple-Button-1> 	{ ttk::combobox::Press "3" %W %x %y }
+bind TCombobox <B1-Motion>		{ ttk::combobox::Drag %W %x }
+bind TCombobox <Motion>			{ ttk::combobox::Motion %W %x %y }
+
+ttk::bindMouseWheel TCombobox [list ttk::combobox::Scroll %W]
+
+bind TCombobox <<TraverseIn>> 		{ ttk::combobox::TraverseIn %W }
+
+### Combobox listbox bindings.
+#
+bind ComboboxListbox <ButtonRelease-1>	{ ttk::combobox::LBSelected %W }
+bind ComboboxListbox <Return>		{ ttk::combobox::LBSelected %W }
+bind ComboboxListbox <Escape>		{ ttk::combobox::LBCancel %W }
+bind ComboboxListbox <Tab>		{ ttk::combobox::LBTab %W next }
+bind ComboboxListbox <<PrevWindow>>	{ ttk::combobox::LBTab %W prev }
+bind ComboboxListbox <Destroy>		{ ttk::combobox::LBCleanup %W }
+bind ComboboxListbox <Motion>		{ ttk::combobox::LBHover %W %x %y }
+bind ComboboxListbox <Map>		{ focus -force %W }
+
+switch -- [tk windowingsystem] {
+    win32 {
+	# Dismiss listbox when user switches to a different application.
+	# NB: *only* do this on Windows (see #1814778)
+	bind ComboboxListbox <FocusOut>		{ ttk::combobox::LBCancel %W }
+    }
+}
+
+### Combobox popdown window bindings.
+#
+bind ComboboxPopdown	<Map>		{ ttk::combobox::MapPopdown %W }
+bind ComboboxPopdown	<Unmap>		{ ttk::combobox::UnmapPopdown %W }
+bind ComboboxPopdown	<Button> \
+			{ ttk::combobox::Unpost [winfo parent %W] }
+
+### Option database settings.
+#
+
+option add *TCombobox*Listbox.font TkTextFont widgetDefault
+option add *TCombobox*Listbox.relief flat widgetDefault
+option add *TCombobox*Listbox.highlightThickness 0 widgetDefault
+
+## Platform-specific settings.
+#
+switch -- [tk windowingsystem] {
+    x11 {
+	option add *TCombobox*Listbox.background white widgetDefault
+    }
+    aqua {
+	option add *TCombobox*Listbox.borderWidth 0 widgetDefault
+    }
+}
+
+### Binding procedures.
+#
+
+## Press $mode $x $y -- Button binding for comboboxes.
+#	Either post/unpost the listbox, or perform Entry widget binding,
+#	depending on widget state and location of button press.
+#
+proc ttk::combobox::Press {mode w x y} {
+    variable State
+
+    $w instate disabled { return }
+
+    set State(entryPress) [expr {
+	   [$w instate !readonly]
+	&& [string match *textarea [$w identify element $x $y]]
+    }]
+
+    focus $w
+    if {$State(entryPress)} {
+	switch -- $mode {
+	    s 	{ ttk::entry::Shift-Press $w $x 	; # Shift }
+	    2	{ ttk::entry::Select $w $x word 	; # Double click}
+	    3	{ ttk::entry::Select $w $x line 	; # Triple click }
+	    ""	-
+	    default { ttk::entry::Press $w $x }
+	}
+    } else {
+	Post $w
+    }
+}
+
+## Drag -- B1-Motion binding for comboboxes.
+#	If the initial Button event was handled by Entry binding,
+#	perform Entry widget drag binding; otherwise nothing.
+#
+proc ttk::combobox::Drag {w x}  {
+    variable State
+    if {$State(entryPress)} {
+	ttk::entry::Drag $w $x
+    }
+}
+
+## Motion --
+#	Set cursor.
+#
+proc ttk::combobox::Motion {w x y} {
+    variable State
+    ttk::saveCursor $w State(userConfCursor) [ttk::cursor text]
+    if {   [$w identify $x $y] eq "textarea"
+        && [$w instate {!readonly !disabled}]
+    } {
+	ttk::setCursor $w text
+    } else {
+	ttk::setCursor $w $State(userConfCursor)
+    }
+}
+
+## TraverseIn -- receive focus due to keyboard navigation
+#	For editable comboboxes, set the selection and insert cursor.
+#
+proc ttk::combobox::TraverseIn {w} {
+    $w instate {!readonly !disabled} {
+	$w selection range 0 end
+	$w icursor end
+    }
+}
+
+## SelectEntry $cb $index --
+#	Set the combobox selection in response to a user action.
+#
+proc ttk::combobox::SelectEntry {cb index} {
+    $cb current $index
+    $cb selection range 0 end
+    $cb icursor end
+    event generate $cb <<ComboboxSelected>> -when mark
+}
+
+## Scroll -- Mousewheel binding
+#
+proc ttk::combobox::Scroll {cb dir} {
+    $cb instate disabled { return }
+    set max [llength [$cb cget -values]]
+    set current [$cb current]
+    incr current $dir
+    if {$max != 0 && $current == $current % $max} {
+	SelectEntry $cb $current
+    }
+}
+
+## LBSelected $lb -- Activation binding for listbox
+#	Set the combobox value to the currently-selected listbox value
+#	and unpost the listbox.
+#
+proc ttk::combobox::LBSelected {lb} {
+    set cb [LBMaster $lb]
+    LBSelect $lb
+    Unpost $cb
+    focus $cb
+}
+
+## LBCancel --
+#	Unpost the listbox.
+#
+proc ttk::combobox::LBCancel {lb} {
+    Unpost [LBMaster $lb]
+}
+
+## LBTab -- Tab key binding for combobox listbox.
+#	Set the selection, and navigate to next/prev widget.
+#
+proc ttk::combobox::LBTab {lb dir} {
+    set cb [LBMaster $lb]
+    switch -- $dir {
+	next	{ set newFocus [tk_focusNext $cb] }
+	prev	{ set newFocus [tk_focusPrev $cb] }
+    }
+
+    if {$newFocus ne ""} {
+	LBSelect $lb
+	Unpost $cb
+	# The [grab release] call in [Unpost] queues events that later
+	# re-set the focus (@@@ NOTE: this might not be true anymore).
+	# Set new focus later:
+	after 0 [list ttk::traverseTo $newFocus]
+    }
+}
+
+## LBHover -- <Motion> binding for combobox listbox.
+#	Follow selection on mouseover.
+#
+proc ttk::combobox::LBHover {w x y} {
+    $w selection clear 0 end
+    $w activate @$x,$y
+    $w selection set @$x,$y
+}
+
+## MapPopdown -- <Map> binding for ComboboxPopdown
+#
+proc ttk::combobox::MapPopdown {w} {
+    [winfo parent $w] state pressed
+    ttk::globalGrab $w
+}
+
+## UnmapPopdown -- <Unmap> binding for ComboboxPopdown
+#
+proc ttk::combobox::UnmapPopdown {w} {
+    [winfo parent $w] state !pressed
+    ttk::releaseGrab $w
+}
+
+## PopdownWindow --
+#	Returns the popdown widget associated with a combobox,
+#	creating it if necessary.
+#
+proc ttk::combobox::PopdownWindow {cb} {
+    if {![winfo exists $cb.popdown]} {
+	set poplevel [PopdownToplevel $cb.popdown]
+	set popdown [ttk::frame $poplevel.f -style ComboboxPopdownFrame]
+
+	ttk::scrollbar $popdown.sb \
+	    -orient vertical -command [list $popdown.l yview]
+	listbox $popdown.l \
+	    -listvariable ttk::combobox::Values($cb) \
+	    -yscrollcommand [list $popdown.sb set] \
+	    -exportselection false \
+	    -selectmode browse \
+	    -activestyle none \
+	    ;
+
+	bindtags $popdown.l \
+	    [list $popdown.l ComboboxListbox Listbox $popdown all]
+
+	grid $popdown.l -row 0 -column 0 -padx {1 0} -pady 1 -sticky nsew
+        grid $popdown.sb -row 0 -column 1 -padx {0 1} -pady 1 -sticky ns
+	grid columnconfigure $popdown 0 -weight 1
+	grid rowconfigure $popdown 0 -weight 1
+
+        grid $popdown -sticky news -padx 0 -pady 0
+        grid rowconfigure $poplevel 0 -weight 1
+        grid columnconfigure $poplevel 0 -weight 1
+    }
+    return $cb.popdown
+}
+
+## PopdownToplevel -- Create toplevel window for the combobox popdown
+#
+#	See also <<NOTE-WM-TRANSIENT>>
+#
+proc ttk::combobox::PopdownToplevel {w} {
+    toplevel $w -class ComboboxPopdown
+    wm withdraw $w
+    switch -- [tk windowingsystem] {
+	default -
+	x11 {
+	    $w configure -relief flat -borderwidth 0
+	    wm attributes $w -type combo
+	    wm overrideredirect $w true
+	}
+	win32 {
+	    $w configure -relief flat -borderwidth 0
+	    wm overrideredirect $w true
+	    wm attributes $w -topmost 1
+	}
+	aqua {
+	    $w configure -relief solid -borderwidth 0
+	    tk::unsupported::MacWindowStyle style $w \
+	    	help {noActivates hideOnSuspend}
+	    wm resizable $w 0 0
+	}
+    }
+    return $w
+}
+
+## ConfigureListbox --
+#	Set listbox values, selection, height, and scrollbar visibility
+#	from current combobox values.
+#
+proc ttk::combobox::ConfigureListbox {cb} {
+    variable Values
+
+    set popdown [PopdownWindow $cb].f
+    set values [$cb cget -values]
+    set current [$cb current]
+    if {$current < 0} {
+	set current 0 		;# no current entry, highlight first one
+    }
+    set Values($cb) $values
+    $popdown.l selection clear 0 end
+    $popdown.l selection set $current
+    $popdown.l activate $current
+    $popdown.l see $current
+    set height [llength $values]
+    if {$height > [$cb cget -height]} {
+	set height [$cb cget -height]
+    	grid $popdown.sb
+        grid configure $popdown.l -padx {1 0}
+    } else {
+	grid remove $popdown.sb
+        grid configure $popdown.l -padx 1
+    }
+    $popdown.l configure -height $height
+}
+
+## PlacePopdown --
+#	Set popdown window geometry.
+#
+# @@@TODO: factor with menubutton::PostPosition
+#
+proc ttk::combobox::PlacePopdown {cb popdown} {
+    set x [winfo rootx $cb]
+    set y [winfo rooty $cb]
+    set w [winfo width $cb]
+    set h [winfo height $cb]
+    set style [$cb cget -style]
+    if { $style eq {} } {
+      set style TCombobox
+    }
+    set postoffset [ttk::style lookup $style -postoffset {} {0 0 0 0}]
+    foreach var {x y w h} delta $postoffset {
+    	incr $var $delta
+    }
+
+    set H [winfo reqheight $popdown]
+    if {$y + $h + $H > [winfo screenheight $popdown]} {
+	set Y [expr {$y - $H}]
+    } else {
+	set Y [expr {$y + $h}]
+    }
+    wm geometry $popdown ${w}x${H}+${x}+${Y}
+}
+
+## Post $cb --
+#	Pop down the associated listbox.
+#
+proc ttk::combobox::Post {cb} {
+    # Don't do anything if disabled:
+    #
+    $cb instate disabled { return }
+
+    # ASSERT: ![$cb instate pressed]
+
+    # Run -postcommand callback:
+    #
+    uplevel #0 [$cb cget -postcommand]
+
+    set popdown [PopdownWindow $cb]
+    ConfigureListbox $cb
+    update idletasks	;# needed for geometry propagation.
+    PlacePopdown $cb $popdown
+    # See <<NOTE-WM-TRANSIENT>>
+    switch -- [tk windowingsystem] {
+	x11 - win32 { wm transient $popdown [winfo toplevel $cb] }
+    }
+
+    # Post the listbox:
+    #
+    wm attribute $popdown -topmost 1
+    wm deiconify $popdown
+    raise $popdown
+}
+
+## Unpost $cb --
+#	Unpost the listbox.
+#
+proc ttk::combobox::Unpost {cb} {
+    if {[winfo exists $cb.popdown]} {
+	wm withdraw $cb.popdown
+    }
+    grab release $cb.popdown ;# in case of stuck or unexpected grab [#1239190]
+}
+
+## LBMaster $lb --
+#	Return the combobox main widget that owns the listbox.
+#
+proc ttk::combobox::LBMaster {lb} {
+    winfo parent [winfo parent [winfo parent $lb]]
+}
+
+## LBSelect $lb --
+#	Transfer listbox selection to combobox value.
+#
+proc ttk::combobox::LBSelect {lb} {
+    set cb [LBMaster $lb]
+    set selection [$lb curselection]
+    if {[llength $selection] == 1} {
+	SelectEntry $cb [lindex $selection 0]
+    }
+}
+
+## LBCleanup $lb --
+#	<Destroy> binding for combobox listboxes.
+#	Cleans up by unsetting the linked textvariable.
+#
+#	Note: we can't just use { unset [%W cget -listvariable] }
+#	because the widget command is already gone when this binding fires).
+#	[winfo parent] still works, fortunately.
+#
+proc ttk::combobox::LBCleanup {lb} {
+    variable Values
+    unset Values([LBMaster $lb])
+}
+
+#*EOF*
diff --git a/mplug_owl2/lib/tk8.6/ttk/cursors.tcl b/mplug_owl2/lib/tk8.6/ttk/cursors.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..9d1e1aef31b6ca1483ed23c9ae2f73c2d29ab33f
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/ttk/cursors.tcl
@@ -0,0 +1,205 @@
+#
+# Map symbolic cursor names to platform-appropriate cursors.
+#
+# The following cursors are defined:
+#
+#	standard	-- default cursor for most controls
+#	""		-- inherit cursor from parent window
+#	none		-- no cursor
+#
+#	text		-- editable widgets (entry, text)
+#	link		-- hyperlinks within text
+#	crosshair	-- graphic selection, fine control
+#	busy		-- operation in progress
+#	forbidden	-- action not allowed
+#
+#	hresize		-- horizontal resizing
+#	vresize		-- vertical resizing
+#
+# Also resize cursors for each of the compass points,
+# {nw,n,ne,w,e,sw,s,se}resize.
+#
+# Platform notes:
+#
+# Windows doesn't distinguish resizing at the 8 compass points,
+# only horizontal, vertical, and the two diagonals.
+#
+# OSX doesn't have resize cursors for nw, ne, sw, or se corners.
+# We use the Tk-defined X11 fallbacks for these.
+#
+# X11 doesn't have a "forbidden" cursor (usually a slashed circle);
+# "pirate" seems to be the conventional cursor for this purpose.
+#
+# Windows has an IDC_HELP cursor, but it's not available from Tk.
+#
+# Tk does not support "none" on Windows.
+#
+
+namespace eval ttk {
+
+    variable Cursors
+
+    # Use X11 cursor names as defaults, since Tk supplies these
+    # on all platforms.
+    #
+    array set Cursors {
+	""		""
+	none		none
+
+	standard	left_ptr
+	text 		xterm
+	link		hand2
+	crosshair	crosshair
+	busy		watch
+	forbidden	pirate
+
+	hresize 	sb_h_double_arrow
+	vresize 	sb_v_double_arrow
+
+	nresize 	top_side
+	sresize 	bottom_side
+	wresize 	left_side
+	eresize 	right_side
+	nwresize	top_left_corner
+	neresize	top_right_corner
+	swresize	bottom_left_corner
+	seresize	bottom_right_corner
+	move		fleur
+
+    }
+
+    # Platform-specific overrides for Windows and OSX.
+    #
+    switch [tk windowingsystem] {
+	"win32" {
+	    array set Cursors {
+		none		{}
+
+		standard	arrow
+		text		ibeam
+		link		hand2
+		crosshair	crosshair
+		busy		wait
+		forbidden	no
+
+		vresize 	size_ns
+		nresize 	size_ns
+		sresize		size_ns
+
+		wresize		size_we
+		eresize		size_we
+		hresize 	size_we
+
+		nwresize	size_nw_se
+		swresize	size_ne_sw
+
+		neresize	size_ne_sw
+		seresize	size_nw_se
+	    }
+	}
+
+	"aqua" {
+	    array set Cursors {
+		standard	arrow
+		text 	ibeam
+		link	pointinghand
+		crosshair	crosshair
+		busy	watch
+		forbidden	notallowed
+
+		hresize 	resizeleftright
+		vresize 	resizeupdown
+		nresize	resizeup
+		sresize	resizedown
+		wresize	resizeleft
+		eresize	resizeright
+	    }
+	}
+    }
+}
+
+## ttk::cursor $cursor --
+#	Return platform-specific cursor for specified symbolic cursor.
+#
+proc ttk::cursor {name} {
+    variable Cursors
+    return $Cursors($name)
+}
+
+## ttk::setCursor $w $cursor --
+#	Set the cursor for specified window.
+#
+# [ttk::setCursor] should be used in <Motion> bindings
+# instead of directly calling [$w configure -cursor ...],
+# as the latter always incurs a server round-trip and
+# can lead to high CPU load (see [#1184746])
+#
+
+proc ttk::setCursor {w name} {
+    variable Cursors
+    if {[info exists Cursors($name)]} {
+        set cursorname $Cursors($name)
+    }  else {
+        set cursorname $name
+    }
+    if {[$w cget -cursor] ne $cursorname} {
+        $w configure -cursor $cursorname
+    }
+}
+
+## ttk::saveCursor $w $saveVar $excludeList --
+#       Set variable $saveVar to the -cursor value from widget $w,
+#       if either:
+#       a. $saveVar does not yet exist
+#       b. the currently user-specified cursor for $w is not in
+#          $excludeList
+
+proc ttk::saveCursor {w saveVar excludeList} {
+    upvar $saveVar sv
+    if {![info exists sv]} {
+        set sv [$w cget -cursor]
+    }
+    if {[$w cget -cursor] ni $excludeList} {
+        set sv [$w cget -cursor]
+    }
+}
+
+## Interactive test harness:
+#
+proc ttk::CursorSampler {f} {
+    ttk::frame $f
+
+    set r 0
+    foreach row {
+	{nwresize nresize   neresize}
+	{ wresize move       eresize}
+	{swresize sresize   seresize}
+	{text link crosshair}
+	{hresize vresize ""}
+	{busy forbidden ""}
+	{none standard ""}
+    } {
+	set c 0
+	foreach cursor $row {
+	    set w $f.${r}${c}
+	    ttk::label $w -text $cursor -cursor [ttk::cursor $cursor] \
+		-relief solid -borderwidth 1 -padding 3
+	    grid $w -row $r -column $c -sticky nswe
+	    grid columnconfigure $f $c -uniform cols -weight 1
+	    incr c
+	}
+	grid rowconfigure $f $r -uniform rows -weight 1
+	incr r
+    }
+
+    return $f
+}
+
+if {[info exists argv0] && $argv0 eq [info script]} {
+    wm title . "[array size ::ttk::Cursors] cursors"
+    pack [ttk::CursorSampler .f] -expand true -fill both
+    bind . <Escape> [list destroy .]
+    focus .f
+}
+
+#*EOF*
diff --git a/mplug_owl2/lib/tk8.6/ttk/fonts.tcl b/mplug_owl2/lib/tk8.6/ttk/fonts.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..4f735a8beb059d00d095b33f425b938d1f89a780
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/ttk/fonts.tcl
@@ -0,0 +1,154 @@
+#
+# Font specifications.
+#
+# This file, [source]d at initialization time, sets up the following
+# symbolic fonts based on the current platform:
+#
+# TkDefaultFont	-- default for GUI items not otherwise specified
+# TkTextFont	-- font for user text (entry, listbox, others)
+# TkFixedFont	-- standard fixed width font
+# TkHeadingFont	-- headings (column headings, etc)
+# TkCaptionFont -- dialog captions (primary text in alert dialogs, etc.)
+# TkTooltipFont	-- font to use for tooltip windows
+# TkIconFont	-- font to use for icon captions
+# TkMenuFont	-- used to use for menu items
+#
+# In Tk 8.5, some of these fonts may be provided by the TIP#145 implementation
+# (On Windows and Mac OS X as of Oct 2007).
+#
+# +++ Platform notes:
+#
+# Windows:
+#	The default system font changed from "MS Sans Serif" to "Tahoma"
+# 	in Windows XP/Windows 2000.
+#
+#	MS documentation says to use "Tahoma 8" in Windows 2000/XP,
+#	although many MS programs still use "MS Sans Serif 8"
+#
+#	Should use SystemParametersInfo() instead.
+#
+# Mac OSX / Aqua:
+#	Quoth the Apple HIG:
+#	The _system font_ (Lucida Grande Regular 13 pt) is used for text
+#	in menus, dialogs, and full-size controls.
+#	[...] Use the _view font_ (Lucida Grande Regular 12pt) as the default
+#	font of text in lists and tables.
+#	[...] Use the _emphasized system font_ (Lucida Grande Bold 13 pt)
+#	sparingly. It is used for the message text in alerts.
+#	[...] The _small system font_ (Lucida Grande Regular 11 pt) [...]
+#	is also the default font for column headings in lists, for help tags,
+#	and for small controls.
+#
+#	Note that the font for column headings (TkHeadingFont) is
+#	_smaller_ than the default font.
+#
+#	There does not appear to be any recommendations for fixed-width fonts.
+#
+# X11:
+#	"Classic" look used Helvetica bold for everything except
+#	for entry widgets, which use Helvetica medium.
+#	Most other toolkits use medium weight for all UI elements,
+#	which is what we do now.
+#
+#	Font size specified in pixels on X11, not points.
+#	This is Theoretically Wrong, but in practice works better; using
+#	points leads to huge inconsistencies across different servers.
+#
+
+namespace eval ttk {
+
+variable tip145 [catch {font create TkDefaultFont}]
+catch {font create TkTextFont}
+catch {font create TkHeadingFont}
+catch {font create TkCaptionFont}
+catch {font create TkTooltipFont}
+catch {font create TkFixedFont}
+catch {font create TkIconFont}
+catch {font create TkMenuFont}
+catch {font create TkSmallCaptionFont}
+
+if {!$tip145} {
+variable F	;# miscellaneous platform-specific font parameters
+switch -- [tk windowingsystem] {
+    win32 {
+        # In safe interps there is no osVersion element.
+	if {[info exists tcl_platform(osVersion)]} {
+            if {$tcl_platform(osVersion) >= 5.0} {
+                set F(family) "Tahoma"
+            } else {
+                set F(family) "MS Sans Serif"
+            }
+        } else {
+            if {[lsearch -exact [font families] Tahoma] >= 0} {
+                set F(family) "Tahoma"
+            } else {
+                set F(family) "MS Sans Serif"
+            }
+        }
+	set F(size) 8
+
+	font configure TkDefaultFont -family $F(family) -size $F(size)
+	font configure TkTextFont    -family $F(family) -size $F(size)
+	font configure TkHeadingFont -family $F(family) -size $F(size)
+	font configure TkCaptionFont -family $F(family) -size $F(size) \
+	    -weight bold
+	font configure TkTooltipFont -family $F(family) -size $F(size)
+	font configure TkFixedFont   -family Courier -size 10
+	font configure TkIconFont    -family $F(family) -size $F(size)
+	font configure TkMenuFont    -family $F(family) -size $F(size)
+	font configure TkSmallCaptionFont -family $F(family) -size $F(size)
+    }
+    aqua {
+	set F(family) "Lucida Grande"
+	set F(fixed) "Monaco"
+	set F(menusize) 14
+	set F(size) 13
+	set F(viewsize) 12
+	set F(smallsize) 11
+	set F(labelsize) 10
+	set F(fixedsize) 11
+
+	font configure TkDefaultFont -family $F(family) -size $F(size)
+	font configure TkTextFont    -family $F(family) -size $F(size)
+	font configure TkHeadingFont -family $F(family) -size $F(smallsize)
+	font configure TkCaptionFont -family $F(family) -size $F(size) \
+					-weight bold
+	font configure TkTooltipFont -family $F(family) -size $F(smallsize)
+	font configure TkFixedFont   -family $F(fixed)  -size $F(fixedsize)
+	font configure TkIconFont    -family $F(family) -size $F(size)
+	font configure TkMenuFont    -family $F(family) -size $F(menusize)
+	font configure TkSmallCaptionFont -family $F(family) -size $F(labelsize)
+    }
+    default -
+    x11 {
+	if {![catch {tk::pkgconfig get fontsystem} F(fs)] && $F(fs) eq "xft"} {
+	    set F(family) "sans-serif"
+	    set F(fixed)  "monospace"
+	} else {
+	    set F(family) "Helvetica"
+	    set F(fixed)  "courier"
+	}
+	set F(size) -12
+	set F(ttsize) -10
+	set F(capsize) -14
+	set F(fixedsize) -12
+
+	font configure TkDefaultFont -family $F(family) -size $F(size)
+	font configure TkTextFont    -family $F(family) -size $F(size)
+	font configure TkHeadingFont -family $F(family) -size $F(size) \
+			-weight bold
+	font configure TkCaptionFont -family $F(family) -size $F(capsize) \
+			-weight bold
+	font configure TkTooltipFont -family $F(family) -size $F(ttsize)
+	font configure TkFixedFont   -family $F(fixed)  -size $F(fixedsize)
+	font configure TkIconFont    -family $F(family) -size $F(size)
+	font configure TkMenuFont    -family $F(family) -size $F(size)
+	font configure TkSmallCaptionFont -family $F(family) -size $F(ttsize)
+    }
+}
+unset -nocomplain F
+}
+
+}
+
+#*EOF*
diff --git a/mplug_owl2/lib/tk8.6/ttk/notebook.tcl b/mplug_owl2/lib/tk8.6/ttk/notebook.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..c5e6d94f1b9fa6840dbf1bf058629f50313e0b75
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/ttk/notebook.tcl
@@ -0,0 +1,201 @@
+#
+# Bindings for TNotebook widget
+#
+
+namespace eval ttk::notebook {
+    variable TLNotebooks ;# See enableTraversal
+}
+
+bind TNotebook <Button-1>		{ ttk::notebook::Press %W %x %y }
+bind TNotebook <Right>			{ ttk::notebook::CycleTab %W  1; break }
+bind TNotebook <Left>			{ ttk::notebook::CycleTab %W -1; break }
+bind TNotebook <Control-Tab>		{ ttk::notebook::CycleTab %W  1; break }
+bind TNotebook <Control-Shift-Tab>	{ ttk::notebook::CycleTab %W -1; break }
+catch {
+bind TNotebook <Control-ISO_Left_Tab>	{ ttk::notebook::CycleTab %W -1; break }
+}
+bind TNotebook <Destroy>		{ ttk::notebook::Cleanup %W }
+
+# ActivateTab $nb $tab --
+#	Select the specified tab and set focus.
+#
+#  Desired behavior:
+#	+ take focus when reselecting the currently-selected tab;
+#	+ keep focus if the notebook already has it;
+#	+ otherwise set focus to the first traversable widget
+#	  in the newly-selected tab;
+#	+ do not leave the focus in a deselected tab.
+#
+proc ttk::notebook::ActivateTab {w tab} {
+    set oldtab [$w select]
+    $w select $tab
+    set newtab [$w select] ;# NOTE: might not be $tab, if $tab is disabled
+
+    if {[focus] eq $w} { return }
+    if {$newtab eq $oldtab} { focus $w ; return }
+
+    update idletasks ;# needed so focus logic sees correct mapped states
+    if {[set f [ttk::focusFirst $newtab]] ne ""} {
+	ttk::traverseTo $f
+    } else {
+	focus $w
+    }
+}
+
+# Press $nb $x $y --
+#	Button-1 binding for notebook widgets.
+#	Activate the tab under the mouse cursor, if any.
+#
+proc ttk::notebook::Press {w x y} {
+    set index [$w index @$x,$y]
+    if {$index ne ""} {
+	ActivateTab $w $index
+    }
+}
+
+# CycleTab --
+#	Select the next/previous tab in the list.
+#
+proc ttk::notebook::CycleTab {w dir} {
+    set current [$w index current]
+    if {$current >= 0} {
+	set tabCount [$w index end]
+	set select [expr {($current + $dir) % $tabCount}]
+	set step [expr {$dir > 0 ? 1 : -1}]
+	while {[$w tab $select -state] ne "normal" && ($select != $current)} {
+	    set select [expr {($select + $step) % $tabCount}]
+	}
+	if {$select != $current} {
+	    ActivateTab $w $select
+	}
+    }
+}
+
+# MnemonicTab $nb $key --
+#	Scan all tabs in the specified notebook for one with the
+#	specified mnemonic. If found, returns path name of tab;
+#	otherwise returns ""
+#
+proc ttk::notebook::MnemonicTab {nb key} {
+    set key [string toupper $key]
+    foreach tab [$nb tabs] {
+	set label [$nb tab $tab -text]
+	set underline [$nb tab $tab -underline]
+	if {$underline >= 0} {
+	    set mnemonic [string toupper [string index $label $underline]]
+	    if {$mnemonic ne "" && $mnemonic eq $key} {
+		return $tab
+	    }
+	}
+    }
+    return ""
+}
+
+# +++ Toplevel keyboard traversal.
+#
+
+# enableTraversal --
+#	Enable keyboard traversal for a notebook widget
+#	by adding bindings to the containing toplevel window.
+#
+#	TLNotebooks($top) keeps track of the list of all traversal-enabled
+#	notebooks contained in the toplevel
+#
+proc ttk::notebook::enableTraversal {nb} {
+    variable TLNotebooks
+
+    set top [winfo toplevel $nb]
+
+    if {![info exists TLNotebooks($top)]} {
+	# Augment $top bindings:
+	#
+	bind $top <Control-Next>             {+ttk::notebook::TLCycleTab %W  1}
+	bind $top <Control-Prior>            {+ttk::notebook::TLCycleTab %W -1}
+	bind $top <Control-Tab> 	     {+ttk::notebook::TLCycleTab %W  1}
+	bind $top <Control-Shift-Tab>        {+ttk::notebook::TLCycleTab %W -1}
+	catch {
+	bind $top <Control-ISO_Left_Tab>     {+ttk::notebook::TLCycleTab %W -1}
+	}
+	if {[tk windowingsystem] eq "aqua"} {
+	    bind $top <Option-Key> \
+		+[list ttk::notebook::MnemonicActivation $top %K]
+	} else {
+	    bind $top <Alt-Key> \
+		+[list ttk::notebook::MnemonicActivation $top %K]
+	}
+	bind $top <Destroy> {+ttk::notebook::TLCleanup %W}
+    }
+
+    lappend TLNotebooks($top) $nb
+}
+
+# TLCleanup -- <Destroy> binding for traversal-enabled toplevels
+#
+proc ttk::notebook::TLCleanup {w} {
+    variable TLNotebooks
+    if {$w eq [winfo toplevel $w]} {
+	unset -nocomplain -please TLNotebooks($w)
+    }
+}
+
+# Cleanup -- <Destroy> binding for notebooks
+#
+proc ttk::notebook::Cleanup {nb} {
+    variable TLNotebooks
+    set top [winfo toplevel $nb]
+    if {[info exists TLNotebooks($top)]} {
+	set index [lsearch -exact $TLNotebooks($top) $nb]
+        set TLNotebooks($top) [lreplace $TLNotebooks($top) $index $index]
+    }
+}
+
+# EnclosingNotebook $w --
+#	Return the nearest traversal-enabled notebook widget
+#	that contains $w.
+#
+# BUGS: this only works properly for tabs that are direct children
+#	of the notebook widget.  This routine should follow the
+#	geometry manager hierarchy, not window ancestry, but that
+#	information is not available in Tk.
+#
+proc ttk::notebook::EnclosingNotebook {w} {
+    variable TLNotebooks
+
+    set top [winfo toplevel $w]
+    if {![info exists TLNotebooks($top)]} { return }
+
+    while {$w ne $top  && $w ne ""} {
+	if {[lsearch -exact $TLNotebooks($top) $w] >= 0} {
+	    return $w
+	}
+	set w [winfo parent $w]
+    }
+    return ""
+}
+
+# TLCycleTab --
+#	toplevel binding procedure for Control-Tab / Control-Shift-Tab
+#	Select the next/previous tab in the nearest ancestor notebook.
+#
+proc ttk::notebook::TLCycleTab {w dir} {
+    set nb [EnclosingNotebook $w]
+    if {$nb ne ""} {
+	CycleTab $nb $dir
+	return -code break
+    }
+}
+
+# MnemonicActivation $nb $key --
+#	Alt-Key binding procedure for mnemonic activation.
+#	Scan all notebooks in specified toplevel for a tab with the
+#	the specified mnemonic.  If found, activate it and return TCL_BREAK.
+#
+proc ttk::notebook::MnemonicActivation {top key} {
+    variable TLNotebooks
+    foreach nb $TLNotebooks($top) {
+	if {[set tab [MnemonicTab $nb $key]] ne ""} {
+	    ActivateTab $nb [$nb index $tab]
+	    return -code break
+	}
+    }
+}
diff --git a/mplug_owl2/lib/tk8.6/ttk/progress.tcl b/mplug_owl2/lib/tk8.6/ttk/progress.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..34dce723ee45305cc1bf95a017d9654d2ce05572
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/ttk/progress.tcl
@@ -0,0 +1,49 @@
+#
+# Ttk widget set: progress bar utilities.
+#
+
+namespace eval ttk::progressbar {
+    variable Timers	;# Map: widget name -> after ID
+}
+
+# Autoincrement --
+#	Periodic callback procedure for autoincrement mode
+#
+proc ttk::progressbar::Autoincrement {pb steptime stepsize} {
+    variable Timers
+
+    if {![winfo exists $pb]} {
+    	# widget has been destroyed -- cancel timer
+	unset -nocomplain Timers($pb)
+	return
+    }
+
+    set Timers($pb) [after $steptime \
+    	[list ttk::progressbar::Autoincrement $pb $steptime $stepsize] ]
+
+    $pb step $stepsize
+}
+
+# ttk::progressbar::start --
+#	Start autoincrement mode.  Invoked by [$pb start] widget code.
+#
+proc ttk::progressbar::start {pb {steptime 50} {stepsize 1}} {
+    variable Timers
+    if {![info exists Timers($pb)]} {
+	Autoincrement $pb $steptime $stepsize
+    }
+}
+
+# ttk::progressbar::stop --
+#	Cancel autoincrement mode. Invoked by [$pb stop] widget code.
+#
+proc ttk::progressbar::stop {pb} {
+    variable Timers
+    if {[info exists Timers($pb)]} {
+	after cancel $Timers($pb)
+	unset Timers($pb)
+    }
+    $pb configure -value 0
+}
+
+
diff --git a/mplug_owl2/lib/tk8.6/ttk/scrollbar.tcl b/mplug_owl2/lib/tk8.6/ttk/scrollbar.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..8be9887de7764d5426496830738f2b4e8c0cb78d
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/ttk/scrollbar.tcl
@@ -0,0 +1,126 @@
+#
+# Bindings for TScrollbar widget
+#
+
+namespace eval ttk::scrollbar {
+    variable State
+    # State(xPress)	--
+    # State(yPress)	-- initial position of mouse at start of drag.
+    # State(first)	-- value of -first at start of drag.
+}
+
+bind TScrollbar <Button-1> 		{ ttk::scrollbar::Press %W %x %y }
+bind TScrollbar <B1-Motion>		{ ttk::scrollbar::Drag %W %x %y }
+bind TScrollbar <ButtonRelease-1>	{ ttk::scrollbar::Release %W %x %y }
+
+bind TScrollbar <Button-2> 		{ ttk::scrollbar::Jump %W %x %y }
+bind TScrollbar <B2-Motion>		{ ttk::scrollbar::Drag %W %x %y }
+bind TScrollbar <ButtonRelease-2>	{ ttk::scrollbar::Release %W %x %y }
+
+# Redirect scrollwheel bindings to the scrollbar widget
+#
+# The shift-bindings scroll left/right (not up/down)
+# if a widget has both possibilities
+set eventList [list <MouseWheel> <Shift-MouseWheel>]
+switch [tk windowingsystem] {
+    aqua {
+        lappend eventList <Option-MouseWheel> <Shift-Option-MouseWheel>
+    }
+    x11 {
+        lappend eventList <Button-4> <Button-5> \
+                <Shift-Button-4> <Shift-Button-5>
+    }
+}
+foreach event $eventList {
+    bind TScrollbar $event [bind Scrollbar $event]
+}
+unset eventList event
+
+proc ttk::scrollbar::Scroll {w n units} {
+    set cmd [$w cget -command]
+    if {$cmd ne ""} {
+	uplevel #0 $cmd scroll $n $units
+    }
+}
+
+proc ttk::scrollbar::Moveto {w fraction} {
+    set cmd [$w cget -command]
+    if {$cmd ne ""} {
+	uplevel #0 $cmd moveto $fraction
+    }
+}
+
+proc ttk::scrollbar::Press {w x y} {
+    variable State
+
+    set State(xPress) $x
+    set State(yPress) $y
+
+    switch -glob -- [$w identify $x $y] {
+	*uparrow -
+	*leftarrow {
+	    ttk::Repeatedly Scroll $w -1 units
+	}
+	*downarrow -
+	*rightarrow {
+	    ttk::Repeatedly Scroll $w  1 units
+	}
+	*grip -
+	*thumb {
+	    set State(first) [lindex [$w get] 0]
+	}
+	*trough {
+	    set f [$w fraction $x $y]
+	    if {$f < [lindex [$w get] 0]} {
+		# Clicked in upper/left trough
+		ttk::Repeatedly Scroll $w -1 pages
+	    } elseif {$f > [lindex [$w get] 1]} {
+		# Clicked in lower/right trough
+		ttk::Repeatedly Scroll $w 1 pages
+	    } else {
+		# Clicked on thumb (???)
+		set State(first) [lindex [$w get] 0]
+	    }
+	}
+    }
+}
+
+proc ttk::scrollbar::Drag {w x y} {
+    variable State
+    if {![info exists State(first)]} {
+    	# Initial buttonpress was not on the thumb,
+	# or something screwy has happened.  In either case, ignore:
+	return;
+    }
+    set xDelta [expr {$x - $State(xPress)}]
+    set yDelta [expr {$y - $State(yPress)}]
+    Moveto $w [expr {$State(first) + [$w delta $xDelta $yDelta]}]
+}
+
+proc ttk::scrollbar::Release {w x y} {
+    variable State
+    unset -nocomplain State(xPress) State(yPress) State(first)
+    ttk::CancelRepeat
+}
+
+# scrollbar::Jump -- Button-2 binding for scrollbars.
+# 	Behaves exactly like scrollbar::Press, except that
+#	clicking in the trough jumps to the the selected position.
+#
+proc ttk::scrollbar::Jump {w x y} {
+    variable State
+
+    switch -glob -- [$w identify $x $y] {
+	*grip -
+	*thumb -
+	*trough {
+	    set State(first) [$w fraction $x $y]
+	    Moveto $w $State(first)
+	    set State(xPress) $x
+	    set State(yPress) $y
+	}
+	default {
+	    Press $w $x $y
+	}
+    }
+}
diff --git a/mplug_owl2/lib/tk8.6/ttk/treeview.tcl b/mplug_owl2/lib/tk8.6/ttk/treeview.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..62fc630b175ab26ced7c345b1e8cc4d88f7cd478
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/ttk/treeview.tcl
@@ -0,0 +1,383 @@
+#
+# ttk::treeview widget bindings and utilities.
+#
+
+namespace eval ttk::treeview {
+    variable State
+
+    # Enter/Leave/Motion
+    #
+    set State(activeWidget) 	{}
+    set State(activeHeading) 	{}
+
+    # Press/drag/release:
+    #
+    set State(pressMode) 	none
+    set State(pressX)		0
+
+    # For pressMode == "resize"
+    set State(resizeColumn)	#0
+
+    # For pressmode == "heading"
+    set State(heading)  	{}
+}
+
+### Widget bindings.
+#
+
+bind Treeview	<Motion> 		{ ttk::treeview::Motion %W %x %y }
+bind Treeview	<B1-Leave>		{ #nothing }
+bind Treeview	<Leave>			{ ttk::treeview::ActivateHeading {} {}}
+bind Treeview	<Button-1> 		{ ttk::treeview::Press %W %x %y }
+bind Treeview	<Double-Button-1> 	{ ttk::treeview::DoubleClick %W %x %y }
+bind Treeview	<ButtonRelease-1> 	{ ttk::treeview::Release %W %x %y }
+bind Treeview	<B1-Motion> 		{ ttk::treeview::Drag %W %x %y }
+bind Treeview 	<Up>    		{ ttk::treeview::Keynav %W up }
+bind Treeview 	<Down>  		{ ttk::treeview::Keynav %W down }
+bind Treeview 	<Right> 		{ ttk::treeview::Keynav %W right }
+bind Treeview 	<Left>  		{ ttk::treeview::Keynav %W left }
+bind Treeview	<Prior>			{ %W yview scroll -1 pages }
+bind Treeview	<Next> 			{ %W yview scroll  1 pages }
+bind Treeview	<Return>		{ ttk::treeview::ToggleFocus %W }
+bind Treeview	<space>			{ ttk::treeview::ToggleFocus %W }
+
+bind Treeview	<Shift-Button-1> \
+		{ ttk::treeview::Select %W %x %y extend }
+bind Treeview	<<ToggleSelection>> \
+		{ ttk::treeview::Select %W %x %y toggle }
+
+ttk::copyBindings TtkScrollable Treeview
+
+### Binding procedures.
+#
+
+## Keynav -- Keyboard navigation
+#
+# @@@ TODO: verify/rewrite up and down code.
+#
+proc ttk::treeview::Keynav {w dir} {
+    set focus [$w focus]
+    if {$focus eq ""} { return }
+
+    switch -- $dir {
+	up {
+	    if {[set up [$w prev $focus]] eq ""} {
+	        set focus [$w parent $focus]
+	    } else {
+		while {[$w item $up -open] && [llength [$w children $up]]} {
+		    set up [lindex [$w children $up] end]
+		}
+		set focus $up
+	    }
+	}
+	down {
+	    if {[$w item $focus -open] && [llength [$w children $focus]]} {
+	        set focus [lindex [$w children $focus] 0]
+	    } else {
+		set up $focus
+		while {$up ne "" && [set down [$w next $up]] eq ""} {
+		    set up [$w parent $up]
+		}
+		set focus $down
+	    }
+	}
+	left {
+	    if {[$w item $focus -open] && [llength [$w children $focus]]} {
+	    	CloseItem $w $focus
+	    } else {
+	    	set focus [$w parent $focus]
+	    }
+	}
+	right {
+	    OpenItem $w $focus
+	}
+    }
+
+    if {$focus != {}} {
+	SelectOp $w $focus choose
+    }
+}
+
+## Motion -- pointer motion binding.
+#	Sets cursor, active element ...
+#
+proc ttk::treeview::Motion {w x y} {
+    variable State
+
+    ttk::saveCursor $w State(userConfCursor) [ttk::cursor hresize]
+
+    set cursor $State(userConfCursor)
+    set activeHeading {}
+
+    switch -- [$w identify region $x $y] {
+	separator { set cursor hresize }
+	heading { set activeHeading [$w identify column $x $y] }
+    }
+
+    ttk::setCursor $w $cursor
+    ActivateHeading $w $activeHeading
+}
+
+## ActivateHeading -- track active heading element
+#
+proc ttk::treeview::ActivateHeading {w heading} {
+    variable State
+
+    if {$w != $State(activeWidget) || $heading != $State(activeHeading)} {
+	if {[winfo exists $State(activeWidget)] && $State(activeHeading) != {}} {
+	    # It may happen that $State(activeHeading) no longer corresponds
+	    # to an existing display column. This happens for instance when
+	    # changing -displaycolumns in a bound script when this change
+	    # triggers a <Leave> event. A proc checking if the display column
+	    # $State(activeHeading) is really still present or not could be
+	    # written but it would need to check several special cases:
+	    #   a. -displaycolumns "#all" or being an explicit columns list
+	    #   b. column #0 display is not governed by the -displaycolumn
+	    #      list but by the value of the -show option
+	    # --> Let's rather catch the following line.
+	    catch {$State(activeWidget) heading $State(activeHeading) state !active}
+	}
+	if {$heading != {}} {
+	    $w heading $heading state active
+	}
+	set State(activeHeading) $heading
+	set State(activeWidget) $w
+    }
+}
+
+## Select $w $x $y $selectop
+#	Binding procedure for selection operations.
+#	See "Selection modes", below.
+#
+proc ttk::treeview::Select {w x y op} {
+    if {[set item [$w identify row $x $y]] ne "" } {
+	SelectOp $w $item $op
+    }
+}
+
+## DoubleClick -- Double-Button-1 binding.
+#
+proc ttk::treeview::DoubleClick {w x y} {
+    if {[set row [$w identify row $x $y]] ne ""} {
+	Toggle $w $row
+    } else {
+	Press $w $x $y ;# perform single-click action
+    }
+}
+
+## Press -- Button binding.
+#
+proc ttk::treeview::Press {w x y} {
+    focus $w
+    switch -- [$w identify region $x $y] {
+	nothing { }
+	heading { heading.press $w $x $y }
+	separator { resize.press $w $x $y }
+	tree -
+	cell {
+	    set item [$w identify item $x $y]
+	    SelectOp $w $item choose
+	    switch -glob -- [$w identify element $x $y] {
+		*indicator -
+		*disclosure { Toggle $w $item }
+	    }
+	}
+    }
+}
+
+## Drag -- B1-Motion binding
+#
+proc ttk::treeview::Drag {w x y} {
+    variable State
+    switch $State(pressMode) {
+	resize	{ resize.drag $w $x }
+	heading	{ heading.drag $w $x $y }
+    }
+}
+
+proc ttk::treeview::Release {w x y} {
+    variable State
+    switch $State(pressMode) {
+	resize	{ resize.release $w $x }
+	heading	{ heading.release $w }
+    }
+    set State(pressMode) none
+    Motion $w $x $y
+}
+
+### Interactive column resizing.
+#
+proc ttk::treeview::resize.press {w x y} {
+    variable State
+    set State(pressMode) "resize"
+    set State(resizeColumn) [$w identify column $x $y]
+}
+
+proc ttk::treeview::resize.drag {w x} {
+    variable State
+    $w drag $State(resizeColumn) $x
+}
+
+proc ttk::treeview::resize.release {w x} {
+    $w drop
+}
+
+### Heading activation.
+#
+
+proc ttk::treeview::heading.press {w x y} {
+    variable State
+    set column [$w identify column $x $y]
+    set State(pressMode) "heading"
+    set State(heading) $column
+    $w heading $column state pressed
+}
+
+proc ttk::treeview::heading.drag {w x y} {
+    variable State
+    if {   [$w identify region $x $y] eq "heading"
+        && [$w identify column $x $y] eq $State(heading)
+    } {
+    	$w heading $State(heading) state pressed
+    } else {
+    	$w heading $State(heading) state !pressed
+    }
+}
+
+proc ttk::treeview::heading.release {w} {
+    variable State
+    if {[lsearch -exact [$w heading $State(heading) state] pressed] >= 0} {
+	after 0 [$w heading $State(heading) -command]
+    }
+    $w heading $State(heading) state !pressed
+}
+
+### Selection modes.
+#
+
+## SelectOp $w $item [ choose | extend | toggle ] --
+#	Dispatch to appropriate selection operation
+#	depending on current value of -selectmode.
+#
+proc ttk::treeview::SelectOp {w item op} {
+    select.$op.[$w cget -selectmode] $w $item
+}
+
+## -selectmode none:
+#
+proc ttk::treeview::select.choose.none {w item} { $w focus $item; $w see $item }
+proc ttk::treeview::select.toggle.none {w item} { $w focus $item; $w see $item }
+proc ttk::treeview::select.extend.none {w item} { $w focus $item; $w see $item }
+
+## -selectmode browse:
+#
+proc ttk::treeview::select.choose.browse {w item} { BrowseTo $w $item }
+proc ttk::treeview::select.toggle.browse {w item} { BrowseTo $w $item }
+proc ttk::treeview::select.extend.browse {w item} { BrowseTo $w $item }
+
+## -selectmode multiple:
+#
+proc ttk::treeview::select.choose.extended {w item} {
+    BrowseTo $w $item
+}
+proc ttk::treeview::select.toggle.extended {w item} {
+    $w selection toggle [list $item]
+}
+proc ttk::treeview::select.extend.extended {w item} {
+    if {[set anchor [$w focus]] ne ""} {
+	$w selection set [between $w $anchor $item]
+    } else {
+    	BrowseTo $w $item
+    }
+}
+
+### Tree structure utilities.
+#
+
+## between $tv $item1 $item2 --
+#	Returns a list of all items between $item1 and $item2,
+#	in preorder traversal order.  $item1 and $item2 may be
+#	in either order.
+#
+# NOTES:
+#	This routine is O(N) in the size of the tree.
+#	There's probably a way to do this that's O(N) in the number
+#	of items returned, but I'm not clever enough to figure it out.
+#
+proc ttk::treeview::between {tv item1 item2} {
+    variable between [list]
+    variable selectingBetween 0
+    ScanBetween $tv $item1 $item2 {}
+    return $between
+}
+
+## ScanBetween --
+#	Recursive worker routine for ttk::treeview::between
+#
+proc ttk::treeview::ScanBetween {tv item1 item2 item} {
+    variable between
+    variable selectingBetween
+
+    if {$item eq $item1 || $item eq $item2} {
+    	lappend between $item
+	set selectingBetween [expr {!$selectingBetween}]
+    } elseif {$selectingBetween} {
+    	lappend between $item
+    }
+    foreach child [$tv children $item] {
+	ScanBetween $tv $item1 $item2 $child
+    }
+}
+
+### User interaction utilities.
+#
+
+## OpenItem, CloseItem -- Set the open state of an item, generate event
+#
+
+proc ttk::treeview::OpenItem {w item} {
+    $w focus $item
+    event generate $w <<TreeviewOpen>>
+    $w item $item -open true
+}
+
+proc ttk::treeview::CloseItem {w item} {
+    $w item $item -open false
+    $w focus $item
+    event generate $w <<TreeviewClose>>
+}
+
+## Toggle -- toggle opened/closed state of item
+#
+proc ttk::treeview::Toggle {w item} {
+    # don't allow toggling on indicators that
+    # are not present in front of leaf items
+    if {[$w children $item] == {}} {
+        return
+    }
+    # not a leaf, toggle!
+    if {[$w item $item -open]} {
+	CloseItem $w $item
+    } else {
+	OpenItem $w $item
+    }
+}
+
+## ToggleFocus -- toggle opened/closed state of focus item
+#
+proc ttk::treeview::ToggleFocus {w} {
+    set item [$w focus]
+    if {$item ne ""} {
+    	Toggle $w $item
+    }
+}
+
+## BrowseTo -- navigate to specified item; set focus and selection
+#
+proc ttk::treeview::BrowseTo {w item} {
+    $w see $item
+    $w focus $item
+    $w selection set [list $item]
+}
+
+#*EOF*
diff --git a/mplug_owl2/lib/tk8.6/ttk/ttk.tcl b/mplug_owl2/lib/tk8.6/ttk/ttk.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..73ee3d9d97ef9a280293e8041cd73c3660ff82e8
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/ttk/ttk.tcl
@@ -0,0 +1,176 @@
+#
+# Ttk widget set initialization script.
+#
+
+### Source library scripts.
+#
+
+namespace eval ::ttk {
+    variable library
+    if {![info exists library]} {
+	set library [file dirname [info script]]
+    }
+}
+
+source -encoding utf-8 [file join $::ttk::library fonts.tcl]
+source -encoding utf-8 [file join $::ttk::library cursors.tcl]
+source -encoding utf-8 [file join $::ttk::library utils.tcl]
+
+## ttk::deprecated $old $new --
+#	Define $old command as a deprecated alias for $new command
+#	$old and $new must be fully namespace-qualified.
+#
+proc ttk::deprecated {old new} {
+    interp alias {} $old {} ttk::do'deprecate $old $new
+}
+## do'deprecate --
+#	Implementation procedure for deprecated commands --
+#	issue a warning (once), then re-alias old to new.
+#
+proc ttk::do'deprecate {old new args} {
+    deprecated'warning $old $new
+    interp alias {} $old {} $new
+    uplevel 1 [linsert $args 0 $new]
+}
+
+## deprecated'warning --
+#	Gripe about use of deprecated commands.
+#
+proc ttk::deprecated'warning {old new} {
+    puts stderr "$old deprecated -- use $new instead"
+}
+
+### Backward-compatibility.
+#
+#
+# Make [package require tile] an effective no-op;
+# see SF#3016598 for discussion.
+#
+package ifneeded tile 0.8.6 { package provide tile 0.8.6 }
+
+# ttk::panedwindow used to be named ttk::paned.  Keep the alias for now.
+#
+::ttk::deprecated ::ttk::paned ::ttk::panedwindow
+
+### ::ttk::ThemeChanged --
+#	Called from [::ttk::style theme use].
+#	Sends a <<ThemeChanged>> virtual event to all widgets.
+#
+proc ::ttk::ThemeChanged {} {
+    set Q .
+    while {[llength $Q]} {
+	set QN [list]
+	foreach w $Q {
+	    event generate $w <<ThemeChanged>>
+	    foreach child [winfo children $w] {
+		lappend QN $child
+	    }
+	}
+	set Q $QN
+    }
+}
+
+### Public API.
+#
+
+proc ::ttk::themes {{ptn *}} {
+    set themes [list]
+
+    foreach pkg [lsearch -inline -all -glob [package names] ttk::theme::$ptn] {
+	lappend themes [namespace tail $pkg]
+    }
+
+    return $themes
+}
+
+## ttk::setTheme $theme --
+#	Set the current theme to $theme, loading it if necessary.
+#
+proc ::ttk::setTheme {theme} {
+    variable currentTheme ;# @@@ Temp -- [::ttk::style theme use] doesn't work
+    if {$theme ni [::ttk::style theme names]} {
+	package require ttk::theme::$theme
+    }
+    ::ttk::style theme use $theme
+    set currentTheme $theme
+}
+
+### Load widget bindings.
+#
+source -encoding utf-8 [file join $::ttk::library button.tcl]
+source -encoding utf-8 [file join $::ttk::library menubutton.tcl]
+source -encoding utf-8 [file join $::ttk::library scrollbar.tcl]
+source -encoding utf-8 [file join $::ttk::library scale.tcl]
+source -encoding utf-8 [file join $::ttk::library progress.tcl]
+source -encoding utf-8 [file join $::ttk::library notebook.tcl]
+source -encoding utf-8 [file join $::ttk::library panedwindow.tcl]
+source -encoding utf-8 [file join $::ttk::library entry.tcl]
+source -encoding utf-8 [file join $::ttk::library combobox.tcl]	;# dependency: entry.tcl
+source -encoding utf-8 [file join $::ttk::library spinbox.tcl]  ;# dependency: entry.tcl
+source -encoding utf-8 [file join $::ttk::library treeview.tcl]
+source -encoding utf-8 [file join $::ttk::library sizegrip.tcl]
+
+## Label and Labelframe bindings:
+#  (not enough to justify their own file...)
+#
+bind TLabelframe <<Invoke>>	{ tk::TabToWindow [tk_focusNext %W] }
+bind TLabel <<Invoke>>		{ tk::TabToWindow [tk_focusNext %W] }
+
+### Load settings for built-in themes:
+#
+proc ttk::LoadThemes {} {
+    variable library
+
+    # "default" always present:
+    uplevel #0 [list source -encoding utf-8 [file join $library defaults.tcl]]
+
+    set builtinThemes [style theme names]
+    foreach {theme scripts} {
+	classic 	classicTheme.tcl
+	alt 		altTheme.tcl
+	clam 		clamTheme.tcl
+	winnative	winTheme.tcl
+	xpnative	{xpTheme.tcl vistaTheme.tcl}
+	aqua 		aquaTheme.tcl
+    } {
+	if {[lsearch -exact $builtinThemes $theme] >= 0} {
+            foreach script $scripts {
+                uplevel #0 [list source -encoding utf-8 [file join $library $script]]
+            }
+	}
+    }
+}
+
+ttk::LoadThemes; rename ::ttk::LoadThemes {}
+
+### Select platform-specific default theme:
+#
+# Notes:
+#	+ On OSX, aqua theme is the default
+#	+ On Windows, xpnative takes precedence over winnative if available.
+#	+ On X11, users can use the X resource database to
+#	  specify a preferred theme (*TkTheme: themeName);
+#	  otherwise "default" is used.
+#
+
+proc ttk::DefaultTheme {} {
+    set preferred [list aqua vista xpnative winnative]
+
+    set userTheme [option get . tkTheme TkTheme]
+    if {$userTheme ne {} && ![catch {
+	uplevel #0 [list package require ttk::theme::$userTheme]
+    }]} {
+	return $userTheme
+    }
+
+    foreach theme $preferred {
+	if {[package provide ttk::theme::$theme] ne ""} {
+	    return $theme
+	}
+    }
+    return "default"
+}
+
+ttk::setTheme [ttk::DefaultTheme] ; rename ttk::DefaultTheme {}
+
+#*EOF*
diff --git a/mplug_owl2/lib/tk8.6/ttk/utils.tcl b/mplug_owl2/lib/tk8.6/ttk/utils.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..3d9088004423077c7513275ff523fa0572311d52
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/ttk/utils.tcl
@@ -0,0 +1,337 @@
+#
+# Utilities for widget implementations.
+#
+
+### Focus management.
+#
+# See also: #1516479
+#
+
+## ttk::takefocus --
+#	This is the default value of the "-takefocus" option
+#	for ttk::* widgets that participate in keyboard navigation.
+#
+# NOTES:
+#	tk::FocusOK (called by tk_focusNext) tests [winfo viewable]
+#	if -takefocus is 1, empty, or missing; but not if it's a
+#	script prefix, so we have to check that here as well.
+#
+#
+proc ttk::takefocus {w} {
+    expr {[$w instate !disabled] && [winfo viewable $w]}
+}
+
+## ttk::GuessTakeFocus --
+#	This routine is called as a fallback for widgets
+#	with a missing or empty -takefocus option.
+#
+#	It implements the same heuristics as tk::FocusOK.
+#
+proc ttk::GuessTakeFocus {w} {
+    # Don't traverse to widgets with '-state disabled':
+    #
+    if {![catch {$w cget -state} state] && $state eq "disabled"} {
+	return 0
+    }
+
+    # Allow traversal to widgets with explicit key or focus bindings:
+    #
+    if {[regexp {Key|Focus} [concat [bind $w] [bind [winfo class $w]]]]} {
+	return 1;
+    }
+
+    # Default is nontraversable:
+    #
+    return 0;
+}
+
+## ttk::traverseTo $w --
+# 	Set the keyboard focus to the specified window.
+#
+proc ttk::traverseTo {w} {
+    set focus [focus]
+    if {$focus ne ""} {
+	event generate $focus <<TraverseOut>>
+    }
+    focus $w
+    event generate $w <<TraverseIn>>
+}
+
+## ttk::clickToFocus $w --
+#	Utility routine, used in <Button-1> bindings --
+#	Assign keyboard focus to the specified widget if -takefocus is enabled.
+#
+proc ttk::clickToFocus {w} {
+    if {[ttk::takesFocus $w]} { focus $w }
+}
+
+## ttk::takesFocus w --
+#	Test if the widget can take keyboard focus.
+#
+#	See the description of the -takefocus option in options(n)
+#	for details.
+#
+proc ttk::takesFocus {w} {
+    if {![winfo viewable $w]} {
+    	return 0
+    } elseif {[catch {$w cget -takefocus} takefocus]} {
+	return [GuessTakeFocus $w]
+    } else {
+	switch -- $takefocus {
+	    "" { return [GuessTakeFocus $w] }
+	    0  { return 0 }
+	    1  { return 1 }
+	    default {
+		return [expr {[uplevel #0 $takefocus [list $w]] == 1}]
+	    }
+	}
+    }
+}
+
+## ttk::focusFirst $w --
+#	Return the first descendant of $w, in preorder traversal order,
+#	that can take keyboard focus, "" if none do.
+#
+# See also: tk_focusNext
+#
+
+proc ttk::focusFirst {w} {
+    if {[ttk::takesFocus $w]} {
+	return $w
+    }
+    foreach child [winfo children $w] {
+	if {[set c [ttk::focusFirst $child]] ne ""} {
+	    return $c
+	}
+    }
+    return ""
+}
+
+### Grabs.
+#
+# Rules:
+#	Each call to [grabWindow $w] or [globalGrab $w] must be
+#	matched with a call to [releaseGrab $w] in LIFO order.
+#
+#	Do not call [grabWindow $w] for a window that currently
+#	appears on the grab stack.
+#
+#	See #1239190 and #1411983 for more discussion.
+#
+namespace eval ttk {
+    variable Grab 		;# map: window name -> grab token
+
+    # grab token details:
+    #	Two-element list containing:
+    #	1) a script to evaluate to restore the previous grab (if any);
+    #	2) a script to evaluate to restore the focus (if any)
+}
+
+## SaveGrab --
+#	Record current grab and focus windows.
+#
+proc ttk::SaveGrab {w} {
+    variable Grab
+
+    if {[info exists Grab($w)]} {
+	# $w is already on the grab stack.
+	# This should not happen, but bail out in case it does anyway:
+	#
+	return
+    }
+
+    set restoreGrab [set restoreFocus ""]
+
+    set grabbed [grab current $w]
+    if {[winfo exists $grabbed]} {
+    	switch [grab status $grabbed] {
+	    global { set restoreGrab [list grab -global $grabbed] }
+	    local  { set restoreGrab [list grab $grabbed] }
+	    none   { ;# grab window is really in a different interp }
+	}
+    }
+
+    set focus [focus]
+    if {$focus ne ""} {
+    	set restoreFocus [list focus -force $focus]
+    }
+
+    set Grab($w) [list $restoreGrab $restoreFocus]
+}
+
+## RestoreGrab --
+#	Restore previous grab and focus windows.
+#	If called more than once without an intervening [SaveGrab $w],
+#	does nothing.
+#
+proc ttk::RestoreGrab {w} {
+    variable Grab
+
+    if {![info exists Grab($w)]} {	# Ignore
+	return;
+    }
+
+    # The previous grab/focus window may have been destroyed,
+    # unmapped, or some other abnormal condition; ignore any errors.
+    #
+    foreach script $Grab($w) {
+	catch $script
+    }
+
+    unset Grab($w)
+}
+
+## ttk::grabWindow $w --
+#	Records the current focus and grab windows, sets an application-modal
+#	grab on window $w.
+#
+proc ttk::grabWindow {w} {
+    SaveGrab $w
+    grab $w
+}
+
+## ttk::globalGrab $w --
+#	Same as grabWindow, but sets a global grab on $w.
+#
+proc ttk::globalGrab {w} {
+    SaveGrab $w
+    grab -global $w
+}
+
+## ttk::releaseGrab --
+#	Release the grab previously set by [ttk::grabWindow]
+#	or [ttk::globalGrab].
+#
+proc ttk::releaseGrab {w} {
+    grab release $w
+    RestoreGrab $w
+}
+
+### Auto-repeat.
+#
+# NOTE: repeating widgets do not have -repeatdelay
+# or -repeatinterval resources as in standard Tk;
+# instead a single set of settings is applied application-wide.
+# (TODO: make this user-configurable)
+#
+# (@@@ Windows seems to use something like 500/50 milliseconds
+#  @@@ for -repeatdelay/-repeatinterval)
+#
+
+namespace eval ttk {
+    variable Repeat
+    array set Repeat {
+	delay		300
+	interval	100
+	timer		{}
+	script		{}
+    }
+}
+
+## ttk::Repeatedly --
+#	Begin auto-repeat.
+#
+proc ttk::Repeatedly {args} {
+    variable Repeat
+    after cancel $Repeat(timer)
+    set script [uplevel 1 [list namespace code $args]]
+    set Repeat(script) $script
+    set Repeat(timer) [after $Repeat(delay) ttk::Repeat]
+    uplevel #0 $script
+}
+
+## Repeat --
+#	Continue auto-repeat
+#
+proc ttk::Repeat {} {
+    variable Repeat
+    set Repeat(timer) [after $Repeat(interval) ttk::Repeat]
+    uplevel #0 $Repeat(script)
+}
+
+## ttk::CancelRepeat --
+#	Halt auto-repeat.
+#
+proc ttk::CancelRepeat {} {
+    variable Repeat
+    after cancel $Repeat(timer)
+}
+
+### Bindings.
+#
+
+## ttk::copyBindings $from $to --
+#	Utility routine; copies bindings from one bindtag onto another.
+#
+proc ttk::copyBindings {from to} {
+    foreach event [bind $from] {
+	bind $to $event [bind $from $event]
+    }
+}
+
+### Mousewheel bindings.
+#
+# Platform inconsistencies:
+#
+# On X11, the server typically maps the mouse wheel to Button4 and Button5.
+#
+# On OSX, Tk generates sensible values for the %D field in <MouseWheel> events.
+#
+# On Windows, %D must be scaled by a factor of 120.
+#
+# OSX conventionally uses Shift+MouseWheel for horizontal scrolling,
+# and Option+MouseWheel for accelerated scrolling.
+#
+# The Shift+MouseWheel behavior is not conventional on Windows or most
+# X11 toolkits, but it's useful.
+#
+# MouseWheel scrolling is accelerated on X11, which is conventional
+# for Tk and appears to be conventional for other toolkits (although
+# Gtk+ and Qt do not appear to use as large a factor).
+#
+
+## ttk::bindMouseWheel $bindtag $command...
+#	Adds basic mousewheel support to $bindtag.
+#	$command will be passed one additional argument
+#	specifying the mousewheel direction (-1: up, +1: down).
+#
+
+proc ttk::bindMouseWheel {bindtag callback} {
+    if {[tk windowingsystem] eq "x11"} {
+	bind $bindtag <Button-4> "$callback -1"
+	bind $bindtag <Button-5> "$callback +1"
+    }
+    if {[tk windowingsystem] eq "aqua"} {
+	bind $bindtag <MouseWheel> "$callback \[expr {-%D}\]"
+	bind $bindtag <Option-MouseWheel> "$callback \[expr {-10 * %D}\]"
+    } else {
+	bind $bindtag <MouseWheel> "$callback \[expr {-%D / 120}\]"
+    }
+}
+
+## Mousewheel bindings for standard scrollable widgets.
+#
+
+if {[tk windowingsystem] eq "x11"} {
+    bind TtkScrollable <Button-4>       { %W yview scroll -5 units }
+    bind TtkScrollable <Button-5>       { %W yview scroll  5 units }
+    bind TtkScrollable <Shift-Button-4> { %W xview scroll -5 units }
+    bind TtkScrollable <Shift-Button-5> { %W xview scroll  5 units }
+}
+if {[tk windowingsystem] eq "aqua"} {
+    bind TtkScrollable <MouseWheel> \
+	    { %W yview scroll [expr {-%D}] units }
+    bind TtkScrollable <Shift-MouseWheel> \
+	    { %W xview scroll [expr {-%D}] units }
+    bind TtkScrollable <Option-MouseWheel> \
+	    { %W yview scroll  [expr {-10 * %D}] units }
+    bind TtkScrollable <Shift-Option-MouseWheel> \
+	    { %W xview scroll [expr {-10 * %D}] units }
+} else {
+    bind TtkScrollable <MouseWheel> \
+	    { %W yview scroll [expr {-%D / 120}] units }
+    bind TtkScrollable <Shift-MouseWheel> \
+	    { %W xview scroll [expr {-%D / 120}] units }
+}
+
+#*EOF*
diff --git a/mplug_owl2/lib/tk8.6/ttk/vistaTheme.tcl b/mplug_owl2/lib/tk8.6/ttk/vistaTheme.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..07003537f484672451ec1c3a23c99d850f2c6e29
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/ttk/vistaTheme.tcl
@@ -0,0 +1,229 @@
+#
+# Settings for Microsoft Windows Vista and Server 2008
+#
+
+# The Vista theme can only be defined on Windows Vista and above. The theme
+# is created in C due to the need to assign a theme-enabled function for
+# detecting when themeing is disabled. On systems that cannot support the
+# Vista theme, there will be no such theme created and we must not
+# evaluate this script.
+
+if {"vista" ni [ttk::style theme names]} {
+    return
+}
+
+namespace eval ttk::theme::vista {
+
+    ttk::style theme settings vista {
+
+ 	ttk::style configure . \
+	    -background SystemButtonFace \
+	    -foreground SystemWindowText \
+	    -selectforeground SystemHighlightText \
+	    -selectbackground SystemHighlight \
+	    -insertcolor SystemWindowText \
+	    -font TkDefaultFont \
+	    ;
+
+	ttk::style map "." \
+	    -foreground [list disabled SystemGrayText] \
+	    ;
+
+	ttk::style configure TButton -anchor center -padding {1 1} -width -11
+	ttk::style configure TRadiobutton -padding 2
+	ttk::style configure TCheckbutton -padding 2
+	ttk::style configure TMenubutton -padding {8 4}
+
+	ttk::style element create Menubutton.dropdown vsapi \
+	    TOOLBAR 4 {{selected active} 6 {selected !active} 5
+		disabled 4 pressed 3 active 2 {} 1} \
+	    -syssize {SM_CXVSCROLL SM_CYVSCROLL}
+
+	ttk::style configure TNotebook -tabmargins {2 2 2 0}
+	ttk::style map TNotebook.Tab \
+	    -expand [list selected {2 2 2 2}]
+
+	# Treeview:
+	ttk::style configure Heading -font TkHeadingFont
+	ttk::style configure Treeview -background SystemWindow
+	ttk::style map Treeview \
+	    -background [list   disabled SystemButtonFace \
+				selected SystemHighlight] \
+	    -foreground [list   disabled SystemGrayText \
+				selected SystemHighlightText]
+
+        # Label and Toolbutton
+	ttk::style configure TLabelframe.Label -foreground SystemButtonText
+
+	ttk::style configure Toolbutton -padding {4 4}
+
+        # Combobox
+	ttk::style configure TCombobox -padding 2
+        ttk::style element create Combobox.border vsapi \
+            COMBOBOX 4 {disabled 4 focus 3 active 2 hover 2 {} 1}
+        ttk::style element create Combobox.background vsapi \
+            EDIT 3 {disabled 3 readonly 5 focus 4 hover 2 {} 1}
+        ttk::style element create Combobox.rightdownarrow vsapi \
+            COMBOBOX 6 {disabled 4 pressed 3 active 2 {} 1} \
+            -syssize {SM_CXVSCROLL SM_CYVSCROLL}
+        ttk::style layout TCombobox {
+            Combobox.border -sticky nswe -border 0 -children {
+                Combobox.rightdownarrow -side right -sticky ns
+                Combobox.padding -sticky nswe -children {
+                    Combobox.background -sticky nswe -children {
+                        Combobox.focus -sticky nswe -children {
+                            Combobox.textarea -sticky nswe
+                        }
+                    }
+                }
+            }
+        }
+        # Vista.Combobox droplist frame
+        ttk::style element create ComboboxPopdownFrame.background vsapi\
+            LISTBOX 3 {disabled 4 active 3 focus 2 {} 1}
+        ttk::style layout ComboboxPopdownFrame {
+            ComboboxPopdownFrame.background -sticky news -border 1 -children {
+                ComboboxPopdownFrame.padding -sticky news
+            }
+        }
+	ttk::style map TCombobox \
+	    -selectbackground [list !focus SystemWindow] \
+	    -selectforeground [list !focus SystemWindowText] \
+	    -foreground	[list \
+		disabled		SystemGrayText \
+	    	{readonly focus}	SystemHighlightText \
+	    ] \
+	    -focusfill	[list {readonly focus} SystemHighlight] \
+	    ;
+
+        # Entry
+        ttk::style configure TEntry -padding {1 1 1 1} ;# Needs lookup
+        ttk::style element create Entry.field vsapi \
+            EDIT 6 {disabled 4 focus 3 hover 2 {} 1} -padding {2 2 2 2}
+        ttk::style element create Entry.background vsapi \
+            EDIT 3 {disabled 3 readonly 3 focus 4 hover 2 {} 1}
+        ttk::style layout TEntry {
+            Entry.field -sticky news -border 0 -children {
+                Entry.background -sticky news -children {
+                    Entry.padding -sticky news -children {
+                        Entry.textarea -sticky news
+                    }
+                }
+            }
+        }
+	ttk::style map TEntry \
+	    -selectbackground [list !focus SystemWindow] \
+	    -selectforeground [list !focus SystemWindowText] \
+	    ;
+
+        # Spinbox
+        ttk::style configure TSpinbox -padding 0
+        ttk::style element create Spinbox.field vsapi \
+            EDIT 9 {disabled 4 focus 3 hover 2 {} 1} -padding {1 1 1 2}
+        ttk::style element create Spinbox.background vsapi \
+            EDIT 3 {disabled 3 readonly 3 focus 4 hover 2 {} 1}
+        ttk::style element create Spinbox.innerbg vsapi \
+            EDIT 3 {disabled 3 readonly 3 focus 4 hover 2 {} 1}\
+            -padding {2 0 15 2}
+        ttk::style element create Spinbox.uparrow vsapi \
+            SPIN 1 {disabled 4 pressed 3 active 2 {} 1} \
+            -padding 1 -halfheight 1 \
+            -syssize { SM_CXVSCROLL SM_CYVSCROLL }
+        ttk::style element create Spinbox.downarrow vsapi \
+            SPIN 2 {disabled 4 pressed 3 active 2 {} 1} \
+            -padding 1 -halfheight 1 \
+            -syssize { SM_CXVSCROLL SM_CYVSCROLL }
+        ttk::style layout TSpinbox {
+            Spinbox.field -sticky nswe -children {
+                Spinbox.background -sticky news -children {
+                    Spinbox.padding -sticky news -children {
+                        Spinbox.innerbg -sticky news -children {
+                            Spinbox.textarea
+                        }
+                    }
+                    Spinbox.uparrow -side top -sticky ens
+                    Spinbox.downarrow -side bottom -sticky ens
+                }
+            }
+        }
+	ttk::style map TSpinbox \
+	    -selectbackground [list !focus SystemWindow] \
+	    -selectforeground [list !focus SystemWindowText] \
+	    ;
+
+
+        # SCROLLBAR elements (Vista includes a state for 'hover')
+        ttk::style element create Vertical.Scrollbar.uparrow vsapi \
+            SCROLLBAR 1 {disabled 4 pressed 3 active 2 hover 17 {} 1} \
+            -syssize {SM_CXVSCROLL SM_CYVSCROLL}
+        ttk::style element create Vertical.Scrollbar.downarrow vsapi \
+            SCROLLBAR 1 {disabled 8 pressed 7 active 6 hover 18 {} 5} \
+            -syssize {SM_CXVSCROLL SM_CYVSCROLL}
+        ttk::style element create Vertical.Scrollbar.trough vsapi \
+            SCROLLBAR 7 {disabled 4 pressed 3 active 2 hover 5 {} 1}
+        ttk::style element create Vertical.Scrollbar.thumb vsapi \
+            SCROLLBAR 3 {disabled 4 pressed 3 active 2 hover 5 {} 1} \
+            -syssize {SM_CXVSCROLL SM_CYVSCROLL}
+        ttk::style element create Vertical.Scrollbar.grip vsapi \
+            SCROLLBAR 9 {disabled 4 pressed 3 active 2 hover 5 {} 1} \
+            -syssize {SM_CXVSCROLL SM_CYVSCROLL}
+        ttk::style element create Horizontal.Scrollbar.leftarrow vsapi \
+            SCROLLBAR 1 {disabled 12 pressed 11 active 10 hover 19 {} 9} \
+            -syssize {SM_CXHSCROLL SM_CYHSCROLL}
+        ttk::style element create Horizontal.Scrollbar.rightarrow vsapi \
+            SCROLLBAR 1 {disabled 16 pressed 15 active 14 hover 20 {} 13} \
+            -syssize {SM_CXHSCROLL SM_CYHSCROLL}
+        ttk::style element create Horizontal.Scrollbar.trough vsapi \
+            SCROLLBAR 5 {disabled 4 pressed 3 active 2 hover 5 {} 1}
+        ttk::style element create Horizontal.Scrollbar.thumb vsapi \
+            SCROLLBAR 2 {disabled 4 pressed 3 active 2 hover 5 {} 1} \
+            -syssize {SM_CXHSCROLL SM_CYHSCROLL}
+        ttk::style element create Horizontal.Scrollbar.grip vsapi \
+            SCROLLBAR 8 {disabled 4 pressed 3 active 2 hover 5 {} 1}
+
+        # Progressbar
+        ttk::style element create Horizontal.Progressbar.pbar vsapi \
+            PROGRESS 3 {{} 1} -padding 8
+        ttk::style layout Horizontal.TProgressbar {
+            Horizontal.Progressbar.trough -sticky nswe -children {
+                Horizontal.Progressbar.pbar -side left -sticky ns
+            }
+        }
+        ttk::style element create Vertical.Progressbar.pbar vsapi \
+            PROGRESS 3 {{} 1} -padding 8
+        ttk::style layout Vertical.TProgressbar {
+            Vertical.Progressbar.trough -sticky nswe -children {
+                Vertical.Progressbar.pbar -side bottom -sticky we
+            }
+        }
+
+        # Scale
+        ttk::style element create Horizontal.Scale.slider vsapi \
+            TRACKBAR 3 {disabled 5 focus 4 pressed 3 active 2 {} 1} \
+            -width 6 -height 12
+        ttk::style layout Horizontal.TScale {
+            Scale.focus -sticky nswe -children {
+                Horizontal.Scale.trough -sticky nswe -children {
+                    Horizontal.Scale.track -sticky we
+                    Horizontal.Scale.slider -side left -sticky {}
+                }
+            }
+        }
+        ttk::style element create Vertical.Scale.slider vsapi \
+            TRACKBAR 6 {disabled 5 focus 4 pressed 3 active 2 {} 1} \
+            -width 12 -height 6
+        ttk::style layout Vertical.TScale {
+            Scale.focus -sticky nswe -children {
+                Vertical.Scale.trough -sticky nswe -children {
+                    Vertical.Scale.track -sticky ns
+                    Vertical.Scale.slider -side top -sticky {}
+                }
+            }
+        }
+
+        # Treeview
+        ttk::style configure Item -padding {4 0 0 0}
+
+        package provide ttk::theme::vista 1.0
+    }
+}
diff --git a/mplug_owl2/lib/tk8.6/ttk/winTheme.tcl b/mplug_owl2/lib/tk8.6/ttk/winTheme.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..db05b45c01e73928d17cebe7f3f1644415407bb3
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/ttk/winTheme.tcl
@@ -0,0 +1,84 @@
+#
+# Settings for 'winnative' theme.
+#
+
+namespace eval ttk::theme::winnative {
+    ttk::style theme settings winnative {
+
+	ttk::style configure "." \
+	    -background SystemButtonFace \
+	    -foreground SystemWindowText \
+	    -selectforeground SystemHighlightText \
+	    -selectbackground SystemHighlight \
+	    -fieldbackground SystemWindow \
+	    -insertcolor SystemWindowText \
+	    -troughcolor SystemScrollbar \
+	    -font TkDefaultFont \
+	    ;
+
+	ttk::style map "." -foreground [list disabled SystemGrayText] ;
+        ttk::style map "." -embossed [list disabled 1] ;
+
+	ttk::style configure TButton \
+	    -anchor center -width -11 -relief raised -shiftrelief 1
+	ttk::style configure TCheckbutton -padding "2 4"
+	ttk::style configure TRadiobutton -padding "2 4"
+	ttk::style configure TMenubutton \
+	    -padding "8 4" -arrowsize 3 -relief raised
+
+	ttk::style map TButton -relief {{!disabled pressed} sunken}
+
+	ttk::style configure TEntry \
+	    -padding 2 -selectborderwidth 0 -insertwidth 1
+	ttk::style map TEntry \
+	    -fieldbackground \
+	    	[list readonly SystemButtonFace disabled SystemButtonFace] \
+	    -selectbackground [list !focus SystemWindow] \
+	    -selectforeground [list !focus SystemWindowText] \
+	    ;
+
+	ttk::style configure TCombobox -padding 2
+	ttk::style map TCombobox \
+	    -selectbackground [list !focus SystemWindow] \
+	    -selectforeground [list !focus SystemWindowText] \
+	    -fieldbackground [list \
+	    	readonly SystemButtonFace \
+		disabled SystemButtonFace] \
+	    -foreground	[list \
+		disabled		SystemGrayText \
+	    	{readonly focus}	SystemHighlightText \
+	    ] \
+	    -focusfill	[list {readonly focus} SystemHighlight] \
+	    ;
+
+	ttk::style element create ComboboxPopdownFrame.border from default
+	ttk::style configure ComboboxPopdownFrame \
+	    -borderwidth 1 -relief solid
+
+        ttk::style configure TSpinbox -padding {2 0 16 0}
+
+	ttk::style configure TLabelframe -borderwidth 2 -relief groove
+
+	ttk::style configure Toolbutton -relief flat -padding {8 4}
+	ttk::style map Toolbutton -relief \
+	    {disabled flat selected sunken  pressed sunken  active raised}
+
+	ttk::style configure TScale -groovewidth 4
+
+	ttk::style configure TNotebook -tabmargins {2 2 2 0}
+	ttk::style configure TNotebook.Tab -padding {3 1} -borderwidth 1
+	ttk::style map TNotebook.Tab -expand [list selected {2 2 2 0}]
+
+	# Treeview:
+	ttk::style configure Heading -font TkHeadingFont -relief raised
+	ttk::style configure Treeview -background SystemWindow
+	ttk::style map Treeview \
+	    -background [list   disabled SystemButtonFace \
+				selected SystemHighlight] \
+	    -foreground [list   disabled SystemGrayText \
+				selected SystemHighlightText]
+
+        ttk::style configure TProgressbar \
+	    -background SystemHighlight -borderwidth 0 ;
+    }
+}
diff --git a/mplug_owl2/lib/tk8.6/unsupported.tcl b/mplug_owl2/lib/tk8.6/unsupported.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..b5f404a36417b76dda00e69ca9630f9421c41b75
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/unsupported.tcl
@@ -0,0 +1,269 @@
+# unsupported.tcl --
+#
+# Commands provided by Tk without official support.  Use them at your
+# own risk.  They may change or go away without notice.
+#
+# 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
+	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 -errorcode {TK EXPOSE_PRIVATE_COMMAND} \
+	    "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 -errorcode {TK EXPOSE_PRIVATE_VARIABLE} \
+	    "No compatibility support for \$$var"
+    }
+    namespace eval ::tk::mac {}
+    foreach {old new} $vars {
+	namespace eval :: [list upvar "#0" $new $old]
+    }
+}
diff --git a/mplug_owl2/lib/tk8.6/xmfbox.tcl b/mplug_owl2/lib/tk8.6/xmfbox.tcl
new file mode 100644
index 0000000000000000000000000000000000000000..c26164a3dd1a21f64a701ee9bb6dd97ac64286c0
--- /dev/null
+++ b/mplug_owl2/lib/tk8.6/xmfbox.tcl
@@ -0,0 +1,989 @@
+# 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.
+#
+# 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 {$data(-parent) eq "."} {
+	set w .$dataName
+    } else {
+	set w $data(-parent).$dataName
+    }
+
+    # (re)create the dialog box if necessary
+    #
+    if {![winfo exists $w]} {
+	MotifFDialog_BuildUI $w
+    } elseif {[winfo class $w] ne "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
+    destroy $f
+
+    # No file types: use "*" as the filter and display no radio-buttons
+    if {$data(-filetypes) eq ""} {
+	set data(filter) *
+	return
+    }
+
+    # The filetypes radiobuttons
+    # set data(fileType) $data(-defaulttype)
+    # Default type to first entry
+    set initialTypeName [lindex $data(origfiletypes) 0 0]
+    if {$data(-typevariable) ne ""} {
+	upvar #0 $data(-typevariable) typeVariable
+	if {[info exists typeVariable]} {
+	    set initialTypeName $typeVariable
+	}
+    }
+    set ix 0
+    set data(fileType) 0
+    foreach fltr $data(origfiletypes) {
+	set fname [lindex $fltr 0]
+	if {[string first $initialTypeName $fname] == 0} {
+	    set data(fileType) $ix
+	    break
+	}
+	incr ix
+    }
+
+    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) ne {}} {
+	foreach type $data(-filetypes) {
+	    set title  [lindex $type 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 "" "" ""}
+	{-typevariable "" "" ""}
+    }
+    if {$type eq "open"} {
+	lappend specs {-multiple "" "" "0"}
+    }
+    if {$type eq "save"} {
+	lappend specs {-confirmoverwrite "" "" "1"}
+    }
+
+    set data(-multiple) 0
+    set data(-confirmoverwrite) 1
+    # 2: default values depending on the type of the dialog
+    #
+    if {![info exists data(selectPath)]} {
+	# first time the dialog has been popped up
+	set data(selectPath) [pwd]
+	set data(selectFile) ""
+    }
+
+    # 3: parse the arguments
+    #
+    tclParseConfigSpec ::tk::dialog::file::$dataName $specs "" $argList
+
+    if {$data(-title) eq ""} {
+	if {$type eq "open"} {
+	    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 {$data(-initialdir) ne ""} {
+	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(origfiletypes) $data(-filetypes)
+    set data(-filetypes) [::tk::FDGetFileTypes $data(-filetypes)]
+
+    if {![info exists data(filter)]} {
+	set data(filter) *
+    }
+    if {![winfo exists $data(-parent)]} {
+	return -code error -errorcode [list TK LOOKUP WINDOW $data(-parent)] \
+	    "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 rowconfigure $f2 0    -minsize 0   -weight 1
+    grid columnconfigure $f2 0 -minsize 0   -weight 1
+    grid columnconfigure $f2 1 -minsize 150 -weight 2
+
+    # The Filter box
+    #
+    bind [::tk::AmpWidget label $f1.lab -text [mc "Fil&ter:"] -anchor w] \
+	<<AltUnderlined>> [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] \
+	<<AltUnderlined>> [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 <Alt-Key> [list ::tk::AltKeyInDialog $w %A]
+
+    bind $data(fEnt) <Return> [list tk::MotifFDialog_ActivateFEnt $w]
+    bind $data(sEnt) <Return> [list tk::MotifFDialog_ActivateSEnt $w]
+    bind $w <Escape> [list tk::MotifFDialog_CancelCmd $w]
+    bind $w.bot <Destroy> {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] \
+	<<AltUnderlined>> [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 rowconfigure    $f 0 -weight 0 -minsize 0
+    grid rowconfigure    $f 1 -weight 1 -minsize 0
+    grid columnconfigure $f 0 -weight 1 -minsize 0
+
+    # bindings for the listboxes
+    #
+    set list $f.l
+    bind $list <<ListboxSelect>> [list tk::MotifFDialog_Browse$cmdPrefix $w]
+    bind $list <Double-ButtonRelease-1> \
+	    [list tk::MotifFDialog_Activate$cmdPrefix $w]
+    bind $list <Return>	"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 index $text 0] eq "~"} {
+	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 {[file pathtype $text] eq "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 {[$data(dList) curselection] eq ""} {
+	return
+    }
+    set subdir [$data(dList) get [$data(dList) curselection]]
+    if {$subdir eq ""} {
+	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 {[$data(dList) curselection] eq ""} {
+	return
+    }
+    set subdir [$data(dList) get [$data(dList) curselection]]
+    if {$subdir eq ""} {
+	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 {$subdir ne ".."} {
+	$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 {[$data(fList) curselection] eq ""} {
+	return
+    }
+    set data(selectFile) [$data(fList) get [$data(fList) curselection]]
+    if {$data(selectFile) eq ""} {
+	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 {$selectFilePath eq ""} {
+	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 {[file pathtype $item] ne "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 {$data(type) eq "open"} {
+		tk_messageBox -icon warning -type ok \
+			-message [mc {File "%1$s" does not exist.} $item]
+		return
+	    }
+	} elseif {$data(type) eq "save" && $data(-confirmoverwrite)} {
+	    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 {$answer eq "no"} {
+		return
+	    }
+	}
+
+	lappend newFileList $item
+    }
+
+    # Return selected filter
+    if {[info exists data(-typevariable)] && $data(-typevariable) ne ""
+	    && [info exists data(-filetypes)] && $data(-filetypes) ne ""} {
+	upvar #0 $data(-typevariable) typeVariable
+	set typeVariable [lindex $data(origfiletypes) $data(fileType) 0]
+    }
+
+    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 <Any-Key> ""
+    bind $w <Destroy> [list tk::ListBoxKeyAccel_Unset $w]
+    bind $w <Any-Key> [list tk::ListBoxKeyAccel_Key $w %A]
+}
+
+proc ::tk::ListBoxKeyAccel_Unset {w} {
+    variable ::tk::Priv
+
+    catch {after cancel $Priv(lbAccel,$w,afterId)}
+    unset -nocomplain Priv(lbAccel,$w) 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 eq "" } {
+	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 <<ListboxSelect>>
+    }
+}
+
+proc ::tk::ListBoxKeyAccel_Reset {w} {
+    variable ::tk::Priv
+
+    unset -nocomplain Priv(lbAccel,$w)
+}
+
+proc ::tk_getFileType {} {
+    variable ::tk::Priv
+
+    return $Priv(selectFileType)
+}
+
diff --git a/openflamingo/lib/python3.10/site-packages/transformers/models/bart/modeling_tf_bart.py b/openflamingo/lib/python3.10/site-packages/transformers/models/bart/modeling_tf_bart.py
new file mode 100644
index 0000000000000000000000000000000000000000..497dad4249113c9b97be06e01e0097a5db467630
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/transformers/models/bart/modeling_tf_bart.py
@@ -0,0 +1,1563 @@
+# coding=utf-8
+# Copyright 2021 The Fairseq Authors and The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""" TF 2.0 Bart model."""
+
+
+from __future__ import annotations
+
+import random
+from typing import Optional, Tuple, Union
+
+import numpy as np
+import tensorflow as tf
+
+from ...activations_tf import get_tf_activation
+from ...modeling_tf_outputs import (
+    TFBaseModelOutput,
+    TFBaseModelOutputWithPastAndCrossAttentions,
+    TFSeq2SeqLMOutput,
+    TFSeq2SeqModelOutput,
+    TFSeq2SeqSequenceClassifierOutput,
+)
+
+# Public API
+from ...modeling_tf_utils import (
+    TFCausalLanguageModelingLoss,
+    TFModelInputType,
+    TFPreTrainedModel,
+    TFSequenceClassificationLoss,
+    keras_serializable,
+    unpack_inputs,
+)
+from ...tf_utils import check_embeddings_within_bounds, shape_list, stable_softmax
+from ...utils import (
+    ContextManagers,
+    add_code_sample_docstrings,
+    add_end_docstrings,
+    add_start_docstrings,
+    add_start_docstrings_to_model_forward,
+    logging,
+    replace_return_docstrings,
+)
+from .configuration_bart import BartConfig
+
+
+logger = logging.get_logger(__name__)
+
+_CHECKPOINT_FOR_DOC = "facebook/bart-large"
+_CONFIG_FOR_DOC = "BartConfig"
+
+
+LARGE_NEGATIVE = -1e8
+
+
+def shift_tokens_right(input_ids: tf.Tensor, pad_token_id: int, decoder_start_token_id: int):
+    pad_token_id = tf.cast(pad_token_id, input_ids.dtype)
+    decoder_start_token_id = tf.cast(decoder_start_token_id, input_ids.dtype)
+    start_tokens = tf.fill(
+        (shape_list(input_ids)[0], 1), tf.convert_to_tensor(decoder_start_token_id, input_ids.dtype)
+    )
+    shifted_input_ids = tf.concat([start_tokens, input_ids[:, :-1]], -1)
+    # replace possible -100 values in labels by `pad_token_id`
+    shifted_input_ids = tf.where(
+        shifted_input_ids == -100,
+        tf.fill(shape_list(shifted_input_ids), tf.convert_to_tensor(pad_token_id, input_ids.dtype)),
+        shifted_input_ids,
+    )
+
+    # "Verify that `labels` has only positive values and -100"
+    assert_gte0 = tf.debugging.assert_greater_equal(shifted_input_ids, tf.constant(0, dtype=input_ids.dtype))
+
+    # Make sure the assertion op is called by wrapping the result in an identity no-op
+    with tf.control_dependencies([assert_gte0]):
+        shifted_input_ids = tf.identity(shifted_input_ids)
+
+    return shifted_input_ids
+
+
+def _make_causal_mask(input_ids_shape: tf.TensorShape, past_key_values_length: int = 0):
+    """
+    Make causal mask used for bi-directional self-attention.
+    """
+    bsz = input_ids_shape[0]
+    tgt_len = input_ids_shape[1]
+    mask = tf.ones((tgt_len, tgt_len)) * LARGE_NEGATIVE
+    mask_cond = tf.range(shape_list(mask)[-1])
+
+    mask = tf.where(mask_cond < tf.reshape(mask_cond + 1, (shape_list(mask)[-1], 1)), 0.0, mask)
+
+    if past_key_values_length > 0:
+        mask = tf.concat([tf.zeros((tgt_len, past_key_values_length)), mask], axis=-1)
+
+    return tf.tile(mask[None, None, :, :], (bsz, 1, 1, 1))
+
+
+def _expand_mask(mask: tf.Tensor, tgt_len: Optional[int] = None):
+    """
+    Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`.
+    """
+    src_len = shape_list(mask)[1]
+    tgt_len = tgt_len if tgt_len is not None else src_len
+    one_cst = tf.constant(1.0)
+    mask = tf.cast(mask, dtype=one_cst.dtype)
+    expanded_mask = tf.tile(mask[:, None, None, :], (1, 1, tgt_len, 1))
+
+    return (one_cst - expanded_mask) * LARGE_NEGATIVE
+
+
+class TFBartLearnedPositionalEmbedding(tf.keras.layers.Embedding):
+    """
+    This module learns positional embeddings up to a fixed maximum size.
+    """
+
+    def __init__(self, num_embeddings: int, embedding_dim: int, **kwargs):
+        # Bart is set up so that if padding_idx is specified then offset the embedding ids by 2
+        # and adjust num_embeddings appropriately. Other models don't have this hack
+        self.offset = 2
+        super().__init__(num_embeddings + self.offset, embedding_dim, **kwargs)
+
+    def call(
+        self,
+        input_shape: Optional[tf.TensorShape] = None,
+        past_key_values_length: int = 0,
+        position_ids: tf.Tensor | None = None,
+    ):
+        """Input is expected to be of size [bsz x seqlen]."""
+        if position_ids is None:
+            seq_len = input_shape[1]
+            position_ids = tf.range(seq_len, delta=1, name="range")
+            position_ids += past_key_values_length
+
+        offset_dtype = position_ids.dtype if isinstance(position_ids, tf.Tensor) else tf.int32
+        return super().call(position_ids + tf.constant(self.offset, dtype=offset_dtype))
+
+
+class TFBartAttention(tf.keras.layers.Layer):
+    """Multi-headed attention from "Attention Is All You Need"""
+
+    def __init__(
+        self,
+        embed_dim: int,
+        num_heads: int,
+        dropout: float = 0.0,
+        is_decoder: bool = False,
+        bias: bool = True,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.embed_dim = embed_dim
+
+        self.num_heads = num_heads
+        self.dropout = tf.keras.layers.Dropout(dropout)
+        self.head_dim = embed_dim // num_heads
+        if (self.head_dim * num_heads) != self.embed_dim:
+            raise ValueError(
+                f"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim}"
+                f" and `num_heads`: {num_heads})."
+            )
+        self.scaling = self.head_dim**-0.5
+        self.is_decoder = is_decoder
+
+        self.k_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name="k_proj")
+        self.q_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name="q_proj")
+        self.v_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name="v_proj")
+        self.out_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name="out_proj")
+
+    def _shape(self, tensor: tf.Tensor, seq_len: int, bsz: int):
+        return tf.transpose(tf.reshape(tensor, (bsz, seq_len, self.num_heads, self.head_dim)), (0, 2, 1, 3))
+
+    def call(
+        self,
+        hidden_states: tf.Tensor,
+        key_value_states: tf.Tensor | None = None,
+        past_key_value: Tuple[Tuple[tf.Tensor]] | None = None,
+        attention_mask: tf.Tensor | None = None,
+        layer_head_mask: tf.Tensor | None = None,
+        training: Optional[bool] = False,
+    ) -> Tuple[tf.Tensor, tf.Tensor | None]:
+        """Input shape: Batch x Time x Channel"""
+
+        # if key_value_states are provided this layer is used as a cross-attention layer
+        # for the decoder
+        is_cross_attention = key_value_states is not None
+        bsz, tgt_len, embed_dim = shape_list(hidden_states)
+
+        # get query proj
+        query_states = self.q_proj(hidden_states) * self.scaling
+        # get key, value proj
+        if is_cross_attention and past_key_value is not None:
+            # reuse k,v, cross_attentions
+            key_states = past_key_value[0]
+            value_states = past_key_value[1]
+        elif is_cross_attention:
+            # cross_attentions
+            key_states = self._shape(self.k_proj(key_value_states), -1, bsz)
+            value_states = self._shape(self.v_proj(key_value_states), -1, bsz)
+        elif past_key_value is not None:
+            # reuse k, v, self_attention
+            key_states = self._shape(self.k_proj(hidden_states), -1, bsz)
+            value_states = self._shape(self.v_proj(hidden_states), -1, bsz)
+            key_states = tf.concat([past_key_value[0], key_states], axis=2)
+            value_states = tf.concat([past_key_value[1], value_states], axis=2)
+        else:
+            # self_attention
+            key_states = self._shape(self.k_proj(hidden_states), -1, bsz)
+            value_states = self._shape(self.v_proj(hidden_states), -1, bsz)
+
+        if self.is_decoder:
+            # if cross_attention save Tuple(tf.Tensor, tf.Tensor) of all cross attention key/value_states.
+            # Further calls to cross_attention layer can then reuse all cross-attention
+            # key/value_states (first "if" case)
+            # if uni-directional self-attention (decoder) save Tuple(tf.Tensor, tf.Tensor) of
+            # all previous decoder key/value_states. Further calls to uni-directional self-attention
+            # can concat previous decoder key/value_states to current projected key/value_states (third "elif" case)
+            # if encoder bi-directional self-attention `past_key_value` is always `None`
+            past_key_value = (key_states, value_states)
+
+        proj_shape = (bsz * self.num_heads, -1, self.head_dim)
+        query_states = tf.reshape(self._shape(query_states, tgt_len, bsz), proj_shape)
+        key_states = tf.reshape(key_states, proj_shape)
+        value_states = tf.reshape(value_states, proj_shape)
+
+        src_len = shape_list(key_states)[1]
+        attn_weights = tf.matmul(query_states, key_states, transpose_b=True)
+
+        tf.debugging.assert_equal(
+            shape_list(attn_weights),
+            [bsz * self.num_heads, tgt_len, src_len],
+            message=(
+                f"Attention weights should be of size {(bsz * self.num_heads, tgt_len, src_len)}, but is"
+                f" {shape_list(attn_weights)}"
+            ),
+        )
+
+        if attention_mask is not None:
+            tf.debugging.assert_equal(
+                shape_list(attention_mask),
+                [bsz, 1, tgt_len, src_len],
+                message=(
+                    f"Attention mask should be of size {(bsz, 1, tgt_len, src_len)}, but is"
+                    f" {shape_list(attention_mask)}"
+                ),
+            )
+
+            attention_mask = tf.cast(attention_mask, dtype=attn_weights.dtype)
+            attn_weights = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) + attention_mask
+            attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len))
+
+        attn_weights = stable_softmax(attn_weights, axis=-1)
+
+        if layer_head_mask is not None:
+            tf.debugging.assert_equal(
+                shape_list(layer_head_mask),
+                [self.num_heads],
+                message=(
+                    f"Head mask for a single layer should be of size {(self.num_heads)}, but is"
+                    f" {shape_list(layer_head_mask)}"
+                ),
+            )
+
+            attn_weights = tf.reshape(layer_head_mask, (1, -1, 1, 1)) * tf.reshape(
+                attn_weights, (bsz, self.num_heads, tgt_len, src_len)
+            )
+            attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len))
+
+        attn_probs = self.dropout(attn_weights, training=training)
+        attn_output = tf.matmul(attn_probs, value_states)
+
+        tf.debugging.assert_equal(
+            shape_list(attn_output),
+            [bsz * self.num_heads, tgt_len, self.head_dim],
+            message=(
+                f"`attn_output` should be of size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but is"
+                f" {shape_list(attn_output)}"
+            ),
+        )
+
+        attn_output = tf.transpose(
+            tf.reshape(attn_output, (bsz, self.num_heads, tgt_len, self.head_dim)), (0, 2, 1, 3)
+        )
+        attn_output = tf.reshape(attn_output, (bsz, tgt_len, embed_dim))
+
+        attn_output = self.out_proj(attn_output)
+        attn_weights: tf.Tensor = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len))
+
+        return attn_output, attn_weights, past_key_value
+
+
+class TFBartEncoderLayer(tf.keras.layers.Layer):
+    def __init__(self, config: BartConfig, **kwargs):
+        super().__init__(**kwargs)
+        self.embed_dim = config.d_model
+        self.self_attn = TFBartAttention(
+            self.embed_dim, config.encoder_attention_heads, dropout=config.attention_dropout, name="self_attn"
+        )
+        self.self_attn_layer_norm = tf.keras.layers.LayerNormalization(epsilon=1e-5, name="self_attn_layer_norm")
+        self.dropout = tf.keras.layers.Dropout(config.dropout)
+        self.activation_fn = get_tf_activation(config.activation_function)
+        self.activation_dropout = tf.keras.layers.Dropout(config.activation_dropout)
+        self.fc1 = tf.keras.layers.Dense(config.encoder_ffn_dim, name="fc1")
+        self.fc2 = tf.keras.layers.Dense(self.embed_dim, name="fc2")
+        self.final_layer_norm = tf.keras.layers.LayerNormalization(epsilon=1e-5, name="final_layer_norm")
+
+    def call(
+        self,
+        hidden_states: tf.Tensor,
+        attention_mask: np.ndarray | tf.Tensor | None,
+        layer_head_mask: tf.Tensor | None,
+        training: Optional[bool] = False,
+    ) -> tf.Tensor:
+        """
+        Args:
+            hidden_states (`tf.Tensor`): input to the layer of shape `(batch, seq_len, embed_dim)`
+            attention_mask (`tf.Tensor`): attention mask of size
+                `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values.
+            layer_head_mask (`tf.Tensor`): mask for attention heads in a given layer of size
+                `(encoder_attention_heads,)`
+        """
+        residual = hidden_states
+        hidden_states, self_attn_weights, _ = self.self_attn(
+            hidden_states=hidden_states, attention_mask=attention_mask, layer_head_mask=layer_head_mask
+        )
+
+        tf.debugging.assert_equal(
+            shape_list(hidden_states),
+            shape_list(residual),
+            message=f"Self attn modified the shape of query {shape_list(residual)} to {shape_list(hidden_states)}",
+        )
+
+        hidden_states = self.dropout(hidden_states, training=training)
+        hidden_states = residual + hidden_states
+        hidden_states = self.self_attn_layer_norm(hidden_states)
+
+        residual = hidden_states
+        hidden_states = self.activation_fn(self.fc1(hidden_states))
+        hidden_states = self.activation_dropout(hidden_states, training=training)
+        hidden_states = self.fc2(hidden_states)
+        hidden_states = self.dropout(hidden_states, training=training)
+        hidden_states = residual + hidden_states
+        hidden_states = self.final_layer_norm(hidden_states)
+
+        return hidden_states, self_attn_weights
+
+
+class TFBartDecoderLayer(tf.keras.layers.Layer):
+    def __init__(self, config: BartConfig, **kwargs):
+        super().__init__(**kwargs)
+        self.embed_dim = config.d_model
+        self.self_attn = TFBartAttention(
+            embed_dim=self.embed_dim,
+            num_heads=config.decoder_attention_heads,
+            dropout=config.attention_dropout,
+            name="self_attn",
+            is_decoder=True,
+        )
+        self.dropout = tf.keras.layers.Dropout(config.dropout)
+        self.activation_fn = get_tf_activation(config.activation_function)
+        self.activation_dropout = tf.keras.layers.Dropout(config.activation_dropout)
+
+        self.self_attn_layer_norm = tf.keras.layers.LayerNormalization(epsilon=1e-5, name="self_attn_layer_norm")
+        self.encoder_attn = TFBartAttention(
+            self.embed_dim,
+            config.decoder_attention_heads,
+            dropout=config.attention_dropout,
+            name="encoder_attn",
+            is_decoder=True,
+        )
+        self.encoder_attn_layer_norm = tf.keras.layers.LayerNormalization(epsilon=1e-5, name="encoder_attn_layer_norm")
+        self.fc1 = tf.keras.layers.Dense(config.decoder_ffn_dim, name="fc1")
+        self.fc2 = tf.keras.layers.Dense(self.embed_dim, name="fc2")
+        self.final_layer_norm = tf.keras.layers.LayerNormalization(epsilon=1e-5, name="final_layer_norm")
+
+    def call(
+        self,
+        hidden_states: tf.Tensor,
+        attention_mask: np.ndarray | tf.Tensor | None = None,
+        encoder_hidden_states: np.ndarray | tf.Tensor | None = None,
+        encoder_attention_mask: np.ndarray | tf.Tensor | None = None,
+        layer_head_mask: tf.Tensor | None = None,
+        cross_attn_layer_head_mask: tf.Tensor | None = None,
+        past_key_value: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None,
+        training: Optional[bool] = False,
+    ) -> Tuple[tf.Tensor, tf.Tensor, Tuple[Tuple[tf.Tensor]]]:
+        """
+        Args:
+            hidden_states (`tf.Tensor`): input to the layer of shape `(batch, seq_len, embed_dim)`
+            attention_mask (`tf.Tensor`): attention mask of size
+                `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values.
+            encoder_hidden_states (`tf.Tensor`):
+                cross attention input to the layer of shape `(batch, seq_len, embed_dim)`
+            encoder_attention_mask (`tf.Tensor`): encoder attention mask of size
+                `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values.
+            layer_head_mask (`tf.Tensor`): mask for attention heads in a given layer of size
+                `(decoder_attention_heads,)`
+            cross_attn_layer_head_mask (`tf.Tensor`): mask for heads of the cross-attention module.
+                `(decoder_attention_heads,)`
+            past_key_value (`Tuple(tf.Tensor)`): cached past key and value projection states
+        """
+        residual = hidden_states
+
+        # Self Attention
+        # decoder uni-directional self-attention cached key/values tuple is at positions 1,2
+        self_attn_past_key_value = past_key_value[:2] if past_key_value is not None else None
+        # add present self-attn cache to positions 1,2 of present_key_value tuple
+        hidden_states, self_attn_weights, present_key_value = self.self_attn(
+            hidden_states=hidden_states,
+            past_key_value=self_attn_past_key_value,
+            attention_mask=attention_mask,
+            layer_head_mask=layer_head_mask,
+        )
+        hidden_states = self.dropout(hidden_states, training=training)
+        hidden_states = residual + hidden_states
+        hidden_states = self.self_attn_layer_norm(hidden_states)
+
+        # Cross-Attention Block
+        cross_attn_present_key_value = None
+        cross_attn_weights = None
+        if encoder_hidden_states is not None:
+            residual = hidden_states
+
+            # cross_attn cached key/values tuple is at positions 3,4 of present_key_value tuple
+            cross_attn_past_key_value = past_key_value[-2:] if past_key_value is not None else None
+            hidden_states, cross_attn_weights, cross_attn_present_key_value = self.encoder_attn(
+                hidden_states=hidden_states,
+                key_value_states=encoder_hidden_states,
+                attention_mask=encoder_attention_mask,
+                layer_head_mask=cross_attn_layer_head_mask,
+                past_key_value=cross_attn_past_key_value,
+            )
+            hidden_states = self.dropout(hidden_states, training=training)
+            hidden_states = residual + hidden_states
+            hidden_states = self.encoder_attn_layer_norm(hidden_states)
+
+            # add cross-attn to positions 3,4 of present_key_value tuple
+            present_key_value = present_key_value + cross_attn_present_key_value
+
+        # Fully Connected
+        residual = hidden_states
+        hidden_states = self.activation_fn(self.fc1(hidden_states))
+        hidden_states = self.activation_dropout(hidden_states, training=training)
+        hidden_states = self.fc2(hidden_states)
+        hidden_states = self.dropout(hidden_states, training=training)
+        hidden_states = residual + hidden_states
+        hidden_states = self.final_layer_norm(hidden_states)
+
+        return (
+            hidden_states,
+            self_attn_weights,
+            cross_attn_weights,
+            present_key_value,
+        )
+
+
+class TFBartClassificationHead(tf.keras.layers.Layer):
+    """Head for sentence-level classification tasks."""
+
+    def __init__(self, inner_dim: int, num_classes: int, pooler_dropout: float, name: str, **kwargs):
+        super().__init__(name=name, **kwargs)
+        self.dense = tf.keras.layers.Dense(inner_dim, name="dense")
+        self.dropout = tf.keras.layers.Dropout(pooler_dropout)
+        self.out_proj = tf.keras.layers.Dense(num_classes, name="out_proj")
+
+    def call(self, inputs):
+        hidden_states = self.dropout(inputs)
+        hidden_states = self.dense(hidden_states)
+        hidden_states = tf.keras.activations.tanh(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        hidden_states = self.out_proj(hidden_states)
+        return hidden_states
+
+
+class TFBartPretrainedModel(TFPreTrainedModel):
+    config_class = BartConfig
+    base_model_prefix = "model"
+
+    @property
+    def dummy_inputs(self):
+        dummy_inputs = super().dummy_inputs
+        # Dummy inputs should not contain the default val of 1
+        # as this is the padding token and some assertions check it
+        dummy_inputs["input_ids"] = dummy_inputs["input_ids"] * 2
+        if "decoder_input_ids" in dummy_inputs:
+            dummy_inputs["decoder_input_ids"] = dummy_inputs["decoder_input_ids"] * 2
+        return dummy_inputs
+
+
+BART_START_DOCSTRING = r"""
+    This model inherits from [`TFPreTrainedModel`]. Check the superclass documentation for the generic methods the
+    library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
+    etc.)
+
+    This model is also a [tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) subclass. Use it
+    as a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and
+    behavior.
+
+    <Tip>
+
+    TensorFlow models and layers in `transformers` accept two formats as input:
+
+    - having all inputs as keyword arguments (like PyTorch models), or
+    - having all inputs as a list, tuple or dict in the first positional argument.
+
+    The reason the second format is supported is that Keras methods prefer this format when passing inputs to models
+    and layers. Because of this support, when using methods like `model.fit()` things should "just work" for you - just
+    pass your inputs and labels in any format that `model.fit()` supports! If, however, you want to use the second
+    format outside of Keras methods like `fit()` and `predict()`, such as when creating your own layers or models with
+    the Keras `Functional` API, there are three possibilities you can use to gather all the input Tensors in the first
+    positional argument:
+
+    - a single Tensor with `input_ids` only and nothing else: `model(input_ids)`
+    - a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
+    `model([input_ids, attention_mask])` or `model([input_ids, attention_mask, token_type_ids])`
+    - a dictionary with one or several input Tensors associated to the input names given in the docstring:
+    `model({"input_ids": input_ids, "token_type_ids": token_type_ids})`
+
+    Note that when creating models and layers with
+    [subclassing](https://keras.io/guides/making_new_layers_and_models_via_subclassing/) then you don't need to worry
+    about any of this, as you can just pass inputs like you would to any other Python function!
+
+    </Tip>
+
+    Args:
+        config ([`BartConfig`]): Model configuration class with all the parameters of the model.
+            Initializing with a config file does not load the weights associated with the model, only the
+            configuration. Check out the [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.
+"""
+
+
+BART_GENERATION_EXAMPLE = r"""
+    Summarization example:
+
+    ```python
+    >>> from transformers import AutoTokenizer, TFBartForConditionalGeneration
+
+    >>> model = TFBartForConditionalGeneration.from_pretrained("facebook/bart-large")
+    >>> tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large")
+
+    >>> ARTICLE_TO_SUMMARIZE = "My friends are cool but they eat too many carbs."
+    >>> inputs = tokenizer([ARTICLE_TO_SUMMARIZE], max_length=1024, return_tensors="tf")
+
+    >>> # Generate Summary
+    >>> summary_ids = model.generate(inputs["input_ids"], num_beams=4, max_length=5)
+    >>> print(tokenizer.batch_decode(summary_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False))
+    ```
+
+    Mask filling example:
+
+    ```python
+    >>> from transformers import AutoTokenizer, TFBartForConditionalGeneration
+
+    >>> tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large")
+    >>> TXT = "My friends are <mask> but they eat too many carbs."
+
+    >>> model = TFBartForConditionalGeneration.from_pretrained("facebook/bart-large")
+    >>> input_ids = tokenizer([TXT], return_tensors="tf")["input_ids"]
+    >>> logits = model(input_ids).logits
+    >>> probs = tf.nn.softmax(logits[0])
+    >>> # probs[5] is associated with the mask token
+    ```
+"""
+
+
+BART_INPUTS_DOCSTRING = r"""
+    Args:
+        input_ids (`tf.Tensor` of shape `({0})`):
+            Indices of input sequence tokens in the vocabulary.
+
+            Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+            [`PreTrainedTokenizer.__call__`] for details.
+
+            [What are input IDs?](../glossary#input-ids)
+        attention_mask (`tf.Tensor` of shape `({0})`, *optional*):
+            Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
+
+            - 1 for tokens that are **not masked**,
+            - 0 for tokens that are **masked**.
+
+            [What are attention masks?](../glossary#attention-mask)
+        decoder_input_ids (`tf.Tensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+            Indices of decoder input sequence tokens in the vocabulary.
+
+            Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+            [`PreTrainedTokenizer.__call__`] for details.
+
+            [What are decoder input IDs?](../glossary#decoder-input-ids)
+
+            Bart uses the `eos_token_id` as the starting token for `decoder_input_ids` generation. If `past_key_values`
+            is used, optionally only the last `decoder_input_ids` have to be input (see `past_key_values`).
+
+            For translation and summarization training, `decoder_input_ids` should be provided. If no
+            `decoder_input_ids` is provided, the model will create this tensor by shifting the `input_ids` to the right
+            for denoising pre-training following the paper.
+        decoder_attention_mask (`tf.Tensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+            will be made by default and ignore pad tokens. It is not recommended to set this for most use cases.
+        decoder_position_ids (`tf.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+            Indices of positions of each decoder input sequence tokens in the position embeddings. Selected in the
+            range `[0, config.max_position_embeddings - 1]`.
+        head_mask (`tf.Tensor` of shape `(encoder_layers, encoder_attention_heads)`, *optional*):
+            Mask to nullify selected heads of the attention modules in the encoder. Mask values selected in `[0, 1]`:
+
+            - 1 indicates the head is **not masked**,
+            - 0 indicates the head is **masked**.
+
+        decoder_head_mask (`tf.Tensor` of shape `(decoder_layers, decoder_attention_heads)`, *optional*):
+            Mask to nullify selected heads of the attention modules in the decoder. Mask values selected in `[0, 1]`:
+
+            - 1 indicates the head is **not masked**,
+            - 0 indicates the head is **masked**.
+
+        cross_attn_head_mask (`tf.Tensor` of shape `(decoder_layers, decoder_attention_heads)`, *optional*):
+            Mask to nullify selected heads of the cross-attention modules. Mask values selected in `[0, 1]`:
+
+            - 1 indicates the head is **not masked**,
+            - 0 indicates the head is **masked**.
+
+        encoder_outputs (`tf.FloatTensor`, *optional*):
+            hidden states at the output of the last layer of the encoder. Used in the cross-attention of the decoder.
+            of shape `(batch_size, sequence_length, hidden_size)` is a sequence of
+        past_key_values (`Tuple[Tuple[tf.Tensor]]` of length `config.n_layers`)
+            contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.
+            If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that
+            don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all
+            `decoder_input_ids` of shape `(batch_size, sequence_length)`.
+        use_cache (`bool`, *optional*, defaults to `True`):
+            If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
+            `past_key_values`). Set to `False` during training, `True` during generation
+        output_attentions (`bool`, *optional*):
+            Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
+            tensors for more detail. This argument can be used only in eager mode, in graph mode the value in the
+            config will be used instead.
+        output_hidden_states (`bool`, *optional*):
+            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
+            more detail. This argument can be used only in eager mode, in graph mode the value in the config will be
+            used instead.
+        return_dict (`bool`, *optional*):
+            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple. This argument can be used in
+            eager mode, in graph mode the value will always be set to True.
+        training (`bool`, *optional*, defaults to `False`):
+            Whether or not to use the model in training mode (some modules like dropout modules have different
+            behaviors between training and evaluation).
+"""
+
+
+@keras_serializable
+class TFBartEncoder(tf.keras.layers.Layer):
+    config_class = BartConfig
+    """
+    Transformer encoder consisting of *config.encoder_layers* self attention layers. Each layer is a
+    [`TFBartEncoderLayer`].
+
+    Args:
+        config: BartConfig
+    """
+
+    def __init__(self, config: BartConfig, embed_tokens: Optional[tf.keras.layers.Embedding] = None, **kwargs):
+        super().__init__(**kwargs)
+        self.config = config
+        self.dropout = tf.keras.layers.Dropout(config.dropout)
+        self.layerdrop = config.encoder_layerdrop
+        self.padding_idx = config.pad_token_id
+        self.max_source_positions = config.max_position_embeddings
+        self.embed_scale = tf.math.sqrt(float(config.d_model)) if config.scale_embedding else 1.0
+
+        self.embed_tokens = embed_tokens
+        self.embed_positions = TFBartLearnedPositionalEmbedding(
+            config.max_position_embeddings,
+            config.d_model,
+            name="embed_positions",
+        )
+        self.layers = [TFBartEncoderLayer(config, name=f"layers.{i}") for i in range(config.encoder_layers)]
+        self.layernorm_embedding = tf.keras.layers.LayerNormalization(epsilon=1e-5, name="layernorm_embedding")
+
+    @unpack_inputs
+    def call(
+        self,
+        input_ids: TFModelInputType | None = None,
+        inputs_embeds: np.ndarray | tf.Tensor | None = None,
+        attention_mask: np.ndarray | tf.Tensor | None = None,
+        head_mask: np.ndarray | tf.Tensor | None = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        training: Optional[bool] = False,
+    ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]:
+        """
+        Args:
+            input_ids (`tf.Tensor` of shape `(batch_size, sequence_length)`):
+                Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you
+                provide it.
+
+                Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+                [`PreTrainedTokenizer.__call__`] for details.
+
+                [What are input IDs?](../glossary#input-ids)
+            attention_mask (`tf.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+                Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
+
+                - 1 for tokens that are **not masked**,
+                - 0 for tokens that are **masked**.
+
+                [What are attention masks?](../glossary#attention-mask)
+            head_mask (`tf.Tensor` of shape `(encoder_layers, encoder_attention_heads)`, `optional):
+                Mask to nullify selected heads of the attention modules. Mask values selected in `[0, 1]`:
+
+                - 1 indicates the head is **not masked**,
+                - 0 indicates the head is **masked**.
+
+            inputs_embeds (`tf.Tensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
+                Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation.
+                This is useful if you want more control over how to convert `input_ids` indices into associated vectors
+                than the model's internal embedding lookup matrix.
+            output_attentions (`bool`, *optional*):
+                Whether or not to return the attentions tensors of all attention layers. See `attentions` under
+                returned tensors for more detail.
+            output_hidden_states (`bool`, *optional*):
+                Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
+                for more detail.
+            return_dict (`bool`, *optional*):
+                Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+        """
+        if input_ids is not None and inputs_embeds is not None:
+            raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
+        elif input_ids is not None:
+            input_shape = shape_list(input_ids)
+        elif inputs_embeds is not None:
+            input_shape = shape_list(inputs_embeds)[:-1]
+        else:
+            raise ValueError("You have to specify either input_ids or inputs_embeds")
+
+        if inputs_embeds is None:
+            # if `self.embed_tokens.load_weight_prefix` is set, runs the embedding operation with the correct name
+            # scope, so that its weights are registered with the desired name for loading/storing. When `tf.name_scope`
+            # is used with a name ending in `/`, that name replaces the current name scope.
+            # (embeddings with tf.name_scope: self.embed_tokens.load_weight_prefix/self.embed_tokens.name/embeddings:0)
+            context = []
+            if hasattr(self.embed_tokens, "load_weight_prefix"):
+                context.append(tf.name_scope(self.embed_tokens.load_weight_prefix + "/"))
+            with ContextManagers(context):
+                check_embeddings_within_bounds(input_ids, self.embed_tokens.input_dim)
+                inputs_embeds = self.embed_tokens(input_ids) * self.embed_scale
+
+        embed_pos = self.embed_positions(input_shape)
+        hidden_states = inputs_embeds + embed_pos
+        hidden_states = self.layernorm_embedding(hidden_states)
+        hidden_states = self.dropout(hidden_states, training=training)
+
+        # check attention mask and invert
+        if attention_mask is not None:
+            # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
+            attention_mask = _expand_mask(attention_mask)
+        else:
+            attention_mask = None
+
+        encoder_states = () if output_hidden_states else None
+        all_attentions = () if output_attentions else None
+
+        # check if head_mask has a correct number of layers specified if desired
+        if head_mask is not None:
+            tf.debugging.assert_equal(
+                shape_list(head_mask)[0],
+                len(self.layers),
+                message=(
+                    f"The head_mask should be specified for {len(self.layers)} layers, but it is for"
+                    f" {shape_list(head_mask)[0]}."
+                ),
+            )
+
+        # encoder layers
+        for idx, encoder_layer in enumerate(self.layers):
+            if output_hidden_states:
+                encoder_states = encoder_states + (hidden_states,)
+            # add LayerDrop (see https://arxiv.org/abs/1909.11556 for description)
+            dropout_probability = random.uniform(0, 1)
+            if training and (dropout_probability < self.layerdrop):  # skip the layer
+                continue
+
+            hidden_states, attn = encoder_layer(
+                hidden_states,
+                attention_mask,
+                head_mask[idx] if head_mask is not None else None,
+            )
+
+            if output_attentions:
+                all_attentions += (attn,)
+
+        if output_hidden_states:
+            encoder_states = encoder_states + (hidden_states,)
+
+        if not return_dict:
+            return tuple(v for v in [hidden_states, encoder_states, all_attentions] if v is not None)
+        return TFBaseModelOutput(
+            last_hidden_state=hidden_states, hidden_states=encoder_states, attentions=all_attentions
+        )
+
+
+@keras_serializable
+class TFBartDecoder(tf.keras.layers.Layer):
+    config_class = BartConfig
+    """
+    Transformer decoder consisting of *config.decoder_layers* layers. Each layer is a [`TFBartDecoderLayer`]
+
+    Args:
+        config: BartConfig
+        embed_tokens: output embedding
+    """
+
+    def __init__(self, config: BartConfig, embed_tokens: Optional[tf.keras.layers.Embedding] = None, **kwargs):
+        super().__init__(**kwargs)
+        self.config = config
+        self.padding_idx = config.pad_token_id
+        self.embed_tokens = embed_tokens
+        self.layerdrop = config.decoder_layerdrop
+        self.embed_positions = TFBartLearnedPositionalEmbedding(
+            config.max_position_embeddings,
+            config.d_model,
+            name="embed_positions",
+        )
+        self.embed_scale = tf.math.sqrt(float(config.d_model)) if config.scale_embedding else 1.0
+        self.layers = [TFBartDecoderLayer(config, name=f"layers.{i}") for i in range(config.decoder_layers)]
+        self.layernorm_embedding = tf.keras.layers.LayerNormalization(epsilon=1e-5, name="layernorm_embedding")
+
+        self.dropout = tf.keras.layers.Dropout(config.dropout)
+
+    @unpack_inputs
+    def call(
+        self,
+        input_ids: TFModelInputType | None = None,
+        inputs_embeds: np.ndarray | tf.Tensor | None = None,
+        attention_mask: np.ndarray | tf.Tensor | None = None,
+        position_ids: np.ndarray | tf.Tensor | None = None,
+        encoder_hidden_states: np.ndarray | tf.Tensor | None = None,
+        encoder_attention_mask: np.ndarray | tf.Tensor | None = None,
+        head_mask: np.ndarray | tf.Tensor | None = None,
+        cross_attn_head_mask: np.ndarray | tf.Tensor | None = None,
+        past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        training: Optional[bool] = False,
+    ) -> Union[TFBaseModelOutputWithPastAndCrossAttentions, Tuple[tf.Tensor]]:
+        r"""
+        Args:
+            input_ids (`tf.Tensor` of shape `(batch_size, sequence_length)`):
+                Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you
+                provide it.
+
+                Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+                [`PreTrainedTokenizer.__call__`] for details.
+
+                [What are input IDs?](../glossary#input-ids)
+            attention_mask (`tf.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+                Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
+
+                - 1 for tokens that are **not masked**,
+                - 0 for tokens that are **masked**.
+
+                [What are attention masks?](../glossary#attention-mask)
+            position_ids (`tf.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+                Indices of positions of each decoder input sequence tokens in the position embeddings. Selected in the
+                range `[0, config.max_position_embeddings - 1]`.
+            encoder_hidden_states (`tf.Tensor` of shape `(batch_size, encoder_sequence_length, hidden_size)`, *optional*):
+                Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention
+                of the decoder.
+            encoder_attention_mask (`tf.Tensor` of shape `(batch_size, encoder_sequence_length)`, *optional*):
+                Mask to avoid performing cross-attention on padding tokens indices of encoder input_ids. Mask values
+                selected in `[0, 1]`:
+
+                - 1 for tokens that are **not masked**,
+                - 0 for tokens that are **masked**.
+
+                [What are attention masks?](../glossary#attention-mask)
+            head_mask (`tf.Tensor` of shape `(decoder_layers, decoder_attention_heads)`, *optional*):
+                Mask to nullify selected heads of the attention modules. Mask values selected in `[0, 1]`:
+
+                - 1 indicates the head is **not masked**,
+                - 0 indicates the head is **masked**.
+
+            cross_attn_head_mask (`tf.Tensor` of shape `(decoder_layers, decoder_attention_heads)`, *optional*):
+                Mask to nullify selected heads of the cross-attention modules. Mask values selected in `[0, 1]`:
+
+                - 1 indicates the head is **not masked**,
+                - 0 indicates the head is **masked**.
+
+            past_key_values (`Tuple[Tuple[tf.Tensor]]` of length `config.n_layers` with each tuple having 2 tuples each of which has 2 tensors of shape `(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`):
+                Contains precomputed key and value hidden-states of the attention blocks. Can be used to speed up
+                decoding.
+
+                If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those
+                that don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of
+                all `decoder_input_ids` of shape `(batch_size, sequence_length)`. inputs_embeds (`tf.Tensor` of shape
+                `(batch_size, sequence_length, hidden_size)`, *optional*): Optionally, instead of passing `input_ids`
+                you can choose to directly pass an embedded representation. This is useful if you want more control
+                over how to convert `input_ids` indices into associated vectors than the model's internal embedding
+                lookup matrix.
+            output_attentions (`bool`, *optional*):
+                Whether or not to return the attentions tensors of all attention layers. See `attentions` under
+                returned tensors for more detail.
+            output_hidden_states (`bool`, *optional*):
+                Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
+                for more detail.
+            return_dict (`bool`, *optional*):
+                Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+        """
+
+        if input_ids is not None and inputs_embeds is not None:
+            raise ValueError("You cannot specify both decoder_input_ids and decoder_inputs_embeds at the same time")
+        elif input_ids is not None:
+            input_shape = shape_list(input_ids)
+        elif inputs_embeds is not None:
+            input_shape = shape_list(inputs_embeds)[:-1]
+        else:
+            raise ValueError("You have to specify either decoder_input_ids or decoder_inputs_embeds")
+
+        past_key_values_length = shape_list(past_key_values[0][0])[2] if past_key_values is not None else 0
+
+        # embed positions
+        if position_ids is None:
+            positions = self.embed_positions(input_shape, past_key_values_length)
+        else:
+            positions = self.embed_positions(input_shape, position_ids=position_ids)
+
+        if inputs_embeds is None:
+            # if `self.embed_tokens.load_weight_prefix` is set, runs the embedding operation with the correct name
+            # scope, so that its weights are registered with the desired name for loading/storing. When `tf.name_scope`
+            # is used with a name ending in `/`, that name replaces the current name scope.
+            # (embeddings with tf.name_scope: self.embed_tokens.load_weight_prefix/self.embed_tokens.name/embeddings:0)
+            context = []
+            if hasattr(self.embed_tokens, "load_weight_prefix"):
+                context.append(tf.name_scope(self.embed_tokens.load_weight_prefix + "/"))
+            with ContextManagers(context):
+                check_embeddings_within_bounds(input_ids, self.embed_tokens.input_dim)
+                inputs_embeds = self.embed_tokens(input_ids) * self.embed_scale
+
+        hidden_states = inputs_embeds
+
+        # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
+        if input_shape[-1] > 1:
+            combined_attention_mask = _make_causal_mask(input_shape, past_key_values_length=past_key_values_length)
+        else:
+            combined_attention_mask = _expand_mask(
+                tf.ones((input_shape[0], input_shape[1] + past_key_values_length)), tgt_len=input_shape[-1]
+            )
+
+        if attention_mask is not None:
+            combined_attention_mask = combined_attention_mask + _expand_mask(attention_mask, tgt_len=input_shape[-1])
+
+        if encoder_hidden_states is not None and encoder_attention_mask is not None:
+            # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
+            encoder_attention_mask = _expand_mask(encoder_attention_mask, tgt_len=input_shape[-1])
+
+        hidden_states = self.layernorm_embedding(hidden_states + positions)
+        hidden_states = self.dropout(hidden_states, training=training)
+
+        # decoder layers
+        all_hidden_states = () if output_hidden_states else None
+        all_self_attns = () if output_attentions else None
+        all_cross_attns = () if (output_attentions and encoder_hidden_states is not None) else None
+        present_key_values = () if use_cache else None
+
+        # check if head_mask and cross_attn_head_mask have a correct number of layers specified if desired
+        for attn_mask_name, attn_mask in [("head_mask", head_mask), ("cross_attn_head_mask", cross_attn_head_mask)]:
+            if attn_mask is not None:
+                tf.debugging.assert_equal(
+                    shape_list(attn_mask)[0],
+                    len(self.layers),
+                    message=(
+                        f"The {attn_mask_name} should be specified for {len(self.layers)} layers, but it is for"
+                        f" {shape_list(attn_mask)[0]}."
+                    ),
+                )
+
+        for idx, decoder_layer in enumerate(self.layers):
+            # add LayerDrop (see https://arxiv.org/abs/1909.11556 for description)
+            if output_hidden_states:
+                all_hidden_states += (hidden_states,)
+
+            dropout_probability = random.uniform(0, 1)
+
+            if training and (dropout_probability < self.layerdrop):
+                continue
+
+            past_key_value = past_key_values[idx] if past_key_values is not None else None
+
+            hidden_states, layer_self_attn, layer_cross_attn, present_key_value = decoder_layer(
+                hidden_states,
+                attention_mask=combined_attention_mask,
+                encoder_hidden_states=encoder_hidden_states,
+                encoder_attention_mask=encoder_attention_mask,
+                layer_head_mask=head_mask[idx] if head_mask is not None else None,
+                cross_attn_layer_head_mask=cross_attn_head_mask[idx] if cross_attn_head_mask is not None else None,
+                past_key_value=past_key_value,
+            )
+
+            if use_cache:
+                present_key_values += (present_key_value,)
+
+            if output_attentions:
+                all_self_attns += (layer_self_attn,)
+
+                if encoder_hidden_states is not None:
+                    all_cross_attns += (layer_cross_attn,)
+
+        if output_hidden_states:
+            all_hidden_states += (hidden_states,)
+
+        if not return_dict:
+            return hidden_states, present_key_values, all_hidden_states, all_self_attns, all_cross_attns
+        else:
+            return TFBaseModelOutputWithPastAndCrossAttentions(
+                last_hidden_state=hidden_states,
+                past_key_values=present_key_values,
+                hidden_states=all_hidden_states,
+                attentions=all_self_attns,
+                cross_attentions=all_cross_attns,
+            )
+
+
+@keras_serializable
+class TFBartMainLayer(tf.keras.layers.Layer):
+    config_class = BartConfig
+
+    def __init__(self, config: BartConfig, load_weight_prefix=None, **kwargs):
+        super().__init__(**kwargs)
+        self.config = config
+        self.shared = tf.keras.layers.Embedding(
+            input_dim=config.vocab_size,
+            output_dim=config.d_model,
+            embeddings_initializer=tf.keras.initializers.TruncatedNormal(stddev=self.config.init_std),
+            name="model.shared",
+        )
+        # Additional attribute to specify the expected name scope of the layer (for loading/storing weights)
+        self.shared.load_weight_prefix = "model.shared" if load_weight_prefix is None else load_weight_prefix
+
+        self.encoder = TFBartEncoder(config, self.shared, name="encoder")
+        self.decoder = TFBartDecoder(config, self.shared, name="decoder")
+
+    def get_input_embeddings(self):
+        return self.shared
+
+    def set_input_embeddings(self, new_embeddings):
+        self.shared = new_embeddings
+        self.encoder.embed_tokens = self.shared
+        self.decoder.embed_tokens = self.shared
+
+    @unpack_inputs
+    def call(
+        self,
+        input_ids: TFModelInputType | None = None,
+        attention_mask: np.ndarray | tf.Tensor | None = None,
+        decoder_input_ids: np.ndarray | tf.Tensor | None = None,
+        decoder_attention_mask: np.ndarray | tf.Tensor | None = None,
+        decoder_position_ids: np.ndarray | tf.Tensor | None = None,
+        head_mask: np.ndarray | tf.Tensor | None = None,
+        decoder_head_mask: np.ndarray | tf.Tensor | None = None,
+        cross_attn_head_mask: np.ndarray | tf.Tensor | None = None,
+        encoder_outputs: Optional[Union[Tuple, TFBaseModelOutput]] = None,
+        past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None,
+        inputs_embeds: np.ndarray | tf.Tensor | None = None,
+        decoder_inputs_embeds: np.ndarray | tf.Tensor | None = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        training: Optional[bool] = False,
+        **kwargs,
+    ) -> Union[TFSeq2SeqModelOutput, Tuple[tf.Tensor]]:
+        # different to other models, Bart automatically creates decoder_input_ids from
+        # input_ids if no decoder_input_ids are provided
+        if decoder_input_ids is None and decoder_inputs_embeds is None:
+            if input_ids is None:
+                raise ValueError(
+                    "If no `decoder_input_ids` or `decoder_inputs_embeds` are "
+                    "passed, `input_ids` cannot be `None`. Please pass either "
+                    "`input_ids` or `decoder_input_ids` or `decoder_inputs_embeds`."
+                )
+
+            decoder_input_ids = shift_tokens_right(
+                input_ids, self.config.pad_token_id, self.config.decoder_start_token_id
+            )
+
+        if encoder_outputs is None:
+            encoder_outputs = self.encoder(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                head_mask=head_mask,
+                inputs_embeds=inputs_embeds,
+                output_attentions=output_attentions,
+                output_hidden_states=output_hidden_states,
+                return_dict=return_dict,
+                training=training,
+            )
+        # If the user passed a tuple for encoder_outputs, we wrap it in a TFBaseModelOutput when return_dict=True
+        elif return_dict and not isinstance(encoder_outputs, TFBaseModelOutput):
+            encoder_outputs = TFBaseModelOutput(
+                last_hidden_state=encoder_outputs[0],
+                hidden_states=encoder_outputs[1] if len(encoder_outputs) > 1 else None,
+                attentions=encoder_outputs[2] if len(encoder_outputs) > 2 else None,
+            )
+        # If the user passed a TFBaseModelOutput for encoder_outputs, we wrap it in a tuple when return_dict=False
+        elif not return_dict and not isinstance(encoder_outputs, tuple):
+            encoder_outputs = encoder_outputs.to_tuple()
+
+        decoder_outputs = self.decoder(
+            decoder_input_ids,
+            attention_mask=decoder_attention_mask,
+            position_ids=decoder_position_ids,
+            encoder_hidden_states=encoder_outputs[0],
+            encoder_attention_mask=attention_mask,
+            head_mask=decoder_head_mask,
+            cross_attn_head_mask=cross_attn_head_mask,
+            past_key_values=past_key_values,
+            inputs_embeds=decoder_inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            training=training,
+        )
+
+        if not return_dict:
+            return decoder_outputs + encoder_outputs
+
+        return TFSeq2SeqModelOutput(
+            last_hidden_state=decoder_outputs.last_hidden_state,
+            past_key_values=decoder_outputs.past_key_values,
+            decoder_hidden_states=decoder_outputs.hidden_states,
+            decoder_attentions=decoder_outputs.attentions,
+            cross_attentions=decoder_outputs.cross_attentions,
+            encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+            encoder_hidden_states=encoder_outputs.hidden_states,
+            encoder_attentions=encoder_outputs.attentions,
+        )
+
+
+@add_start_docstrings(
+    "The bare BART Model outputting raw hidden-states without any specific head on top.",
+    BART_START_DOCSTRING,
+)
+class TFBartModel(TFBartPretrainedModel):
+    _requires_load_weight_prefix = True
+
+    def __init__(self, config: BartConfig, load_weight_prefix=None, *inputs, **kwargs):
+        super().__init__(config, *inputs, **kwargs)
+
+        self.model = TFBartMainLayer(config, load_weight_prefix=load_weight_prefix, name="model")
+
+    def get_encoder(self):
+        return self.model.encoder
+
+    def get_decoder(self):
+        return self.model.decoder
+
+    @add_start_docstrings_to_model_forward(BART_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
+    @add_code_sample_docstrings(
+        checkpoint=_CHECKPOINT_FOR_DOC,
+        output_type=TFSeq2SeqModelOutput,
+        config_class=_CONFIG_FOR_DOC,
+    )
+    @unpack_inputs
+    def call(
+        self,
+        input_ids: TFModelInputType | None = None,
+        attention_mask: np.ndarray | tf.Tensor | None = None,
+        decoder_input_ids: np.ndarray | tf.Tensor | None = None,
+        decoder_attention_mask: np.ndarray | tf.Tensor | None = None,
+        decoder_position_ids: np.ndarray | tf.Tensor | None = None,
+        head_mask: np.ndarray | tf.Tensor | None = None,
+        decoder_head_mask: np.ndarray | tf.Tensor | None = None,
+        cross_attn_head_mask: np.ndarray | tf.Tensor | None = None,
+        encoder_outputs: Optional[Union[Tuple, TFBaseModelOutput]] = None,
+        past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None,
+        inputs_embeds: np.ndarray | tf.Tensor | None = None,
+        decoder_inputs_embeds: np.ndarray | tf.Tensor | None = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        training: Optional[bool] = False,
+        **kwargs,
+    ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]:
+        outputs = self.model(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            decoder_input_ids=decoder_input_ids,
+            decoder_attention_mask=decoder_attention_mask,
+            decoder_position_ids=decoder_position_ids,
+            head_mask=head_mask,
+            decoder_head_mask=decoder_head_mask,
+            cross_attn_head_mask=cross_attn_head_mask,
+            encoder_outputs=encoder_outputs,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            decoder_inputs_embeds=decoder_inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            training=training,
+        )
+
+        return outputs
+
+    def serving_output(self, output):
+        pkv = tf.tuple(output.past_key_values)[1] if self.config.use_cache else None
+        dec_hs = tf.convert_to_tensor(output.decoder_hidden_states) if self.config.output_hidden_states else None
+        dec_attns = tf.convert_to_tensor(output.decoder_attentions) if self.config.output_attentions else None
+        cross_attns = tf.convert_to_tensor(output.cross_attentions) if self.config.output_attentions else None
+        enc_hs = tf.convert_to_tensor(output.encoder_hidden_states) if self.config.output_hidden_states else None
+        enc_attns = tf.convert_to_tensor(output.encoder_attentions) if self.config.output_attentions else None
+
+        return TFSeq2SeqModelOutput(
+            last_hidden_state=output.last_hidden_state,
+            past_key_values=pkv,
+            decoder_hidden_states=dec_hs,
+            decoder_attentions=dec_attns,
+            cross_attentions=cross_attns,
+            encoder_last_hidden_state=output.encoder_last_hidden_state,
+            encoder_hidden_states=enc_hs,
+            encoder_attentions=enc_attns,
+        )
+
+
+class BiasLayer(tf.keras.layers.Layer):
+    """
+    Bias as a layer. It is used for serialization purposes: `tf.keras.Model.save_weights` stores on a per-layer basis,
+    so all weights have to be registered in a layer.
+    """
+
+    def __init__(self, shape, initializer, trainable, name, **kwargs):
+        super().__init__(name=name, **kwargs)
+        # Note: the name of this variable will NOT be scoped when serialized, i.e. it will not be in the format of
+        # "outer_layer/inner_layer/.../name:0". Instead, it will be "name:0". For further details, see:
+        # https://github.com/huggingface/transformers/pull/18833#issuecomment-1233090214
+        self.bias = self.add_weight(name=name, shape=shape, initializer=initializer, trainable=trainable)
+
+    def call(self, x):
+        return x + self.bias
+
+
+@add_start_docstrings(
+    "The BART Model with a language modeling head. Can be used for summarization.",
+    BART_START_DOCSTRING,
+)
+class TFBartForConditionalGeneration(TFBartPretrainedModel, TFCausalLanguageModelingLoss):
+    _keys_to_ignore_on_load_missing = [r"final_logits_bias"]
+    _requires_load_weight_prefix = True
+
+    def __init__(self, config, load_weight_prefix=None, *inputs, **kwargs):
+        super().__init__(config, *inputs, **kwargs)
+        self.model = TFBartMainLayer(config, load_weight_prefix=load_weight_prefix, name="model")
+        self.use_cache = config.use_cache
+        # final_bias_logits is registered as a buffer in pytorch, so not trainable for the sake of consistency.
+        self.bias_layer = BiasLayer(
+            name="final_logits_bias", shape=[1, config.vocab_size], initializer="zeros", trainable=False
+        )
+
+    def get_decoder(self):
+        return self.model.decoder
+
+    def get_encoder(self):
+        return self.model.encoder
+
+    def get_output_embeddings(self):
+        return self.get_input_embeddings()
+
+    def set_output_embeddings(self, value):
+        self.set_input_embeddings(value)
+
+    def get_bias(self):
+        return {"final_logits_bias": self.bias_layer.bias}
+
+    def set_bias(self, value):
+        # Replaces the existing layers containing bias for correct (de)serialization.
+        vocab_size = value["final_logits_bias"].shape[-1]
+        self.bias_layer = BiasLayer(
+            name="final_logits_bias", shape=[1, vocab_size], initializer="zeros", trainable=False
+        )
+        self.bias_layer.bias.assign(value["final_logits_bias"])
+
+    @add_start_docstrings_to_model_forward(BART_INPUTS_DOCSTRING)
+    @replace_return_docstrings(output_type=TFSeq2SeqLMOutput, config_class=_CONFIG_FOR_DOC)
+    @add_end_docstrings(BART_GENERATION_EXAMPLE)
+    @unpack_inputs
+    def call(
+        self,
+        input_ids: TFModelInputType | None = None,
+        attention_mask: np.ndarray | tf.Tensor | None = None,
+        decoder_input_ids: np.ndarray | tf.Tensor | None = None,
+        decoder_attention_mask: np.ndarray | tf.Tensor | None = None,
+        decoder_position_ids: np.ndarray | tf.Tensor | None = None,
+        head_mask: np.ndarray | tf.Tensor | None = None,
+        decoder_head_mask: np.ndarray | tf.Tensor | None = None,
+        cross_attn_head_mask: np.ndarray | tf.Tensor | None = None,
+        encoder_outputs: Optional[TFBaseModelOutput] = None,
+        past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None,
+        inputs_embeds: np.ndarray | tf.Tensor | None = None,
+        decoder_inputs_embeds: np.ndarray | tf.Tensor | None = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        labels: tf.Tensor | None = None,
+        training: Optional[bool] = False,
+    ) -> Union[TFSeq2SeqLMOutput, Tuple[tf.Tensor]]:
+        r"""
+        labels (`tf.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+            Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
+            config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
+            (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
+
+        Returns:
+
+        """
+
+        if labels is not None:
+            labels = tf.where(
+                labels == self.config.pad_token_id,
+                tf.cast(tf.fill(shape_list(labels), -100), labels.dtype),
+                labels,
+            )
+            use_cache = False
+            if decoder_input_ids is None and decoder_inputs_embeds is None:
+                decoder_input_ids = shift_tokens_right(
+                    labels, self.config.pad_token_id, self.config.decoder_start_token_id
+                )
+
+        outputs = self.model(
+            input_ids,
+            attention_mask=attention_mask,
+            decoder_input_ids=decoder_input_ids,
+            encoder_outputs=encoder_outputs,
+            decoder_attention_mask=decoder_attention_mask,
+            decoder_position_ids=decoder_position_ids,
+            head_mask=head_mask,
+            decoder_head_mask=decoder_head_mask,
+            cross_attn_head_mask=cross_attn_head_mask,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            decoder_inputs_embeds=decoder_inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            training=training,
+        )
+        lm_logits = tf.matmul(outputs[0], self.model.shared.weights, transpose_b=True)
+        lm_logits = self.bias_layer(lm_logits)
+        masked_lm_loss = None if labels is None else self.hf_compute_loss(labels, lm_logits)
+
+        if not return_dict:
+            output = (lm_logits,) + outputs[1:]
+            return ((masked_lm_loss,) + output) if masked_lm_loss is not None else output
+        return TFSeq2SeqLMOutput(
+            loss=masked_lm_loss,
+            logits=lm_logits,
+            past_key_values=outputs.past_key_values,  # index 1 of d outputs
+            decoder_hidden_states=outputs.decoder_hidden_states,  # index 2 of d outputs
+            decoder_attentions=outputs.decoder_attentions,  # index 3 of d outputs
+            cross_attentions=outputs.cross_attentions,  # index 4 of d outputs
+            encoder_last_hidden_state=outputs.encoder_last_hidden_state,  # index 0 of encoder outputs
+            encoder_hidden_states=outputs.encoder_hidden_states,  # 1 of e out
+            encoder_attentions=outputs.encoder_attentions,  # 2 of e out
+        )
+
+    def serving_output(self, output):
+        pkv = tf.tuple(output.past_key_values)[1] if self.config.use_cache else None
+        dec_hs = tf.convert_to_tensor(output.decoder_hidden_states) if self.config.output_hidden_states else None
+        dec_attns = tf.convert_to_tensor(output.decoder_attentions) if self.config.output_attentions else None
+        cross_attns = tf.convert_to_tensor(output.cross_attentions) if self.config.output_attentions else None
+        enc_hs = tf.convert_to_tensor(output.encoder_hidden_states) if self.config.output_hidden_states else None
+        enc_attns = tf.convert_to_tensor(output.encoder_attentions) if self.config.output_attentions else None
+
+        return TFSeq2SeqLMOutput(
+            logits=output.logits,
+            past_key_values=pkv,
+            decoder_hidden_states=dec_hs,
+            decoder_attentions=dec_attns,
+            cross_attentions=cross_attns,
+            encoder_last_hidden_state=output.encoder_last_hidden_state,
+            encoder_hidden_states=enc_hs,
+            encoder_attentions=enc_attns,
+        )
+
+    def prepare_inputs_for_generation(
+        self,
+        decoder_input_ids,
+        past_key_values=None,
+        attention_mask=None,
+        decoder_attention_mask=None,
+        head_mask=None,
+        decoder_head_mask=None,
+        cross_attn_head_mask=None,
+        use_cache=None,
+        encoder_outputs=None,
+        **kwargs,
+    ):
+        # cut decoder_input_ids if past_key_values is used
+        if past_key_values is not None:
+            decoder_input_ids = decoder_input_ids[:, -1:]
+
+        if decoder_attention_mask is not None:  # xla
+            decoder_position_ids = tf.math.cumsum(decoder_attention_mask, axis=-1, exclusive=True)[:, -1:]
+        elif past_key_values is not None:  # no xla + past_key_values
+            decoder_position_ids = past_key_values[0][0].shape[2]
+        else:  # no xla + no past_key_values
+            decoder_position_ids = tf.range(decoder_input_ids.shape[1])
+
+        return {
+            "input_ids": None,  # encoder_outputs is defined. input_ids not needed
+            "encoder_outputs": encoder_outputs,
+            "past_key_values": past_key_values,
+            "decoder_input_ids": decoder_input_ids,
+            "attention_mask": attention_mask,
+            "decoder_attention_mask": decoder_attention_mask,
+            "decoder_position_ids": decoder_position_ids,
+            "head_mask": head_mask,
+            "decoder_head_mask": decoder_head_mask,
+            "cross_attn_head_mask": cross_attn_head_mask,
+            "use_cache": use_cache,  # change this to avoid caching (presumably for debugging)
+        }
+
+    def prepare_decoder_input_ids_from_labels(self, labels: tf.Tensor):
+        return shift_tokens_right(labels, self.config.pad_token_id, self.config.decoder_start_token_id)
+
+
+@add_start_docstrings(
+    """
+    Bart model with a sequence classification/head on top (a linear layer on top of the pooled output) e.g. for GLUE
+    tasks.
+    """,
+    BART_START_DOCSTRING,
+)
+class TFBartForSequenceClassification(TFBartPretrainedModel, TFSequenceClassificationLoss):
+    def __init__(self, config: BartConfig, load_weight_prefix=None, *inputs, **kwargs):
+        super().__init__(config, *inputs, **kwargs)
+        self.model = TFBartMainLayer(config, load_weight_prefix=load_weight_prefix, name="model")
+        self.classification_head = TFBartClassificationHead(
+            config.d_model, config.num_labels, config.classifier_dropout, name="classification_head"
+        )
+
+    @add_start_docstrings_to_model_forward(BART_INPUTS_DOCSTRING)
+    @replace_return_docstrings(output_type=TFSeq2SeqSequenceClassifierOutput, config_class=_CONFIG_FOR_DOC)
+    @unpack_inputs
+    def call(
+        self,
+        input_ids: TFModelInputType | None = None,
+        attention_mask: np.ndarray | tf.Tensor | None = None,
+        decoder_input_ids: np.ndarray | tf.Tensor | None = None,
+        decoder_attention_mask: np.ndarray | tf.Tensor | None = None,
+        decoder_position_ids: np.ndarray | tf.Tensor | None = None,
+        head_mask: np.ndarray | tf.Tensor | None = None,
+        decoder_head_mask: np.ndarray | tf.Tensor | None = None,
+        cross_attn_head_mask: np.ndarray | tf.Tensor | None = None,
+        encoder_outputs: Optional[TFBaseModelOutput] = None,
+        past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None,
+        inputs_embeds: np.ndarray | tf.Tensor | None = None,
+        decoder_inputs_embeds: np.ndarray | tf.Tensor | None = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        labels: tf.Tensor | None = None,
+        training: Optional[bool] = False,
+    ) -> Union[TFSeq2SeqSequenceClassifierOutput, Tuple[tf.Tensor]]:
+        r"""
+        labels (`tf.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+            Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+            config.num_labels - 1]`. If `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+
+        Returns:
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        if labels is not None:
+            use_cache = False
+
+        if input_ids is None and inputs_embeds is not None:
+            raise NotImplementedError(
+                f"Passing input embeddings is currently not supported for {self.__class__.__name__}"
+            )
+
+        outputs = self.model(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            decoder_input_ids=decoder_input_ids,
+            decoder_attention_mask=decoder_attention_mask,
+            decoder_position_ids=decoder_position_ids,
+            head_mask=head_mask,
+            decoder_head_mask=decoder_head_mask,
+            cross_attn_head_mask=cross_attn_head_mask,
+            encoder_outputs=encoder_outputs,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            decoder_inputs_embeds=decoder_inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            training=training,
+        )
+
+        last_hidden_state = outputs[0]
+        eos_mask = tf.equal(input_ids, self.config.eos_token_id)
+        # out the rows with False where present.  Then verify all the final
+        # entries are True
+        self_masked = tf.reshape(tf.boolean_mask(eos_mask, eos_mask), (tf.shape(input_ids)[0], -1))
+        tf.Assert(tf.reduce_all(self_masked[:, -1]), ["All examples must have the same number of <eos> tokens."])
+
+        masked = tf.reshape(
+            tf.boolean_mask(last_hidden_state, eos_mask),
+            (tf.shape(input_ids)[0], tf.shape(self_masked)[1], tf.shape(last_hidden_state)[-1]),
+        )
+
+        sentence_representation = masked[:, -1, :]
+        logits = self.classification_head(sentence_representation)
+        loss = None if labels is None else self.hf_compute_loss(labels=labels, logits=logits)
+
+        if not return_dict:
+            output = (logits,) + outputs[1:]
+            return ((loss,) + output) if loss is not None else output
+
+        return TFSeq2SeqSequenceClassifierOutput(
+            loss=loss,
+            logits=logits,
+            past_key_values=outputs.past_key_values,
+            decoder_hidden_states=outputs.decoder_hidden_states,
+            decoder_attentions=outputs.decoder_attentions,
+            cross_attentions=outputs.cross_attentions,
+            encoder_last_hidden_state=outputs.encoder_last_hidden_state,
+            encoder_hidden_states=outputs.encoder_hidden_states,
+            encoder_attentions=outputs.encoder_attentions,
+        )
+
+    def serving_output(self, output):
+        logits = tf.convert_to_tensor(output.logits)
+        pkv = tf.tuple(output.past_key_values)[1] if self.config.use_cache else None
+        dec_hs = tf.convert_to_tensor(output.decoder_hidden_states) if self.config.output_hidden_states else None
+        dec_attns = tf.convert_to_tensor(output.decoder_attentions) if self.config.output_attentions else None
+        cross_attns = tf.convert_to_tensor(output.cross_attentions) if self.config.output_attentions else None
+        enc_hs = tf.convert_to_tensor(output.encoder_hidden_states) if self.config.output_hidden_states else None
+        enc_attns = tf.convert_to_tensor(output.encoder_attentions) if self.config.output_attentions else None
+
+        return TFSeq2SeqSequenceClassifierOutput(
+            logits=logits,
+            past_key_values=pkv,
+            decoder_hidden_states=dec_hs,
+            decoder_attentions=dec_attns,
+            cross_attentions=cross_attns,
+            encoder_last_hidden_state=output.encoder_last_hidden_state,
+            encoder_hidden_states=enc_hs,
+            encoder_attentions=enc_attns,
+        )
diff --git a/openflamingo/lib/python3.10/site-packages/transformers/models/esm/__init__.py b/openflamingo/lib/python3.10/site-packages/transformers/models/esm/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1b07db5a5eea64b8e5d37cf2c9c89429586ea8fe
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/transformers/models/esm/__init__.py
@@ -0,0 +1,94 @@
+# Copyright 2022 Facebook and The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import TYPE_CHECKING
+
+from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available
+
+
+_import_structure = {
+    "configuration_esm": ["ESM_PRETRAINED_CONFIG_ARCHIVE_MAP", "EsmConfig"],
+    "tokenization_esm": ["EsmTokenizer"],
+}
+
+try:
+    if not is_torch_available():
+        raise OptionalDependencyNotAvailable()
+except OptionalDependencyNotAvailable:
+    pass
+else:
+    _import_structure["modeling_esm"] = [
+        "ESM_PRETRAINED_MODEL_ARCHIVE_LIST",
+        "EsmForMaskedLM",
+        "EsmForSequenceClassification",
+        "EsmForTokenClassification",
+        "EsmModel",
+        "EsmPreTrainedModel",
+    ]
+    _import_structure["modeling_esmfold"] = ["EsmForProteinFolding", "EsmFoldPreTrainedModel"]
+
+try:
+    if not is_tf_available():
+        raise OptionalDependencyNotAvailable()
+except OptionalDependencyNotAvailable:
+    pass
+else:
+    _import_structure["modeling_tf_esm"] = [
+        "TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST",
+        "TFEsmForMaskedLM",
+        "TFEsmForSequenceClassification",
+        "TFEsmForTokenClassification",
+        "TFEsmModel",
+        "TFEsmPreTrainedModel",
+    ]
+
+if TYPE_CHECKING:
+    from .configuration_esm import ESM_PRETRAINED_CONFIG_ARCHIVE_MAP, EsmConfig
+    from .tokenization_esm import EsmTokenizer
+
+    try:
+        if not is_torch_available():
+            raise OptionalDependencyNotAvailable()
+    except OptionalDependencyNotAvailable:
+        pass
+    else:
+        from .modeling_esm import (
+            ESM_PRETRAINED_MODEL_ARCHIVE_LIST,
+            EsmForMaskedLM,
+            EsmForSequenceClassification,
+            EsmForTokenClassification,
+            EsmModel,
+            EsmPreTrainedModel,
+        )
+        from .modeling_esmfold import EsmFoldPreTrainedModel, EsmForProteinFolding
+
+    try:
+        if not is_tf_available():
+            raise OptionalDependencyNotAvailable()
+    except OptionalDependencyNotAvailable:
+        pass
+    else:
+        from .modeling_tf_esm import (
+            TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST,
+            TFEsmForMaskedLM,
+            TFEsmForSequenceClassification,
+            TFEsmForTokenClassification,
+            TFEsmModel,
+            TFEsmPreTrainedModel,
+        )
+
+
+else:
+    import sys
+
+    sys.modules[__name__] = _LazyModule(__name__, globals()["__file__"], _import_structure)
diff --git a/openflamingo/lib/python3.10/site-packages/transformers/models/esm/modeling_esm.py b/openflamingo/lib/python3.10/site-packages/transformers/models/esm/modeling_esm.py
new file mode 100644
index 0000000000000000000000000000000000000000..05693b0c1e1e0dc25b3553b3dc40a7ca13662d48
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/transformers/models/esm/modeling_esm.py
@@ -0,0 +1,1279 @@
+# coding=utf-8
+# Copyright 2022 Meta and The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""" PyTorch ESM model."""
+
+import math
+from typing import List, Optional, Tuple, Union
+
+import torch
+import torch.utils.checkpoint
+from torch import nn
+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
+
+from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
+from ...modeling_outputs import (
+    BaseModelOutputWithPastAndCrossAttentions,
+    BaseModelOutputWithPoolingAndCrossAttentions,
+    MaskedLMOutput,
+    SequenceClassifierOutput,
+    TokenClassifierOutput,
+)
+from ...modeling_utils import PreTrainedModel, find_pruneable_heads_and_indices, prune_linear_layer
+from ...utils import logging
+from .configuration_esm import EsmConfig
+
+
+logger = logging.get_logger(__name__)
+
+_CHECKPOINT_FOR_DOC = "facebook/esm2_t6_8M_UR50D"
+_CONFIG_FOR_DOC = "EsmConfig"
+
+ESM_PRETRAINED_MODEL_ARCHIVE_LIST = [
+    "facebook/esm2_t6_8M_UR50D",
+    "facebook/esm2_t12_35M_UR50D",
+    # This is not a complete list of all ESM models!
+    # See all ESM models at https://huggingface.co/models?filter=esm
+]
+
+
+def rotate_half(x):
+    x1, x2 = x.chunk(2, dim=-1)
+    return torch.cat((-x2, x1), dim=-1)
+
+
+def apply_rotary_pos_emb(x, cos, sin):
+    cos = cos[:, :, : x.shape[-2], :]
+    sin = sin[:, :, : x.shape[-2], :]
+
+    return (x * cos) + (rotate_half(x) * sin)
+
+
+def gelu(x):
+    """
+    This is the gelu implementation from the original ESM repo. Using F.gelu yields subtly wrong results.
+    """
+    return x * 0.5 * (1.0 + torch.erf(x / math.sqrt(2.0)))
+
+
+def symmetrize(x):
+    "Make layer symmetric in final two dimensions, used for contact prediction."
+    return x + x.transpose(-1, -2)
+
+
+def average_product_correct(x):
+    "Perform average product correct, used for contact prediction."
+    a1 = x.sum(-1, keepdims=True)
+    a2 = x.sum(-2, keepdims=True)
+    a12 = x.sum((-1, -2), keepdims=True)
+
+    avg = a1 * a2
+    avg.div_(a12)  # in-place to reduce memory
+    normalized = x - avg
+    return normalized
+
+
+class RotaryEmbedding(torch.nn.Module):
+    """
+    Rotary position embeddings based on those in
+    [RoFormer](https://huggingface.co/docs/transformers/model_doc/roformer). Query and keys are transformed by rotation
+    matrices which depend on their relative positions.
+    """
+
+    def __init__(self, dim: int):
+        super().__init__()
+        # Generate and save the inverse frequency buffer (non trainable)
+        inv_freq = 1.0 / (10000 ** (torch.arange(0, dim, 2).float() / dim))
+        inv_freq = inv_freq
+        self.register_buffer("inv_freq", inv_freq)
+
+        self._seq_len_cached = None
+        self._cos_cached = None
+        self._sin_cached = None
+
+    def _update_cos_sin_tables(self, x, seq_dimension=2):
+        seq_len = x.shape[seq_dimension]
+
+        # Reset the tables if the sequence length has changed,
+        # or if we're on a new device (possibly due to tracing for instance)
+        if seq_len != self._seq_len_cached or self._cos_cached.device != x.device:
+            self._seq_len_cached = seq_len
+            t = torch.arange(x.shape[seq_dimension], device=x.device).type_as(self.inv_freq)
+            freqs = torch.outer(t, self.inv_freq)
+            emb = torch.cat((freqs, freqs), dim=-1).to(x.device)
+
+            self._cos_cached = emb.cos()[None, None, :, :]
+            self._sin_cached = emb.sin()[None, None, :, :]
+
+        return self._cos_cached, self._sin_cached
+
+    def forward(self, q: torch.Tensor, k: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+        self._cos_cached, self._sin_cached = self._update_cos_sin_tables(k, seq_dimension=-2)
+
+        return (
+            apply_rotary_pos_emb(q, self._cos_cached, self._sin_cached),
+            apply_rotary_pos_emb(k, self._cos_cached, self._sin_cached),
+        )
+
+
+class EsmContactPredictionHead(nn.Module):
+    """Performs symmetrization, apc, and computes a logistic regression on the output features"""
+
+    def __init__(
+        self,
+        in_features: int,
+        bias=True,
+        eos_idx: int = 2,
+    ):
+        super().__init__()
+        self.in_features = in_features
+        self.eos_idx = eos_idx
+        self.regression = nn.Linear(in_features, 1, bias)
+        self.activation = nn.Sigmoid()
+
+    def forward(self, tokens, attentions):
+        # remove eos token attentions
+        eos_mask = tokens.ne(self.eos_idx).to(attentions)
+        eos_mask = eos_mask.unsqueeze(1) * eos_mask.unsqueeze(2)
+        attentions = attentions * eos_mask[:, None, None, :, :]
+        attentions = attentions[..., :-1, :-1]
+        # remove cls token attentions
+        attentions = attentions[..., 1:, 1:]
+        batch_size, layers, heads, seqlen, _ = attentions.size()
+        attentions = attentions.view(batch_size, layers * heads, seqlen, seqlen)
+
+        # features: batch x channels x tokens x tokens (symmetric)
+        attentions = attentions.to(
+            self.regression.weight.device
+        )  # attentions always float32, may need to convert to float16
+        attentions = average_product_correct(symmetrize(attentions))
+        attentions = attentions.permute(0, 2, 3, 1)
+        return self.activation(self.regression(attentions).squeeze(3))
+
+
+class EsmEmbeddings(nn.Module):
+    """
+    Same as BertEmbeddings with a tiny tweak for positional embeddings indexing.
+    """
+
+    def __init__(self, config):
+        super().__init__()
+        self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
+
+        if config.emb_layer_norm_before:
+            self.layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        else:
+            self.layer_norm = None
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+        # position_ids (1, len position emb) is contiguous in memory and exported when serialized
+        self.position_embedding_type = getattr(config, "position_embedding_type", "absolute")
+        self.register_buffer(
+            "position_ids", torch.arange(config.max_position_embeddings).expand((1, -1)), persistent=False
+        )
+
+        self.padding_idx = config.pad_token_id
+        self.position_embeddings = nn.Embedding(
+            config.max_position_embeddings, config.hidden_size, padding_idx=self.padding_idx
+        )
+        self.token_dropout = config.token_dropout
+        self.mask_token_id = config.mask_token_id
+
+    def forward(
+        self, input_ids=None, attention_mask=None, position_ids=None, inputs_embeds=None, past_key_values_length=0
+    ):
+        if position_ids is None:
+            if input_ids is not None:
+                # Create the position ids from the input token ids. Any padded tokens remain padded.
+                position_ids = create_position_ids_from_input_ids(input_ids, self.padding_idx, past_key_values_length)
+            else:
+                position_ids = self.create_position_ids_from_inputs_embeds(inputs_embeds)
+
+        if inputs_embeds is None:
+            inputs_embeds = self.word_embeddings(input_ids)
+
+        # Note that if we want to support ESM-1 (not 1b!) in future then we need to support an
+        # embedding_scale factor here.
+        embeddings = inputs_embeds
+
+        # Matt: ESM has the option to handle masking in MLM in a slightly unusual way. If the token_dropout
+        # flag is False then it is handled in the same was as BERT/RoBERTa. If it is set to True, however,
+        # masked tokens are treated as if they were selected for input dropout and zeroed out.
+        # This "mask-dropout" is compensated for when masked tokens are not present, by scaling embeddings by
+        # a factor of (fraction of unmasked tokens during training) / (fraction of unmasked tokens in sample).
+        # This is analogous to the way that dropout layers scale down outputs during evaluation when not
+        # actually dropping out values (or, equivalently, scale up their un-dropped outputs in training).
+        if self.token_dropout:
+            embeddings.masked_fill_((input_ids == self.mask_token_id).unsqueeze(-1), 0.0)
+            mask_ratio_train = 0.15 * 0.8  # Hardcoded as the ratio used in all ESM model training runs
+            src_lengths = attention_mask.sum(-1)
+            mask_ratio_observed = (input_ids == self.mask_token_id).sum(-1).float() / src_lengths
+            embeddings = (embeddings * (1 - mask_ratio_train) / (1 - mask_ratio_observed)[:, None, None]).to(
+                embeddings.dtype
+            )
+
+        if self.position_embedding_type == "absolute":
+            position_embeddings = self.position_embeddings(position_ids)
+            embeddings += position_embeddings
+
+        if self.layer_norm is not None:
+            embeddings = self.layer_norm(embeddings)
+        if attention_mask is not None:
+            embeddings = (embeddings * attention_mask.unsqueeze(-1)).to(embeddings.dtype)
+        # Matt: I think this line was copied incorrectly from BERT, disabling it for now.
+        # embeddings = self.dropout(embeddings)
+        return embeddings
+
+    def create_position_ids_from_inputs_embeds(self, inputs_embeds):
+        """
+        We are provided embeddings directly. We cannot infer which are padded so just generate sequential position ids.
+
+        Args:
+            inputs_embeds: torch.Tensor
+
+        Returns: torch.Tensor
+        """
+        input_shape = inputs_embeds.size()[:-1]
+        sequence_length = input_shape[1]
+
+        position_ids = torch.arange(
+            self.padding_idx + 1, sequence_length + self.padding_idx + 1, dtype=torch.long, device=inputs_embeds.device
+        )
+        return position_ids.unsqueeze(0).expand(input_shape)
+
+
+class EsmSelfAttention(nn.Module):
+    def __init__(self, config, position_embedding_type=None):
+        super().__init__()
+        if config.hidden_size % config.num_attention_heads != 0 and not hasattr(config, "embedding_size"):
+            raise ValueError(
+                f"The hidden size ({config.hidden_size}) is not a multiple of the number of attention "
+                f"heads ({config.num_attention_heads})"
+            )
+
+        self.num_attention_heads = config.num_attention_heads
+        self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
+        self.all_head_size = self.num_attention_heads * self.attention_head_size
+
+        self.query = nn.Linear(config.hidden_size, self.all_head_size)
+        self.key = nn.Linear(config.hidden_size, self.all_head_size)
+        self.value = nn.Linear(config.hidden_size, self.all_head_size)
+
+        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+        self.position_embedding_type = position_embedding_type or getattr(
+            config, "position_embedding_type", "absolute"
+        )
+        self.rotary_embeddings = None
+        if self.position_embedding_type == "relative_key" or self.position_embedding_type == "relative_key_query":
+            self.max_position_embeddings = config.max_position_embeddings
+            self.distance_embedding = nn.Embedding(2 * config.max_position_embeddings - 1, self.attention_head_size)
+        elif self.position_embedding_type == "rotary":
+            self.rotary_embeddings = RotaryEmbedding(dim=self.attention_head_size)
+
+        self.is_decoder = config.is_decoder
+
+    def transpose_for_scores(self, x: torch.Tensor) -> torch.Tensor:
+        new_x_shape = x.size()[:-1] + (self.num_attention_heads, self.attention_head_size)
+        x = x.view(new_x_shape)
+        return x.permute(0, 2, 1, 3)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: Optional[torch.FloatTensor] = None,
+        head_mask: Optional[torch.FloatTensor] = None,
+        encoder_hidden_states: Optional[torch.FloatTensor] = None,
+        encoder_attention_mask: Optional[torch.FloatTensor] = None,
+        past_key_value: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,
+        output_attentions: Optional[bool] = False,
+    ) -> Tuple[torch.Tensor]:
+        mixed_query_layer = self.query(hidden_states)
+
+        # If this is instantiated as a cross-attention module, the keys
+        # and values come from an encoder; the attention mask needs to be
+        # such that the encoder's padding tokens are not attended to.
+        is_cross_attention = encoder_hidden_states is not None
+
+        if is_cross_attention and past_key_value is not None:
+            # reuse k,v, cross_attentions
+            key_layer = past_key_value[0]
+            value_layer = past_key_value[1]
+            attention_mask = encoder_attention_mask
+        elif is_cross_attention:
+            key_layer = self.transpose_for_scores(self.key(encoder_hidden_states))
+            value_layer = self.transpose_for_scores(self.value(encoder_hidden_states))
+            attention_mask = encoder_attention_mask
+        elif past_key_value is not None:
+            key_layer = self.transpose_for_scores(self.key(hidden_states))
+            value_layer = self.transpose_for_scores(self.value(hidden_states))
+            key_layer = torch.cat([past_key_value[0], key_layer], dim=2)
+            value_layer = torch.cat([past_key_value[1], value_layer], dim=2)
+        else:
+            key_layer = self.transpose_for_scores(self.key(hidden_states))
+            value_layer = self.transpose_for_scores(self.value(hidden_states))
+
+        query_layer = self.transpose_for_scores(mixed_query_layer)
+
+        # Matt: Our BERT model (which this code was derived from) scales attention logits down by sqrt(head_dim).
+        # ESM scales the query down by the same factor instead. Modulo numerical stability these are equivalent,
+        # but not when rotary embeddings get involved. Therefore, we scale the query here to match the original
+        # ESM code and fix rotary embeddings.
+        query_layer = query_layer * self.attention_head_size**-0.5
+
+        if self.is_decoder:
+            # if cross_attention save Tuple(torch.Tensor, torch.Tensor) of all cross attention key/value_states.
+            # Further calls to cross_attention layer can then reuse all cross-attention
+            # key/value_states (first "if" case)
+            # if uni-directional self-attention (decoder) save Tuple(torch.Tensor, torch.Tensor) of
+            # all previous decoder key/value_states. Further calls to uni-directional self-attention
+            # can concat previous decoder key/value_states to current projected key/value_states (third "elif" case)
+            # if encoder bi-directional self-attention `past_key_value` is always `None`
+            past_key_value = (key_layer, value_layer)
+
+        if self.position_embedding_type == "rotary":
+            query_layer, key_layer = self.rotary_embeddings(query_layer, key_layer)
+
+        # Take the dot product between "query" and "key" to get the raw attention scores.
+        attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
+
+        if self.position_embedding_type == "relative_key" or self.position_embedding_type == "relative_key_query":
+            seq_length = hidden_states.size()[1]
+            position_ids_l = torch.arange(seq_length, dtype=torch.long, device=hidden_states.device).view(-1, 1)
+            position_ids_r = torch.arange(seq_length, dtype=torch.long, device=hidden_states.device).view(1, -1)
+            distance = position_ids_l - position_ids_r
+            positional_embedding = self.distance_embedding(distance + self.max_position_embeddings - 1)
+            positional_embedding = positional_embedding.to(dtype=query_layer.dtype)  # fp16 compatibility
+
+            if self.position_embedding_type == "relative_key":
+                relative_position_scores = torch.einsum("bhld,lrd->bhlr", query_layer, positional_embedding)
+                attention_scores = attention_scores + relative_position_scores
+            elif self.position_embedding_type == "relative_key_query":
+                relative_position_scores_query = torch.einsum("bhld,lrd->bhlr", query_layer, positional_embedding)
+                relative_position_scores_key = torch.einsum("bhrd,lrd->bhlr", key_layer, positional_embedding)
+                attention_scores = attention_scores + relative_position_scores_query + relative_position_scores_key
+
+        if attention_mask is not None:
+            # Apply the attention mask is (precomputed for all layers in EsmModel forward() function)
+            attention_scores = attention_scores + attention_mask
+
+        # Normalize the attention scores to probabilities.
+        attention_probs = nn.functional.softmax(attention_scores, dim=-1)
+
+        # This is actually dropping out entire tokens to attend to, which might
+        # seem a bit unusual, but is taken from the original Transformer paper.
+        attention_probs = self.dropout(attention_probs)
+
+        # Mask heads if we want to
+        if head_mask is not None:
+            attention_probs = attention_probs * head_mask
+
+        context_layer = torch.matmul(attention_probs, value_layer)
+
+        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
+        new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
+        context_layer = context_layer.view(new_context_layer_shape)
+
+        outputs = (context_layer, attention_probs) if output_attentions else (context_layer,)
+
+        if self.is_decoder:
+            outputs = outputs + (past_key_value,)
+        return outputs
+
+
+class EsmSelfOutput(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+    def forward(self, hidden_states, input_tensor):
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        hidden_states += input_tensor
+        return hidden_states
+
+
+class EsmAttention(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.self = EsmSelfAttention(config)
+        self.output = EsmSelfOutput(config)
+        self.pruned_heads = set()
+        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+    def prune_heads(self, heads):
+        if len(heads) == 0:
+            return
+        heads, index = find_pruneable_heads_and_indices(
+            heads, self.self.num_attention_heads, self.self.attention_head_size, self.pruned_heads
+        )
+
+        # Prune linear layers
+        self.self.query = prune_linear_layer(self.self.query, index)
+        self.self.key = prune_linear_layer(self.self.key, index)
+        self.self.value = prune_linear_layer(self.self.value, index)
+        self.output.dense = prune_linear_layer(self.output.dense, index, dim=1)
+
+        # Update hyper params and store pruned heads
+        self.self.num_attention_heads = self.self.num_attention_heads - len(heads)
+        self.self.all_head_size = self.self.attention_head_size * self.self.num_attention_heads
+        self.pruned_heads = self.pruned_heads.union(heads)
+
+    def forward(
+        self,
+        hidden_states,
+        attention_mask=None,
+        head_mask=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        past_key_value=None,
+        output_attentions=False,
+    ):
+        hidden_states_ln = self.LayerNorm(hidden_states)
+        self_outputs = self.self(
+            hidden_states_ln,
+            attention_mask,
+            head_mask,
+            encoder_hidden_states,
+            encoder_attention_mask,
+            past_key_value,
+            output_attentions,
+        )
+        attention_output = self.output(self_outputs[0], hidden_states)
+        outputs = (attention_output,) + self_outputs[1:]  # add attentions if we output them
+        return outputs
+
+
+class EsmIntermediate(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.intermediate_size)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.dense(hidden_states)
+        hidden_states = gelu(hidden_states)
+        return hidden_states
+
+
+class EsmOutput(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+    def forward(self, hidden_states, input_tensor):
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        hidden_states += input_tensor
+        return hidden_states
+
+
+class EsmLayer(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.chunk_size_feed_forward = config.chunk_size_feed_forward
+        self.seq_len_dim = 1
+        self.attention = EsmAttention(config)
+        self.is_decoder = config.is_decoder
+        self.add_cross_attention = config.add_cross_attention
+        if self.add_cross_attention:
+            if not self.is_decoder:
+                raise RuntimeError(f"{self} should be used as a decoder model if cross attention is added")
+            self.crossattention = EsmAttention(config)
+        self.intermediate = EsmIntermediate(config)
+        self.output = EsmOutput(config)
+        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+    def forward(
+        self,
+        hidden_states,
+        attention_mask=None,
+        head_mask=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        past_key_value=None,
+        output_attentions=False,
+    ):
+        # decoder uni-directional self-attention cached key/values tuple is at positions 1,2
+        self_attn_past_key_value = past_key_value[:2] if past_key_value is not None else None
+        self_attention_outputs = self.attention(
+            hidden_states,
+            attention_mask,
+            head_mask,
+            output_attentions=output_attentions,
+            past_key_value=self_attn_past_key_value,
+        )
+        attention_output = self_attention_outputs[0]
+
+        # if decoder, the last output is tuple of self-attn cache
+        if self.is_decoder:
+            outputs = self_attention_outputs[1:-1]
+            present_key_value = self_attention_outputs[-1]
+        else:
+            outputs = self_attention_outputs[1:]  # add self attentions if we output attention weights
+
+        cross_attn_present_key_value = None
+        if self.is_decoder and encoder_hidden_states is not None:
+            if not hasattr(self, "crossattention"):
+                raise AttributeError(
+                    f"If `encoder_hidden_states` are passed, {self} has to be instantiated"
+                    " with cross-attention layers by setting `config.add_cross_attention=True`"
+                )
+
+            # cross_attn cached key/values tuple is at positions 3,4 of past_key_value tuple
+            cross_attn_past_key_value = past_key_value[-2:] if past_key_value is not None else None
+            cross_attention_outputs = self.crossattention(
+                attention_output,
+                attention_mask,
+                head_mask,
+                encoder_hidden_states,
+                encoder_attention_mask,
+                cross_attn_past_key_value,
+                output_attentions,
+            )
+            attention_output = cross_attention_outputs[0]
+            outputs = outputs + cross_attention_outputs[1:-1]  # add cross attentions if we output attention weights
+
+            # add cross-attn cache to positions 3,4 of present_key_value tuple
+            cross_attn_present_key_value = cross_attention_outputs[-1]
+            present_key_value = present_key_value + cross_attn_present_key_value
+
+        layer_output = self.feed_forward_chunk(attention_output)
+
+        outputs = (layer_output,) + outputs
+
+        # if decoder, return the attn key/values as the last output
+        if self.is_decoder:
+            outputs = outputs + (present_key_value,)
+        return outputs
+
+    def feed_forward_chunk(self, attention_output):
+        attention_output_ln = self.LayerNorm(attention_output)
+        intermediate_output = self.intermediate(attention_output_ln)
+        layer_output = self.output(intermediate_output, attention_output)
+        return layer_output
+
+
+class EsmEncoder(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.layer = nn.ModuleList([EsmLayer(config) for _ in range(config.num_hidden_layers)])
+        self.emb_layer_norm_after = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.gradient_checkpointing = False
+
+    def forward(
+        self,
+        hidden_states,
+        attention_mask=None,
+        head_mask=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        past_key_values=None,
+        use_cache=None,
+        output_attentions=False,
+        output_hidden_states=False,
+        return_dict=True,
+    ):
+        if self.gradient_checkpointing and self.training:
+            if use_cache:
+                logger.warning_once(
+                    "`use_cache=True` is incompatible with `config.gradient_checkpointing=True`. Setting "
+                    "`use_cache=False`..."
+                )
+                use_cache = False
+        all_hidden_states = () if output_hidden_states else None
+        all_self_attentions = () if output_attentions else None
+        all_cross_attentions = () if output_attentions and self.config.add_cross_attention else None
+
+        next_decoder_cache = () if use_cache else None
+        for i, layer_module in enumerate(self.layer):
+            if output_hidden_states:
+                all_hidden_states = all_hidden_states + (hidden_states,)
+
+            layer_head_mask = head_mask[i] if head_mask is not None else None
+            past_key_value = past_key_values[i] if past_key_values is not None else None
+
+            if self.gradient_checkpointing and self.training:
+
+                def create_custom_forward(module):
+                    def custom_forward(*inputs):
+                        return module(*inputs, past_key_value, output_attentions)
+
+                    return custom_forward
+
+                layer_outputs = torch.utils.checkpoint.checkpoint(
+                    create_custom_forward(layer_module),
+                    hidden_states,
+                    attention_mask,
+                    layer_head_mask,
+                    encoder_hidden_states,
+                    encoder_attention_mask,
+                )
+            else:
+                layer_outputs = layer_module(
+                    hidden_states,
+                    attention_mask,
+                    layer_head_mask,
+                    encoder_hidden_states,
+                    encoder_attention_mask,
+                    past_key_value,
+                    output_attentions,
+                )
+
+            hidden_states = layer_outputs[0]
+            if use_cache:
+                next_decoder_cache += (layer_outputs[-1],)
+            if output_attentions:
+                all_self_attentions = all_self_attentions + (layer_outputs[1],)
+                if self.config.add_cross_attention:
+                    all_cross_attentions = all_cross_attentions + (layer_outputs[2],)
+
+        if self.emb_layer_norm_after:
+            hidden_states = self.emb_layer_norm_after(hidden_states)
+
+        if output_hidden_states:
+            all_hidden_states = all_hidden_states + (hidden_states,)
+
+        if not return_dict:
+            return tuple(
+                v
+                for v in [
+                    hidden_states,
+                    next_decoder_cache,
+                    all_hidden_states,
+                    all_self_attentions,
+                    all_cross_attentions,
+                ]
+                if v is not None
+            )
+        return BaseModelOutputWithPastAndCrossAttentions(
+            last_hidden_state=hidden_states,
+            past_key_values=next_decoder_cache,
+            hidden_states=all_hidden_states,
+            attentions=all_self_attentions,
+            cross_attentions=all_cross_attentions,
+        )
+
+
+# Copied from transformers.models.bert.modeling_bert.BertPooler
+class EsmPooler(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        self.activation = nn.Tanh()
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        # We "pool" the model by simply taking the hidden state corresponding
+        # to the first token.
+        first_token_tensor = hidden_states[:, 0]
+        pooled_output = self.dense(first_token_tensor)
+        pooled_output = self.activation(pooled_output)
+        return pooled_output
+
+
+class EsmPreTrainedModel(PreTrainedModel):
+    """
+    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
+    models.
+    """
+
+    config_class = EsmConfig
+    base_model_prefix = "esm"
+    _no_split_modules = ["EsmLayer", "EsmFoldTriangularSelfAttentionBlock", "EsmEmbeddings"]
+
+    # Copied from transformers.models.bert.modeling_bert.BertPreTrainedModel._init_weights
+    def _init_weights(self, module):
+        """Initialize the weights"""
+        if isinstance(module, nn.Linear):
+            # Slightly different from the TF version which uses truncated_normal for initialization
+            # cf https://github.com/pytorch/pytorch/pull/5617
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.bias is not None:
+                module.bias.data.zero_()
+        elif isinstance(module, nn.Embedding):
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.padding_idx is not None:
+                module.weight.data[module.padding_idx].zero_()
+        elif isinstance(module, nn.LayerNorm):
+            module.bias.data.zero_()
+            module.weight.data.fill_(1.0)
+
+
+ESM_START_DOCSTRING = r"""
+
+    This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the
+    library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
+    etc.)
+
+    This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass.
+    Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
+    and behavior.
+
+    Parameters:
+        config ([`EsmConfig`]): Model configuration class with all the parameters of the
+            model. Initializing with a config file does not load the weights associated with the model, only the
+            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
+"""
+
+ESM_INPUTS_DOCSTRING = r"""
+    Args:
+        input_ids (`torch.LongTensor` of shape `({0})`):
+            Indices of input sequence tokens in the vocabulary.
+
+            Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+            [`PreTrainedTokenizer.__call__`] for details.
+
+            [What are input IDs?](../glossary#input-ids)
+        attention_mask (`torch.FloatTensor` of shape `({0})`, *optional*):
+            Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
+
+            - 1 for tokens that are **not masked**,
+            - 0 for tokens that are **masked**.
+
+            [What are attention masks?](../glossary#attention-mask)
+        position_ids (`torch.LongTensor` of shape `({0})`, *optional*):
+            Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0,
+            config.max_position_embeddings - 1]`.
+
+            [What are position IDs?](../glossary#position-ids)
+        head_mask (`torch.FloatTensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*):
+            Mask to nullify selected heads of the self-attention modules. Mask values selected in `[0, 1]`:
+
+            - 1 indicates the head is **not masked**,
+            - 0 indicates the head is **masked**.
+
+        inputs_embeds (`torch.FloatTensor` of shape `({0}, hidden_size)`, *optional*):
+            Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This
+            is useful if you want more control over how to convert `input_ids` indices into associated vectors than the
+            model's internal embedding lookup matrix.
+        output_attentions (`bool`, *optional*):
+            Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
+            tensors for more detail.
+        output_hidden_states (`bool`, *optional*):
+            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
+            more detail.
+        return_dict (`bool`, *optional*):
+            Whether or not to return a [`~file_utils.ModelOutput`] instead of a plain tuple.
+"""
+
+
+@add_start_docstrings(
+    "The bare ESM Model transformer outputting raw hidden-states without any specific head on top.",
+    ESM_START_DOCSTRING,
+)
+class EsmModel(EsmPreTrainedModel):
+    """
+
+    The model can behave as an encoder (with only self-attention) as well as a decoder, in which case a layer of
+    cross-attention is added between the self-attention layers, following the architecture described in [Attention is
+    all you need](https://arxiv.org/abs/1706.03762) by Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit,
+    Llion Jones, Aidan N. Gomez, Lukasz Kaiser and Illia Polosukhin.
+
+    To behave as an decoder the model needs to be initialized with the `is_decoder` argument of the configuration set
+    to `True`. To be used in a Seq2Seq model, the model needs to initialized with both `is_decoder` argument and
+    `add_cross_attention` set to `True`; an `encoder_hidden_states` is then expected as an input to the forward pass.
+    """
+
+    supports_gradient_checkpointing = False
+
+    def __init__(self, config, add_pooling_layer=True):
+        super().__init__(config)
+        self.config = config
+
+        self.embeddings = EsmEmbeddings(config)
+        self.encoder = EsmEncoder(config)
+
+        self.pooler = EsmPooler(config) if add_pooling_layer else None
+
+        self.contact_head = EsmContactPredictionHead(
+            in_features=config.num_hidden_layers * config.num_attention_heads, bias=True
+        )
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def _set_gradient_checkpointing(self, module, value=False):
+        if isinstance(module, EsmEncoder):
+            module.gradient_checkpointing = value
+
+    def get_input_embeddings(self):
+        return self.embeddings.word_embeddings
+
+    def set_input_embeddings(self, value):
+        self.embeddings.word_embeddings = value
+
+    def _prune_heads(self, heads_to_prune):
+        """
+        Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base
+        class PreTrainedModel
+        """
+        for layer, heads in heads_to_prune.items():
+            self.encoder.layer[layer].attention.prune_heads(heads)
+
+    @add_start_docstrings_to_model_forward(ESM_INPUTS_DOCSTRING.format("(batch_size, sequence_length)"))
+    @add_code_sample_docstrings(
+        checkpoint=_CHECKPOINT_FOR_DOC,
+        output_type=BaseModelOutputWithPoolingAndCrossAttentions,
+        config_class=_CONFIG_FOR_DOC,
+    )
+    def forward(
+        self,
+        input_ids: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.Tensor] = None,
+        head_mask: Optional[torch.Tensor] = None,
+        inputs_embeds: Optional[torch.Tensor] = None,
+        encoder_hidden_states: Optional[torch.Tensor] = None,
+        encoder_attention_mask: Optional[torch.Tensor] = None,
+        past_key_values: Optional[List[torch.FloatTensor]] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple[torch.Tensor], BaseModelOutputWithPoolingAndCrossAttentions]:
+        r"""
+        encoder_hidden_states  (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
+            Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if
+            the model is configured as a decoder.
+        encoder_attention_mask (`torch.FloatTensor` of shape `(batch_size, sequence_length)`, *optional*):
+            Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in
+            the cross-attention if the model is configured as a decoder. Mask values selected in `[0, 1]`:
+
+            - 1 for tokens that are **not masked**,
+            - 0 for tokens that are **masked**.
+        past_key_values (`tuple(tuple(torch.FloatTensor))` of length `config.n_layers` with each tuple having 4 tensors of shape `(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`):
+            Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.
+
+            If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that
+            don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all
+            `decoder_input_ids` of shape `(batch_size, sequence_length)`.
+        use_cache (`bool`, *optional*):
+            If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
+            `past_key_values`).
+        """
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        if self.config.is_decoder:
+            use_cache = use_cache if use_cache is not None else self.config.use_cache
+        else:
+            use_cache = False
+
+        if input_ids is not None and inputs_embeds is not None:
+            raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
+        elif input_ids is not None:
+            self.warn_if_padding_and_no_attention_mask(input_ids, attention_mask)
+            input_shape = input_ids.size()
+        elif inputs_embeds is not None:
+            input_shape = inputs_embeds.size()[:-1]
+        else:
+            raise ValueError("You have to specify either input_ids or inputs_embeds")
+
+        batch_size, seq_length = input_shape
+        device = input_ids.device if input_ids is not None else inputs_embeds.device
+
+        # past_key_values_length
+        past_key_values_length = past_key_values[0][0].shape[2] if past_key_values is not None else 0
+
+        if attention_mask is None:
+            attention_mask = torch.ones(((batch_size, seq_length + past_key_values_length)), device=device)
+
+        # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
+        # ourselves in which case we just need to make it broadcastable to all heads.
+        extended_attention_mask: torch.Tensor = self.get_extended_attention_mask(attention_mask, input_shape)
+
+        # If a 2D or 3D attention mask is provided for the cross-attention
+        # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]
+        if self.config.is_decoder and encoder_hidden_states is not None:
+            encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states.size()
+            encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length)
+            if encoder_attention_mask is None:
+                encoder_attention_mask = torch.ones(encoder_hidden_shape, device=device)
+            encoder_extended_attention_mask = self.invert_attention_mask(encoder_attention_mask)
+        else:
+            encoder_extended_attention_mask = None
+
+        # Prepare head mask if needed
+        # 1.0 in head_mask indicate we keep the head
+        # attention_probs has shape bsz x n_heads x N x N
+        # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
+        # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
+        head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)
+
+        embedding_output = self.embeddings(
+            input_ids=input_ids,
+            position_ids=position_ids,
+            attention_mask=attention_mask,
+            inputs_embeds=inputs_embeds,
+            past_key_values_length=past_key_values_length,
+        )
+        encoder_outputs = self.encoder(
+            embedding_output,
+            attention_mask=extended_attention_mask,
+            head_mask=head_mask,
+            encoder_hidden_states=encoder_hidden_states,
+            encoder_attention_mask=encoder_extended_attention_mask,
+            past_key_values=past_key_values,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+        sequence_output = encoder_outputs[0]
+        pooled_output = self.pooler(sequence_output) if self.pooler is not None else None
+
+        if not return_dict:
+            return (sequence_output, pooled_output) + encoder_outputs[1:]
+
+        return BaseModelOutputWithPoolingAndCrossAttentions(
+            last_hidden_state=sequence_output,
+            pooler_output=pooled_output,
+            past_key_values=encoder_outputs.past_key_values,
+            hidden_states=encoder_outputs.hidden_states,
+            attentions=encoder_outputs.attentions,
+            cross_attentions=encoder_outputs.cross_attentions,
+        )
+
+    def predict_contacts(self, tokens, attention_mask):
+        attns = self(tokens, attention_mask=attention_mask, return_dict=True, output_attentions=True).attentions
+        attns = torch.stack(attns, dim=1)  # Matches the original model layout
+        # In the original model, attentions for padding tokens are completely zeroed out.
+        # This makes no difference most of the time because the other tokens won't attend to them,
+        # but it does for the contact prediction task, which takes attentions as input,
+        # so we have to mimic that here.
+        attns *= attention_mask.unsqueeze(1).unsqueeze(2).unsqueeze(3)
+        attns *= attention_mask.unsqueeze(1).unsqueeze(2).unsqueeze(4)
+        return self.contact_head(tokens, attns)
+
+
+@add_start_docstrings("""ESM Model with a `language modeling` head on top.""", ESM_START_DOCSTRING)
+class EsmForMaskedLM(EsmPreTrainedModel):
+    _tied_weights_keys = ["lm_head.decoder.weight"]
+
+    def __init__(self, config):
+        super().__init__(config)
+
+        if config.is_decoder:
+            logger.warning(
+                "If you want to use `EsmForMaskedLM` make sure `config.is_decoder=False` for "
+                "bi-directional self-attention."
+            )
+
+        self.esm = EsmModel(config, add_pooling_layer=False)
+        self.lm_head = EsmLMHead(config)
+
+        self.init_weights()
+
+    def get_output_embeddings(self):
+        return self.lm_head.decoder
+
+    def set_output_embeddings(self, new_embeddings):
+        self.lm_head.decoder = new_embeddings
+
+    @add_start_docstrings_to_model_forward(ESM_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
+    @add_code_sample_docstrings(
+        checkpoint=_CHECKPOINT_FOR_DOC,
+        output_type=MaskedLMOutput,
+        config_class=_CONFIG_FOR_DOC,
+        mask="<mask>",
+    )
+    def forward(
+        self,
+        input_ids: Optional[torch.LongTensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        head_mask: Optional[torch.Tensor] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        encoder_hidden_states: Optional[torch.FloatTensor] = None,
+        encoder_attention_mask: Optional[torch.Tensor] = None,
+        labels: Optional[torch.LongTensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, MaskedLMOutput]:
+        r"""
+        labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+            Labels for computing the masked language modeling loss. Indices should be in `[-100, 0, ...,
+            config.vocab_size]` (see `input_ids` docstring) Tokens with indices set to `-100` are ignored (masked), the
+            loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`
+        kwargs (`Dict[str, any]`, optional, defaults to *{}*):
+            Used to hide legacy arguments that have been deprecated.
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        outputs = self.esm(
+            input_ids,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            encoder_hidden_states=encoder_hidden_states,
+            encoder_attention_mask=encoder_attention_mask,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+        sequence_output = outputs[0]
+        prediction_scores = self.lm_head(sequence_output)
+
+        masked_lm_loss = None
+        if labels is not None:
+            loss_fct = CrossEntropyLoss()
+
+            labels = labels.to(prediction_scores.device)
+            masked_lm_loss = loss_fct(prediction_scores.view(-1, self.config.vocab_size), labels.view(-1))
+
+        if not return_dict:
+            output = (prediction_scores,) + outputs[2:]
+            return ((masked_lm_loss,) + output) if masked_lm_loss is not None else output
+
+        return MaskedLMOutput(
+            loss=masked_lm_loss,
+            logits=prediction_scores,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+
+    def predict_contacts(self, tokens, attention_mask):
+        return self.esm.predict_contacts(tokens, attention_mask=attention_mask)
+
+
+class EsmLMHead(nn.Module):
+    """ESM Head for masked language modeling."""
+
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        self.layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+        self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+        self.bias = nn.Parameter(torch.zeros(config.vocab_size))
+
+    def forward(self, features, **kwargs):
+        x = self.dense(features)
+        x = gelu(x)
+        x = self.layer_norm(x)
+
+        # project back to size of vocabulary with bias
+        x = self.decoder(x) + self.bias
+        return x
+
+
+@add_start_docstrings(
+    """
+    ESM Model transformer with a sequence classification/regression head on top (a linear layer on top of the pooled
+    output) e.g. for GLUE tasks.
+    """,
+    ESM_START_DOCSTRING,
+)
+class EsmForSequenceClassification(EsmPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+        self.num_labels = config.num_labels
+        self.config = config
+
+        self.esm = EsmModel(config, add_pooling_layer=False)
+        self.classifier = EsmClassificationHead(config)
+
+        self.init_weights()
+
+    @add_start_docstrings_to_model_forward(ESM_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
+    @add_code_sample_docstrings(
+        checkpoint=_CHECKPOINT_FOR_DOC,
+        output_type=SequenceClassifierOutput,
+        config_class=_CONFIG_FOR_DOC,
+    )
+    def forward(
+        self,
+        input_ids: Optional[torch.LongTensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        head_mask: Optional[torch.Tensor] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        labels: Optional[torch.LongTensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, SequenceClassifierOutput]:
+        r"""
+        labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+            Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+            config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+            `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        outputs = self.esm(
+            input_ids,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+        sequence_output = outputs[0]
+        logits = self.classifier(sequence_output)
+
+        loss = None
+        if labels is not None:
+            labels = labels.to(logits.device)
+
+            if self.config.problem_type is None:
+                if self.num_labels == 1:
+                    self.config.problem_type = "regression"
+                elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
+                    self.config.problem_type = "single_label_classification"
+                else:
+                    self.config.problem_type = "multi_label_classification"
+
+            if self.config.problem_type == "regression":
+                loss_fct = MSELoss()
+                if self.num_labels == 1:
+                    loss = loss_fct(logits.squeeze(), labels.squeeze())
+                else:
+                    loss = loss_fct(logits, labels)
+            elif self.config.problem_type == "single_label_classification":
+                loss_fct = CrossEntropyLoss()
+                loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
+            elif self.config.problem_type == "multi_label_classification":
+                loss_fct = BCEWithLogitsLoss()
+                loss = loss_fct(logits, labels)
+
+        if not return_dict:
+            output = (logits,) + outputs[2:]
+            return ((loss,) + output) if loss is not None else output
+
+        return SequenceClassifierOutput(
+            loss=loss,
+            logits=logits,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+
+
+@add_start_docstrings(
+    """
+    ESM Model with a token classification head on top (a linear layer on top of the hidden-states output) e.g. for
+    Named-Entity-Recognition (NER) tasks.
+    """,
+    ESM_START_DOCSTRING,
+)
+class EsmForTokenClassification(EsmPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+        self.num_labels = config.num_labels
+
+        self.esm = EsmModel(config, add_pooling_layer=False)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+        self.classifier = nn.Linear(config.hidden_size, config.num_labels)
+
+        self.init_weights()
+
+    @add_start_docstrings_to_model_forward(ESM_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
+    @add_code_sample_docstrings(
+        checkpoint=_CHECKPOINT_FOR_DOC,
+        output_type=TokenClassifierOutput,
+        config_class=_CONFIG_FOR_DOC,
+    )
+    def forward(
+        self,
+        input_ids: Optional[torch.LongTensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        head_mask: Optional[torch.Tensor] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        labels: Optional[torch.LongTensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, TokenClassifierOutput]:
+        r"""
+        labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+            Labels for computing the token classification loss. Indices should be in `[0, ..., config.num_labels - 1]`.
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        outputs = self.esm(
+            input_ids,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        sequence_output = outputs[0]
+
+        sequence_output = self.dropout(sequence_output)
+        logits = self.classifier(sequence_output)
+
+        loss = None
+        if labels is not None:
+            loss_fct = CrossEntropyLoss()
+
+            labels = labels.to(logits.device)
+            loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
+
+        if not return_dict:
+            output = (logits,) + outputs[2:]
+            return ((loss,) + output) if loss is not None else output
+
+        return TokenClassifierOutput(
+            loss=loss,
+            logits=logits,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+
+
+class EsmClassificationHead(nn.Module):
+    """Head for sentence-level classification tasks."""
+
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+        self.out_proj = nn.Linear(config.hidden_size, config.num_labels)
+
+    def forward(self, features, **kwargs):
+        x = features[:, 0, :]  # take <s> token (equiv. to [CLS])
+        x = self.dropout(x)
+        x = self.dense(x)
+        x = torch.tanh(x)
+        x = self.dropout(x)
+        x = self.out_proj(x)
+        return x
+
+
+def create_position_ids_from_input_ids(input_ids, padding_idx, past_key_values_length=0):
+    """
+    Replace non-padding symbols with their position numbers. Position numbers begin at padding_idx+1. Padding symbols
+    are ignored. This is modified from fairseq's `utils.make_positions`.
+
+    Args:
+        x: torch.Tensor x:
+
+    Returns: torch.Tensor
+    """
+    # The series of casts and type-conversions here are carefully balanced to both work with ONNX export and XLA.
+    mask = input_ids.ne(padding_idx).int()
+    incremental_indices = (torch.cumsum(mask, dim=1).type_as(mask) + past_key_values_length) * mask
+    return incremental_indices.long() + padding_idx
diff --git a/openflamingo/lib/python3.10/site-packages/transformers/models/esm/openfold_utils/loss.py b/openflamingo/lib/python3.10/site-packages/transformers/models/esm/openfold_utils/loss.py
new file mode 100644
index 0000000000000000000000000000000000000000..8c442786dc82ba2ebe243923509ed76a40de2a01
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/transformers/models/esm/openfold_utils/loss.py
@@ -0,0 +1,105 @@
+# Copyright 2021 AlQuraishi Laboratory
+# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Dict, Optional, Tuple
+
+import torch
+
+
+def _calculate_bin_centers(boundaries: torch.Tensor) -> torch.Tensor:
+    step = boundaries[1] - boundaries[0]
+    bin_centers = boundaries + step / 2
+    bin_centers = torch.cat([bin_centers, (bin_centers[-1] + step).unsqueeze(-1)], dim=0)
+    return bin_centers
+
+
+def _calculate_expected_aligned_error(
+    alignment_confidence_breaks: torch.Tensor,
+    aligned_distance_error_probs: torch.Tensor,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    bin_centers = _calculate_bin_centers(alignment_confidence_breaks)
+    return (
+        torch.sum(aligned_distance_error_probs * bin_centers, dim=-1),
+        bin_centers[-1],
+    )
+
+
+def compute_predicted_aligned_error(
+    logits: torch.Tensor,
+    max_bin: int = 31,
+    no_bins: int = 64,
+    **kwargs,
+) -> Dict[str, torch.Tensor]:
+    """Computes aligned confidence metrics from logits.
+
+    Args:
+      logits: [*, num_res, num_res, num_bins] the logits output from
+        PredictedAlignedErrorHead.
+      max_bin: Maximum bin value
+      no_bins: Number of bins
+    Returns:
+      aligned_confidence_probs: [*, num_res, num_res, num_bins] the predicted
+        aligned error probabilities over bins for each residue pair.
+      predicted_aligned_error: [*, num_res, num_res] the expected aligned distance
+        error for each pair of residues.
+      max_predicted_aligned_error: [*] the maximum predicted error possible.
+    """
+    boundaries = torch.linspace(0, max_bin, steps=(no_bins - 1), device=logits.device)
+
+    aligned_confidence_probs = torch.nn.functional.softmax(logits, dim=-1)
+    predicted_aligned_error, max_predicted_aligned_error = _calculate_expected_aligned_error(
+        alignment_confidence_breaks=boundaries,
+        aligned_distance_error_probs=aligned_confidence_probs,
+    )
+
+    return {
+        "aligned_confidence_probs": aligned_confidence_probs,
+        "predicted_aligned_error": predicted_aligned_error,
+        "max_predicted_aligned_error": max_predicted_aligned_error,
+    }
+
+
+def compute_tm(
+    logits: torch.Tensor,
+    residue_weights: Optional[torch.Tensor] = None,
+    max_bin: int = 31,
+    no_bins: int = 64,
+    eps: float = 1e-8,
+    **kwargs,
+) -> torch.Tensor:
+    if residue_weights is None:
+        residue_weights = logits.new_ones(logits.shape[-2])
+
+    boundaries = torch.linspace(0, max_bin, steps=(no_bins - 1), device=logits.device)
+
+    bin_centers = _calculate_bin_centers(boundaries)
+    torch.sum(residue_weights)
+    n = logits.shape[-2]
+    clipped_n = max(n, 19)
+
+    d0 = 1.24 * (clipped_n - 15) ** (1.0 / 3) - 1.8
+
+    probs = torch.nn.functional.softmax(logits, dim=-1)
+
+    tm_per_bin = 1.0 / (1 + (bin_centers**2) / (d0**2))
+    predicted_tm_term = torch.sum(probs * tm_per_bin, dim=-1)
+
+    normed_residue_mask = residue_weights / (eps + residue_weights.sum())
+    per_alignment = torch.sum(predicted_tm_term * normed_residue_mask, dim=-1)
+
+    weighted = per_alignment * residue_weights
+
+    argmax = (weighted == torch.max(weighted)).nonzero()[0]
+    return per_alignment[tuple(argmax)]
diff --git a/openflamingo/lib/python3.10/site-packages/transformers/models/esm/openfold_utils/rigid_utils.py b/openflamingo/lib/python3.10/site-packages/transformers/models/esm/openfold_utils/rigid_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..2bc2fe5f5c4ebff888e2d66eae3647073be89b4f
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/transformers/models/esm/openfold_utils/rigid_utils.py
@@ -0,0 +1,1242 @@
+# Copyright 2021 AlQuraishi Laboratory
+# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from functools import lru_cache
+from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple
+
+import numpy as np
+import torch
+
+
+def rot_matmul(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
+    """
+    Performs matrix multiplication of two rotation matrix tensors. Written out by hand to avoid AMP downcasting.
+
+    Args:
+        a: [*, 3, 3] left multiplicand
+        b: [*, 3, 3] right multiplicand
+    Returns:
+        The product ab
+    """
+
+    def row_mul(i: int) -> torch.Tensor:
+        return torch.stack(
+            [
+                a[..., i, 0] * b[..., 0, 0] + a[..., i, 1] * b[..., 1, 0] + a[..., i, 2] * b[..., 2, 0],
+                a[..., i, 0] * b[..., 0, 1] + a[..., i, 1] * b[..., 1, 1] + a[..., i, 2] * b[..., 2, 1],
+                a[..., i, 0] * b[..., 0, 2] + a[..., i, 1] * b[..., 1, 2] + a[..., i, 2] * b[..., 2, 2],
+            ],
+            dim=-1,
+        )
+
+    return torch.stack(
+        [
+            row_mul(0),
+            row_mul(1),
+            row_mul(2),
+        ],
+        dim=-2,
+    )
+
+
+def rot_vec_mul(r: torch.Tensor, t: torch.Tensor) -> torch.Tensor:
+    """
+    Applies a rotation to a vector. Written out by hand to avoid transfer to avoid AMP downcasting.
+
+    Args:
+        r: [*, 3, 3] rotation matrices
+        t: [*, 3] coordinate tensors
+    Returns:
+        [*, 3] rotated coordinates
+    """
+    x, y, z = torch.unbind(t, dim=-1)
+    return torch.stack(
+        [
+            r[..., 0, 0] * x + r[..., 0, 1] * y + r[..., 0, 2] * z,
+            r[..., 1, 0] * x + r[..., 1, 1] * y + r[..., 1, 2] * z,
+            r[..., 2, 0] * x + r[..., 2, 1] * y + r[..., 2, 2] * z,
+        ],
+        dim=-1,
+    )
+
+
+@lru_cache(maxsize=None)
+def identity_rot_mats(
+    batch_dims: Tuple[int, ...],
+    dtype: Optional[torch.dtype] = None,
+    device: Optional[torch.device] = None,
+    requires_grad: bool = True,
+) -> torch.Tensor:
+    rots = torch.eye(3, dtype=dtype, device=device, requires_grad=requires_grad)
+    rots = rots.view(*((1,) * len(batch_dims)), 3, 3)
+    rots = rots.expand(*batch_dims, -1, -1)
+    rots = rots.contiguous()
+
+    return rots
+
+
+@lru_cache(maxsize=None)
+def identity_trans(
+    batch_dims: Tuple[int, ...],
+    dtype: Optional[torch.dtype] = None,
+    device: Optional[torch.device] = None,
+    requires_grad: bool = True,
+) -> torch.Tensor:
+    trans = torch.zeros((*batch_dims, 3), dtype=dtype, device=device, requires_grad=requires_grad)
+    return trans
+
+
+@lru_cache(maxsize=None)
+def identity_quats(
+    batch_dims: Tuple[int, ...],
+    dtype: Optional[torch.dtype] = None,
+    device: Optional[torch.device] = None,
+    requires_grad: bool = True,
+) -> torch.Tensor:
+    quat = torch.zeros((*batch_dims, 4), dtype=dtype, device=device, requires_grad=requires_grad)
+
+    with torch.no_grad():
+        quat[..., 0] = 1
+
+    return quat
+
+
+_quat_elements: List[str] = ["a", "b", "c", "d"]
+_qtr_keys: List[str] = [l1 + l2 for l1 in _quat_elements for l2 in _quat_elements]
+_qtr_ind_dict: Dict[str, int] = {key: ind for ind, key in enumerate(_qtr_keys)}
+
+
+def _to_mat(pairs: List[Tuple[str, int]]) -> np.ndarray:
+    mat = np.zeros((4, 4))
+    for key, value in pairs:
+        ind = _qtr_ind_dict[key]
+        mat[ind // 4][ind % 4] = value
+
+    return mat
+
+
+_QTR_MAT = np.zeros((4, 4, 3, 3))
+_QTR_MAT[..., 0, 0] = _to_mat([("aa", 1), ("bb", 1), ("cc", -1), ("dd", -1)])
+_QTR_MAT[..., 0, 1] = _to_mat([("bc", 2), ("ad", -2)])
+_QTR_MAT[..., 0, 2] = _to_mat([("bd", 2), ("ac", 2)])
+_QTR_MAT[..., 1, 0] = _to_mat([("bc", 2), ("ad", 2)])
+_QTR_MAT[..., 1, 1] = _to_mat([("aa", 1), ("bb", -1), ("cc", 1), ("dd", -1)])
+_QTR_MAT[..., 1, 2] = _to_mat([("cd", 2), ("ab", -2)])
+_QTR_MAT[..., 2, 0] = _to_mat([("bd", 2), ("ac", -2)])
+_QTR_MAT[..., 2, 1] = _to_mat([("cd", 2), ("ab", 2)])
+_QTR_MAT[..., 2, 2] = _to_mat([("aa", 1), ("bb", -1), ("cc", -1), ("dd", 1)])
+
+
+def quat_to_rot(quat: torch.Tensor) -> torch.Tensor:
+    """
+    Converts a quaternion to a rotation matrix.
+
+    Args:
+        quat: [*, 4] quaternions
+    Returns:
+        [*, 3, 3] rotation matrices
+    """
+    # [*, 4, 4]
+    quat = quat[..., None] * quat[..., None, :]
+
+    # [4, 4, 3, 3]
+    mat = _get_quat("_QTR_MAT", dtype=quat.dtype, device=quat.device)
+
+    # [*, 4, 4, 3, 3]
+    shaped_qtr_mat = mat.view((1,) * len(quat.shape[:-2]) + mat.shape)
+    quat = quat[..., None, None] * shaped_qtr_mat
+
+    # [*, 3, 3]
+    return torch.sum(quat, dim=(-3, -4))
+
+
+def rot_to_quat(rot: torch.Tensor) -> torch.Tensor:
+    if rot.shape[-2:] != (3, 3):
+        raise ValueError("Input rotation is incorrectly shaped")
+
+    [[xx, xy, xz], [yx, yy, yz], [zx, zy, zz]] = [[rot[..., i, j] for j in range(3)] for i in range(3)]
+
+    k = [
+        [
+            xx + yy + zz,
+            zy - yz,
+            xz - zx,
+            yx - xy,
+        ],
+        [
+            zy - yz,
+            xx - yy - zz,
+            xy + yx,
+            xz + zx,
+        ],
+        [
+            xz - zx,
+            xy + yx,
+            yy - xx - zz,
+            yz + zy,
+        ],
+        [
+            yx - xy,
+            xz + zx,
+            yz + zy,
+            zz - xx - yy,
+        ],
+    ]
+
+    _, vectors = torch.linalg.eigh((1.0 / 3.0) * torch.stack([torch.stack(t, dim=-1) for t in k], dim=-2))
+    return vectors[..., -1]
+
+
+_QUAT_MULTIPLY = np.zeros((4, 4, 4))
+_QUAT_MULTIPLY[:, :, 0] = [[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0], [0, 0, 0, -1]]
+
+_QUAT_MULTIPLY[:, :, 1] = [[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, -1, 0]]
+
+_QUAT_MULTIPLY[:, :, 2] = [[0, 0, 1, 0], [0, 0, 0, -1], [1, 0, 0, 0], [0, 1, 0, 0]]
+
+_QUAT_MULTIPLY[:, :, 3] = [[0, 0, 0, 1], [0, 0, 1, 0], [0, -1, 0, 0], [1, 0, 0, 0]]
+
+_QUAT_MULTIPLY_BY_VEC = _QUAT_MULTIPLY[:, 1:, :]
+
+_CACHED_QUATS: Dict[str, np.ndarray] = {
+    "_QTR_MAT": _QTR_MAT,
+    "_QUAT_MULTIPLY": _QUAT_MULTIPLY,
+    "_QUAT_MULTIPLY_BY_VEC": _QUAT_MULTIPLY_BY_VEC,
+}
+
+
+@lru_cache(maxsize=None)
+def _get_quat(quat_key: str, dtype: torch.dtype, device: torch.device) -> torch.Tensor:
+    return torch.tensor(_CACHED_QUATS[quat_key], dtype=dtype, device=device)
+
+
+def quat_multiply(quat1: torch.Tensor, quat2: torch.Tensor) -> torch.Tensor:
+    """Multiply a quaternion by another quaternion."""
+    mat = _get_quat("_QUAT_MULTIPLY", dtype=quat1.dtype, device=quat1.device)
+    reshaped_mat = mat.view((1,) * len(quat1.shape[:-1]) + mat.shape)
+    return torch.sum(reshaped_mat * quat1[..., :, None, None] * quat2[..., None, :, None], dim=(-3, -2))
+
+
+def quat_multiply_by_vec(quat: torch.Tensor, vec: torch.Tensor) -> torch.Tensor:
+    """Multiply a quaternion by a pure-vector quaternion."""
+    mat = _get_quat("_QUAT_MULTIPLY_BY_VEC", dtype=quat.dtype, device=quat.device)
+    reshaped_mat = mat.view((1,) * len(quat.shape[:-1]) + mat.shape)
+    return torch.sum(reshaped_mat * quat[..., :, None, None] * vec[..., None, :, None], dim=(-3, -2))
+
+
+def invert_rot_mat(rot_mat: torch.Tensor) -> torch.Tensor:
+    return rot_mat.transpose(-1, -2)
+
+
+def invert_quat(quat: torch.Tensor) -> torch.Tensor:
+    quat_prime = quat.clone()
+    quat_prime[..., 1:] *= -1
+    inv = quat_prime / torch.sum(quat**2, dim=-1, keepdim=True)
+    return inv
+
+
+class Rotation:
+    """
+    A 3D rotation. Depending on how the object is initialized, the rotation is represented by either a rotation matrix
+    or a quaternion, though both formats are made available by helper functions. To simplify gradient computation, the
+    underlying format of the rotation cannot be changed in-place. Like Rigid, the class is designed to mimic the
+    behavior of a torch Tensor, almost as if each Rotation object were a tensor of rotations, in one format or another.
+    """
+
+    def __init__(
+        self,
+        rot_mats: Optional[torch.Tensor] = None,
+        quats: Optional[torch.Tensor] = None,
+        normalize_quats: bool = True,
+    ):
+        """
+        Args:
+            rot_mats:
+                A [*, 3, 3] rotation matrix tensor. Mutually exclusive with quats
+            quats:
+                A [*, 4] quaternion. Mutually exclusive with rot_mats. If normalize_quats is not True, must be a unit
+                quaternion
+            normalize_quats:
+                If quats is specified, whether to normalize quats
+        """
+        if (rot_mats is None and quats is None) or (rot_mats is not None and quats is not None):
+            raise ValueError("Exactly one input argument must be specified")
+
+        if (rot_mats is not None and rot_mats.shape[-2:] != (3, 3)) or (quats is not None and quats.shape[-1] != 4):
+            raise ValueError("Incorrectly shaped rotation matrix or quaternion")
+
+        # Force full-precision
+        if quats is not None:
+            quats = quats.to(dtype=torch.float32)
+        if rot_mats is not None:
+            rot_mats = rot_mats.to(dtype=torch.float32)
+
+        if quats is not None and normalize_quats:
+            quats = quats / torch.linalg.norm(quats, dim=-1, keepdim=True)
+
+        self._rot_mats = rot_mats
+        self._quats = quats
+
+    @staticmethod
+    def identity(
+        shape,
+        dtype: Optional[torch.dtype] = None,
+        device: Optional[torch.device] = None,
+        requires_grad: bool = True,
+        fmt: str = "quat",
+    ) -> Rotation:
+        """
+        Returns an identity Rotation.
+
+        Args:
+            shape:
+                The "shape" of the resulting Rotation object. See documentation for the shape property
+            dtype:
+                The torch dtype for the rotation
+            device:
+                The torch device for the new rotation
+            requires_grad:
+                Whether the underlying tensors in the new rotation object should require gradient computation
+            fmt:
+                One of "quat" or "rot_mat". Determines the underlying format of the new object's rotation
+        Returns:
+            A new identity rotation
+        """
+        if fmt == "rot_mat":
+            rot_mats = identity_rot_mats(
+                shape,
+                dtype,
+                device,
+                requires_grad,
+            )
+            return Rotation(rot_mats=rot_mats, quats=None)
+        elif fmt == "quat":
+            quats = identity_quats(shape, dtype, device, requires_grad)
+            return Rotation(rot_mats=None, quats=quats, normalize_quats=False)
+        else:
+            raise ValueError(f"Invalid format: f{fmt}")
+
+    # Magic methods
+
+    def __getitem__(self, index: Any) -> Rotation:
+        """
+        Allows torch-style indexing over the virtual shape of the rotation object. See documentation for the shape
+        property.
+
+        Args:
+            index:
+                A torch index. E.g. (1, 3, 2), or (slice(None,))
+        Returns:
+            The indexed rotation
+        """
+        if type(index) != tuple:
+            index = (index,)
+
+        if self._rot_mats is not None:
+            rot_mats = self._rot_mats[index + (slice(None), slice(None))]
+            return Rotation(rot_mats=rot_mats)
+        elif self._quats is not None:
+            quats = self._quats[index + (slice(None),)]
+            return Rotation(quats=quats, normalize_quats=False)
+        else:
+            raise ValueError("Both rotations are None")
+
+    def __mul__(self, right: torch.Tensor) -> Rotation:
+        """
+        Pointwise left multiplication of the rotation with a tensor. Can be used to e.g. mask the Rotation.
+
+        Args:
+            right:
+                The tensor multiplicand
+        Returns:
+            The product
+        """
+        if not (isinstance(right, torch.Tensor)):
+            raise TypeError("The other multiplicand must be a Tensor")
+
+        if self._rot_mats is not None:
+            rot_mats = self._rot_mats * right[..., None, None]
+            return Rotation(rot_mats=rot_mats, quats=None)
+        elif self._quats is not None:
+            quats = self._quats * right[..., None]
+            return Rotation(rot_mats=None, quats=quats, normalize_quats=False)
+        else:
+            raise ValueError("Both rotations are None")
+
+    def __rmul__(self, left: torch.Tensor) -> Rotation:
+        """
+        Reverse pointwise multiplication of the rotation with a tensor.
+
+        Args:
+            left:
+                The left multiplicand
+        Returns:
+            The product
+        """
+        return self.__mul__(left)
+
+    # Properties
+
+    @property
+    def shape(self) -> torch.Size:
+        """
+        Returns the virtual shape of the rotation object. This shape is defined as the batch dimensions of the
+        underlying rotation matrix or quaternion. If the Rotation was initialized with a [10, 3, 3] rotation matrix
+        tensor, for example, the resulting shape would be [10].
+
+        Returns:
+            The virtual shape of the rotation object
+        """
+        if self._rot_mats is not None:
+            return self._rot_mats.shape[:-2]
+        elif self._quats is not None:
+            return self._quats.shape[:-1]
+        else:
+            raise ValueError("Both rotations are None")
+
+    @property
+    def dtype(self) -> torch.dtype:
+        """
+        Returns the dtype of the underlying rotation.
+
+        Returns:
+            The dtype of the underlying rotation
+        """
+        if self._rot_mats is not None:
+            return self._rot_mats.dtype
+        elif self._quats is not None:
+            return self._quats.dtype
+        else:
+            raise ValueError("Both rotations are None")
+
+    @property
+    def device(self) -> torch.device:
+        """
+        The device of the underlying rotation
+
+        Returns:
+            The device of the underlying rotation
+        """
+        if self._rot_mats is not None:
+            return self._rot_mats.device
+        elif self._quats is not None:
+            return self._quats.device
+        else:
+            raise ValueError("Both rotations are None")
+
+    @property
+    def requires_grad(self) -> bool:
+        """
+        Returns the requires_grad property of the underlying rotation
+
+        Returns:
+            The requires_grad property of the underlying tensor
+        """
+        if self._rot_mats is not None:
+            return self._rot_mats.requires_grad
+        elif self._quats is not None:
+            return self._quats.requires_grad
+        else:
+            raise ValueError("Both rotations are None")
+
+    def get_rot_mats(self) -> torch.Tensor:
+        """
+        Returns the underlying rotation as a rotation matrix tensor.
+
+        Returns:
+            The rotation as a rotation matrix tensor
+        """
+        if self._rot_mats is not None:
+            return self._rot_mats
+        elif self._quats is not None:
+            return quat_to_rot(self._quats)
+        else:
+            raise ValueError("Both rotations are None")
+
+    def get_quats(self) -> torch.Tensor:
+        """
+        Returns the underlying rotation as a quaternion tensor.
+
+        Depending on whether the Rotation was initialized with a quaternion, this function may call torch.linalg.eigh.
+
+        Returns:
+            The rotation as a quaternion tensor.
+        """
+        if self._rot_mats is not None:
+            return rot_to_quat(self._rot_mats)
+        elif self._quats is not None:
+            return self._quats
+        else:
+            raise ValueError("Both rotations are None")
+
+    def get_cur_rot(self) -> torch.Tensor:
+        """
+        Return the underlying rotation in its current form
+
+        Returns:
+            The stored rotation
+        """
+        if self._rot_mats is not None:
+            return self._rot_mats
+        elif self._quats is not None:
+            return self._quats
+        else:
+            raise ValueError("Both rotations are None")
+
+    # Rotation functions
+
+    def compose_q_update_vec(self, q_update_vec: torch.Tensor, normalize_quats: bool = True) -> Rotation:
+        """
+        Returns a new quaternion Rotation after updating the current object's underlying rotation with a quaternion
+        update, formatted as a [*, 3] tensor whose final three columns represent x, y, z such that (1, x, y, z) is the
+        desired (not necessarily unit) quaternion update.
+
+        Args:
+            q_update_vec:
+                A [*, 3] quaternion update tensor
+            normalize_quats:
+                Whether to normalize the output quaternion
+        Returns:
+            An updated Rotation
+        """
+        quats = self.get_quats()
+        new_quats = quats + quat_multiply_by_vec(quats, q_update_vec)
+        return Rotation(
+            rot_mats=None,
+            quats=new_quats,
+            normalize_quats=normalize_quats,
+        )
+
+    def compose_r(self, r: Rotation) -> Rotation:
+        """
+        Compose the rotation matrices of the current Rotation object with those of another.
+
+        Args:
+            r:
+                An update rotation object
+        Returns:
+            An updated rotation object
+        """
+        r1 = self.get_rot_mats()
+        r2 = r.get_rot_mats()
+        new_rot_mats = rot_matmul(r1, r2)
+        return Rotation(rot_mats=new_rot_mats, quats=None)
+
+    def compose_q(self, r: Rotation, normalize_quats: bool = True) -> Rotation:
+        """
+        Compose the quaternions of the current Rotation object with those of another.
+
+        Depending on whether either Rotation was initialized with quaternions, this function may call
+        torch.linalg.eigh.
+
+        Args:
+            r:
+                An update rotation object
+        Returns:
+            An updated rotation object
+        """
+        q1 = self.get_quats()
+        q2 = r.get_quats()
+        new_quats = quat_multiply(q1, q2)
+        return Rotation(rot_mats=None, quats=new_quats, normalize_quats=normalize_quats)
+
+    def apply(self, pts: torch.Tensor) -> torch.Tensor:
+        """
+        Apply the current Rotation as a rotation matrix to a set of 3D coordinates.
+
+        Args:
+            pts:
+                A [*, 3] set of points
+        Returns:
+            [*, 3] rotated points
+        """
+        rot_mats = self.get_rot_mats()
+        return rot_vec_mul(rot_mats, pts)
+
+    def invert_apply(self, pts: torch.Tensor) -> torch.Tensor:
+        """
+        The inverse of the apply() method.
+
+        Args:
+            pts:
+                A [*, 3] set of points
+        Returns:
+            [*, 3] inverse-rotated points
+        """
+        rot_mats = self.get_rot_mats()
+        inv_rot_mats = invert_rot_mat(rot_mats)
+        return rot_vec_mul(inv_rot_mats, pts)
+
+    def invert(self) -> Rotation:
+        """
+        Returns the inverse of the current Rotation.
+
+        Returns:
+            The inverse of the current Rotation
+        """
+        if self._rot_mats is not None:
+            return Rotation(rot_mats=invert_rot_mat(self._rot_mats), quats=None)
+        elif self._quats is not None:
+            return Rotation(
+                rot_mats=None,
+                quats=invert_quat(self._quats),
+                normalize_quats=False,
+            )
+        else:
+            raise ValueError("Both rotations are None")
+
+    # "Tensor" stuff
+
+    def unsqueeze(self, dim: int) -> Rotation:
+        """
+        Analogous to torch.unsqueeze. The dimension is relative to the shape of the Rotation object.
+
+        Args:
+            dim: A positive or negative dimension index.
+        Returns:
+            The unsqueezed Rotation.
+        """
+        if dim >= len(self.shape):
+            raise ValueError("Invalid dimension")
+
+        if self._rot_mats is not None:
+            rot_mats = self._rot_mats.unsqueeze(dim if dim >= 0 else dim - 2)
+            return Rotation(rot_mats=rot_mats, quats=None)
+        elif self._quats is not None:
+            quats = self._quats.unsqueeze(dim if dim >= 0 else dim - 1)
+            return Rotation(rot_mats=None, quats=quats, normalize_quats=False)
+        else:
+            raise ValueError("Both rotations are None")
+
+    @staticmethod
+    def cat(rs: Sequence[Rotation], dim: int) -> Rotation:
+        """
+        Concatenates rotations along one of the batch dimensions. Analogous to torch.cat().
+
+        Note that the output of this operation is always a rotation matrix, regardless of the format of input
+        rotations.
+
+        Args:
+            rs:
+                A list of rotation objects
+            dim:
+                The dimension along which the rotations should be concatenated
+        Returns:
+            A concatenated Rotation object in rotation matrix format
+        """
+        rot_mats = torch.cat(
+            [r.get_rot_mats() for r in rs],
+            dim=dim if dim >= 0 else dim - 2,
+        )
+
+        return Rotation(rot_mats=rot_mats, quats=None)
+
+    def map_tensor_fn(self, fn: Callable[[torch.Tensor], torch.Tensor]) -> Rotation:
+        """
+        Apply a Tensor -> Tensor function to underlying rotation tensors, mapping over the rotation dimension(s). Can
+        be used e.g. to sum out a one-hot batch dimension.
+
+        Args:
+            fn:
+                A Tensor -> Tensor function to be mapped over the Rotation
+        Returns:
+            The transformed Rotation object
+        """
+        if self._rot_mats is not None:
+            rot_mats = self._rot_mats.view(self._rot_mats.shape[:-2] + (9,))
+            rot_mats = torch.stack(list(map(fn, torch.unbind(rot_mats, dim=-1))), dim=-1)
+            rot_mats = rot_mats.view(rot_mats.shape[:-1] + (3, 3))
+            return Rotation(rot_mats=rot_mats, quats=None)
+        elif self._quats is not None:
+            quats = torch.stack(list(map(fn, torch.unbind(self._quats, dim=-1))), dim=-1)
+            return Rotation(rot_mats=None, quats=quats, normalize_quats=False)
+        else:
+            raise ValueError("Both rotations are None")
+
+    def cuda(self) -> Rotation:
+        """
+        Analogous to the cuda() method of torch Tensors
+
+        Returns:
+            A copy of the Rotation in CUDA memory
+        """
+        if self._rot_mats is not None:
+            return Rotation(rot_mats=self._rot_mats.cuda(), quats=None)
+        elif self._quats is not None:
+            return Rotation(rot_mats=None, quats=self._quats.cuda(), normalize_quats=False)
+        else:
+            raise ValueError("Both rotations are None")
+
+    def to(self, device: Optional[torch.device], dtype: Optional[torch.dtype]) -> Rotation:
+        """
+        Analogous to the to() method of torch Tensors
+
+        Args:
+            device:
+                A torch device
+            dtype:
+                A torch dtype
+        Returns:
+            A copy of the Rotation using the new device and dtype
+        """
+        if self._rot_mats is not None:
+            return Rotation(
+                rot_mats=self._rot_mats.to(device=device, dtype=dtype),
+                quats=None,
+            )
+        elif self._quats is not None:
+            return Rotation(
+                rot_mats=None,
+                quats=self._quats.to(device=device, dtype=dtype),
+                normalize_quats=False,
+            )
+        else:
+            raise ValueError("Both rotations are None")
+
+    def detach(self) -> Rotation:
+        """
+        Returns a copy of the Rotation whose underlying Tensor has been detached from its torch graph.
+
+        Returns:
+            A copy of the Rotation whose underlying Tensor has been detached from its torch graph
+        """
+        if self._rot_mats is not None:
+            return Rotation(rot_mats=self._rot_mats.detach(), quats=None)
+        elif self._quats is not None:
+            return Rotation(
+                rot_mats=None,
+                quats=self._quats.detach(),
+                normalize_quats=False,
+            )
+        else:
+            raise ValueError("Both rotations are None")
+
+
+class Rigid:
+    """
+    A class representing a rigid transformation. Little more than a wrapper around two objects: a Rotation object and a
+    [*, 3] translation Designed to behave approximately like a single torch tensor with the shape of the shared batch
+    dimensions of its component parts.
+    """
+
+    def __init__(self, rots: Optional[Rotation], trans: Optional[torch.Tensor]):
+        """
+        Args:
+            rots: A [*, 3, 3] rotation tensor
+            trans: A corresponding [*, 3] translation tensor
+        """
+        # (we need device, dtype, etc. from at least one input)
+
+        batch_dims, dtype, device, requires_grad = None, None, None, None
+        if trans is not None:
+            batch_dims = trans.shape[:-1]
+            dtype = trans.dtype
+            device = trans.device
+            requires_grad = trans.requires_grad
+        elif rots is not None:
+            batch_dims = rots.shape
+            dtype = rots.dtype
+            device = rots.device
+            requires_grad = rots.requires_grad
+        else:
+            raise ValueError("At least one input argument must be specified")
+
+        if rots is None:
+            rots = Rotation.identity(
+                batch_dims,
+                dtype,
+                device,
+                requires_grad,
+            )
+        elif trans is None:
+            trans = identity_trans(
+                batch_dims,
+                dtype,
+                device,
+                requires_grad,
+            )
+
+        assert rots is not None
+        assert trans is not None
+
+        if (rots.shape != trans.shape[:-1]) or (rots.device != trans.device):
+            raise ValueError("Rots and trans incompatible")
+
+        # Force full precision. Happens to the rotations automatically.
+        trans = trans.to(dtype=torch.float32)
+
+        self._rots = rots
+        self._trans = trans
+
+    @staticmethod
+    def identity(
+        shape: Tuple[int, ...],
+        dtype: Optional[torch.dtype] = None,
+        device: Optional[torch.device] = None,
+        requires_grad: bool = True,
+        fmt: str = "quat",
+    ) -> Rigid:
+        """
+        Constructs an identity transformation.
+
+        Args:
+            shape:
+                The desired shape
+            dtype:
+                The dtype of both internal tensors
+            device:
+                The device of both internal tensors
+            requires_grad:
+                Whether grad should be enabled for the internal tensors
+        Returns:
+            The identity transformation
+        """
+        return Rigid(
+            Rotation.identity(shape, dtype, device, requires_grad, fmt=fmt),
+            identity_trans(shape, dtype, device, requires_grad),
+        )
+
+    def __getitem__(self, index: Any) -> Rigid:
+        """
+        Indexes the affine transformation with PyTorch-style indices. The index is applied to the shared dimensions of
+        both the rotation and the translation.
+
+        E.g.::
+
+            r = Rotation(rot_mats=torch.rand(10, 10, 3, 3), quats=None) t = Rigid(r, torch.rand(10, 10, 3)) indexed =
+            t[3, 4:6] assert(indexed.shape == (2,)) assert(indexed.get_rots().shape == (2,))
+            assert(indexed.get_trans().shape == (2, 3))
+
+        Args:
+            index: A standard torch tensor index. E.g. 8, (10, None, 3),
+            or (3, slice(0, 1, None))
+        Returns:
+            The indexed tensor
+        """
+        if type(index) != tuple:
+            index = (index,)
+
+        return Rigid(
+            self._rots[index],
+            self._trans[index + (slice(None),)],
+        )
+
+    def __mul__(self, right: torch.Tensor) -> Rigid:
+        """
+        Pointwise left multiplication of the transformation with a tensor. Can be used to e.g. mask the Rigid.
+
+        Args:
+            right:
+                The tensor multiplicand
+        Returns:
+            The product
+        """
+        if not (isinstance(right, torch.Tensor)):
+            raise TypeError("The other multiplicand must be a Tensor")
+
+        new_rots = self._rots * right
+        new_trans = self._trans * right[..., None]
+
+        return Rigid(new_rots, new_trans)
+
+    def __rmul__(self, left: torch.Tensor) -> Rigid:
+        """
+        Reverse pointwise multiplication of the transformation with a tensor.
+
+        Args:
+            left:
+                The left multiplicand
+        Returns:
+            The product
+        """
+        return self.__mul__(left)
+
+    @property
+    def shape(self) -> torch.Size:
+        """
+        Returns the shape of the shared dimensions of the rotation and the translation.
+
+        Returns:
+            The shape of the transformation
+        """
+        return self._trans.shape[:-1]
+
+    @property
+    def device(self) -> torch.device:
+        """
+        Returns the device on which the Rigid's tensors are located.
+
+        Returns:
+            The device on which the Rigid's tensors are located
+        """
+        return self._trans.device
+
+    def get_rots(self) -> Rotation:
+        """
+        Getter for the rotation.
+
+        Returns:
+            The rotation object
+        """
+        return self._rots
+
+    def get_trans(self) -> torch.Tensor:
+        """
+        Getter for the translation.
+
+        Returns:
+            The stored translation
+        """
+        return self._trans
+
+    def compose_q_update_vec(self, q_update_vec: torch.Tensor) -> Rigid:
+        """
+        Composes the transformation with a quaternion update vector of shape [*, 6], where the final 6 columns
+        represent the x, y, and z values of a quaternion of form (1, x, y, z) followed by a 3D translation.
+
+        Args:
+            q_vec: The quaternion update vector.
+        Returns:
+            The composed transformation.
+        """
+        q_vec, t_vec = q_update_vec[..., :3], q_update_vec[..., 3:]
+        new_rots = self._rots.compose_q_update_vec(q_vec)
+
+        trans_update = self._rots.apply(t_vec)
+        new_translation = self._trans + trans_update
+
+        return Rigid(new_rots, new_translation)
+
+    def compose(self, r: Rigid) -> Rigid:
+        """
+        Composes the current rigid object with another.
+
+        Args:
+            r:
+                Another Rigid object
+        Returns:
+            The composition of the two transformations
+        """
+        new_rot = self._rots.compose_r(r._rots)
+        new_trans = self._rots.apply(r._trans) + self._trans
+        return Rigid(new_rot, new_trans)
+
+    def apply(self, pts: torch.Tensor) -> torch.Tensor:
+        """
+        Applies the transformation to a coordinate tensor.
+
+        Args:
+            pts: A [*, 3] coordinate tensor.
+        Returns:
+            The transformed points.
+        """
+        rotated = self._rots.apply(pts)
+        return rotated + self._trans
+
+    def invert_apply(self, pts: torch.Tensor) -> torch.Tensor:
+        """
+        Applies the inverse of the transformation to a coordinate tensor.
+
+        Args:
+            pts: A [*, 3] coordinate tensor
+        Returns:
+            The transformed points.
+        """
+        pts = pts - self._trans
+        return self._rots.invert_apply(pts)
+
+    def invert(self) -> Rigid:
+        """
+        Inverts the transformation.
+
+        Returns:
+            The inverse transformation.
+        """
+        rot_inv = self._rots.invert()
+        trn_inv = rot_inv.apply(self._trans)
+
+        return Rigid(rot_inv, -1 * trn_inv)
+
+    def map_tensor_fn(self, fn: Callable[[torch.Tensor], torch.Tensor]) -> Rigid:
+        """
+        Apply a Tensor -> Tensor function to underlying translation and rotation tensors, mapping over the
+        translation/rotation dimensions respectively.
+
+        Args:
+            fn:
+                A Tensor -> Tensor function to be mapped over the Rigid
+        Returns:
+            The transformed Rigid object
+        """
+        new_rots = self._rots.map_tensor_fn(fn)
+        new_trans = torch.stack(list(map(fn, torch.unbind(self._trans, dim=-1))), dim=-1)
+
+        return Rigid(new_rots, new_trans)
+
+    def to_tensor_4x4(self) -> torch.Tensor:
+        """
+        Converts a transformation to a homogenous transformation tensor.
+
+        Returns:
+            A [*, 4, 4] homogenous transformation tensor
+        """
+        tensor = self._trans.new_zeros((*self.shape, 4, 4))
+        tensor[..., :3, :3] = self._rots.get_rot_mats()
+        tensor[..., :3, 3] = self._trans
+        tensor[..., 3, 3] = 1
+        return tensor
+
+    @staticmethod
+    def from_tensor_4x4(t: torch.Tensor) -> Rigid:
+        """
+        Constructs a transformation from a homogenous transformation tensor.
+
+        Args:
+            t: [*, 4, 4] homogenous transformation tensor
+        Returns:
+            T object with shape [*]
+        """
+        if t.shape[-2:] != (4, 4):
+            raise ValueError("Incorrectly shaped input tensor")
+
+        rots = Rotation(rot_mats=t[..., :3, :3], quats=None)
+        trans = t[..., :3, 3]
+
+        return Rigid(rots, trans)
+
+    def to_tensor_7(self) -> torch.Tensor:
+        """
+        Converts a transformation to a tensor with 7 final columns, four for the quaternion followed by three for the
+        translation.
+
+        Returns:
+            A [*, 7] tensor representation of the transformation
+        """
+        tensor = self._trans.new_zeros((*self.shape, 7))
+        tensor[..., :4] = self._rots.get_quats()
+        tensor[..., 4:] = self._trans
+
+        return tensor
+
+    @staticmethod
+    def from_tensor_7(t: torch.Tensor, normalize_quats: bool = False) -> Rigid:
+        if t.shape[-1] != 7:
+            raise ValueError("Incorrectly shaped input tensor")
+
+        quats, trans = t[..., :4], t[..., 4:]
+
+        rots = Rotation(rot_mats=None, quats=quats, normalize_quats=normalize_quats)
+
+        return Rigid(rots, trans)
+
+    @staticmethod
+    def from_3_points(
+        p_neg_x_axis: torch.Tensor, origin: torch.Tensor, p_xy_plane: torch.Tensor, eps: float = 1e-8
+    ) -> Rigid:
+        """
+        Implements algorithm 21. Constructs transformations from sets of 3 points using the Gram-Schmidt algorithm.
+
+        Args:
+            p_neg_x_axis: [*, 3] coordinates
+            origin: [*, 3] coordinates used as frame origins
+            p_xy_plane: [*, 3] coordinates
+            eps: Small epsilon value
+        Returns:
+            A transformation object of shape [*]
+        """
+        p_neg_x_axis_unbound = torch.unbind(p_neg_x_axis, dim=-1)
+        origin_unbound = torch.unbind(origin, dim=-1)
+        p_xy_plane_unbound = torch.unbind(p_xy_plane, dim=-1)
+
+        e0 = [c1 - c2 for c1, c2 in zip(origin_unbound, p_neg_x_axis_unbound)]
+        e1 = [c1 - c2 for c1, c2 in zip(p_xy_plane_unbound, origin_unbound)]
+
+        denom = torch.sqrt(sum(c * c for c in e0) + eps * torch.ones_like(e0[0]))
+        e0 = [c / denom for c in e0]
+        dot = sum((c1 * c2 for c1, c2 in zip(e0, e1)))
+        e1 = [c2 - c1 * dot for c1, c2 in zip(e0, e1)]
+        denom = torch.sqrt(sum((c * c for c in e1)) + eps * torch.ones_like(e1[0]))
+        e1 = [c / denom for c in e1]
+        e2 = [
+            e0[1] * e1[2] - e0[2] * e1[1],
+            e0[2] * e1[0] - e0[0] * e1[2],
+            e0[0] * e1[1] - e0[1] * e1[0],
+        ]
+
+        rots = torch.stack([c for tup in zip(e0, e1, e2) for c in tup], dim=-1)
+        rots = rots.reshape(rots.shape[:-1] + (3, 3))
+
+        rot_obj = Rotation(rot_mats=rots, quats=None)
+
+        return Rigid(rot_obj, torch.stack(origin_unbound, dim=-1))
+
+    def unsqueeze(self, dim: int) -> Rigid:
+        """
+        Analogous to torch.unsqueeze. The dimension is relative to the shared dimensions of the rotation/translation.
+
+        Args:
+            dim: A positive or negative dimension index.
+        Returns:
+            The unsqueezed transformation.
+        """
+        if dim >= len(self.shape):
+            raise ValueError("Invalid dimension")
+        rots = self._rots.unsqueeze(dim)
+        trans = self._trans.unsqueeze(dim if dim >= 0 else dim - 1)
+
+        return Rigid(rots, trans)
+
+    @staticmethod
+    def cat(ts: Sequence[Rigid], dim: int) -> Rigid:
+        """
+        Concatenates transformations along a new dimension.
+
+        Args:
+            ts:
+                A list of T objects
+            dim:
+                The dimension along which the transformations should be concatenated
+        Returns:
+            A concatenated transformation object
+        """
+        rots = Rotation.cat([t._rots for t in ts], dim)
+        trans = torch.cat([t._trans for t in ts], dim=dim if dim >= 0 else dim - 1)
+
+        return Rigid(rots, trans)
+
+    def apply_rot_fn(self, fn: Callable[[Rotation], Rotation]) -> Rigid:
+        """
+        Applies a Rotation -> Rotation function to the stored rotation object.
+
+        Args:
+            fn: A function of type Rotation -> Rotation
+        Returns:
+            A transformation object with a transformed rotation.
+        """
+        return Rigid(fn(self._rots), self._trans)
+
+    def apply_trans_fn(self, fn: Callable[[torch.Tensor], torch.Tensor]) -> Rigid:
+        """
+        Applies a Tensor -> Tensor function to the stored translation.
+
+        Args:
+            fn:
+                A function of type Tensor -> Tensor to be applied to the translation
+        Returns:
+            A transformation object with a transformed translation.
+        """
+        return Rigid(self._rots, fn(self._trans))
+
+    def scale_translation(self, trans_scale_factor: float) -> Rigid:
+        """
+        Scales the translation by a constant factor.
+
+        Args:
+            trans_scale_factor:
+                The constant factor
+        Returns:
+            A transformation object with a scaled translation.
+        """
+        return self.apply_trans_fn(lambda t: t * trans_scale_factor)
+
+    def stop_rot_gradient(self) -> Rigid:
+        """
+        Detaches the underlying rotation object
+
+        Returns:
+            A transformation object with detached rotations
+        """
+        return self.apply_rot_fn(lambda r: r.detach())
+
+    @staticmethod
+    def make_transform_from_reference(
+        n_xyz: torch.Tensor, ca_xyz: torch.Tensor, c_xyz: torch.Tensor, eps: float = 1e-20
+    ) -> Rigid:
+        """
+        Returns a transformation object from reference coordinates.
+
+        Note that this method does not take care of symmetries. If you provide the atom positions in the non-standard
+        way, the N atom will end up not at [-0.527250, 1.359329, 0.0] but instead at [-0.527250, -1.359329, 0.0]. You
+        need to take care of such cases in your code.
+
+        Args:
+            n_xyz: A [*, 3] tensor of nitrogen xyz coordinates.
+            ca_xyz: A [*, 3] tensor of carbon alpha xyz coordinates.
+            c_xyz: A [*, 3] tensor of carbon xyz coordinates.
+        Returns:
+            A transformation object. After applying the translation and rotation to the reference backbone, the
+            coordinates will approximately equal to the input coordinates.
+        """
+        translation = -1 * ca_xyz
+        n_xyz = n_xyz + translation
+        c_xyz = c_xyz + translation
+
+        c_x, c_y, c_z = [c_xyz[..., i] for i in range(3)]
+        norm = torch.sqrt(eps + c_x**2 + c_y**2)
+        sin_c1 = -c_y / norm
+        cos_c1 = c_x / norm
+
+        c1_rots = sin_c1.new_zeros((*sin_c1.shape, 3, 3))
+        c1_rots[..., 0, 0] = cos_c1
+        c1_rots[..., 0, 1] = -1 * sin_c1
+        c1_rots[..., 1, 0] = sin_c1
+        c1_rots[..., 1, 1] = cos_c1
+        c1_rots[..., 2, 2] = 1
+
+        norm = torch.sqrt(eps + c_x**2 + c_y**2 + c_z**2)
+        sin_c2 = c_z / norm
+        cos_c2 = torch.sqrt(c_x**2 + c_y**2) / norm
+
+        c2_rots = sin_c2.new_zeros((*sin_c2.shape, 3, 3))
+        c2_rots[..., 0, 0] = cos_c2
+        c2_rots[..., 0, 2] = sin_c2
+        c2_rots[..., 1, 1] = 1
+        c2_rots[..., 2, 0] = -1 * sin_c2
+        c2_rots[..., 2, 2] = cos_c2
+
+        c_rots = rot_matmul(c2_rots, c1_rots)
+        n_xyz = rot_vec_mul(c_rots, n_xyz)
+
+        _, n_y, n_z = [n_xyz[..., i] for i in range(3)]
+        norm = torch.sqrt(eps + n_y**2 + n_z**2)
+        sin_n = -n_z / norm
+        cos_n = n_y / norm
+
+        n_rots = sin_c2.new_zeros((*sin_c2.shape, 3, 3))
+        n_rots[..., 0, 0] = 1
+        n_rots[..., 1, 1] = cos_n
+        n_rots[..., 1, 2] = -1 * sin_n
+        n_rots[..., 2, 1] = sin_n
+        n_rots[..., 2, 2] = cos_n
+
+        rots = rot_matmul(n_rots, c_rots)
+
+        rots = rots.transpose(-1, -2)
+        translation = -1 * translation
+
+        rot_obj = Rotation(rot_mats=rots, quats=None)
+
+        return Rigid(rot_obj, translation)
+
+    def cuda(self) -> Rigid:
+        """
+        Moves the transformation object to GPU memory
+
+        Returns:
+            A version of the transformation on GPU
+        """
+        return Rigid(self._rots.cuda(), self._trans.cuda())
diff --git a/openflamingo/lib/python3.10/site-packages/transformers/models/esm/tokenization_esm.py b/openflamingo/lib/python3.10/site-packages/transformers/models/esm/tokenization_esm.py
new file mode 100644
index 0000000000000000000000000000000000000000..f19d0de58a94712231ce2e3c8b7ebb4eba02c902
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/transformers/models/esm/tokenization_esm.py
@@ -0,0 +1,156 @@
+# coding=utf-8
+# Copyright 2022 Meta and The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Tokenization classes for ESM."""
+import os
+from typing import List, Optional, Union
+
+from ...tokenization_utils import PreTrainedTokenizer
+from ...tokenization_utils_base import AddedToken
+from ...utils import logging
+
+
+logger = logging.get_logger(__name__)
+
+VOCAB_FILES_NAMES = {"vocab_file": "vocab.txt"}
+
+PRETRAINED_VOCAB_FILES_MAP = {
+    "vocab_file": {
+        "facebook/esm2_t6_8M_UR50D": "https://huggingface.co/facebook/esm2_t6_8M_UR50D/resolve/main/vocab.txt",
+        "facebook/esm2_t12_35M_UR50D": "https://huggingface.co/facebook/esm2_t12_35M_UR50D/resolve/main/vocab.txt",
+    },
+}
+
+PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES = {
+    "facebook/esm2_t6_8M_UR50D": 1024,
+    "facebook/esm2_t12_35M_UR50D": 1024,
+}
+
+
+def load_vocab_file(vocab_file):
+    with open(vocab_file, "r") as f:
+        lines = f.read().splitlines()
+        return [l.strip() for l in lines]
+
+
+class EsmTokenizer(PreTrainedTokenizer):
+    """
+    Constructs an ESM tokenizer.
+    """
+
+    vocab_files_names = VOCAB_FILES_NAMES
+    pretrained_vocab_files_map = PRETRAINED_VOCAB_FILES_MAP
+    max_model_input_sizes = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
+    model_input_names = ["input_ids", "attention_mask"]
+
+    def __init__(
+        self,
+        vocab_file,
+        unk_token="<unk>",
+        cls_token="<cls>",
+        pad_token="<pad>",
+        mask_token="<mask>",
+        eos_token="<eos>",
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.all_tokens = load_vocab_file(vocab_file)
+        self._id_to_token = dict(enumerate(self.all_tokens))
+        self._token_to_id = {tok: ind for ind, tok in enumerate(self.all_tokens)}
+        self.unk_token = unk_token
+        self.cls_token = cls_token
+        self.pad_token = pad_token
+        self.mask_token = mask_token
+        self.eos_token = eos_token
+        self.unique_no_split_tokens = self.all_tokens
+        self._create_trie(self.unique_no_split_tokens)
+
+    def _convert_id_to_token(self, index: int) -> str:
+        return self._id_to_token.get(index, self.unk_token)
+
+    def _convert_token_to_id(self, token: str) -> int:
+        return self._token_to_id.get(token, self._token_to_id.get(self.unk_token))
+
+    def _tokenize(self, text, **kwargs):
+        return text.split()
+
+    def get_vocab_size(self, with_added_tokens=False):
+        return len(self._id_to_token)
+
+    def get_vocab(self):
+        return {token: i for i, token in enumerate(self.all_tokens)}
+
+    def token_to_id(self, token: str) -> int:
+        return self._token_to_id.get(token, self._token_to_id.get(self.unk_token))
+
+    def id_to_token(self, index: int) -> str:
+        return self._id_to_token.get(index, self.unk_token)
+
+    def build_inputs_with_special_tokens(
+        self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None
+    ) -> List[int]:
+        cls = [self.cls_token_id]
+        sep = [self.eos_token_id]  # No sep token in ESM vocabulary
+        if token_ids_1 is None:
+            if self.eos_token_id is None:
+                return cls + token_ids_0
+            else:
+                return cls + token_ids_0 + sep
+        elif self.eos_token_id is None:
+            raise ValueError("Cannot tokenize multiple sequences when EOS token is not set!")
+        return cls + token_ids_0 + sep + token_ids_1 + sep  # Multiple inputs always have an EOS token
+
+    def get_special_tokens_mask(
+        self, token_ids_0: List, token_ids_1: Optional[List] = None, already_has_special_tokens: bool = False
+    ) -> List[int]:
+        """
+        Retrieves sequence ids from a token list that has no special tokens added. This method is called when adding
+        special tokens using the tokenizer `prepare_for_model` or `encode_plus` methods.
+
+        Args:
+            token_ids_0 (`List[int]`):
+                List of ids of the first sequence.
+            token_ids_1 (`List[int]`, *optional*):
+                List of ids of the second sequence.
+            already_has_special_tokens (`bool`, *optional*, defaults to `False`):
+                Whether or not the token list is already formatted with special tokens for the model.
+
+        Returns:
+            A list of integers in the range [0, 1]: 1 for a special token, 0 for a sequence token.
+        """
+        if already_has_special_tokens:
+            if token_ids_1 is not None:
+                raise ValueError(
+                    "You should not supply a second sequence if the provided sequence of "
+                    "ids is already formatted with special tokens for the model."
+                )
+
+            return [1 if token in self.all_special_ids else 0 for token in token_ids_0]
+        mask = [1] + ([0] * len(token_ids_0)) + [1]
+        if token_ids_1 is not None:
+            mask += [0] * len(token_ids_1) + [1]
+        return mask
+
+    def save_vocabulary(self, save_directory, filename_prefix):
+        vocab_file = os.path.join(save_directory, (filename_prefix + "-" if filename_prefix else "") + "vocab.txt")
+        with open(vocab_file, "w") as f:
+            f.write("\n".join(self.all_tokens))
+        return (vocab_file,)
+
+    @property
+    def vocab_size(self) -> int:
+        return self.get_vocab_size(with_added_tokens=False)
+
+    def _add_tokens(self, new_tokens: Union[List[str], List[AddedToken]], special_tokens: bool = False) -> int:
+        return super()._add_tokens(new_tokens, special_tokens=True)
diff --git a/openflamingo/lib/python3.10/site-packages/transformers/models/nat/__init__.py b/openflamingo/lib/python3.10/site-packages/transformers/models/nat/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..19ddb46e8266fa85d25a3d085f2de33bf1dd4603
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/transformers/models/nat/__init__.py
@@ -0,0 +1,56 @@
+# Copyright 2022 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import TYPE_CHECKING
+
+from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available
+
+
+_import_structure = {"configuration_nat": ["NAT_PRETRAINED_CONFIG_ARCHIVE_MAP", "NatConfig"]}
+
+
+try:
+    if not is_torch_available():
+        raise OptionalDependencyNotAvailable()
+except OptionalDependencyNotAvailable:
+    pass
+else:
+    _import_structure["modeling_nat"] = [
+        "NAT_PRETRAINED_MODEL_ARCHIVE_LIST",
+        "NatForImageClassification",
+        "NatModel",
+        "NatPreTrainedModel",
+        "NatBackbone",
+    ]
+
+if TYPE_CHECKING:
+    from .configuration_nat import NAT_PRETRAINED_CONFIG_ARCHIVE_MAP, NatConfig
+
+    try:
+        if not is_torch_available():
+            raise OptionalDependencyNotAvailable()
+    except OptionalDependencyNotAvailable:
+        pass
+    else:
+        from .modeling_nat import (
+            NAT_PRETRAINED_MODEL_ARCHIVE_LIST,
+            NatBackbone,
+            NatForImageClassification,
+            NatModel,
+            NatPreTrainedModel,
+        )
+
+else:
+    import sys
+
+    sys.modules[__name__] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
diff --git a/openflamingo/lib/python3.10/site-packages/transformers/models/nat/__pycache__/modeling_nat.cpython-310.pyc b/openflamingo/lib/python3.10/site-packages/transformers/models/nat/__pycache__/modeling_nat.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..24f985bd709ec027a79188bce34d728bbc635707
Binary files /dev/null and b/openflamingo/lib/python3.10/site-packages/transformers/models/nat/__pycache__/modeling_nat.cpython-310.pyc differ
diff --git a/openflamingo/lib/python3.10/site-packages/transformers/models/nat/modeling_nat.py b/openflamingo/lib/python3.10/site-packages/transformers/models/nat/modeling_nat.py
new file mode 100644
index 0000000000000000000000000000000000000000..ecc745b558dd714cfb5ebb64c0c03579a86c4ec7
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/transformers/models/nat/modeling_nat.py
@@ -0,0 +1,960 @@
+# coding=utf-8
+# Copyright 2022 SHI Labs and The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""" PyTorch Neighborhood Attention Transformer model."""
+
+
+import math
+from dataclasses import dataclass
+from typing import Optional, Tuple, Union
+
+import torch
+import torch.utils.checkpoint
+from torch import nn
+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
+
+from ...activations import ACT2FN
+from ...modeling_outputs import BackboneOutput
+from ...modeling_utils import PreTrainedModel
+from ...pytorch_utils import find_pruneable_heads_and_indices, prune_linear_layer
+from ...utils import (
+    ModelOutput,
+    OptionalDependencyNotAvailable,
+    add_code_sample_docstrings,
+    add_start_docstrings,
+    add_start_docstrings_to_model_forward,
+    is_natten_available,
+    logging,
+    replace_return_docstrings,
+    requires_backends,
+)
+from ...utils.backbone_utils import BackboneMixin
+from .configuration_nat import NatConfig
+
+
+if is_natten_available():
+    from natten.functional import natten2dav, natten2dqkrpb
+else:
+
+    def natten2dqkrpb(*args, **kwargs):
+        raise OptionalDependencyNotAvailable()
+
+    def natten2dav(*args, **kwargs):
+        raise OptionalDependencyNotAvailable()
+
+
+logger = logging.get_logger(__name__)
+
+# General docstring
+_CONFIG_FOR_DOC = "NatConfig"
+
+# Base docstring
+_CHECKPOINT_FOR_DOC = "shi-labs/nat-mini-in1k-224"
+_EXPECTED_OUTPUT_SHAPE = [1, 7, 7, 512]
+
+# Image classification docstring
+_IMAGE_CLASS_CHECKPOINT = "shi-labs/nat-mini-in1k-224"
+_IMAGE_CLASS_EXPECTED_OUTPUT = "tiger cat"
+
+
+NAT_PRETRAINED_MODEL_ARCHIVE_LIST = [
+    "shi-labs/nat-mini-in1k-224",
+    # See all Nat models at https://huggingface.co/models?filter=nat
+]
+
+# drop_path and NatDropPath are from the timm library.
+
+
+@dataclass
+class NatEncoderOutput(ModelOutput):
+    """
+    Nat encoder's outputs, with potential hidden states and attentions.
+
+    Args:
+        last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+            Sequence of hidden-states at the output of the last layer of the model.
+        hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+            Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
+            shape `(batch_size, sequence_length, hidden_size)`.
+
+            Hidden-states of the model at the output of each layer plus the initial embedding outputs.
+        attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
+            Tuple of `torch.FloatTensor` (one for each stage) of shape `(batch_size, num_heads, sequence_length,
+            sequence_length)`.
+
+            Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
+            heads.
+        reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+            Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
+            shape `(batch_size, hidden_size, height, width)`.
+
+            Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
+            include the spatial dimensions.
+    """
+
+    last_hidden_state: torch.FloatTensor = None
+    hidden_states: Optional[Tuple[torch.FloatTensor]] = None
+    attentions: Optional[Tuple[torch.FloatTensor]] = None
+    reshaped_hidden_states: Optional[Tuple[torch.FloatTensor]] = None
+
+
+@dataclass
+class NatModelOutput(ModelOutput):
+    """
+    Nat model's outputs that also contains a pooling of the last hidden states.
+
+    Args:
+        last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+            Sequence of hidden-states at the output of the last layer of the model.
+        pooler_output (`torch.FloatTensor` of shape `(batch_size, hidden_size)`, *optional*, returned when `add_pooling_layer=True` is passed):
+            Average pooling of the last layer hidden-state.
+        hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+            Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
+            shape `(batch_size, sequence_length, hidden_size)`.
+
+            Hidden-states of the model at the output of each layer plus the initial embedding outputs.
+        attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
+            Tuple of `torch.FloatTensor` (one for each stage) of shape `(batch_size, num_heads, sequence_length,
+            sequence_length)`.
+
+            Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
+            heads.
+        reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+            Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
+            shape `(batch_size, hidden_size, height, width)`.
+
+            Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
+            include the spatial dimensions.
+    """
+
+    last_hidden_state: torch.FloatTensor = None
+    pooler_output: Optional[torch.FloatTensor] = None
+    hidden_states: Optional[Tuple[torch.FloatTensor]] = None
+    attentions: Optional[Tuple[torch.FloatTensor]] = None
+    reshaped_hidden_states: Optional[Tuple[torch.FloatTensor]] = None
+
+
+@dataclass
+class NatImageClassifierOutput(ModelOutput):
+    """
+    Nat outputs for image classification.
+
+    Args:
+        loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided):
+            Classification (or regression if config.num_labels==1) loss.
+        logits (`torch.FloatTensor` of shape `(batch_size, config.num_labels)`):
+            Classification (or regression if config.num_labels==1) scores (before SoftMax).
+        hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+            Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
+            shape `(batch_size, sequence_length, hidden_size)`.
+
+            Hidden-states of the model at the output of each layer plus the initial embedding outputs.
+        attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
+            Tuple of `torch.FloatTensor` (one for each stage) of shape `(batch_size, num_heads, sequence_length,
+            sequence_length)`.
+
+            Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
+            heads.
+        reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+            Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
+            shape `(batch_size, hidden_size, height, width)`.
+
+            Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
+            include the spatial dimensions.
+    """
+
+    loss: Optional[torch.FloatTensor] = None
+    logits: torch.FloatTensor = None
+    hidden_states: Optional[Tuple[torch.FloatTensor]] = None
+    attentions: Optional[Tuple[torch.FloatTensor]] = None
+    reshaped_hidden_states: Optional[Tuple[torch.FloatTensor]] = None
+
+
+class NatEmbeddings(nn.Module):
+    """
+    Construct the patch and position embeddings.
+    """
+
+    def __init__(self, config):
+        super().__init__()
+
+        self.patch_embeddings = NatPatchEmbeddings(config)
+
+        self.norm = nn.LayerNorm(config.embed_dim)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+    def forward(self, pixel_values: Optional[torch.FloatTensor]) -> Tuple[torch.Tensor]:
+        embeddings = self.patch_embeddings(pixel_values)
+        embeddings = self.norm(embeddings)
+
+        embeddings = self.dropout(embeddings)
+
+        return embeddings
+
+
+class NatPatchEmbeddings(nn.Module):
+    """
+    This class turns `pixel_values` of shape `(batch_size, num_channels, height, width)` into the initial
+    `hidden_states` (patch embeddings) of shape `(batch_size, height, width, hidden_size)` to be consumed by a
+    Transformer.
+    """
+
+    def __init__(self, config):
+        super().__init__()
+        patch_size = config.patch_size
+        num_channels, hidden_size = config.num_channels, config.embed_dim
+        self.num_channels = num_channels
+
+        if patch_size == 4:
+            pass
+        else:
+            # TODO: Support arbitrary patch sizes.
+            raise ValueError("Dinat only supports patch size of 4 at the moment.")
+
+        self.projection = nn.Sequential(
+            nn.Conv2d(self.num_channels, hidden_size // 2, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)),
+            nn.Conv2d(hidden_size // 2, hidden_size, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)),
+        )
+
+    def forward(self, pixel_values: Optional[torch.FloatTensor]) -> torch.Tensor:
+        _, num_channels, height, width = pixel_values.shape
+        if num_channels != self.num_channels:
+            raise ValueError(
+                "Make sure that the channel dimension of the pixel values match with the one set in the configuration."
+            )
+        embeddings = self.projection(pixel_values)
+        embeddings = embeddings.permute(0, 2, 3, 1)
+
+        return embeddings
+
+
+class NatDownsampler(nn.Module):
+    """
+    Convolutional Downsampling Layer.
+
+    Args:
+        dim (`int`):
+            Number of input channels.
+        norm_layer (`nn.Module`, *optional*, defaults to `nn.LayerNorm`):
+            Normalization layer class.
+    """
+
+    def __init__(self, dim: int, norm_layer: nn.Module = nn.LayerNorm) -> None:
+        super().__init__()
+        self.dim = dim
+        self.reduction = nn.Conv2d(dim, 2 * dim, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
+        self.norm = norm_layer(2 * dim)
+
+    def forward(self, input_feature: torch.Tensor) -> torch.Tensor:
+        input_feature = self.reduction(input_feature.permute(0, 3, 1, 2)).permute(0, 2, 3, 1)
+        input_feature = self.norm(input_feature)
+        return input_feature
+
+
+# Copied from transformers.models.beit.modeling_beit.drop_path
+def drop_path(input: torch.Tensor, drop_prob: float = 0.0, training: bool = False) -> torch.Tensor:
+    """
+    Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).
+
+    Comment by Ross Wightman: This is the same as the DropConnect impl I created for EfficientNet, etc networks,
+    however, the original name is misleading as 'Drop Connect' is a different form of dropout in a separate paper...
+    See discussion: https://github.com/tensorflow/tpu/issues/494#issuecomment-532968956 ... I've opted for changing the
+    layer and argument names to 'drop path' rather than mix DropConnect as a layer name and use 'survival rate' as the
+    argument.
+    """
+    if drop_prob == 0.0 or not training:
+        return input
+    keep_prob = 1 - drop_prob
+    shape = (input.shape[0],) + (1,) * (input.ndim - 1)  # work with diff dim tensors, not just 2D ConvNets
+    random_tensor = keep_prob + torch.rand(shape, dtype=input.dtype, device=input.device)
+    random_tensor.floor_()  # binarize
+    output = input.div(keep_prob) * random_tensor
+    return output
+
+
+# Copied from transformers.models.beit.modeling_beit.BeitDropPath with Beit->Nat
+class NatDropPath(nn.Module):
+    """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks)."""
+
+    def __init__(self, drop_prob: Optional[float] = None) -> None:
+        super().__init__()
+        self.drop_prob = drop_prob
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        return drop_path(hidden_states, self.drop_prob, self.training)
+
+    def extra_repr(self) -> str:
+        return "p={}".format(self.drop_prob)
+
+
+class NeighborhoodAttention(nn.Module):
+    def __init__(self, config, dim, num_heads, kernel_size):
+        super().__init__()
+        if dim % num_heads != 0:
+            raise ValueError(
+                f"The hidden size ({dim}) is not a multiple of the number of attention heads ({num_heads})"
+            )
+
+        self.num_attention_heads = num_heads
+        self.attention_head_size = int(dim / num_heads)
+        self.all_head_size = self.num_attention_heads * self.attention_head_size
+        self.kernel_size = kernel_size
+
+        # rpb is learnable relative positional biases; same concept is used Swin.
+        self.rpb = nn.Parameter(torch.zeros(num_heads, (2 * self.kernel_size - 1), (2 * self.kernel_size - 1)))
+
+        self.query = nn.Linear(self.all_head_size, self.all_head_size, bias=config.qkv_bias)
+        self.key = nn.Linear(self.all_head_size, self.all_head_size, bias=config.qkv_bias)
+        self.value = nn.Linear(self.all_head_size, self.all_head_size, bias=config.qkv_bias)
+
+        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+
+    def transpose_for_scores(self, x):
+        new_x_shape = x.size()[:-1] + (self.num_attention_heads, self.attention_head_size)
+        x = x.view(new_x_shape)
+        return x.permute(0, 3, 1, 2, 4)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        output_attentions: Optional[bool] = False,
+    ) -> Tuple[torch.Tensor]:
+        query_layer = self.transpose_for_scores(self.query(hidden_states))
+        key_layer = self.transpose_for_scores(self.key(hidden_states))
+        value_layer = self.transpose_for_scores(self.value(hidden_states))
+
+        # Apply the scale factor before computing attention weights. It's usually more efficient because
+        # attention weights are typically a bigger tensor compared to query.
+        # It gives identical results because scalars are commutable in matrix multiplication.
+        query_layer = query_layer / math.sqrt(self.attention_head_size)
+
+        # Compute NA between "query" and "key" to get the raw attention scores, and add relative positional biases.
+        attention_scores = natten2dqkrpb(query_layer, key_layer, self.rpb, self.kernel_size, 1)
+
+        # Normalize the attention scores to probabilities.
+        attention_probs = nn.functional.softmax(attention_scores, dim=-1)
+
+        # This is actually dropping out entire tokens to attend to, which might
+        # seem a bit unusual, but is taken from the original Transformer paper.
+        attention_probs = self.dropout(attention_probs)
+
+        context_layer = natten2dav(attention_probs, value_layer, self.kernel_size, 1)
+        context_layer = context_layer.permute(0, 2, 3, 1, 4).contiguous()
+        new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
+        context_layer = context_layer.view(new_context_layer_shape)
+
+        outputs = (context_layer, attention_probs) if output_attentions else (context_layer,)
+
+        return outputs
+
+
+class NeighborhoodAttentionOutput(nn.Module):
+    def __init__(self, config, dim):
+        super().__init__()
+        self.dense = nn.Linear(dim, dim)
+        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+
+    def forward(self, hidden_states: torch.Tensor, input_tensor: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+
+        return hidden_states
+
+
+class NeighborhoodAttentionModule(nn.Module):
+    def __init__(self, config, dim, num_heads, kernel_size):
+        super().__init__()
+        self.self = NeighborhoodAttention(config, dim, num_heads, kernel_size)
+        self.output = NeighborhoodAttentionOutput(config, dim)
+        self.pruned_heads = set()
+
+    def prune_heads(self, heads):
+        if len(heads) == 0:
+            return
+        heads, index = find_pruneable_heads_and_indices(
+            heads, self.self.num_attention_heads, self.self.attention_head_size, self.pruned_heads
+        )
+
+        # Prune linear layers
+        self.self.query = prune_linear_layer(self.self.query, index)
+        self.self.key = prune_linear_layer(self.self.key, index)
+        self.self.value = prune_linear_layer(self.self.value, index)
+        self.output.dense = prune_linear_layer(self.output.dense, index, dim=1)
+
+        # Update hyper params and store pruned heads
+        self.self.num_attention_heads = self.self.num_attention_heads - len(heads)
+        self.self.all_head_size = self.self.attention_head_size * self.self.num_attention_heads
+        self.pruned_heads = self.pruned_heads.union(heads)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        output_attentions: Optional[bool] = False,
+    ) -> Tuple[torch.Tensor]:
+        self_outputs = self.self(hidden_states, output_attentions)
+        attention_output = self.output(self_outputs[0], hidden_states)
+        outputs = (attention_output,) + self_outputs[1:]  # add attentions if we output them
+        return outputs
+
+
+class NatIntermediate(nn.Module):
+    def __init__(self, config, dim):
+        super().__init__()
+        self.dense = nn.Linear(dim, int(config.mlp_ratio * dim))
+        if isinstance(config.hidden_act, str):
+            self.intermediate_act_fn = ACT2FN[config.hidden_act]
+        else:
+            self.intermediate_act_fn = config.hidden_act
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.intermediate_act_fn(hidden_states)
+        return hidden_states
+
+
+class NatOutput(nn.Module):
+    def __init__(self, config, dim):
+        super().__init__()
+        self.dense = nn.Linear(int(config.mlp_ratio * dim), dim)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        return hidden_states
+
+
+class NatLayer(nn.Module):
+    def __init__(self, config, dim, num_heads, drop_path_rate=0.0):
+        super().__init__()
+        self.chunk_size_feed_forward = config.chunk_size_feed_forward
+        self.kernel_size = config.kernel_size
+        self.layernorm_before = nn.LayerNorm(dim, eps=config.layer_norm_eps)
+        self.attention = NeighborhoodAttentionModule(config, dim, num_heads, kernel_size=self.kernel_size)
+        self.drop_path = NatDropPath(drop_path_rate) if drop_path_rate > 0.0 else nn.Identity()
+        self.layernorm_after = nn.LayerNorm(dim, eps=config.layer_norm_eps)
+        self.intermediate = NatIntermediate(config, dim)
+        self.output = NatOutput(config, dim)
+        self.layer_scale_parameters = (
+            nn.Parameter(config.layer_scale_init_value * torch.ones((2, dim)), requires_grad=True)
+            if config.layer_scale_init_value > 0
+            else None
+        )
+
+    def maybe_pad(self, hidden_states, height, width):
+        window_size = self.kernel_size
+        pad_values = (0, 0, 0, 0, 0, 0)
+        if height < window_size or width < window_size:
+            pad_l = pad_t = 0
+            pad_r = max(0, window_size - width)
+            pad_b = max(0, window_size - height)
+            pad_values = (0, 0, pad_l, pad_r, pad_t, pad_b)
+            hidden_states = nn.functional.pad(hidden_states, pad_values)
+        return hidden_states, pad_values
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        output_attentions: Optional[bool] = False,
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        batch_size, height, width, channels = hidden_states.size()
+        shortcut = hidden_states
+
+        hidden_states = self.layernorm_before(hidden_states)
+        # pad hidden_states if they are smaller than kernel size
+        hidden_states, pad_values = self.maybe_pad(hidden_states, height, width)
+
+        _, height_pad, width_pad, _ = hidden_states.shape
+
+        attention_outputs = self.attention(hidden_states, output_attentions=output_attentions)
+
+        attention_output = attention_outputs[0]
+
+        was_padded = pad_values[3] > 0 or pad_values[5] > 0
+        if was_padded:
+            attention_output = attention_output[:, :height, :width, :].contiguous()
+
+        if self.layer_scale_parameters is not None:
+            attention_output = self.layer_scale_parameters[0] * attention_output
+
+        hidden_states = shortcut + self.drop_path(attention_output)
+
+        layer_output = self.layernorm_after(hidden_states)
+        layer_output = self.output(self.intermediate(layer_output))
+
+        if self.layer_scale_parameters is not None:
+            layer_output = self.layer_scale_parameters[1] * layer_output
+
+        layer_output = hidden_states + self.drop_path(layer_output)
+
+        layer_outputs = (layer_output, attention_outputs[1]) if output_attentions else (layer_output,)
+        return layer_outputs
+
+
+class NatStage(nn.Module):
+    def __init__(self, config, dim, depth, num_heads, drop_path_rate, downsample):
+        super().__init__()
+        self.config = config
+        self.dim = dim
+        self.layers = nn.ModuleList(
+            [
+                NatLayer(
+                    config=config,
+                    dim=dim,
+                    num_heads=num_heads,
+                    drop_path_rate=drop_path_rate[i],
+                )
+                for i in range(depth)
+            ]
+        )
+
+        # patch merging layer
+        if downsample is not None:
+            self.downsample = downsample(dim=dim, norm_layer=nn.LayerNorm)
+        else:
+            self.downsample = None
+
+        self.pointing = False
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        output_attentions: Optional[bool] = False,
+    ) -> Tuple[torch.Tensor]:
+        _, height, width, _ = hidden_states.size()
+        for i, layer_module in enumerate(self.layers):
+            layer_outputs = layer_module(hidden_states, output_attentions)
+            hidden_states = layer_outputs[0]
+
+        hidden_states_before_downsampling = hidden_states
+        if self.downsample is not None:
+            hidden_states = self.downsample(hidden_states_before_downsampling)
+
+        stage_outputs = (hidden_states, hidden_states_before_downsampling)
+
+        if output_attentions:
+            stage_outputs += layer_outputs[1:]
+        return stage_outputs
+
+
+class NatEncoder(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.num_levels = len(config.depths)
+        self.config = config
+        dpr = [x.item() for x in torch.linspace(0, config.drop_path_rate, sum(config.depths))]
+        self.levels = nn.ModuleList(
+            [
+                NatStage(
+                    config=config,
+                    dim=int(config.embed_dim * 2**i_layer),
+                    depth=config.depths[i_layer],
+                    num_heads=config.num_heads[i_layer],
+                    drop_path_rate=dpr[sum(config.depths[:i_layer]) : sum(config.depths[: i_layer + 1])],
+                    downsample=NatDownsampler if (i_layer < self.num_levels - 1) else None,
+                )
+                for i_layer in range(self.num_levels)
+            ]
+        )
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        output_attentions: Optional[bool] = False,
+        output_hidden_states: Optional[bool] = False,
+        output_hidden_states_before_downsampling: Optional[bool] = False,
+        return_dict: Optional[bool] = True,
+    ) -> Union[Tuple, NatEncoderOutput]:
+        all_hidden_states = () if output_hidden_states else None
+        all_reshaped_hidden_states = () if output_hidden_states else None
+        all_self_attentions = () if output_attentions else None
+
+        if output_hidden_states:
+            # rearrange b h w c -> b c h w
+            reshaped_hidden_state = hidden_states.permute(0, 3, 1, 2)
+            all_hidden_states += (hidden_states,)
+            all_reshaped_hidden_states += (reshaped_hidden_state,)
+
+        for i, layer_module in enumerate(self.levels):
+            layer_outputs = layer_module(hidden_states, output_attentions)
+
+            hidden_states = layer_outputs[0]
+            hidden_states_before_downsampling = layer_outputs[1]
+
+            if output_hidden_states and output_hidden_states_before_downsampling:
+                # rearrange b h w c -> b c h w
+                reshaped_hidden_state = hidden_states_before_downsampling.permute(0, 3, 1, 2)
+                all_hidden_states += (hidden_states_before_downsampling,)
+                all_reshaped_hidden_states += (reshaped_hidden_state,)
+            elif output_hidden_states and not output_hidden_states_before_downsampling:
+                # rearrange b h w c -> b c h w
+                reshaped_hidden_state = hidden_states.permute(0, 3, 1, 2)
+                all_hidden_states += (hidden_states,)
+                all_reshaped_hidden_states += (reshaped_hidden_state,)
+
+            if output_attentions:
+                all_self_attentions += layer_outputs[2:]
+
+        if not return_dict:
+            return tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions] if v is not None)
+
+        return NatEncoderOutput(
+            last_hidden_state=hidden_states,
+            hidden_states=all_hidden_states,
+            attentions=all_self_attentions,
+            reshaped_hidden_states=all_reshaped_hidden_states,
+        )
+
+
+class NatPreTrainedModel(PreTrainedModel):
+    """
+    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
+    models.
+    """
+
+    config_class = NatConfig
+    base_model_prefix = "nat"
+    main_input_name = "pixel_values"
+
+    def _init_weights(self, module):
+        """Initialize the weights"""
+        if isinstance(module, (nn.Linear, nn.Conv2d)):
+            # Slightly different from the TF version which uses truncated_normal for initialization
+            # cf https://github.com/pytorch/pytorch/pull/5617
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.bias is not None:
+                module.bias.data.zero_()
+        elif isinstance(module, nn.LayerNorm):
+            module.bias.data.zero_()
+            module.weight.data.fill_(1.0)
+
+    def _set_gradient_checkpointing(self, module: NatEncoder, value: bool = False) -> None:
+        pass
+
+
+NAT_START_DOCSTRING = r"""
+    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) sub-class. Use
+    it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and
+    behavior.
+
+    Parameters:
+        config ([`NatConfig`]): Model configuration class with all the parameters of the model.
+            Initializing with a config file does not load the weights associated with the model, only the
+            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
+"""
+
+NAT_INPUTS_DOCSTRING = r"""
+    Args:
+        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
+            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See [`ViTImageProcessor.__call__`]
+            for details.
+
+        output_attentions (`bool`, *optional*):
+            Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
+            tensors for more detail.
+        output_hidden_states (`bool`, *optional*):
+            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
+            more detail.
+        return_dict (`bool`, *optional*):
+            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+"""
+
+
+@add_start_docstrings(
+    "The bare Nat Model transformer outputting raw hidden-states without any specific head on top.",
+    NAT_START_DOCSTRING,
+)
+class NatModel(NatPreTrainedModel):
+    def __init__(self, config, add_pooling_layer=True):
+        super().__init__(config)
+
+        requires_backends(self, ["natten"])
+
+        self.config = config
+        self.num_levels = len(config.depths)
+        self.num_features = int(config.embed_dim * 2 ** (self.num_levels - 1))
+
+        self.embeddings = NatEmbeddings(config)
+        self.encoder = NatEncoder(config)
+
+        self.layernorm = nn.LayerNorm(self.num_features, eps=config.layer_norm_eps)
+        self.pooler = nn.AdaptiveAvgPool1d(1) if add_pooling_layer else None
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_input_embeddings(self):
+        return self.embeddings.patch_embeddings
+
+    def _prune_heads(self, heads_to_prune):
+        """
+        Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base
+        class PreTrainedModel
+        """
+        for layer, heads in heads_to_prune.items():
+            self.encoder.layer[layer].attention.prune_heads(heads)
+
+    @add_start_docstrings_to_model_forward(NAT_INPUTS_DOCSTRING)
+    @add_code_sample_docstrings(
+        checkpoint=_CHECKPOINT_FOR_DOC,
+        output_type=NatModelOutput,
+        config_class=_CONFIG_FOR_DOC,
+        modality="vision",
+        expected_output=_EXPECTED_OUTPUT_SHAPE,
+    )
+    def forward(
+        self,
+        pixel_values: Optional[torch.FloatTensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, NatModelOutput]:
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        if pixel_values is None:
+            raise ValueError("You have to specify pixel_values")
+
+        embedding_output = self.embeddings(pixel_values)
+
+        encoder_outputs = self.encoder(
+            embedding_output,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        sequence_output = encoder_outputs[0]
+        sequence_output = self.layernorm(sequence_output)
+
+        pooled_output = None
+        if self.pooler is not None:
+            pooled_output = self.pooler(sequence_output.flatten(1, 2).transpose(1, 2))
+            pooled_output = torch.flatten(pooled_output, 1)
+
+        if not return_dict:
+            output = (sequence_output, pooled_output) + encoder_outputs[1:]
+
+            return output
+
+        return NatModelOutput(
+            last_hidden_state=sequence_output,
+            pooler_output=pooled_output,
+            hidden_states=encoder_outputs.hidden_states,
+            attentions=encoder_outputs.attentions,
+            reshaped_hidden_states=encoder_outputs.reshaped_hidden_states,
+        )
+
+
+@add_start_docstrings(
+    """
+    Nat Model transformer with an image classification head on top (a linear layer on top of the final hidden state of
+    the [CLS] token) e.g. for ImageNet.
+    """,
+    NAT_START_DOCSTRING,
+)
+class NatForImageClassification(NatPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+
+        requires_backends(self, ["natten"])
+
+        self.num_labels = config.num_labels
+        self.nat = NatModel(config)
+
+        # Classifier head
+        self.classifier = (
+            nn.Linear(self.nat.num_features, config.num_labels) if config.num_labels > 0 else nn.Identity()
+        )
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    @add_start_docstrings_to_model_forward(NAT_INPUTS_DOCSTRING)
+    @add_code_sample_docstrings(
+        checkpoint=_IMAGE_CLASS_CHECKPOINT,
+        output_type=NatImageClassifierOutput,
+        config_class=_CONFIG_FOR_DOC,
+        expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT,
+    )
+    def forward(
+        self,
+        pixel_values: Optional[torch.FloatTensor] = None,
+        labels: Optional[torch.LongTensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, NatImageClassifierOutput]:
+        r"""
+        labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+            Labels for computing the image classification/regression loss. Indices should be in `[0, ...,
+            config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+            `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        outputs = self.nat(
+            pixel_values,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        pooled_output = outputs[1]
+
+        logits = self.classifier(pooled_output)
+
+        loss = None
+        if labels is not None:
+            if self.config.problem_type is None:
+                if self.num_labels == 1:
+                    self.config.problem_type = "regression"
+                elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
+                    self.config.problem_type = "single_label_classification"
+                else:
+                    self.config.problem_type = "multi_label_classification"
+
+            if self.config.problem_type == "regression":
+                loss_fct = MSELoss()
+                if self.num_labels == 1:
+                    loss = loss_fct(logits.squeeze(), labels.squeeze())
+                else:
+                    loss = loss_fct(logits, labels)
+            elif self.config.problem_type == "single_label_classification":
+                loss_fct = CrossEntropyLoss()
+                loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
+            elif self.config.problem_type == "multi_label_classification":
+                loss_fct = BCEWithLogitsLoss()
+                loss = loss_fct(logits, labels)
+
+        if not return_dict:
+            output = (logits,) + outputs[2:]
+            return ((loss,) + output) if loss is not None else output
+
+        return NatImageClassifierOutput(
+            loss=loss,
+            logits=logits,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+            reshaped_hidden_states=outputs.reshaped_hidden_states,
+        )
+
+
+@add_start_docstrings(
+    "NAT backbone, to be used with frameworks like DETR and MaskFormer.",
+    NAT_START_DOCSTRING,
+)
+class NatBackbone(NatPreTrainedModel, BackboneMixin):
+    def __init__(self, config):
+        super().__init__(config)
+        super()._init_backbone(config)
+
+        requires_backends(self, ["natten"])
+
+        self.embeddings = NatEmbeddings(config)
+        self.encoder = NatEncoder(config)
+        self.num_features = [config.embed_dim] + [int(config.embed_dim * 2**i) for i in range(len(config.depths))]
+
+        # Add layer norms to hidden states of out_features
+        hidden_states_norms = {}
+        for stage, num_channels in zip(self.out_features, self.channels):
+            hidden_states_norms[stage] = nn.LayerNorm(num_channels)
+        self.hidden_states_norms = nn.ModuleDict(hidden_states_norms)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_input_embeddings(self):
+        return self.embeddings.patch_embeddings
+
+    @add_start_docstrings_to_model_forward(NAT_INPUTS_DOCSTRING)
+    @replace_return_docstrings(output_type=BackboneOutput, config_class=_CONFIG_FOR_DOC)
+    def forward(
+        self,
+        pixel_values: torch.Tensor,
+        output_hidden_states: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> BackboneOutput:
+        """
+        Returns:
+
+        Examples:
+
+        ```python
+        >>> from transformers import AutoImageProcessor, AutoBackbone
+        >>> import torch
+        >>> from PIL import Image
+        >>> import requests
+
+        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+        >>> image = Image.open(requests.get(url, stream=True).raw)
+
+        >>> processor = AutoImageProcessor.from_pretrained("shi-labs/nat-mini-in1k-224")
+        >>> model = AutoBackbone.from_pretrained(
+        ...     "shi-labs/nat-mini-in1k-224", out_features=["stage1", "stage2", "stage3", "stage4"]
+        ... )
+
+        >>> inputs = processor(image, return_tensors="pt")
+
+        >>> outputs = model(**inputs)
+
+        >>> feature_maps = outputs.feature_maps
+        >>> list(feature_maps[-1].shape)
+        [1, 512, 7, 7]
+        ```"""
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+
+        embedding_output = self.embeddings(pixel_values)
+
+        outputs = self.encoder(
+            embedding_output,
+            output_attentions=output_attentions,
+            output_hidden_states=True,
+            output_hidden_states_before_downsampling=True,
+            return_dict=True,
+        )
+
+        hidden_states = outputs.reshaped_hidden_states
+
+        feature_maps = ()
+        for stage, hidden_state in zip(self.stage_names, hidden_states):
+            if stage in self.out_features:
+                # TODO can we simplify this?
+                batch_size, num_channels, height, width = hidden_state.shape
+                hidden_state = hidden_state.permute(0, 2, 3, 1).contiguous()
+                hidden_state = hidden_state.view(batch_size, height * width, num_channels)
+                hidden_state = self.hidden_states_norms[stage](hidden_state)
+                hidden_state = hidden_state.view(batch_size, height, width, num_channels)
+                hidden_state = hidden_state.permute(0, 3, 1, 2).contiguous()
+                feature_maps += (hidden_state,)
+
+        if not return_dict:
+            output = (feature_maps,)
+            if output_hidden_states:
+                output += (outputs.hidden_states,)
+            return output
+
+        return BackboneOutput(
+            feature_maps=feature_maps,
+            hidden_states=outputs.hidden_states if output_hidden_states else None,
+            attentions=outputs.attentions,
+        )
diff --git a/openflamingo/lib/python3.10/site-packages/transformers/models/realm/__pycache__/configuration_realm.cpython-310.pyc b/openflamingo/lib/python3.10/site-packages/transformers/models/realm/__pycache__/configuration_realm.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2fcabd11fb55113b58183074f5549d088a3801ef
Binary files /dev/null and b/openflamingo/lib/python3.10/site-packages/transformers/models/realm/__pycache__/configuration_realm.cpython-310.pyc differ
diff --git a/openflamingo/lib/python3.10/site-packages/transformers/models/realm/__pycache__/modeling_realm.cpython-310.pyc b/openflamingo/lib/python3.10/site-packages/transformers/models/realm/__pycache__/modeling_realm.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..119e1018770adb4e906c502999ac332a3b5af787
Binary files /dev/null and b/openflamingo/lib/python3.10/site-packages/transformers/models/realm/__pycache__/modeling_realm.cpython-310.pyc differ
diff --git a/openflamingo/lib/python3.10/site-packages/transformers/models/swin/__pycache__/__init__.cpython-310.pyc b/openflamingo/lib/python3.10/site-packages/transformers/models/swin/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1b4fd61b1ec1541faa9b418e2b52df161d4a6a84
Binary files /dev/null and b/openflamingo/lib/python3.10/site-packages/transformers/models/swin/__pycache__/__init__.cpython-310.pyc differ
diff --git a/openflamingo/lib/python3.10/site-packages/transformers/models/swin/__pycache__/configuration_swin.cpython-310.pyc b/openflamingo/lib/python3.10/site-packages/transformers/models/swin/__pycache__/configuration_swin.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..af2afa5d9755abb5e04b0e5b9a91a83a8de70530
Binary files /dev/null and b/openflamingo/lib/python3.10/site-packages/transformers/models/swin/__pycache__/configuration_swin.cpython-310.pyc differ
diff --git a/openflamingo/lib/python3.10/site-packages/transformers/models/swin/__pycache__/convert_swin_simmim_to_pytorch.cpython-310.pyc b/openflamingo/lib/python3.10/site-packages/transformers/models/swin/__pycache__/convert_swin_simmim_to_pytorch.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..42be40b6afc18b65becee0cd1c8171430724551b
Binary files /dev/null and b/openflamingo/lib/python3.10/site-packages/transformers/models/swin/__pycache__/convert_swin_simmim_to_pytorch.cpython-310.pyc differ
diff --git a/openflamingo/lib/python3.10/site-packages/transformers/models/swin/__pycache__/convert_swin_timm_to_pytorch.cpython-310.pyc b/openflamingo/lib/python3.10/site-packages/transformers/models/swin/__pycache__/convert_swin_timm_to_pytorch.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..99cbcfb20042c87191c4a52b314364b9fba40380
Binary files /dev/null and b/openflamingo/lib/python3.10/site-packages/transformers/models/swin/__pycache__/convert_swin_timm_to_pytorch.cpython-310.pyc differ
diff --git a/openflamingo/lib/python3.10/site-packages/transformers/models/swin/configuration_swin.py b/openflamingo/lib/python3.10/site-packages/transformers/models/swin/configuration_swin.py
new file mode 100644
index 0000000000000000000000000000000000000000..757112f8cebf49adbbb6d4c263e6bfb124b02373
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/transformers/models/swin/configuration_swin.py
@@ -0,0 +1,180 @@
+# coding=utf-8
+# Copyright 2022 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""" Swin Transformer model configuration"""
+
+from collections import OrderedDict
+from typing import Mapping
+
+from packaging import version
+
+from ...configuration_utils import PretrainedConfig
+from ...onnx import OnnxConfig
+from ...utils import logging
+from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices
+
+
+logger = logging.get_logger(__name__)
+
+SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP = {
+    "microsoft/swin-tiny-patch4-window7-224": (
+        "https://huggingface.co/microsoft/swin-tiny-patch4-window7-224/resolve/main/config.json"
+    ),
+    # See all Swin models at https://huggingface.co/models?filter=swin
+}
+
+
+class SwinConfig(BackboneConfigMixin, PretrainedConfig):
+    r"""
+    This is the configuration class to store the configuration of a [`SwinModel`]. It is used to instantiate a Swin
+    model according to the specified arguments, defining the model architecture. Instantiating a configuration with the
+    defaults will yield a similar configuration to that of the Swin
+    [microsoft/swin-tiny-patch4-window7-224](https://huggingface.co/microsoft/swin-tiny-patch4-window7-224)
+    architecture.
+
+    Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
+    documentation from [`PretrainedConfig`] for more information.
+
+    Args:
+        image_size (`int`, *optional*, defaults to 224):
+            The size (resolution) of each image.
+        patch_size (`int`, *optional*, defaults to 4):
+            The size (resolution) of each patch.
+        num_channels (`int`, *optional*, defaults to 3):
+            The number of input channels.
+        embed_dim (`int`, *optional*, defaults to 96):
+            Dimensionality of patch embedding.
+        depths (`list(int)`, *optional*, defaults to [2, 2, 6, 2]):
+            Depth of each layer in the Transformer encoder.
+        num_heads (`list(int)`, *optional*, defaults to [3, 6, 12, 24]):
+            Number of attention heads in each layer of the Transformer encoder.
+        window_size (`int`, *optional*, defaults to 7):
+            Size of windows.
+        mlp_ratio (`float`, *optional*, defaults to 4.0):
+            Ratio of MLP hidden dimensionality to embedding dimensionality.
+        qkv_bias (`bool`, *optional*, defaults to True):
+            Whether or not a learnable bias should be added to the queries, keys and values.
+        hidden_dropout_prob (`float`, *optional*, defaults to 0.0):
+            The dropout probability for all fully connected layers in the embeddings and encoder.
+        attention_probs_dropout_prob (`float`, *optional*, defaults to 0.0):
+            The dropout ratio for the attention probabilities.
+        drop_path_rate (`float`, *optional*, defaults to 0.1):
+            Stochastic depth rate.
+        hidden_act (`str` or `function`, *optional*, defaults to `"gelu"`):
+            The non-linear activation function (function or string) in the encoder. If string, `"gelu"`, `"relu"`,
+            `"selu"` and `"gelu_new"` are supported.
+        use_absolute_embeddings (`bool`, *optional*, defaults to False):
+            Whether or not to add absolute position embeddings to the patch embeddings.
+        initializer_range (`float`, *optional*, defaults to 0.02):
+            The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
+        layer_norm_eps (`float`, *optional*, defaults to 1e-12):
+            The epsilon used by the layer normalization layers.
+        encoder_stride (`int`, `optional`, defaults to 32):
+            Factor to increase the spatial resolution by in the decoder head for masked image modeling.
+        out_features (`List[str]`, *optional*):
+            If used as backbone, list of features to output. Can be any of `"stem"`, `"stage1"`, `"stage2"`, etc.
+            (depending on how many stages the model has). If unset and `out_indices` is set, will default to the
+            corresponding stages. If unset and `out_indices` is unset, will default to the last stage.
+        out_indices (`List[int]`, *optional*):
+            If used as backbone, list of indices of features to output. Can be any of 0, 1, 2, etc. (depending on how
+            many stages the model has). If unset and `out_features` is set, will default to the corresponding stages.
+            If unset and `out_features` is unset, will default to the last stage.
+
+    Example:
+
+    ```python
+    >>> from transformers import SwinConfig, SwinModel
+
+    >>> # Initializing a Swin microsoft/swin-tiny-patch4-window7-224 style configuration
+    >>> configuration = SwinConfig()
+
+    >>> # Initializing a model (with random weights) from the microsoft/swin-tiny-patch4-window7-224 style configuration
+    >>> model = SwinModel(configuration)
+
+    >>> # Accessing the model configuration
+    >>> configuration = model.config
+    ```"""
+    model_type = "swin"
+
+    attribute_map = {
+        "num_attention_heads": "num_heads",
+        "num_hidden_layers": "num_layers",
+    }
+
+    def __init__(
+        self,
+        image_size=224,
+        patch_size=4,
+        num_channels=3,
+        embed_dim=96,
+        depths=[2, 2, 6, 2],
+        num_heads=[3, 6, 12, 24],
+        window_size=7,
+        mlp_ratio=4.0,
+        qkv_bias=True,
+        hidden_dropout_prob=0.0,
+        attention_probs_dropout_prob=0.0,
+        drop_path_rate=0.1,
+        hidden_act="gelu",
+        use_absolute_embeddings=False,
+        initializer_range=0.02,
+        layer_norm_eps=1e-5,
+        encoder_stride=32,
+        out_features=None,
+        out_indices=None,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+
+        self.image_size = image_size
+        self.patch_size = patch_size
+        self.num_channels = num_channels
+        self.embed_dim = embed_dim
+        self.depths = depths
+        self.num_layers = len(depths)
+        self.num_heads = num_heads
+        self.window_size = window_size
+        self.mlp_ratio = mlp_ratio
+        self.qkv_bias = qkv_bias
+        self.hidden_dropout_prob = hidden_dropout_prob
+        self.attention_probs_dropout_prob = attention_probs_dropout_prob
+        self.drop_path_rate = drop_path_rate
+        self.hidden_act = hidden_act
+        self.use_absolute_embeddings = use_absolute_embeddings
+        self.layer_norm_eps = layer_norm_eps
+        self.initializer_range = initializer_range
+        self.encoder_stride = encoder_stride
+        # we set the hidden_size attribute in order to make Swin work with VisionEncoderDecoderModel
+        # this indicates the channel dimension after the last stage of the model
+        self.hidden_size = int(embed_dim * 2 ** (len(depths) - 1))
+        self.stage_names = ["stem"] + [f"stage{idx}" for idx in range(1, len(depths) + 1)]
+        self._out_features, self._out_indices = get_aligned_output_features_output_indices(
+            out_features=out_features, out_indices=out_indices, stage_names=self.stage_names
+        )
+
+
+class SwinOnnxConfig(OnnxConfig):
+    torch_onnx_minimum_version = version.parse("1.11")
+
+    @property
+    def inputs(self) -> Mapping[str, Mapping[int, str]]:
+        return OrderedDict(
+            [
+                ("pixel_values", {0: "batch", 1: "num_channels", 2: "height", 3: "width"}),
+            ]
+        )
+
+    @property
+    def atol_for_validation(self) -> float:
+        return 1e-4
diff --git a/openflamingo/lib/python3.10/site-packages/transformers/models/swin/convert_swin_simmim_to_pytorch.py b/openflamingo/lib/python3.10/site-packages/transformers/models/swin/convert_swin_simmim_to_pytorch.py
new file mode 100644
index 0000000000000000000000000000000000000000..156b0ba86c524340fd2fb59a5f4762dfa874f722
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/transformers/models/swin/convert_swin_simmim_to_pytorch.py
@@ -0,0 +1,182 @@
+# coding=utf-8
+# Copyright 2022 The HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Convert Swin SimMIM checkpoints from the original repository.
+
+URL: https://github.com/microsoft/Swin-Transformer/blob/main/MODELHUB.md#simmim-pretrained-swin-v1-models"""
+
+import argparse
+
+import requests
+import torch
+from PIL import Image
+
+from transformers import SwinConfig, SwinForMaskedImageModeling, ViTImageProcessor
+
+
+def get_swin_config(model_name):
+    config = SwinConfig(image_size=192)
+
+    if "base" in model_name:
+        window_size = 6
+        embed_dim = 128
+        depths = (2, 2, 18, 2)
+        num_heads = (4, 8, 16, 32)
+    elif "large" in model_name:
+        window_size = 12
+        embed_dim = 192
+        depths = (2, 2, 18, 2)
+        num_heads = (6, 12, 24, 48)
+    else:
+        raise ValueError("Model not supported, only supports base and large variants")
+
+    config.window_size = window_size
+    config.embed_dim = embed_dim
+    config.depths = depths
+    config.num_heads = num_heads
+
+    return config
+
+
+def rename_key(name):
+    if "encoder.mask_token" in name:
+        name = name.replace("encoder.mask_token", "embeddings.mask_token")
+    if "encoder.patch_embed.proj" in name:
+        name = name.replace("encoder.patch_embed.proj", "embeddings.patch_embeddings.projection")
+    if "encoder.patch_embed.norm" in name:
+        name = name.replace("encoder.patch_embed.norm", "embeddings.norm")
+    if "attn.proj" in name:
+        name = name.replace("attn.proj", "attention.output.dense")
+    if "attn" in name:
+        name = name.replace("attn", "attention.self")
+    if "norm1" in name:
+        name = name.replace("norm1", "layernorm_before")
+    if "norm2" in name:
+        name = name.replace("norm2", "layernorm_after")
+    if "mlp.fc1" in name:
+        name = name.replace("mlp.fc1", "intermediate.dense")
+    if "mlp.fc2" in name:
+        name = name.replace("mlp.fc2", "output.dense")
+
+    if name == "encoder.norm.weight":
+        name = "layernorm.weight"
+    if name == "encoder.norm.bias":
+        name = "layernorm.bias"
+
+    if "decoder" in name:
+        pass
+    else:
+        name = "swin." + name
+
+    return name
+
+
+def convert_state_dict(orig_state_dict, model):
+    for key in orig_state_dict.copy().keys():
+        val = orig_state_dict.pop(key)
+
+        if "attn_mask" in key:
+            pass
+        elif "qkv" in key:
+            key_split = key.split(".")
+            layer_num = int(key_split[2])
+            block_num = int(key_split[4])
+            dim = model.swin.encoder.layers[layer_num].blocks[block_num].attention.self.all_head_size
+
+            if "weight" in key:
+                orig_state_dict[
+                    f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.query.weight"
+                ] = val[:dim, :]
+                orig_state_dict[f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.key.weight"] = val[
+                    dim : dim * 2, :
+                ]
+                orig_state_dict[
+                    f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.value.weight"
+                ] = val[-dim:, :]
+            else:
+                orig_state_dict[f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.query.bias"] = val[
+                    :dim
+                ]
+                orig_state_dict[f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.key.bias"] = val[
+                    dim : dim * 2
+                ]
+                orig_state_dict[f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.value.bias"] = val[
+                    -dim:
+                ]
+        else:
+            orig_state_dict[rename_key(key)] = val
+
+    return orig_state_dict
+
+
+def convert_swin_checkpoint(model_name, checkpoint_path, pytorch_dump_folder_path, push_to_hub):
+    state_dict = torch.load(checkpoint_path, map_location="cpu")["model"]
+
+    config = get_swin_config(model_name)
+    model = SwinForMaskedImageModeling(config)
+    model.eval()
+
+    new_state_dict = convert_state_dict(state_dict, model)
+    model.load_state_dict(new_state_dict)
+
+    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+
+    image_processor = ViTImageProcessor(size={"height": 192, "width": 192})
+    image = Image.open(requests.get(url, stream=True).raw)
+    inputs = image_processor(images=image, return_tensors="pt")
+
+    with torch.no_grad():
+        outputs = model(**inputs).logits
+
+    print(outputs.keys())
+    print("Looks ok!")
+
+    if pytorch_dump_folder_path is not None:
+        print(f"Saving model {model_name} to {pytorch_dump_folder_path}")
+        model.save_pretrained(pytorch_dump_folder_path)
+
+        print(f"Saving image processor to {pytorch_dump_folder_path}")
+        image_processor.save_pretrained(pytorch_dump_folder_path)
+
+    if push_to_hub:
+        print(f"Pushing model and image processor for {model_name} to hub")
+        model.push_to_hub(f"microsoft/{model_name}")
+        image_processor.push_to_hub(f"microsoft/{model_name}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    # Required parameters
+    parser.add_argument(
+        "--model_name",
+        default="swin-base-simmim-window6-192",
+        type=str,
+        choices=["swin-base-simmim-window6-192", "swin-large-simmim-window12-192"],
+        help="Name of the Swin SimMIM model you'd like to convert.",
+    )
+    parser.add_argument(
+        "--checkpoint_path",
+        default="/Users/nielsrogge/Documents/SwinSimMIM/simmim_pretrain__swin_base__img192_window6__100ep.pth",
+        type=str,
+        help="Path to the original PyTorch checkpoint (.pth file).",
+    )
+    parser.add_argument(
+        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
+    )
+    parser.add_argument(
+        "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
+    )
+
+    args = parser.parse_args()
+    convert_swin_checkpoint(args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub)
diff --git a/openflamingo/lib/python3.10/site-packages/transformers/models/swin/convert_swin_timm_to_pytorch.py b/openflamingo/lib/python3.10/site-packages/transformers/models/swin/convert_swin_timm_to_pytorch.py
new file mode 100644
index 0000000000000000000000000000000000000000..828237490e0ebd7eb0df8fae05c8c81e5eed4f14
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/transformers/models/swin/convert_swin_timm_to_pytorch.py
@@ -0,0 +1,173 @@
+import argparse
+import json
+
+import requests
+import timm
+import torch
+from huggingface_hub import hf_hub_download
+from PIL import Image
+
+from transformers import AutoImageProcessor, SwinConfig, SwinForImageClassification
+
+
+def get_swin_config(swin_name):
+    config = SwinConfig()
+    name_split = swin_name.split("_")
+
+    model_size = name_split[1]
+    img_size = int(name_split[4])
+    window_size = int(name_split[3][-1])
+
+    if model_size == "tiny":
+        embed_dim = 96
+        depths = (2, 2, 6, 2)
+        num_heads = (3, 6, 12, 24)
+    elif model_size == "small":
+        embed_dim = 96
+        depths = (2, 2, 18, 2)
+        num_heads = (3, 6, 12, 24)
+    elif model_size == "base":
+        embed_dim = 128
+        depths = (2, 2, 18, 2)
+        num_heads = (4, 8, 16, 32)
+    else:
+        embed_dim = 192
+        depths = (2, 2, 18, 2)
+        num_heads = (6, 12, 24, 48)
+
+    if "in22k" in swin_name:
+        num_classes = 21841
+    else:
+        num_classes = 1000
+        repo_id = "huggingface/label-files"
+        filename = "imagenet-1k-id2label.json"
+        id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
+        id2label = {int(k): v for k, v in id2label.items()}
+        config.id2label = id2label
+        config.label2id = {v: k for k, v in id2label.items()}
+
+    config.image_size = img_size
+    config.num_labels = num_classes
+    config.embed_dim = embed_dim
+    config.depths = depths
+    config.num_heads = num_heads
+    config.window_size = window_size
+
+    return config
+
+
+def rename_key(name):
+    if "patch_embed.proj" in name:
+        name = name.replace("patch_embed.proj", "embeddings.patch_embeddings.projection")
+    if "patch_embed.norm" in name:
+        name = name.replace("patch_embed.norm", "embeddings.norm")
+    if "layers" in name:
+        name = "encoder." + name
+    if "attn.proj" in name:
+        name = name.replace("attn.proj", "attention.output.dense")
+    if "attn" in name:
+        name = name.replace("attn", "attention.self")
+    if "norm1" in name:
+        name = name.replace("norm1", "layernorm_before")
+    if "norm2" in name:
+        name = name.replace("norm2", "layernorm_after")
+    if "mlp.fc1" in name:
+        name = name.replace("mlp.fc1", "intermediate.dense")
+    if "mlp.fc2" in name:
+        name = name.replace("mlp.fc2", "output.dense")
+
+    if name == "norm.weight":
+        name = "layernorm.weight"
+    if name == "norm.bias":
+        name = "layernorm.bias"
+
+    if "head" in name:
+        name = name.replace("head", "classifier")
+    else:
+        name = "swin." + name
+
+    return name
+
+
+def convert_state_dict(orig_state_dict, model):
+    for key in orig_state_dict.copy().keys():
+        val = orig_state_dict.pop(key)
+
+        if "mask" in key:
+            continue
+        elif "qkv" in key:
+            key_split = key.split(".")
+            layer_num = int(key_split[1])
+            block_num = int(key_split[3])
+            dim = model.swin.encoder.layers[layer_num].blocks[block_num].attention.self.all_head_size
+
+            if "weight" in key:
+                orig_state_dict[
+                    f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.query.weight"
+                ] = val[:dim, :]
+                orig_state_dict[f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.key.weight"] = val[
+                    dim : dim * 2, :
+                ]
+                orig_state_dict[
+                    f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.value.weight"
+                ] = val[-dim:, :]
+            else:
+                orig_state_dict[f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.query.bias"] = val[
+                    :dim
+                ]
+                orig_state_dict[f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.key.bias"] = val[
+                    dim : dim * 2
+                ]
+                orig_state_dict[f"swin.encoder.layers.{layer_num}.blocks.{block_num}.attention.self.value.bias"] = val[
+                    -dim:
+                ]
+        else:
+            orig_state_dict[rename_key(key)] = val
+
+    return orig_state_dict
+
+
+def convert_swin_checkpoint(swin_name, pytorch_dump_folder_path):
+    timm_model = timm.create_model(swin_name, pretrained=True)
+    timm_model.eval()
+
+    config = get_swin_config(swin_name)
+    model = SwinForImageClassification(config)
+    model.eval()
+
+    new_state_dict = convert_state_dict(timm_model.state_dict(), model)
+    model.load_state_dict(new_state_dict)
+
+    url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+
+    image_processor = AutoImageProcessor.from_pretrained("microsoft/{}".format(swin_name.replace("_", "-")))
+    image = Image.open(requests.get(url, stream=True).raw)
+    inputs = image_processor(images=image, return_tensors="pt")
+
+    timm_outs = timm_model(inputs["pixel_values"])
+    hf_outs = model(**inputs).logits
+
+    assert torch.allclose(timm_outs, hf_outs, atol=1e-3)
+
+    print(f"Saving model {swin_name} to {pytorch_dump_folder_path}")
+    model.save_pretrained(pytorch_dump_folder_path)
+
+    print(f"Saving image processor to {pytorch_dump_folder_path}")
+    image_processor.save_pretrained(pytorch_dump_folder_path)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    # Required parameters
+    parser.add_argument(
+        "--swin_name",
+        default="swin_tiny_patch4_window7_224",
+        type=str,
+        help="Name of the Swin timm model you'd like to convert.",
+    )
+    parser.add_argument(
+        "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
+    )
+
+    args = parser.parse_args()
+    convert_swin_checkpoint(args.swin_name, args.pytorch_dump_folder_path)