Add files using upload-large-folder tool

miniconda3/envs/active_proaction/lib/tcl8.6/msgs/sh.msg

@@ -0,0 +1,52 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset sh DAYS_OF_WEEK_ABBREV [list \
+        "Ned"\
+        "Pon"\
+        "Uto"\
+        "Sre"\
+        "\u010cet"\
+        "Pet"\
+        "Sub"]
+    ::msgcat::mcset sh DAYS_OF_WEEK_FULL [list \
+        "Nedelja"\
+        "Ponedeljak"\
+        "Utorak"\
+        "Sreda"\
+        "\u010cetvrtak"\
+        "Petak"\
+        "Subota"]
+    ::msgcat::mcset sh MONTHS_ABBREV [list \
+        "Jan"\
+        "Feb"\
+        "Mar"\
+        "Apr"\
+        "Maj"\
+        "Jun"\
+        "Jul"\
+        "Avg"\
+        "Sep"\
+        "Okt"\
+        "Nov"\
+        "Dec"\
+        ""]
+    ::msgcat::mcset sh MONTHS_FULL [list \
+        "Januar"\
+        "Februar"\
+        "Mart"\
+        "April"\
+        "Maj"\
+        "Juni"\
+        "Juli"\
+        "Avgust"\
+        "Septembar"\
+        "Oktobar"\
+        "Novembar"\
+        "Decembar"\
+        ""]
+    ::msgcat::mcset sh BCE "p. n. e."
+    ::msgcat::mcset sh CE "n. e."
+    ::msgcat::mcset sh DATE_FORMAT "%d.%m.%Y."
+    ::msgcat::mcset sh TIME_FORMAT "%k.%M.%S"
+    ::msgcat::mcset sh DATE_TIME_FORMAT "%d.%m.%Y. %k.%M.%S %z"
+}

miniconda3/envs/active_proaction/lib/tcl8.6/msgs/sk.msg

@@ -0,0 +1,52 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset sk DAYS_OF_WEEK_ABBREV [list \
+        "Ne"\
+        "Po"\
+        "Ut"\
+        "St"\
+        "\u0160t"\
+        "Pa"\
+        "So"]
+    ::msgcat::mcset sk DAYS_OF_WEEK_FULL [list \
+        "Nede\u013ee"\
+        "Pondelok"\
+        "Utorok"\
+        "Streda"\
+        "\u0160tvrtok"\
+        "Piatok"\
+        "Sobota"]
+    ::msgcat::mcset sk MONTHS_ABBREV [list \
+        "jan"\
+        "feb"\
+        "mar"\
+        "apr"\
+        "m\u00e1j"\
+        "j\u00fan"\
+        "j\u00fal"\
+        "aug"\
+        "sep"\
+        "okt"\
+        "nov"\
+        "dec"\
+        ""]
+    ::msgcat::mcset sk MONTHS_FULL [list \
+        "janu\u00e1r"\
+        "febru\u00e1r"\
+        "marec"\
+        "apr\u00edl"\
+        "m\u00e1j"\
+        "j\u00fan"\
+        "j\u00fal"\
+        "august"\
+        "september"\
+        "okt\u00f3ber"\
+        "november"\
+        "december"\
+        ""]
+    ::msgcat::mcset sk BCE "pred n.l."
+    ::msgcat::mcset sk CE "n.l."
+    ::msgcat::mcset sk DATE_FORMAT "%e.%m.%Y"
+    ::msgcat::mcset sk TIME_FORMAT "%k:%M:%S"
+    ::msgcat::mcset sk DATE_TIME_FORMAT "%e.%m.%Y %k:%M:%S %z"
+}

miniconda3/envs/active_proaction/lib/tcl8.6/msgs/sl.msg

@@ -0,0 +1,52 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset sl DAYS_OF_WEEK_ABBREV [list \
+        "Ned"\
+        "Pon"\
+        "Tor"\
+        "Sre"\
+        "\u010cet"\
+        "Pet"\
+        "Sob"]
+    ::msgcat::mcset sl DAYS_OF_WEEK_FULL [list \
+        "Nedelja"\
+        "Ponedeljek"\
+        "Torek"\
+        "Sreda"\
+        "\u010cetrtek"\
+        "Petek"\
+        "Sobota"]
+    ::msgcat::mcset sl MONTHS_ABBREV [list \
+        "jan"\
+        "feb"\
+        "mar"\
+        "apr"\
+        "maj"\
+        "jun"\
+        "jul"\
+        "avg"\
+        "sep"\
+        "okt"\
+        "nov"\
+        "dec"\
+        ""]
+    ::msgcat::mcset sl MONTHS_FULL [list \
+        "januar"\
+        "februar"\
+        "marec"\
+        "april"\
+        "maj"\
+        "junij"\
+        "julij"\
+        "avgust"\
+        "september"\
+        "oktober"\
+        "november"\
+        "december"\
+        ""]
+    ::msgcat::mcset sl BCE "pr.n.\u0161."
+    ::msgcat::mcset sl CE "po Kr."
+    ::msgcat::mcset sl DATE_FORMAT "%Y.%m.%e"
+    ::msgcat::mcset sl TIME_FORMAT "%k:%M:%S"
+    ::msgcat::mcset sl DATE_TIME_FORMAT "%Y.%m.%e %k:%M:%S %z"
+}

miniconda3/envs/active_proaction/lib/tcl8.6/msgs/sq.msg

@@ -0,0 +1,54 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset sq DAYS_OF_WEEK_ABBREV [list \
+        "Die"\
+        "H\u00ebn"\
+        "Mar"\
+        "M\u00ebr"\
+        "Enj"\
+        "Pre"\
+        "Sht"]
+    ::msgcat::mcset sq DAYS_OF_WEEK_FULL [list \
+        "e diel"\
+        "e h\u00ebn\u00eb"\
+        "e mart\u00eb"\
+        "e m\u00ebrkur\u00eb"\
+        "e enjte"\
+        "e premte"\
+        "e shtun\u00eb"]
+    ::msgcat::mcset sq MONTHS_ABBREV [list \
+        "Jan"\
+        "Shk"\
+        "Mar"\
+        "Pri"\
+        "Maj"\
+        "Qer"\
+        "Kor"\
+        "Gsh"\
+        "Sht"\
+        "Tet"\
+        "N\u00ebn"\
+        "Dhj"\
+        ""]
+    ::msgcat::mcset sq MONTHS_FULL [list \
+        "janar"\
+        "shkurt"\
+        "mars"\
+        "prill"\
+        "maj"\
+        "qershor"\
+        "korrik"\
+        "gusht"\
+        "shtator"\
+        "tetor"\
+        "n\u00ebntor"\
+        "dhjetor"\
+        ""]
+    ::msgcat::mcset sq BCE "p.e.r."
+    ::msgcat::mcset sq CE "n.e.r."
+    ::msgcat::mcset sq AM "PD"
+    ::msgcat::mcset sq PM "MD"
+    ::msgcat::mcset sq DATE_FORMAT "%Y-%m-%d"
+    ::msgcat::mcset sq TIME_FORMAT_12 "%l:%M:%S.%P"
+    ::msgcat::mcset sq DATE_TIME_FORMAT "%Y-%m-%d %l:%M:%S.%P %z"
+}

miniconda3/envs/active_proaction/lib/tcl8.6/msgs/sr.msg

@@ -0,0 +1,52 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset sr DAYS_OF_WEEK_ABBREV [list \
+        "\u041d\u0435\u0434"\
+        "\u041f\u043e\u043d"\
+        "\u0423\u0442\u043e"\
+        "\u0421\u0440\u0435"\
+        "\u0427\u0435\u0442"\
+        "\u041f\u0435\u0442"\
+        "\u0421\u0443\u0431"]
+    ::msgcat::mcset sr DAYS_OF_WEEK_FULL [list \
+        "\u041d\u0435\u0434\u0435\u0459\u0430"\
+        "\u041f\u043e\u043d\u0435\u0434\u0435\u0459\u0430\u043a"\
+        "\u0423\u0442\u043e\u0440\u0430\u043a"\
+        "\u0421\u0440\u0435\u0434\u0430"\
+        "\u0427\u0435\u0442\u0432\u0440\u0442\u0430\u043a"\
+        "\u041f\u0435\u0442\u0430\u043a"\
+        "\u0421\u0443\u0431\u043e\u0442\u0430"]
+    ::msgcat::mcset sr MONTHS_ABBREV [list \
+        "\u0408\u0430\u043d"\
+        "\u0424\u0435\u0431"\
+        "\u041c\u0430\u0440"\
+        "\u0410\u043f\u0440"\
+        "\u041c\u0430\u0458"\
+        "\u0408\u0443\u043d"\
+        "\u0408\u0443\u043b"\
+        "\u0410\u0432\u0433"\
+        "\u0421\u0435\u043f"\
+        "\u041e\u043a\u0442"\
+        "\u041d\u043e\u0432"\
+        "\u0414\u0435\u0446"\
+        ""]
+    ::msgcat::mcset sr MONTHS_FULL [list \
+        "\u0408\u0430\u043d\u0443\u0430\u0440"\
+        "\u0424\u0435\u0431\u0440\u0443\u0430\u0440"\
+        "\u041c\u0430\u0440\u0442"\
+        "\u0410\u043f\u0440\u0438\u043b"\
+        "\u041c\u0430\u0458"\
+        "\u0408\u0443\u043d\u0438"\
+        "\u0408\u0443\u043b\u0438"\
+        "\u0410\u0432\u0433\u0443\u0441\u0442"\
+        "\u0421\u0435\u043f\u0442\u0435\u043c\u0431\u0430\u0440"\
+        "\u041e\u043a\u0442\u043e\u0431\u0430\u0440"\
+        "\u041d\u043e\u0432\u0435\u043c\u0431\u0430\u0440"\
+        "\u0414\u0435\u0446\u0435\u043c\u0431\u0430\u0440"\
+        ""]
+    ::msgcat::mcset sr BCE "\u043f. \u043d. \u0435."
+    ::msgcat::mcset sr CE "\u043d. \u0435"
+    ::msgcat::mcset sr DATE_FORMAT "%Y.%m.%e"
+    ::msgcat::mcset sr TIME_FORMAT "%k.%M.%S"
+    ::msgcat::mcset sr DATE_TIME_FORMAT "%Y.%m.%e %k.%M.%S %z"
+}

miniconda3/envs/active_proaction/lib/tcl8.6/msgs/sv.msg

@@ -0,0 +1,52 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset sv DAYS_OF_WEEK_ABBREV [list \
+        "s\u00f6"\
+        "m\u00e5"\
+        "ti"\
+        "on"\
+        "to"\
+        "fr"\
+        "l\u00f6"]
+    ::msgcat::mcset sv DAYS_OF_WEEK_FULL [list \
+        "s\u00f6ndag"\
+        "m\u00e5ndag"\
+        "tisdag"\
+        "onsdag"\
+        "torsdag"\
+        "fredag"\
+        "l\u00f6rdag"]
+    ::msgcat::mcset sv MONTHS_ABBREV [list \
+        "jan"\
+        "feb"\
+        "mar"\
+        "apr"\
+        "maj"\
+        "jun"\
+        "jul"\
+        "aug"\
+        "sep"\
+        "okt"\
+        "nov"\
+        "dec"\
+        ""]
+    ::msgcat::mcset sv MONTHS_FULL [list \
+        "januari"\
+        "februari"\
+        "mars"\
+        "april"\
+        "maj"\
+        "juni"\
+        "juli"\
+        "augusti"\
+        "september"\
+        "oktober"\
+        "november"\
+        "december"\
+        ""]
+    ::msgcat::mcset sv BCE "f.Kr."
+    ::msgcat::mcset sv CE "e.Kr."
+    ::msgcat::mcset sv DATE_FORMAT "%Y-%m-%d"
+    ::msgcat::mcset sv TIME_FORMAT "%H:%M:%S"
+    ::msgcat::mcset sv DATE_TIME_FORMAT "%Y-%m-%d %H:%M:%S %z"
+}

miniconda3/envs/active_proaction/lib/tcl8.6/msgs/sw.msg

@@ -0,0 +1,49 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset sw DAYS_OF_WEEK_ABBREV [list \
+        "Jpi"\
+        "Jtt"\
+        "Jnn"\
+        "Jtn"\
+        "Alh"\
+        "Iju"\
+        "Jmo"]
+    ::msgcat::mcset sw DAYS_OF_WEEK_FULL [list \
+        "Jumapili"\
+        "Jumatatu"\
+        "Jumanne"\
+        "Jumatano"\
+        "Alhamisi"\
+        "Ijumaa"\
+        "Jumamosi"]
+    ::msgcat::mcset sw MONTHS_ABBREV [list \
+        "Jan"\
+        "Feb"\
+        "Mar"\
+        "Apr"\
+        "Mei"\
+        "Jun"\
+        "Jul"\
+        "Ago"\
+        "Sep"\
+        "Okt"\
+        "Nov"\
+        "Des"\
+        ""]
+    ::msgcat::mcset sw MONTHS_FULL [list \
+        "Januari"\
+        "Februari"\
+        "Machi"\
+        "Aprili"\
+        "Mei"\
+        "Juni"\
+        "Julai"\
+        "Agosti"\
+        "Septemba"\
+        "Oktoba"\
+        "Novemba"\
+        "Desemba"\
+        ""]
+    ::msgcat::mcset sw BCE "KK"
+    ::msgcat::mcset sw CE "BK"
+}

miniconda3/envs/active_proaction/lib/tcl8.6/msgs/ta.msg

@@ -0,0 +1,39 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset ta DAYS_OF_WEEK_FULL [list \
+        "\u0b9e\u0bbe\u0baf\u0bbf\u0bb1\u0bc1"\
+        "\u0ba4\u0bbf\u0b99\u0bcd\u0b95\u0bb3\u0bcd"\
+        "\u0b9a\u0bc6\u0bb5\u0bcd\u0bb5\u0bbe\u0baf\u0bcd"\
+        "\u0baa\u0bc1\u0ba4\u0ba9\u0bcd"\
+        "\u0bb5\u0bbf\u0baf\u0bbe\u0bb4\u0ba9\u0bcd"\
+        "\u0bb5\u0bc6\u0bb3\u0bcd\u0bb3\u0bbf"\
+        "\u0b9a\u0ba9\u0bbf"]
+    ::msgcat::mcset ta MONTHS_ABBREV [list \
+        "\u0b9c\u0ba9\u0bb5\u0bb0\u0bbf"\
+        "\u0baa\u0bc6\u0baa\u0bcd\u0bb0\u0bb5\u0bb0\u0bbf"\
+        "\u0bae\u0bbe\u0bb0\u0bcd\u0b9a\u0bcd"\
+        "\u0b8f\u0baa\u0bcd\u0bb0\u0bb2\u0bcd"\
+        "\u0bae\u0bc7"\
+        "\u0b9c\u0bc2\u0ba9\u0bcd"\
+        "\u0b9c\u0bc2\u0bb2\u0bc8"\
+        "\u0b86\u0b95\u0bb8\u0bcd\u0b9f\u0bcd"\
+        "\u0b9a\u0bc6\u0baa\u0bcd\u0b9f\u0bae\u0bcd\u0baa\u0bb0\u0bcd"\
+        "\u0b85\u0b95\u0bcd\u0b9f\u0bcb\u0baa\u0bb0\u0bcd"\
+        "\u0ba8\u0bb5\u0bae\u0bcd\u0baa\u0bb0\u0bcd"\
+        "\u0b9f\u0bbf\u0b9a\u0bae\u0bcd\u0baa\u0bb0\u0bcdr"]
+    ::msgcat::mcset ta MONTHS_FULL [list \
+        "\u0b9c\u0ba9\u0bb5\u0bb0\u0bbf"\
+        "\u0baa\u0bc6\u0baa\u0bcd\u0bb0\u0bb5\u0bb0\u0bbf"\
+        "\u0bae\u0bbe\u0bb0\u0bcd\u0b9a\u0bcd"\
+        "\u0b8f\u0baa\u0bcd\u0bb0\u0bb2\u0bcd"\
+        "\u0bae\u0bc7"\
+        "\u0b9c\u0bc2\u0ba9\u0bcd"\
+        "\u0b9c\u0bc2\u0bb2\u0bc8"\
+        "\u0b86\u0b95\u0bb8\u0bcd\u0b9f\u0bcd"\
+        "\u0b9a\u0bc6\u0baa\u0bcd\u0b9f\u0bae\u0bcd\u0baa\u0bb0\u0bcd"\
+        "\u0b85\u0b95\u0bcd\u0b9f\u0bcb\u0baa\u0bb0\u0bcd"\
+        "\u0ba8\u0bb5\u0bae\u0bcd\u0baa\u0bb0\u0bcd"\
+        "\u0b9f\u0bbf\u0b9a\u0bae\u0bcd\u0baa\u0bb0\u0bcdr"]
+    ::msgcat::mcset ta AM "\u0b95\u0bbf\u0bae\u0bc1"
+    ::msgcat::mcset ta PM "\u0b95\u0bbf\u0baa\u0bbf"
+}

miniconda3/envs/active_proaction/lib/tcl8.6/msgs/ta_in.msg

@@ -0,0 +1,6 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset ta_IN DATE_FORMAT "%d %M %Y"
+    ::msgcat::mcset ta_IN TIME_FORMAT_12 "%I:%M:%S %P"
+    ::msgcat::mcset ta_IN DATE_TIME_FORMAT "%d %M %Y %I:%M:%S %P %z"
+}

miniconda3/envs/active_proaction/lib/tcl8.6/msgs/te.msg

@@ -0,0 +1,47 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset te DAYS_OF_WEEK_ABBREV [list \
+        "\u0c06\u0c26\u0c3f"\
+        "\u0c38\u0c4b\u0c2e"\
+        "\u0c2e\u0c02\u0c17\u0c33"\
+        "\u0c2c\u0c41\u0c27"\
+        "\u0c17\u0c41\u0c30\u0c41"\
+        "\u0c36\u0c41\u0c15\u0c4d\u0c30"\
+        "\u0c36\u0c28\u0c3f"]
+    ::msgcat::mcset te DAYS_OF_WEEK_FULL [list \
+        "\u0c06\u0c26\u0c3f\u0c35\u0c3e\u0c30\u0c02"\
+        "\u0c38\u0c4b\u0c2e\u0c35\u0c3e\u0c30\u0c02"\
+        "\u0c2e\u0c02\u0c17\u0c33\u0c35\u0c3e\u0c30\u0c02"\
+        "\u0c2c\u0c41\u0c27\u0c35\u0c3e\u0c30\u0c02"\
+        "\u0c17\u0c41\u0c30\u0c41\u0c35\u0c3e\u0c30\u0c02"\
+        "\u0c36\u0c41\u0c15\u0c4d\u0c30\u0c35\u0c3e\u0c30\u0c02"\
+        "\u0c36\u0c28\u0c3f\u0c35\u0c3e\u0c30\u0c02"]
+    ::msgcat::mcset te MONTHS_ABBREV [list \
+        "\u0c1c\u0c28\u0c35\u0c30\u0c3f"\
+        "\u0c2b\u0c3f\u0c2c\u0c4d\u0c30\u0c35\u0c30\u0c3f"\
+        "\u0c2e\u0c3e\u0c30\u0c4d\u0c1a\u0c3f"\
+        "\u0c0f\u0c2a\u0c4d\u0c30\u0c3f\u0c32\u0c4d"\
+        "\u0c2e\u0c47"\
+        "\u0c1c\u0c42\u0c28\u0c4d"\
+        "\u0c1c\u0c42\u0c32\u0c48"\
+        "\u0c06\u0c17\u0c38\u0c4d\u0c1f\u0c41"\
+        "\u0c38\u0c46\u0c2a\u0c4d\u0c1f\u0c46\u0c02\u0c2c\u0c30\u0c4d"\
+        "\u0c05\u0c15\u0c4d\u0c1f\u0c4b\u0c2c\u0c30\u0c4d"\
+        "\u0c28\u0c35\u0c02\u0c2c\u0c30\u0c4d"\
+        "\u0c21\u0c3f\u0c38\u0c46\u0c02\u0c2c\u0c30\u0c4d"\
+        ""]
+    ::msgcat::mcset te MONTHS_FULL [list \
+        "\u0c1c\u0c28\u0c35\u0c30\u0c3f"\
+        "\u0c2b\u0c3f\u0c2c\u0c4d\u0c30\u0c35\u0c30\u0c3f"\
+        "\u0c2e\u0c3e\u0c30\u0c4d\u0c1a\u0c3f"\
+        "\u0c0f\u0c2a\u0c4d\u0c30\u0c3f\u0c32\u0c4d"\
+        "\u0c2e\u0c47"\
+        "\u0c1c\u0c42\u0c28\u0c4d"\
+        "\u0c1c\u0c42\u0c32\u0c48"\
+        "\u0c06\u0c17\u0c38\u0c4d\u0c1f\u0c41"\
+        "\u0c38\u0c46\u0c2a\u0c4d\u0c1f\u0c46\u0c02\u0c2c\u0c30\u0c4d"\
+        "\u0c05\u0c15\u0c4d\u0c1f\u0c4b\u0c2c\u0c30\u0c4d"\
+        "\u0c28\u0c35\u0c02\u0c2c\u0c30\u0c4d"\
+        "\u0c21\u0c3f\u0c38\u0c46\u0c02\u0c2c\u0c30\u0c4d"\
+        ""]
+}

miniconda3/envs/active_proaction/lib/tcl8.6/msgs/te_in.msg

@@ -0,0 +1,8 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset te_IN AM "\u0c2a\u0c42\u0c30\u0c4d\u0c35\u0c3e\u0c39\u0c4d\u0c28"
+    ::msgcat::mcset te_IN PM "\u0c05\u0c2a\u0c30\u0c3e\u0c39\u0c4d\u0c28"
+    ::msgcat::mcset te_IN DATE_FORMAT "%d/%m/%Y"
+    ::msgcat::mcset te_IN TIME_FORMAT_12 "%I:%M:%S %P"
+    ::msgcat::mcset te_IN DATE_TIME_FORMAT "%d/%m/%Y %I:%M:%S %P %z"
+}

miniconda3/envs/active_proaction/lib/tcl8.6/msgs/th.msg

@@ -0,0 +1,54 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset th DAYS_OF_WEEK_ABBREV [list \
+        "\u0e2d\u0e32."\
+        "\u0e08."\
+        "\u0e2d."\
+        "\u0e1e."\
+        "\u0e1e\u0e24."\
+        "\u0e28."\
+        "\u0e2a."]
+    ::msgcat::mcset th DAYS_OF_WEEK_FULL [list \
+        "\u0e27\u0e31\u0e19\u0e2d\u0e32\u0e17\u0e34\u0e15\u0e22\u0e4c"\
+        "\u0e27\u0e31\u0e19\u0e08\u0e31\u0e19\u0e17\u0e23\u0e4c"\
+        "\u0e27\u0e31\u0e19\u0e2d\u0e31\u0e07\u0e04\u0e32\u0e23"\
+        "\u0e27\u0e31\u0e19\u0e1e\u0e38\u0e18"\
+        "\u0e27\u0e31\u0e19\u0e1e\u0e24\u0e2b\u0e31\u0e2a\u0e1a\u0e14\u0e35"\
+        "\u0e27\u0e31\u0e19\u0e28\u0e38\u0e01\u0e23\u0e4c"\
+        "\u0e27\u0e31\u0e19\u0e40\u0e2a\u0e32\u0e23\u0e4c"]
+    ::msgcat::mcset th MONTHS_ABBREV [list \
+        "\u0e21.\u0e04."\
+        "\u0e01.\u0e1e."\
+        "\u0e21\u0e35.\u0e04."\
+        "\u0e40\u0e21.\u0e22."\
+        "\u0e1e.\u0e04."\
+        "\u0e21\u0e34.\u0e22."\
+        "\u0e01.\u0e04."\
+        "\u0e2a.\u0e04."\
+        "\u0e01.\u0e22."\
+        "\u0e15.\u0e04."\
+        "\u0e1e.\u0e22."\
+        "\u0e18.\u0e04."\
+        ""]
+    ::msgcat::mcset th MONTHS_FULL [list \
+        "\u0e21\u0e01\u0e23\u0e32\u0e04\u0e21"\
+        "\u0e01\u0e38\u0e21\u0e20\u0e32\u0e1e\u0e31\u0e19\u0e18\u0e4c"\
+        "\u0e21\u0e35\u0e19\u0e32\u0e04\u0e21"\
+        "\u0e40\u0e21\u0e29\u0e32\u0e22\u0e19"\
+        "\u0e1e\u0e24\u0e29\u0e20\u0e32\u0e04\u0e21"\
+        "\u0e21\u0e34\u0e16\u0e38\u0e19\u0e32\u0e22\u0e19"\
+        "\u0e01\u0e23\u0e01\u0e0e\u0e32\u0e04\u0e21"\
+        "\u0e2a\u0e34\u0e07\u0e2b\u0e32\u0e04\u0e21"\
+        "\u0e01\u0e31\u0e19\u0e22\u0e32\u0e22\u0e19"\
+        "\u0e15\u0e38\u0e25\u0e32\u0e04\u0e21"\
+        "\u0e1e\u0e24\u0e28\u0e08\u0e34\u0e01\u0e32\u0e22\u0e19"\
+        "\u0e18\u0e31\u0e19\u0e27\u0e32\u0e04\u0e21"\
+        ""]
+    ::msgcat::mcset th BCE "\u0e25\u0e17\u0e35\u0e48"
+    ::msgcat::mcset th CE "\u0e04.\u0e28."
+    ::msgcat::mcset th AM "\u0e01\u0e48\u0e2d\u0e19\u0e40\u0e17\u0e35\u0e48\u0e22\u0e07"
+    ::msgcat::mcset th PM "\u0e2b\u0e25\u0e31\u0e07\u0e40\u0e17\u0e35\u0e48\u0e22\u0e07"
+    ::msgcat::mcset th DATE_FORMAT "%e/%m/%Y"
+    ::msgcat::mcset th TIME_FORMAT "%k:%M:%S"
+    ::msgcat::mcset th DATE_TIME_FORMAT "%e/%m/%Y %k:%M:%S %z"
+}

miniconda3/envs/active_proaction/lib/tcl8.6/msgs/tr.msg

@@ -0,0 +1,50 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset tr DAYS_OF_WEEK_ABBREV [list \
+        "Paz"\
+        "Pzt"\
+        "Sal"\
+        "\u00c7ar"\
+        "Per"\
+        "Cum"\
+        "Cmt"]
+    ::msgcat::mcset tr DAYS_OF_WEEK_FULL [list \
+        "Pazar"\
+        "Pazartesi"\
+        "Sal\u0131"\
+        "\u00c7ar\u015famba"\
+        "Per\u015fembe"\
+        "Cuma"\
+        "Cumartesi"]
+    ::msgcat::mcset tr MONTHS_ABBREV [list \
+        "Oca"\
+        "\u015eub"\
+        "Mar"\
+        "Nis"\
+        "May"\
+        "Haz"\
+        "Tem"\
+        "A\u011fu"\
+        "Eyl"\
+        "Eki"\
+        "Kas"\
+        "Ara"\
+        ""]
+    ::msgcat::mcset tr MONTHS_FULL [list \
+        "Ocak"\
+        "\u015eubat"\
+        "Mart"\
+        "Nisan"\
+        "May\u0131s"\
+        "Haziran"\
+        "Temmuz"\
+        "A\u011fustos"\
+        "Eyl\u00fcl"\
+        "Ekim"\
+        "Kas\u0131m"\
+        "Aral\u0131k"\
+        ""]
+    ::msgcat::mcset tr DATE_FORMAT "%d.%m.%Y"
+    ::msgcat::mcset tr TIME_FORMAT "%H:%M:%S"
+    ::msgcat::mcset tr DATE_TIME_FORMAT "%d.%m.%Y %H:%M:%S %z"
+}

miniconda3/envs/active_proaction/lib/tcl8.6/msgs/uk.msg

@@ -0,0 +1,52 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset uk DAYS_OF_WEEK_ABBREV [list \
+        "\u043d\u0434"\
+        "\u043f\u043d"\
+        "\u0432\u0442"\
+        "\u0441\u0440"\
+        "\u0447\u0442"\
+        "\u043f\u0442"\
+        "\u0441\u0431"]
+    ::msgcat::mcset uk DAYS_OF_WEEK_FULL [list \
+        "\u043d\u0435\u0434\u0456\u043b\u044f"\
+        "\u043f\u043e\u043d\u0435\u0434\u0456\u043b\u043e\u043a"\
+        "\u0432\u0456\u0432\u0442\u043e\u0440\u043e\u043a"\
+        "\u0441\u0435\u0440\u0435\u0434\u0430"\
+        "\u0447\u0435\u0442\u0432\u0435\u0440"\
+        "\u043f'\u044f\u0442\u043d\u0438\u0446\u044f"\
+        "\u0441\u0443\u0431\u043e\u0442\u0430"]
+    ::msgcat::mcset uk MONTHS_ABBREV [list \
+        "\u0441\u0456\u0447"\
+        "\u043b\u044e\u0442"\
+        "\u0431\u0435\u0440"\
+        "\u043a\u0432\u0456\u0442"\
+        "\u0442\u0440\u0430\u0432"\
+        "\u0447\u0435\u0440\u0432"\
+        "\u043b\u0438\u043f"\
+        "\u0441\u0435\u0440\u043f"\
+        "\u0432\u0435\u0440"\
+        "\u0436\u043e\u0432\u0442"\
+        "\u043b\u0438\u0441\u0442"\
+        "\u0433\u0440\u0443\u0434"\
+        ""]
+    ::msgcat::mcset uk MONTHS_FULL [list \
+        "\u0441\u0456\u0447\u043d\u044f"\
+        "\u043b\u044e\u0442\u043e\u0433\u043e"\
+        "\u0431\u0435\u0440\u0435\u0437\u043d\u044f"\
+        "\u043a\u0432\u0456\u0442\u043d\u044f"\
+        "\u0442\u0440\u0430\u0432\u043d\u044f"\
+        "\u0447\u0435\u0440\u0432\u043d\u044f"\
+        "\u043b\u0438\u043f\u043d\u044f"\
+        "\u0441\u0435\u0440\u043f\u043d\u044f"\
+        "\u0432\u0435\u0440\u0435\u0441\u043d\u044f"\
+        "\u0436\u043e\u0432\u0442\u043d\u044f"\
+        "\u043b\u0438\u0441\u0442\u043e\u043f\u0430\u0434\u0430"\
+        "\u0433\u0440\u0443\u0434\u043d\u044f"\
+        ""]
+    ::msgcat::mcset uk BCE "\u0434\u043e \u043d.\u0435."
+    ::msgcat::mcset uk CE "\u043f\u0456\u0441\u043b\u044f \u043d.\u0435."
+    ::msgcat::mcset uk DATE_FORMAT "%e/%m/%Y"
+    ::msgcat::mcset uk TIME_FORMAT "%k:%M:%S"
+    ::msgcat::mcset uk DATE_TIME_FORMAT "%e/%m/%Y %k:%M:%S %z"
+}

miniconda3/envs/active_proaction/lib/tcl8.6/msgs/vi.msg

@@ -0,0 +1,50 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset vi DAYS_OF_WEEK_ABBREV [list \
+        "Th 2"\
+        "Th 3"\
+        "Th 4"\
+        "Th 5"\
+        "Th 6"\
+        "Th 7"\
+        "CN"]
+    ::msgcat::mcset vi DAYS_OF_WEEK_FULL [list \
+        "Th\u01b0\u0301 hai"\
+        "Th\u01b0\u0301 ba"\
+        "Th\u01b0\u0301 t\u01b0"\
+        "Th\u01b0\u0301 n\u0103m"\
+        "Th\u01b0\u0301 s\u00e1u"\
+        "Th\u01b0\u0301 ba\u0309y"\
+        "Chu\u0309 nh\u00e2\u0323t"]
+    ::msgcat::mcset vi MONTHS_ABBREV [list \
+        "Thg 1"\
+        "Thg 2"\
+        "Thg 3"\
+        "Thg 4"\
+        "Thg 5"\
+        "Thg 6"\
+        "Thg 7"\
+        "Thg 8"\
+        "Thg 9"\
+        "Thg 10"\
+        "Thg 11"\
+        "Thg 12"\
+        ""]
+    ::msgcat::mcset vi MONTHS_FULL [list \
+        "Th\u00e1ng m\u00f4\u0323t"\
+        "Th\u00e1ng hai"\
+        "Th\u00e1ng ba"\
+        "Th\u00e1ng t\u01b0"\
+        "Th\u00e1ng n\u0103m"\
+        "Th\u00e1ng s\u00e1u"\
+        "Th\u00e1ng ba\u0309y"\
+        "Th\u00e1ng t\u00e1m"\
+        "Th\u00e1ng ch\u00edn"\
+        "Th\u00e1ng m\u01b0\u01a1\u0300i"\
+        "Th\u00e1ng m\u01b0\u01a1\u0300i m\u00f4\u0323t"\
+        "Th\u00e1ng m\u01b0\u01a1\u0300i hai"\
+        ""]
+    ::msgcat::mcset vi DATE_FORMAT "%d %b %Y"
+    ::msgcat::mcset vi TIME_FORMAT "%H:%M:%S"
+    ::msgcat::mcset vi DATE_TIME_FORMAT "%d %b %Y %H:%M:%S %z"
+}

miniconda3/envs/active_proaction/lib/tcl8.6/msgs/zh.msg

@@ -0,0 +1,55 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset zh DAYS_OF_WEEK_ABBREV [list \
+        "\u661f\u671f\u65e5"\
+        "\u661f\u671f\u4e00"\
+        "\u661f\u671f\u4e8c"\
+        "\u661f\u671f\u4e09"\
+        "\u661f\u671f\u56db"\
+        "\u661f\u671f\u4e94"\
+        "\u661f\u671f\u516d"]
+    ::msgcat::mcset zh DAYS_OF_WEEK_FULL [list \
+        "\u661f\u671f\u65e5"\
+        "\u661f\u671f\u4e00"\
+        "\u661f\u671f\u4e8c"\
+        "\u661f\u671f\u4e09"\
+        "\u661f\u671f\u56db"\
+        "\u661f\u671f\u4e94"\
+        "\u661f\u671f\u516d"]
+    ::msgcat::mcset zh MONTHS_ABBREV [list \
+        "\u4e00\u6708"\
+        "\u4e8c\u6708"\
+        "\u4e09\u6708"\
+        "\u56db\u6708"\
+        "\u4e94\u6708"\
+        "\u516d\u6708"\
+        "\u4e03\u6708"\
+        "\u516b\u6708"\
+        "\u4e5d\u6708"\
+        "\u5341\u6708"\
+        "\u5341\u4e00\u6708"\
+        "\u5341\u4e8c\u6708"\
+        ""]
+    ::msgcat::mcset zh MONTHS_FULL [list \
+        "\u4e00\u6708"\
+        "\u4e8c\u6708"\
+        "\u4e09\u6708"\
+        "\u56db\u6708"\
+        "\u4e94\u6708"\
+        "\u516d\u6708"\
+        "\u4e03\u6708"\
+        "\u516b\u6708"\
+        "\u4e5d\u6708"\
+        "\u5341\u6708"\
+        "\u5341\u4e00\u6708"\
+        "\u5341\u4e8c\u6708"\
+        ""]
+    ::msgcat::mcset zh BCE "\u516c\u5143\u524d"
+    ::msgcat::mcset zh CE "\u516c\u5143"
+    ::msgcat::mcset zh AM "\u4e0a\u5348"
+    ::msgcat::mcset zh PM "\u4e0b\u5348"
+    ::msgcat::mcset zh LOCALE_NUMERALS "\u3007 \u4e00 \u4e8c \u4e09 \u56db \u4e94 \u516d \u4e03 \u516b \u4e5d \u5341 \u5341\u4e00 \u5341\u4e8c \u5341\u4e09 \u5341\u56db \u5341\u4e94 \u5341\u516d \u5341\u4e03 \u5341\u516b \u5341\u4e5d \u4e8c\u5341 \u5eff\u4e00 \u5eff\u4e8c \u5eff\u4e09 \u5eff\u56db \u5eff\u4e94 \u5eff\u516d \u5eff\u4e03 \u5eff\u516b \u5eff\u4e5d \u4e09\u5341 \u5345\u4e00 \u5345\u4e8c \u5345\u4e09 \u5345\u56db \u5345\u4e94 \u5345\u516d \u5345\u4e03 \u5345\u516b \u5345\u4e5d \u56db\u5341 \u56db\u5341\u4e00 \u56db\u5341\u4e8c \u56db\u5341\u4e09 \u56db\u5341\u56db \u56db\u5341\u4e94 \u56db\u5341\u516d \u56db\u5341\u4e03 \u56db\u5341\u516b \u56db\u5341\u4e5d \u4e94\u5341 \u4e94\u5341\u4e00 \u4e94\u5341\u4e8c \u4e94\u5341\u4e09 \u4e94\u5341\u56db \u4e94\u5341\u4e94 \u4e94\u5341\u516d \u4e94\u5341\u4e03 \u4e94\u5341\u516b \u4e94\u5341\u4e5d \u516d\u5341 \u516d\u5341\u4e00 \u516d\u5341\u4e8c \u516d\u5341\u4e09 \u516d\u5341\u56db \u516d\u5341\u4e94 \u516d\u5341\u516d \u516d\u5341\u4e03 \u516d\u5341\u516b \u516d\u5341\u4e5d \u4e03\u5341 \u4e03\u5341\u4e00 \u4e03\u5341\u4e8c \u4e03\u5341\u4e09 \u4e03\u5341\u56db \u4e03\u5341\u4e94 \u4e03\u5341\u516d \u4e03\u5341\u4e03 \u4e03\u5341\u516b \u4e03\u5341\u4e5d \u516b\u5341 \u516b\u5341\u4e00 \u516b\u5341\u4e8c \u516b\u5341\u4e09 \u516b\u5341\u56db \u516b\u5341\u4e94 \u516b\u5341\u516d \u516b\u5341\u4e03 \u516b\u5341\u516b \u516b\u5341\u4e5d \u4e5d\u5341 \u4e5d\u5341\u4e00 \u4e5d\u5341\u4e8c \u4e5d\u5341\u4e09 \u4e5d\u5341\u56db \u4e5d\u5341\u4e94 \u4e5d\u5341\u516d \u4e5d\u5341\u4e03 \u4e5d\u5341\u516b \u4e5d\u5341\u4e5d"
+    ::msgcat::mcset zh LOCALE_DATE_FORMAT "\u516c\u5143%Y\u5e74%B%Od\u65e5"
+    ::msgcat::mcset zh LOCALE_TIME_FORMAT "%OH\u65f6%OM\u5206%OS\u79d2"
+    ::msgcat::mcset zh LOCALE_DATE_TIME_FORMAT "%A %Y\u5e74%B%Od\u65e5%OH\u65f6%OM\u5206%OS\u79d2 %z"
+}

miniconda3/envs/active_proaction/lib/tcl8.6/msgs/zh_cn.msg

@@ -0,0 +1,7 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset zh_CN DATE_FORMAT "%Y-%m-%e"
+    ::msgcat::mcset zh_CN TIME_FORMAT "%k:%M:%S"
+    ::msgcat::mcset zh_CN TIME_FORMAT_12 "%P%I\u65f6%M\u5206%S\u79d2"
+    ::msgcat::mcset zh_CN DATE_TIME_FORMAT "%Y-%m-%e %k:%M:%S %z"
+}

miniconda3/envs/active_proaction/lib/tcl8.6/msgs/zh_hk.msg

@@ -0,0 +1,28 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset zh_HK DAYS_OF_WEEK_ABBREV [list \
+        "\u65e5"\
+        "\u4e00"\
+        "\u4e8c"\
+        "\u4e09"\
+        "\u56db"\
+        "\u4e94"\
+        "\u516d"]
+    ::msgcat::mcset zh_HK MONTHS_ABBREV [list \
+        "1\u6708"\
+        "2\u6708"\
+        "3\u6708"\
+        "4\u6708"\
+        "5\u6708"\
+        "6\u6708"\
+        "7\u6708"\
+        "8\u6708"\
+        "9\u6708"\
+        "10\u6708"\
+        "11\u6708"\
+        "12\u6708"\
+        ""]
+    ::msgcat::mcset zh_HK DATE_FORMAT "%Y\u5e74%m\u6708%e\u65e5"
+    ::msgcat::mcset zh_HK TIME_FORMAT_12 "%P%I:%M:%S"
+    ::msgcat::mcset zh_HK DATE_TIME_FORMAT "%Y\u5e74%m\u6708%e\u65e5 %P%I:%M:%S %z"
+}

miniconda3/envs/active_proaction/lib/tcl8.6/msgs/zh_sg.msg

@@ -0,0 +1,8 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset zh_SG AM "\u4e0a\u5348"
+    ::msgcat::mcset zh_SG PM "\u4e2d\u5348"
+    ::msgcat::mcset zh_SG DATE_FORMAT "%d %B %Y"
+    ::msgcat::mcset zh_SG TIME_FORMAT_12 "%P %I:%M:%S"
+    ::msgcat::mcset zh_SG DATE_TIME_FORMAT "%d %B %Y %P %I:%M:%S %z"
+}

miniconda3/envs/active_proaction/lib/tcl8.6/msgs/zh_tw.msg

@@ -0,0 +1,8 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset zh_TW BCE "\u6c11\u570b\u524d"
+    ::msgcat::mcset zh_TW CE "\u6c11\u570b"
+    ::msgcat::mcset zh_TW DATE_FORMAT "%Y/%m/%e"
+    ::msgcat::mcset zh_TW TIME_FORMAT_12 "%P %I:%M:%S"
+    ::msgcat::mcset zh_TW DATE_TIME_FORMAT "%Y/%m/%e %P %I:%M:%S %z"
+}

miniconda3/envs/active_proaction/lib/tcl8.6/opt0.4/optparse.tcl

@@ -0,0 +1,1072 @@
+# optparse.tcl --
+#
+#       (private) Option parsing package
+#       Primarily used internally by the safe:: code.
+#
+#	WARNING: This code will go away in a future release
+#	of Tcl.  It is NOT supported and you should not rely
+#	on it.  If your code does rely on this package you
+#	may directly incorporate this code into your application.
+
+package require Tcl 8.5-
+# When this version number changes, update the pkgIndex.tcl file
+# and the install directory in the Makefiles.
+package provide opt 0.4.9
+
+namespace eval ::tcl {
+
+    # Exported APIs
+    namespace export OptKeyRegister OptKeyDelete OptKeyError OptKeyParse \
+             OptProc OptProcArgGiven OptParse \
+	     Lempty Lget \
+             Lassign Lvarpop Lvarpop1 Lvarset Lvarincr \
+             SetMax SetMin
+
+
+#################  Example of use / 'user documentation'  ###################
+
+    proc OptCreateTestProc {} {
+
+	# Defines ::tcl::OptParseTest as a test proc with parsed arguments
+	# (can't be defined before the code below is loaded (before "OptProc"))
+
+	# Every OptProc give usage information on "procname -help".
+	# Try "tcl::OptParseTest -help" and "tcl::OptParseTest -a" and
+	# then other arguments.
+	#
+	# example of 'valid' call:
+	# ::tcl::OptParseTest save -4 -pr 23 -libsok SybTcl\
+	#		-nostatics false ch1
+	OptProc OptParseTest {
+            {subcommand -choice {save print} "sub command"}
+            {arg1 3 "some number"}
+            {-aflag}
+            {-intflag      7}
+            {-weirdflag                    "help string"}
+            {-noStatics                    "Not ok to load static packages"}
+            {-nestedloading1 true           "OK to load into nested children"}
+            {-nestedloading2 -boolean true "OK to load into nested children"}
+            {-libsOK        -choice {Tk SybTcl}
+		                      "List of packages that can be loaded"}
+            {-precision     -int 12        "Number of digits of precision"}
+            {-intval        7               "An integer"}
+            {-scale         -float 1.0     "Scale factor"}
+            {-zoom          1.0             "Zoom factor"}
+            {-arbitrary     foobar          "Arbitrary string"}
+            {-random        -string 12   "Random string"}
+            {-listval       -list {}       "List value"}
+            {-blahflag       -blah abc       "Funny type"}
+	    {arg2 -boolean "a boolean"}
+	    {arg3 -choice "ch1 ch2"}
+	    {?optarg? -list {} "optional argument"}
+        } {
+	    foreach v [info locals] {
+		puts stderr [format "%14s : %s" $v [set $v]]
+	    }
+	}
+    }
+
+###################  No User serviceable part below ! ###############
+
+    # Array storing the parsed descriptions
+    variable OptDesc
+    array set OptDesc {}
+    # Next potentially free key id (numeric)
+    variable OptDescN 0
+
+# Inside algorithm/mechanism description:
+# (not for the faint-hearted ;-)
+#
+# The argument description is parsed into a "program tree"
+# It is called a "program" because it is the program used by
+# the state machine interpreter that use that program to
+# actually parse the arguments at run time.
+#
+# The general structure of a "program" is
+# notation (pseudo bnf like)
+#    name :== definition        defines "name" as being "definition"
+#    { x y z }                  means list of x, y, and z
+#    x*                         means x repeated 0 or more time
+#    x+                         means "x x*"
+#    x?                         means optionally x
+#    x | y                      means x or y
+#    "cccc"                     means the literal string
+#
+#    program        :== { programCounter programStep* }
+#
+#    programStep    :== program | singleStep
+#
+#    programCounter :== {"P" integer+ }
+#
+#    singleStep     :== { instruction parameters* }
+#
+#    instruction    :== single element list
+#
+# (the difference between singleStep and program is that \
+#   llength [lindex $program 0] >= 2
+# while
+#   llength [lindex $singleStep 0] == 1
+# )
+#
+# And for this application:
+#
+#    singleStep     :== { instruction varname {hasBeenSet currentValue} type
+#                         typeArgs help }
+#    instruction    :== "flags" | "value"
+#    type           :== knowType | anyword
+#    knowType       :== "string" | "int" | "boolean" | "boolflag" | "float"
+#                       | "choice"
+#
+# for type "choice" typeArgs is a list of possible choices, the first one
+# is the default value. for all other types the typeArgs is the default value
+#
+# a "boolflag" is the type for a flag whose presence or absence, without
+# additional arguments means respectively true or false (default flag type).
+#
+# programCounter is the index in the list of the currently processed
+# programStep (thus starting at 1 (0 is {"P" prgCounterValue}).
+# If it is a list it points toward each currently selected programStep.
+# (like for "flags", as they are optional, form a set and programStep).
+
+# Performance/Implementation issues
+# ---------------------------------
+# We use tcl lists instead of arrays because with tcl8.0
+# they should start to be much faster.
+# But this code use a lot of helper procs (like Lvarset)
+# which are quite slow and would be helpfully optimized
+# for instance by being written in C. Also our structure
+# is complex and there is maybe some places where the
+# string rep might be calculated at great expense. to be checked.
+
+#
+# Parse a given description and saves it here under the given key
+# generate a unused keyid if not given
+#
+proc ::tcl::OptKeyRegister {desc {key ""}} {
+    variable OptDesc
+    variable OptDescN
+    if {[string equal $key ""]} {
+        # in case a key given to us as a parameter was a number
+        while {[info exists OptDesc($OptDescN)]} {incr OptDescN}
+        set key $OptDescN
+        incr OptDescN
+    }
+    # program counter
+    set program [list [list "P" 1]]
+
+    # are we processing flags (which makes a single program step)
+    set inflags 0
+
+    set state {}
+
+    # flag used to detect that we just have a single (flags set) subprogram.
+    set empty 1
+
+    foreach item $desc {
+	if {$state == "args"} {
+	    # more items after 'args'...
+	    return -code error "'args' special argument must be the last one"
+	}
+        set res [OptNormalizeOne $item]
+        set state [lindex $res 0]
+        if {$inflags} {
+            if {$state == "flags"} {
+		# add to 'subprogram'
+                lappend flagsprg $res
+            } else {
+                # put in the flags
+                # structure for flag programs items is a list of
+                # {subprgcounter {prg flag 1} {prg flag 2} {...}}
+                lappend program $flagsprg
+                # put the other regular stuff
+                lappend program $res
+		set inflags 0
+		set empty 0
+            }
+        } else {
+           if {$state == "flags"} {
+               set inflags 1
+               # sub program counter + first sub program
+               set flagsprg [list [list "P" 1] $res]
+           } else {
+               lappend program $res
+               set empty 0
+           }
+       }
+   }
+   if {$inflags} {
+       if {$empty} {
+	   # We just have the subprogram, optimize and remove
+	   # unneeded level:
+	   set program $flagsprg
+       } else {
+	   lappend program $flagsprg
+       }
+   }
+
+   set OptDesc($key) $program
+
+   return $key
+}
+
+#
+# Free the storage for that given key
+#
+proc ::tcl::OptKeyDelete {key} {
+    variable OptDesc
+    unset OptDesc($key)
+}
+
+    # Get the parsed description stored under the given key.
+    proc OptKeyGetDesc {descKey} {
+        variable OptDesc
+        if {![info exists OptDesc($descKey)]} {
+            return -code error "Unknown option description key \"$descKey\""
+        }
+        set OptDesc($descKey)
+    }
+
+# Parse entry point for people who don't want to register with a key,
+# for instance because the description changes dynamically.
+#  (otherwise one should really use OptKeyRegister once + OptKeyParse
+#   as it is way faster or simply OptProc which does it all)
+# Assign a temporary key, call OptKeyParse and then free the storage
+proc ::tcl::OptParse {desc arglist} {
+    set tempkey [OptKeyRegister $desc]
+    set ret [catch {uplevel 1 [list ::tcl::OptKeyParse $tempkey $arglist]} res]
+    OptKeyDelete $tempkey
+    return -code $ret $res
+}
+
+# Helper function, replacement for proc that both
+# register the description under a key which is the name of the proc
+# (and thus unique to that code)
+# and add a first line to the code to call the OptKeyParse proc
+# Stores the list of variables that have been actually given by the user
+# (the other will be sets to their default value)
+# into local variable named "Args".
+proc ::tcl::OptProc {name desc body} {
+    set namespace [uplevel 1 [list ::namespace current]]
+    if {[string match "::*" $name] || [string equal $namespace "::"]} {
+        # absolute name or global namespace, name is the key
+        set key $name
+    } else {
+        # we are relative to some non top level namespace:
+        set key "${namespace}::${name}"
+    }
+    OptKeyRegister $desc $key
+    uplevel 1 [list ::proc $name args "set Args \[::tcl::OptKeyParse $key \$args\]\n$body"]
+    return $key
+}
+# Check that a argument has been given
+# assumes that "OptProc" has been used as it will check in "Args" list
+proc ::tcl::OptProcArgGiven {argname} {
+    upvar Args alist
+    expr {[lsearch $alist $argname] >=0}
+}
+
+    #######
+    # Programs/Descriptions manipulation
+
+    # Return the instruction word/list of a given step/(sub)program
+    proc OptInstr {lst} {
+	lindex $lst 0
+    }
+    # Is a (sub) program or a plain instruction ?
+    proc OptIsPrg {lst} {
+	expr {[llength [OptInstr $lst]]>=2}
+    }
+    # Is this instruction a program counter or a real instr
+    proc OptIsCounter {item} {
+	expr {[lindex $item 0]=="P"}
+    }
+    # Current program counter (2nd word of first word)
+    proc OptGetPrgCounter {lst} {
+	Lget $lst {0 1}
+    }
+    # Current program counter (2nd word of first word)
+    proc OptSetPrgCounter {lstName newValue} {
+	upvar $lstName lst
+	set lst [lreplace $lst 0 0 [concat "P" $newValue]]
+    }
+    # returns a list of currently selected items.
+    proc OptSelection {lst} {
+	set res {}
+	foreach idx [lrange [lindex $lst 0] 1 end] {
+	    lappend res [Lget $lst $idx]
+	}
+	return $res
+    }
+
+    # Advance to next description
+    proc OptNextDesc {descName} {
+        uplevel 1 [list Lvarincr $descName {0 1}]
+    }
+
+    # Get the current description, eventually descend
+    proc OptCurDesc {descriptions} {
+        lindex $descriptions [OptGetPrgCounter $descriptions]
+    }
+    # get the current description, eventually descend
+    # through sub programs as needed.
+    proc OptCurDescFinal {descriptions} {
+        set item [OptCurDesc $descriptions]
+	# Descend untill we get the actual item and not a sub program
+        while {[OptIsPrg $item]} {
+            set item [OptCurDesc $item]
+        }
+	return $item
+    }
+    # Current final instruction adress
+    proc OptCurAddr {descriptions {start {}}} {
+	set adress [OptGetPrgCounter $descriptions]
+	lappend start $adress
+	set item [lindex $descriptions $adress]
+	if {[OptIsPrg $item]} {
+	    return [OptCurAddr $item $start]
+	} else {
+	    return $start
+	}
+    }
+    # Set the value field of the current instruction.
+    proc OptCurSetValue {descriptionsName value} {
+	upvar $descriptionsName descriptions
+	# Get the current item full address.
+        set adress [OptCurAddr $descriptions]
+	# Use the 3rd field of the item  (see OptValue / OptNewInst).
+	lappend adress 2
+	Lvarset descriptions $adress [list 1 $value]
+	#                                  ^hasBeenSet flag
+    }
+
+    # Empty state means done/paste the end of the program.
+    proc OptState {item} {
+        lindex $item 0
+    }
+
+    # current state
+    proc OptCurState {descriptions} {
+        OptState [OptCurDesc $descriptions]
+    }
+
+    #######
+    # Arguments manipulation
+
+    # Returns the argument that has to be processed now.
+    proc OptCurrentArg {lst} {
+        lindex $lst 0
+    }
+    # Advance to next argument.
+    proc OptNextArg {argsName} {
+        uplevel 1 [list Lvarpop1 $argsName]
+    }
+    #######
+
+
+
+
+
+    # Loop over all descriptions, calling OptDoOne which will
+    # eventually eat all the arguments.
+    proc OptDoAll {descriptionsName argumentsName} {
+	upvar $descriptionsName descriptions
+	upvar $argumentsName arguments
+#	puts "entered DoAll"
+	# Nb: the places where "state" can be set are tricky to figure
+	#     because DoOne sets the state to flagsValue and return -continue
+	#     when needed...
+	set state [OptCurState $descriptions]
+	# We'll exit the loop in "OptDoOne" or when state is empty.
+        while 1 {
+	    set curitem [OptCurDesc $descriptions]
+	    # Do subprograms if needed, call ourselves on the sub branch
+	    while {[OptIsPrg $curitem]} {
+		OptDoAll curitem arguments
+#		puts "done DoAll sub"
+		# Insert back the results in current tree
+		Lvarset1nc descriptions [OptGetPrgCounter $descriptions]\
+			$curitem
+		OptNextDesc descriptions
+		set curitem [OptCurDesc $descriptions]
+                set state [OptCurState $descriptions]
+	    }
+#           puts "state = \"$state\" - arguments=($arguments)"
+	    if {[Lempty $state]} {
+		# Nothing left to do, we are done in this branch:
+		break
+	    }
+	    # The following statement can make us terminate/continue
+	    # as it use return -code {break, continue, return and error}
+	    # codes
+            OptDoOne descriptions state arguments
+	    # If we are here, no special return code where issued,
+	    # we'll step to next instruction :
+#           puts "new state  = \"$state\""
+	    OptNextDesc descriptions
+	    set state [OptCurState $descriptions]
+        }
+    }
+
+    # Process one step for the state machine,
+    # eventually consuming the current argument.
+    proc OptDoOne {descriptionsName stateName argumentsName} {
+        upvar $argumentsName arguments
+        upvar $descriptionsName descriptions
+	upvar $stateName state
+
+	# the special state/instruction "args" eats all
+	# the remaining args (if any)
+	if {($state == "args")} {
+	    if {![Lempty $arguments]} {
+		# If there is no additional arguments, leave the default value
+		# in.
+		OptCurSetValue descriptions $arguments
+		set arguments {}
+	    }
+#            puts "breaking out ('args' state: consuming every reminding args)"
+	    return -code break
+	}
+
+	if {[Lempty $arguments]} {
+	    if {$state == "flags"} {
+		# no argument and no flags : we're done
+#                puts "returning to previous (sub)prg (no more args)"
+		return -code return
+	    } elseif {$state == "optValue"} {
+		set state next; # not used, for debug only
+		# go to next state
+		return
+	    } else {
+		return -code error [OptMissingValue $descriptions]
+	    }
+	} else {
+	    set arg [OptCurrentArg $arguments]
+	}
+
+        switch $state {
+            flags {
+                # A non-dash argument terminates the options, as does --
+
+                # Still a flag ?
+                if {![OptIsFlag $arg]} {
+                    # don't consume the argument, return to previous prg
+                    return -code return
+                }
+                # consume the flag
+                OptNextArg arguments
+                if {[string equal "--" $arg]} {
+                    # return from 'flags' state
+                    return -code return
+                }
+
+                set hits [OptHits descriptions $arg]
+                if {$hits > 1} {
+                    return -code error [OptAmbigous $descriptions $arg]
+                } elseif {$hits == 0} {
+                    return -code error [OptFlagUsage $descriptions $arg]
+                }
+		set item [OptCurDesc $descriptions]
+                if {[OptNeedValue $item]} {
+		    # we need a value, next state is
+		    set state flagValue
+                } else {
+                    OptCurSetValue descriptions 1
+                }
+		# continue
+		return -code continue
+            }
+	    flagValue -
+	    value {
+		set item [OptCurDesc $descriptions]
+                # Test the values against their required type
+		if {[catch {OptCheckType $arg\
+			[OptType $item] [OptTypeArgs $item]} val]} {
+		    return -code error [OptBadValue $item $arg $val]
+		}
+                # consume the value
+                OptNextArg arguments
+		# set the value
+		OptCurSetValue descriptions $val
+		# go to next state
+		if {$state == "flagValue"} {
+		    set state flags
+		    return -code continue
+		} else {
+		    set state next; # not used, for debug only
+		    return ; # will go on next step
+		}
+	    }
+	    optValue {
+		set item [OptCurDesc $descriptions]
+                # Test the values against their required type
+		if {![catch {OptCheckType $arg\
+			[OptType $item] [OptTypeArgs $item]} val]} {
+		    # right type, so :
+		    # consume the value
+		    OptNextArg arguments
+		    # set the value
+		    OptCurSetValue descriptions $val
+		}
+		# go to next state
+		set state next; # not used, for debug only
+		return ; # will go on next step
+	    }
+        }
+	# If we reach this point: an unknown
+	# state as been entered !
+	return -code error "Bug! unknown state in DoOne \"$state\"\
+		(prg counter [OptGetPrgCounter $descriptions]:\
+			[OptCurDesc $descriptions])"
+    }
+
+# Parse the options given the key to previously registered description
+# and arguments list
+proc ::tcl::OptKeyParse {descKey arglist} {
+
+    set desc [OptKeyGetDesc $descKey]
+
+    # make sure -help always give usage
+    if {[string equal -nocase "-help" $arglist]} {
+	return -code error [OptError "Usage information:" $desc 1]
+    }
+
+    OptDoAll desc arglist
+
+    if {![Lempty $arglist]} {
+	return -code error [OptTooManyArgs $desc $arglist]
+    }
+
+    # Analyse the result
+    # Walk through the tree:
+    OptTreeVars $desc "#[expr {[info level]-1}]"
+}
+
+    # determine string length for nice tabulated output
+    proc OptTreeVars {desc level {vnamesLst {}}} {
+	foreach item $desc {
+	    if {[OptIsCounter $item]} continue
+	    if {[OptIsPrg $item]} {
+		set vnamesLst [OptTreeVars $item $level $vnamesLst]
+	    } else {
+		set vname [OptVarName $item]
+		upvar $level $vname var
+		if {[OptHasBeenSet $item]} {
+#		    puts "adding $vname"
+		    # lets use the input name for the returned list
+		    # it is more useful, for instance you can check that
+		    # no flags at all was given with expr
+		    # {![string match "*-*" $Args]}
+		    lappend vnamesLst [OptName $item]
+		    set var [OptValue $item]
+		} else {
+		    set var [OptDefaultValue $item]
+		}
+	    }
+	}
+	return $vnamesLst
+    }
+
+
+# Check the type of a value
+# and emit an error if arg is not of the correct type
+# otherwise returns the canonical value of that arg (ie 0/1 for booleans)
+proc ::tcl::OptCheckType {arg type {typeArgs ""}} {
+#    puts "checking '$arg' against '$type' ($typeArgs)"
+
+    # only types "any", "choice", and numbers can have leading "-"
+
+    switch -exact -- $type {
+        int {
+            if {![string is integer -strict $arg]} {
+                error "not an integer"
+            }
+	    return $arg
+        }
+        float {
+            return [expr {double($arg)}]
+        }
+	script -
+        list {
+	    # if llength fail : malformed list
+            if {[llength $arg]==0 && [OptIsFlag $arg]} {
+		error "no values with leading -"
+	    }
+	    return $arg
+        }
+        boolean {
+	    if {![string is boolean -strict $arg]} {
+		error "non canonic boolean"
+            }
+	    # convert true/false because expr/if is broken with "!,...
+	    return [expr {$arg ? 1 : 0}]
+        }
+        choice {
+            if {$arg ni $typeArgs} {
+                error "invalid choice"
+            }
+	    return $arg
+        }
+	any {
+	    return $arg
+	}
+	string -
+	default {
+            if {[OptIsFlag $arg]} {
+                error "no values with leading -"
+            }
+	    return $arg
+        }
+    }
+    return neverReached
+}
+
+    # internal utilities
+
+    # returns the number of flags matching the given arg
+    # sets the (local) prg counter to the list of matches
+    proc OptHits {descName arg} {
+        upvar $descName desc
+        set hits 0
+        set hitems {}
+	set i 1
+
+	set larg [string tolower $arg]
+	set len  [string length $larg]
+	set last [expr {$len-1}]
+
+        foreach item [lrange $desc 1 end] {
+            set flag [OptName $item]
+	    # lets try to match case insensitively
+	    # (string length ought to be cheap)
+	    set lflag [string tolower $flag]
+	    if {$len == [string length $lflag]} {
+		if {[string equal $larg $lflag]} {
+		    # Exact match case
+		    OptSetPrgCounter desc $i
+		    return 1
+		}
+	    } elseif {[string equal $larg [string range $lflag 0 $last]]} {
+		lappend hitems $i
+		incr hits
+            }
+	    incr i
+        }
+	if {$hits} {
+	    OptSetPrgCounter desc $hitems
+	}
+        return $hits
+    }
+
+    # Extract fields from the list structure:
+
+    proc OptName {item} {
+        lindex $item 1
+    }
+    proc OptHasBeenSet {item} {
+	Lget $item {2 0}
+    }
+    proc OptValue {item} {
+	Lget $item {2 1}
+    }
+
+    proc OptIsFlag {name} {
+        string match "-*" $name
+    }
+    proc OptIsOpt {name} {
+        string match {\?*} $name
+    }
+    proc OptVarName {item} {
+        set name [OptName $item]
+        if {[OptIsFlag $name]} {
+            return [string range $name 1 end]
+        } elseif {[OptIsOpt $name]} {
+	    return [string trim $name "?"]
+	} else {
+            return $name
+        }
+    }
+    proc OptType {item} {
+        lindex $item 3
+    }
+    proc OptTypeArgs {item} {
+        lindex $item 4
+    }
+    proc OptHelp {item} {
+        lindex $item 5
+    }
+    proc OptNeedValue {item} {
+        expr {![string equal [OptType $item] boolflag]}
+    }
+    proc OptDefaultValue {item} {
+        set val [OptTypeArgs $item]
+        switch -exact -- [OptType $item] {
+            choice {return [lindex $val 0]}
+	    boolean -
+	    boolflag {
+		# convert back false/true to 0/1 because expr !$bool
+		# is broken..
+		if {$val} {
+		    return 1
+		} else {
+		    return 0
+		}
+	    }
+        }
+        return $val
+    }
+
+    # Description format error helper
+    proc OptOptUsage {item {what ""}} {
+        return -code error "invalid description format$what: $item\n\
+                should be a list of {varname|-flagname ?-type? ?defaultvalue?\
+                ?helpstring?}"
+    }
+
+
+    # Generate a canonical form single instruction
+    proc OptNewInst {state varname type typeArgs help} {
+	list $state $varname [list 0 {}] $type $typeArgs $help
+	#                          ^  ^
+	#                          |  |
+	#               hasBeenSet=+  +=currentValue
+    }
+
+    # Translate one item to canonical form
+    proc OptNormalizeOne {item} {
+        set lg [Lassign $item varname arg1 arg2 arg3]
+#       puts "called optnormalizeone '$item' v=($varname), lg=$lg"
+        set isflag [OptIsFlag $varname]
+	set isopt  [OptIsOpt  $varname]
+        if {$isflag} {
+            set state "flags"
+        } elseif {$isopt} {
+	    set state "optValue"
+	} elseif {![string equal $varname "args"]} {
+	    set state "value"
+	} else {
+	    set state "args"
+	}
+
+	# apply 'smart' 'fuzzy' logic to try to make
+	# description writer's life easy, and our's difficult :
+	# let's guess the missing arguments :-)
+
+        switch $lg {
+            1 {
+                if {$isflag} {
+                    return [OptNewInst $state $varname boolflag false ""]
+                } else {
+                    return [OptNewInst $state $varname any "" ""]
+                }
+            }
+            2 {
+                # varname default
+                # varname help
+                set type [OptGuessType $arg1]
+                if {[string equal $type "string"]} {
+                    if {$isflag} {
+			set type boolflag
+			set def false
+		    } else {
+			set type any
+			set def ""
+		    }
+		    set help $arg1
+                } else {
+                    set help ""
+                    set def $arg1
+                }
+                return [OptNewInst $state $varname $type $def $help]
+            }
+            3 {
+                # varname type value
+                # varname value comment
+
+                if {[regexp {^-(.+)$} $arg1 x type]} {
+		    # flags/optValue as they are optional, need a "value",
+		    # on the contrary, for a variable (non optional),
+		    # default value is pointless, 'cept for choices :
+		    if {$isflag || $isopt || ($type == "choice")} {
+			return [OptNewInst $state $varname $type $arg2 ""]
+		    } else {
+			return [OptNewInst $state $varname $type "" $arg2]
+		    }
+                } else {
+                    return [OptNewInst $state $varname\
+			    [OptGuessType $arg1] $arg1 $arg2]
+                }
+            }
+            4 {
+                if {[regexp {^-(.+)$} $arg1 x type]} {
+		    return [OptNewInst $state $varname $type $arg2 $arg3]
+                } else {
+                    return -code error [OptOptUsage $item]
+                }
+            }
+            default {
+                return -code error [OptOptUsage $item]
+            }
+        }
+    }
+
+    # Auto magic lazy type determination
+    proc OptGuessType {arg} {
+ 	 if { $arg == "true" || $arg == "false" } {
+            return boolean
+        }
+        if {[string is integer -strict $arg]} {
+            return int
+        }
+        if {[string is double -strict $arg]} {
+            return float
+        }
+        return string
+    }
+
+    # Error messages front ends
+
+    proc OptAmbigous {desc arg} {
+        OptError "ambigous option \"$arg\", choose from:" [OptSelection $desc]
+    }
+    proc OptFlagUsage {desc arg} {
+        OptError "bad flag \"$arg\", must be one of" $desc
+    }
+    proc OptTooManyArgs {desc arguments} {
+        OptError "too many arguments (unexpected argument(s): $arguments),\
+		usage:"\
+		$desc 1
+    }
+    proc OptParamType {item} {
+	if {[OptIsFlag $item]} {
+	    return "flag"
+	} else {
+	    return "parameter"
+	}
+    }
+    proc OptBadValue {item arg {err {}}} {
+#       puts "bad val err = \"$err\""
+        OptError "bad value \"$arg\" for [OptParamType $item]"\
+		[list $item]
+    }
+    proc OptMissingValue {descriptions} {
+#        set item [OptCurDescFinal $descriptions]
+        set item [OptCurDesc $descriptions]
+        OptError "no value given for [OptParamType $item] \"[OptName $item]\"\
+		(use -help for full usage) :"\
+		[list $item]
+    }
+
+proc ::tcl::OptKeyError {prefix descKey {header 0}} {
+    OptError $prefix [OptKeyGetDesc $descKey] $header
+}
+
+    # determine string length for nice tabulated output
+    proc OptLengths {desc nlName tlName dlName} {
+	upvar $nlName nl
+	upvar $tlName tl
+	upvar $dlName dl
+	foreach item $desc {
+	    if {[OptIsCounter $item]} continue
+	    if {[OptIsPrg $item]} {
+		OptLengths $item nl tl dl
+	    } else {
+		SetMax nl [string length [OptName $item]]
+		SetMax tl [string length [OptType $item]]
+		set dv [OptTypeArgs $item]
+		if {[OptState $item] != "header"} {
+		    set dv "($dv)"
+		}
+		set l [string length $dv]
+		# limit the space allocated to potentially big "choices"
+		if {([OptType $item] != "choice") || ($l<=12)} {
+		    SetMax dl $l
+		} else {
+		    if {![info exists dl]} {
+			set dl 0
+		    }
+		}
+	    }
+	}
+    }
+    # output the tree
+    proc OptTree {desc nl tl dl} {
+	set res ""
+	foreach item $desc {
+	    if {[OptIsCounter $item]} continue
+	    if {[OptIsPrg $item]} {
+		append res [OptTree $item $nl $tl $dl]
+	    } else {
+		set dv [OptTypeArgs $item]
+		if {[OptState $item] != "header"} {
+		    set dv "($dv)"
+		}
+		append res [string trimright [format "\n    %-*s %-*s %-*s %s" \
+			$nl [OptName $item] $tl [OptType $item] \
+			$dl $dv [OptHelp $item]]]
+	    }
+	}
+	return $res
+    }
+
+# Give nice usage string
+proc ::tcl::OptError {prefix desc {header 0}} {
+    # determine length
+    if {$header} {
+	# add faked instruction
+	set h [list [OptNewInst header Var/FlagName Type Value Help]]
+	lappend h   [OptNewInst header ------------ ---- ----- ----]
+	lappend h   [OptNewInst header {(-help} "" "" {gives this help)}]
+	set desc [concat $h $desc]
+    }
+    OptLengths $desc nl tl dl
+    # actually output
+    return "$prefix[OptTree $desc $nl $tl $dl]"
+}
+
+
+################     General Utility functions   #######################
+
+#
+# List utility functions
+# Naming convention:
+#     "Lvarxxx" take the list VARiable name as argument
+#     "Lxxxx"   take the list value as argument
+#               (which is not costly with Tcl8 objects system
+#                as it's still a reference and not a copy of the values)
+#
+
+# Is that list empty ?
+proc ::tcl::Lempty {list} {
+    expr {[llength $list]==0}
+}
+
+# Gets the value of one leaf of a lists tree
+proc ::tcl::Lget {list indexLst} {
+    if {[llength $indexLst] <= 1} {
+        return [lindex $list $indexLst]
+    }
+    Lget [lindex $list [lindex $indexLst 0]] [lrange $indexLst 1 end]
+}
+# Sets the value of one leaf of a lists tree
+# (we use the version that does not create the elements because
+#  it would be even slower... needs to be written in C !)
+# (nb: there is a non trivial recursive problem with indexes 0,
+#  which appear because there is no difference between a list
+#  of 1 element and 1 element alone : [list "a"] == "a" while
+#  it should be {a} and [listp a] should be 0 while [listp {a b}] would be 1
+#  and [listp "a b"] maybe 0. listp does not exist either...)
+proc ::tcl::Lvarset {listName indexLst newValue} {
+    upvar $listName list
+    if {[llength $indexLst] <= 1} {
+        Lvarset1nc list $indexLst $newValue
+    } else {
+        set idx [lindex $indexLst 0]
+        set targetList [lindex $list $idx]
+        # reduce refcount on targetList (not really usefull now,
+	# could be with optimizing compiler)
+#        Lvarset1 list $idx {}
+        # recursively replace in targetList
+        Lvarset targetList [lrange $indexLst 1 end] $newValue
+        # put updated sub list back in the tree
+        Lvarset1nc list $idx $targetList
+    }
+}
+# Set one cell to a value, eventually create all the needed elements
+# (on level-1 of lists)
+variable emptyList {}
+proc ::tcl::Lvarset1 {listName index newValue} {
+    upvar $listName list
+    if {$index < 0} {return -code error "invalid negative index"}
+    set lg [llength $list]
+    if {$index >= $lg} {
+        variable emptyList
+        for {set i $lg} {$i<$index} {incr i} {
+            lappend list $emptyList
+        }
+        lappend list $newValue
+    } else {
+        set list [lreplace $list $index $index $newValue]
+    }
+}
+# same as Lvarset1 but no bound checking / creation
+proc ::tcl::Lvarset1nc {listName index newValue} {
+    upvar $listName list
+    set list [lreplace $list $index $index $newValue]
+}
+# Increments the value of one leaf of a lists tree
+# (which must exists)
+proc ::tcl::Lvarincr {listName indexLst {howMuch 1}} {
+    upvar $listName list
+    if {[llength $indexLst] <= 1} {
+        Lvarincr1 list $indexLst $howMuch
+    } else {
+        set idx [lindex $indexLst 0]
+        set targetList [lindex $list $idx]
+        # reduce refcount on targetList
+        Lvarset1nc list $idx {}
+        # recursively replace in targetList
+        Lvarincr targetList [lrange $indexLst 1 end] $howMuch
+        # put updated sub list back in the tree
+        Lvarset1nc list $idx $targetList
+    }
+}
+# Increments the value of one cell of a list
+proc ::tcl::Lvarincr1 {listName index {howMuch 1}} {
+    upvar $listName list
+    set newValue [expr {[lindex $list $index]+$howMuch}]
+    set list [lreplace $list $index $index $newValue]
+    return $newValue
+}
+# Removes the first element of a list
+# and returns the new list value
+proc ::tcl::Lvarpop1 {listName} {
+    upvar $listName list
+    set list [lrange $list 1 end]
+}
+# Same but returns the removed element
+# (Like the tclX version)
+proc ::tcl::Lvarpop {listName} {
+    upvar $listName list
+    set el [lindex $list 0]
+    set list [lrange $list 1 end]
+    return $el
+}
+# Assign list elements to variables and return the length of the list
+proc ::tcl::Lassign {list args} {
+    # faster than direct blown foreach (which does not byte compile)
+    set i 0
+    set lg [llength $list]
+    foreach vname $args {
+        if {$i>=$lg} break
+        uplevel 1 [list ::set $vname [lindex $list $i]]
+        incr i
+    }
+    return $lg
+}
+
+# Misc utilities
+
+# Set the varname to value if value is greater than varname's current value
+# or if varname is undefined
+proc ::tcl::SetMax {varname value} {
+    upvar 1 $varname var
+    if {![info exists var] || $value > $var} {
+        set var $value
+    }
+}
+
+# Set the varname to value if value is smaller than varname's current value
+# or if varname is undefined
+proc ::tcl::SetMin {varname value} {
+    upvar 1 $varname var
+    if {![info exists var] || $value < $var} {
+        set var $value
+    }
+}
+
+
+    # everything loaded fine, lets create the test proc:
+ #    OptCreateTestProc
+    # Don't need the create temp proc anymore:
+ #    rename OptCreateTestProc {}
+}

miniconda3/envs/active_proaction/lib/tcl8.6/opt0.4/pkgIndex.tcl

@@ -0,0 +1,12 @@
+# Tcl package index file, version 1.1
+# This file is generated by the "pkg_mkIndex -direct" command
+# and sourced either when an application starts up or
+# by a "package unknown" script.  It invokes the
+# "package ifneeded" command to set up package-related
+# information so that packages will be loaded automatically
+# in response to "package require" commands.  When this
+# script is sourced, the variable $dir must contain the
+# full path name of this file's directory.
+
+if {![package vsatisfies [package provide Tcl] 8.5-]} {return}
+package ifneeded opt 0.4.9 [list source -encoding utf-8 [file join $dir optparse.tcl]]

miniconda3/envs/active_proaction/lib/tdbc1.1.9/pkgIndex.tcl

@@ -0,0 +1,26 @@
+# -*- tcl -*-
+# Tcl package index file, version 1.1
+#
+# Make sure that TDBC is running in a compatible version of Tcl, and
+# that TclOO is available.
+
+if {![package vsatisfies [package provide Tcl] 8.6-]} {
+    return
+}
+apply {{dir} {
+    set libraryfile [file join $dir tdbc.tcl]
+    if {![file exists $libraryfile] && [info exists ::env(TDBC_LIBRARY)]} {
+	set libraryfile [file join $::env(TDBC_LIBRARY) tdbc.tcl]
+    }
+    if {[package vsatisfies [package provide Tcl] 9.0-]} {
+	package ifneeded tdbc 1.1.9 \
+		"package require TclOO;\
+		[list load [file join $dir libtcl9tdbc1.1.9.so] [string totitle tdbc]]\;\
+		[list source -encoding utf-8 $libraryfile]"
+    } else {
+	package ifneeded tdbc 1.1.9 \
+		"package require TclOO;\
+		[list load [file join $dir libtdbc1.1.9.so] [string totitle tdbc]]\;\
+		[list source -encoding utf-8 $libraryfile]"
+    }
+}} $dir

miniconda3/envs/active_proaction/lib/tdbc1.1.9/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.
+
+}

miniconda3/envs/active_proaction/lib/tdbc1.1.9/tdbcConfig.sh

@@ -0,0 +1,81 @@
+# tdbcConfig.sh --
+#
+# This shell script (for sh) is generated automatically by TDBC's configure
+# script. It will create shell variables for most of the configuration options
+# discovered by the configure script. This script is intended to be included
+# by the configure scripts for TDBC extensions so that they don't have to
+# figure this all out for themselves.
+#
+# The information in this file is specific to a single platform.
+#
+# RCS: @(#) $Id$
+
+# TDBC's version number
+tdbc_VERSION=1.1.9
+TDBC_VERSION=1.1.9
+
+# Name of the TDBC library - may be either a static or shared library
+tdbc_LIB_FILE=libtdbc1.1.9.so
+TDBC_LIB_FILE=libtdbc1.1.9.so
+
+# String to pass to the linker to pick up the TDBC library from its build dir
+tdbc_BUILD_LIB_SPEC="-L/croot/tk_1755243777296/work/tcl8.6.15/unix/pkgs/tdbc1.1.9 -ltdbc1.1.9"
+TDBC_BUILD_LIB_SPEC="-L/croot/tk_1755243777296/work/tcl8.6.15/unix/pkgs/tdbc1.1.9 -ltdbc1.1.9"
+
+# String to pass to the linker to pick up the TDBC library from its installed
+# dir.
+tdbc_LIB_SPEC="-L/mnt/bn/bohanzhainas1/jiashuo/miniconda3/envs/active_proaction/lib/tdbc1.1.9 -ltdbc1.1.9"
+TDBC_LIB_SPEC="-L/mnt/bn/bohanzhainas1/jiashuo/miniconda3/envs/active_proaction/lib/tdbc1.1.9 -ltdbc1.1.9"
+
+# Name of the TBDC stub library
+tdbc_STUB_LIB_FILE="libtdbcstub1.1.9.a"
+TDBC_STUB_LIB_FILE="libtdbcstub1.1.9.a"
+
+# String to pass to the linker to pick up the TDBC stub library from its
+# build directory
+tdbc_BUILD_STUB_LIB_SPEC="-L/croot/tk_1755243777296/work/tcl8.6.15/unix/pkgs/tdbc1.1.9 -ltdbcstub1.1.9"
+TDBC_BUILD_STUB_LIB_SPEC="-L/croot/tk_1755243777296/work/tcl8.6.15/unix/pkgs/tdbc1.1.9 -ltdbcstub1.1.9"
+
+# String to pass to the linker to pick up the TDBC stub library from its
+# installed directory
+tdbc_STUB_LIB_SPEC="-L/mnt/bn/bohanzhainas1/jiashuo/miniconda3/envs/active_proaction/lib/tdbc1.1.9 -ltdbcstub1.1.9"
+TDBC_STUB_LIB_SPEC="-L/mnt/bn/bohanzhainas1/jiashuo/miniconda3/envs/active_proaction/lib/tdbc1.1.9 -ltdbcstub1.1.9"
+
+# Path name of the TDBC stub library in its build directory
+tdbc_BUILD_STUB_LIB_PATH="/croot/tk_1755243777296/work/tcl8.6.15/unix/pkgs/tdbc1.1.9/libtdbcstub1.1.9.a"
+TDBC_BUILD_STUB_LIB_PATH="/croot/tk_1755243777296/work/tcl8.6.15/unix/pkgs/tdbc1.1.9/libtdbcstub1.1.9.a"
+
+# Path name of the TDBC stub library in its installed directory
+tdbc_STUB_LIB_PATH="/mnt/bn/bohanzhainas1/jiashuo/miniconda3/envs/active_proaction/lib/tdbc1.1.9/libtdbcstub1.1.9.a"
+TDBC_STUB_LIB_PATH="/mnt/bn/bohanzhainas1/jiashuo/miniconda3/envs/active_proaction/lib/tdbc1.1.9/libtdbcstub1.1.9.a"
+
+# Location of the top-level source directories from which TDBC was built.
+# This is the directory that contains doc/, generic/ and so on.  If TDBC
+# was compiled in a directory other than the source directory, this still
+# points to the location of the sources, not the location where TDBC was
+# compiled.
+tdbc_SRC_DIR="/croot/tk_1755243777296/work/tcl8.6.15/pkgs/tdbc1.1.9"
+TDBC_SRC_DIR="/croot/tk_1755243777296/work/tcl8.6.15/pkgs/tdbc1.1.9"
+
+# String to pass to the compiler so that an extension can find installed TDBC
+# headers
+tdbc_INCLUDE_SPEC="-I/mnt/bn/bohanzhainas1/jiashuo/miniconda3/envs/active_proaction/include"
+TDBC_INCLUDE_SPEC="-I/mnt/bn/bohanzhainas1/jiashuo/miniconda3/envs/active_proaction/include"
+
+# String to pass to the compiler so that an extension can find TDBC headers
+# in the source directory
+tdbc_BUILD_INCLUDE_SPEC="-I/croot/tk_1755243777296/work/tcl8.6.15/pkgs/tdbc1.1.9/generic"
+TDBC_BUILD_INCLUDE_SPEC="-I/croot/tk_1755243777296/work/tcl8.6.15/pkgs/tdbc1.1.9/generic"
+
+# Path name where .tcl files in the tdbc package appear at run time.
+tdbc_LIBRARY_PATH="/mnt/bn/bohanzhainas1/jiashuo/miniconda3/envs/active_proaction/lib/tdbc1.1.9"
+TDBC_LIBRARY_PATH="/mnt/bn/bohanzhainas1/jiashuo/miniconda3/envs/active_proaction/lib/tdbc1.1.9"
+
+# Path name where .tcl files in the tdbc package appear at build time.
+tdbc_BUILD_LIBRARY_PATH="/croot/tk_1755243777296/work/tcl8.6.15/pkgs/tdbc1.1.9/library"
+TDBC_BUILD_LIBRARY_PATH="/croot/tk_1755243777296/work/tcl8.6.15/pkgs/tdbc1.1.9/library"
+
+# Additional flags that must be passed to the C compiler to use tdbc
+tdbc_CFLAGS=
+TDBC_CFLAGS=
+

miniconda3/envs/active_proaction/lib/tdbcmysql1.1.9/pkgIndex.tcl

@@ -0,0 +1,14 @@
+# Index file to load the TDBC MySQL package.
+
+if {![package vsatisfies [package provide Tcl] 8.6-]} {
+    return
+}
+if {[package vsatisfies [package provide Tcl] 9.0-]} {
+    package ifneeded tdbc::mysql 1.1.9 \
+	    "[list source -encoding utf-8 [file join $dir tdbcmysql.tcl]]\;\
+	    [list load [file join $dir libtcl9tdbcmysql1.1.9.so] [string totitle tdbcmysql]]"
+} else {
+    package ifneeded tdbc::mysql 1.1.9 \
+	    "[list source -encoding utf-8 [file join $dir tdbcmysql.tcl]]\;\
+	    [list load [file join $dir libtdbcmysql1.1.9.so] [string totitle tdbcmysql]]"
+}

miniconda3/envs/active_proaction/lib/tdbcmysql1.1.9/tdbcmysql.tcl

@@ -0,0 +1,193 @@
+# tdbcmysql.tcl --
+#
+#	Class definitions and Tcl-level methods for the tdbc::mysql 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: tdbcmysql.tcl,v 1.47 2008/02/27 02:08:27 kennykb Exp $
+#
+#------------------------------------------------------------------------------
+
+package require tdbc
+
+::namespace eval ::tdbc::mysql {
+
+    namespace export connection datasources drivers
+
+}
+
+#------------------------------------------------------------------------------
+#
+# tdbc::mysql::connection --
+#
+#	Class representing a connection to a database through MYSQL.
+#
+#-------------------------------------------------------------------------------
+
+::oo::class create ::tdbc::mysql::connection {
+
+    superclass ::tdbc::connection
+
+    # The constructor is written in C. It takes alternating keywords
+    # and values pairs as its argumenta.  (See the manual page for the
+    # available options.)
+
+    variable foreignKeysStatement
+
+    # The 'statementCreate' method delegates to the constructor of the
+    # statement class
+
+    forward statementCreate ::tdbc::mysql::statement create
+
+    # The 'columns' method returns a dictionary describing the tables
+    # in the database
+
+    method columns {table {pattern %}} {
+
+	# To return correct lengths of CHARACTER and BINARY columns,
+	# we need to know the maximum lengths of characters in each
+	# collation. We cache this information only once, on the first
+	# call to 'columns'.
+
+	if {[my NeedCollationInfo]} {
+	    my SetCollationInfo {*}[my allrows -as lists {
+		SELECT coll.id, cs.maxlen
+		FROM INFORMATION_SCHEMA.COLLATIONS coll,
+		     INFORMATION_SCHEMA.CHARACTER_SETS cs
+		WHERE cs.CHARACTER_SET_NAME = coll.CHARACTER_SET_NAME
+		ORDER BY coll.id DESC
+	    }]
+	}
+
+	return [my Columns $table $pattern]
+    }
+
+    # 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=$rest\\}
+	}
+    }
+
+    # The 'init', 'begintransaction', 'commit, 'rollback', 'tables'
+    # 'NeedCollationInfo', 'SetCollationInfo', and 'Columns' methods
+    # are implemented in C.
+
+    # 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.)  It is slightly nonstandard because
+    # MYSQL doesn't name the PRIMARY constraints uniquely.
+
+    method BuildForeignKeysStatement {} {
+
+	foreach {exists1 clause1} {
+	    0 {}
+	    1 { AND fkc.REFERENCED_TABLE_NAME = :primary}
+	} {
+	    foreach {exists2 clause2} {
+		0 {}
+		1 { AND fkc.TABLE_NAME = :foreign}
+	    } {
+		set stmt [my prepare "
+	     SELECT rc.CONSTRAINT_SCHEMA AS \"foreignConstraintSchema\",
+		    rc.CONSTRAINT_NAME AS \"foreignConstraintName\",
+		    rc.UPDATE_RULE AS \"updateAction\",
+		    rc.DELETE_RULE AS \"deleteAction\",
+		    fkc.REFERENCED_TABLE_SCHEMA AS \"primarySchema\",
+		    fkc.REFERENCED_TABLE_NAME AS \"primaryTable\",
+		    fkc.REFERENCED_COLUMN_NAME AS \"primaryColumn\",
+		    fkc.TABLE_SCHEMA AS \"foreignSchema\",
+		    fkc.TABLE_NAME AS \"foreignTable\",
+		    fkc.COLUMN_NAME AS \"foreignColumn\",
+		    fkc.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
+	     WHERE 1=1
+		 $clause1
+		 $clause2
+"]
+		dict set foreignKeysStatement $exists1 $exists2 $stmt
+	    }
+	}
+    }
+}
+
+#------------------------------------------------------------------------------
+#
+# tdbc::mysql::statement --
+#
+#	The class 'tdbc::mysql::statement' models one statement against a
+#       database accessed through an MYSQL connection
+#
+#------------------------------------------------------------------------------
+
+::oo::class create ::tdbc::mysql::statement {
+
+    superclass ::tdbc::statement
+
+    # The 'resultSetCreate' method forwards to the constructor of the
+    # result set.
+
+    forward resultSetCreate ::tdbc::mysql::resultset create
+
+    # Methods implemented in C:
+    #
+    # constructor connection SQLCode
+    #	The constructor 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.
+    # params
+    #   Returns descriptions of the parameters of a statement.
+    # paramtype paramname ?direction? type ?precision ?scale??
+    #   Declares the type of a parameter in the statement
+
+}
+
+#------------------------------------------------------------------------------
+#
+# tdbc::mysql::resultset --
+#
+#	The class 'tdbc::mysql::resultset' models the result set that is
+#	produced by executing a statement against an MYSQL database.
+#
+#------------------------------------------------------------------------------
+
+::oo::class create ::tdbc::mysql::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, or else
+    #        as a list of cells.
+    # 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.
+
+}

miniconda3/envs/active_proaction/lib/tdbcodbc1.1.9/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.9 \
+	    "[list source -encoding utf-8 [file join $dir tdbcodbc.tcl]]\;\
+	    [list load [file join $dir libtcl9tdbcodbc1.1.9.so] [string totitle tdbcodbc]]"
+} else {
+    package ifneeded tdbc::odbc 1.1.9 \
+	    "[list source -encoding utf-8 [file join $dir tdbcodbc.tcl]]\;\
+	    [list load [file join $dir libtdbcodbc1.1.9.so] [string totitle tdbcodbc]]"
+}

miniconda3/envs/active_proaction/lib/tdbcodbc1.1.9/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.
+
+}

miniconda3/envs/active_proaction/lib/tdbcpostgres1.1.9/pkgIndex.tcl

@@ -0,0 +1,14 @@
+# Index file to load the TDBC Postgres package.
+
+if {![package vsatisfies [package provide Tcl] 8.6-]} {
+    return
+}
+if {[package vsatisfies [package provide Tcl] 9.0-]} {
+    package ifneeded tdbc::postgres 1.1.9 \
+	    "[list source -encoding utf-8 [file join $dir tdbcpostgres.tcl]]\;\
+	    [list load [file join $dir libtcl9tdbcpostgres1.1.9.so] [string totitle tdbcpostgres]]"
+} else {
+    package ifneeded tdbc::postgres 1.1.9 \
+	    "[list source -encoding utf-8 [file join $dir tdbcpostgres.tcl]]\;\
+	    [list load [file join $dir libtdbcpostgres1.1.9.so] [string totitle tdbcpostgres]]"
+}

miniconda3/envs/active_proaction/lib/tdbcpostgres1.1.9/tdbcpostgres.tcl

@@ -0,0 +1,135 @@
+# tdbcpostgres.tcl --
+#
+#	Class definitions and Tcl-level methods for the tdbc::postgres bridge.
+#
+# Copyright (c) 2009 by Slawomir Cygan
+#
+# See the file "license.terms" for information on usage and redistribution
+# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+#
+#------------------------------------------------------------------------------
+
+package require tdbc
+
+::namespace eval ::tdbc::mypostgres {
+
+    namespace export connection datasources drivers
+
+}
+
+#------------------------------------------------------------------------------
+#
+# tdbc::postgres::connection --
+#
+#	Class representing a connection to a Postgres database.
+#
+#-------------------------------------------------------------------------------
+
+::oo::class create ::tdbc::postgres::connection {
+
+    superclass ::tdbc::connection
+
+    # The constructor is written in C. It takes alternating keywords
+    # and values pairs as its arguments.  (See the manual page for the
+    # available options.)
+
+    # The 'statementCreate' method delegates to the constructor of the
+    # statement class
+
+    forward statementCreate ::tdbc::postgres::statement create
+
+
+    # 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 \\{$rest\\}
+	} else {
+	    my prepare \\{:$varName=$rest\\}
+	}
+    }
+
+    # The 'init', 'begintransaction', 'commit, 'rollback', 'tables'
+    #  and 'columns' methods are implemented in C.
+
+}
+
+#------------------------------------------------------------------------------
+#
+# tdbc::postgres::statement --
+#
+#	The class 'tdbc::postgres::statement' models one statement against a
+#       database accessed through a Postgres connection
+#
+#------------------------------------------------------------------------------
+
+::oo::class create ::tdbc::postgres::statement {
+
+    superclass ::tdbc::statement
+
+    # The 'resultSetCreate' method forwards to the constructor of the
+    # result set.
+
+    forward resultSetCreate ::tdbc::postgres::resultset create
+
+    # Methods implemented in C:
+    #
+    # constructor connection SQLCode
+    #	The constructor 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.
+    # params
+    #   Returns descriptions of the parameters of a statement.
+    # paramtype paramname ?direction? type ?precision ?scale??
+    #   Declares the type of a parameter in the statement
+
+}
+
+#------------------------------------------------------------------------------
+#
+# tdbc::postgres::resultset --
+#
+#	The class 'tdbc::postgres::resultset' models the result set that is
+#	produced by executing a statement against a Postgres database.
+#
+#------------------------------------------------------------------------------
+
+::oo::class create ::tdbc::postgres::resultset {
+
+    superclass ::tdbc::resultset
+
+    # The 'nextresults' method is stubbed out; tdbcpostgres does not
+    # allow a single call to return multiple results.
+
+    method nextresults {} {
+	while {[my nextdict rubbish]} {}
+	return 0
+    }
+
+    # 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, or else
+    #        as a list of cells.
+    # 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.
+
+}

miniconda3/envs/active_proaction/lib/thread2.8.10/pkgIndex.tcl

@@ -0,0 +1,68 @@
+# -*- tcl -*-
+# Tcl package index file, version 1.1
+#
+
+if {![package vsatisfies [package provide Tcl] 8.4]} {
+    # Pre-8.4 Tcl interps we dont support at all.  Bye!
+    # 9.0+ Tcl interps are only supported on 32-bit platforms.
+    if {![package vsatisfies [package provide Tcl] 9.0]
+	    || ($::tcl_platform(pointerSize) != 4)} {
+	return
+    }
+}
+
+# All Tcl 8.4+ interps can [load] Thread 2.8.10
+#
+# For interps that are not thread-enabled, we still call [package ifneeded].
+# This is contrary to the usual convention, but is a good idea because we
+# cannot imagine any other version of Thread that might succeed in a
+# thread-disabled interp.  There's nothing to gain by yielding to other
+# competing callers of [package ifneeded Thread].  On the other hand,
+# deferring the error has the advantage that a script calling
+# [package require Thread] in a thread-disabled interp gets an error message
+# about a thread-disabled interp, instead of the message
+# "can't find package Thread".
+
+package ifneeded Thread 2.8.10 [list load [file join $dir libthread2.8.10.so] [string totitle thread]]
+
+# package Ttrace uses some support machinery.
+
+# In Tcl 8.4 interps we use some older interfaces
+if {![package vsatisfies [package provide Tcl] 8.5]} {
+    package ifneeded Ttrace 2.8.10 "
+    [list proc thread_source {dir} {
+	if {[info exists ::env(TCL_THREAD_LIBRARY)] &&
+		[file readable $::env(TCL_THREAD_LIBRARY)/ttrace.tcl]} {
+	    source -encoding utf-8 $::env(TCL_THREAD_LIBRARY)/ttrace.tcl
+	} elseif {[file readable [file join $dir .. lib ttrace.tcl]]} {
+	    source -encoding utf-8 [file join $dir .. lib ttrace.tcl]
+	} elseif {[file readable [file join $dir ttrace.tcl]]} {
+	    source -encoding utf-8 [file join $dir ttrace.tcl]
+	}
+	if {[namespace which ::ttrace::update] ne ""} {
+	    ::ttrace::update
+	}
+    }]
+    [list thread_source $dir]
+    [list rename thread_source {}]"
+    return
+}
+
+# In Tcl 8.5+ interps; use [::apply]
+
+package ifneeded Ttrace 2.8.10 [list ::apply {{dir} {
+    if {[info exists ::env(TCL_THREAD_LIBRARY)] &&
+	[file readable $::env(TCL_THREAD_LIBRARY)/ttrace.tcl]} {
+	source -encoding utf-8 $::env(TCL_THREAD_LIBRARY)/ttrace.tcl
+    } elseif {[file readable [file join $dir .. lib ttrace.tcl]]} {
+	source -encoding utf-8 [file join $dir .. lib ttrace.tcl]
+    } elseif {[file readable [file join $dir ttrace.tcl]]} {
+	source -encoding utf-8 [file join $dir ttrace.tcl]
+    }
+    if {[namespace which ::ttrace::update] ne ""} {
+	::ttrace::update
+    }
+}} $dir]
+
+
+

miniconda3/envs/active_proaction/lib/thread2.8.10/ttrace.tcl

@@ -0,0 +1,942 @@
+#
+# ttrace.tcl --
+#
+# Copyright (C) 2003 Zoran Vasiljevic, Archiware GmbH. All Rights Reserved.
+#
+# See the file "license.terms" for information on usage and redistribution of
+# this file, and for a DISCLAIMER OF ALL WARRANTIES.
+# ----------------------------------------------------------------------------
+#
+# User level commands:
+#
+#   ttrace::eval           top-level wrapper (ttrace-savvy eval)
+#   ttrace::enable         activates registered Tcl command traces
+#   ttrace::disable        terminates tracing of Tcl commands
+#   ttrace::isenabled      returns true if ttrace is enabled
+#   ttrace::cleanup        bring the interp to a pristine state
+#   ttrace::update         update interp to the latest trace epoch
+#   ttrace::config         setup some configuration options
+#   ttrace::getscript      returns a script for initializing interps
+#
+# Commands used for/from trace callbacks:
+#
+#   ttrace::atenable       register callback to be done at trace enable
+#   ttrace::atdisable      register callback to be done at trace disable
+#   ttrace::addtrace       register user-defined tracer callback
+#   ttrace::addscript      register user-defined script generator
+#   ttrace::addresolver    register user-defined command resolver
+#   ttrace::addcleanup     register user-defined cleanup procedures
+#   ttrace::addentry       adds one entry into the named trace store
+#   ttrace::getentry       returns the entry value from the named store
+#   ttrace::delentry       removes the entry from the named store
+#   ttrace::getentries     returns all entries from the named store
+#   ttrace::preload        register procedures to be preloaded always
+#
+#
+# Limitations:
+#
+#   o. [namespace forget] is still not implemented
+#   o. [namespace origin cmd] breaks if cmd is not already defined
+#
+#      I left this deliberately. I didn't want to override the [namespace]
+#      command in order to avoid potential slowdown.
+#
+
+namespace eval ttrace {
+
+    # Setup some compatibility wrappers
+    if {[info commands nsv_set] != ""} {
+        variable tvers 0
+        variable mutex ns_mutex
+        variable elock [$mutex create traceepochmutex]
+        # Import the underlying API; faster than recomputing
+        interp alias {} [namespace current]::_array   {} nsv_array
+        interp alias {} [namespace current]::_incr    {} nsv_incr
+        interp alias {} [namespace current]::_lappend {} nsv_lappend
+        interp alias {} [namespace current]::_names   {} nsv_names
+        interp alias {} [namespace current]::_set     {} nsv_set
+        interp alias {} [namespace current]::_unset   {} nsv_unset
+    } elseif {![catch {
+        variable tvers [package require Thread]
+    }]} {
+        variable mutex thread::mutex
+        variable elock [$mutex create]
+        # Import the underlying API; faster than recomputing
+        interp alias {} [namespace current]::_array   {} tsv::array
+        interp alias {} [namespace current]::_incr    {} tsv::incr
+        interp alias {} [namespace current]::_lappend {} tsv::lappend
+        interp alias {} [namespace current]::_names   {} tsv::names
+        interp alias {} [namespace current]::_set     {} tsv::set
+        interp alias {} [namespace current]::_unset   {} tsv::unset
+    } else {
+        error "requires NaviServer/AOLserver or Tcl threading extension"
+    }
+
+    # Keep in sync with the Thread package
+    package provide Ttrace 2.8.10
+
+    # Package variables
+    variable resolvers ""     ; # List of registered resolvers
+    variable tracers   ""     ; # List of registered cmd tracers
+    variable scripts   ""     ; # List of registered script makers
+    variable enables   ""     ; # List of trace-enable callbacks
+    variable disables  ""     ; # List of trace-disable callbacks
+    variable preloads  ""     ; # List of procedure names to preload
+    variable enabled   0      ; # True if trace is enabled
+    variable config           ; # Array with config options
+
+    variable epoch     -1     ; # The initialization epoch
+    variable cleancnt   0     ; # Counter of registered cleaners
+
+    # Package private namespaces
+    namespace eval resolve "" ; # Commands for resolving commands
+    namespace eval trace   "" ; # Commands registered for tracing
+    namespace eval enable  "" ; # Commands invoked at trace enable
+    namespace eval disable "" ; # Commands invoked at trace disable
+    namespace eval script  "" ; # Commands for generating scripts
+
+    # Exported commands
+    namespace export unknown
+
+    # Initialize ttrace shared state
+    if {[_array exists ttrace] == 0} {
+        _set ttrace lastepoch $epoch
+        _set ttrace epochlist ""
+    }
+
+    # Initially, allow creation of epochs
+    set config(-doepochs) 1
+
+    proc eval {cmd args} {
+        enable
+        set code [catch {uplevel 1 [concat $cmd $args]} result]
+        disable
+        if {$code == 0} {
+            if {[llength [info commands ns_ictl]]} {
+                ns_ictl save [getscript]
+            } else {
+                thread::broadcast {
+                    package require Ttrace
+                    ttrace::update
+                }
+            }
+        }
+        return -code $code \
+            -errorinfo $::errorInfo -errorcode $::errorCode $result
+    }
+
+    proc config {args} {
+        variable config
+        if {[llength $args] == 0} {
+            array get config
+        } elseif {[llength $args] == 1} {
+            set opt [lindex $args 0]
+            set config($opt)
+        } else {
+            set opt [lindex $args 0]
+            set val [lindex $args 1]
+            set config($opt) $val
+        }
+    }
+
+    proc enable {} {
+        variable config
+        variable tracers
+        variable enables
+        variable enabled
+        incr enabled 1
+        if {$enabled > 1} {
+            return
+        }
+        if {$config(-doepochs) != 0} {
+            variable epoch [_newepoch]
+        }
+        set nsp [namespace current]
+        foreach enabler $enables {
+            enable::_$enabler
+        }
+        foreach trace $tracers {
+            if {[info commands $trace] != ""} {
+                trace add execution $trace leave ${nsp}::trace::_$trace
+            }
+        }
+    }
+
+    proc disable {} {
+        variable enabled
+        variable tracers
+        variable disables
+        incr enabled -1
+        if {$enabled > 0} {
+            return
+        }
+        set nsp [namespace current]
+        foreach disabler $disables {
+            disable::_$disabler
+        }
+        foreach trace $tracers {
+            if {[info commands $trace] != ""} {
+                trace remove execution $trace leave ${nsp}::trace::_$trace
+            }
+        }
+    }
+
+    proc isenabled {} {
+        variable enabled
+        expr {$enabled > 0}
+    }
+
+    proc update {{from -1}} {
+        if {$from < 0} {
+            variable epoch [_set ttrace lastepoch]
+        } else {
+            if {[lsearch [_set ttrace epochlist] $from] < 0} {
+                error "no such epoch: $from"
+            }
+            variable epoch $from
+        }
+        uplevel 1 [getscript]
+    }
+
+    proc getscript {} {
+        variable preloads
+        variable epoch
+        variable scripts
+        append script [_serializensp] \n
+        append script "::namespace eval [namespace current] {" \n
+        append script "::namespace export unknown" \n
+        append script "_useepoch $epoch" \n
+        append script "}" \n
+        foreach cmd $preloads {
+            append script [_serializeproc $cmd] \n
+        }
+        foreach maker $scripts {
+            append script [script::_$maker]
+        }
+        return $script
+    }
+
+    proc cleanup {args} {
+        foreach cmd [info commands resolve::cleaner_*] {
+            uplevel 1 $cmd $args
+        }
+    }
+
+    proc preload {cmd} {
+        variable preloads
+        if {[lsearch $preloads $cmd] < 0} {
+            lappend preloads $cmd
+        }
+    }
+
+    proc atenable {cmd arglist body} {
+        variable enables
+        if {[lsearch $enables $cmd] < 0} {
+            lappend enables $cmd
+            set cmd [namespace current]::enable::_$cmd
+            proc $cmd $arglist $body
+            return $cmd
+        }
+    }
+
+    proc atdisable {cmd arglist body} {
+        variable disables
+        if {[lsearch $disables $cmd] < 0} {
+            lappend disables $cmd
+            set cmd [namespace current]::disable::_$cmd
+            proc $cmd $arglist $body
+            return $cmd
+        }
+    }
+
+    proc addtrace {cmd arglist body} {
+        variable tracers
+        if {[lsearch $tracers $cmd] < 0} {
+            lappend tracers $cmd
+            set tracer [namespace current]::trace::_$cmd
+            proc $tracer $arglist $body
+            if {[isenabled]} {
+                trace add execution $cmd leave $tracer
+            }
+            return $tracer
+        }
+    }
+
+    proc addscript {cmd body} {
+        variable scripts
+        if {[lsearch $scripts $cmd] < 0} {
+            lappend scripts $cmd
+            set cmd [namespace current]::script::_$cmd
+            proc $cmd args $body
+            return $cmd
+        }
+    }
+
+    proc addresolver {cmd arglist body} {
+        variable resolvers
+        if {[lsearch $resolvers $cmd] < 0} {
+            lappend resolvers $cmd
+            set cmd [namespace current]::resolve::$cmd
+            proc $cmd $arglist $body
+            return $cmd
+        }
+    }
+
+    proc addcleanup {body} {
+        variable cleancnt
+        set cmd [namespace current]::resolve::cleaner_[incr cleancnt]
+        proc $cmd args $body
+        return $cmd
+    }
+
+    proc addentry {cmd var val} {
+        variable epoch
+        _set ${epoch}-$cmd $var $val
+    }
+
+    proc delentry {cmd var} {
+        variable epoch
+        set ei $::errorInfo
+        set ec $::errorCode
+        catch {_unset ${epoch}-$cmd $var}
+        set ::errorInfo $ei
+        set ::errorCode $ec
+    }
+
+    proc getentry {cmd var} {
+        variable epoch
+        set ei $::errorInfo
+        set ec $::errorCode
+        if {[catch {_set ${epoch}-$cmd $var} val]} {
+            set ::errorInfo $ei
+            set ::errorCode $ec
+            set val ""
+        }
+        return $val
+    }
+
+    proc getentries {cmd {pattern *}} {
+        variable epoch
+        _array names ${epoch}-$cmd $pattern
+    }
+
+    proc unknown {args} {
+        set cmd [lindex $args 0]
+        if {[uplevel 1 ttrace::_resolve [list $cmd]]} {
+            set c [catch {uplevel 1 $cmd [lrange $args 1 end]} r]
+        } else {
+            set c [catch {uplevel 1 ::tcl::unknown $args} r]
+        }
+        return -code $c -errorcode $::errorCode -errorinfo $::errorInfo $r
+    }
+
+    proc _resolve {cmd} {
+        variable resolvers
+        foreach resolver $resolvers {
+            if {[uplevel 1 [info comm resolve::$resolver] [list $cmd]]} {
+                return 1
+            }
+        }
+        return 0
+    }
+
+    proc _getthread {} {
+        if {[info commands ns_thread] == ""} {
+            thread::id
+        } else {
+            ns_thread getid
+        }
+    }
+
+    proc _getthreads {} {
+        if {[info commands ns_thread] == ""} {
+            return [thread::names]
+        } else {
+            foreach entry [ns_info threads] {
+                lappend threads [lindex $entry 2]
+            }
+            return $threads
+        }
+    }
+
+    proc _newepoch {} {
+        variable elock
+        variable mutex
+        $mutex lock $elock
+        set old [_set ttrace lastepoch]
+        set new [_incr ttrace lastepoch]
+        _lappend ttrace $new [_getthread]
+        if {$old >= 0} {
+            _copyepoch $old $new
+            _delepochs
+        }
+        _lappend ttrace epochlist $new
+        $mutex unlock $elock
+        return $new
+    }
+
+    proc _copyepoch {old new} {
+        foreach var [_names $old-*] {
+            set cmd [lindex [split $var -] 1]
+            _array reset $new-$cmd [_array get $var]
+        }
+    }
+
+    proc _delepochs {} {
+        set tlist [_getthreads]
+        set elist ""
+        foreach epoch [_set ttrace epochlist] {
+            if {[_dropepoch $epoch $tlist] == 0} {
+                lappend elist $epoch
+            } else {
+                _unset ttrace $epoch
+            }
+        }
+        _set ttrace epochlist $elist
+    }
+
+    proc _dropepoch {epoch threads} {
+        set self [_getthread]
+        foreach tid [_set ttrace $epoch] {
+            if {$tid != $self && [lsearch $threads $tid] >= 0} {
+                lappend alive $tid
+            }
+        }
+        if {[info exists alive]} {
+            _set ttrace $epoch $alive
+            return 0
+        } else {
+            foreach var [_names $epoch-*] {
+                _unset $var
+            }
+            return 1
+        }
+    }
+
+    proc _useepoch {epoch} {
+        if {$epoch >= 0} {
+            set tid [_getthread]
+            if {[lsearch [_set ttrace $epoch] $tid] == -1} {
+                _lappend ttrace $epoch $tid
+            }
+        }
+    }
+
+    proc _serializeproc {cmd} {
+        set dargs [info args $cmd]
+        set pbody [info body $cmd]
+        set pargs ""
+        foreach arg $dargs {
+            if {![info default $cmd $arg def]} {
+                lappend pargs $arg
+            } else {
+                lappend pargs [list $arg $def]
+            }
+        }
+        set nsp [namespace qual $cmd]
+        if {$nsp == ""} {
+            set nsp "::"
+        }
+        append res [list ::namespace eval $nsp] " {" \n
+        append res [list ::proc [namespace tail $cmd] $pargs $pbody] \n
+        append res "}" \n
+    }
+
+    proc _serializensp {{nsp ""} {result _}} {
+        upvar $result res
+        if {$nsp == ""} {
+            set nsp [namespace current]
+        }
+        append res [list ::namespace eval $nsp] " {" \n
+        foreach var [info vars ${nsp}::*] {
+            set vname [namespace tail $var]
+            if {[array exists $var] == 0} {
+                append res [list ::variable $vname [set $var]] \n
+            } else {
+                append res [list ::variable $vname] \n
+                append res [list ::array set $vname [array get $var]] \n
+            }
+        }
+        foreach cmd [info procs ${nsp}::*] {
+            append res [_serializeproc $cmd] \n
+        }
+        append res "}" \n
+        foreach nn [namespace children $nsp] {
+            _serializensp $nn res
+        }
+        return $res
+    }
+}
+
+#
+# The code below is ment to be run once during the application start.  It
+# provides implementation of tracing callbacks for some Tcl commands.  Users
+# can supply their own tracer implementations on-the-fly.
+#
+# The code below will create traces for the following Tcl commands:
+#    "namespace", "variable", "load", "proc" and "rename"
+#
+# Also, the Tcl object extension XOTcl 1.1.0 is handled and all XOTcl related
+# things, like classes and objects are traced (many thanks to Gustaf Neumann
+# from XOTcl for his kind help and support).
+#
+
+eval {
+
+    #
+    # Register the "load" trace. This will create the following key/value pair
+    # in the "load" store:
+    #
+    #  --- key ----              --- value ---
+    #  <path_of_loaded_image>    <name_of_the_init_proc>
+    #
+    # We normally need only the name_of_the_init_proc for being able to load
+    # the package in other interpreters, but we store the path to the image
+    # file as well.
+    #
+
+    ttrace::addtrace load {cmdline code args} {
+        if {$code != 0} {
+            return
+        }
+        set image [lindex $cmdline 1]
+        set initp [lindex $cmdline 2]
+        if {$initp == ""} {
+            foreach pkg [info loaded] {
+                if {[lindex $pkg 0] == $image} {
+                    set initp [lindex $pkg 1]
+                }
+            }
+        }
+        ttrace::addentry load $image $initp
+    }
+
+    ttrace::addscript load {
+        append res "\n"
+        foreach entry [ttrace::getentries load] {
+            set initp [ttrace::getentry load $entry]
+            append res "::load {} $initp" \n
+        }
+        return $res
+    }
+
+    #
+    # Register the "namespace" trace. This will create the following key/value
+    # entry in "namespace" store:
+    #
+    #  --- key ----                   --- value ---
+    #  ::fully::qualified::namespace  1
+    #
+    # It will also fill the "proc" store for procedures and commands imported
+    # in this namespace with following:
+    #
+    #  --- key ----                   --- value ---
+    #  ::fully::qualified::proc       [list <ns>  "" ""]
+    #
+    # The <ns> is the name of the namespace where the command or procedure is
+    # imported from.
+    #
+
+    ttrace::addtrace namespace {cmdline code args} {
+        if {$code != 0} {
+            return
+        }
+        set nop [lindex $cmdline 1]
+        set cns [uplevel 1 namespace current]
+        if {$cns == "::"} {
+            set cns ""
+        }
+        switch -glob $nop {
+            eva* {
+                set nsp [lindex $cmdline 2]
+                if {![string match "::*" $nsp]} {
+                    set nsp ${cns}::$nsp
+                }
+                ttrace::addentry namespace $nsp 1
+            }
+            imp* {
+                # - parse import arguments (skip opt "-force")
+                set opts [lrange $cmdline 2 end]
+                if {[string match "-fo*" [lindex $opts 0]]} {
+                    set opts [lrange $cmdline 3 end]
+                }
+                # - register all imported procs and commands
+                foreach opt $opts {
+                    if {![string match "::*" [::namespace qual $opt]]} {
+                        set opt ${cns}::$opt
+                    }
+                    # - first import procs
+                    foreach entry [ttrace::getentries proc $opt] {
+                        set cmd ${cns}::[::namespace tail $entry]
+                        set nsp [::namespace qual $entry]
+                        set done($cmd) 1
+                        set entry [list 0 $nsp "" ""]
+                        ttrace::addentry proc $cmd $entry
+                    }
+
+                    # - then import commands
+                    foreach entry [info commands $opt] {
+                        set cmd ${cns}::[::namespace tail $entry]
+                        set nsp [::namespace qual $entry]
+                        if {[info exists done($cmd)] == 0} {
+                            set entry [list 0 $nsp "" ""]
+                            ttrace::addentry proc $cmd $entry
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    ttrace::addscript namespace {
+        append res \n
+        foreach entry [ttrace::getentries namespace] {
+            append res "::namespace eval $entry {}" \n
+        }
+        return $res
+    }
+
+    #
+    # Register the "variable" trace. This will create the following key/value
+    # entry in the "variable" store:
+    #
+    #  --- key ----                   --- value ---
+    #  ::fully::qualified::variable   1
+    #
+    # The variable value itself is ignored at the time of
+    # trace/collection. Instead, we take the real value at the time of script
+    # generation.
+    #
+
+    ttrace::addtrace variable {cmdline code args} {
+        if {$code != 0} {
+            return
+        }
+        set opts [lrange $cmdline 1 end]
+        if {[llength $opts]} {
+            set cns [uplevel 1 namespace current]
+            if {$cns == "::"} {
+                set cns ""
+            }
+            foreach {var val} $opts {
+                if {![string match "::*" $var]} {
+                    set var ${cns}::$var
+                }
+                ttrace::addentry variable $var 1
+            }
+        }
+    }
+
+    ttrace::addscript variable {
+        append res \n
+        foreach entry [ttrace::getentries variable] {
+            set cns [namespace qual $entry]
+            set var [namespace tail $entry]
+            append res "::namespace eval $cns {" \n
+            append res "::variable $var"
+            if {[array exists $entry]} {
+                append res "\n::array set $var [list [array get $entry]]" \n
+            } elseif {[info exists $entry]} {
+                append res " [list [set $entry]]" \n
+            } else {
+                append res \n
+            }
+            append res "}" \n
+        }
+        return $res
+    }
+
+
+    #
+    # Register the "rename" trace. It will create the following key/value pair
+    # in "rename" store:
+    #
+    #  --- key ----              --- value ---
+    #  ::fully::qualified::old  ::fully::qualified::new
+    #
+    # The "new" value may be empty, for commands that have been deleted. In
+    # such cases we also remove any traced procedure definitions.
+    #
+
+    ttrace::addtrace rename {cmdline code args} {
+        if {$code != 0} {
+            return
+        }
+        set cns [uplevel 1 namespace current]
+        if {$cns == "::"} {
+            set cns ""
+        }
+        set old [lindex $cmdline 1]
+        if {![string match "::*" $old]} {
+            set old ${cns}::$old
+        }
+        set new [lindex $cmdline 2]
+        if {$new != ""} {
+            if {![string match "::*" $new]} {
+                set new ${cns}::$new
+            }
+            ttrace::addentry rename $old $new
+        } else {
+            ttrace::delentry proc $old
+        }
+    }
+
+    ttrace::addscript rename {
+        append res \n
+        foreach old [ttrace::getentries rename] {
+            set new [ttrace::getentry rename $old]
+            append res "::rename $old {$new}" \n
+        }
+        return $res
+    }
+
+    #
+    # Register the "proc" trace. This will create the following key/value pair
+    # in the "proc" store:
+    #
+    #  --- key ----              --- value ---
+    #  ::fully::qualified::proc  [list <epoch> <ns> <arglist> <body>]
+    #
+    # The <epoch> chages anytime one (re)defines a proc.  The <ns> is the
+    # namespace where the command was imported from. If empty, the <arglist>
+    # and <body> will hold the actual procedure definition. See the
+    # "namespace" tracer implementation also.
+    #
+
+    ttrace::addtrace proc {cmdline code args} {
+        if {$code != 0} {
+            return
+        }
+        set cns [uplevel 1 namespace current]
+        if {$cns == "::"} {
+            set cns ""
+        }
+        set cmd [lindex $cmdline 1]
+        if {![string match "::*" $cmd]} {
+            set cmd ${cns}::$cmd
+        }
+        set dargs [info args $cmd]
+        set pbody [info body $cmd]
+        set pargs ""
+        foreach arg $dargs {
+            if {![info default $cmd $arg def]} {
+                lappend pargs $arg
+            } else {
+                lappend pargs [list $arg $def]
+            }
+        }
+        set pdef [ttrace::getentry proc $cmd]
+        if {$pdef == ""} {
+            set epoch -1 ; # never traced before
+        } else {
+            set epoch [lindex $pdef 0]
+        }
+        ttrace::addentry proc $cmd [list [incr epoch] "" $pargs $pbody]
+    }
+
+    ttrace::addscript proc {
+        return {
+            if {[info command ::tcl::unknown] == ""} {
+                rename ::unknown ::tcl::unknown
+                namespace import -force ::ttrace::unknown
+            }
+            if {[info command ::tcl::info] == ""} {
+                rename ::info ::tcl::info
+            }
+            proc ::info args {
+                set cmd [lindex $args 0]
+                set hit [lsearch -glob {commands procs args default body} $cmd*]
+                if {$hit > 1} {
+                    if {[catch {uplevel 1 ::tcl::info $args}]} {
+                        uplevel 1 ttrace::_resolve [list [lindex $args 1]]
+                    }
+                    return [uplevel 1 ::tcl::info $args]
+                }
+                if {$hit == -1} {
+                    return [uplevel 1 ::tcl::info $args]
+                }
+                set cns [uplevel 1 namespace current]
+                if {$cns == "::"} {
+                    set cns ""
+                }
+                set pat [lindex $args 1]
+                if {![string match "::*" $pat]} {
+                    set pat ${cns}::$pat
+                }
+                set fns [ttrace::getentries proc $pat]
+                if {[string match $cmd* commands]} {
+                    set fns [concat $fns [ttrace::getentries xotcl $pat]]
+                }
+                foreach entry $fns {
+                    if {$cns != [namespace qual $entry]} {
+                        set lazy($entry) 1
+                    } else {
+                        set lazy([namespace tail $entry]) 1
+                    }
+                }
+                foreach entry [uplevel 1 ::tcl::info $args] {
+                    set lazy($entry) 1
+                }
+                array names lazy
+            }
+        }
+    }
+
+    #
+    # Register procedure resolver. This will try to resolve the command in the
+    # current namespace first, and if not found, in global namespace.  It also
+    # handles commands imported from other namespaces.
+    #
+
+    ttrace::addresolver resolveprocs {cmd {export 0}} {
+        set cns [uplevel 1 namespace current]
+        set name [namespace tail $cmd]
+        if {$cns == "::"} {
+            set cns ""
+        }
+        if {![string match "::*" $cmd]} {
+            set ncmd ${cns}::$cmd
+            set gcmd ::$cmd
+        } else {
+            set ncmd $cmd
+            set gcmd $cmd
+        }
+        set pdef [ttrace::getentry proc $ncmd]
+        if {$pdef == ""} {
+            set pdef [ttrace::getentry proc $gcmd]
+            if {$pdef == ""} {
+                return 0
+            }
+            set cmd $gcmd
+        } else {
+            set cmd $ncmd
+        }
+        set epoch [lindex $pdef 0]
+        set pnsp  [lindex $pdef 1]
+        if {$pnsp != ""} {
+            set nsp [namespace qual $cmd]
+            if {$nsp == ""} {
+                set nsp ::
+            }
+            set cmd ${pnsp}::$name
+            if {[resolveprocs $cmd 1] == 0 && [info commands $cmd] == ""} {
+                return 0
+            }
+            namespace eval $nsp "namespace import -force $cmd"
+        } else {
+            uplevel 0 [list ::proc $cmd [lindex $pdef 2] [lindex $pdef 3]]
+            if {$export} {
+                set nsp [namespace qual $cmd]
+                if {$nsp == ""} {
+                    set nsp ::
+                }
+                namespace eval $nsp "namespace export $name"
+            }
+        }
+        variable resolveproc
+        set resolveproc($cmd) $epoch
+        return 1
+    }
+
+    #
+    # For XOTcl, the entire item introspection/tracing is delegated to XOTcl
+    # itself. The xotcl store is filled with this:
+    #
+    #  --- key ----               --- value ---
+    #  ::fully::qualified::item   <body>
+    #
+    # The <body> is the script used to generate the entire item (class,
+    # object). Note that we do not fill in this during code tracing. It is
+    # done during the script generation. In this step, only the placeholder is
+    # set.
+    #
+    # NOTE: we assume all XOTcl commands are imported in global namespace
+    #
+
+    ttrace::atenable XOTclEnabler {args} {
+        if {[info commands ::xotcl::Class] == ""} {
+            return
+        }
+        if {[info commands ::xotcl::_creator] == ""} {
+            ::xotcl::Class create ::xotcl::_creator -instproc create {args} {
+                set result [next]
+                if {![string match ::xotcl::_* $result]} {
+                    ttrace::addentry xotcl $result ""
+                }
+                return $result
+            }
+        }
+        ::xotcl::Class instmixin ::xotcl::_creator
+    }
+
+    ttrace::atdisable XOTclDisabler {args} {
+        if {   [info commands ::xotcl::Class] == ""
+            || [info commands ::xotcl::_creator] == ""} {
+            return
+        }
+        ::xotcl::Class instmixin ""
+        ::xotcl::_creator destroy
+    }
+
+    set resolver [ttrace::addresolver resolveclasses {classname} {
+        set cns [uplevel 1 namespace current]
+        set script [ttrace::getentry xotcl $classname]
+        if {$script == ""} {
+            set name [namespace tail $classname]
+            if {$cns == "::"} {
+                set script [ttrace::getentry xotcl ::$name]
+            } else {
+                set script [ttrace::getentry xotcl ${cns}::$name]
+                if {$script == ""} {
+                    set script [ttrace::getentry xotcl ::$name]
+                }
+            }
+            if {$script == ""} {
+                return 0
+            }
+        }
+        uplevel 1 [list namespace eval $cns $script]
+        return 1
+    }]
+
+    ttrace::addscript xotcl [subst -nocommands {
+        if {![catch {Serializer new} ss]} {
+            foreach entry [ttrace::getentries xotcl] {
+                if {[ttrace::getentry xotcl \$entry] == ""} {
+                    ttrace::addentry xotcl \$entry [\$ss serialize \$entry]
+                }
+            }
+            \$ss destroy
+            return {::xotcl::Class proc __unknown name {$resolver \$name}}
+        }
+    }]
+
+    #
+    # Register callback to be called on cleanup. This will trash lazily loaded
+    # procs which have changed since.
+    #
+
+    ttrace::addcleanup {
+        variable resolveproc
+        foreach cmd [array names resolveproc] {
+            set def [ttrace::getentry proc $cmd]
+            if {$def != ""} {
+                set new [lindex $def 0]
+                set old $resolveproc($cmd)
+                if {[info command $cmd] != "" && $new != $old} {
+                    catch {rename $cmd ""}
+                }
+            }
+        }
+    }
+}
+
+# EOF
+return
+
+# Local Variables:
+# mode: tcl
+# fill-column: 78
+# tab-width: 8
+# indent-tabs-mode: nil
+# End:

miniconda3/envs/active_proaction/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
+}

miniconda3/envs/active_proaction/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:

miniconda3/envs/active_proaction/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
+}

miniconda3/envs/active_proaction/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) ""
+}

miniconda3/envs/active_proaction/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
+}

miniconda3/envs/active_proaction/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 -encoding utf-8 $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

miniconda3/envs/active_proaction/lib/tk8.6/demos/README

@@ -0,0 +1,44 @@
+This directory contains a collection of programs to demonstrate
+the features of the Tk toolkit.  The programs are all scripts for
+"wish", a windowing shell.  If wish has been installed on your path
+then you can invoke any of the programs in this directory just
+by typing its file name to your command shell under Unix.  Otherwise
+invoke wish with the file as its first argument, e.g., "wish hello".
+The rest of this file contains a brief description of each program.
+Files with names ending in ".tcl" are procedure packages used by one
+or more of the demo programs;  they can't be used as programs by
+themselves so they aren't described below.
+
+hello -		Creates a single button;  if you click on it, a message
+		is typed and the application terminates.
+
+widget -	Contains a collection of demonstrations of the widgets
+		currently available in the Tk library.  Most of the .tcl
+		files are scripts for individual demos available through
+		the "widget" program.
+
+ixset -		A simple Tk-based wrapper for the "xset" program, which
+		allows you to interactively query and set various X options
+		such as mouse acceleration and bell volume.  Thanks to
+		Pierre David for contributing this example.
+
+rolodex -	A mock-up of a simple rolodex application.  It has much of
+		the user interface for such an application but no back-end
+		database.  This program was written in response to Tom
+		LaStrange's toolkit benchmark challenge.
+
+tcolor -	A color editor.  Allows you to edit colors in several
+		different ways, and will also perform automatic updates
+		using "send".
+
+rmt -		Allows you to "hook-up" remotely to any Tk application
+		on the display.  Select an application with the menu,
+		then just type commands:  they'll go to that application.
+
+timer -		Displays a seconds timer with start and stop buttons.
+		Control-c and control-q cause it to exit.
+
+browse -	A simple directory browser.  Invoke it with and argument
+		giving the name of the directory you'd like to browse.
+		Double-click on files or subdirectories to browse them.
+		Control-c and control-q cause the program to exit.

miniconda3/envs/active_proaction/lib/tk8.6/demos/anilabel.tcl

@@ -0,0 +1,160 @@
+# anilabel.tcl --
+#
+# This demonstration script creates a toplevel window containing
+# several animated label widgets.
+
+if {![info exists widgetDemo]} {
+    error "This script should be run from the \"widget\" demo."
+}
+
+package require Tk
+
+set w .anilabel
+catch {destroy $w}
+toplevel $w
+wm title $w "Animated Label Demonstration"
+wm iconname $w "anilabel"
+positionWindow $w
+
+label $w.msg -font $font -wraplength 4i -justify left -text "Four animated labels are displayed below; each of the labels on the left is animated by making the text message inside it appear to scroll, and the label on the right is animated by animating the image that it displays."
+pack $w.msg -side top
+
+## See Code / Dismiss buttons
+set btns [addSeeDismiss $w.buttons $w]
+pack $btns -side bottom -fill x
+
+# Ensure that this this is an array
+array set animationCallbacks {}
+
+## This callback is the core of how to do animation in Tcl/Tk; all
+## animations work in basically the same way, with a procedure that
+## uses the [after] command to reschedule itself at some point in the
+## future. Of course, the details of how to update the state will vary
+## according to what is being animated.
+proc RotateLabelText {w interval} {
+    global animationCallbacks
+
+    # Schedule the calling of this procedure again in the future
+    set animationCallbacks($w) [after $interval RotateLabelText $w $interval]
+
+    # We do marquee-like scrolling text by chopping characters off the
+    # front of the text and sticking them on the end.
+    set text [$w cget -text]
+    set newText [string range $text 1 end][string index $text 0]
+    $w configure -text $newText
+}
+
+## A helper procedure to start the animation happening.
+proc animateLabelText {w text interval} {
+    global animationCallbacks
+
+    # Install the text into the widget
+    $w configure -text $text
+
+    # Schedule the start of the animation loop
+    set animationCallbacks($w) [after $interval RotateLabelText $w $interval]
+
+    # Make sure that the animation stops and is cleaned up after itself
+    # when the animated label is destroyed.  Note that at this point we
+    # cannot manipulate the widget itself, as that has already died.
+    bind $w <Destroy> {
+	after cancel $animationCallbacks(%W)
+	unset animationCallbacks(%W)
+    }
+}
+
+## Next, a similar pair of procedures to animate a GIF loaded into a
+## photo image.
+proc SelectNextImageFrame {w interval} {
+    global animationCallbacks
+    set animationCallbacks($w) \
+	    [after $interval SelectNextImageFrame $w $interval]
+    set image [$w cget -image]
+
+    # The easy way to animate a GIF!
+    set idx -1
+    scan [$image cget -format] "GIF -index %d" idx
+    if {[catch {
+	# Note that we get an error if the index is out of range
+	$image configure -format "GIF -index [incr idx]"
+    }]} then {
+	$image configure -format "GIF -index 0"
+    }
+}
+proc animateLabelImage {w imageData interval} {
+    global animationCallbacks
+
+    # Create a multi-frame GIF from base-64-encoded data
+    set image [image create photo -format GIF -data $imageData]
+
+    # Install the image into the widget
+    $w configure -image $image
+
+    # Schedule the start of the animation loop
+    set animationCallbacks($w) \
+	    [after $interval SelectNextImageFrame $w $interval]
+
+    # Make sure that the animation stops and is cleaned up after itself
+    # when the animated label is destroyed.  Note that at this point we
+    # cannot manipulate the widget itself, as that has already died.
+    # Also note that this script is in double-quotes; this is always OK
+    # because image names are chosen automatically to be simple words.
+    bind $w <Destroy> "
+	after cancel \$animationCallbacks(%W)
+	unset animationCallbacks(%W)
+	rename $image {}
+    "
+}
+
+# Make some widgets to contain the animations
+labelframe $w.left -text "Scrolling Texts"
+labelframe $w.right -text "GIF Image"
+pack $w.left $w.right -side left -padx 10 -pady 10 -expand yes
+
+# This method of scrolling text looks far better with a fixed-width font
+label $w.left.l1 -bd 4 -relief ridge -font fixedFont
+label $w.left.l2 -bd 4 -relief groove -font fixedFont
+label $w.left.l3 -bd 4 -relief flat -font fixedFont -width 18
+pack $w.left.l1 $w.left.l2 $w.left.l3 -side top -expand yes -padx 10 -pady 10 -anchor w
+# Don't need to do very much with this label except turn off the border
+label $w.right.l -bd 0
+pack $w.right.l -side top -expand yes -padx 10 -pady 10
+
+# This is a base-64-encoded animated GIF file.
+set tclPoweredData {
+    R0lGODlhKgBAAPQAAP//////zP//AP/MzP/Mmf/MAP+Zmf+ZZv+ZAMz//8zM
+    zMyZmcyZZsxmZsxmAMwzAJnMzJmZzJmZmZlmmZlmZplmM5kzM2aZzGZmzGZm
+    mWZmZmYzZmYzMzNmzDMzZgAzmSH+IE1hZGUgd2l0aCBHSU1QIGJ5IExARGVt
+    YWlsbHkuY29tACH5BAVkAAEALAAAAAAqAEAAAAX+YCCOZEkyTKM2jOm66yPP
+    dF03bx7YcuHIDkGBR7SZeIyhTID4FZ+4Es8nQyCe2EeUNJ0peY2s9mi7PhAM
+    ngEAMGRbUpvzSxskLh1J+Hkg134OdDIDEB+GHxtYMEQMTjMGEYeGFoomezaC
+    DZGSHFmLXTQKkh8eNQVpZ2afmDQGHaOYSoEyhhcklzVmMpuHnaZmDqiGJbg0
+    qFqvh6UNAwB7VA+OwydEjgujkgrPNhbTI8dFvNgEYcHcHx0lB1kX2IYeA2G6
+    NN0YfkXJ2BsAMuAzHB9cZMk3qoEbRzUACsRCUBK5JxsC3iMiKd8GN088SIyT
+    0RAFSROyeEg38caDiB/+JEgqxsODrZJ1BkT0oHKSmI0ceQxo94HDpg0qsuDk
+    UmRAMgu8OgwQ+uIJgUMVeGXA+IQkzEeHGvD8cIGlDXsLiRjQ+EHroQhea7xY
+    8IQBSgYYDi1IS+OFBCgaDMGVS3fGi5BPJpBaENdQ0EomKGD56IHwO39EXiSC
+    Ysgxor5+Xfgq0qByYUpiXmwuoredB2aYH4gWWda0B7SeNENpEJHC1ghi+pS4
+    AJpIAwWvKPBi+8YEht5EriEqpFfMlhEdkBNpx0HUhwypx5T4IB1MBg/Ws2sn
+    wV3MSQOkzI8fUd48Aw3dOZto71x85hHtHijYv18Gf/3GqCdDCXHNoICBobSo
+    IqBqJLyCoH8JPrLgdh88CKCFD0CGmAiGYPgffwceZh6FC2ohIIklnkhehTNY
+    4CIHHGzgwYw01ujBBhvAqKOLLq5AAk9kuSPkkKO40NB+h1gnypJIIvkBf09a
+    N5QIRz5p5ZJXJpmlIVhOGQA2TmIJZZhKKmmll2BqyWSXWUrZpQtpatlmk1c2
+    KaWRHeTZEJF8SqLDn/hhsOeQgBbqAh6DGqronxeARUIIACH5BAUeAAAALAUA
+    LgAFAAUAAAUM4CeKz/OV5YmqaRkCACH5BAUeAAEALAUALgAKAAUAAAUUICCK
+    z/OdJVCaa7p+7aOWcDvTZwgAIfkEBR4AAQAsCwAuAAkABQAABRPgA4zP95zA
+    eZqoWqqpyqLkZ38hACH5BAUKAAEALAcALgANAA4AAAU7ICA+jwiUJEqeKau+
+    r+vGaTmac63v/GP9HM7GQyx+jsgkkoRUHJ3Qx0cK/VQVTKtWwbVKn9suNunc
+    WkMAIfkEBQoAAAAsBwA3AAcABQAABRGgIHzk842j+Yjlt5KuO8JmCAAh+QQF
+    CgAAACwLADcABwAFAAAFEeAnfN9TjqP5oOWziq05lmUIACH5BAUKAAAALA8A
+    NwAHAAUAAAUPoPCJTymS3yiQj4qOcPmEACH5BAUKAAAALBMANwAHAAUAAAUR
+    oCB+z/MJX2o+I2miKimiawgAIfkEBQoAAAAsFwA3AAcABQAABRGgIHzfY47j
+    Q4qk+aHl+pZmCAAh+QQFCgAAACwbADcABwAFAAAFEaAgfs/zCV9qPiNJouo7
+    ll8IACH5BAUKAAAALB8ANwADAAUAAAUIoCB8o0iWZggAOw==
+}
+
+# Finally, set up the text scrolling animation
+animateLabelText $w.left.l1 "* Slow Animation *" 300
+animateLabelText $w.left.l2 "* Fast Animation *" 80
+animateLabelText $w.left.l3 "This is a longer scrolling text in a widget that will not show the whole message at once. " 150
+animateLabelImage $w.right.l $tclPoweredData 100

miniconda3/envs/active_proaction/lib/tk8.6/demos/aniwave.tcl

@@ -0,0 +1,104 @@
+# aniwave.tcl --
+#
+# This demonstration script illustrates how to adjust canvas item
+# coordinates in a way that does something fairly similar to waveform
+# display.
+
+if {![info exists widgetDemo]} {
+    error "This script should be run from the \"widget\" demo."
+}
+
+package require Tk
+
+set w .aniwave
+catch {destroy $w}
+toplevel $w
+wm title $w "Animated Wave Demonstration"
+wm iconname $w "aniwave"
+positionWindow $w
+
+label $w.msg -font $font -wraplength 4i -justify left -text "This demonstration contains a canvas widget with a line item inside it. The animation routines work by adjusting the coordinates list of the line; a trace on a variable is used so updates to the variable result in a change of position of the line."
+pack $w.msg -side top
+
+## See Code / Dismiss buttons
+set btns [addSeeDismiss $w.buttons $w]
+pack $btns -side bottom -fill x
+
+# Create a canvas large enough to hold the wave. In fact, the wave
+# sticks off both sides of the canvas to prevent visual glitches.
+pack [canvas $w.c -width 300 -height 200 -background black] -padx 10 -pady 10 -expand yes
+
+# Ensure that this this is an array
+array set animationCallbacks {}
+
+# Creates a coordinates list of a wave. This code does a very sketchy
+# job and relies on Tk's line smoothing to make things look better.
+set waveCoords {}
+for {set x -10} {$x<=300} {incr x 5} {
+    lappend waveCoords $x 100
+}
+lappend waveCoords $x 0 [incr x 5] 200
+
+# Create a smoothed line and arrange for its coordinates to be the
+# contents of the variable waveCoords.
+$w.c create line $waveCoords -tags wave -width 1 -fill green -smooth 1
+proc waveCoordsTracer {w args} {
+    global waveCoords
+    # Actual visual update will wait until we have finished
+    # processing; Tk does that for us automatically.
+    $w.c coords wave $waveCoords
+}
+trace add variable waveCoords write [list waveCoordsTracer $w]
+
+# Basic motion handler. Given what direction the wave is travelling
+# in, it advances the y coordinates in the coordinate-list one step in
+# that direction.
+proc basicMotion {} {
+    global waveCoords direction
+    set oc $waveCoords
+    for {set i 1} {$i<[llength $oc]} {incr i 2} {
+	if {$direction eq "left"} {
+	    lset waveCoords $i [lindex $oc \
+		    [expr {$i+2>[llength $oc] ? 1 : $i+2}]]
+	} else {
+	    lset waveCoords $i \
+		    [lindex $oc [expr {$i-2<0 ? "end" : $i-2}]]
+	}
+    }
+}
+
+# Oscillation handler. This detects whether to reverse the direction
+# of the wave by checking to see if the peak of the wave has moved off
+# the screen (whose size we know already.)
+proc reverser {} {
+    global waveCoords direction
+    if {[lindex $waveCoords 1] < 10} {
+	set direction "right"
+    } elseif {[lindex $waveCoords end] < 10} {
+	set direction "left"
+    }
+}
+
+# Main animation "loop". This calls the two procedures that handle the
+# movement repeatedly by scheduling asynchronous calls back to itself
+# using the [after] command. This procedure is the fundamental basis
+# for all animated effect handling in Tk.
+proc move {} {
+    basicMotion
+    reverser
+
+    # Theoretically 100 frames-per-second (==10ms between frames)
+    global animationCallbacks
+    set animationCallbacks(simpleWave) [after 10 move]
+}
+
+# Initialise our remaining animation variables
+set direction "left"
+set animateAfterCallback {}
+# Arrange for the animation loop to stop when the canvas is deleted
+bind $w.c <Destroy> {
+    after cancel $animationCallbacks(simpleWave)
+    unset animationCallbacks(simpleWave)
+}
+# Start the animation processing
+move

miniconda3/envs/active_proaction/lib/tk8.6/demos/arrow.tcl

@@ -0,0 +1,241 @@
+# arrow.tcl --
+#
+# This demonstration script creates a canvas widget that displays a
+# large line with an arrowhead whose shape can be edited interactively.
+
+if {![info exists widgetDemo]} {
+    error "This script should be run from the \"widget\" demo."
+}
+
+package require Tk
+
+# arrowSetup --
+# This procedure regenerates all the text and graphics in the canvas
+# window.  It's called when the canvas is initially created, and also
+# whenever any of the parameters of the arrow head are changed
+# interactively.
+#
+# Arguments:
+# c -		Name of the canvas widget.
+
+proc arrowSetup c {
+    upvar #0 demo_arrowInfo v
+
+    # Remember the current box, if there is one.
+
+    set tags [$c gettags current]
+    if {$tags != ""} {
+	set cur [lindex $tags [lsearch -glob $tags box?]]
+    } else {
+	set cur ""
+    }
+
+    # Create the arrow and outline.
+
+    $c delete all
+    eval {$c create line $v(x1) $v(y) $v(x2) $v(y)  -arrow last \
+	    -width [expr {10*$v(width)}] -arrowshape [list \
+	    [expr {10*$v(a)}] [expr {10*$v(b)}] [expr {10*$v(c)}]]} \
+	    $v(bigLineStyle)
+    set xtip [expr {$v(x2)-10*$v(b)}]
+    set deltaY [expr {10*$v(c)+5*$v(width)}]
+    $c create line $v(x2) $v(y) $xtip [expr {$v(y)+$deltaY}] \
+	    [expr {$v(x2)-10*$v(a)}] $v(y) $xtip [expr {$v(y)-$deltaY}] \
+	    $v(x2) $v(y) -width 2 -capstyle round -joinstyle round
+
+    # Create the boxes for reshaping the line and arrowhead.
+
+    eval {$c create rect [expr {$v(x2)-10*$v(a)-5}] [expr {$v(y)-5}] \
+	    [expr {$v(x2)-10*$v(a)+5}] [expr {$v(y)+5}] \
+	    -tags {box1 box}} $v(boxStyle)
+    eval {$c create rect [expr {$xtip-5}] [expr {$v(y)-$deltaY-5}] \
+	    [expr {$xtip+5}] [expr {$v(y)-$deltaY+5}] \
+	    -tags {box2 box}} $v(boxStyle)
+    eval {$c create rect [expr {$v(x1)-5}] [expr {$v(y)-5*$v(width)-5}] \
+	    [expr {$v(x1)+5}] [expr {$v(y)-5*$v(width)+5}] \
+	    -tags {box3 box}} $v(boxStyle)
+    if {$cur != ""} {
+	eval $c itemconfigure $cur $v(activeStyle)
+    }
+
+    # Create three arrows in actual size with the same parameters
+
+    $c create line [expr {$v(x2)+50}] 0 [expr {$v(x2)+50}] 1000 \
+	    -width 2
+    set tmp [expr {$v(x2)+100}]
+    $c create line $tmp [expr {$v(y)-125}] $tmp [expr {$v(y)-75}] \
+	    -width $v(width) \
+	    -arrow both -arrowshape "$v(a) $v(b) $v(c)"
+    $c create line [expr {$tmp-25}] $v(y) [expr {$tmp+25}] $v(y) \
+	    -width $v(width) \
+	    -arrow both -arrowshape "$v(a) $v(b) $v(c)"
+    $c create line [expr {$tmp-25}] [expr {$v(y)+75}] [expr {$tmp+25}] \
+	    [expr {$v(y)+125}] -width $v(width) \
+	    -arrow both -arrowshape "$v(a) $v(b) $v(c)"
+
+    # Create a bunch of other arrows and text items showing the
+    # current dimensions.
+
+    set tmp [expr {$v(x2)+10}]
+    $c create line $tmp [expr {$v(y)-5*$v(width)}] \
+	    $tmp [expr {$v(y)-$deltaY}] \
+	    -arrow both -arrowshape $v(smallTips)
+    $c create text [expr {$v(x2)+15}] [expr {$v(y)-$deltaY+5*$v(c)}] \
+	    -text $v(c) -anchor w
+    set tmp [expr {$v(x1)-10}]
+    $c create line $tmp [expr {$v(y)-5*$v(width)}] \
+	    $tmp [expr {$v(y)+5*$v(width)}] \
+	    -arrow both -arrowshape $v(smallTips)
+    $c create text [expr {$v(x1)-15}] $v(y) -text $v(width) -anchor e
+    set tmp [expr {$v(y)+5*$v(width)+10*$v(c)+10}]
+    $c create line [expr {$v(x2)-10*$v(a)}] $tmp $v(x2) $tmp \
+	    -arrow both -arrowshape $v(smallTips)
+    $c create text [expr {$v(x2)-5*$v(a)}] [expr {$tmp+5}] \
+	    -text $v(a) -anchor n
+    set tmp [expr {$tmp+25}]
+    $c create line [expr {$v(x2)-10*$v(b)}] $tmp $v(x2) $tmp \
+	    -arrow both -arrowshape $v(smallTips)
+    $c create text [expr {$v(x2)-5*$v(b)}] [expr {$tmp+5}] \
+	    -text $v(b) -anchor n
+
+    $c create text $v(x1) 310 -text "-width  $v(width)" \
+	    -anchor w -font {Helvetica 18}
+    $c create text $v(x1) 330 -text "-arrowshape  {$v(a)  $v(b)  $v(c)}" \
+	    -anchor w -font {Helvetica 18}
+
+    incr v(count)
+}
+
+set w .arrow
+catch {destroy $w}
+toplevel $w
+wm title $w "Arrowhead Editor Demonstration"
+wm iconname $w "arrow"
+positionWindow $w
+set c $w.c
+
+label $w.msg -font $font -wraplength 5i -justify left -text "This widget allows you to experiment with different widths and arrowhead shapes for lines in canvases.  To change the line width or the shape of the arrowhead, drag any of the three boxes attached to the oversized arrow.  The arrows on the right give examples at normal scale.  The text at the bottom shows the configuration options as you'd enter them for a canvas line item."
+pack $w.msg -side top
+
+## See Code / Dismiss buttons
+set btns [addSeeDismiss $w.buttons $w]
+pack $btns -side bottom -fill x
+
+canvas $c -width 500 -height 350 -relief sunken -borderwidth 2
+pack $c -expand yes -fill both
+
+set demo_arrowInfo(a) 8
+set demo_arrowInfo(b) 10
+set demo_arrowInfo(c) 3
+set demo_arrowInfo(width) 2
+set demo_arrowInfo(motionProc) arrowMoveNull
+set demo_arrowInfo(x1) 40
+set demo_arrowInfo(x2) 350
+set demo_arrowInfo(y) 150
+set demo_arrowInfo(smallTips) {5 5 2}
+set demo_arrowInfo(count) 0
+if {[winfo depth $c] > 1} {
+    if {[tk windowingsystem] eq "aqua"} {
+	set demo_arrowInfo(bigLineStyle) "-fill systemSelectedTextBackgroundColor"
+    } else {
+	set demo_arrowInfo(bigLineStyle) "-fill LightSeaGreen"
+    }
+    set demo_arrowInfo(boxStyle) "-fill {} -width 1"
+    set demo_arrowInfo(activeStyle) "-fill red -width 1"
+} else {
+    # Main widget program sets variable tk_demoDirectory
+    set demo_arrowInfo(bigLineStyle) "-fill black \
+	-stipple @[file join $tk_demoDirectory images grey.25]"
+    set demo_arrowInfo(boxStyle) "-fill {} -outline black -width 1"
+    set demo_arrowInfo(activeStyle) "-fill black -outline black -width 1"
+}
+arrowSetup $c
+$c bind box <Enter> "$c itemconfigure current $demo_arrowInfo(activeStyle)"
+$c bind box <Leave> "$c itemconfigure current $demo_arrowInfo(boxStyle)"
+$c bind box <B1-Enter> " "
+$c bind box <B1-Leave> " "
+$c bind box1 <Button-1> {set demo_arrowInfo(motionProc) arrowMove1}
+$c bind box2 <Button-1> {set demo_arrowInfo(motionProc) arrowMove2}
+$c bind box3 <Button-1> {set demo_arrowInfo(motionProc) arrowMove3}
+$c bind box <B1-Motion> "\$demo_arrowInfo(motionProc) $c %x %y"
+bind $c <ButtonRelease-1> "arrowSetup $c"
+
+# arrowMove1 --
+# This procedure is called for each mouse motion event on box1 (the
+# one at the vertex of the arrow).  It updates the controlling parameters
+# for the line and arrowhead.
+#
+# Arguments:
+# c -		The name of the canvas window.
+# x, y -	The coordinates of the mouse.
+
+proc arrowMove1 {c x y} {
+    upvar #0 demo_arrowInfo v
+    set newA [expr {($v(x2)+5-round([$c canvasx $x]))/10}]
+    if {$newA < 0} {
+	set newA 0
+    }
+    if {$newA > 25} {
+	set newA 25
+    }
+    if {$newA != $v(a)} {
+	$c move box1 [expr {10*($v(a)-$newA)}] 0
+	set v(a) $newA
+    }
+}
+
+# arrowMove2 --
+# This procedure is called for each mouse motion event on box2 (the
+# one at the trailing tip of the arrowhead).  It updates the controlling
+# parameters for the line and arrowhead.
+#
+# Arguments:
+# c -		The name of the canvas window.
+# x, y -	The coordinates of the mouse.
+
+proc arrowMove2 {c x y} {
+    upvar #0 demo_arrowInfo v
+    set newB [expr {($v(x2)+5-round([$c canvasx $x]))/10}]
+    if {$newB < 0} {
+	set newB 0
+    }
+    if {$newB > 25} {
+	set newB 25
+    }
+    set newC [expr {($v(y)+5-round([$c canvasy $y])-5*$v(width))/10}]
+    if {$newC < 0} {
+	set newC 0
+    }
+    if {$newC > 20} {
+	set newC 20
+    }
+    if {($newB != $v(b)) || ($newC != $v(c))} {
+	$c move box2 [expr {10*($v(b)-$newB)}] [expr {10*($v(c)-$newC)}]
+	set v(b) $newB
+	set v(c) $newC
+    }
+}
+
+# arrowMove3 --
+# This procedure is called for each mouse motion event on box3 (the
+# one that controls the thickness of the line).  It updates the
+# controlling parameters for the line and arrowhead.
+#
+# Arguments:
+# c -		The name of the canvas window.
+# x, y -	The coordinates of the mouse.
+
+proc arrowMove3 {c x y} {
+    upvar #0 demo_arrowInfo v
+    set newWidth [expr {($v(y)+2-round([$c canvasy $y]))/5}]
+    if {$newWidth < 0} {
+	set newWidth 0
+    }
+    if {$newWidth > 20} {
+	set newWidth 20
+    }
+    if {$newWidth != $v(width)} {
+	$c move box3 0 [expr {5*($v(width)-$newWidth)}]
+	set v(width) $newWidth
+    }
+}

miniconda3/envs/active_proaction/lib/tk8.6/demos/bind.tcl

@@ -0,0 +1,78 @@
+# bind.tcl --
+#
+# This demonstration script creates a text widget with bindings set
+# up for hypertext-like effects.
+
+if {![info exists widgetDemo]} {
+    error "This script should be run from the \"widget\" demo."
+}
+
+package require Tk
+
+set w .bind
+catch {destroy $w}
+toplevel $w
+wm title $w "Text Demonstration - Tag Bindings"
+wm iconname $w "bind"
+positionWindow $w
+
+## See Code / Dismiss buttons
+set btns [addSeeDismiss $w.buttons $w]
+pack $btns -side bottom -fill x
+
+text $w.text -yscrollcommand "$w.scroll set" -setgrid true \
+	-width 60 -height 24 -font $font -wrap word
+ttk::scrollbar $w.scroll -command "$w.text yview"
+pack $w.scroll -side right -fill y
+pack $w.text -expand yes -fill both
+
+# Set up display styles.
+
+if {[winfo depth $w] > 1} {
+    set bold "-background #43ce80 -relief raised -borderwidth 1"
+    set normal "-background {} -relief flat"
+} else {
+    set bold "-foreground white -background black"
+    set normal "-foreground {} -background {}"
+}
+
+# Add text to widget.
+
+$w.text insert 0.0 {\
+The same tag mechanism that controls display styles in text widgets can also be used to associate Tcl commands with regions of text, so that mouse or keyboard actions on the text cause particular Tcl commands to be invoked.  For example, in the text below the descriptions of the canvas demonstrations have been tagged.  When you move the mouse over a demo description the description lights up, and when you press button 1 over a description then that particular demonstration is invoked.
+
+}
+$w.text insert end \
+{1. Samples of all the different types of items that can be created in canvas widgets.} d1
+$w.text insert end \n\n
+$w.text insert end \
+{2. A simple two-dimensional plot that allows you to adjust the positions of the data points.} d2
+$w.text insert end \n\n
+$w.text insert end \
+{3. Anchoring and justification modes for text items.} d3
+$w.text insert end \n\n
+$w.text insert end \
+{4. An editor for arrow-head shapes for line items.} d4
+$w.text insert end \n\n
+$w.text insert end \
+{5. A ruler with facilities for editing tab stops.} d5
+$w.text insert end \n\n
+$w.text insert end \
+{6. A grid that demonstrates how canvases can be scrolled.} d6
+
+# Create bindings for tags.
+
+foreach tag {d1 d2 d3 d4 d5 d6} {
+    $w.text tag bind $tag <Enter> "$w.text tag configure $tag $bold"
+    $w.text tag bind $tag <Leave> "$w.text tag configure $tag $normal"
+}
+# Main widget program sets variable tk_demoDirectory
+$w.text tag bind d1 <Button-1> {source -encoding utf-8 [file join $tk_demoDirectory items.tcl]}
+$w.text tag bind d2 <Button-1> {source -encoding utf-8 [file join $tk_demoDirectory plot.tcl]}
+$w.text tag bind d3 <Button-1> {source -encoding utf-8 [file join $tk_demoDirectory ctext.tcl]}
+$w.text tag bind d4 <Button-1> {source -encoding utf-8 [file join $tk_demoDirectory arrow.tcl]}
+$w.text tag bind d5 <Button-1> {source -encoding utf-8 [file join $tk_demoDirectory ruler.tcl]}
+$w.text tag bind d6 <Button-1> {source -encoding utf-8 [file join $tk_demoDirectory cscroll.tcl]}
+
+$w.text mark set insert 0.0
+$w.text configure -state disabled