diff --git a/ChangeLog.md b/ChangeLog.md new file mode 100644 --- /dev/null +++ b/ChangeLog.md @@ -0,0 +1,5 @@ +# Revision history for ige + +## 0.1.0.0 -- 2017-07-07 + +* Basic graph editing is working, including saving and reading from files. diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMain diff --git a/ige.cabal b/ige.cabal new file mode 100644 --- /dev/null +++ b/ige.cabal @@ -0,0 +1,70 @@ +-- Initial ige.cabal generated by cabal init. For further documentation, +-- see http://haskell.org/cabal/users-guide/ + +name: ige +version: 0.1.0.0 +Homepage: https://github.com/olynch/ige +synopsis: An keyboard-driven interactive graph editor +description: + `IGE` attempts to build a reusable library for implementing graph editors. The intent is to allow a new class of programming languages that have non-linear structure. See `glance` (an alternative syntax for haskell) for one example of such a structure. Other applications include circuit design, commutative diagram drawing, server configuration. Currently a very early alpha. +license: GPL-3 +license-file: LICENSE +author: Owen Lynch +maintainer: owen@olynch.me +category: Editing +build-type: Simple +extra-source-files: ChangeLog.md +cabal-version: >=1.10 + +executable ige + main-is: Main.hs + other-modules: IGE.Types + , IGE.Control + , IGE.Layout + , IGE.Render + , IGE.UI + , IGE.Keys +-- , IGE.Lisp + , IGE.Serialization + -- other-extensions: + build-depends: base >= 4.9 && < 4.10 + , cairo >= 0.13 + , gtk >= 0.14 + , protolude >= 0.1 + , fgl + , microlens-platform + , linear + , containers + , conduit + , conduit-combinators + , stm-conduit + , stm-chans + , stm + , array + , mwc-random + , mtl + , transformers + , megaparsec + , text + , wl-pprint-text + , aeson + , bytestring + , directory + + default-extensions: NoImplicitPrelude + , FlexibleContexts + , NoMonomorphismRestriction + , TypeFamilies + , GeneralizedNewtypeDeriving + , TemplateHaskell + , TypeSynonymInstances + , FlexibleInstances + , RankNTypes + , OverloadedStrings + hs-source-dirs: src + default-language: Haskell2010 + ghc-options: -threaded + +source-repository head + type: git + location: git://github.com/olynch/ige.git diff --git a/src/IGE/Control.hs b/src/IGE/Control.hs new file mode 100644 --- /dev/null +++ b/src/IGE/Control.hs @@ -0,0 +1,260 @@ +module IGE.Control + ( runKeyBinding + , basicKeyBinding + , textKeyBinding + ) + where + +import Prelude (String) +import Protolude hiding (empty, readFile, writeFile) +import qualified Data.Map.Strict as Map +import Lens.Micro.Platform +import Conduit +import Data.Conduit.TMChan +import Graphics.UI.Gtk hiding (get) +import Data.Graph.Inductive.Graph +import Data.Graph.Inductive.PatriciaTree +import Control.Concurrent.STM +import qualified Data.Sequence as Seq +import Data.Sequence ((<|), (|>), viewl, ViewL(..), Seq(..)) +import Control.Monad.Trans.Maybe +import Data.Text (pack) +import Data.Aeson (ToJSON, FromJSON) +import Data.ByteString.Lazy (readFile, writeFile) +import System.Directory (doesFileExist) + +import IGE.Types +import IGE.Keys +import IGE.Layout +import IGE.Serialization + +navigationKeyMap :: Map.Map KeyVal (EditorM n e ()) +navigationKeyMap = Map.fromList [ + (xK_plus, _rm . _at *= ((10/9) :+ 0)) + , (xK_minus, _rm . _at *= ((9/10) :+ 0)) + , (xK_h, transRel (0.5 :+ 0)) + , (xK_j, transRel (0 :+ (-0.5))) + , (xK_k, transRel (0 :+ 0.5)) + , (xK_l, transRel ((-0.5) :+ 0)) + , (xK_greater, _rm . _at *= cis (pi / 6)) + , (xK_less, _rm . _at *= cis ((- pi) / 6)) + ] + +transRel :: ℂ -> EditorM n e () +transRel z = do + r <- use $ _rm . _r + _rm . _trans += (r :+ 0) * z + + +awaitOrFinish :: (Monad m) => a -> (i -> ConduitM i o m a) -> ConduitM i o m a +awaitOrFinish x action = await >>= maybe (return x) action + +updateEditor :: EditorM n e a -> KeyBinding n e a +updateEditor em = do + x <- runTVarState em + yield NoLayoutChange + return x + +updateEditorLayout :: EditorM n e a -> KeyBinding n e a +updateEditorLayout em = do + x <- runTVarState em + yield LayoutChange + return x + +tailButN :: Int -> [a] -> [a] +tailButN n xs = if length theTail < n then xs else theTail + where theTail = tailDef [] xs + +getString :: String -> KeyBinding n e (Maybe String) +getString init' = do + updateEditor $ _cmd .= init + loop + where + init = reverse init' + n = length init + handleInput kv + | kv == xK_BackSpace = updateEditor (_cmd %= tailButN n) >> loop + | kv == xK_Return = do + s <- runTVarReader $ view _cmd + updateEditor (_cmd .= "") >> return (Just $ drop n $ reverse s) + | kv == xK_Escape = updateEditor (_cmd .= "") >> return Nothing + | otherwise = loop + + loop = awaitOrFinish Nothing $ \kv -> + case keyToChar kv of + (Just c) -> updateEditor (_cmd %= (c:)) >> loop + Nothing -> + handleInput kv + +labelChars = "asdfghjkl" + +makeLabels :: Int -> String -> [String] +makeLabels n alphabet = helper n alphabet "" Seq.empty + where + helper :: Int -> String -> String -> Seq String -> [String] + helper 0 _ _ queue = reverse <$> toList queue + helper n (c:cs) postfix queue = + helper (n - 1) cs postfix (queue |> (c:postfix)) + helper n [] _ queue = + case viewl queue of + a :< rest -> helper (n + 1) alphabet a rest + EmptyL -> [] + +labelGraph :: Gr n e -> [(String, Node)] +labelGraph gr = zip labels (nodes gr) + where + labels = makeLabels (length $ nodes gr) labelChars + +getNode :: KeyBinding n e (Maybe Node) +getNode = initLabels >> loop + where + initLabels = updateEditor $ do + gr <- use _graph + _labels .= labelGraph gr + reset = updateEditor $ _labels .= [] + loop = awaitOrFinish Nothing $ \kv -> + case keyToChar kv of + (Just c) -> do + labels <- runTVarReader $ view _labels + let labels' = [(xs, node) | (x:xs, node) <- labels, x == c] + case labels' of + [] -> reset >> return Nothing + [(_, node)] -> reset >> return (Just node) + xs -> do + updateEditor $ _labels .= labels' + loop + Nothing -> reset >> return Nothing + +addNode :: KeyBinding () e () +addNode = + updateEditorLayout $ do + n <- use _num + _graph %= insNode (n, ()) + _num += 1 + +addNodeText :: KeyBinding Text e () +addNodeText = do + mlabel <- getString "label: " + case mlabel of + Just label -> updateEditorLayout $ do + n <- use _num + _graph %= insNode (n, pack label) + _num += 1 + Nothing -> return () + +linkNodes :: KeyBinding n () () +linkNodes = do + mnodes <- runMaybeT $ do + lift $ updateEditor $ _cmd .= reverse "SELECT NODE 1" + n1 <- MaybeT getNode + lift $ updateEditor $ _cmd .= reverse "SELECT NODE 2" + n2 <- MaybeT getNode + return (n1, n2) + updateEditor $ _cmd .= "" + case mnodes of + Just (n1, n2) -> + updateEditorLayout $ _graph %= insEdge (n1, n2, ()) + Nothing -> + return () + +linkNodesText :: KeyBinding n Text () +linkNodesText = do + mnodes <- runMaybeT $ do + lift $ updateEditor $ _cmd .= reverse "SELECT NODE 1" + n1 <- MaybeT getNode + lift $ updateEditor $ _cmd .= reverse "SELECT NODE 2" + n2 <- MaybeT getNode + label <- MaybeT $ getString "label: " + return (n1, n2, label) + case mnodes of + Just (n1, n2, label) -> + updateEditorLayout $ _graph %= insEdge (n1, n2, pack label) + Nothing -> + return () + +deleteNode :: KeyBinding n e () +deleteNode = do + mnode <- getNode + case mnode of + Just n -> updateEditor $ _graph %= delNode n + Nothing -> return () + +readGraph :: (FromJSON n, FromJSON e) => KeyBinding n e () +readGraph = do + mnewgraph <- runMaybeT $ do + filename <- MaybeT $ getString "filename: " + liftIO (doesFileExist filename) >>= guard + MaybeT $ graphFromBS <$> liftIO (readFile filename) + case mnewgraph of + Just newgraph -> + updateEditorLayout $ _graph .= newgraph + Nothing -> return () + +writeGraph :: (ToJSON n, ToJSON e) => KeyBinding n e () +writeGraph = do + mfilename <- getString "filename: " + case mfilename of + Just fn -> do + g <- runTVarReader $ view _graph + liftIO $ writeFile fn $ graphToBS g + Nothing -> return () + +textKeyBinding :: KeyBinding Text Text () +textKeyBinding = loop + where + loop = awaitOrFinish () $ \kv -> + case Map.lookup kv navigationKeyMap of + (Just em) -> do + updateEditor em + loop + Nothing -> handleSpecial kv + handleSpecial kv + | kv == xK_colon = do + cmd <- getString ":" + print cmd + loop + | kv == xK_a = addNodeText >> loop + | kv == xK_c = linkNodesText >> loop + | kv == xK_d = deleteNode >> loop + | kv == xK_w = writeGraph >> loop + | kv == xK_o = readGraph >> loop + | kv == xK_q = liftIO mainQuit >> return () + | otherwise = loop + +basicKeyBinding :: KeyBinding () () () +basicKeyBinding = loop + where + loop = awaitOrFinish () $ \kv -> + case Map.lookup kv navigationKeyMap of + (Just em) -> do + updateEditor em + loop + Nothing -> handleSpecial kv + handleSpecial kv + | kv == xK_colon = do + cmd <- getString ":" + print cmd + loop + | kv == xK_a = addNode >> loop + | kv == xK_c = linkNodes >> loop + | kv == xK_d = deleteNode >> loop + | kv == xK_q = liftIO mainQuit >> return () + | otherwise = loop + +refresh :: (WidgetClass w) => w -> Consumer RefreshType (IGEM n e) () +refresh widget = do + rt <- await + if rt == Just LayoutChange + then runTVarState $ do + graph <- use _graph + _nodeMap .= layoutGr graph + else return () + liftIO $ widgetQueueDraw widget + refresh widget + +runKeyBinding :: (WidgetClass w, RenderNode n, RenderEdge e) => TBMChan KeyVal -> TVar (EditorState n e) -> w -> KeyBinding n e () -> IO () +runKeyBinding keyChan editorState w kb = + runIGEM editorState $ runConduit $ + sourceTBMChan keyChan + .| kb + .| refresh w diff --git a/src/IGE/Keys.hs b/src/IGE/Keys.hs new file mode 100644 --- /dev/null +++ b/src/IGE/Keys.hs @@ -0,0 +1,4544 @@ +module IGE.Keys where + +import Graphics.UI.Gtk (KeyVal) + +xK_VoidSymbol :: KeyVal +xK_VoidSymbol = 0xffffff +xK_BackSpace :: KeyVal +xK_BackSpace = 0xff08 +xK_Tab :: KeyVal +xK_Tab = 0xff09 +xK_Linefeed :: KeyVal +xK_Linefeed = 0xff0a +xK_Clear :: KeyVal +xK_Clear = 0xff0b +xK_Return :: KeyVal +xK_Return = 0xff0d +xK_Pause :: KeyVal +xK_Pause = 0xff13 +xK_Scroll_Lock :: KeyVal +xK_Scroll_Lock = 0xff14 +xK_Sys_Req :: KeyVal +xK_Sys_Req = 0xff15 +xK_Escape :: KeyVal +xK_Escape = 0xff1b +xK_Delete :: KeyVal +xK_Delete = 0xffff +xK_Multi_key :: KeyVal +xK_Multi_key = 0xff20 +xK_Codeinput :: KeyVal +xK_Codeinput = 0xff37 +xK_SingleCandidate :: KeyVal +xK_SingleCandidate = 0xff3c +xK_MultipleCandidate :: KeyVal +xK_MultipleCandidate = 0xff3d +xK_PreviousCandidate :: KeyVal +xK_PreviousCandidate = 0xff3e +xK_Kanji :: KeyVal +xK_Kanji = 0xff21 +xK_Muhenkan :: KeyVal +xK_Muhenkan = 0xff22 +xK_Henkan_Mode :: KeyVal +xK_Henkan_Mode = 0xff23 +xK_Henkan :: KeyVal +xK_Henkan = 0xff23 +xK_Romaji :: KeyVal +xK_Romaji = 0xff24 +xK_Hiragana :: KeyVal +xK_Hiragana = 0xff25 +xK_Katakana :: KeyVal +xK_Katakana = 0xff26 +xK_Hiragana_Katakana :: KeyVal +xK_Hiragana_Katakana = 0xff27 +xK_Zenkaku :: KeyVal +xK_Zenkaku = 0xff28 +xK_Hankaku :: KeyVal +xK_Hankaku = 0xff29 +xK_Zenkaku_Hankaku :: KeyVal +xK_Zenkaku_Hankaku = 0xff2a +xK_Touroku :: KeyVal +xK_Touroku = 0xff2b +xK_Massyo :: KeyVal +xK_Massyo = 0xff2c +xK_Kana_Lock :: KeyVal +xK_Kana_Lock = 0xff2d +xK_Kana_Shift :: KeyVal +xK_Kana_Shift = 0xff2e +xK_Eisu_Shift :: KeyVal +xK_Eisu_Shift = 0xff2f +xK_Eisu_toggle :: KeyVal +xK_Eisu_toggle = 0xff30 +xK_Kanji_Bangou :: KeyVal +xK_Kanji_Bangou = 0xff37 +xK_Zen_Koho :: KeyVal +xK_Zen_Koho = 0xff3d +xK_Mae_Koho :: KeyVal +xK_Mae_Koho = 0xff3e +xK_Home :: KeyVal +xK_Home = 0xff50 +xK_Left :: KeyVal +xK_Left = 0xff51 +xK_Up :: KeyVal +xK_Up = 0xff52 +xK_Right :: KeyVal +xK_Right = 0xff53 +xK_Down :: KeyVal +xK_Down = 0xff54 +xK_Prior :: KeyVal +xK_Prior = 0xff55 +xK_Page_Up :: KeyVal +xK_Page_Up = 0xff55 +xK_Next :: KeyVal +xK_Next = 0xff56 +xK_Page_Down :: KeyVal +xK_Page_Down = 0xff56 +xK_End :: KeyVal +xK_End = 0xff57 +xK_Begin :: KeyVal +xK_Begin = 0xff58 +xK_Select :: KeyVal +xK_Select = 0xff60 +xK_Print :: KeyVal +xK_Print = 0xff61 +xK_Execute :: KeyVal +xK_Execute = 0xff62 +xK_Insert :: KeyVal +xK_Insert = 0xff63 +xK_Undo :: KeyVal +xK_Undo = 0xff65 +xK_Redo :: KeyVal +xK_Redo = 0xff66 +xK_Menu :: KeyVal +xK_Menu = 0xff67 +xK_Find :: KeyVal +xK_Find = 0xff68 +xK_Cancel :: KeyVal +xK_Cancel = 0xff69 +xK_Help :: KeyVal +xK_Help = 0xff6a +xK_Break :: KeyVal +xK_Break = 0xff6b +xK_Mode_switch :: KeyVal +xK_Mode_switch = 0xff7e +xK_script_switch :: KeyVal +xK_script_switch = 0xff7e +xK_Num_Lock :: KeyVal +xK_Num_Lock = 0xff7f +xK_KP_Space :: KeyVal +xK_KP_Space = 0xff80 +xK_KP_Tab :: KeyVal +xK_KP_Tab = 0xff89 +xK_KP_Enter :: KeyVal +xK_KP_Enter = 0xff8d +xK_KP_F1 :: KeyVal +xK_KP_F1 = 0xff91 +xK_KP_F2 :: KeyVal +xK_KP_F2 = 0xff92 +xK_KP_F3 :: KeyVal +xK_KP_F3 = 0xff93 +xK_KP_F4 :: KeyVal +xK_KP_F4 = 0xff94 +xK_KP_Home :: KeyVal +xK_KP_Home = 0xff95 +xK_KP_Left :: KeyVal +xK_KP_Left = 0xff96 +xK_KP_Up :: KeyVal +xK_KP_Up = 0xff97 +xK_KP_Right :: KeyVal +xK_KP_Right = 0xff98 +xK_KP_Down :: KeyVal +xK_KP_Down = 0xff99 +xK_KP_Prior :: KeyVal +xK_KP_Prior = 0xff9a +xK_KP_Page_Up :: KeyVal +xK_KP_Page_Up = 0xff9a +xK_KP_Next :: KeyVal +xK_KP_Next = 0xff9b +xK_KP_Page_Down :: KeyVal +xK_KP_Page_Down = 0xff9b +xK_KP_End :: KeyVal +xK_KP_End = 0xff9c +xK_KP_Begin :: KeyVal +xK_KP_Begin = 0xff9d +xK_KP_Insert :: KeyVal +xK_KP_Insert = 0xff9e +xK_KP_Delete :: KeyVal +xK_KP_Delete = 0xff9f +xK_KP_Equal :: KeyVal +xK_KP_Equal = 0xffbd +xK_KP_Multiply :: KeyVal +xK_KP_Multiply = 0xffaa +xK_KP_Add :: KeyVal +xK_KP_Add = 0xffab +xK_KP_Separator :: KeyVal +xK_KP_Separator = 0xffac +xK_KP_Subtract :: KeyVal +xK_KP_Subtract = 0xffad +xK_KP_Decimal :: KeyVal +xK_KP_Decimal = 0xffae +xK_KP_Divide :: KeyVal +xK_KP_Divide = 0xffaf +xK_KP_0 :: KeyVal +xK_KP_0 = 0xffb0 +xK_KP_1 :: KeyVal +xK_KP_1 = 0xffb1 +xK_KP_2 :: KeyVal +xK_KP_2 = 0xffb2 +xK_KP_3 :: KeyVal +xK_KP_3 = 0xffb3 +xK_KP_4 :: KeyVal +xK_KP_4 = 0xffb4 +xK_KP_5 :: KeyVal +xK_KP_5 = 0xffb5 +xK_KP_6 :: KeyVal +xK_KP_6 = 0xffb6 +xK_KP_7 :: KeyVal +xK_KP_7 = 0xffb7 +xK_KP_8 :: KeyVal +xK_KP_8 = 0xffb8 +xK_KP_9 :: KeyVal +xK_KP_9 = 0xffb9 +xK_F1 :: KeyVal +xK_F1 = 0xffbe +xK_F2 :: KeyVal +xK_F2 = 0xffbf +xK_F3 :: KeyVal +xK_F3 = 0xffc0 +xK_F4 :: KeyVal +xK_F4 = 0xffc1 +xK_F5 :: KeyVal +xK_F5 = 0xffc2 +xK_F6 :: KeyVal +xK_F6 = 0xffc3 +xK_F7 :: KeyVal +xK_F7 = 0xffc4 +xK_F8 :: KeyVal +xK_F8 = 0xffc5 +xK_F9 :: KeyVal +xK_F9 = 0xffc6 +xK_F10 :: KeyVal +xK_F10 = 0xffc7 +xK_F11 :: KeyVal +xK_F11 = 0xffc8 +xK_L1 :: KeyVal +xK_L1 = 0xffc8 +xK_F12 :: KeyVal +xK_F12 = 0xffc9 +xK_L2 :: KeyVal +xK_L2 = 0xffc9 +xK_F13 :: KeyVal +xK_F13 = 0xffca +xK_L3 :: KeyVal +xK_L3 = 0xffca +xK_F14 :: KeyVal +xK_F14 = 0xffcb +xK_L4 :: KeyVal +xK_L4 = 0xffcb +xK_F15 :: KeyVal +xK_F15 = 0xffcc +xK_L5 :: KeyVal +xK_L5 = 0xffcc +xK_F16 :: KeyVal +xK_F16 = 0xffcd +xK_L6 :: KeyVal +xK_L6 = 0xffcd +xK_F17 :: KeyVal +xK_F17 = 0xffce +xK_L7 :: KeyVal +xK_L7 = 0xffce +xK_F18 :: KeyVal +xK_F18 = 0xffcf +xK_L8 :: KeyVal +xK_L8 = 0xffcf +xK_F19 :: KeyVal +xK_F19 = 0xffd0 +xK_L9 :: KeyVal +xK_L9 = 0xffd0 +xK_F20 :: KeyVal +xK_F20 = 0xffd1 +xK_L10 :: KeyVal +xK_L10 = 0xffd1 +xK_F21 :: KeyVal +xK_F21 = 0xffd2 +xK_R1 :: KeyVal +xK_R1 = 0xffd2 +xK_F22 :: KeyVal +xK_F22 = 0xffd3 +xK_R2 :: KeyVal +xK_R2 = 0xffd3 +xK_F23 :: KeyVal +xK_F23 = 0xffd4 +xK_R3 :: KeyVal +xK_R3 = 0xffd4 +xK_F24 :: KeyVal +xK_F24 = 0xffd5 +xK_R4 :: KeyVal +xK_R4 = 0xffd5 +xK_F25 :: KeyVal +xK_F25 = 0xffd6 +xK_R5 :: KeyVal +xK_R5 = 0xffd6 +xK_F26 :: KeyVal +xK_F26 = 0xffd7 +xK_R6 :: KeyVal +xK_R6 = 0xffd7 +xK_F27 :: KeyVal +xK_F27 = 0xffd8 +xK_R7 :: KeyVal +xK_R7 = 0xffd8 +xK_F28 :: KeyVal +xK_F28 = 0xffd9 +xK_R8 :: KeyVal +xK_R8 = 0xffd9 +xK_F29 :: KeyVal +xK_F29 = 0xffda +xK_R9 :: KeyVal +xK_R9 = 0xffda +xK_F30 :: KeyVal +xK_F30 = 0xffdb +xK_R10 :: KeyVal +xK_R10 = 0xffdb +xK_F31 :: KeyVal +xK_F31 = 0xffdc +xK_R11 :: KeyVal +xK_R11 = 0xffdc +xK_F32 :: KeyVal +xK_F32 = 0xffdd +xK_R12 :: KeyVal +xK_R12 = 0xffdd +xK_F33 :: KeyVal +xK_F33 = 0xffde +xK_R13 :: KeyVal +xK_R13 = 0xffde +xK_F34 :: KeyVal +xK_F34 = 0xffdf +xK_R14 :: KeyVal +xK_R14 = 0xffdf +xK_F35 :: KeyVal +xK_F35 = 0xffe0 +xK_R15 :: KeyVal +xK_R15 = 0xffe0 +xK_Shift_L :: KeyVal +xK_Shift_L = 0xffe1 +xK_Shift_R :: KeyVal +xK_Shift_R = 0xffe2 +xK_Control_L :: KeyVal +xK_Control_L = 0xffe3 +xK_Control_R :: KeyVal +xK_Control_R = 0xffe4 +xK_Caps_Lock :: KeyVal +xK_Caps_Lock = 0xffe5 +xK_Shift_Lock :: KeyVal +xK_Shift_Lock = 0xffe6 +xK_Meta_L :: KeyVal +xK_Meta_L = 0xffe7 +xK_Meta_R :: KeyVal +xK_Meta_R = 0xffe8 +xK_Alt_L :: KeyVal +xK_Alt_L = 0xffe9 +xK_Alt_R :: KeyVal +xK_Alt_R = 0xffea +xK_Super_L :: KeyVal +xK_Super_L = 0xffeb +xK_Super_R :: KeyVal +xK_Super_R = 0xffec +xK_Hyper_L :: KeyVal +xK_Hyper_L = 0xffed +xK_Hyper_R :: KeyVal +xK_Hyper_R = 0xffee +xK_ISO_Lock :: KeyVal +xK_ISO_Lock = 0xfe01 +xK_ISO_Level2_Latch :: KeyVal +xK_ISO_Level2_Latch = 0xfe02 +xK_ISO_Level3_Shift :: KeyVal +xK_ISO_Level3_Shift = 0xfe03 +xK_ISO_Level3_Latch :: KeyVal +xK_ISO_Level3_Latch = 0xfe04 +xK_ISO_Level3_Lock :: KeyVal +xK_ISO_Level3_Lock = 0xfe05 +xK_ISO_Level5_Shift :: KeyVal +xK_ISO_Level5_Shift = 0xfe11 +xK_ISO_Level5_Latch :: KeyVal +xK_ISO_Level5_Latch = 0xfe12 +xK_ISO_Level5_Lock :: KeyVal +xK_ISO_Level5_Lock = 0xfe13 +xK_ISO_Group_Shift :: KeyVal +xK_ISO_Group_Shift = 0xff7e +xK_ISO_Group_Latch :: KeyVal +xK_ISO_Group_Latch = 0xfe06 +xK_ISO_Group_Lock :: KeyVal +xK_ISO_Group_Lock = 0xfe07 +xK_ISO_Next_Group :: KeyVal +xK_ISO_Next_Group = 0xfe08 +xK_ISO_Next_Group_Lock :: KeyVal +xK_ISO_Next_Group_Lock = 0xfe09 +xK_ISO_Prev_Group :: KeyVal +xK_ISO_Prev_Group = 0xfe0a +xK_ISO_Prev_Group_Lock :: KeyVal +xK_ISO_Prev_Group_Lock = 0xfe0b +xK_ISO_First_Group :: KeyVal +xK_ISO_First_Group = 0xfe0c +xK_ISO_First_Group_Lock :: KeyVal +xK_ISO_First_Group_Lock = 0xfe0d +xK_ISO_Last_Group :: KeyVal +xK_ISO_Last_Group = 0xfe0e +xK_ISO_Last_Group_Lock :: KeyVal +xK_ISO_Last_Group_Lock = 0xfe0f +xK_ISO_Left_Tab :: KeyVal +xK_ISO_Left_Tab = 0xfe20 +xK_ISO_Move_Line_Up :: KeyVal +xK_ISO_Move_Line_Up = 0xfe21 +xK_ISO_Move_Line_Down :: KeyVal +xK_ISO_Move_Line_Down = 0xfe22 +xK_ISO_Partial_Line_Up :: KeyVal +xK_ISO_Partial_Line_Up = 0xfe23 +xK_ISO_Partial_Line_Down :: KeyVal +xK_ISO_Partial_Line_Down = 0xfe24 +xK_ISO_Partial_Space_Left :: KeyVal +xK_ISO_Partial_Space_Left = 0xfe25 +xK_ISO_Partial_Space_Right :: KeyVal +xK_ISO_Partial_Space_Right = 0xfe26 +xK_ISO_Set_Margin_Left :: KeyVal +xK_ISO_Set_Margin_Left = 0xfe27 +xK_ISO_Set_Margin_Right :: KeyVal +xK_ISO_Set_Margin_Right = 0xfe28 +xK_ISO_Release_Margin_Left :: KeyVal +xK_ISO_Release_Margin_Left = 0xfe29 +xK_ISO_Release_Margin_Right :: KeyVal +xK_ISO_Release_Margin_Right = 0xfe2a +xK_ISO_Release_Both_Margins :: KeyVal +xK_ISO_Release_Both_Margins = 0xfe2b +xK_ISO_Fast_Cursor_Left :: KeyVal +xK_ISO_Fast_Cursor_Left = 0xfe2c +xK_ISO_Fast_Cursor_Right :: KeyVal +xK_ISO_Fast_Cursor_Right = 0xfe2d +xK_ISO_Fast_Cursor_Up :: KeyVal +xK_ISO_Fast_Cursor_Up = 0xfe2e +xK_ISO_Fast_Cursor_Down :: KeyVal +xK_ISO_Fast_Cursor_Down = 0xfe2f +xK_ISO_Continuous_Underline :: KeyVal +xK_ISO_Continuous_Underline = 0xfe30 +xK_ISO_Discontinuous_Underline :: KeyVal +xK_ISO_Discontinuous_Underline = 0xfe31 +xK_ISO_Emphasize :: KeyVal +xK_ISO_Emphasize = 0xfe32 +xK_ISO_Center_Object :: KeyVal +xK_ISO_Center_Object = 0xfe33 +xK_ISO_Enter :: KeyVal +xK_ISO_Enter = 0xfe34 +xK_dead_grave :: KeyVal +xK_dead_grave = 0xfe50 +xK_dead_acute :: KeyVal +xK_dead_acute = 0xfe51 +xK_dead_circumflex :: KeyVal +xK_dead_circumflex = 0xfe52 +xK_dead_tilde :: KeyVal +xK_dead_tilde = 0xfe53 +xK_dead_perispomeni :: KeyVal +xK_dead_perispomeni = 0xfe53 +xK_dead_macron :: KeyVal +xK_dead_macron = 0xfe54 +xK_dead_breve :: KeyVal +xK_dead_breve = 0xfe55 +xK_dead_abovedot :: KeyVal +xK_dead_abovedot = 0xfe56 +xK_dead_diaeresis :: KeyVal +xK_dead_diaeresis = 0xfe57 +xK_dead_abovering :: KeyVal +xK_dead_abovering = 0xfe58 +xK_dead_doubleacute :: KeyVal +xK_dead_doubleacute = 0xfe59 +xK_dead_caron :: KeyVal +xK_dead_caron = 0xfe5a +xK_dead_cedilla :: KeyVal +xK_dead_cedilla = 0xfe5b +xK_dead_ogonek :: KeyVal +xK_dead_ogonek = 0xfe5c +xK_dead_iota :: KeyVal +xK_dead_iota = 0xfe5d +xK_dead_voiced_sound :: KeyVal +xK_dead_voiced_sound = 0xfe5e +xK_dead_semivoiced_sound :: KeyVal +xK_dead_semivoiced_sound = 0xfe5f +xK_dead_belowdot :: KeyVal +xK_dead_belowdot = 0xfe60 +xK_dead_hook :: KeyVal +xK_dead_hook = 0xfe61 +xK_dead_horn :: KeyVal +xK_dead_horn = 0xfe62 +xK_dead_stroke :: KeyVal +xK_dead_stroke = 0xfe63 +xK_dead_abovecomma :: KeyVal +xK_dead_abovecomma = 0xfe64 +xK_dead_psili :: KeyVal +xK_dead_psili = 0xfe64 +xK_dead_abovereversedcomma :: KeyVal +xK_dead_abovereversedcomma = 0xfe65 +xK_dead_dasia :: KeyVal +xK_dead_dasia = 0xfe65 +xK_dead_doublegrave :: KeyVal +xK_dead_doublegrave = 0xfe66 +xK_dead_belowring :: KeyVal +xK_dead_belowring = 0xfe67 +xK_dead_belowmacron :: KeyVal +xK_dead_belowmacron = 0xfe68 +xK_dead_belowcircumflex :: KeyVal +xK_dead_belowcircumflex = 0xfe69 +xK_dead_belowtilde :: KeyVal +xK_dead_belowtilde = 0xfe6a +xK_dead_belowbreve :: KeyVal +xK_dead_belowbreve = 0xfe6b +xK_dead_belowdiaeresis :: KeyVal +xK_dead_belowdiaeresis = 0xfe6c +xK_dead_invertedbreve :: KeyVal +xK_dead_invertedbreve = 0xfe6d +xK_dead_belowcomma :: KeyVal +xK_dead_belowcomma = 0xfe6e +xK_dead_currency :: KeyVal +xK_dead_currency = 0xfe6f +xK_dead_a :: KeyVal +xK_dead_a = 0xfe80 +xK_dead_A :: KeyVal +xK_dead_A = 0xfe81 +xK_dead_e :: KeyVal +xK_dead_e = 0xfe82 +xK_dead_E :: KeyVal +xK_dead_E = 0xfe83 +xK_dead_i :: KeyVal +xK_dead_i = 0xfe84 +xK_dead_I :: KeyVal +xK_dead_I = 0xfe85 +xK_dead_o :: KeyVal +xK_dead_o = 0xfe86 +xK_dead_O :: KeyVal +xK_dead_O = 0xfe87 +xK_dead_u :: KeyVal +xK_dead_u = 0xfe88 +xK_dead_U :: KeyVal +xK_dead_U = 0xfe89 +xK_dead_small_schwa :: KeyVal +xK_dead_small_schwa = 0xfe8a +xK_dead_capital_schwa :: KeyVal +xK_dead_capital_schwa = 0xfe8b +xK_dead_greek :: KeyVal +xK_dead_greek = 0xfe8c +xK_First_Virtual_Screen :: KeyVal +xK_First_Virtual_Screen = 0xfed0 +xK_Prev_Virtual_Screen :: KeyVal +xK_Prev_Virtual_Screen = 0xfed1 +xK_Next_Virtual_Screen :: KeyVal +xK_Next_Virtual_Screen = 0xfed2 +xK_Last_Virtual_Screen :: KeyVal +xK_Last_Virtual_Screen = 0xfed4 +xK_Terminate_Server :: KeyVal +xK_Terminate_Server = 0xfed5 +xK_AccessX_Enable :: KeyVal +xK_AccessX_Enable = 0xfe70 +xK_AccessX_Feedback_Enable :: KeyVal +xK_AccessX_Feedback_Enable = 0xfe71 +xK_RepeatKeys_Enable :: KeyVal +xK_RepeatKeys_Enable = 0xfe72 +xK_SlowKeys_Enable :: KeyVal +xK_SlowKeys_Enable = 0xfe73 +xK_BounceKeys_Enable :: KeyVal +xK_BounceKeys_Enable = 0xfe74 +xK_StickyKeys_Enable :: KeyVal +xK_StickyKeys_Enable = 0xfe75 +xK_MouseKeys_Enable :: KeyVal +xK_MouseKeys_Enable = 0xfe76 +xK_MouseKeys_Accel_Enable :: KeyVal +xK_MouseKeys_Accel_Enable = 0xfe77 +xK_Overlay1_Enable :: KeyVal +xK_Overlay1_Enable = 0xfe78 +xK_Overlay2_Enable :: KeyVal +xK_Overlay2_Enable = 0xfe79 +xK_AudibleBell_Enable :: KeyVal +xK_AudibleBell_Enable = 0xfe7a +xK_Pointer_Left :: KeyVal +xK_Pointer_Left = 0xfee0 +xK_Pointer_Right :: KeyVal +xK_Pointer_Right = 0xfee1 +xK_Pointer_Up :: KeyVal +xK_Pointer_Up = 0xfee2 +xK_Pointer_Down :: KeyVal +xK_Pointer_Down = 0xfee3 +xK_Pointer_UpLeft :: KeyVal +xK_Pointer_UpLeft = 0xfee4 +xK_Pointer_UpRight :: KeyVal +xK_Pointer_UpRight = 0xfee5 +xK_Pointer_DownLeft :: KeyVal +xK_Pointer_DownLeft = 0xfee6 +xK_Pointer_DownRight :: KeyVal +xK_Pointer_DownRight = 0xfee7 +xK_Pointer_Button_Dflt :: KeyVal +xK_Pointer_Button_Dflt = 0xfee8 +xK_Pointer_Button1 :: KeyVal +xK_Pointer_Button1 = 0xfee9 +xK_Pointer_Button2 :: KeyVal +xK_Pointer_Button2 = 0xfeea +xK_Pointer_Button3 :: KeyVal +xK_Pointer_Button3 = 0xfeeb +xK_Pointer_Button4 :: KeyVal +xK_Pointer_Button4 = 0xfeec +xK_Pointer_Button5 :: KeyVal +xK_Pointer_Button5 = 0xfeed +xK_Pointer_DblClick_Dflt :: KeyVal +xK_Pointer_DblClick_Dflt = 0xfeee +xK_Pointer_DblClick1 :: KeyVal +xK_Pointer_DblClick1 = 0xfeef +xK_Pointer_DblClick2 :: KeyVal +xK_Pointer_DblClick2 = 0xfef0 +xK_Pointer_DblClick3 :: KeyVal +xK_Pointer_DblClick3 = 0xfef1 +xK_Pointer_DblClick4 :: KeyVal +xK_Pointer_DblClick4 = 0xfef2 +xK_Pointer_DblClick5 :: KeyVal +xK_Pointer_DblClick5 = 0xfef3 +xK_Pointer_Drag_Dflt :: KeyVal +xK_Pointer_Drag_Dflt = 0xfef4 +xK_Pointer_Drag1 :: KeyVal +xK_Pointer_Drag1 = 0xfef5 +xK_Pointer_Drag2 :: KeyVal +xK_Pointer_Drag2 = 0xfef6 +xK_Pointer_Drag3 :: KeyVal +xK_Pointer_Drag3 = 0xfef7 +xK_Pointer_Drag4 :: KeyVal +xK_Pointer_Drag4 = 0xfef8 +xK_Pointer_Drag5 :: KeyVal +xK_Pointer_Drag5 = 0xfefd +xK_Pointer_EnableKeys :: KeyVal +xK_Pointer_EnableKeys = 0xfef9 +xK_Pointer_Accelerate :: KeyVal +xK_Pointer_Accelerate = 0xfefa +xK_Pointer_DfltBtnNext :: KeyVal +xK_Pointer_DfltBtnNext = 0xfefb +xK_Pointer_DfltBtnPrev :: KeyVal +xK_Pointer_DfltBtnPrev = 0xfefc +xK_ch :: KeyVal +xK_ch = 0xfea0 +xK_Ch :: KeyVal +xK_Ch = 0xfea1 +xK_CH :: KeyVal +xK_CH = 0xfea2 +xK_c_h :: KeyVal +xK_c_h = 0xfea3 +xK_C_h :: KeyVal +xK_C_h = 0xfea4 +xK_C_H :: KeyVal +xK_C_H = 0xfea5 +xK_3270_Duplicate :: KeyVal +xK_3270_Duplicate = 0xfd01 +xK_3270_FieldMark :: KeyVal +xK_3270_FieldMark = 0xfd02 +xK_3270_Right2 :: KeyVal +xK_3270_Right2 = 0xfd03 +xK_3270_Left2 :: KeyVal +xK_3270_Left2 = 0xfd04 +xK_3270_BackTab :: KeyVal +xK_3270_BackTab = 0xfd05 +xK_3270_EraseEOF :: KeyVal +xK_3270_EraseEOF = 0xfd06 +xK_3270_EraseInput :: KeyVal +xK_3270_EraseInput = 0xfd07 +xK_3270_Reset :: KeyVal +xK_3270_Reset = 0xfd08 +xK_3270_Quit :: KeyVal +xK_3270_Quit = 0xfd09 +xK_3270_PA1 :: KeyVal +xK_3270_PA1 = 0xfd0a +xK_3270_PA2 :: KeyVal +xK_3270_PA2 = 0xfd0b +xK_3270_PA3 :: KeyVal +xK_3270_PA3 = 0xfd0c +xK_3270_Test :: KeyVal +xK_3270_Test = 0xfd0d +xK_3270_Attn :: KeyVal +xK_3270_Attn = 0xfd0e +xK_3270_CursorBlink :: KeyVal +xK_3270_CursorBlink = 0xfd0f +xK_3270_AltCursor :: KeyVal +xK_3270_AltCursor = 0xfd10 +xK_3270_KeyClick :: KeyVal +xK_3270_KeyClick = 0xfd11 +xK_3270_Jump :: KeyVal +xK_3270_Jump = 0xfd12 +xK_3270_Ident :: KeyVal +xK_3270_Ident = 0xfd13 +xK_3270_Rule :: KeyVal +xK_3270_Rule = 0xfd14 +xK_3270_Copy :: KeyVal +xK_3270_Copy = 0xfd15 +xK_3270_Play :: KeyVal +xK_3270_Play = 0xfd16 +xK_3270_Setup :: KeyVal +xK_3270_Setup = 0xfd17 +xK_3270_Record :: KeyVal +xK_3270_Record = 0xfd18 +xK_3270_ChangeScreen :: KeyVal +xK_3270_ChangeScreen = 0xfd19 +xK_3270_DeleteWord :: KeyVal +xK_3270_DeleteWord = 0xfd1a +xK_3270_ExSelect :: KeyVal +xK_3270_ExSelect = 0xfd1b +xK_3270_CursorSelect :: KeyVal +xK_3270_CursorSelect = 0xfd1c +xK_3270_PrintScreen :: KeyVal +xK_3270_PrintScreen = 0xfd1d +xK_3270_Enter :: KeyVal +xK_3270_Enter = 0xfd1e +xK_space :: KeyVal +xK_space = 0x020 +xK_exclam :: KeyVal +xK_exclam = 0x021 +xK_quotedbl :: KeyVal +xK_quotedbl = 0x022 +xK_numbersign :: KeyVal +xK_numbersign = 0x023 +xK_dollar :: KeyVal +xK_dollar = 0x024 +xK_percent :: KeyVal +xK_percent = 0x025 +xK_ampersand :: KeyVal +xK_ampersand = 0x026 +xK_apostrophe :: KeyVal +xK_apostrophe = 0x027 +xK_quoteright :: KeyVal +xK_quoteright = 0x027 +xK_parenleft :: KeyVal +xK_parenleft = 0x028 +xK_parenright :: KeyVal +xK_parenright = 0x029 +xK_asterisk :: KeyVal +xK_asterisk = 0x02a +xK_plus :: KeyVal +xK_plus = 0x02b +xK_comma :: KeyVal +xK_comma = 0x02c +xK_minus :: KeyVal +xK_minus = 0x02d +xK_period :: KeyVal +xK_period = 0x02e +xK_slash :: KeyVal +xK_slash = 0x02f +xK_0 :: KeyVal +xK_0 = 0x030 +xK_1 :: KeyVal +xK_1 = 0x031 +xK_2 :: KeyVal +xK_2 = 0x032 +xK_3 :: KeyVal +xK_3 = 0x033 +xK_4 :: KeyVal +xK_4 = 0x034 +xK_5 :: KeyVal +xK_5 = 0x035 +xK_6 :: KeyVal +xK_6 = 0x036 +xK_7 :: KeyVal +xK_7 = 0x037 +xK_8 :: KeyVal +xK_8 = 0x038 +xK_9 :: KeyVal +xK_9 = 0x039 +xK_colon :: KeyVal +xK_colon = 0x03a +xK_semicolon :: KeyVal +xK_semicolon = 0x03b +xK_less :: KeyVal +xK_less = 0x03c +xK_equal :: KeyVal +xK_equal = 0x03d +xK_greater :: KeyVal +xK_greater = 0x03e +xK_question :: KeyVal +xK_question = 0x03f +xK_at :: KeyVal +xK_at = 0x040 +xK_A :: KeyVal +xK_A = 0x041 +xK_B :: KeyVal +xK_B = 0x042 +xK_C :: KeyVal +xK_C = 0x043 +xK_D :: KeyVal +xK_D = 0x044 +xK_E :: KeyVal +xK_E = 0x045 +xK_F :: KeyVal +xK_F = 0x046 +xK_G :: KeyVal +xK_G = 0x047 +xK_H :: KeyVal +xK_H = 0x048 +xK_I :: KeyVal +xK_I = 0x049 +xK_J :: KeyVal +xK_J = 0x04a +xK_K :: KeyVal +xK_K = 0x04b +xK_L :: KeyVal +xK_L = 0x04c +xK_M :: KeyVal +xK_M = 0x04d +xK_N :: KeyVal +xK_N = 0x04e +xK_O :: KeyVal +xK_O = 0x04f +xK_P :: KeyVal +xK_P = 0x050 +xK_Q :: KeyVal +xK_Q = 0x051 +xK_R :: KeyVal +xK_R = 0x052 +xK_S :: KeyVal +xK_S = 0x053 +xK_T :: KeyVal +xK_T = 0x054 +xK_U :: KeyVal +xK_U = 0x055 +xK_V :: KeyVal +xK_V = 0x056 +xK_W :: KeyVal +xK_W = 0x057 +xK_X :: KeyVal +xK_X = 0x058 +xK_Y :: KeyVal +xK_Y = 0x059 +xK_Z :: KeyVal +xK_Z = 0x05a +xK_bracketleft :: KeyVal +xK_bracketleft = 0x05b +xK_backslash :: KeyVal +xK_backslash = 0x05c +xK_bracketright :: KeyVal +xK_bracketright = 0x05d +xK_asciicircum :: KeyVal +xK_asciicircum = 0x05e +xK_underscore :: KeyVal +xK_underscore = 0x05f +xK_grave :: KeyVal +xK_grave = 0x060 +xK_quoteleft :: KeyVal +xK_quoteleft = 0x060 +xK_a :: KeyVal +xK_a = 0x061 +xK_b :: KeyVal +xK_b = 0x062 +xK_c :: KeyVal +xK_c = 0x063 +xK_d :: KeyVal +xK_d = 0x064 +xK_e :: KeyVal +xK_e = 0x065 +xK_f :: KeyVal +xK_f = 0x066 +xK_g :: KeyVal +xK_g = 0x067 +xK_h :: KeyVal +xK_h = 0x068 +xK_i :: KeyVal +xK_i = 0x069 +xK_j :: KeyVal +xK_j = 0x06a +xK_k :: KeyVal +xK_k = 0x06b +xK_l :: KeyVal +xK_l = 0x06c +xK_m :: KeyVal +xK_m = 0x06d +xK_n :: KeyVal +xK_n = 0x06e +xK_o :: KeyVal +xK_o = 0x06f +xK_p :: KeyVal +xK_p = 0x070 +xK_q :: KeyVal +xK_q = 0x071 +xK_r :: KeyVal +xK_r = 0x072 +xK_s :: KeyVal +xK_s = 0x073 +xK_t :: KeyVal +xK_t = 0x074 +xK_u :: KeyVal +xK_u = 0x075 +xK_v :: KeyVal +xK_v = 0x076 +xK_w :: KeyVal +xK_w = 0x077 +xK_x :: KeyVal +xK_x = 0x078 +xK_y :: KeyVal +xK_y = 0x079 +xK_z :: KeyVal +xK_z = 0x07a +xK_braceleft :: KeyVal +xK_braceleft = 0x07b +xK_bar :: KeyVal +xK_bar = 0x07c +xK_braceright :: KeyVal +xK_braceright = 0x07d +xK_asciitilde :: KeyVal +xK_asciitilde = 0x07e +xK_nobreakspace :: KeyVal +xK_nobreakspace = 0x0a0 +xK_exclamdown :: KeyVal +xK_exclamdown = 0x0a1 +xK_cent :: KeyVal +xK_cent = 0x0a2 +xK_sterling :: KeyVal +xK_sterling = 0x0a3 +xK_currency :: KeyVal +xK_currency = 0x0a4 +xK_yen :: KeyVal +xK_yen = 0x0a5 +xK_brokenbar :: KeyVal +xK_brokenbar = 0x0a6 +xK_section :: KeyVal +xK_section = 0x0a7 +xK_diaeresis :: KeyVal +xK_diaeresis = 0x0a8 +xK_copyright :: KeyVal +xK_copyright = 0x0a9 +xK_ordfeminine :: KeyVal +xK_ordfeminine = 0x0aa +xK_guillemotleft :: KeyVal +xK_guillemotleft = 0x0ab +xK_notsign :: KeyVal +xK_notsign = 0x0ac +xK_hyphen :: KeyVal +xK_hyphen = 0x0ad +xK_registered :: KeyVal +xK_registered = 0x0ae +xK_macron :: KeyVal +xK_macron = 0x0af +xK_degree :: KeyVal +xK_degree = 0x0b0 +xK_plusminus :: KeyVal +xK_plusminus = 0x0b1 +xK_twosuperior :: KeyVal +xK_twosuperior = 0x0b2 +xK_threesuperior :: KeyVal +xK_threesuperior = 0x0b3 +xK_acute :: KeyVal +xK_acute = 0x0b4 +xK_mu :: KeyVal +xK_mu = 0x0b5 +xK_paragraph :: KeyVal +xK_paragraph = 0x0b6 +xK_periodcentered :: KeyVal +xK_periodcentered = 0x0b7 +xK_cedilla :: KeyVal +xK_cedilla = 0x0b8 +xK_onesuperior :: KeyVal +xK_onesuperior = 0x0b9 +xK_masculine :: KeyVal +xK_masculine = 0x0ba +xK_guillemotright :: KeyVal +xK_guillemotright = 0x0bb +xK_onequarter :: KeyVal +xK_onequarter = 0x0bc +xK_onehalf :: KeyVal +xK_onehalf = 0x0bd +xK_threequarters :: KeyVal +xK_threequarters = 0x0be +xK_questiondown :: KeyVal +xK_questiondown = 0x0bf +xK_Agrave :: KeyVal +xK_Agrave = 0x0c0 +xK_Aacute :: KeyVal +xK_Aacute = 0x0c1 +xK_Acircumflex :: KeyVal +xK_Acircumflex = 0x0c2 +xK_Atilde :: KeyVal +xK_Atilde = 0x0c3 +xK_Adiaeresis :: KeyVal +xK_Adiaeresis = 0x0c4 +xK_Aring :: KeyVal +xK_Aring = 0x0c5 +xK_AE :: KeyVal +xK_AE = 0x0c6 +xK_Ccedilla :: KeyVal +xK_Ccedilla = 0x0c7 +xK_Egrave :: KeyVal +xK_Egrave = 0x0c8 +xK_Eacute :: KeyVal +xK_Eacute = 0x0c9 +xK_Ecircumflex :: KeyVal +xK_Ecircumflex = 0x0ca +xK_Ediaeresis :: KeyVal +xK_Ediaeresis = 0x0cb +xK_Igrave :: KeyVal +xK_Igrave = 0x0cc +xK_Iacute :: KeyVal +xK_Iacute = 0x0cd +xK_Icircumflex :: KeyVal +xK_Icircumflex = 0x0ce +xK_Idiaeresis :: KeyVal +xK_Idiaeresis = 0x0cf +xK_ETH :: KeyVal +xK_ETH = 0x0d0 +xK_Eth :: KeyVal +xK_Eth = 0x0d0 +xK_Ntilde :: KeyVal +xK_Ntilde = 0x0d1 +xK_Ograve :: KeyVal +xK_Ograve = 0x0d2 +xK_Oacute :: KeyVal +xK_Oacute = 0x0d3 +xK_Ocircumflex :: KeyVal +xK_Ocircumflex = 0x0d4 +xK_Otilde :: KeyVal +xK_Otilde = 0x0d5 +xK_Odiaeresis :: KeyVal +xK_Odiaeresis = 0x0d6 +xK_multiply :: KeyVal +xK_multiply = 0x0d7 +xK_Oslash :: KeyVal +xK_Oslash = 0x0d8 +xK_Ooblique :: KeyVal +xK_Ooblique = 0x0d8 +xK_Ugrave :: KeyVal +xK_Ugrave = 0x0d9 +xK_Uacute :: KeyVal +xK_Uacute = 0x0da +xK_Ucircumflex :: KeyVal +xK_Ucircumflex = 0x0db +xK_Udiaeresis :: KeyVal +xK_Udiaeresis = 0x0dc +xK_Yacute :: KeyVal +xK_Yacute = 0x0dd +xK_THORN :: KeyVal +xK_THORN = 0x0de +xK_Thorn :: KeyVal +xK_Thorn = 0x0de +xK_ssharp :: KeyVal +xK_ssharp = 0x0df +xK_agrave :: KeyVal +xK_agrave = 0x0e0 +xK_aacute :: KeyVal +xK_aacute = 0x0e1 +xK_acircumflex :: KeyVal +xK_acircumflex = 0x0e2 +xK_atilde :: KeyVal +xK_atilde = 0x0e3 +xK_adiaeresis :: KeyVal +xK_adiaeresis = 0x0e4 +xK_aring :: KeyVal +xK_aring = 0x0e5 +xK_ae :: KeyVal +xK_ae = 0x0e6 +xK_ccedilla :: KeyVal +xK_ccedilla = 0x0e7 +xK_egrave :: KeyVal +xK_egrave = 0x0e8 +xK_eacute :: KeyVal +xK_eacute = 0x0e9 +xK_ecircumflex :: KeyVal +xK_ecircumflex = 0x0ea +xK_ediaeresis :: KeyVal +xK_ediaeresis = 0x0eb +xK_igrave :: KeyVal +xK_igrave = 0x0ec +xK_iacute :: KeyVal +xK_iacute = 0x0ed +xK_icircumflex :: KeyVal +xK_icircumflex = 0x0ee +xK_idiaeresis :: KeyVal +xK_idiaeresis = 0x0ef +xK_eth :: KeyVal +xK_eth = 0x0f0 +xK_ntilde :: KeyVal +xK_ntilde = 0x0f1 +xK_ograve :: KeyVal +xK_ograve = 0x0f2 +xK_oacute :: KeyVal +xK_oacute = 0x0f3 +xK_ocircumflex :: KeyVal +xK_ocircumflex = 0x0f4 +xK_otilde :: KeyVal +xK_otilde = 0x0f5 +xK_odiaeresis :: KeyVal +xK_odiaeresis = 0x0f6 +xK_division :: KeyVal +xK_division = 0x0f7 +xK_oslash :: KeyVal +xK_oslash = 0x0f8 +xK_ooblique :: KeyVal +xK_ooblique = 0x0f8 +xK_ugrave :: KeyVal +xK_ugrave = 0x0f9 +xK_uacute :: KeyVal +xK_uacute = 0x0fa +xK_ucircumflex :: KeyVal +xK_ucircumflex = 0x0fb +xK_udiaeresis :: KeyVal +xK_udiaeresis = 0x0fc +xK_yacute :: KeyVal +xK_yacute = 0x0fd +xK_thorn :: KeyVal +xK_thorn = 0x0fe +xK_ydiaeresis :: KeyVal +xK_ydiaeresis = 0x0ff +xK_Aogonek :: KeyVal +xK_Aogonek = 0x1a1 +xK_breve :: KeyVal +xK_breve = 0x1a2 +xK_Lstroke :: KeyVal +xK_Lstroke = 0x1a3 +xK_Lcaron :: KeyVal +xK_Lcaron = 0x1a5 +xK_Sacute :: KeyVal +xK_Sacute = 0x1a6 +xK_Scaron :: KeyVal +xK_Scaron = 0x1a9 +xK_Scedilla :: KeyVal +xK_Scedilla = 0x1aa +xK_Tcaron :: KeyVal +xK_Tcaron = 0x1ab +xK_Zacute :: KeyVal +xK_Zacute = 0x1ac +xK_Zcaron :: KeyVal +xK_Zcaron = 0x1ae +xK_Zabovedot :: KeyVal +xK_Zabovedot = 0x1af +xK_aogonek :: KeyVal +xK_aogonek = 0x1b1 +xK_ogonek :: KeyVal +xK_ogonek = 0x1b2 +xK_lstroke :: KeyVal +xK_lstroke = 0x1b3 +xK_lcaron :: KeyVal +xK_lcaron = 0x1b5 +xK_sacute :: KeyVal +xK_sacute = 0x1b6 +xK_caron :: KeyVal +xK_caron = 0x1b7 +xK_scaron :: KeyVal +xK_scaron = 0x1b9 +xK_scedilla :: KeyVal +xK_scedilla = 0x1ba +xK_tcaron :: KeyVal +xK_tcaron = 0x1bb +xK_zacute :: KeyVal +xK_zacute = 0x1bc +xK_doubleacute :: KeyVal +xK_doubleacute = 0x1bd +xK_zcaron :: KeyVal +xK_zcaron = 0x1be +xK_zabovedot :: KeyVal +xK_zabovedot = 0x1bf +xK_Racute :: KeyVal +xK_Racute = 0x1c0 +xK_Abreve :: KeyVal +xK_Abreve = 0x1c3 +xK_Lacute :: KeyVal +xK_Lacute = 0x1c5 +xK_Cacute :: KeyVal +xK_Cacute = 0x1c6 +xK_Ccaron :: KeyVal +xK_Ccaron = 0x1c8 +xK_Eogonek :: KeyVal +xK_Eogonek = 0x1ca +xK_Ecaron :: KeyVal +xK_Ecaron = 0x1cc +xK_Dcaron :: KeyVal +xK_Dcaron = 0x1cf +xK_Dstroke :: KeyVal +xK_Dstroke = 0x1d0 +xK_Nacute :: KeyVal +xK_Nacute = 0x1d1 +xK_Ncaron :: KeyVal +xK_Ncaron = 0x1d2 +xK_Odoubleacute :: KeyVal +xK_Odoubleacute = 0x1d5 +xK_Rcaron :: KeyVal +xK_Rcaron = 0x1d8 +xK_Uring :: KeyVal +xK_Uring = 0x1d9 +xK_Udoubleacute :: KeyVal +xK_Udoubleacute = 0x1db +xK_Tcedilla :: KeyVal +xK_Tcedilla = 0x1de +xK_racute :: KeyVal +xK_racute = 0x1e0 +xK_abreve :: KeyVal +xK_abreve = 0x1e3 +xK_lacute :: KeyVal +xK_lacute = 0x1e5 +xK_cacute :: KeyVal +xK_cacute = 0x1e6 +xK_ccaron :: KeyVal +xK_ccaron = 0x1e8 +xK_eogonek :: KeyVal +xK_eogonek = 0x1ea +xK_ecaron :: KeyVal +xK_ecaron = 0x1ec +xK_dcaron :: KeyVal +xK_dcaron = 0x1ef +xK_dstroke :: KeyVal +xK_dstroke = 0x1f0 +xK_nacute :: KeyVal +xK_nacute = 0x1f1 +xK_ncaron :: KeyVal +xK_ncaron = 0x1f2 +xK_odoubleacute :: KeyVal +xK_odoubleacute = 0x1f5 +xK_rcaron :: KeyVal +xK_rcaron = 0x1f8 +xK_uring :: KeyVal +xK_uring = 0x1f9 +xK_udoubleacute :: KeyVal +xK_udoubleacute = 0x1fb +xK_tcedilla :: KeyVal +xK_tcedilla = 0x1fe +xK_abovedot :: KeyVal +xK_abovedot = 0x1ff +xK_Hstroke :: KeyVal +xK_Hstroke = 0x2a1 +xK_Hcircumflex :: KeyVal +xK_Hcircumflex = 0x2a6 +xK_Iabovedot :: KeyVal +xK_Iabovedot = 0x2a9 +xK_Gbreve :: KeyVal +xK_Gbreve = 0x2ab +xK_Jcircumflex :: KeyVal +xK_Jcircumflex = 0x2ac +xK_hstroke :: KeyVal +xK_hstroke = 0x2b1 +xK_hcircumflex :: KeyVal +xK_hcircumflex = 0x2b6 +xK_idotless :: KeyVal +xK_idotless = 0x2b9 +xK_gbreve :: KeyVal +xK_gbreve = 0x2bb +xK_jcircumflex :: KeyVal +xK_jcircumflex = 0x2bc +xK_Cabovedot :: KeyVal +xK_Cabovedot = 0x2c5 +xK_Ccircumflex :: KeyVal +xK_Ccircumflex = 0x2c6 +xK_Gabovedot :: KeyVal +xK_Gabovedot = 0x2d5 +xK_Gcircumflex :: KeyVal +xK_Gcircumflex = 0x2d8 +xK_Ubreve :: KeyVal +xK_Ubreve = 0x2dd +xK_Scircumflex :: KeyVal +xK_Scircumflex = 0x2de +xK_cabovedot :: KeyVal +xK_cabovedot = 0x2e5 +xK_ccircumflex :: KeyVal +xK_ccircumflex = 0x2e6 +xK_gabovedot :: KeyVal +xK_gabovedot = 0x2f5 +xK_gcircumflex :: KeyVal +xK_gcircumflex = 0x2f8 +xK_ubreve :: KeyVal +xK_ubreve = 0x2fd +xK_scircumflex :: KeyVal +xK_scircumflex = 0x2fe +xK_kra :: KeyVal +xK_kra = 0x3a2 +xK_kappa :: KeyVal +xK_kappa = 0x3a2 +xK_Rcedilla :: KeyVal +xK_Rcedilla = 0x3a3 +xK_Itilde :: KeyVal +xK_Itilde = 0x3a5 +xK_Lcedilla :: KeyVal +xK_Lcedilla = 0x3a6 +xK_Emacron :: KeyVal +xK_Emacron = 0x3aa +xK_Gcedilla :: KeyVal +xK_Gcedilla = 0x3ab +xK_Tslash :: KeyVal +xK_Tslash = 0x3ac +xK_rcedilla :: KeyVal +xK_rcedilla = 0x3b3 +xK_itilde :: KeyVal +xK_itilde = 0x3b5 +xK_lcedilla :: KeyVal +xK_lcedilla = 0x3b6 +xK_emacron :: KeyVal +xK_emacron = 0x3ba +xK_gcedilla :: KeyVal +xK_gcedilla = 0x3bb +xK_tslash :: KeyVal +xK_tslash = 0x3bc +xK_ENG :: KeyVal +xK_ENG = 0x3bd +xK_eng :: KeyVal +xK_eng = 0x3bf +xK_Amacron :: KeyVal +xK_Amacron = 0x3c0 +xK_Iogonek :: KeyVal +xK_Iogonek = 0x3c7 +xK_Eabovedot :: KeyVal +xK_Eabovedot = 0x3cc +xK_Imacron :: KeyVal +xK_Imacron = 0x3cf +xK_Ncedilla :: KeyVal +xK_Ncedilla = 0x3d1 +xK_Omacron :: KeyVal +xK_Omacron = 0x3d2 +xK_Kcedilla :: KeyVal +xK_Kcedilla = 0x3d3 +xK_Uogonek :: KeyVal +xK_Uogonek = 0x3d9 +xK_Utilde :: KeyVal +xK_Utilde = 0x3dd +xK_Umacron :: KeyVal +xK_Umacron = 0x3de +xK_amacron :: KeyVal +xK_amacron = 0x3e0 +xK_iogonek :: KeyVal +xK_iogonek = 0x3e7 +xK_eabovedot :: KeyVal +xK_eabovedot = 0x3ec +xK_imacron :: KeyVal +xK_imacron = 0x3ef +xK_ncedilla :: KeyVal +xK_ncedilla = 0x3f1 +xK_omacron :: KeyVal +xK_omacron = 0x3f2 +xK_kcedilla :: KeyVal +xK_kcedilla = 0x3f3 +xK_uogonek :: KeyVal +xK_uogonek = 0x3f9 +xK_utilde :: KeyVal +xK_utilde = 0x3fd +xK_umacron :: KeyVal +xK_umacron = 0x3fe +xK_Wcircumflex :: KeyVal +xK_Wcircumflex = 0x1000174 +xK_wcircumflex :: KeyVal +xK_wcircumflex = 0x1000175 +xK_Ycircumflex :: KeyVal +xK_Ycircumflex = 0x1000176 +xK_ycircumflex :: KeyVal +xK_ycircumflex = 0x1000177 +xK_Babovedot :: KeyVal +xK_Babovedot = 0x1001e02 +xK_babovedot :: KeyVal +xK_babovedot = 0x1001e03 +xK_Dabovedot :: KeyVal +xK_Dabovedot = 0x1001e0a +xK_dabovedot :: KeyVal +xK_dabovedot = 0x1001e0b +xK_Fabovedot :: KeyVal +xK_Fabovedot = 0x1001e1e +xK_fabovedot :: KeyVal +xK_fabovedot = 0x1001e1f +xK_Mabovedot :: KeyVal +xK_Mabovedot = 0x1001e40 +xK_mabovedot :: KeyVal +xK_mabovedot = 0x1001e41 +xK_Pabovedot :: KeyVal +xK_Pabovedot = 0x1001e56 +xK_pabovedot :: KeyVal +xK_pabovedot = 0x1001e57 +xK_Sabovedot :: KeyVal +xK_Sabovedot = 0x1001e60 +xK_sabovedot :: KeyVal +xK_sabovedot = 0x1001e61 +xK_Tabovedot :: KeyVal +xK_Tabovedot = 0x1001e6a +xK_tabovedot :: KeyVal +xK_tabovedot = 0x1001e6b +xK_Wgrave :: KeyVal +xK_Wgrave = 0x1001e80 +xK_wgrave :: KeyVal +xK_wgrave = 0x1001e81 +xK_Wacute :: KeyVal +xK_Wacute = 0x1001e82 +xK_wacute :: KeyVal +xK_wacute = 0x1001e83 +xK_Wdiaeresis :: KeyVal +xK_Wdiaeresis = 0x1001e84 +xK_wdiaeresis :: KeyVal +xK_wdiaeresis = 0x1001e85 +xK_Ygrave :: KeyVal +xK_Ygrave = 0x1001ef2 +xK_ygrave :: KeyVal +xK_ygrave = 0x1001ef3 +xK_OE :: KeyVal +xK_OE = 0x13bc +xK_oe :: KeyVal +xK_oe = 0x13bd +xK_Ydiaeresis :: KeyVal +xK_Ydiaeresis = 0x13be +xK_overline :: KeyVal +xK_overline = 0x47e +xK_kana_fullstop :: KeyVal +xK_kana_fullstop = 0x4a1 +xK_kana_openingbracket :: KeyVal +xK_kana_openingbracket = 0x4a2 +xK_kana_closingbracket :: KeyVal +xK_kana_closingbracket = 0x4a3 +xK_kana_comma :: KeyVal +xK_kana_comma = 0x4a4 +xK_kana_conjunctive :: KeyVal +xK_kana_conjunctive = 0x4a5 +xK_kana_middledot :: KeyVal +xK_kana_middledot = 0x4a5 +xK_kana_WO :: KeyVal +xK_kana_WO = 0x4a6 +xK_kana_a :: KeyVal +xK_kana_a = 0x4a7 +xK_kana_i :: KeyVal +xK_kana_i = 0x4a8 +xK_kana_u :: KeyVal +xK_kana_u = 0x4a9 +xK_kana_e :: KeyVal +xK_kana_e = 0x4aa +xK_kana_o :: KeyVal +xK_kana_o = 0x4ab +xK_kana_ya :: KeyVal +xK_kana_ya = 0x4ac +xK_kana_yu :: KeyVal +xK_kana_yu = 0x4ad +xK_kana_yo :: KeyVal +xK_kana_yo = 0x4ae +xK_kana_tsu :: KeyVal +xK_kana_tsu = 0x4af +xK_kana_tu :: KeyVal +xK_kana_tu = 0x4af +xK_prolongedsound :: KeyVal +xK_prolongedsound = 0x4b0 +xK_kana_A :: KeyVal +xK_kana_A = 0x4b1 +xK_kana_I :: KeyVal +xK_kana_I = 0x4b2 +xK_kana_U :: KeyVal +xK_kana_U = 0x4b3 +xK_kana_E :: KeyVal +xK_kana_E = 0x4b4 +xK_kana_O :: KeyVal +xK_kana_O = 0x4b5 +xK_kana_KA :: KeyVal +xK_kana_KA = 0x4b6 +xK_kana_KI :: KeyVal +xK_kana_KI = 0x4b7 +xK_kana_KU :: KeyVal +xK_kana_KU = 0x4b8 +xK_kana_KE :: KeyVal +xK_kana_KE = 0x4b9 +xK_kana_KO :: KeyVal +xK_kana_KO = 0x4ba +xK_kana_SA :: KeyVal +xK_kana_SA = 0x4bb +xK_kana_SHI :: KeyVal +xK_kana_SHI = 0x4bc +xK_kana_SU :: KeyVal +xK_kana_SU = 0x4bd +xK_kana_SE :: KeyVal +xK_kana_SE = 0x4be +xK_kana_SO :: KeyVal +xK_kana_SO = 0x4bf +xK_kana_TA :: KeyVal +xK_kana_TA = 0x4c0 +xK_kana_CHI :: KeyVal +xK_kana_CHI = 0x4c1 +xK_kana_TI :: KeyVal +xK_kana_TI = 0x4c1 +xK_kana_TSU :: KeyVal +xK_kana_TSU = 0x4c2 +xK_kana_TU :: KeyVal +xK_kana_TU = 0x4c2 +xK_kana_TE :: KeyVal +xK_kana_TE = 0x4c3 +xK_kana_TO :: KeyVal +xK_kana_TO = 0x4c4 +xK_kana_NA :: KeyVal +xK_kana_NA = 0x4c5 +xK_kana_NI :: KeyVal +xK_kana_NI = 0x4c6 +xK_kana_NU :: KeyVal +xK_kana_NU = 0x4c7 +xK_kana_NE :: KeyVal +xK_kana_NE = 0x4c8 +xK_kana_NO :: KeyVal +xK_kana_NO = 0x4c9 +xK_kana_HA :: KeyVal +xK_kana_HA = 0x4ca +xK_kana_HI :: KeyVal +xK_kana_HI = 0x4cb +xK_kana_FU :: KeyVal +xK_kana_FU = 0x4cc +xK_kana_HU :: KeyVal +xK_kana_HU = 0x4cc +xK_kana_HE :: KeyVal +xK_kana_HE = 0x4cd +xK_kana_HO :: KeyVal +xK_kana_HO = 0x4ce +xK_kana_MA :: KeyVal +xK_kana_MA = 0x4cf +xK_kana_MI :: KeyVal +xK_kana_MI = 0x4d0 +xK_kana_MU :: KeyVal +xK_kana_MU = 0x4d1 +xK_kana_ME :: KeyVal +xK_kana_ME = 0x4d2 +xK_kana_MO :: KeyVal +xK_kana_MO = 0x4d3 +xK_kana_YA :: KeyVal +xK_kana_YA = 0x4d4 +xK_kana_YU :: KeyVal +xK_kana_YU = 0x4d5 +xK_kana_YO :: KeyVal +xK_kana_YO = 0x4d6 +xK_kana_RA :: KeyVal +xK_kana_RA = 0x4d7 +xK_kana_RI :: KeyVal +xK_kana_RI = 0x4d8 +xK_kana_RU :: KeyVal +xK_kana_RU = 0x4d9 +xK_kana_RE :: KeyVal +xK_kana_RE = 0x4da +xK_kana_RO :: KeyVal +xK_kana_RO = 0x4db +xK_kana_WA :: KeyVal +xK_kana_WA = 0x4dc +xK_kana_N :: KeyVal +xK_kana_N = 0x4dd +xK_voicedsound :: KeyVal +xK_voicedsound = 0x4de +xK_semivoicedsound :: KeyVal +xK_semivoicedsound = 0x4df +xK_kana_switch :: KeyVal +xK_kana_switch = 0xff7e +xK_Farsi_0 :: KeyVal +xK_Farsi_0 = 0x10006f0 +xK_Farsi_1 :: KeyVal +xK_Farsi_1 = 0x10006f1 +xK_Farsi_2 :: KeyVal +xK_Farsi_2 = 0x10006f2 +xK_Farsi_3 :: KeyVal +xK_Farsi_3 = 0x10006f3 +xK_Farsi_4 :: KeyVal +xK_Farsi_4 = 0x10006f4 +xK_Farsi_5 :: KeyVal +xK_Farsi_5 = 0x10006f5 +xK_Farsi_6 :: KeyVal +xK_Farsi_6 = 0x10006f6 +xK_Farsi_7 :: KeyVal +xK_Farsi_7 = 0x10006f7 +xK_Farsi_8 :: KeyVal +xK_Farsi_8 = 0x10006f8 +xK_Farsi_9 :: KeyVal +xK_Farsi_9 = 0x10006f9 +xK_Arabic_percent :: KeyVal +xK_Arabic_percent = 0x100066a +xK_Arabic_superscript_alef :: KeyVal +xK_Arabic_superscript_alef = 0x1000670 +xK_Arabic_tteh :: KeyVal +xK_Arabic_tteh = 0x1000679 +xK_Arabic_peh :: KeyVal +xK_Arabic_peh = 0x100067e +xK_Arabic_tcheh :: KeyVal +xK_Arabic_tcheh = 0x1000686 +xK_Arabic_ddal :: KeyVal +xK_Arabic_ddal = 0x1000688 +xK_Arabic_rreh :: KeyVal +xK_Arabic_rreh = 0x1000691 +xK_Arabic_comma :: KeyVal +xK_Arabic_comma = 0x5ac +xK_Arabic_fullstop :: KeyVal +xK_Arabic_fullstop = 0x10006d4 +xK_Arabic_0 :: KeyVal +xK_Arabic_0 = 0x1000660 +xK_Arabic_1 :: KeyVal +xK_Arabic_1 = 0x1000661 +xK_Arabic_2 :: KeyVal +xK_Arabic_2 = 0x1000662 +xK_Arabic_3 :: KeyVal +xK_Arabic_3 = 0x1000663 +xK_Arabic_4 :: KeyVal +xK_Arabic_4 = 0x1000664 +xK_Arabic_5 :: KeyVal +xK_Arabic_5 = 0x1000665 +xK_Arabic_6 :: KeyVal +xK_Arabic_6 = 0x1000666 +xK_Arabic_7 :: KeyVal +xK_Arabic_7 = 0x1000667 +xK_Arabic_8 :: KeyVal +xK_Arabic_8 = 0x1000668 +xK_Arabic_9 :: KeyVal +xK_Arabic_9 = 0x1000669 +xK_Arabic_semicolon :: KeyVal +xK_Arabic_semicolon = 0x5bb +xK_Arabic_question_mark :: KeyVal +xK_Arabic_question_mark = 0x5bf +xK_Arabic_hamza :: KeyVal +xK_Arabic_hamza = 0x5c1 +xK_Arabic_maddaonalef :: KeyVal +xK_Arabic_maddaonalef = 0x5c2 +xK_Arabic_hamzaonalef :: KeyVal +xK_Arabic_hamzaonalef = 0x5c3 +xK_Arabic_hamzaonwaw :: KeyVal +xK_Arabic_hamzaonwaw = 0x5c4 +xK_Arabic_hamzaunderalef :: KeyVal +xK_Arabic_hamzaunderalef = 0x5c5 +xK_Arabic_hamzaonyeh :: KeyVal +xK_Arabic_hamzaonyeh = 0x5c6 +xK_Arabic_alef :: KeyVal +xK_Arabic_alef = 0x5c7 +xK_Arabic_beh :: KeyVal +xK_Arabic_beh = 0x5c8 +xK_Arabic_tehmarbuta :: KeyVal +xK_Arabic_tehmarbuta = 0x5c9 +xK_Arabic_teh :: KeyVal +xK_Arabic_teh = 0x5ca +xK_Arabic_theh :: KeyVal +xK_Arabic_theh = 0x5cb +xK_Arabic_jeem :: KeyVal +xK_Arabic_jeem = 0x5cc +xK_Arabic_hah :: KeyVal +xK_Arabic_hah = 0x5cd +xK_Arabic_khah :: KeyVal +xK_Arabic_khah = 0x5ce +xK_Arabic_dal :: KeyVal +xK_Arabic_dal = 0x5cf +xK_Arabic_thal :: KeyVal +xK_Arabic_thal = 0x5d0 +xK_Arabic_ra :: KeyVal +xK_Arabic_ra = 0x5d1 +xK_Arabic_zain :: KeyVal +xK_Arabic_zain = 0x5d2 +xK_Arabic_seen :: KeyVal +xK_Arabic_seen = 0x5d3 +xK_Arabic_sheen :: KeyVal +xK_Arabic_sheen = 0x5d4 +xK_Arabic_sad :: KeyVal +xK_Arabic_sad = 0x5d5 +xK_Arabic_dad :: KeyVal +xK_Arabic_dad = 0x5d6 +xK_Arabic_tah :: KeyVal +xK_Arabic_tah = 0x5d7 +xK_Arabic_zah :: KeyVal +xK_Arabic_zah = 0x5d8 +xK_Arabic_ain :: KeyVal +xK_Arabic_ain = 0x5d9 +xK_Arabic_ghain :: KeyVal +xK_Arabic_ghain = 0x5da +xK_Arabic_tatweel :: KeyVal +xK_Arabic_tatweel = 0x5e0 +xK_Arabic_feh :: KeyVal +xK_Arabic_feh = 0x5e1 +xK_Arabic_qaf :: KeyVal +xK_Arabic_qaf = 0x5e2 +xK_Arabic_kaf :: KeyVal +xK_Arabic_kaf = 0x5e3 +xK_Arabic_lam :: KeyVal +xK_Arabic_lam = 0x5e4 +xK_Arabic_meem :: KeyVal +xK_Arabic_meem = 0x5e5 +xK_Arabic_noon :: KeyVal +xK_Arabic_noon = 0x5e6 +xK_Arabic_ha :: KeyVal +xK_Arabic_ha = 0x5e7 +xK_Arabic_heh :: KeyVal +xK_Arabic_heh = 0x5e7 +xK_Arabic_waw :: KeyVal +xK_Arabic_waw = 0x5e8 +xK_Arabic_alefmaksura :: KeyVal +xK_Arabic_alefmaksura = 0x5e9 +xK_Arabic_yeh :: KeyVal +xK_Arabic_yeh = 0x5ea +xK_Arabic_fathatan :: KeyVal +xK_Arabic_fathatan = 0x5eb +xK_Arabic_dammatan :: KeyVal +xK_Arabic_dammatan = 0x5ec +xK_Arabic_kasratan :: KeyVal +xK_Arabic_kasratan = 0x5ed +xK_Arabic_fatha :: KeyVal +xK_Arabic_fatha = 0x5ee +xK_Arabic_damma :: KeyVal +xK_Arabic_damma = 0x5ef +xK_Arabic_kasra :: KeyVal +xK_Arabic_kasra = 0x5f0 +xK_Arabic_shadda :: KeyVal +xK_Arabic_shadda = 0x5f1 +xK_Arabic_sukun :: KeyVal +xK_Arabic_sukun = 0x5f2 +xK_Arabic_madda_above :: KeyVal +xK_Arabic_madda_above = 0x1000653 +xK_Arabic_hamza_above :: KeyVal +xK_Arabic_hamza_above = 0x1000654 +xK_Arabic_hamza_below :: KeyVal +xK_Arabic_hamza_below = 0x1000655 +xK_Arabic_jeh :: KeyVal +xK_Arabic_jeh = 0x1000698 +xK_Arabic_veh :: KeyVal +xK_Arabic_veh = 0x10006a4 +xK_Arabic_keheh :: KeyVal +xK_Arabic_keheh = 0x10006a9 +xK_Arabic_gaf :: KeyVal +xK_Arabic_gaf = 0x10006af +xK_Arabic_noon_ghunna :: KeyVal +xK_Arabic_noon_ghunna = 0x10006ba +xK_Arabic_heh_doachashmee :: KeyVal +xK_Arabic_heh_doachashmee = 0x10006be +xK_Farsi_yeh :: KeyVal +xK_Farsi_yeh = 0x10006cc +xK_Arabic_farsi_yeh :: KeyVal +xK_Arabic_farsi_yeh = 0x10006cc +xK_Arabic_yeh_baree :: KeyVal +xK_Arabic_yeh_baree = 0x10006d2 +xK_Arabic_heh_goal :: KeyVal +xK_Arabic_heh_goal = 0x10006c1 +xK_Arabic_switch :: KeyVal +xK_Arabic_switch = 0xff7e +xK_Cyrillic_GHE_bar :: KeyVal +xK_Cyrillic_GHE_bar = 0x1000492 +xK_Cyrillic_ghe_bar :: KeyVal +xK_Cyrillic_ghe_bar = 0x1000493 +xK_Cyrillic_ZHE_descender :: KeyVal +xK_Cyrillic_ZHE_descender = 0x1000496 +xK_Cyrillic_zhe_descender :: KeyVal +xK_Cyrillic_zhe_descender = 0x1000497 +xK_Cyrillic_KA_descender :: KeyVal +xK_Cyrillic_KA_descender = 0x100049a +xK_Cyrillic_ka_descender :: KeyVal +xK_Cyrillic_ka_descender = 0x100049b +xK_Cyrillic_KA_vertstroke :: KeyVal +xK_Cyrillic_KA_vertstroke = 0x100049c +xK_Cyrillic_ka_vertstroke :: KeyVal +xK_Cyrillic_ka_vertstroke = 0x100049d +xK_Cyrillic_EN_descender :: KeyVal +xK_Cyrillic_EN_descender = 0x10004a2 +xK_Cyrillic_en_descender :: KeyVal +xK_Cyrillic_en_descender = 0x10004a3 +xK_Cyrillic_U_straight :: KeyVal +xK_Cyrillic_U_straight = 0x10004ae +xK_Cyrillic_u_straight :: KeyVal +xK_Cyrillic_u_straight = 0x10004af +xK_Cyrillic_U_straight_bar :: KeyVal +xK_Cyrillic_U_straight_bar = 0x10004b0 +xK_Cyrillic_u_straight_bar :: KeyVal +xK_Cyrillic_u_straight_bar = 0x10004b1 +xK_Cyrillic_HA_descender :: KeyVal +xK_Cyrillic_HA_descender = 0x10004b2 +xK_Cyrillic_ha_descender :: KeyVal +xK_Cyrillic_ha_descender = 0x10004b3 +xK_Cyrillic_CHE_descender :: KeyVal +xK_Cyrillic_CHE_descender = 0x10004b6 +xK_Cyrillic_che_descender :: KeyVal +xK_Cyrillic_che_descender = 0x10004b7 +xK_Cyrillic_CHE_vertstroke :: KeyVal +xK_Cyrillic_CHE_vertstroke = 0x10004b8 +xK_Cyrillic_che_vertstroke :: KeyVal +xK_Cyrillic_che_vertstroke = 0x10004b9 +xK_Cyrillic_SHHA :: KeyVal +xK_Cyrillic_SHHA = 0x10004ba +xK_Cyrillic_shha :: KeyVal +xK_Cyrillic_shha = 0x10004bb +xK_Cyrillic_SCHWA :: KeyVal +xK_Cyrillic_SCHWA = 0x10004d8 +xK_Cyrillic_schwa :: KeyVal +xK_Cyrillic_schwa = 0x10004d9 +xK_Cyrillic_I_macron :: KeyVal +xK_Cyrillic_I_macron = 0x10004e2 +xK_Cyrillic_i_macron :: KeyVal +xK_Cyrillic_i_macron = 0x10004e3 +xK_Cyrillic_O_bar :: KeyVal +xK_Cyrillic_O_bar = 0x10004e8 +xK_Cyrillic_o_bar :: KeyVal +xK_Cyrillic_o_bar = 0x10004e9 +xK_Cyrillic_U_macron :: KeyVal +xK_Cyrillic_U_macron = 0x10004ee +xK_Cyrillic_u_macron :: KeyVal +xK_Cyrillic_u_macron = 0x10004ef +xK_Serbian_dje :: KeyVal +xK_Serbian_dje = 0x6a1 +xK_Macedonia_gje :: KeyVal +xK_Macedonia_gje = 0x6a2 +xK_Cyrillic_io :: KeyVal +xK_Cyrillic_io = 0x6a3 +xK_Ukrainian_ie :: KeyVal +xK_Ukrainian_ie = 0x6a4 +xK_Ukranian_je :: KeyVal +xK_Ukranian_je = 0x6a4 +xK_Macedonia_dse :: KeyVal +xK_Macedonia_dse = 0x6a5 +xK_Ukrainian_i :: KeyVal +xK_Ukrainian_i = 0x6a6 +xK_Ukranian_i :: KeyVal +xK_Ukranian_i = 0x6a6 +xK_Ukrainian_yi :: KeyVal +xK_Ukrainian_yi = 0x6a7 +xK_Ukranian_yi :: KeyVal +xK_Ukranian_yi = 0x6a7 +xK_Cyrillic_je :: KeyVal +xK_Cyrillic_je = 0x6a8 +xK_Serbian_je :: KeyVal +xK_Serbian_je = 0x6a8 +xK_Cyrillic_lje :: KeyVal +xK_Cyrillic_lje = 0x6a9 +xK_Serbian_lje :: KeyVal +xK_Serbian_lje = 0x6a9 +xK_Cyrillic_nje :: KeyVal +xK_Cyrillic_nje = 0x6aa +xK_Serbian_nje :: KeyVal +xK_Serbian_nje = 0x6aa +xK_Serbian_tshe :: KeyVal +xK_Serbian_tshe = 0x6ab +xK_Macedonia_kje :: KeyVal +xK_Macedonia_kje = 0x6ac +xK_Ukrainian_ghe_with_upturn :: KeyVal +xK_Ukrainian_ghe_with_upturn = 0x6ad +xK_Byelorussian_shortu :: KeyVal +xK_Byelorussian_shortu = 0x6ae +xK_Cyrillic_dzhe :: KeyVal +xK_Cyrillic_dzhe = 0x6af +xK_Serbian_dze :: KeyVal +xK_Serbian_dze = 0x6af +xK_numerosign :: KeyVal +xK_numerosign = 0x6b0 +xK_Serbian_DJE :: KeyVal +xK_Serbian_DJE = 0x6b1 +xK_Macedonia_GJE :: KeyVal +xK_Macedonia_GJE = 0x6b2 +xK_Cyrillic_IO :: KeyVal +xK_Cyrillic_IO = 0x6b3 +xK_Ukrainian_IE :: KeyVal +xK_Ukrainian_IE = 0x6b4 +xK_Ukranian_JE :: KeyVal +xK_Ukranian_JE = 0x6b4 +xK_Macedonia_DSE :: KeyVal +xK_Macedonia_DSE = 0x6b5 +xK_Ukrainian_I :: KeyVal +xK_Ukrainian_I = 0x6b6 +xK_Ukranian_I :: KeyVal +xK_Ukranian_I = 0x6b6 +xK_Ukrainian_YI :: KeyVal +xK_Ukrainian_YI = 0x6b7 +xK_Ukranian_YI :: KeyVal +xK_Ukranian_YI = 0x6b7 +xK_Cyrillic_JE :: KeyVal +xK_Cyrillic_JE = 0x6b8 +xK_Serbian_JE :: KeyVal +xK_Serbian_JE = 0x6b8 +xK_Cyrillic_LJE :: KeyVal +xK_Cyrillic_LJE = 0x6b9 +xK_Serbian_LJE :: KeyVal +xK_Serbian_LJE = 0x6b9 +xK_Cyrillic_NJE :: KeyVal +xK_Cyrillic_NJE = 0x6ba +xK_Serbian_NJE :: KeyVal +xK_Serbian_NJE = 0x6ba +xK_Serbian_TSHE :: KeyVal +xK_Serbian_TSHE = 0x6bb +xK_Macedonia_KJE :: KeyVal +xK_Macedonia_KJE = 0x6bc +xK_Ukrainian_GHE_WITH_UPTURN :: KeyVal +xK_Ukrainian_GHE_WITH_UPTURN = 0x6bd +xK_Byelorussian_SHORTU :: KeyVal +xK_Byelorussian_SHORTU = 0x6be +xK_Cyrillic_DZHE :: KeyVal +xK_Cyrillic_DZHE = 0x6bf +xK_Serbian_DZE :: KeyVal +xK_Serbian_DZE = 0x6bf +xK_Cyrillic_yu :: KeyVal +xK_Cyrillic_yu = 0x6c0 +xK_Cyrillic_a :: KeyVal +xK_Cyrillic_a = 0x6c1 +xK_Cyrillic_be :: KeyVal +xK_Cyrillic_be = 0x6c2 +xK_Cyrillic_tse :: KeyVal +xK_Cyrillic_tse = 0x6c3 +xK_Cyrillic_de :: KeyVal +xK_Cyrillic_de = 0x6c4 +xK_Cyrillic_ie :: KeyVal +xK_Cyrillic_ie = 0x6c5 +xK_Cyrillic_ef :: KeyVal +xK_Cyrillic_ef = 0x6c6 +xK_Cyrillic_ghe :: KeyVal +xK_Cyrillic_ghe = 0x6c7 +xK_Cyrillic_ha :: KeyVal +xK_Cyrillic_ha = 0x6c8 +xK_Cyrillic_i :: KeyVal +xK_Cyrillic_i = 0x6c9 +xK_Cyrillic_shorti :: KeyVal +xK_Cyrillic_shorti = 0x6ca +xK_Cyrillic_ka :: KeyVal +xK_Cyrillic_ka = 0x6cb +xK_Cyrillic_el :: KeyVal +xK_Cyrillic_el = 0x6cc +xK_Cyrillic_em :: KeyVal +xK_Cyrillic_em = 0x6cd +xK_Cyrillic_en :: KeyVal +xK_Cyrillic_en = 0x6ce +xK_Cyrillic_o :: KeyVal +xK_Cyrillic_o = 0x6cf +xK_Cyrillic_pe :: KeyVal +xK_Cyrillic_pe = 0x6d0 +xK_Cyrillic_ya :: KeyVal +xK_Cyrillic_ya = 0x6d1 +xK_Cyrillic_er :: KeyVal +xK_Cyrillic_er = 0x6d2 +xK_Cyrillic_es :: KeyVal +xK_Cyrillic_es = 0x6d3 +xK_Cyrillic_te :: KeyVal +xK_Cyrillic_te = 0x6d4 +xK_Cyrillic_u :: KeyVal +xK_Cyrillic_u = 0x6d5 +xK_Cyrillic_zhe :: KeyVal +xK_Cyrillic_zhe = 0x6d6 +xK_Cyrillic_ve :: KeyVal +xK_Cyrillic_ve = 0x6d7 +xK_Cyrillic_softsign :: KeyVal +xK_Cyrillic_softsign = 0x6d8 +xK_Cyrillic_yeru :: KeyVal +xK_Cyrillic_yeru = 0x6d9 +xK_Cyrillic_ze :: KeyVal +xK_Cyrillic_ze = 0x6da +xK_Cyrillic_sha :: KeyVal +xK_Cyrillic_sha = 0x6db +xK_Cyrillic_e :: KeyVal +xK_Cyrillic_e = 0x6dc +xK_Cyrillic_shcha :: KeyVal +xK_Cyrillic_shcha = 0x6dd +xK_Cyrillic_che :: KeyVal +xK_Cyrillic_che = 0x6de +xK_Cyrillic_hardsign :: KeyVal +xK_Cyrillic_hardsign = 0x6df +xK_Cyrillic_YU :: KeyVal +xK_Cyrillic_YU = 0x6e0 +xK_Cyrillic_A :: KeyVal +xK_Cyrillic_A = 0x6e1 +xK_Cyrillic_BE :: KeyVal +xK_Cyrillic_BE = 0x6e2 +xK_Cyrillic_TSE :: KeyVal +xK_Cyrillic_TSE = 0x6e3 +xK_Cyrillic_DE :: KeyVal +xK_Cyrillic_DE = 0x6e4 +xK_Cyrillic_IE :: KeyVal +xK_Cyrillic_IE = 0x6e5 +xK_Cyrillic_EF :: KeyVal +xK_Cyrillic_EF = 0x6e6 +xK_Cyrillic_GHE :: KeyVal +xK_Cyrillic_GHE = 0x6e7 +xK_Cyrillic_HA :: KeyVal +xK_Cyrillic_HA = 0x6e8 +xK_Cyrillic_I :: KeyVal +xK_Cyrillic_I = 0x6e9 +xK_Cyrillic_SHORTI :: KeyVal +xK_Cyrillic_SHORTI = 0x6ea +xK_Cyrillic_KA :: KeyVal +xK_Cyrillic_KA = 0x6eb +xK_Cyrillic_EL :: KeyVal +xK_Cyrillic_EL = 0x6ec +xK_Cyrillic_EM :: KeyVal +xK_Cyrillic_EM = 0x6ed +xK_Cyrillic_EN :: KeyVal +xK_Cyrillic_EN = 0x6ee +xK_Cyrillic_O :: KeyVal +xK_Cyrillic_O = 0x6ef +xK_Cyrillic_PE :: KeyVal +xK_Cyrillic_PE = 0x6f0 +xK_Cyrillic_YA :: KeyVal +xK_Cyrillic_YA = 0x6f1 +xK_Cyrillic_ER :: KeyVal +xK_Cyrillic_ER = 0x6f2 +xK_Cyrillic_ES :: KeyVal +xK_Cyrillic_ES = 0x6f3 +xK_Cyrillic_TE :: KeyVal +xK_Cyrillic_TE = 0x6f4 +xK_Cyrillic_U :: KeyVal +xK_Cyrillic_U = 0x6f5 +xK_Cyrillic_ZHE :: KeyVal +xK_Cyrillic_ZHE = 0x6f6 +xK_Cyrillic_VE :: KeyVal +xK_Cyrillic_VE = 0x6f7 +xK_Cyrillic_SOFTSIGN :: KeyVal +xK_Cyrillic_SOFTSIGN = 0x6f8 +xK_Cyrillic_YERU :: KeyVal +xK_Cyrillic_YERU = 0x6f9 +xK_Cyrillic_ZE :: KeyVal +xK_Cyrillic_ZE = 0x6fa +xK_Cyrillic_SHA :: KeyVal +xK_Cyrillic_SHA = 0x6fb +xK_Cyrillic_E :: KeyVal +xK_Cyrillic_E = 0x6fc +xK_Cyrillic_SHCHA :: KeyVal +xK_Cyrillic_SHCHA = 0x6fd +xK_Cyrillic_CHE :: KeyVal +xK_Cyrillic_CHE = 0x6fe +xK_Cyrillic_HARDSIGN :: KeyVal +xK_Cyrillic_HARDSIGN = 0x6ff +xK_Greek_ALPHAaccent :: KeyVal +xK_Greek_ALPHAaccent = 0x7a1 +xK_Greek_EPSILONaccent :: KeyVal +xK_Greek_EPSILONaccent = 0x7a2 +xK_Greek_ETAaccent :: KeyVal +xK_Greek_ETAaccent = 0x7a3 +xK_Greek_IOTAaccent :: KeyVal +xK_Greek_IOTAaccent = 0x7a4 +xK_Greek_IOTAdieresis :: KeyVal +xK_Greek_IOTAdieresis = 0x7a5 +xK_Greek_IOTAdiaeresis :: KeyVal +xK_Greek_IOTAdiaeresis = 0x7a5 +xK_Greek_OMICRONaccent :: KeyVal +xK_Greek_OMICRONaccent = 0x7a7 +xK_Greek_UPSILONaccent :: KeyVal +xK_Greek_UPSILONaccent = 0x7a8 +xK_Greek_UPSILONdieresis :: KeyVal +xK_Greek_UPSILONdieresis = 0x7a9 +xK_Greek_OMEGAaccent :: KeyVal +xK_Greek_OMEGAaccent = 0x7ab +xK_Greek_accentdieresis :: KeyVal +xK_Greek_accentdieresis = 0x7ae +xK_Greek_horizbar :: KeyVal +xK_Greek_horizbar = 0x7af +xK_Greek_alphaaccent :: KeyVal +xK_Greek_alphaaccent = 0x7b1 +xK_Greek_epsilonaccent :: KeyVal +xK_Greek_epsilonaccent = 0x7b2 +xK_Greek_etaaccent :: KeyVal +xK_Greek_etaaccent = 0x7b3 +xK_Greek_iotaaccent :: KeyVal +xK_Greek_iotaaccent = 0x7b4 +xK_Greek_iotadieresis :: KeyVal +xK_Greek_iotadieresis = 0x7b5 +xK_Greek_iotaaccentdieresis :: KeyVal +xK_Greek_iotaaccentdieresis = 0x7b6 +xK_Greek_omicronaccent :: KeyVal +xK_Greek_omicronaccent = 0x7b7 +xK_Greek_upsilonaccent :: KeyVal +xK_Greek_upsilonaccent = 0x7b8 +xK_Greek_upsilondieresis :: KeyVal +xK_Greek_upsilondieresis = 0x7b9 +xK_Greek_upsilonaccentdieresis :: KeyVal +xK_Greek_upsilonaccentdieresis = 0x7ba +xK_Greek_omegaaccent :: KeyVal +xK_Greek_omegaaccent = 0x7bb +xK_Greek_ALPHA :: KeyVal +xK_Greek_ALPHA = 0x7c1 +xK_Greek_BETA :: KeyVal +xK_Greek_BETA = 0x7c2 +xK_Greek_GAMMA :: KeyVal +xK_Greek_GAMMA = 0x7c3 +xK_Greek_DELTA :: KeyVal +xK_Greek_DELTA = 0x7c4 +xK_Greek_EPSILON :: KeyVal +xK_Greek_EPSILON = 0x7c5 +xK_Greek_ZETA :: KeyVal +xK_Greek_ZETA = 0x7c6 +xK_Greek_ETA :: KeyVal +xK_Greek_ETA = 0x7c7 +xK_Greek_THETA :: KeyVal +xK_Greek_THETA = 0x7c8 +xK_Greek_IOTA :: KeyVal +xK_Greek_IOTA = 0x7c9 +xK_Greek_KAPPA :: KeyVal +xK_Greek_KAPPA = 0x7ca +xK_Greek_LAMDA :: KeyVal +xK_Greek_LAMDA = 0x7cb +xK_Greek_LAMBDA :: KeyVal +xK_Greek_LAMBDA = 0x7cb +xK_Greek_MU :: KeyVal +xK_Greek_MU = 0x7cc +xK_Greek_NU :: KeyVal +xK_Greek_NU = 0x7cd +xK_Greek_XI :: KeyVal +xK_Greek_XI = 0x7ce +xK_Greek_OMICRON :: KeyVal +xK_Greek_OMICRON = 0x7cf +xK_Greek_PI :: KeyVal +xK_Greek_PI = 0x7d0 +xK_Greek_RHO :: KeyVal +xK_Greek_RHO = 0x7d1 +xK_Greek_SIGMA :: KeyVal +xK_Greek_SIGMA = 0x7d2 +xK_Greek_TAU :: KeyVal +xK_Greek_TAU = 0x7d4 +xK_Greek_UPSILON :: KeyVal +xK_Greek_UPSILON = 0x7d5 +xK_Greek_PHI :: KeyVal +xK_Greek_PHI = 0x7d6 +xK_Greek_CHI :: KeyVal +xK_Greek_CHI = 0x7d7 +xK_Greek_PSI :: KeyVal +xK_Greek_PSI = 0x7d8 +xK_Greek_OMEGA :: KeyVal +xK_Greek_OMEGA = 0x7d9 +xK_Greek_alpha :: KeyVal +xK_Greek_alpha = 0x7e1 +xK_Greek_beta :: KeyVal +xK_Greek_beta = 0x7e2 +xK_Greek_gamma :: KeyVal +xK_Greek_gamma = 0x7e3 +xK_Greek_delta :: KeyVal +xK_Greek_delta = 0x7e4 +xK_Greek_epsilon :: KeyVal +xK_Greek_epsilon = 0x7e5 +xK_Greek_zeta :: KeyVal +xK_Greek_zeta = 0x7e6 +xK_Greek_eta :: KeyVal +xK_Greek_eta = 0x7e7 +xK_Greek_theta :: KeyVal +xK_Greek_theta = 0x7e8 +xK_Greek_iota :: KeyVal +xK_Greek_iota = 0x7e9 +xK_Greek_kappa :: KeyVal +xK_Greek_kappa = 0x7ea +xK_Greek_lamda :: KeyVal +xK_Greek_lamda = 0x7eb +xK_Greek_lambda :: KeyVal +xK_Greek_lambda = 0x7eb +xK_Greek_mu :: KeyVal +xK_Greek_mu = 0x7ec +xK_Greek_nu :: KeyVal +xK_Greek_nu = 0x7ed +xK_Greek_xi :: KeyVal +xK_Greek_xi = 0x7ee +xK_Greek_omicron :: KeyVal +xK_Greek_omicron = 0x7ef +xK_Greek_pi :: KeyVal +xK_Greek_pi = 0x7f0 +xK_Greek_rho :: KeyVal +xK_Greek_rho = 0x7f1 +xK_Greek_sigma :: KeyVal +xK_Greek_sigma = 0x7f2 +xK_Greek_finalsmallsigma :: KeyVal +xK_Greek_finalsmallsigma = 0x7f3 +xK_Greek_tau :: KeyVal +xK_Greek_tau = 0x7f4 +xK_Greek_upsilon :: KeyVal +xK_Greek_upsilon = 0x7f5 +xK_Greek_phi :: KeyVal +xK_Greek_phi = 0x7f6 +xK_Greek_chi :: KeyVal +xK_Greek_chi = 0x7f7 +xK_Greek_psi :: KeyVal +xK_Greek_psi = 0x7f8 +xK_Greek_omega :: KeyVal +xK_Greek_omega = 0x7f9 +xK_Greek_switch :: KeyVal +xK_Greek_switch = 0xff7e +xK_leftradical :: KeyVal +xK_leftradical = 0x8a1 +xK_topleftradical :: KeyVal +xK_topleftradical = 0x8a2 +xK_horizconnector :: KeyVal +xK_horizconnector = 0x8a3 +xK_topintegral :: KeyVal +xK_topintegral = 0x8a4 +xK_botintegral :: KeyVal +xK_botintegral = 0x8a5 +xK_vertconnector :: KeyVal +xK_vertconnector = 0x8a6 +xK_topleftsqbracket :: KeyVal +xK_topleftsqbracket = 0x8a7 +xK_botleftsqbracket :: KeyVal +xK_botleftsqbracket = 0x8a8 +xK_toprightsqbracket :: KeyVal +xK_toprightsqbracket = 0x8a9 +xK_botrightsqbracket :: KeyVal +xK_botrightsqbracket = 0x8aa +xK_topleftparens :: KeyVal +xK_topleftparens = 0x8ab +xK_botleftparens :: KeyVal +xK_botleftparens = 0x8ac +xK_toprightparens :: KeyVal +xK_toprightparens = 0x8ad +xK_botrightparens :: KeyVal +xK_botrightparens = 0x8ae +xK_leftmiddlecurlybrace :: KeyVal +xK_leftmiddlecurlybrace = 0x8af +xK_rightmiddlecurlybrace :: KeyVal +xK_rightmiddlecurlybrace = 0x8b0 +xK_topleftsummation :: KeyVal +xK_topleftsummation = 0x8b1 +xK_botleftsummation :: KeyVal +xK_botleftsummation = 0x8b2 +xK_topvertsummationconnector :: KeyVal +xK_topvertsummationconnector = 0x8b3 +xK_botvertsummationconnector :: KeyVal +xK_botvertsummationconnector = 0x8b4 +xK_toprightsummation :: KeyVal +xK_toprightsummation = 0x8b5 +xK_botrightsummation :: KeyVal +xK_botrightsummation = 0x8b6 +xK_rightmiddlesummation :: KeyVal +xK_rightmiddlesummation = 0x8b7 +xK_lessthanequal :: KeyVal +xK_lessthanequal = 0x8bc +xK_notequal :: KeyVal +xK_notequal = 0x8bd +xK_greaterthanequal :: KeyVal +xK_greaterthanequal = 0x8be +xK_integral :: KeyVal +xK_integral = 0x8bf +xK_therefore :: KeyVal +xK_therefore = 0x8c0 +xK_variation :: KeyVal +xK_variation = 0x8c1 +xK_infinity :: KeyVal +xK_infinity = 0x8c2 +xK_nabla :: KeyVal +xK_nabla = 0x8c5 +xK_approximate :: KeyVal +xK_approximate = 0x8c8 +xK_similarequal :: KeyVal +xK_similarequal = 0x8c9 +xK_ifonlyif :: KeyVal +xK_ifonlyif = 0x8cd +xK_implies :: KeyVal +xK_implies = 0x8ce +xK_identical :: KeyVal +xK_identical = 0x8cf +xK_radical :: KeyVal +xK_radical = 0x8d6 +xK_includedin :: KeyVal +xK_includedin = 0x8da +xK_includes :: KeyVal +xK_includes = 0x8db +xK_intersection :: KeyVal +xK_intersection = 0x8dc +xK_union :: KeyVal +xK_union = 0x8dd +xK_logicaland :: KeyVal +xK_logicaland = 0x8de +xK_logicalor :: KeyVal +xK_logicalor = 0x8df +xK_partialderivative :: KeyVal +xK_partialderivative = 0x8ef +xK_function :: KeyVal +xK_function = 0x8f6 +xK_leftarrow :: KeyVal +xK_leftarrow = 0x8fb +xK_uparrow :: KeyVal +xK_uparrow = 0x8fc +xK_rightarrow :: KeyVal +xK_rightarrow = 0x8fd +xK_downarrow :: KeyVal +xK_downarrow = 0x8fe +xK_blank :: KeyVal +xK_blank = 0x9df +xK_soliddiamond :: KeyVal +xK_soliddiamond = 0x9e0 +xK_checkerboard :: KeyVal +xK_checkerboard = 0x9e1 +xK_ht :: KeyVal +xK_ht = 0x9e2 +xK_ff :: KeyVal +xK_ff = 0x9e3 +xK_cr :: KeyVal +xK_cr = 0x9e4 +xK_lf :: KeyVal +xK_lf = 0x9e5 +xK_nl :: KeyVal +xK_nl = 0x9e8 +xK_vt :: KeyVal +xK_vt = 0x9e9 +xK_lowrightcorner :: KeyVal +xK_lowrightcorner = 0x9ea +xK_uprightcorner :: KeyVal +xK_uprightcorner = 0x9eb +xK_upleftcorner :: KeyVal +xK_upleftcorner = 0x9ec +xK_lowleftcorner :: KeyVal +xK_lowleftcorner = 0x9ed +xK_crossinglines :: KeyVal +xK_crossinglines = 0x9ee +xK_horizlinescan1 :: KeyVal +xK_horizlinescan1 = 0x9ef +xK_horizlinescan3 :: KeyVal +xK_horizlinescan3 = 0x9f0 +xK_horizlinescan5 :: KeyVal +xK_horizlinescan5 = 0x9f1 +xK_horizlinescan7 :: KeyVal +xK_horizlinescan7 = 0x9f2 +xK_horizlinescan9 :: KeyVal +xK_horizlinescan9 = 0x9f3 +xK_leftt :: KeyVal +xK_leftt = 0x9f4 +xK_rightt :: KeyVal +xK_rightt = 0x9f5 +xK_bott :: KeyVal +xK_bott = 0x9f6 +xK_topt :: KeyVal +xK_topt = 0x9f7 +xK_vertbar :: KeyVal +xK_vertbar = 0x9f8 +xK_emspace :: KeyVal +xK_emspace = 0xaa1 +xK_enspace :: KeyVal +xK_enspace = 0xaa2 +xK_em3space :: KeyVal +xK_em3space = 0xaa3 +xK_em4space :: KeyVal +xK_em4space = 0xaa4 +xK_digitspace :: KeyVal +xK_digitspace = 0xaa5 +xK_punctspace :: KeyVal +xK_punctspace = 0xaa6 +xK_thinspace :: KeyVal +xK_thinspace = 0xaa7 +xK_hairspace :: KeyVal +xK_hairspace = 0xaa8 +xK_emdash :: KeyVal +xK_emdash = 0xaa9 +xK_endash :: KeyVal +xK_endash = 0xaaa +xK_signifblank :: KeyVal +xK_signifblank = 0xaac +xK_ellipsis :: KeyVal +xK_ellipsis = 0xaae +xK_doubbaselinedot :: KeyVal +xK_doubbaselinedot = 0xaaf +xK_onethird :: KeyVal +xK_onethird = 0xab0 +xK_twothirds :: KeyVal +xK_twothirds = 0xab1 +xK_onefifth :: KeyVal +xK_onefifth = 0xab2 +xK_twofifths :: KeyVal +xK_twofifths = 0xab3 +xK_threefifths :: KeyVal +xK_threefifths = 0xab4 +xK_fourfifths :: KeyVal +xK_fourfifths = 0xab5 +xK_onesixth :: KeyVal +xK_onesixth = 0xab6 +xK_fivesixths :: KeyVal +xK_fivesixths = 0xab7 +xK_careof :: KeyVal +xK_careof = 0xab8 +xK_figdash :: KeyVal +xK_figdash = 0xabb +xK_leftanglebracket :: KeyVal +xK_leftanglebracket = 0xabc +xK_decimalpoint :: KeyVal +xK_decimalpoint = 0xabd +xK_rightanglebracket :: KeyVal +xK_rightanglebracket = 0xabe +xK_marker :: KeyVal +xK_marker = 0xabf +xK_oneeighth :: KeyVal +xK_oneeighth = 0xac3 +xK_threeeighths :: KeyVal +xK_threeeighths = 0xac4 +xK_fiveeighths :: KeyVal +xK_fiveeighths = 0xac5 +xK_seveneighths :: KeyVal +xK_seveneighths = 0xac6 +xK_trademark :: KeyVal +xK_trademark = 0xac9 +xK_signaturemark :: KeyVal +xK_signaturemark = 0xaca +xK_trademarkincircle :: KeyVal +xK_trademarkincircle = 0xacb +xK_leftopentriangle :: KeyVal +xK_leftopentriangle = 0xacc +xK_rightopentriangle :: KeyVal +xK_rightopentriangle = 0xacd +xK_emopencircle :: KeyVal +xK_emopencircle = 0xace +xK_emopenrectangle :: KeyVal +xK_emopenrectangle = 0xacf +xK_leftsinglequotemark :: KeyVal +xK_leftsinglequotemark = 0xad0 +xK_rightsinglequotemark :: KeyVal +xK_rightsinglequotemark = 0xad1 +xK_leftdoublequotemark :: KeyVal +xK_leftdoublequotemark = 0xad2 +xK_rightdoublequotemark :: KeyVal +xK_rightdoublequotemark = 0xad3 +xK_prescription :: KeyVal +xK_prescription = 0xad4 +xK_permille :: KeyVal +xK_permille = 0xad5 +xK_minutes :: KeyVal +xK_minutes = 0xad6 +xK_seconds :: KeyVal +xK_seconds = 0xad7 +xK_latincross :: KeyVal +xK_latincross = 0xad9 +xK_hexagram :: KeyVal +xK_hexagram = 0xada +xK_filledrectbullet :: KeyVal +xK_filledrectbullet = 0xadb +xK_filledlefttribullet :: KeyVal +xK_filledlefttribullet = 0xadc +xK_filledrighttribullet :: KeyVal +xK_filledrighttribullet = 0xadd +xK_emfilledcircle :: KeyVal +xK_emfilledcircle = 0xade +xK_emfilledrect :: KeyVal +xK_emfilledrect = 0xadf +xK_enopencircbullet :: KeyVal +xK_enopencircbullet = 0xae0 +xK_enopensquarebullet :: KeyVal +xK_enopensquarebullet = 0xae1 +xK_openrectbullet :: KeyVal +xK_openrectbullet = 0xae2 +xK_opentribulletup :: KeyVal +xK_opentribulletup = 0xae3 +xK_opentribulletdown :: KeyVal +xK_opentribulletdown = 0xae4 +xK_openstar :: KeyVal +xK_openstar = 0xae5 +xK_enfilledcircbullet :: KeyVal +xK_enfilledcircbullet = 0xae6 +xK_enfilledsqbullet :: KeyVal +xK_enfilledsqbullet = 0xae7 +xK_filledtribulletup :: KeyVal +xK_filledtribulletup = 0xae8 +xK_filledtribulletdown :: KeyVal +xK_filledtribulletdown = 0xae9 +xK_leftpointer :: KeyVal +xK_leftpointer = 0xaea +xK_rightpointer :: KeyVal +xK_rightpointer = 0xaeb +xK_club :: KeyVal +xK_club = 0xaec +xK_diamond :: KeyVal +xK_diamond = 0xaed +xK_heart :: KeyVal +xK_heart = 0xaee +xK_maltesecross :: KeyVal +xK_maltesecross = 0xaf0 +xK_dagger :: KeyVal +xK_dagger = 0xaf1 +xK_doubledagger :: KeyVal +xK_doubledagger = 0xaf2 +xK_checkmark :: KeyVal +xK_checkmark = 0xaf3 +xK_ballotcross :: KeyVal +xK_ballotcross = 0xaf4 +xK_musicalsharp :: KeyVal +xK_musicalsharp = 0xaf5 +xK_musicalflat :: KeyVal +xK_musicalflat = 0xaf6 +xK_malesymbol :: KeyVal +xK_malesymbol = 0xaf7 +xK_femalesymbol :: KeyVal +xK_femalesymbol = 0xaf8 +xK_telephone :: KeyVal +xK_telephone = 0xaf9 +xK_telephonerecorder :: KeyVal +xK_telephonerecorder = 0xafa +xK_phonographcopyright :: KeyVal +xK_phonographcopyright = 0xafb +xK_caret :: KeyVal +xK_caret = 0xafc +xK_singlelowquotemark :: KeyVal +xK_singlelowquotemark = 0xafd +xK_doublelowquotemark :: KeyVal +xK_doublelowquotemark = 0xafe +xK_cursor :: KeyVal +xK_cursor = 0xaff +xK_leftcaret :: KeyVal +xK_leftcaret = 0xba3 +xK_rightcaret :: KeyVal +xK_rightcaret = 0xba6 +xK_downcaret :: KeyVal +xK_downcaret = 0xba8 +xK_upcaret :: KeyVal +xK_upcaret = 0xba9 +xK_overbar :: KeyVal +xK_overbar = 0xbc0 +xK_downtack :: KeyVal +xK_downtack = 0xbc2 +xK_upshoe :: KeyVal +xK_upshoe = 0xbc3 +xK_downstile :: KeyVal +xK_downstile = 0xbc4 +xK_underbar :: KeyVal +xK_underbar = 0xbc6 +xK_jot :: KeyVal +xK_jot = 0xbca +xK_quad :: KeyVal +xK_quad = 0xbcc +xK_uptack :: KeyVal +xK_uptack = 0xbce +xK_circle :: KeyVal +xK_circle = 0xbcf +xK_upstile :: KeyVal +xK_upstile = 0xbd3 +xK_downshoe :: KeyVal +xK_downshoe = 0xbd6 +xK_rightshoe :: KeyVal +xK_rightshoe = 0xbd8 +xK_leftshoe :: KeyVal +xK_leftshoe = 0xbda +xK_lefttack :: KeyVal +xK_lefttack = 0xbdc +xK_righttack :: KeyVal +xK_righttack = 0xbfc +xK_hebrew_doublelowline :: KeyVal +xK_hebrew_doublelowline = 0xcdf +xK_hebrew_aleph :: KeyVal +xK_hebrew_aleph = 0xce0 +xK_hebrew_bet :: KeyVal +xK_hebrew_bet = 0xce1 +xK_hebrew_beth :: KeyVal +xK_hebrew_beth = 0xce1 +xK_hebrew_gimel :: KeyVal +xK_hebrew_gimel = 0xce2 +xK_hebrew_gimmel :: KeyVal +xK_hebrew_gimmel = 0xce2 +xK_hebrew_dalet :: KeyVal +xK_hebrew_dalet = 0xce3 +xK_hebrew_daleth :: KeyVal +xK_hebrew_daleth = 0xce3 +xK_hebrew_he :: KeyVal +xK_hebrew_he = 0xce4 +xK_hebrew_waw :: KeyVal +xK_hebrew_waw = 0xce5 +xK_hebrew_zain :: KeyVal +xK_hebrew_zain = 0xce6 +xK_hebrew_zayin :: KeyVal +xK_hebrew_zayin = 0xce6 +xK_hebrew_chet :: KeyVal +xK_hebrew_chet = 0xce7 +xK_hebrew_het :: KeyVal +xK_hebrew_het = 0xce7 +xK_hebrew_tet :: KeyVal +xK_hebrew_tet = 0xce8 +xK_hebrew_teth :: KeyVal +xK_hebrew_teth = 0xce8 +xK_hebrew_yod :: KeyVal +xK_hebrew_yod = 0xce9 +xK_hebrew_finalkaph :: KeyVal +xK_hebrew_finalkaph = 0xcea +xK_hebrew_kaph :: KeyVal +xK_hebrew_kaph = 0xceb +xK_hebrew_lamed :: KeyVal +xK_hebrew_lamed = 0xcec +xK_hebrew_finalmem :: KeyVal +xK_hebrew_finalmem = 0xced +xK_hebrew_mem :: KeyVal +xK_hebrew_mem = 0xcee +xK_hebrew_finalnun :: KeyVal +xK_hebrew_finalnun = 0xcef +xK_hebrew_nun :: KeyVal +xK_hebrew_nun = 0xcf0 +xK_hebrew_samech :: KeyVal +xK_hebrew_samech = 0xcf1 +xK_hebrew_samekh :: KeyVal +xK_hebrew_samekh = 0xcf1 +xK_hebrew_ayin :: KeyVal +xK_hebrew_ayin = 0xcf2 +xK_hebrew_finalpe :: KeyVal +xK_hebrew_finalpe = 0xcf3 +xK_hebrew_pe :: KeyVal +xK_hebrew_pe = 0xcf4 +xK_hebrew_finalzade :: KeyVal +xK_hebrew_finalzade = 0xcf5 +xK_hebrew_finalzadi :: KeyVal +xK_hebrew_finalzadi = 0xcf5 +xK_hebrew_zade :: KeyVal +xK_hebrew_zade = 0xcf6 +xK_hebrew_zadi :: KeyVal +xK_hebrew_zadi = 0xcf6 +xK_hebrew_qoph :: KeyVal +xK_hebrew_qoph = 0xcf7 +xK_hebrew_kuf :: KeyVal +xK_hebrew_kuf = 0xcf7 +xK_hebrew_resh :: KeyVal +xK_hebrew_resh = 0xcf8 +xK_hebrew_shin :: KeyVal +xK_hebrew_shin = 0xcf9 +xK_hebrew_taw :: KeyVal +xK_hebrew_taw = 0xcfa +xK_hebrew_taf :: KeyVal +xK_hebrew_taf = 0xcfa +xK_Hebrew_switch :: KeyVal +xK_Hebrew_switch = 0xff7e +xK_Thai_kokai :: KeyVal +xK_Thai_kokai = 0xda1 +xK_Thai_khokhai :: KeyVal +xK_Thai_khokhai = 0xda2 +xK_Thai_khokhuat :: KeyVal +xK_Thai_khokhuat = 0xda3 +xK_Thai_khokhwai :: KeyVal +xK_Thai_khokhwai = 0xda4 +xK_Thai_khokhon :: KeyVal +xK_Thai_khokhon = 0xda5 +xK_Thai_khorakhang :: KeyVal +xK_Thai_khorakhang = 0xda6 +xK_Thai_ngongu :: KeyVal +xK_Thai_ngongu = 0xda7 +xK_Thai_chochan :: KeyVal +xK_Thai_chochan = 0xda8 +xK_Thai_choching :: KeyVal +xK_Thai_choching = 0xda9 +xK_Thai_chochang :: KeyVal +xK_Thai_chochang = 0xdaa +xK_Thai_soso :: KeyVal +xK_Thai_soso = 0xdab +xK_Thai_chochoe :: KeyVal +xK_Thai_chochoe = 0xdac +xK_Thai_yoying :: KeyVal +xK_Thai_yoying = 0xdad +xK_Thai_dochada :: KeyVal +xK_Thai_dochada = 0xdae +xK_Thai_topatak :: KeyVal +xK_Thai_topatak = 0xdaf +xK_Thai_thothan :: KeyVal +xK_Thai_thothan = 0xdb0 +xK_Thai_thonangmontho :: KeyVal +xK_Thai_thonangmontho = 0xdb1 +xK_Thai_thophuthao :: KeyVal +xK_Thai_thophuthao = 0xdb2 +xK_Thai_nonen :: KeyVal +xK_Thai_nonen = 0xdb3 +xK_Thai_dodek :: KeyVal +xK_Thai_dodek = 0xdb4 +xK_Thai_totao :: KeyVal +xK_Thai_totao = 0xdb5 +xK_Thai_thothung :: KeyVal +xK_Thai_thothung = 0xdb6 +xK_Thai_thothahan :: KeyVal +xK_Thai_thothahan = 0xdb7 +xK_Thai_thothong :: KeyVal +xK_Thai_thothong = 0xdb8 +xK_Thai_nonu :: KeyVal +xK_Thai_nonu = 0xdb9 +xK_Thai_bobaimai :: KeyVal +xK_Thai_bobaimai = 0xdba +xK_Thai_popla :: KeyVal +xK_Thai_popla = 0xdbb +xK_Thai_phophung :: KeyVal +xK_Thai_phophung = 0xdbc +xK_Thai_fofa :: KeyVal +xK_Thai_fofa = 0xdbd +xK_Thai_phophan :: KeyVal +xK_Thai_phophan = 0xdbe +xK_Thai_fofan :: KeyVal +xK_Thai_fofan = 0xdbf +xK_Thai_phosamphao :: KeyVal +xK_Thai_phosamphao = 0xdc0 +xK_Thai_moma :: KeyVal +xK_Thai_moma = 0xdc1 +xK_Thai_yoyak :: KeyVal +xK_Thai_yoyak = 0xdc2 +xK_Thai_rorua :: KeyVal +xK_Thai_rorua = 0xdc3 +xK_Thai_ru :: KeyVal +xK_Thai_ru = 0xdc4 +xK_Thai_loling :: KeyVal +xK_Thai_loling = 0xdc5 +xK_Thai_lu :: KeyVal +xK_Thai_lu = 0xdc6 +xK_Thai_wowaen :: KeyVal +xK_Thai_wowaen = 0xdc7 +xK_Thai_sosala :: KeyVal +xK_Thai_sosala = 0xdc8 +xK_Thai_sorusi :: KeyVal +xK_Thai_sorusi = 0xdc9 +xK_Thai_sosua :: KeyVal +xK_Thai_sosua = 0xdca +xK_Thai_hohip :: KeyVal +xK_Thai_hohip = 0xdcb +xK_Thai_lochula :: KeyVal +xK_Thai_lochula = 0xdcc +xK_Thai_oang :: KeyVal +xK_Thai_oang = 0xdcd +xK_Thai_honokhuk :: KeyVal +xK_Thai_honokhuk = 0xdce +xK_Thai_paiyannoi :: KeyVal +xK_Thai_paiyannoi = 0xdcf +xK_Thai_saraa :: KeyVal +xK_Thai_saraa = 0xdd0 +xK_Thai_maihanakat :: KeyVal +xK_Thai_maihanakat = 0xdd1 +xK_Thai_saraaa :: KeyVal +xK_Thai_saraaa = 0xdd2 +xK_Thai_saraam :: KeyVal +xK_Thai_saraam = 0xdd3 +xK_Thai_sarai :: KeyVal +xK_Thai_sarai = 0xdd4 +xK_Thai_saraii :: KeyVal +xK_Thai_saraii = 0xdd5 +xK_Thai_saraue :: KeyVal +xK_Thai_saraue = 0xdd6 +xK_Thai_sarauee :: KeyVal +xK_Thai_sarauee = 0xdd7 +xK_Thai_sarau :: KeyVal +xK_Thai_sarau = 0xdd8 +xK_Thai_sarauu :: KeyVal +xK_Thai_sarauu = 0xdd9 +xK_Thai_phinthu :: KeyVal +xK_Thai_phinthu = 0xdda +xK_Thai_maihanakat_maitho :: KeyVal +xK_Thai_maihanakat_maitho = 0xdde +xK_Thai_baht :: KeyVal +xK_Thai_baht = 0xddf +xK_Thai_sarae :: KeyVal +xK_Thai_sarae = 0xde0 +xK_Thai_saraae :: KeyVal +xK_Thai_saraae = 0xde1 +xK_Thai_sarao :: KeyVal +xK_Thai_sarao = 0xde2 +xK_Thai_saraaimaimuan :: KeyVal +xK_Thai_saraaimaimuan = 0xde3 +xK_Thai_saraaimaimalai :: KeyVal +xK_Thai_saraaimaimalai = 0xde4 +xK_Thai_lakkhangyao :: KeyVal +xK_Thai_lakkhangyao = 0xde5 +xK_Thai_maiyamok :: KeyVal +xK_Thai_maiyamok = 0xde6 +xK_Thai_maitaikhu :: KeyVal +xK_Thai_maitaikhu = 0xde7 +xK_Thai_maiek :: KeyVal +xK_Thai_maiek = 0xde8 +xK_Thai_maitho :: KeyVal +xK_Thai_maitho = 0xde9 +xK_Thai_maitri :: KeyVal +xK_Thai_maitri = 0xdea +xK_Thai_maichattawa :: KeyVal +xK_Thai_maichattawa = 0xdeb +xK_Thai_thanthakhat :: KeyVal +xK_Thai_thanthakhat = 0xdec +xK_Thai_nikhahit :: KeyVal +xK_Thai_nikhahit = 0xded +xK_Thai_leksun :: KeyVal +xK_Thai_leksun = 0xdf0 +xK_Thai_leknung :: KeyVal +xK_Thai_leknung = 0xdf1 +xK_Thai_leksong :: KeyVal +xK_Thai_leksong = 0xdf2 +xK_Thai_leksam :: KeyVal +xK_Thai_leksam = 0xdf3 +xK_Thai_leksi :: KeyVal +xK_Thai_leksi = 0xdf4 +xK_Thai_lekha :: KeyVal +xK_Thai_lekha = 0xdf5 +xK_Thai_lekhok :: KeyVal +xK_Thai_lekhok = 0xdf6 +xK_Thai_lekchet :: KeyVal +xK_Thai_lekchet = 0xdf7 +xK_Thai_lekpaet :: KeyVal +xK_Thai_lekpaet = 0xdf8 +xK_Thai_lekkao :: KeyVal +xK_Thai_lekkao = 0xdf9 +xK_Hangul :: KeyVal +xK_Hangul = 0xff31 +xK_Hangul_Start :: KeyVal +xK_Hangul_Start = 0xff32 +xK_Hangul_End :: KeyVal +xK_Hangul_End = 0xff33 +xK_Hangul_Hanja :: KeyVal +xK_Hangul_Hanja = 0xff34 +xK_Hangul_Jamo :: KeyVal +xK_Hangul_Jamo = 0xff35 +xK_Hangul_Romaja :: KeyVal +xK_Hangul_Romaja = 0xff36 +xK_Hangul_Codeinput :: KeyVal +xK_Hangul_Codeinput = 0xff37 +xK_Hangul_Jeonja :: KeyVal +xK_Hangul_Jeonja = 0xff38 +xK_Hangul_Banja :: KeyVal +xK_Hangul_Banja = 0xff39 +xK_Hangul_PreHanja :: KeyVal +xK_Hangul_PreHanja = 0xff3a +xK_Hangul_PostHanja :: KeyVal +xK_Hangul_PostHanja = 0xff3b +xK_Hangul_SingleCandidate :: KeyVal +xK_Hangul_SingleCandidate = 0xff3c +xK_Hangul_MultipleCandidate :: KeyVal +xK_Hangul_MultipleCandidate = 0xff3d +xK_Hangul_PreviousCandidate :: KeyVal +xK_Hangul_PreviousCandidate = 0xff3e +xK_Hangul_Special :: KeyVal +xK_Hangul_Special = 0xff3f +xK_Hangul_switch :: KeyVal +xK_Hangul_switch = 0xff7e +xK_Hangul_Kiyeog :: KeyVal +xK_Hangul_Kiyeog = 0xea1 +xK_Hangul_SsangKiyeog :: KeyVal +xK_Hangul_SsangKiyeog = 0xea2 +xK_Hangul_KiyeogSios :: KeyVal +xK_Hangul_KiyeogSios = 0xea3 +xK_Hangul_Nieun :: KeyVal +xK_Hangul_Nieun = 0xea4 +xK_Hangul_NieunJieuj :: KeyVal +xK_Hangul_NieunJieuj = 0xea5 +xK_Hangul_NieunHieuh :: KeyVal +xK_Hangul_NieunHieuh = 0xea6 +xK_Hangul_Dikeud :: KeyVal +xK_Hangul_Dikeud = 0xea7 +xK_Hangul_SsangDikeud :: KeyVal +xK_Hangul_SsangDikeud = 0xea8 +xK_Hangul_Rieul :: KeyVal +xK_Hangul_Rieul = 0xea9 +xK_Hangul_RieulKiyeog :: KeyVal +xK_Hangul_RieulKiyeog = 0xeaa +xK_Hangul_RieulMieum :: KeyVal +xK_Hangul_RieulMieum = 0xeab +xK_Hangul_RieulPieub :: KeyVal +xK_Hangul_RieulPieub = 0xeac +xK_Hangul_RieulSios :: KeyVal +xK_Hangul_RieulSios = 0xead +xK_Hangul_RieulTieut :: KeyVal +xK_Hangul_RieulTieut = 0xeae +xK_Hangul_RieulPhieuf :: KeyVal +xK_Hangul_RieulPhieuf = 0xeaf +xK_Hangul_RieulHieuh :: KeyVal +xK_Hangul_RieulHieuh = 0xeb0 +xK_Hangul_Mieum :: KeyVal +xK_Hangul_Mieum = 0xeb1 +xK_Hangul_Pieub :: KeyVal +xK_Hangul_Pieub = 0xeb2 +xK_Hangul_SsangPieub :: KeyVal +xK_Hangul_SsangPieub = 0xeb3 +xK_Hangul_PieubSios :: KeyVal +xK_Hangul_PieubSios = 0xeb4 +xK_Hangul_Sios :: KeyVal +xK_Hangul_Sios = 0xeb5 +xK_Hangul_SsangSios :: KeyVal +xK_Hangul_SsangSios = 0xeb6 +xK_Hangul_Ieung :: KeyVal +xK_Hangul_Ieung = 0xeb7 +xK_Hangul_Jieuj :: KeyVal +xK_Hangul_Jieuj = 0xeb8 +xK_Hangul_SsangJieuj :: KeyVal +xK_Hangul_SsangJieuj = 0xeb9 +xK_Hangul_Cieuc :: KeyVal +xK_Hangul_Cieuc = 0xeba +xK_Hangul_Khieuq :: KeyVal +xK_Hangul_Khieuq = 0xebb +xK_Hangul_Tieut :: KeyVal +xK_Hangul_Tieut = 0xebc +xK_Hangul_Phieuf :: KeyVal +xK_Hangul_Phieuf = 0xebd +xK_Hangul_Hieuh :: KeyVal +xK_Hangul_Hieuh = 0xebe +xK_Hangul_A :: KeyVal +xK_Hangul_A = 0xebf +xK_Hangul_AE :: KeyVal +xK_Hangul_AE = 0xec0 +xK_Hangul_YA :: KeyVal +xK_Hangul_YA = 0xec1 +xK_Hangul_YAE :: KeyVal +xK_Hangul_YAE = 0xec2 +xK_Hangul_EO :: KeyVal +xK_Hangul_EO = 0xec3 +xK_Hangul_E :: KeyVal +xK_Hangul_E = 0xec4 +xK_Hangul_YEO :: KeyVal +xK_Hangul_YEO = 0xec5 +xK_Hangul_YE :: KeyVal +xK_Hangul_YE = 0xec6 +xK_Hangul_O :: KeyVal +xK_Hangul_O = 0xec7 +xK_Hangul_WA :: KeyVal +xK_Hangul_WA = 0xec8 +xK_Hangul_WAE :: KeyVal +xK_Hangul_WAE = 0xec9 +xK_Hangul_OE :: KeyVal +xK_Hangul_OE = 0xeca +xK_Hangul_YO :: KeyVal +xK_Hangul_YO = 0xecb +xK_Hangul_U :: KeyVal +xK_Hangul_U = 0xecc +xK_Hangul_WEO :: KeyVal +xK_Hangul_WEO = 0xecd +xK_Hangul_WE :: KeyVal +xK_Hangul_WE = 0xece +xK_Hangul_WI :: KeyVal +xK_Hangul_WI = 0xecf +xK_Hangul_YU :: KeyVal +xK_Hangul_YU = 0xed0 +xK_Hangul_EU :: KeyVal +xK_Hangul_EU = 0xed1 +xK_Hangul_YI :: KeyVal +xK_Hangul_YI = 0xed2 +xK_Hangul_I :: KeyVal +xK_Hangul_I = 0xed3 +xK_Hangul_J_Kiyeog :: KeyVal +xK_Hangul_J_Kiyeog = 0xed4 +xK_Hangul_J_SsangKiyeog :: KeyVal +xK_Hangul_J_SsangKiyeog = 0xed5 +xK_Hangul_J_KiyeogSios :: KeyVal +xK_Hangul_J_KiyeogSios = 0xed6 +xK_Hangul_J_Nieun :: KeyVal +xK_Hangul_J_Nieun = 0xed7 +xK_Hangul_J_NieunJieuj :: KeyVal +xK_Hangul_J_NieunJieuj = 0xed8 +xK_Hangul_J_NieunHieuh :: KeyVal +xK_Hangul_J_NieunHieuh = 0xed9 +xK_Hangul_J_Dikeud :: KeyVal +xK_Hangul_J_Dikeud = 0xeda +xK_Hangul_J_Rieul :: KeyVal +xK_Hangul_J_Rieul = 0xedb +xK_Hangul_J_RieulKiyeog :: KeyVal +xK_Hangul_J_RieulKiyeog = 0xedc +xK_Hangul_J_RieulMieum :: KeyVal +xK_Hangul_J_RieulMieum = 0xedd +xK_Hangul_J_RieulPieub :: KeyVal +xK_Hangul_J_RieulPieub = 0xede +xK_Hangul_J_RieulSios :: KeyVal +xK_Hangul_J_RieulSios = 0xedf +xK_Hangul_J_RieulTieut :: KeyVal +xK_Hangul_J_RieulTieut = 0xee0 +xK_Hangul_J_RieulPhieuf :: KeyVal +xK_Hangul_J_RieulPhieuf = 0xee1 +xK_Hangul_J_RieulHieuh :: KeyVal +xK_Hangul_J_RieulHieuh = 0xee2 +xK_Hangul_J_Mieum :: KeyVal +xK_Hangul_J_Mieum = 0xee3 +xK_Hangul_J_Pieub :: KeyVal +xK_Hangul_J_Pieub = 0xee4 +xK_Hangul_J_PieubSios :: KeyVal +xK_Hangul_J_PieubSios = 0xee5 +xK_Hangul_J_Sios :: KeyVal +xK_Hangul_J_Sios = 0xee6 +xK_Hangul_J_SsangSios :: KeyVal +xK_Hangul_J_SsangSios = 0xee7 +xK_Hangul_J_Ieung :: KeyVal +xK_Hangul_J_Ieung = 0xee8 +xK_Hangul_J_Jieuj :: KeyVal +xK_Hangul_J_Jieuj = 0xee9 +xK_Hangul_J_Cieuc :: KeyVal +xK_Hangul_J_Cieuc = 0xeea +xK_Hangul_J_Khieuq :: KeyVal +xK_Hangul_J_Khieuq = 0xeeb +xK_Hangul_J_Tieut :: KeyVal +xK_Hangul_J_Tieut = 0xeec +xK_Hangul_J_Phieuf :: KeyVal +xK_Hangul_J_Phieuf = 0xeed +xK_Hangul_J_Hieuh :: KeyVal +xK_Hangul_J_Hieuh = 0xeee +xK_Hangul_RieulYeorinHieuh :: KeyVal +xK_Hangul_RieulYeorinHieuh = 0xeef +xK_Hangul_SunkyeongeumMieum :: KeyVal +xK_Hangul_SunkyeongeumMieum = 0xef0 +xK_Hangul_SunkyeongeumPieub :: KeyVal +xK_Hangul_SunkyeongeumPieub = 0xef1 +xK_Hangul_PanSios :: KeyVal +xK_Hangul_PanSios = 0xef2 +xK_Hangul_KkogjiDalrinIeung :: KeyVal +xK_Hangul_KkogjiDalrinIeung = 0xef3 +xK_Hangul_SunkyeongeumPhieuf :: KeyVal +xK_Hangul_SunkyeongeumPhieuf = 0xef4 +xK_Hangul_YeorinHieuh :: KeyVal +xK_Hangul_YeorinHieuh = 0xef5 +xK_Hangul_AraeA :: KeyVal +xK_Hangul_AraeA = 0xef6 +xK_Hangul_AraeAE :: KeyVal +xK_Hangul_AraeAE = 0xef7 +xK_Hangul_J_PanSios :: KeyVal +xK_Hangul_J_PanSios = 0xef8 +xK_Hangul_J_KkogjiDalrinIeung :: KeyVal +xK_Hangul_J_KkogjiDalrinIeung = 0xef9 +xK_Hangul_J_YeorinHieuh :: KeyVal +xK_Hangul_J_YeorinHieuh = 0xefa +xK_Korean_Won :: KeyVal +xK_Korean_Won = 0xeff +xK_Armenian_ligature_ew :: KeyVal +xK_Armenian_ligature_ew = 0x1000587 +xK_Armenian_full_stop :: KeyVal +xK_Armenian_full_stop = 0x1000589 +xK_Armenian_verjaket :: KeyVal +xK_Armenian_verjaket = 0x1000589 +xK_Armenian_separation_mark :: KeyVal +xK_Armenian_separation_mark = 0x100055d +xK_Armenian_but :: KeyVal +xK_Armenian_but = 0x100055d +xK_Armenian_hyphen :: KeyVal +xK_Armenian_hyphen = 0x100058a +xK_Armenian_yentamna :: KeyVal +xK_Armenian_yentamna = 0x100058a +xK_Armenian_exclam :: KeyVal +xK_Armenian_exclam = 0x100055c +xK_Armenian_amanak :: KeyVal +xK_Armenian_amanak = 0x100055c +xK_Armenian_accent :: KeyVal +xK_Armenian_accent = 0x100055b +xK_Armenian_shesht :: KeyVal +xK_Armenian_shesht = 0x100055b +xK_Armenian_question :: KeyVal +xK_Armenian_question = 0x100055e +xK_Armenian_paruyk :: KeyVal +xK_Armenian_paruyk = 0x100055e +xK_Armenian_AYB :: KeyVal +xK_Armenian_AYB = 0x1000531 +xK_Armenian_ayb :: KeyVal +xK_Armenian_ayb = 0x1000561 +xK_Armenian_BEN :: KeyVal +xK_Armenian_BEN = 0x1000532 +xK_Armenian_ben :: KeyVal +xK_Armenian_ben = 0x1000562 +xK_Armenian_GIM :: KeyVal +xK_Armenian_GIM = 0x1000533 +xK_Armenian_gim :: KeyVal +xK_Armenian_gim = 0x1000563 +xK_Armenian_DA :: KeyVal +xK_Armenian_DA = 0x1000534 +xK_Armenian_da :: KeyVal +xK_Armenian_da = 0x1000564 +xK_Armenian_YECH :: KeyVal +xK_Armenian_YECH = 0x1000535 +xK_Armenian_yech :: KeyVal +xK_Armenian_yech = 0x1000565 +xK_Armenian_ZA :: KeyVal +xK_Armenian_ZA = 0x1000536 +xK_Armenian_za :: KeyVal +xK_Armenian_za = 0x1000566 +xK_Armenian_E :: KeyVal +xK_Armenian_E = 0x1000537 +xK_Armenian_e :: KeyVal +xK_Armenian_e = 0x1000567 +xK_Armenian_AT :: KeyVal +xK_Armenian_AT = 0x1000538 +xK_Armenian_at :: KeyVal +xK_Armenian_at = 0x1000568 +xK_Armenian_TO :: KeyVal +xK_Armenian_TO = 0x1000539 +xK_Armenian_to :: KeyVal +xK_Armenian_to = 0x1000569 +xK_Armenian_ZHE :: KeyVal +xK_Armenian_ZHE = 0x100053a +xK_Armenian_zhe :: KeyVal +xK_Armenian_zhe = 0x100056a +xK_Armenian_INI :: KeyVal +xK_Armenian_INI = 0x100053b +xK_Armenian_ini :: KeyVal +xK_Armenian_ini = 0x100056b +xK_Armenian_LYUN :: KeyVal +xK_Armenian_LYUN = 0x100053c +xK_Armenian_lyun :: KeyVal +xK_Armenian_lyun = 0x100056c +xK_Armenian_KHE :: KeyVal +xK_Armenian_KHE = 0x100053d +xK_Armenian_khe :: KeyVal +xK_Armenian_khe = 0x100056d +xK_Armenian_TSA :: KeyVal +xK_Armenian_TSA = 0x100053e +xK_Armenian_tsa :: KeyVal +xK_Armenian_tsa = 0x100056e +xK_Armenian_KEN :: KeyVal +xK_Armenian_KEN = 0x100053f +xK_Armenian_ken :: KeyVal +xK_Armenian_ken = 0x100056f +xK_Armenian_HO :: KeyVal +xK_Armenian_HO = 0x1000540 +xK_Armenian_ho :: KeyVal +xK_Armenian_ho = 0x1000570 +xK_Armenian_DZA :: KeyVal +xK_Armenian_DZA = 0x1000541 +xK_Armenian_dza :: KeyVal +xK_Armenian_dza = 0x1000571 +xK_Armenian_GHAT :: KeyVal +xK_Armenian_GHAT = 0x1000542 +xK_Armenian_ghat :: KeyVal +xK_Armenian_ghat = 0x1000572 +xK_Armenian_TCHE :: KeyVal +xK_Armenian_TCHE = 0x1000543 +xK_Armenian_tche :: KeyVal +xK_Armenian_tche = 0x1000573 +xK_Armenian_MEN :: KeyVal +xK_Armenian_MEN = 0x1000544 +xK_Armenian_men :: KeyVal +xK_Armenian_men = 0x1000574 +xK_Armenian_HI :: KeyVal +xK_Armenian_HI = 0x1000545 +xK_Armenian_hi :: KeyVal +xK_Armenian_hi = 0x1000575 +xK_Armenian_NU :: KeyVal +xK_Armenian_NU = 0x1000546 +xK_Armenian_nu :: KeyVal +xK_Armenian_nu = 0x1000576 +xK_Armenian_SHA :: KeyVal +xK_Armenian_SHA = 0x1000547 +xK_Armenian_sha :: KeyVal +xK_Armenian_sha = 0x1000577 +xK_Armenian_VO :: KeyVal +xK_Armenian_VO = 0x1000548 +xK_Armenian_vo :: KeyVal +xK_Armenian_vo = 0x1000578 +xK_Armenian_CHA :: KeyVal +xK_Armenian_CHA = 0x1000549 +xK_Armenian_cha :: KeyVal +xK_Armenian_cha = 0x1000579 +xK_Armenian_PE :: KeyVal +xK_Armenian_PE = 0x100054a +xK_Armenian_pe :: KeyVal +xK_Armenian_pe = 0x100057a +xK_Armenian_JE :: KeyVal +xK_Armenian_JE = 0x100054b +xK_Armenian_je :: KeyVal +xK_Armenian_je = 0x100057b +xK_Armenian_RA :: KeyVal +xK_Armenian_RA = 0x100054c +xK_Armenian_ra :: KeyVal +xK_Armenian_ra = 0x100057c +xK_Armenian_SE :: KeyVal +xK_Armenian_SE = 0x100054d +xK_Armenian_se :: KeyVal +xK_Armenian_se = 0x100057d +xK_Armenian_VEV :: KeyVal +xK_Armenian_VEV = 0x100054e +xK_Armenian_vev :: KeyVal +xK_Armenian_vev = 0x100057e +xK_Armenian_TYUN :: KeyVal +xK_Armenian_TYUN = 0x100054f +xK_Armenian_tyun :: KeyVal +xK_Armenian_tyun = 0x100057f +xK_Armenian_RE :: KeyVal +xK_Armenian_RE = 0x1000550 +xK_Armenian_re :: KeyVal +xK_Armenian_re = 0x1000580 +xK_Armenian_TSO :: KeyVal +xK_Armenian_TSO = 0x1000551 +xK_Armenian_tso :: KeyVal +xK_Armenian_tso = 0x1000581 +xK_Armenian_VYUN :: KeyVal +xK_Armenian_VYUN = 0x1000552 +xK_Armenian_vyun :: KeyVal +xK_Armenian_vyun = 0x1000582 +xK_Armenian_PYUR :: KeyVal +xK_Armenian_PYUR = 0x1000553 +xK_Armenian_pyur :: KeyVal +xK_Armenian_pyur = 0x1000583 +xK_Armenian_KE :: KeyVal +xK_Armenian_KE = 0x1000554 +xK_Armenian_ke :: KeyVal +xK_Armenian_ke = 0x1000584 +xK_Armenian_O :: KeyVal +xK_Armenian_O = 0x1000555 +xK_Armenian_o :: KeyVal +xK_Armenian_o = 0x1000585 +xK_Armenian_FE :: KeyVal +xK_Armenian_FE = 0x1000556 +xK_Armenian_fe :: KeyVal +xK_Armenian_fe = 0x1000586 +xK_Armenian_apostrophe :: KeyVal +xK_Armenian_apostrophe = 0x100055a +xK_Georgian_an :: KeyVal +xK_Georgian_an = 0x10010d0 +xK_Georgian_ban :: KeyVal +xK_Georgian_ban = 0x10010d1 +xK_Georgian_gan :: KeyVal +xK_Georgian_gan = 0x10010d2 +xK_Georgian_don :: KeyVal +xK_Georgian_don = 0x10010d3 +xK_Georgian_en :: KeyVal +xK_Georgian_en = 0x10010d4 +xK_Georgian_vin :: KeyVal +xK_Georgian_vin = 0x10010d5 +xK_Georgian_zen :: KeyVal +xK_Georgian_zen = 0x10010d6 +xK_Georgian_tan :: KeyVal +xK_Georgian_tan = 0x10010d7 +xK_Georgian_in :: KeyVal +xK_Georgian_in = 0x10010d8 +xK_Georgian_kan :: KeyVal +xK_Georgian_kan = 0x10010d9 +xK_Georgian_las :: KeyVal +xK_Georgian_las = 0x10010da +xK_Georgian_man :: KeyVal +xK_Georgian_man = 0x10010db +xK_Georgian_nar :: KeyVal +xK_Georgian_nar = 0x10010dc +xK_Georgian_on :: KeyVal +xK_Georgian_on = 0x10010dd +xK_Georgian_par :: KeyVal +xK_Georgian_par = 0x10010de +xK_Georgian_zhar :: KeyVal +xK_Georgian_zhar = 0x10010df +xK_Georgian_rae :: KeyVal +xK_Georgian_rae = 0x10010e0 +xK_Georgian_san :: KeyVal +xK_Georgian_san = 0x10010e1 +xK_Georgian_tar :: KeyVal +xK_Georgian_tar = 0x10010e2 +xK_Georgian_un :: KeyVal +xK_Georgian_un = 0x10010e3 +xK_Georgian_phar :: KeyVal +xK_Georgian_phar = 0x10010e4 +xK_Georgian_khar :: KeyVal +xK_Georgian_khar = 0x10010e5 +xK_Georgian_ghan :: KeyVal +xK_Georgian_ghan = 0x10010e6 +xK_Georgian_qar :: KeyVal +xK_Georgian_qar = 0x10010e7 +xK_Georgian_shin :: KeyVal +xK_Georgian_shin = 0x10010e8 +xK_Georgian_chin :: KeyVal +xK_Georgian_chin = 0x10010e9 +xK_Georgian_can :: KeyVal +xK_Georgian_can = 0x10010ea +xK_Georgian_jil :: KeyVal +xK_Georgian_jil = 0x10010eb +xK_Georgian_cil :: KeyVal +xK_Georgian_cil = 0x10010ec +xK_Georgian_char :: KeyVal +xK_Georgian_char = 0x10010ed +xK_Georgian_xan :: KeyVal +xK_Georgian_xan = 0x10010ee +xK_Georgian_jhan :: KeyVal +xK_Georgian_jhan = 0x10010ef +xK_Georgian_hae :: KeyVal +xK_Georgian_hae = 0x10010f0 +xK_Georgian_he :: KeyVal +xK_Georgian_he = 0x10010f1 +xK_Georgian_hie :: KeyVal +xK_Georgian_hie = 0x10010f2 +xK_Georgian_we :: KeyVal +xK_Georgian_we = 0x10010f3 +xK_Georgian_har :: KeyVal +xK_Georgian_har = 0x10010f4 +xK_Georgian_hoe :: KeyVal +xK_Georgian_hoe = 0x10010f5 +xK_Georgian_fi :: KeyVal +xK_Georgian_fi = 0x10010f6 +xK_Xabovedot :: KeyVal +xK_Xabovedot = 0x1001e8a +xK_Ibreve :: KeyVal +xK_Ibreve = 0x100012c +xK_Zstroke :: KeyVal +xK_Zstroke = 0x10001b5 +xK_Gcaron :: KeyVal +xK_Gcaron = 0x10001e6 +xK_Ocaron :: KeyVal +xK_Ocaron = 0x10001d1 +xK_Obarred :: KeyVal +xK_Obarred = 0x100019f +xK_xabovedot :: KeyVal +xK_xabovedot = 0x1001e8b +xK_ibreve :: KeyVal +xK_ibreve = 0x100012d +xK_zstroke :: KeyVal +xK_zstroke = 0x10001b6 +xK_gcaron :: KeyVal +xK_gcaron = 0x10001e7 +xK_ocaron :: KeyVal +xK_ocaron = 0x10001d2 +xK_obarred :: KeyVal +xK_obarred = 0x1000275 +xK_SCHWA :: KeyVal +xK_SCHWA = 0x100018f +xK_schwa :: KeyVal +xK_schwa = 0x1000259 +xK_EZH :: KeyVal +xK_EZH = 0x10001b7 +xK_ezh :: KeyVal +xK_ezh = 0x1000292 +xK_Lbelowdot :: KeyVal +xK_Lbelowdot = 0x1001e36 +xK_lbelowdot :: KeyVal +xK_lbelowdot = 0x1001e37 +xK_Abelowdot :: KeyVal +xK_Abelowdot = 0x1001ea0 +xK_abelowdot :: KeyVal +xK_abelowdot = 0x1001ea1 +xK_Ahook :: KeyVal +xK_Ahook = 0x1001ea2 +xK_ahook :: KeyVal +xK_ahook = 0x1001ea3 +xK_Acircumflexacute :: KeyVal +xK_Acircumflexacute = 0x1001ea4 +xK_acircumflexacute :: KeyVal +xK_acircumflexacute = 0x1001ea5 +xK_Acircumflexgrave :: KeyVal +xK_Acircumflexgrave = 0x1001ea6 +xK_acircumflexgrave :: KeyVal +xK_acircumflexgrave = 0x1001ea7 +xK_Acircumflexhook :: KeyVal +xK_Acircumflexhook = 0x1001ea8 +xK_acircumflexhook :: KeyVal +xK_acircumflexhook = 0x1001ea9 +xK_Acircumflextilde :: KeyVal +xK_Acircumflextilde = 0x1001eaa +xK_acircumflextilde :: KeyVal +xK_acircumflextilde = 0x1001eab +xK_Acircumflexbelowdot :: KeyVal +xK_Acircumflexbelowdot = 0x1001eac +xK_acircumflexbelowdot :: KeyVal +xK_acircumflexbelowdot = 0x1001ead +xK_Abreveacute :: KeyVal +xK_Abreveacute = 0x1001eae +xK_abreveacute :: KeyVal +xK_abreveacute = 0x1001eaf +xK_Abrevegrave :: KeyVal +xK_Abrevegrave = 0x1001eb0 +xK_abrevegrave :: KeyVal +xK_abrevegrave = 0x1001eb1 +xK_Abrevehook :: KeyVal +xK_Abrevehook = 0x1001eb2 +xK_abrevehook :: KeyVal +xK_abrevehook = 0x1001eb3 +xK_Abrevetilde :: KeyVal +xK_Abrevetilde = 0x1001eb4 +xK_abrevetilde :: KeyVal +xK_abrevetilde = 0x1001eb5 +xK_Abrevebelowdot :: KeyVal +xK_Abrevebelowdot = 0x1001eb6 +xK_abrevebelowdot :: KeyVal +xK_abrevebelowdot = 0x1001eb7 +xK_Ebelowdot :: KeyVal +xK_Ebelowdot = 0x1001eb8 +xK_ebelowdot :: KeyVal +xK_ebelowdot = 0x1001eb9 +xK_Ehook :: KeyVal +xK_Ehook = 0x1001eba +xK_ehook :: KeyVal +xK_ehook = 0x1001ebb +xK_Etilde :: KeyVal +xK_Etilde = 0x1001ebc +xK_etilde :: KeyVal +xK_etilde = 0x1001ebd +xK_Ecircumflexacute :: KeyVal +xK_Ecircumflexacute = 0x1001ebe +xK_ecircumflexacute :: KeyVal +xK_ecircumflexacute = 0x1001ebf +xK_Ecircumflexgrave :: KeyVal +xK_Ecircumflexgrave = 0x1001ec0 +xK_ecircumflexgrave :: KeyVal +xK_ecircumflexgrave = 0x1001ec1 +xK_Ecircumflexhook :: KeyVal +xK_Ecircumflexhook = 0x1001ec2 +xK_ecircumflexhook :: KeyVal +xK_ecircumflexhook = 0x1001ec3 +xK_Ecircumflextilde :: KeyVal +xK_Ecircumflextilde = 0x1001ec4 +xK_ecircumflextilde :: KeyVal +xK_ecircumflextilde = 0x1001ec5 +xK_Ecircumflexbelowdot :: KeyVal +xK_Ecircumflexbelowdot = 0x1001ec6 +xK_ecircumflexbelowdot :: KeyVal +xK_ecircumflexbelowdot = 0x1001ec7 +xK_Ihook :: KeyVal +xK_Ihook = 0x1001ec8 +xK_ihook :: KeyVal +xK_ihook = 0x1001ec9 +xK_Ibelowdot :: KeyVal +xK_Ibelowdot = 0x1001eca +xK_ibelowdot :: KeyVal +xK_ibelowdot = 0x1001ecb +xK_Obelowdot :: KeyVal +xK_Obelowdot = 0x1001ecc +xK_obelowdot :: KeyVal +xK_obelowdot = 0x1001ecd +xK_Ohook :: KeyVal +xK_Ohook = 0x1001ece +xK_ohook :: KeyVal +xK_ohook = 0x1001ecf +xK_Ocircumflexacute :: KeyVal +xK_Ocircumflexacute = 0x1001ed0 +xK_ocircumflexacute :: KeyVal +xK_ocircumflexacute = 0x1001ed1 +xK_Ocircumflexgrave :: KeyVal +xK_Ocircumflexgrave = 0x1001ed2 +xK_ocircumflexgrave :: KeyVal +xK_ocircumflexgrave = 0x1001ed3 +xK_Ocircumflexhook :: KeyVal +xK_Ocircumflexhook = 0x1001ed4 +xK_ocircumflexhook :: KeyVal +xK_ocircumflexhook = 0x1001ed5 +xK_Ocircumflextilde :: KeyVal +xK_Ocircumflextilde = 0x1001ed6 +xK_ocircumflextilde :: KeyVal +xK_ocircumflextilde = 0x1001ed7 +xK_Ocircumflexbelowdot :: KeyVal +xK_Ocircumflexbelowdot = 0x1001ed8 +xK_ocircumflexbelowdot :: KeyVal +xK_ocircumflexbelowdot = 0x1001ed9 +xK_Ohornacute :: KeyVal +xK_Ohornacute = 0x1001eda +xK_ohornacute :: KeyVal +xK_ohornacute = 0x1001edb +xK_Ohorngrave :: KeyVal +xK_Ohorngrave = 0x1001edc +xK_ohorngrave :: KeyVal +xK_ohorngrave = 0x1001edd +xK_Ohornhook :: KeyVal +xK_Ohornhook = 0x1001ede +xK_ohornhook :: KeyVal +xK_ohornhook = 0x1001edf +xK_Ohorntilde :: KeyVal +xK_Ohorntilde = 0x1001ee0 +xK_ohorntilde :: KeyVal +xK_ohorntilde = 0x1001ee1 +xK_Ohornbelowdot :: KeyVal +xK_Ohornbelowdot = 0x1001ee2 +xK_ohornbelowdot :: KeyVal +xK_ohornbelowdot = 0x1001ee3 +xK_Ubelowdot :: KeyVal +xK_Ubelowdot = 0x1001ee4 +xK_ubelowdot :: KeyVal +xK_ubelowdot = 0x1001ee5 +xK_Uhook :: KeyVal +xK_Uhook = 0x1001ee6 +xK_uhook :: KeyVal +xK_uhook = 0x1001ee7 +xK_Uhornacute :: KeyVal +xK_Uhornacute = 0x1001ee8 +xK_uhornacute :: KeyVal +xK_uhornacute = 0x1001ee9 +xK_Uhorngrave :: KeyVal +xK_Uhorngrave = 0x1001eea +xK_uhorngrave :: KeyVal +xK_uhorngrave = 0x1001eeb +xK_Uhornhook :: KeyVal +xK_Uhornhook = 0x1001eec +xK_uhornhook :: KeyVal +xK_uhornhook = 0x1001eed +xK_Uhorntilde :: KeyVal +xK_Uhorntilde = 0x1001eee +xK_uhorntilde :: KeyVal +xK_uhorntilde = 0x1001eef +xK_Uhornbelowdot :: KeyVal +xK_Uhornbelowdot = 0x1001ef0 +xK_uhornbelowdot :: KeyVal +xK_uhornbelowdot = 0x1001ef1 +xK_Ybelowdot :: KeyVal +xK_Ybelowdot = 0x1001ef4 +xK_ybelowdot :: KeyVal +xK_ybelowdot = 0x1001ef5 +xK_Yhook :: KeyVal +xK_Yhook = 0x1001ef6 +xK_yhook :: KeyVal +xK_yhook = 0x1001ef7 +xK_Ytilde :: KeyVal +xK_Ytilde = 0x1001ef8 +xK_ytilde :: KeyVal +xK_ytilde = 0x1001ef9 +xK_Ohorn :: KeyVal +xK_Ohorn = 0x10001a0 +xK_ohorn :: KeyVal +xK_ohorn = 0x10001a1 +xK_Uhorn :: KeyVal +xK_Uhorn = 0x10001af +xK_uhorn :: KeyVal +xK_uhorn = 0x10001b0 +xK_EcuSign :: KeyVal +xK_EcuSign = 0x10020a0 +xK_ColonSign :: KeyVal +xK_ColonSign = 0x10020a1 +xK_CruzeiroSign :: KeyVal +xK_CruzeiroSign = 0x10020a2 +xK_FFrancSign :: KeyVal +xK_FFrancSign = 0x10020a3 +xK_LiraSign :: KeyVal +xK_LiraSign = 0x10020a4 +xK_MillSign :: KeyVal +xK_MillSign = 0x10020a5 +xK_NairaSign :: KeyVal +xK_NairaSign = 0x10020a6 +xK_PesetaSign :: KeyVal +xK_PesetaSign = 0x10020a7 +xK_RupeeSign :: KeyVal +xK_RupeeSign = 0x10020a8 +xK_WonSign :: KeyVal +xK_WonSign = 0x10020a9 +xK_NewSheqelSign :: KeyVal +xK_NewSheqelSign = 0x10020aa +xK_DongSign :: KeyVal +xK_DongSign = 0x10020ab +xK_EuroSign :: KeyVal +xK_EuroSign = 0x20ac +xK_zerosuperior :: KeyVal +xK_zerosuperior = 0x1002070 +xK_foursuperior :: KeyVal +xK_foursuperior = 0x1002074 +xK_fivesuperior :: KeyVal +xK_fivesuperior = 0x1002075 +xK_sixsuperior :: KeyVal +xK_sixsuperior = 0x1002076 +xK_sevensuperior :: KeyVal +xK_sevensuperior = 0x1002077 +xK_eightsuperior :: KeyVal +xK_eightsuperior = 0x1002078 +xK_ninesuperior :: KeyVal +xK_ninesuperior = 0x1002079 +xK_zerosubscript :: KeyVal +xK_zerosubscript = 0x1002080 +xK_onesubscript :: KeyVal +xK_onesubscript = 0x1002081 +xK_twosubscript :: KeyVal +xK_twosubscript = 0x1002082 +xK_threesubscript :: KeyVal +xK_threesubscript = 0x1002083 +xK_foursubscript :: KeyVal +xK_foursubscript = 0x1002084 +xK_fivesubscript :: KeyVal +xK_fivesubscript = 0x1002085 +xK_sixsubscript :: KeyVal +xK_sixsubscript = 0x1002086 +xK_sevensubscript :: KeyVal +xK_sevensubscript = 0x1002087 +xK_eightsubscript :: KeyVal +xK_eightsubscript = 0x1002088 +xK_ninesubscript :: KeyVal +xK_ninesubscript = 0x1002089 +xK_partdifferential :: KeyVal +xK_partdifferential = 0x1002202 +xK_emptyset :: KeyVal +xK_emptyset = 0x1002205 +xK_elementof :: KeyVal +xK_elementof = 0x1002208 +xK_notelementof :: KeyVal +xK_notelementof = 0x1002209 +xK_containsas :: KeyVal +xK_containsas = 0x100220b +xK_squareroot :: KeyVal +xK_squareroot = 0x100221a +xK_cuberoot :: KeyVal +xK_cuberoot = 0x100221b +xK_fourthroot :: KeyVal +xK_fourthroot = 0x100221c +xK_dintegral :: KeyVal +xK_dintegral = 0x100222c +xK_tintegral :: KeyVal +xK_tintegral = 0x100222d +xK_because :: KeyVal +xK_because = 0x1002235 +xK_approxeq :: KeyVal +xK_approxeq = 0x1002248 +xK_notapproxeq :: KeyVal +xK_notapproxeq = 0x1002247 +xK_notidentical :: KeyVal +xK_notidentical = 0x1002262 +xK_stricteq :: KeyVal +xK_stricteq = 0x1002263 +xK_braille_dot_1 :: KeyVal +xK_braille_dot_1 = 0xfff1 +xK_braille_dot_2 :: KeyVal +xK_braille_dot_2 = 0xfff2 +xK_braille_dot_3 :: KeyVal +xK_braille_dot_3 = 0xfff3 +xK_braille_dot_4 :: KeyVal +xK_braille_dot_4 = 0xfff4 +xK_braille_dot_5 :: KeyVal +xK_braille_dot_5 = 0xfff5 +xK_braille_dot_6 :: KeyVal +xK_braille_dot_6 = 0xfff6 +xK_braille_dot_7 :: KeyVal +xK_braille_dot_7 = 0xfff7 +xK_braille_dot_8 :: KeyVal +xK_braille_dot_8 = 0xfff8 +xK_braille_dot_9 :: KeyVal +xK_braille_dot_9 = 0xfff9 +xK_braille_dot_10 :: KeyVal +xK_braille_dot_10 = 0xfffa +xK_braille_blank :: KeyVal +xK_braille_blank = 0x1002800 +xK_braille_dots_1 :: KeyVal +xK_braille_dots_1 = 0x1002801 +xK_braille_dots_2 :: KeyVal +xK_braille_dots_2 = 0x1002802 +xK_braille_dots_12 :: KeyVal +xK_braille_dots_12 = 0x1002803 +xK_braille_dots_3 :: KeyVal +xK_braille_dots_3 = 0x1002804 +xK_braille_dots_13 :: KeyVal +xK_braille_dots_13 = 0x1002805 +xK_braille_dots_23 :: KeyVal +xK_braille_dots_23 = 0x1002806 +xK_braille_dots_123 :: KeyVal +xK_braille_dots_123 = 0x1002807 +xK_braille_dots_4 :: KeyVal +xK_braille_dots_4 = 0x1002808 +xK_braille_dots_14 :: KeyVal +xK_braille_dots_14 = 0x1002809 +xK_braille_dots_24 :: KeyVal +xK_braille_dots_24 = 0x100280a +xK_braille_dots_124 :: KeyVal +xK_braille_dots_124 = 0x100280b +xK_braille_dots_34 :: KeyVal +xK_braille_dots_34 = 0x100280c +xK_braille_dots_134 :: KeyVal +xK_braille_dots_134 = 0x100280d +xK_braille_dots_234 :: KeyVal +xK_braille_dots_234 = 0x100280e +xK_braille_dots_1234 :: KeyVal +xK_braille_dots_1234 = 0x100280f +xK_braille_dots_5 :: KeyVal +xK_braille_dots_5 = 0x1002810 +xK_braille_dots_15 :: KeyVal +xK_braille_dots_15 = 0x1002811 +xK_braille_dots_25 :: KeyVal +xK_braille_dots_25 = 0x1002812 +xK_braille_dots_125 :: KeyVal +xK_braille_dots_125 = 0x1002813 +xK_braille_dots_35 :: KeyVal +xK_braille_dots_35 = 0x1002814 +xK_braille_dots_135 :: KeyVal +xK_braille_dots_135 = 0x1002815 +xK_braille_dots_235 :: KeyVal +xK_braille_dots_235 = 0x1002816 +xK_braille_dots_1235 :: KeyVal +xK_braille_dots_1235 = 0x1002817 +xK_braille_dots_45 :: KeyVal +xK_braille_dots_45 = 0x1002818 +xK_braille_dots_145 :: KeyVal +xK_braille_dots_145 = 0x1002819 +xK_braille_dots_245 :: KeyVal +xK_braille_dots_245 = 0x100281a +xK_braille_dots_1245 :: KeyVal +xK_braille_dots_1245 = 0x100281b +xK_braille_dots_345 :: KeyVal +xK_braille_dots_345 = 0x100281c +xK_braille_dots_1345 :: KeyVal +xK_braille_dots_1345 = 0x100281d +xK_braille_dots_2345 :: KeyVal +xK_braille_dots_2345 = 0x100281e +xK_braille_dots_12345 :: KeyVal +xK_braille_dots_12345 = 0x100281f +xK_braille_dots_6 :: KeyVal +xK_braille_dots_6 = 0x1002820 +xK_braille_dots_16 :: KeyVal +xK_braille_dots_16 = 0x1002821 +xK_braille_dots_26 :: KeyVal +xK_braille_dots_26 = 0x1002822 +xK_braille_dots_126 :: KeyVal +xK_braille_dots_126 = 0x1002823 +xK_braille_dots_36 :: KeyVal +xK_braille_dots_36 = 0x1002824 +xK_braille_dots_136 :: KeyVal +xK_braille_dots_136 = 0x1002825 +xK_braille_dots_236 :: KeyVal +xK_braille_dots_236 = 0x1002826 +xK_braille_dots_1236 :: KeyVal +xK_braille_dots_1236 = 0x1002827 +xK_braille_dots_46 :: KeyVal +xK_braille_dots_46 = 0x1002828 +xK_braille_dots_146 :: KeyVal +xK_braille_dots_146 = 0x1002829 +xK_braille_dots_246 :: KeyVal +xK_braille_dots_246 = 0x100282a +xK_braille_dots_1246 :: KeyVal +xK_braille_dots_1246 = 0x100282b +xK_braille_dots_346 :: KeyVal +xK_braille_dots_346 = 0x100282c +xK_braille_dots_1346 :: KeyVal +xK_braille_dots_1346 = 0x100282d +xK_braille_dots_2346 :: KeyVal +xK_braille_dots_2346 = 0x100282e +xK_braille_dots_12346 :: KeyVal +xK_braille_dots_12346 = 0x100282f +xK_braille_dots_56 :: KeyVal +xK_braille_dots_56 = 0x1002830 +xK_braille_dots_156 :: KeyVal +xK_braille_dots_156 = 0x1002831 +xK_braille_dots_256 :: KeyVal +xK_braille_dots_256 = 0x1002832 +xK_braille_dots_1256 :: KeyVal +xK_braille_dots_1256 = 0x1002833 +xK_braille_dots_356 :: KeyVal +xK_braille_dots_356 = 0x1002834 +xK_braille_dots_1356 :: KeyVal +xK_braille_dots_1356 = 0x1002835 +xK_braille_dots_2356 :: KeyVal +xK_braille_dots_2356 = 0x1002836 +xK_braille_dots_12356 :: KeyVal +xK_braille_dots_12356 = 0x1002837 +xK_braille_dots_456 :: KeyVal +xK_braille_dots_456 = 0x1002838 +xK_braille_dots_1456 :: KeyVal +xK_braille_dots_1456 = 0x1002839 +xK_braille_dots_2456 :: KeyVal +xK_braille_dots_2456 = 0x100283a +xK_braille_dots_12456 :: KeyVal +xK_braille_dots_12456 = 0x100283b +xK_braille_dots_3456 :: KeyVal +xK_braille_dots_3456 = 0x100283c +xK_braille_dots_13456 :: KeyVal +xK_braille_dots_13456 = 0x100283d +xK_braille_dots_23456 :: KeyVal +xK_braille_dots_23456 = 0x100283e +xK_braille_dots_123456 :: KeyVal +xK_braille_dots_123456 = 0x100283f +xK_braille_dots_7 :: KeyVal +xK_braille_dots_7 = 0x1002840 +xK_braille_dots_17 :: KeyVal +xK_braille_dots_17 = 0x1002841 +xK_braille_dots_27 :: KeyVal +xK_braille_dots_27 = 0x1002842 +xK_braille_dots_127 :: KeyVal +xK_braille_dots_127 = 0x1002843 +xK_braille_dots_37 :: KeyVal +xK_braille_dots_37 = 0x1002844 +xK_braille_dots_137 :: KeyVal +xK_braille_dots_137 = 0x1002845 +xK_braille_dots_237 :: KeyVal +xK_braille_dots_237 = 0x1002846 +xK_braille_dots_1237 :: KeyVal +xK_braille_dots_1237 = 0x1002847 +xK_braille_dots_47 :: KeyVal +xK_braille_dots_47 = 0x1002848 +xK_braille_dots_147 :: KeyVal +xK_braille_dots_147 = 0x1002849 +xK_braille_dots_247 :: KeyVal +xK_braille_dots_247 = 0x100284a +xK_braille_dots_1247 :: KeyVal +xK_braille_dots_1247 = 0x100284b +xK_braille_dots_347 :: KeyVal +xK_braille_dots_347 = 0x100284c +xK_braille_dots_1347 :: KeyVal +xK_braille_dots_1347 = 0x100284d +xK_braille_dots_2347 :: KeyVal +xK_braille_dots_2347 = 0x100284e +xK_braille_dots_12347 :: KeyVal +xK_braille_dots_12347 = 0x100284f +xK_braille_dots_57 :: KeyVal +xK_braille_dots_57 = 0x1002850 +xK_braille_dots_157 :: KeyVal +xK_braille_dots_157 = 0x1002851 +xK_braille_dots_257 :: KeyVal +xK_braille_dots_257 = 0x1002852 +xK_braille_dots_1257 :: KeyVal +xK_braille_dots_1257 = 0x1002853 +xK_braille_dots_357 :: KeyVal +xK_braille_dots_357 = 0x1002854 +xK_braille_dots_1357 :: KeyVal +xK_braille_dots_1357 = 0x1002855 +xK_braille_dots_2357 :: KeyVal +xK_braille_dots_2357 = 0x1002856 +xK_braille_dots_12357 :: KeyVal +xK_braille_dots_12357 = 0x1002857 +xK_braille_dots_457 :: KeyVal +xK_braille_dots_457 = 0x1002858 +xK_braille_dots_1457 :: KeyVal +xK_braille_dots_1457 = 0x1002859 +xK_braille_dots_2457 :: KeyVal +xK_braille_dots_2457 = 0x100285a +xK_braille_dots_12457 :: KeyVal +xK_braille_dots_12457 = 0x100285b +xK_braille_dots_3457 :: KeyVal +xK_braille_dots_3457 = 0x100285c +xK_braille_dots_13457 :: KeyVal +xK_braille_dots_13457 = 0x100285d +xK_braille_dots_23457 :: KeyVal +xK_braille_dots_23457 = 0x100285e +xK_braille_dots_123457 :: KeyVal +xK_braille_dots_123457 = 0x100285f +xK_braille_dots_67 :: KeyVal +xK_braille_dots_67 = 0x1002860 +xK_braille_dots_167 :: KeyVal +xK_braille_dots_167 = 0x1002861 +xK_braille_dots_267 :: KeyVal +xK_braille_dots_267 = 0x1002862 +xK_braille_dots_1267 :: KeyVal +xK_braille_dots_1267 = 0x1002863 +xK_braille_dots_367 :: KeyVal +xK_braille_dots_367 = 0x1002864 +xK_braille_dots_1367 :: KeyVal +xK_braille_dots_1367 = 0x1002865 +xK_braille_dots_2367 :: KeyVal +xK_braille_dots_2367 = 0x1002866 +xK_braille_dots_12367 :: KeyVal +xK_braille_dots_12367 = 0x1002867 +xK_braille_dots_467 :: KeyVal +xK_braille_dots_467 = 0x1002868 +xK_braille_dots_1467 :: KeyVal +xK_braille_dots_1467 = 0x1002869 +xK_braille_dots_2467 :: KeyVal +xK_braille_dots_2467 = 0x100286a +xK_braille_dots_12467 :: KeyVal +xK_braille_dots_12467 = 0x100286b +xK_braille_dots_3467 :: KeyVal +xK_braille_dots_3467 = 0x100286c +xK_braille_dots_13467 :: KeyVal +xK_braille_dots_13467 = 0x100286d +xK_braille_dots_23467 :: KeyVal +xK_braille_dots_23467 = 0x100286e +xK_braille_dots_123467 :: KeyVal +xK_braille_dots_123467 = 0x100286f +xK_braille_dots_567 :: KeyVal +xK_braille_dots_567 = 0x1002870 +xK_braille_dots_1567 :: KeyVal +xK_braille_dots_1567 = 0x1002871 +xK_braille_dots_2567 :: KeyVal +xK_braille_dots_2567 = 0x1002872 +xK_braille_dots_12567 :: KeyVal +xK_braille_dots_12567 = 0x1002873 +xK_braille_dots_3567 :: KeyVal +xK_braille_dots_3567 = 0x1002874 +xK_braille_dots_13567 :: KeyVal +xK_braille_dots_13567 = 0x1002875 +xK_braille_dots_23567 :: KeyVal +xK_braille_dots_23567 = 0x1002876 +xK_braille_dots_123567 :: KeyVal +xK_braille_dots_123567 = 0x1002877 +xK_braille_dots_4567 :: KeyVal +xK_braille_dots_4567 = 0x1002878 +xK_braille_dots_14567 :: KeyVal +xK_braille_dots_14567 = 0x1002879 +xK_braille_dots_24567 :: KeyVal +xK_braille_dots_24567 = 0x100287a +xK_braille_dots_124567 :: KeyVal +xK_braille_dots_124567 = 0x100287b +xK_braille_dots_34567 :: KeyVal +xK_braille_dots_34567 = 0x100287c +xK_braille_dots_134567 :: KeyVal +xK_braille_dots_134567 = 0x100287d +xK_braille_dots_234567 :: KeyVal +xK_braille_dots_234567 = 0x100287e +xK_braille_dots_1234567 :: KeyVal +xK_braille_dots_1234567 = 0x100287f +xK_braille_dots_8 :: KeyVal +xK_braille_dots_8 = 0x1002880 +xK_braille_dots_18 :: KeyVal +xK_braille_dots_18 = 0x1002881 +xK_braille_dots_28 :: KeyVal +xK_braille_dots_28 = 0x1002882 +xK_braille_dots_128 :: KeyVal +xK_braille_dots_128 = 0x1002883 +xK_braille_dots_38 :: KeyVal +xK_braille_dots_38 = 0x1002884 +xK_braille_dots_138 :: KeyVal +xK_braille_dots_138 = 0x1002885 +xK_braille_dots_238 :: KeyVal +xK_braille_dots_238 = 0x1002886 +xK_braille_dots_1238 :: KeyVal +xK_braille_dots_1238 = 0x1002887 +xK_braille_dots_48 :: KeyVal +xK_braille_dots_48 = 0x1002888 +xK_braille_dots_148 :: KeyVal +xK_braille_dots_148 = 0x1002889 +xK_braille_dots_248 :: KeyVal +xK_braille_dots_248 = 0x100288a +xK_braille_dots_1248 :: KeyVal +xK_braille_dots_1248 = 0x100288b +xK_braille_dots_348 :: KeyVal +xK_braille_dots_348 = 0x100288c +xK_braille_dots_1348 :: KeyVal +xK_braille_dots_1348 = 0x100288d +xK_braille_dots_2348 :: KeyVal +xK_braille_dots_2348 = 0x100288e +xK_braille_dots_12348 :: KeyVal +xK_braille_dots_12348 = 0x100288f +xK_braille_dots_58 :: KeyVal +xK_braille_dots_58 = 0x1002890 +xK_braille_dots_158 :: KeyVal +xK_braille_dots_158 = 0x1002891 +xK_braille_dots_258 :: KeyVal +xK_braille_dots_258 = 0x1002892 +xK_braille_dots_1258 :: KeyVal +xK_braille_dots_1258 = 0x1002893 +xK_braille_dots_358 :: KeyVal +xK_braille_dots_358 = 0x1002894 +xK_braille_dots_1358 :: KeyVal +xK_braille_dots_1358 = 0x1002895 +xK_braille_dots_2358 :: KeyVal +xK_braille_dots_2358 = 0x1002896 +xK_braille_dots_12358 :: KeyVal +xK_braille_dots_12358 = 0x1002897 +xK_braille_dots_458 :: KeyVal +xK_braille_dots_458 = 0x1002898 +xK_braille_dots_1458 :: KeyVal +xK_braille_dots_1458 = 0x1002899 +xK_braille_dots_2458 :: KeyVal +xK_braille_dots_2458 = 0x100289a +xK_braille_dots_12458 :: KeyVal +xK_braille_dots_12458 = 0x100289b +xK_braille_dots_3458 :: KeyVal +xK_braille_dots_3458 = 0x100289c +xK_braille_dots_13458 :: KeyVal +xK_braille_dots_13458 = 0x100289d +xK_braille_dots_23458 :: KeyVal +xK_braille_dots_23458 = 0x100289e +xK_braille_dots_123458 :: KeyVal +xK_braille_dots_123458 = 0x100289f +xK_braille_dots_68 :: KeyVal +xK_braille_dots_68 = 0x10028a0 +xK_braille_dots_168 :: KeyVal +xK_braille_dots_168 = 0x10028a1 +xK_braille_dots_268 :: KeyVal +xK_braille_dots_268 = 0x10028a2 +xK_braille_dots_1268 :: KeyVal +xK_braille_dots_1268 = 0x10028a3 +xK_braille_dots_368 :: KeyVal +xK_braille_dots_368 = 0x10028a4 +xK_braille_dots_1368 :: KeyVal +xK_braille_dots_1368 = 0x10028a5 +xK_braille_dots_2368 :: KeyVal +xK_braille_dots_2368 = 0x10028a6 +xK_braille_dots_12368 :: KeyVal +xK_braille_dots_12368 = 0x10028a7 +xK_braille_dots_468 :: KeyVal +xK_braille_dots_468 = 0x10028a8 +xK_braille_dots_1468 :: KeyVal +xK_braille_dots_1468 = 0x10028a9 +xK_braille_dots_2468 :: KeyVal +xK_braille_dots_2468 = 0x10028aa +xK_braille_dots_12468 :: KeyVal +xK_braille_dots_12468 = 0x10028ab +xK_braille_dots_3468 :: KeyVal +xK_braille_dots_3468 = 0x10028ac +xK_braille_dots_13468 :: KeyVal +xK_braille_dots_13468 = 0x10028ad +xK_braille_dots_23468 :: KeyVal +xK_braille_dots_23468 = 0x10028ae +xK_braille_dots_123468 :: KeyVal +xK_braille_dots_123468 = 0x10028af +xK_braille_dots_568 :: KeyVal +xK_braille_dots_568 = 0x10028b0 +xK_braille_dots_1568 :: KeyVal +xK_braille_dots_1568 = 0x10028b1 +xK_braille_dots_2568 :: KeyVal +xK_braille_dots_2568 = 0x10028b2 +xK_braille_dots_12568 :: KeyVal +xK_braille_dots_12568 = 0x10028b3 +xK_braille_dots_3568 :: KeyVal +xK_braille_dots_3568 = 0x10028b4 +xK_braille_dots_13568 :: KeyVal +xK_braille_dots_13568 = 0x10028b5 +xK_braille_dots_23568 :: KeyVal +xK_braille_dots_23568 = 0x10028b6 +xK_braille_dots_123568 :: KeyVal +xK_braille_dots_123568 = 0x10028b7 +xK_braille_dots_4568 :: KeyVal +xK_braille_dots_4568 = 0x10028b8 +xK_braille_dots_14568 :: KeyVal +xK_braille_dots_14568 = 0x10028b9 +xK_braille_dots_24568 :: KeyVal +xK_braille_dots_24568 = 0x10028ba +xK_braille_dots_124568 :: KeyVal +xK_braille_dots_124568 = 0x10028bb +xK_braille_dots_34568 :: KeyVal +xK_braille_dots_34568 = 0x10028bc +xK_braille_dots_134568 :: KeyVal +xK_braille_dots_134568 = 0x10028bd +xK_braille_dots_234568 :: KeyVal +xK_braille_dots_234568 = 0x10028be +xK_braille_dots_1234568 :: KeyVal +xK_braille_dots_1234568 = 0x10028bf +xK_braille_dots_78 :: KeyVal +xK_braille_dots_78 = 0x10028c0 +xK_braille_dots_178 :: KeyVal +xK_braille_dots_178 = 0x10028c1 +xK_braille_dots_278 :: KeyVal +xK_braille_dots_278 = 0x10028c2 +xK_braille_dots_1278 :: KeyVal +xK_braille_dots_1278 = 0x10028c3 +xK_braille_dots_378 :: KeyVal +xK_braille_dots_378 = 0x10028c4 +xK_braille_dots_1378 :: KeyVal +xK_braille_dots_1378 = 0x10028c5 +xK_braille_dots_2378 :: KeyVal +xK_braille_dots_2378 = 0x10028c6 +xK_braille_dots_12378 :: KeyVal +xK_braille_dots_12378 = 0x10028c7 +xK_braille_dots_478 :: KeyVal +xK_braille_dots_478 = 0x10028c8 +xK_braille_dots_1478 :: KeyVal +xK_braille_dots_1478 = 0x10028c9 +xK_braille_dots_2478 :: KeyVal +xK_braille_dots_2478 = 0x10028ca +xK_braille_dots_12478 :: KeyVal +xK_braille_dots_12478 = 0x10028cb +xK_braille_dots_3478 :: KeyVal +xK_braille_dots_3478 = 0x10028cc +xK_braille_dots_13478 :: KeyVal +xK_braille_dots_13478 = 0x10028cd +xK_braille_dots_23478 :: KeyVal +xK_braille_dots_23478 = 0x10028ce +xK_braille_dots_123478 :: KeyVal +xK_braille_dots_123478 = 0x10028cf +xK_braille_dots_578 :: KeyVal +xK_braille_dots_578 = 0x10028d0 +xK_braille_dots_1578 :: KeyVal +xK_braille_dots_1578 = 0x10028d1 +xK_braille_dots_2578 :: KeyVal +xK_braille_dots_2578 = 0x10028d2 +xK_braille_dots_12578 :: KeyVal +xK_braille_dots_12578 = 0x10028d3 +xK_braille_dots_3578 :: KeyVal +xK_braille_dots_3578 = 0x10028d4 +xK_braille_dots_13578 :: KeyVal +xK_braille_dots_13578 = 0x10028d5 +xK_braille_dots_23578 :: KeyVal +xK_braille_dots_23578 = 0x10028d6 +xK_braille_dots_123578 :: KeyVal +xK_braille_dots_123578 = 0x10028d7 +xK_braille_dots_4578 :: KeyVal +xK_braille_dots_4578 = 0x10028d8 +xK_braille_dots_14578 :: KeyVal +xK_braille_dots_14578 = 0x10028d9 +xK_braille_dots_24578 :: KeyVal +xK_braille_dots_24578 = 0x10028da +xK_braille_dots_124578 :: KeyVal +xK_braille_dots_124578 = 0x10028db +xK_braille_dots_34578 :: KeyVal +xK_braille_dots_34578 = 0x10028dc +xK_braille_dots_134578 :: KeyVal +xK_braille_dots_134578 = 0x10028dd +xK_braille_dots_234578 :: KeyVal +xK_braille_dots_234578 = 0x10028de +xK_braille_dots_1234578 :: KeyVal +xK_braille_dots_1234578 = 0x10028df +xK_braille_dots_678 :: KeyVal +xK_braille_dots_678 = 0x10028e0 +xK_braille_dots_1678 :: KeyVal +xK_braille_dots_1678 = 0x10028e1 +xK_braille_dots_2678 :: KeyVal +xK_braille_dots_2678 = 0x10028e2 +xK_braille_dots_12678 :: KeyVal +xK_braille_dots_12678 = 0x10028e3 +xK_braille_dots_3678 :: KeyVal +xK_braille_dots_3678 = 0x10028e4 +xK_braille_dots_13678 :: KeyVal +xK_braille_dots_13678 = 0x10028e5 +xK_braille_dots_23678 :: KeyVal +xK_braille_dots_23678 = 0x10028e6 +xK_braille_dots_123678 :: KeyVal +xK_braille_dots_123678 = 0x10028e7 +xK_braille_dots_4678 :: KeyVal +xK_braille_dots_4678 = 0x10028e8 +xK_braille_dots_14678 :: KeyVal +xK_braille_dots_14678 = 0x10028e9 +xK_braille_dots_24678 :: KeyVal +xK_braille_dots_24678 = 0x10028ea +xK_braille_dots_124678 :: KeyVal +xK_braille_dots_124678 = 0x10028eb +xK_braille_dots_34678 :: KeyVal +xK_braille_dots_34678 = 0x10028ec +xK_braille_dots_134678 :: KeyVal +xK_braille_dots_134678 = 0x10028ed +xK_braille_dots_234678 :: KeyVal +xK_braille_dots_234678 = 0x10028ee +xK_braille_dots_1234678 :: KeyVal +xK_braille_dots_1234678 = 0x10028ef +xK_braille_dots_5678 :: KeyVal +xK_braille_dots_5678 = 0x10028f0 +xK_braille_dots_15678 :: KeyVal +xK_braille_dots_15678 = 0x10028f1 +xK_braille_dots_25678 :: KeyVal +xK_braille_dots_25678 = 0x10028f2 +xK_braille_dots_125678 :: KeyVal +xK_braille_dots_125678 = 0x10028f3 +xK_braille_dots_35678 :: KeyVal +xK_braille_dots_35678 = 0x10028f4 +xK_braille_dots_135678 :: KeyVal +xK_braille_dots_135678 = 0x10028f5 +xK_braille_dots_235678 :: KeyVal +xK_braille_dots_235678 = 0x10028f6 +xK_braille_dots_1235678 :: KeyVal +xK_braille_dots_1235678 = 0x10028f7 +xK_braille_dots_45678 :: KeyVal +xK_braille_dots_45678 = 0x10028f8 +xK_braille_dots_145678 :: KeyVal +xK_braille_dots_145678 = 0x10028f9 +xK_braille_dots_245678 :: KeyVal +xK_braille_dots_245678 = 0x10028fa +xK_braille_dots_1245678 :: KeyVal +xK_braille_dots_1245678 = 0x10028fb +xK_braille_dots_345678 :: KeyVal +xK_braille_dots_345678 = 0x10028fc +xK_braille_dots_1345678 :: KeyVal +xK_braille_dots_1345678 = 0x10028fd +xK_braille_dots_2345678 :: KeyVal +xK_braille_dots_2345678 = 0x10028fe +xK_braille_dots_12345678 :: KeyVal +xK_braille_dots_12345678 = 0x10028ff +xK_Sinh_ng :: KeyVal +xK_Sinh_ng = 0x1000d82 +xK_Sinh_h2 :: KeyVal +xK_Sinh_h2 = 0x1000d83 +xK_Sinh_a :: KeyVal +xK_Sinh_a = 0x1000d85 +xK_Sinh_aa :: KeyVal +xK_Sinh_aa = 0x1000d86 +xK_Sinh_ae :: KeyVal +xK_Sinh_ae = 0x1000d87 +xK_Sinh_aee :: KeyVal +xK_Sinh_aee = 0x1000d88 +xK_Sinh_i :: KeyVal +xK_Sinh_i = 0x1000d89 +xK_Sinh_ii :: KeyVal +xK_Sinh_ii = 0x1000d8a +xK_Sinh_u :: KeyVal +xK_Sinh_u = 0x1000d8b +xK_Sinh_uu :: KeyVal +xK_Sinh_uu = 0x1000d8c +xK_Sinh_ri :: KeyVal +xK_Sinh_ri = 0x1000d8d +xK_Sinh_rii :: KeyVal +xK_Sinh_rii = 0x1000d8e +xK_Sinh_lu :: KeyVal +xK_Sinh_lu = 0x1000d8f +xK_Sinh_luu :: KeyVal +xK_Sinh_luu = 0x1000d90 +xK_Sinh_e :: KeyVal +xK_Sinh_e = 0x1000d91 +xK_Sinh_ee :: KeyVal +xK_Sinh_ee = 0x1000d92 +xK_Sinh_ai :: KeyVal +xK_Sinh_ai = 0x1000d93 +xK_Sinh_o :: KeyVal +xK_Sinh_o = 0x1000d94 +xK_Sinh_oo :: KeyVal +xK_Sinh_oo = 0x1000d95 +xK_Sinh_au :: KeyVal +xK_Sinh_au = 0x1000d96 +xK_Sinh_ka :: KeyVal +xK_Sinh_ka = 0x1000d9a +xK_Sinh_kha :: KeyVal +xK_Sinh_kha = 0x1000d9b +xK_Sinh_ga :: KeyVal +xK_Sinh_ga = 0x1000d9c +xK_Sinh_gha :: KeyVal +xK_Sinh_gha = 0x1000d9d +xK_Sinh_ng2 :: KeyVal +xK_Sinh_ng2 = 0x1000d9e +xK_Sinh_nga :: KeyVal +xK_Sinh_nga = 0x1000d9f +xK_Sinh_ca :: KeyVal +xK_Sinh_ca = 0x1000da0 +xK_Sinh_cha :: KeyVal +xK_Sinh_cha = 0x1000da1 +xK_Sinh_ja :: KeyVal +xK_Sinh_ja = 0x1000da2 +xK_Sinh_jha :: KeyVal +xK_Sinh_jha = 0x1000da3 +xK_Sinh_nya :: KeyVal +xK_Sinh_nya = 0x1000da4 +xK_Sinh_jnya :: KeyVal +xK_Sinh_jnya = 0x1000da5 +xK_Sinh_nja :: KeyVal +xK_Sinh_nja = 0x1000da6 +xK_Sinh_tta :: KeyVal +xK_Sinh_tta = 0x1000da7 +xK_Sinh_ttha :: KeyVal +xK_Sinh_ttha = 0x1000da8 +xK_Sinh_dda :: KeyVal +xK_Sinh_dda = 0x1000da9 +xK_Sinh_ddha :: KeyVal +xK_Sinh_ddha = 0x1000daa +xK_Sinh_nna :: KeyVal +xK_Sinh_nna = 0x1000dab +xK_Sinh_ndda :: KeyVal +xK_Sinh_ndda = 0x1000dac +xK_Sinh_tha :: KeyVal +xK_Sinh_tha = 0x1000dad +xK_Sinh_thha :: KeyVal +xK_Sinh_thha = 0x1000dae +xK_Sinh_dha :: KeyVal +xK_Sinh_dha = 0x1000daf +xK_Sinh_dhha :: KeyVal +xK_Sinh_dhha = 0x1000db0 +xK_Sinh_na :: KeyVal +xK_Sinh_na = 0x1000db1 +xK_Sinh_ndha :: KeyVal +xK_Sinh_ndha = 0x1000db3 +xK_Sinh_pa :: KeyVal +xK_Sinh_pa = 0x1000db4 +xK_Sinh_pha :: KeyVal +xK_Sinh_pha = 0x1000db5 +xK_Sinh_ba :: KeyVal +xK_Sinh_ba = 0x1000db6 +xK_Sinh_bha :: KeyVal +xK_Sinh_bha = 0x1000db7 +xK_Sinh_ma :: KeyVal +xK_Sinh_ma = 0x1000db8 +xK_Sinh_mba :: KeyVal +xK_Sinh_mba = 0x1000db9 +xK_Sinh_ya :: KeyVal +xK_Sinh_ya = 0x1000dba +xK_Sinh_ra :: KeyVal +xK_Sinh_ra = 0x1000dbb +xK_Sinh_la :: KeyVal +xK_Sinh_la = 0x1000dbd +xK_Sinh_va :: KeyVal +xK_Sinh_va = 0x1000dc0 +xK_Sinh_sha :: KeyVal +xK_Sinh_sha = 0x1000dc1 +xK_Sinh_ssha :: KeyVal +xK_Sinh_ssha = 0x1000dc2 +xK_Sinh_sa :: KeyVal +xK_Sinh_sa = 0x1000dc3 +xK_Sinh_ha :: KeyVal +xK_Sinh_ha = 0x1000dc4 +xK_Sinh_lla :: KeyVal +xK_Sinh_lla = 0x1000dc5 +xK_Sinh_fa :: KeyVal +xK_Sinh_fa = 0x1000dc6 +xK_Sinh_al :: KeyVal +xK_Sinh_al = 0x1000dca +xK_Sinh_aa2 :: KeyVal +xK_Sinh_aa2 = 0x1000dcf +xK_Sinh_ae2 :: KeyVal +xK_Sinh_ae2 = 0x1000dd0 +xK_Sinh_aee2 :: KeyVal +xK_Sinh_aee2 = 0x1000dd1 +xK_Sinh_i2 :: KeyVal +xK_Sinh_i2 = 0x1000dd2 +xK_Sinh_ii2 :: KeyVal +xK_Sinh_ii2 = 0x1000dd3 +xK_Sinh_u2 :: KeyVal +xK_Sinh_u2 = 0x1000dd4 +xK_Sinh_uu2 :: KeyVal +xK_Sinh_uu2 = 0x1000dd6 +xK_Sinh_ru2 :: KeyVal +xK_Sinh_ru2 = 0x1000dd8 +xK_Sinh_e2 :: KeyVal +xK_Sinh_e2 = 0x1000dd9 +xK_Sinh_ee2 :: KeyVal +xK_Sinh_ee2 = 0x1000dda +xK_Sinh_ai2 :: KeyVal +xK_Sinh_ai2 = 0x1000ddb +xK_Sinh_o2 :: KeyVal +xK_Sinh_o2 = 0x1000ddc +xK_Sinh_oo2 :: KeyVal +xK_Sinh_oo2 = 0x1000ddd +xK_Sinh_au2 :: KeyVal +xK_Sinh_au2 = 0x1000dde +xK_Sinh_lu2 :: KeyVal +xK_Sinh_lu2 = 0x1000ddf +xK_Sinh_ruu2 :: KeyVal +xK_Sinh_ruu2 = 0x1000df2 +xK_Sinh_luu2 :: KeyVal +xK_Sinh_luu2 = 0x1000df3 +xK_Sinh_kunddaliya :: KeyVal +xK_Sinh_kunddaliya = 0x1000df4 +xK_ModeLock :: KeyVal +xK_ModeLock = 0x1008ff01 +xK_MonBrightnessUp :: KeyVal +xK_MonBrightnessUp = 0x1008ff02 +xK_MonBrightnessDown :: KeyVal +xK_MonBrightnessDown = 0x1008ff03 +xK_KbdLightOnOff :: KeyVal +xK_KbdLightOnOff = 0x1008ff04 +xK_KbdBrightnessUp :: KeyVal +xK_KbdBrightnessUp = 0x1008ff05 +xK_KbdBrightnessDown :: KeyVal +xK_KbdBrightnessDown = 0x1008ff06 +xK_Standby :: KeyVal +xK_Standby = 0x1008ff10 +xK_AudioLowerVolume :: KeyVal +xK_AudioLowerVolume = 0x1008ff11 +xK_AudioMute :: KeyVal +xK_AudioMute = 0x1008ff12 +xK_AudioRaiseVolume :: KeyVal +xK_AudioRaiseVolume = 0x1008ff13 +xK_AudioPlay :: KeyVal +xK_AudioPlay = 0x1008ff14 +xK_AudioStop :: KeyVal +xK_AudioStop = 0x1008ff15 +xK_AudioPrev :: KeyVal +xK_AudioPrev = 0x1008ff16 +xK_AudioNext :: KeyVal +xK_AudioNext = 0x1008ff17 +xK_HomePage :: KeyVal +xK_HomePage = 0x1008ff18 +xK_Mail :: KeyVal +xK_Mail = 0x1008ff19 +xK_Start :: KeyVal +xK_Start = 0x1008ff1a +xK_Search :: KeyVal +xK_Search = 0x1008ff1b +xK_AudioRecord :: KeyVal +xK_AudioRecord = 0x1008ff1c +xK_Calculator :: KeyVal +xK_Calculator = 0x1008ff1d +xK_Memo :: KeyVal +xK_Memo = 0x1008ff1e +xK_ToDoList :: KeyVal +xK_ToDoList = 0x1008ff1f +xK_Calendar :: KeyVal +xK_Calendar = 0x1008ff20 +xK_PowerDown :: KeyVal +xK_PowerDown = 0x1008ff21 +xK_ContrastAdjust :: KeyVal +xK_ContrastAdjust = 0x1008ff22 +xK_RockerUp :: KeyVal +xK_RockerUp = 0x1008ff23 +xK_RockerDown :: KeyVal +xK_RockerDown = 0x1008ff24 +xK_RockerEnter :: KeyVal +xK_RockerEnter = 0x1008ff25 +xK_Back :: KeyVal +xK_Back = 0x1008ff26 +xK_Forward :: KeyVal +xK_Forward = 0x1008ff27 +xK_Stop :: KeyVal +xK_Stop = 0x1008ff28 +xK_Refresh :: KeyVal +xK_Refresh = 0x1008ff29 +xK_PowerOff :: KeyVal +xK_PowerOff = 0x1008ff2a +xK_WakeUp :: KeyVal +xK_WakeUp = 0x1008ff2b +xK_Eject :: KeyVal +xK_Eject = 0x1008ff2c +xK_ScreenSaver :: KeyVal +xK_ScreenSaver = 0x1008ff2d +xK_WWW :: KeyVal +xK_WWW = 0x1008ff2e +xK_Sleep :: KeyVal +xK_Sleep = 0x1008ff2f +xK_Favorites :: KeyVal +xK_Favorites = 0x1008ff30 +xK_AudioPause :: KeyVal +xK_AudioPause = 0x1008ff31 +xK_AudioMedia :: KeyVal +xK_AudioMedia = 0x1008ff32 +xK_MyComputer :: KeyVal +xK_MyComputer = 0x1008ff33 +xK_VendorHome :: KeyVal +xK_VendorHome = 0x1008ff34 +xK_LightBulb :: KeyVal +xK_LightBulb = 0x1008ff35 +xK_Shop :: KeyVal +xK_Shop = 0x1008ff36 +xK_History :: KeyVal +xK_History = 0x1008ff37 +xK_OpenURL :: KeyVal +xK_OpenURL = 0x1008ff38 +xK_AddFavorite :: KeyVal +xK_AddFavorite = 0x1008ff39 +xK_HotLinks :: KeyVal +xK_HotLinks = 0x1008ff3a +xK_BrightnessAdjust :: KeyVal +xK_BrightnessAdjust = 0x1008ff3b +xK_Finance :: KeyVal +xK_Finance = 0x1008ff3c +xK_Community :: KeyVal +xK_Community = 0x1008ff3d +xK_AudioRewind :: KeyVal +xK_AudioRewind = 0x1008ff3e +xK_BackForward :: KeyVal +xK_BackForward = 0x1008ff3f +xK_Launch0 :: KeyVal +xK_Launch0 = 0x1008ff40 +xK_Launch1 :: KeyVal +xK_Launch1 = 0x1008ff41 +xK_Launch2 :: KeyVal +xK_Launch2 = 0x1008ff42 +xK_Launch3 :: KeyVal +xK_Launch3 = 0x1008ff43 +xK_Launch4 :: KeyVal +xK_Launch4 = 0x1008ff44 +xK_Launch5 :: KeyVal +xK_Launch5 = 0x1008ff45 +xK_Launch6 :: KeyVal +xK_Launch6 = 0x1008ff46 +xK_Launch7 :: KeyVal +xK_Launch7 = 0x1008ff47 +xK_Launch8 :: KeyVal +xK_Launch8 = 0x1008ff48 +xK_Launch9 :: KeyVal +xK_Launch9 = 0x1008ff49 +xK_LaunchA :: KeyVal +xK_LaunchA = 0x1008ff4a +xK_LaunchB :: KeyVal +xK_LaunchB = 0x1008ff4b +xK_LaunchC :: KeyVal +xK_LaunchC = 0x1008ff4c +xK_LaunchD :: KeyVal +xK_LaunchD = 0x1008ff4d +xK_LaunchE :: KeyVal +xK_LaunchE = 0x1008ff4e +xK_LaunchF :: KeyVal +xK_LaunchF = 0x1008ff4f +xK_ApplicationLeft :: KeyVal +xK_ApplicationLeft = 0x1008ff50 +xK_ApplicationRight :: KeyVal +xK_ApplicationRight = 0x1008ff51 +xK_Book :: KeyVal +xK_Book = 0x1008ff52 +xK_CD :: KeyVal +xK_CD = 0x1008ff53 +xK_WindowClear :: KeyVal +xK_WindowClear = 0x1008ff55 +xK_Close :: KeyVal +xK_Close = 0x1008ff56 +xK_Copy :: KeyVal +xK_Copy = 0x1008ff57 +xK_Cut :: KeyVal +xK_Cut = 0x1008ff58 +xK_Display :: KeyVal +xK_Display = 0x1008ff59 +xK_DOS :: KeyVal +xK_DOS = 0x1008ff5a +xK_Documents :: KeyVal +xK_Documents = 0x1008ff5b +xK_Excel :: KeyVal +xK_Excel = 0x1008ff5c +xK_Explorer :: KeyVal +xK_Explorer = 0x1008ff5d +xK_Game :: KeyVal +xK_Game = 0x1008ff5e +xK_Go :: KeyVal +xK_Go = 0x1008ff5f +xK_iTouch :: KeyVal +xK_iTouch = 0x1008ff60 +xK_LogOff :: KeyVal +xK_LogOff = 0x1008ff61 +xK_Market :: KeyVal +xK_Market = 0x1008ff62 +xK_Meeting :: KeyVal +xK_Meeting = 0x1008ff63 +xK_MenuKB :: KeyVal +xK_MenuKB = 0x1008ff65 +xK_MenuPB :: KeyVal +xK_MenuPB = 0x1008ff66 +xK_MySites :: KeyVal +xK_MySites = 0x1008ff67 +xK_New :: KeyVal +xK_New = 0x1008ff68 +xK_News :: KeyVal +xK_News = 0x1008ff69 +xK_OfficeHome :: KeyVal +xK_OfficeHome = 0x1008ff6a +xK_Open :: KeyVal +xK_Open = 0x1008ff6b +xK_Option :: KeyVal +xK_Option = 0x1008ff6c +xK_Paste :: KeyVal +xK_Paste = 0x1008ff6d +xK_Phone :: KeyVal +xK_Phone = 0x1008ff6e +xK_Reply :: KeyVal +xK_Reply = 0x1008ff72 +xK_Reload :: KeyVal +xK_Reload = 0x1008ff73 +xK_RotateWindows :: KeyVal +xK_RotateWindows = 0x1008ff74 +xK_RotationPB :: KeyVal +xK_RotationPB = 0x1008ff75 +xK_RotationKB :: KeyVal +xK_RotationKB = 0x1008ff76 +xK_Save :: KeyVal +xK_Save = 0x1008ff77 +xK_ScrollUp :: KeyVal +xK_ScrollUp = 0x1008ff78 +xK_ScrollDown :: KeyVal +xK_ScrollDown = 0x1008ff79 +xK_ScrollClick :: KeyVal +xK_ScrollClick = 0x1008ff7a +xK_Send :: KeyVal +xK_Send = 0x1008ff7b +xK_Spell :: KeyVal +xK_Spell = 0x1008ff7c +xK_SplitScreen :: KeyVal +xK_SplitScreen = 0x1008ff7d +xK_Support :: KeyVal +xK_Support = 0x1008ff7e +xK_TaskPane :: KeyVal +xK_TaskPane = 0x1008ff7f +xK_Terminal :: KeyVal +xK_Terminal = 0x1008ff80 +xK_Tools :: KeyVal +xK_Tools = 0x1008ff81 +xK_Travel :: KeyVal +xK_Travel = 0x1008ff82 +xK_UserPB :: KeyVal +xK_UserPB = 0x1008ff84 +xK_User1KB :: KeyVal +xK_User1KB = 0x1008ff85 +xK_User2KB :: KeyVal +xK_User2KB = 0x1008ff86 +xK_Video :: KeyVal +xK_Video = 0x1008ff87 +xK_WheelButton :: KeyVal +xK_WheelButton = 0x1008ff88 +xK_Word :: KeyVal +xK_Word = 0x1008ff89 +xK_Xfer :: KeyVal +xK_Xfer = 0x1008ff8a +xK_ZoomIn :: KeyVal +xK_ZoomIn = 0x1008ff8b +xK_ZoomOut :: KeyVal +xK_ZoomOut = 0x1008ff8c +xK_Away :: KeyVal +xK_Away = 0x1008ff8d +xK_Messenger :: KeyVal +xK_Messenger = 0x1008ff8e +xK_WebCam :: KeyVal +xK_WebCam = 0x1008ff8f +xK_MailForward :: KeyVal +xK_MailForward = 0x1008ff90 +xK_Pictures :: KeyVal +xK_Pictures = 0x1008ff91 +xK_Music :: KeyVal +xK_Music = 0x1008ff92 +xK_Battery :: KeyVal +xK_Battery = 0x1008ff93 +xK_Bluetooth :: KeyVal +xK_Bluetooth = 0x1008ff94 +xK_WLAN :: KeyVal +xK_WLAN = 0x1008ff95 +xK_UWB :: KeyVal +xK_UWB = 0x1008ff96 +xK_AudioForward :: KeyVal +xK_AudioForward = 0x1008ff97 +xK_AudioRepeat :: KeyVal +xK_AudioRepeat = 0x1008ff98 +xK_AudioRandomPlay :: KeyVal +xK_AudioRandomPlay = 0x1008ff99 +xK_Subtitle :: KeyVal +xK_Subtitle = 0x1008ff9a +xK_AudioCycleTrack :: KeyVal +xK_AudioCycleTrack = 0x1008ff9b +xK_CycleAngle :: KeyVal +xK_CycleAngle = 0x1008ff9c +xK_FrameBack :: KeyVal +xK_FrameBack = 0x1008ff9d +xK_FrameForward :: KeyVal +xK_FrameForward = 0x1008ff9e +xK_Time :: KeyVal +xK_Time = 0x1008ff9f +xK_SelectButton :: KeyVal +xK_SelectButton = 0x1008ffa0 +xK_View :: KeyVal +xK_View = 0x1008ffa1 +xK_TopMenu :: KeyVal +xK_TopMenu = 0x1008ffa2 +xK_Red :: KeyVal +xK_Red = 0x1008ffa3 +xK_Green :: KeyVal +xK_Green = 0x1008ffa4 +xK_Yellow :: KeyVal +xK_Yellow = 0x1008ffa5 +xK_Blue :: KeyVal +xK_Blue = 0x1008ffa6 +xK_Suspend :: KeyVal +xK_Suspend = 0x1008ffa7 +xK_Hibernate :: KeyVal +xK_Hibernate = 0x1008ffa8 +xK_TouchpadToggle :: KeyVal +xK_TouchpadToggle = 0x1008ffa9 +xK_TouchpadOn :: KeyVal +xK_TouchpadOn = 0x1008ffb0 +xK_TouchpadOff :: KeyVal +xK_TouchpadOff = 0x1008ffb1 +xK_AudioMicMute :: KeyVal +xK_AudioMicMute = 0x1008ffb2 +xK_Switch_VT_1 :: KeyVal +xK_Switch_VT_1 = 0x1008fe01 +xK_Switch_VT_2 :: KeyVal +xK_Switch_VT_2 = 0x1008fe02 +xK_Switch_VT_3 :: KeyVal +xK_Switch_VT_3 = 0x1008fe03 +xK_Switch_VT_4 :: KeyVal +xK_Switch_VT_4 = 0x1008fe04 +xK_Switch_VT_5 :: KeyVal +xK_Switch_VT_5 = 0x1008fe05 +xK_Switch_VT_6 :: KeyVal +xK_Switch_VT_6 = 0x1008fe06 +xK_Switch_VT_7 :: KeyVal +xK_Switch_VT_7 = 0x1008fe07 +xK_Switch_VT_8 :: KeyVal +xK_Switch_VT_8 = 0x1008fe08 +xK_Switch_VT_9 :: KeyVal +xK_Switch_VT_9 = 0x1008fe09 +xK_Switch_VT_10 :: KeyVal +xK_Switch_VT_10 = 0x1008fe0a +xK_Switch_VT_11 :: KeyVal +xK_Switch_VT_11 = 0x1008fe0b +xK_Switch_VT_12 :: KeyVal +xK_Switch_VT_12 = 0x1008fe0c +xK_Ungrab :: KeyVal +xK_Ungrab = 0x1008fe20 +xK_ClearGrab :: KeyVal +xK_ClearGrab = 0x1008fe21 +xK_Next_VMode :: KeyVal +xK_Next_VMode = 0x1008fe22 +xK_Prev_VMode :: KeyVal +xK_Prev_VMode = 0x1008fe23 +xK_LogWindowTree :: KeyVal +xK_LogWindowTree = 0x1008fe24 +xK_LogGrabInfo :: KeyVal +xK_LogGrabInfo = 0x1008fe25 diff --git a/src/IGE/Layout.hs b/src/IGE/Layout.hs new file mode 100644 --- /dev/null +++ b/src/IGE/Layout.hs @@ -0,0 +1,104 @@ +module IGE.Layout + ( layoutGr ) + where + +import Protolude hiding (force) +import IGE.Types +import Data.Graph.Inductive.Graph +import Data.Graph.Inductive.PatriciaTree +import qualified Data.Map.Strict as Map +import Data.Array +import Data.Array.MArray +import Data.Array.ST +import Control.Monad.ST +import Data.STRef +import Lens.Micro.Platform +import System.Random.MWC + +data PEdge = Spring Double Double | Spacer Double Double + +force :: PEdge -> ℂ -> ℂ -> ℂ +force (Spring k l) p1 p2 = ((k * (magnitude z - l)) :+ 0) * signum z + where z = p2 - p1 +force (Spacer k l) p1 p2 = ((max 0 (k * (magnitude z - l))) :+ 0) * signum z + where z = p2 - p1 + +type Edges = Array (Int, Int) PEdge +type STNodes s = STArray s Int ℂ +type Nodes = Array Int ℂ + +fdStep :: Double -> Edges -> STNodes s -> ST s Double +fdStep stepSize edges nodes = do + let stepSizeC = stepSize :+ 0 + (0, n) <- getBounds nodes + maxForceRef <- newSTRef 0 + forM_ [0..n] $ \i -> do + fRef <- newSTRef $ 0 :+ 0 + p1 <- readArray nodes i + forM_ [0..n] $ \j -> do + p2 <- readArray nodes j + let edge = edges ! (i, j) + f <- readSTRef fRef + writeSTRef fRef $ f + (force edge p1 p2) + f <- readSTRef fRef + let dp = stepSizeC * f + writeArray nodes i $ p1 + dp + maxF <- readSTRef maxForceRef + if magnitude f > maxF + then writeSTRef maxForceRef $ magnitude f + else return () + maxF <- readSTRef maxForceRef + return maxF + +runFd :: Double -> Double -> Edges -> STNodes s -> ST s () +runFd tolerance stepSize edges nodes = perturb >> loop + where + perturb = do + gen <- create + (0, n) <- getBounds nodes + forM_ [0..n] $ \i -> do + p <- readArray nodes i + cθ <- uniformR (0, 2 * pi) gen + cr <- uniformR (0, 0.2) gen + writeArray nodes i (p + mkPolar cr cθ) + loop = do + f <- fdStep stepSize edges nodes + if f > tolerance + then loop + else return () + +defaultSpring :: PEdge +defaultSpring = Spring 0.1 0.8 +defaultSpacer :: PEdge +defaultSpacer = Spacer 0 0.5 +defaultStepSize :: Double +defaultStepSize = 0.01 +defaultTolerance :: Double +defaultTolerance = 0.001 + +initNodes :: Gr a b -> (Map.Map Node Int, Nodes) +initNodes g = ( Map.fromList $ zip (nodes g) [0..] + , listArray (0, n - 1) $ (\k -> fromIntegral (k `rem` d) :+ fromIntegral (k `quot` d)) <$> [0..n-1]) + where + n = length $ nodes g + d = ceiling $ sqrt $ fromIntegral $ order g + +initEdges :: Gr a b -> Map.Map Node Int -> Edges +initEdges g m = runSTArray $ do + edgeMat <- newArray ((0, 0), (n - 1, n - 1)) defaultSpacer + forM_ (over both (m Map.!) <$> edges g) $ \(n1, n2) -> do + writeArray edgeMat (n1, n2) defaultSpring + writeArray edgeMat (n2, n1) defaultSpring + return edgeMat + where + n = length $ nodes g + +layoutGr :: Gr n e -> Map.Map Node ℂ +layoutGr g = Map.map (nodeVec !) nodeMap + where + (nodeMap, frozenNodes) = initNodes g + nodeVec = runSTArray $ do + let edgeMat = initEdges g nodeMap + nodeVec' <- thaw frozenNodes + runFd defaultTolerance defaultStepSize edgeMat nodeVec' + return nodeVec' diff --git a/src/IGE/Render.hs b/src/IGE/Render.hs new file mode 100644 --- /dev/null +++ b/src/IGE/Render.hs @@ -0,0 +1,101 @@ +module IGE.Render + ( renderEditorState ) + where + +import Protolude +import IGE.Types +import IGE.Layout +import Data.Graph.Inductive.Graph +import Data.Graph.Inductive.PatriciaTree +import Graphics.Rendering.Cairo +import Lens.Micro.Platform +import qualified Data.Map.Strict as Map + +-- Refactoring ideas: +-- - Use diagrams + +instance Renderable Text where + render s (x :+ y) = do + extents <- textExtents s + rectangle + (x - textMargin) + (y - (textExtentsHeight extents + textMargin)) + (textExtentsWidth extents + (2 * textMargin)) + (textExtentsHeight extents + (2 * textMargin)) + setSourceRGB 0.1 0.1 0.1 + fill + setSourceRGB 0.9 0.9 0.9 + moveTo x y + showText s + +instance Renderable () where + render () (x :+ y) = do + arc x y nodeSize 0 (2 * pi) + fill + +instance RenderNode Text where + +instance RenderEdge Text where + +instance RenderNode () where + +instance RenderEdge () where + renderEdge _ _ = return () + +nodeSize :: Double +nodeSize = 4 + +renderBackground :: Render () +renderBackground = do + setSourceRGB 0.1 0.1 0.1 + paint + setSourceRGB 0.9 0.9 0.9 + selectFontFace ("monospace" :: Text) FontSlantNormal FontWeightNormal + setFontSize 15 + +renderNodes :: (RenderNode a) => [(ℂ, a)] -> Render () +renderNodes nodes = mapM_ (uncurry $ flip renderNode) nodes + +renderEdges :: (RenderEdge a) => [(ℂ, ℂ, a)] -> Render () +renderEdges edges = + forM_ edges $ \(p1@(x0 :+ y0), p2@(x1 :+ y1), label) -> do + moveTo x0 y0 + lineTo x1 y1 + stroke + renderEdge label $ (p1 + p2) / (2 :+ 0) + +renderCommand :: (Int, Int) -> [Char] -> Render () +renderCommand (w, h) s = do + let s' = reverse s + extents <- textExtents s' + moveTo 0 ((fromIntegral h) - (textExtentsHeight extents)) + showText s' + +textMargin = 3 + +renderLabels :: [([Char], ℂ)] -> Render () +renderLabels labels = + forM_ labels $ \(s, x :+ y) -> do + extents <- textExtents s + rectangle + (x - textMargin) + (y - (textExtentsHeight extents + textMargin)) + (textExtentsWidth extents + (2 * textMargin)) + (textExtentsHeight extents + (2 * textMargin)) + setSourceRGB 0.7 0.7 0.2 + fill + setSourceRGB 0.1 0.1 0.1 + moveTo x y + showText s + +renderEditorState :: (RenderNode n, RenderEdge e) => EditorState n e -> (Int, Int) -> Render () +renderEditorState es dims = do + let rm = es^._rm + let graph = es^._graph + let labels = es^._labels + let nodeMap = (rm ^*) <$> es^._nodeMap + renderBackground + renderEdges $ ((_1 %~ (nodeMap Map.!)) . (_2 %~ (nodeMap Map.!))) <$> labEdges graph + renderNodes $ (_1 %~ (nodeMap Map.!)) <$> labNodes graph + renderCommand dims (es^._cmd) + renderLabels $ over _2 (nodeMap Map.!) <$> labels diff --git a/src/IGE/Serialization.hs b/src/IGE/Serialization.hs new file mode 100644 --- /dev/null +++ b/src/IGE/Serialization.hs @@ -0,0 +1,13 @@ +module IGE.Serialization where + +import Protolude hiding (ByteString) +import Data.Aeson +import Data.Graph.Inductive.Graph +import Data.Graph.Inductive.PatriciaTree +import Data.ByteString.Lazy + +graphToBS :: (ToJSON n, ToJSON e) => Gr n e -> ByteString +graphToBS g = encode (labNodes g, labEdges g) + +graphFromBS :: (FromJSON n, FromJSON e) => ByteString -> Maybe (Gr n e) +graphFromBS bs = uncurry mkGraph <$> decode bs diff --git a/src/IGE/Types.hs b/src/IGE/Types.hs new file mode 100644 --- /dev/null +++ b/src/IGE/Types.hs @@ -0,0 +1,115 @@ +module IGE.Types where + +import Protolude +import Data.Complex +import Data.Graph.Inductive.Graph +import Data.Graph.Inductive.PatriciaTree +import Lens.Micro.Platform +import Control.Concurrent.STM +import Conduit +import Graphics.UI.Gtk (KeyVal) +import Graphics.Rendering.Cairo +import qualified Data.Map.Strict as Map + +-- Refactoring ideas: +-- - Use typeclass-based EditorState +-- - Use StateT based Keybinding -- use hoisting to promote pure functions +-- - + +type ℂ = Complex Double + +class Translation a where + _x :: Lens' a Double + _y :: Lens' a Double + +class Amplitwist a where + _r :: Lens' a Double + _θ :: Lens' a Double + +instance Translation ℂ where + _x f (x :+ y) = (:+ y) <$> f x + _y f (x :+ y) = (x :+) <$> f x + +instance Amplitwist ℂ where + _r f z = (* z) . (:+ 0) . (/ r) <$> f r + where r = magnitude z + _θ f z = (* z) . cis . (+ (-θ)) <$> f θ + where θ = phase z + +class (Translation a, Amplitwist a) => RigidMotion a where + (^.^) :: a -> a -> a + (^*) :: a -> ℂ -> ℂ + -- law = (a ^.^ b) ^* z = a ^* (b ^* c) + +data RM = RM { rmAT :: ℂ, rmTrans :: ℂ } -- rigid motion + deriving (Eq, Show) + +makeLensesFor [("rmAT", "_at"), ("rmTrans", "_trans")] ''RM + +instance Translation RM where + _x f (RM at trans) = (RM at) <$> _x f trans + _y f (RM at trans) = (RM at) <$> _y f trans + +instance Amplitwist RM where + _r f (RM at trans) = (flip RM trans) <$> _r f at + _θ f (RM at trans) = (flip RM trans) <$> _θ f at + +instance RigidMotion RM where + (RM at1 trans1) ^.^ (RM at2 trans2) = RM (at1 * at2) (trans1 + (at1 * trans2)) + (RM at trans) ^* z = (z * at) + trans + +class Renderable a where + render :: a -> ℂ -> Render () + +class Renderable a => RenderNode a where + renderNode :: a -> ℂ -> Render () + renderNode = render + +class Renderable a => RenderEdge a where + renderEdge :: a -> ℂ -> Render () + renderEdge = render + +data EditorState n e = EditorState { + esGraph :: Gr n e + , esRM :: RM + , esNum :: Int + , esCommand :: [Char] -- stored backwards + , esLabels :: [([Char], Node)] + , esNodeMap :: Map.Map Node ℂ + } + +makeLensesFor [ + ("esGraph", "_graph") + , ("esRM", "_rm") + , ("esNum", "_num") + , ("esCommand", "_cmd") + , ("esLabels", "_labels") + , ("esNodeMap", "_nodeMap")] ''EditorState + +newtype IGEM n e a = IGEM { unIGEM :: ReaderT (TVar (EditorState n e)) IO a } + deriving (Functor, Applicative, Monad, MonadIO, MonadReader (TVar (EditorState n e))) + +runIGEM :: TVar (EditorState n e) -> IGEM n e a -> IO a +runIGEM v m = runReaderT (unIGEM m) v + +type EditorM n e = State (EditorState n e) + +runTVarState :: (MonadReader (TVar s) m, MonadIO m) => State s a -> m a +runTVarState action = do + stateVar <- ask + liftIO $ atomically $ do + s <- readTVar stateVar + let (a, s') = runState action s + writeTVar stateVar s' + return a + +runTVarReader :: (MonadReader (TVar s) m, MonadIO m) => Reader s a -> m a +runTVarReader action = do + stateVar <- ask + s <- liftIO $ readTVarIO stateVar + return $ runReader action s + +data RefreshType = LayoutChange | NoLayoutChange + deriving (Show, Eq) + +type KeyBinding n e = ConduitM KeyVal RefreshType (IGEM n e) diff --git a/src/IGE/UI.hs b/src/IGE/UI.hs new file mode 100644 --- /dev/null +++ b/src/IGE/UI.hs @@ -0,0 +1,44 @@ +module IGE.UI where + +import Protolude hiding (on) +import Graphics.UI.Gtk hiding (get) +import Data.Graph.Inductive.Graph +import Data.Graph.Inductive.PatriciaTree +import Control.Concurrent.STM +import Control.Concurrent.STM.TBMChan + +import IGE.Types +import IGE.Render +import IGE.Layout +import IGE.Control + +runMainWindow :: (RenderNode n, RenderEdge e) => Gr n e -> RM -> KeyBinding n e () -> IO () +runMainWindow initGr initRM keybinding = do + void initGUI + w <- windowNew + da <- drawingAreaNew + w `containerAdd` da + editorState <- newTVarIO $ EditorState initGr initRM 3 "" [] (layoutGr initGr) + keyChan <- newTBMChanIO 16 + + _ <- forkIO $ runKeyBinding keyChan editorState w keybinding + + void $ (w `on` deleteEvent) $ liftIO mainQuit >> return True + + void $ (da `on` exposeEvent) $ liftIO $ do + dw <- widgetGetDrawWindow da + es <- readTVarIO editorState + dims <- drawableGetSize dw + renderWithDrawable dw $ renderEditorState es dims + return True + + void $ (da `on` keyPressEvent) $ do + kv <- eventKeyVal + liftIO $ atomically $ writeTBMChan keyChan kv + return True + + da `widgetSetCanFocus` True + da `widgetAddEvents` [KeyPressMask] + + widgetShowAll w + mainGUI diff --git a/src/Main.hs b/src/Main.hs new file mode 100644 --- /dev/null +++ b/src/Main.hs @@ -0,0 +1,17 @@ +module Main where + +import Protolude +import Data.Graph.Inductive.PatriciaTree +import Data.Graph.Inductive.Graph as Graph +import IGE.Types +import IGE.UI +import IGE.Control + +sampleGr :: Gr () () +sampleGr = mkGraph [(0, ()), (1, ()), (2, ())] [(0, 1, ()), (1, 2, ()), (0, 2, ())] + +initRM :: RM +initRM = RM (100 :+ 0) (100 :+ 100) + +main :: IO () +main = runMainWindow Graph.empty initRM textKeyBinding