Merging back in the jcterm branch

25 files changed, 7739 insertions, 356 deletions

diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..94a9ed0
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ 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.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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 <http://www.gnu.org/licenses/>.
+
+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:
+
+    <program>  Copyright (C) <year>  <name of author>
+    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
+<http://www.gnu.org/licenses/>.
+
+  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
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/res/layout/secure_shell.xml b/res/layout/secure_shell.xml
index 0f47c70..9af5081 100644
--- a/res/layout/secure_shell.xml
+++ b/res/layout/secure_shell.xml
@@ -3,10 +3,16 @@
     android:layout_width="fill_parent"
     android:layout_height="fill_parent">
 
+    <org.theb.ssh.TerminalView id="@+id/terminal"
+    	android:layout_width="fill_parent"
+    	android:layout_height="fill_parent"
+    	android:textSize="8sp"
+    	android:typeface="monospace" />
+<!-- 
     <TextView id="@+id/output"
         android:layout_width="fill_parent"
         android:layout_height="fill_parent"
         android:textSize="8sp"
         android:typeface="monospace" />
-
+ -->
 </RelativeLayout>
diff --git a/src/com/jcraft/jcterm/Emulator.java b/src/com/jcraft/jcterm/Emulator.java
new file mode 100644
index 0000000..7723738
--- /dev/null
+++ b/src/com/jcraft/jcterm/Emulator.java
@@ -0,0 +1,416 @@
+/* -*-mode:java; c-basic-offset:2; -*- */
+/* JCTerm
+ * Copyright (C) 2002,2007 ymnk, JCraft,Inc.
+ *  
+ * Written by: ymnk<ymnk@jcaft.com>
+ *   
+ *   
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public License
+ * as published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+package com.jcraft.jcterm;
+
+import java.io.InputStream;
+import java.io.IOException;
+
+public abstract class Emulator{
+  Term term=null;
+  InputStream in=null;
+
+  public Emulator(Term term, InputStream in){
+    this.term=term;
+    this.in=in;
+  }
+
+  public abstract void start();
+
+  public abstract byte[] getCodeENTER();
+
+  public abstract byte[] getCodeUP();
+
+  public abstract byte[] getCodeDOWN();
+
+  public abstract byte[] getCodeRIGHT();
+
+  public abstract byte[] getCodeLEFT();
+
+  public abstract byte[] getCodeF1();
+
+  public abstract byte[] getCodeF2();
+
+  public abstract byte[] getCodeF3();
+
+  public abstract byte[] getCodeF4();
+
+  public abstract byte[] getCodeF5();
+
+  public abstract byte[] getCodeF6();
+
+  public abstract byte[] getCodeF7();
+
+  public abstract byte[] getCodeF8();
+
+  public abstract byte[] getCodeF9();
+
+  public abstract byte[] getCodeF10();
+
+  public abstract byte[] getCodeTAB();
+
+  public void reset(){
+    term_width=term.getColumnCount();
+    term_height=term.getRowCount();
+    char_width=term.getCharWidth();
+    char_height=term.getCharHeight();
+    region_y1=1;
+    region_y2=term_height;
+  }
+
+  byte[] buf=new byte[1024];
+  int bufs=0;
+  int buflen=0;
+
+  byte getChar() throws java.io.IOException{
+    if(buflen==0){
+      fillBuf();
+    }
+    buflen--;
+
+    //    System.out.println("getChar: "+new Character((char)buf[bufs])+"["+Integer.toHexString(buf[bufs]&0xff)+"]");
+
+    return buf[bufs++];
+  }
+
+  void fillBuf() throws java.io.IOException{
+    buflen=bufs=0;
+    buflen=in.read(buf, bufs, buf.length-bufs);
+    /*
+    System.out.println("fillBuf: ");
+    for(int i=0; i<buflen; i++){
+    byte b=buf[i];
+    System.out.print(new Character((char)b)+"["+Integer.toHexString(b&0xff)+"], ");
+    }
+    System.out.println("");
+    */
+    if(buflen<=0){
+      buflen=0;
+      throw new IOException("fillBuf");
+    }
+  }
+
+  void pushChar(byte foo) throws java.io.IOException{
+    //System.out.println("pushChar: "+new Character((char)foo)+"["+Integer.toHexString(foo&0xff)+"]");
+    buflen++;
+    buf[--bufs]=foo;
+  }
+
+  int getASCII(int len) throws java.io.IOException{
+    //System.out.println("bufs="+bufs+", buflen="+buflen+", len="+len);
+    if(buflen==0){
+      fillBuf();
+    }
+    if(len>buflen)
+      len=buflen;
+    int foo=len;
+    byte tmp;
+    while(len>0){
+      tmp=buf[bufs++];
+      if(0x20<=tmp&&tmp<=0x7f){
+        buflen--;
+        len--;
+        continue;
+      }
+      bufs--;
+      break;
+    }
+    //System.out.println(" return "+(foo-len));
+    return foo-len;
+  }
+
+  protected int term_width=80;
+  protected int term_height=24;
+
+  protected int x=0;
+  protected int y=0;
+
+  protected int char_width;
+  protected int char_height;
+
+  private int region_y2;
+  private int region_y1;
+
+  protected int tab=8;
+
+  // Reverse scroll
+  protected void scroll_reverse(){
+    term.draw_cursor();
+    term.scroll_area(0, (region_y1-1)*char_height, term_width*char_width,
+        (region_y2-region_y1)*char_height, 0, char_height);
+    term.clear_area(x, y-char_height, term_width*char_width, y);
+    term.redraw(0, 0, term_width*char_width, term_height*char_height
+        -char_height);
+    //term.setCursor(x, y);
+    term.draw_cursor();
+  }
+
+  // Normal scroll one line
+  protected void scroll_forward(){
+    term.draw_cursor();
+    term.scroll_area(0, (region_y1-1)*char_height, term_width*char_width,
+        (region_y2-region_y1+1)*char_height, 0, -char_height);
+    term.clear_area(0, region_y2*char_height-char_height,
+        term_width*char_width, region_y2*char_height);
+    term.redraw(0, (region_y1-1)*char_height, term_width*char_width, (region_y2
+        -region_y1+1)
+        *char_height);
+    term.draw_cursor();
+  }
+
+  // Save cursor position
+  protected void save_cursor(){
+    // TODO
+    //System.out.println("save current cursor position");
+  }
+
+  // Enable alternate character set
+  protected void ena_acs(){
+    // TODO
+    //System.out.println("enable alterate char set");
+  }
+
+  protected void exit_alt_charset_mode(){
+    // TODO
+    //System.out.println("end alternate character set (P)");
+  }
+
+  protected void enter_alt_charset_mode(){
+    // TODO
+    //System.out.println("start alternate character set (P)");
+  }
+
+  protected void reset_2string(){
+    // TODO
+    // rs2(reset string)
+  }
+
+  protected void exit_attribute_mode(){
+    // TODO
+    //System.out.println("turn off all attributes");
+    term.resetAllAttributes();
+  }
+
+  protected void exit_standout_mode(){
+    term.resetAllAttributes();
+  }
+
+  protected void exit_underline_mode(){
+    // TODO
+  }
+
+  protected void enter_bold_mode(){
+    term.setBold();
+  }
+
+  protected void enter_underline_mode(){
+    term.setUnderline();
+  }
+
+  protected void enter_reverse_mode(){
+    term.setReverse();
+  }
+
+  protected void change_scroll_region(int y1, int y2){
+    region_y1=y1;
+    region_y2=y2;
+  }
+
+  protected void cursor_address(int r, int c){
+    term.draw_cursor();
+    x=(c-1)*char_width;
+    y=r*char_height;
+    //System.out.println("setCourosr: "+x+" "+y);
+    term.setCursor(x, y);
+    term.draw_cursor();
+  }
+
+  protected void parm_down_cursor(int lines){
+    term.draw_cursor();
+    y+=(lines)*char_height;
+    term.setCursor(x, y);
+    term.draw_cursor();
+  }
+
+  protected void parm_left_cursor(int chars){
+    term.draw_cursor();
+    x-=(chars)*char_width;
+    term.setCursor(x, y);
+    term.draw_cursor();
+  }
+
+  protected void parm_right_cursor(int chars){
+    term.draw_cursor();
+    x+=(chars)*char_width;
+    term.setCursor(x, y);
+    term.draw_cursor();
+  }
+
+  protected void clr_eol(){
+    term.draw_cursor();
+    term.clear_area(x, y-char_height, term_width*char_width, y);
+    term.redraw(x, y-char_height, (term_width)*char_width-x, char_height);
+    term.draw_cursor();
+  }
+
+  protected void clr_bol(){
+    term.draw_cursor();
+    term.clear_area(0, y-char_height, x, y);
+    term.redraw(0, y-char_height, x, char_height);
+    term.draw_cursor();
+  }
+
+  protected void clr_eos(){
+    term.draw_cursor();
+    term.clear_area(x, y-char_height, term_width*char_width, term_height
+        *char_height);
+    term.redraw(x, y-char_height, term_width*char_width-x, term_height
+        *char_height-y+char_height);
+    term.draw_cursor();
+  }
+
+  protected void parm_up_cursor(int lines){
+    term.draw_cursor();
+    //	  x=0;
+    //	  y-=char_height;
+    y-=(lines)*char_height;
+    term.setCursor(x, y);
+    term.draw_cursor();
+  }
+
+  protected void bell(){
+    term.beep();
+  }
+
+  protected void tab(){
+    term.draw_cursor();
+    x=(((x/char_width)/tab+1)*tab*char_width);
+    if(x>=term_width*char_width){
+      x=0;
+      y+=char_height;
+    }
+    term.setCursor(x, y);
+    term.draw_cursor();
+  }
+
+  protected void carriage_return(){
+    term.draw_cursor();
+    x=0;
+    term.setCursor(x, y);
+    term.draw_cursor();
+  }
+
+  protected void cursor_left(){
+    term.draw_cursor();
+    x-=char_width;
+    if(x<0){
+      y-=char_height;
+      x=term_width*char_width-char_width;
+    }
+    term.setCursor(x, y);
+    term.draw_cursor();
+  }
+
+  protected void cursor_down(){
+    term.draw_cursor();
+    y+=char_height;
+    term.setCursor(x, y);
+    term.draw_cursor();
+
+    check_region();
+  }
+
+  private byte[] b2=new byte[2];
+  private byte[] b1=new byte[1];
+
+  protected void draw_text() throws java.io.IOException{
+
+    int rx;
+    int ry;
+    int w;
+    int h;
+
+    check_region();
+
+    rx=x;
+    ry=y;
+
+    byte b=getChar();
+    term.draw_cursor();
+    //System.out.print(new Character((char)b)+"["+Integer.toHexString(b&0xff)+"]");
+    if((b&0x80)!=0){
+      term.clear_area(x, y-char_height, x+char_width*2, y);
+      b2[0]=b;
+      b2[1]=getChar();
+      term.drawString(new String(b2, 0, 2, "EUC-JP"), x, y);
+      x+=char_width;
+      x+=char_width;
+      w=char_width*2;
+      h=char_height;
+    }
+    else{
+      pushChar(b);
+      int foo=getASCII(term_width-(x/char_width));
+      if(foo!=0){
+        //System.out.println("foo="+foo+" "+x+", "+(y-char_height)+" "+(x+foo*char_width)+" "+y+" "+buf+" "+bufs+" "+b+" "+buf[bufs-foo]);
+        //System.out.println("foo="+foo+" ["+new String(buf, bufs-foo, foo));
+        term.clear_area(x, y-char_height, x+foo*char_width, y);
+        term.drawBytes(buf, bufs-foo, foo, x, y);
+      }
+      else{
+        foo=1;
+        term.clear_area(x, y-char_height, x+foo*char_width, y);
+        b1[0]=getChar();
+        term.drawBytes(b1, 0, foo, x, y);
+        //System.out.print("["+Integer.toHexString(bar[0]&0xff)+"]");
+      }
+      x+=(char_width*foo);
+      w=char_width*foo;
+      h=char_height;
+    }
+    term.redraw(rx, ry-char_height, w, h);
+    term.setCursor(x, y);
+    term.draw_cursor();
+  }
+
+  private void check_region(){
+    if(x>=term_width*char_width){
+      //System.out.println("!! "+new Character((char)b)+"["+Integer.toHexString(b&0xff)+"]");
+      x=0;
+      y+=char_height;
+      //System.out.println("@1: ry="+ry);
+    }
+
+    if(y>region_y2*char_height){
+      while(y>region_y2*char_height){
+        y-=char_height;
+      }
+      term.draw_cursor();
+      term.scroll_area(0, region_y1*char_height, term_width*char_width,
+          (region_y2-region_y1)*char_height, 0, -char_height);
+      term.clear_area(0, y-char_height, term_width*char_width, y);
+      term.redraw(0, 0, term_width*char_width, region_y2*char_height);
+      term.setCursor(x, y);
+      term.draw_cursor();
+    }
+  }
+}
diff --git a/src/com/jcraft/jcterm/EmulatorVT100.java b/src/com/jcraft/jcterm/EmulatorVT100.java
new file mode 100644
index 0000000..cf2f96a
--- /dev/null
+++ b/src/com/jcraft/jcterm/EmulatorVT100.java
@@ -0,0 +1,634 @@
+/* -*-mode:java; c-basic-offset:2; -*- */
+/* JCTerm
+ * Copyright (C) 2002,2007 ymnk, JCraft,Inc.
+ *  
+ * Written by: ymnk<ymnk@jcaft.com>
+ *   
+ *   
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public License
+ * as published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+package com.jcraft.jcterm;
+
+import java.io.InputStream;
+
+public class EmulatorVT100 extends Emulator{
+
+  public EmulatorVT100(Term term, InputStream in){
+    super(term, in);
+  }
+
+  public void setInputStream(InputStream in){
+    this.in=in;
+  }
+
+  public void setTerm(Term term){
+    this.term=term;
+  }
+
+  public void start(){
+    reset();
+
+    int[] intarg=new int[10];
+    int intargi=0;
+
+    x=0;
+    y=char_height;
+
+    byte b;
+
+    try{
+      while(true){
+
+        b=getChar();
+
+        //System.out.println("@0: "+ new Character((char)b)+"["+Integer.toHexString(b&0xff)+"]");
+
+        //System.out.println("@0: ry="+ry);
+
+        /*
+                outputs from infocmp on RedHat8.0
+        #       Reconstructed via infocmp from file: /usr/share/terminfo/v/vt100
+        vt100|vt100-am|dec vt100 (w/advanced video), 
+                am, msgr, xenl, xon, 
+                cols#80, it#8, lines#24, vt#3, 
+        	acsc=``aaffggjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~, 
+        	bel=^G, blink=\E[5m$<2>, bold=\E[1m$<2>, 
+        	clear=\E[H\E[J$<50>, cr=^M, csr=\E[%i%p1%d;%p2%dr,
+        	cub=\E[%p1%dD, cub1=^H, cud=\E[%p1%dB, cud1=^J,
+                cuf=\E[%p1%dC, cuf1=\E[C$<2>,
+                cup=\E[%i%p1%d;%p2%dH$<5>, cuu=\E[%p1%dA, 
+                cuu1=\E[A$<2>, ed=\E[J$<50>, el=\E[K$<3>, el1=\E[1K$<3>, 
+                enacs=\E(B\E)0, home=\E[H, ht=^I, hts=\EH, ind=^J, ka1=\EOq, 
+                ka3=\EOs, kb2=\EOr, kbs=^H, kc1=\EOp, kc3=\EOn, kcub1=\EOD, 
+                kcud1=\EOB, kcuf1=\EOC, kcuu1=\EOA, kent=\EOM, kf0=\EOy, 
+                kf1=\EOP, kf10=\EOx, kf2=\EOQ, kf3=\EOR, kf4=\EOS, kf5=\EOt, 
+                kf6=\EOu, kf7=\EOv, kf8=\EOl, kf9=\EOw, rc=\E8, 
+                rev=\E[7m$<2>, ri=\EM$<5>, rmacs=^O, rmam=\E[?7l, 
+                rmkx=\E[?1l\E>, rmso=\E[m$<2>, rmul=\E[m$<2>, 
+                rs2=\E>\E[?3l\E[?4l\E[?5l\E[?7h\E[?8h, sc=\E7, 
+                sgr=\E[0%?%p1%p6%|%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;m%?%p9%t\016%e\017%;$<2>, 
+                sgr0=\E[m\017$<2>, smacs=^N, smam=\E[?7h, smkx=\E[?1h\E=, 
+                smso=\E[7m$<2>, smul=\E[4m$<2>, tbc=\E[3g, 
+        */
+        /*
+                am    terminal has automatic margnins
+                msgr  safe to move while in standout mode
+                xenl  newline ignored after 80 cols (concept)
+                xon   terminal uses xon/xoff handshake
+                cols  number of columns in a line
+                it    tabs initially every # spaces
+                lines number of lines on screen of page
+                vt    virstual terminal number(CB/unix)
+                acsc  graphics charset pairs, based on vt100
+                bel   bell
+                blink turn on blinking
+                bold  turn on bold(extra bright) mode
+                clear clear screen and home cursor(P*)
+                cr    carriage return (P)(P*)
+                csr   change region to line #1 to line #2(P)
+                cub   move #1 characters to the left (P)
+                cub1  move left one space
+                cud   down #1 lines (P*)
+                cud1  down one line
+                cuf   move to #1 characters to the right.
+                cuf1  non-destructive space (move right one space)
+                cup   move to row #1 columns #2
+                cuu   up #1 lines (P*)
+                cuu1  up one line
+                ed    clear to end of screen (P*)
+                el    clear to end of line (P)
+                el1   Clear to begining of line 
+                enacs enable alterate char set
+                home  home cursor (if no cup)
+                ht    tab to next 8-space hardware tab stop
+                hts   set a tab in every row, current columns
+                ind   scroll text up
+                ka1   upper left of keypad
+                ka3   upper right of keypad
+                kb2   center of keypad
+                kbs   backspace key
+                kc1   lower left of keypad
+                kc3   lower right of keypad
+                kcub1 left-arrow key
+                kcud1 down-arrow key
+                kcuf1 right-arrow key
+                kcuu1 up-arrow key
+                kent  enter/sekd key
+                kf0   F0 function key
+                kf1   F1 function key
+                kf10  F10 function key
+                kf2   F2 function key
+                kf3   F3 function key
+                kf4   F4 function key
+                kf5   F5 function key
+                kf6   F6 function key
+                kf7   F7 function key
+                kf8   F8 function key
+                kf9   F9 function key
+                rc    restore cursor to position of last save_cursor
+                rev   turn on reverse video mode
+                ri    scroll text down (P)
+                rmacs end alternate character set 
+                rmam  turn off automatic margins
+                rmkx  leave 'keybroad_transmit' mode
+                rmso  exit standout mode
+                rmul  exit underline mode
+                rs2   reset string
+                sc    save current cursor position (P)
+                sgr   define video attribute #1-#9(PG9)
+                sgr0  turn off all attributes
+                smacs start alternate character set (P)
+                smam  turn on automatic margins 
+                smkx  enter 'keyborad_transmit' mode
+                smso  begin standout mode
+                smul  begin underline mode
+                tbc   clear all tab stops(P)
+         */
+        if(b==0){
+          continue;
+        }
+
+        if(b==0x1b){
+          b=getChar();
+
+          //System.out.println("@1: "+ new Character((char)b)+"["+Integer.toHexString(b&0xff)+"]");
+
+          if(b=='M'){ // sr \EM sr scroll text down (P)
+            scroll_reverse();
+            continue;
+          }
+
+          if(b=='D'){ // sf
+            scroll_forward();
+            continue;
+          }
+
+          if(b=='7'){
+            save_cursor();
+            continue;
+          }
+
+          if(b=='('){
+            b=getChar();
+            if(b=='B'){
+              b=getChar();
+              if(b==0x1b){
+                b=getChar();
+                if(b==')'){
+                  b=getChar();
+                  if(b=='0'){ // enacs
+                    ena_acs();
+                    continue;
+                  }
+                  else{
+                    pushChar((byte)'0');
+                  }
+                }
+                else{
+                  pushChar((byte)')');
+                }
+              }
+              else{
+                pushChar((byte)0x1b);
+              }
+            }
+            else{
+              pushChar((byte)'B');
+            }
+          }
+
+          if(b=='>'){
+            b=getChar(); // 0x1b
+            b=getChar(); // '['
+            b=getChar(); // '?'
+            b=getChar(); // '3'
+            b=getChar(); // 'l'
+            b=getChar(); // 0x1b
+            b=getChar(); // '['
+            b=getChar(); // '?'
+            b=getChar(); // '4'
+            b=getChar(); // 'l'
+            b=getChar(); // 0x1b
+            b=getChar(); // '['
+            b=getChar(); // '?'
+            b=getChar(); // '5'
+            b=getChar(); // 'l'
+            b=getChar(); // 0x1b
+            b=getChar(); // '['
+            b=getChar(); // '?'
+            b=getChar(); // '7'
+            b=getChar(); // 'h'
+            b=getChar(); // 0x1b
+            b=getChar(); // '['
+            b=getChar(); // '?'
+            b=getChar(); // '8'
+            b=getChar(); // 'h'
+
+            reset_2string();
+            continue;
+          }
+
+          if(b!='['){
+            System.out.print("@11: "+new Character((char)b)+"["
+                +Integer.toHexString(b&0xff)+"]");
+            pushChar(b);
+            continue;
+          }
+
+          //System.out.print("@2: "+ new Character((char)b)+"["+Integer.toHexString(b&0xff)+"]");
+
+          intargi=0;
+          intarg[intargi]=0;
+          int digit=0;
+
+          while(true){
+            b=getChar();
+            //System.out.print("#"+new Character((char)b)+"["+Integer.toHexString(b&0xff)+"]");
+            if(b==';'){
+              if(digit>0){
+                intargi++;
+                intarg[intargi]=0;
+                digit=0;
+              }
+              continue;
+            }
+
+            if('0'<=b&&b<='9'){
+              intarg[intargi]=intarg[intargi]*10+(b-'0');
+              digit++;
+              continue;
+            }
+
+            pushChar(b);
+            break;
+          }
+
+          b=getChar();
+
+          //System.out.print("@4: "+ new Character((char)b)+"["+Integer.toHexString(b&0xff)+"]");
+
+          if(b=='m'){
+            /*
+            b=getChar();
+            if(b=='$'){
+              b=getChar();  // <
+              b=getChar();  // 2
+              b=getChar();  // >
+            }
+            else{
+              pushChar(b);
+            }
+            */
+
+            if(digit==0&&intargi==0){
+              b=getChar();
+              if(b==0x0f){ // sgr0
+                exit_attribute_mode();
+                continue;
+              }
+              else{ // rmso, rmul
+                exit_underline_mode();
+                exit_standout_mode();
+                pushChar(b);
+                continue;
+              }
+            }
+
+            for(int i=0; i<=intargi; i++){
+              Object fg=null;
+              Object bg=null;
+              Object tmp=null;
+
+              switch(intarg[i]){
+                case 0: // Reset all attributes
+                  exit_standout_mode();
+                  continue;
+                case 1: // Bright  // bold
+                  enter_bold_mode();
+                  continue;
+                case 2: // Dim
+                  break;
+                case 4: // Underline
+                  enter_underline_mode();
+                  continue;
+                case 5: // Blink
+                case 8: // Hidden
+                  break;
+                case 7: // reverse
+                  enter_reverse_mode();
+                  continue;
+                case 30:
+                case 31:
+                case 32:
+                case 33:
+                case 34:
+                case 35:
+                case 36:
+                case 37:
+                  tmp=term.getColor(intarg[i]-30);
+                  if(tmp!=null)
+                    fg=tmp;
+                  break;
+                case 40:
+                case 41:
+                case 42:
+                case 43:
+                case 44:
+                case 45:
+                case 46:
+                case 47:
+                  tmp=term.getColor(intarg[i]-40);
+                  if(tmp!=null)
+                    bg=tmp;
+                  break;
+                default:
+                  break;
+              }
+              if(fg!=null)
+                term.setForeGround(fg);
+              if(bg!=null)
+                term.setBackGround(bg);
+            }
+            //System.out.println("fg: "+fg+" bg: "+bg);
+            continue;
+          }
+
+          if(b=='r'){ // csr
+            change_scroll_region(intarg[0], intarg[1]);
+            //System.out.println("r: "+region_y1+", "+region_y2+", intargi="+intargi);
+            continue;
+          }
+
+          if(b=='H'){ // cup
+            /*
+            b=getChar();
+            if(b!='$'){      // home
+              pushChar(b);
+            }
+            else{
+              b=getChar();  // <
+              b=getChar();  // 5
+              b=getChar();  // >
+            }
+            */
+
+            if(digit==0&&intargi==0){
+              intarg[0]=intarg[1]=1;
+            }
+
+            //System.out.println("H: "+region_y1+", "+region_y2+", intargi="+intargi);
+            cursor_address(intarg[0], intarg[1]);
+            continue;
+          }
+
+          if(b=='B'){ // cud
+            parm_down_cursor(intarg[0]);
+            continue;
+          }
+
+          if(b=='D'){ // cub
+            parm_left_cursor(intarg[0]);
+            continue;
+          }
+
+          if(b=='C'){ // cuf
+            if(digit==0&&intargi==0){
+              intarg[0]=1;
+            }
+            parm_right_cursor(intarg[0]);
+            continue;
+          }
+
+          if(b=='K'){ // el
+          /*
+          	  b=getChar(); // 
+          	  if(b=='$'){
+          	    b=getChar(); // < 
+          	    b=getChar(); // 3 
+          	    b=getChar(); // > 
+          	  }
+          	  else{
+          	    pushChar(b);
+          	  }
+          */
+
+            if(digit==0&&intargi==0){ // el
+              clr_eol();
+            }
+            else{ // el1
+              clr_bol();
+            }
+            continue;
+          }
+
+          if(b=='J'){
+            //for(int i=0; i<intargi; i++){ System.out.print(intarg[i]+" ");}
+            //System.out.println(intarg[0]+"<- intargi="+intargi);
+            clr_eos();
+            continue;
+          }
+
+          if(b=='A'){ // cuu
+            if(digit==0&&intargi==0){
+              intarg[0]=1;
+            }
+            parm_up_cursor(intarg[0]);
+            continue;
+          }
+
+          if(b=='?'){
+            b=getChar();
+            if(b=='1'){
+              b=getChar();
+              if(b=='l'||b=='h'){
+                b=getChar();
+                if(b==0x1b){
+                  b=getChar();
+                  if(b=='>'|| // rmkx   , leave 'keybroad_transmit' mode
+                      b=='='){ // smkx   , enter 'keyborad_transmit' mode 
+                    // TODO
+                    continue;
+                  }
+                }
+              }
+              else if(b=='h'){
+                b=getChar();
+                if(b==0x1b){
+                  b=getChar();
+                  if(b=='='){ // smkx enter 'keyborad_transmit' mode
+                    continue;
+                  }
+                }
+              }
+            }
+            else if(b=='7'){
+              b=getChar();
+              if(b=='h'){ // smam
+                // TODO
+                //System.out.println("turn on automatic magins");
+                continue;
+              }
+              else if(b=='l'){ // rmam
+                // TODO
+                //System.out.println("turn off automatic magins");
+                continue;
+              }
+              pushChar(b);
+              b='7';
+            }
+            else{
+            }
+          }
+
+          if(b=='h'){ // kh \Eh home key
+            continue;
+          }
+
+          System.out.println("unknown "+Integer.toHexString(b&0xff)+" "
+              +new Character((char)b)+", "+intarg[0]+", "+intarg[1]+", "
+              +intarg[2]+",intargi="+intargi);
+          continue;
+        }
+
+        if(b==0x07){ // bel ^G
+          bell();
+          continue;
+        }
+
+        if(b==0x09){ // ht(^I)
+          tab();
+          continue;
+        }
+
+        if(b==0x0f){ // rmacs ^O  	// end alternate character set (P)
+          exit_alt_charset_mode();
+          continue;
+        }
+
+        if(b==0x0e){ // smacs ^N  	// start alternate character set (P)
+          enter_alt_charset_mode();
+          continue;
+        }
+
+        if(b==0x0d){
+          carriage_return();
+          continue;
+        }
+
+        if(b==0x08){
+          cursor_left();
+          continue;
+        }
+
+        if(b==0x0a){ // '\n'
+          //System.out.println("x="+x+",y="+y);
+          cursor_down();
+          //check_region();
+          continue;
+        }
+
+        if(b!=0x0a){ // !'\n'
+          pushChar(b);
+          draw_text();
+          continue;
+        }
+      }
+    }
+    catch(Exception e){
+    }
+  }
+
+  private static byte[] ENTER= {(byte)0x0d};
+  private static byte[] UP= {(byte)0x1b, (byte)0x4f, (byte)0x41};
+  private static byte[] DOWN= {(byte)0x1b, (byte)0x4f, (byte)0x42};
+  private static byte[] RIGHT= {(byte)0x1b, (byte)/*0x5b*/0x4f, (byte)0x43};
+  private static byte[] LEFT= {(byte)0x1b, (byte)/*0x5b*/0x4f, (byte)0x44};
+  private static byte[] F1= {(byte)0x1b, (byte)0x4f, (byte)'P'};
+  private static byte[] F2= {(byte)0x1b, (byte)0x4f, (byte)'Q'};
+  private static byte[] F3= {(byte)0x1b, (byte)0x4f, (byte)'R'};
+  private static byte[] F4= {(byte)0x1b, (byte)0x4f, (byte)'S'};
+  private static byte[] F5= {(byte)0x1b, (byte)0x4f, (byte)'t'};
+  private static byte[] F6= {(byte)0x1b, (byte)0x4f, (byte)'u'};
+  private static byte[] F7= {(byte)0x1b, (byte)0x4f, (byte)'v'};
+  private static byte[] F8= {(byte)0x1b, (byte)0x4f, (byte)'I'};
+  private static byte[] F9= {(byte)0x1b, (byte)0x4f, (byte)'w'};
+  private static byte[] F10= {(byte)0x1b, (byte)0x4f, (byte)'x'};
+  private static byte[] tab= {(byte)0x09};
+
+  public byte[] getCodeENTER(){
+    return ENTER;
+  }
+
+  public byte[] getCodeUP(){
+    return UP;
+  }
+
+  public byte[] getCodeDOWN(){
+    return DOWN;
+  }
+
+  public byte[] getCodeRIGHT(){
+    return RIGHT;
+  }
+
+  public byte[] getCodeLEFT(){
+    return LEFT;
+  }
+
+  public byte[] getCodeF1(){
+    return F1;
+  }
+
+  public byte[] getCodeF2(){
+    return F2;
+  }
+
+  public byte[] getCodeF3(){
+    return F3;
+  }
+
+  public byte[] getCodeF4(){
+    return F4;
+  }
+
+  public byte[] getCodeF5(){
+    return F5;
+  }
+
+  public byte[] getCodeF6(){
+    return F6;
+  }
+
+  public byte[] getCodeF7(){
+    return F7;
+  }
+
+  public byte[] getCodeF8(){
+    return F8;
+  }
+
+  public byte[] getCodeF9(){
+    return F9;
+  }
+
+  public byte[] getCodeF10(){
+    return F10;
+  }
+
+  public byte[] getCodeTAB(){
+    return tab;
+  }
+}
diff --git a/src/com/jcraft/jcterm/Term.java b/src/com/jcraft/jcterm/Term.java
new file mode 100644
index 0000000..c574509
--- /dev/null
+++ b/src/com/jcraft/jcterm/Term.java
@@ -0,0 +1,80 @@
+/* -*-mode:java; c-basic-offset:2; -*- */
+/* JCTerm
+ * Copyright (C) 2002,2007 ymnk, JCraft,Inc.
+ *  
+ * Written by: ymnk<ymnk@jcaft.com>
+ *   
+ *   
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public License
+ * as published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+package com.jcraft.jcterm;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public interface Term{
+
+  void start(InputStream in, OutputStream out);
+
+  int getRowCount();
+
+  int getColumnCount();
+
+  int getCharWidth();
+
+  int getCharHeight();
+
+  void setCursor(int x, int y);
+
+  void clear();
+
+  void draw_cursor();
+
+  void redraw(int x, int y, int width, int height);
+
+  //void redraw();
+  void clear_area(int x1, int y1, int x2, int y2);
+
+  void scroll_area(int x, int y, int w, int h, int dx, int dy);
+
+  void drawBytes(byte[] buf, int s, int len, int x, int y);
+
+  void drawString(String str, int x, int y);
+
+  void beep();
+
+  void setDefaultForeGround(Object foreground);
+
+  void setDefaultBackGround(Object background);
+
+  void setForeGround(Object foreground);
+
+  void setBackGround(Object background);
+
+  void setBold();
+
+  void setUnderline();
+
+  void setReverse();
+
+  void resetAllAttributes();
+
+  int getTermWidth();
+
+  int getTermHeight();
+
+  Object getColor(int index);
+}
diff --git a/src/de/mud/terminal/SoftFont.java b/src/de/mud/terminal/SoftFont.java
new file mode 100644
index 0000000..5f13f28
--- /dev/null
+++ b/src/de/mud/terminal/SoftFont.java
@@ -0,0 +1,1145 @@
+/*
+ * This file is part of "JTA - Telnet/SSH for the JAVA(tm) platform".
+ *
+ * (c) Matthias L. Jugel, Marcus Meißner 1996-2005. All Rights Reserved.
+ *
+ * Please visit http://javatelnet.org/ for updates and contact.
+ *
+ * --LICENSE NOTICE--
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * --LICENSE NOTICE--
+ *
+ */
+
+package de.mud.terminal;
+
+import android.graphics.Canvas;
+import android.graphics.Paint;
+
+/**
+ * Any characters that are not available in standard java fonts may be
+ * drawn using the softfont utility. This utility class was derived from
+ * the cpi fonts used in linux console drivers.<P>
+ * <small>Font file generated by cpi2fnt</small>
+ * <P>
+ * <B>Maintainer:</B> Marcus Meissner
+ *
+ * @version $Id: SoftFont.java 499 2005-09-29 08:24:54Z leo $
+ * @author Matthias L. Jugel, Marcus Meissner
+ */
+public class SoftFont {
+	final static private char	SF_BITMAP = 0;
+	final static private char	SF_FILLRECT = 1;
+
+	//final static private char	SF_CHAR	= 0;
+	final static private char	SF_WIDTH= 1;
+	final static private char	SF_HEIGHT= 2;
+	final static private char	SF_TYPE  = 3;
+	final static private char	SF_DATA  = 4;
+	
+	java.util.Hashtable<Integer, Integer> font;
+	
+	/** softfont characterdata */
+	private static char[][] fontdata = {
+	
+	{0x01,8,8,SF_BITMAP, /* 1 0x01 '^A' */
+	0x7e, /* 01111110 */
+	0x81, /* 10000001 */
+	0xa5, /* 10100101 */
+	0x81, /* 10000001 */
+	0xbd, /* 10111101 */
+	0x99, /* 10011001 */
+	0x81, /* 10000001 */
+	0x7e, /* 01111110 */
+	},{ 0x02,8,8,SF_BITMAP,/* 2 0x02 '^B' */
+	0x7e, /* 01111110 */
+	0xff, /* 11111111 */
+	0xdb, /* 11011011 */
+	0xff, /* 11111111 */
+	0xc3, /* 11000011 */
+	0xe7, /* 11100111 */
+	0xff, /* 11111111 */
+	0x7e, /* 01111110 */
+	},{ 0x03,8,8,SF_BITMAP,/* 3 0x03 '^C' */
+	0x6c, /* 01101100 */
+	0xfe, /* 11111110 */
+	0xfe, /* 11111110 */
+	0xfe, /* 11111110 */
+	0x7c, /* 01111100 */
+	0x38, /* 00111000 */
+	0x10, /* 00010000 */
+	0x00, /* 00000000 */
+	},{ 0x04,8,8,SF_BITMAP,/* 4 0x04 '^D' */
+	0x10, /* 00010000 */
+	0x38, /* 00111000 */
+	0x7c, /* 01111100 */
+	0xfe, /* 11111110 */
+	0x7c, /* 01111100 */
+	0x38, /* 00111000 */
+	0x10, /* 00010000 */
+	0x00, /* 00000000 */
+	},{ 0x05,8,8,SF_BITMAP,/* 5 0x05 '^E' */
+	0x38, /* 00111000 */
+	0x7c, /* 01111100 */
+	0x38, /* 00111000 */
+	0xfe, /* 11111110 */
+	0xfe, /* 11111110 */
+	0xd6, /* 11010110 */
+	0x10, /* 00010000 */
+	0x38, /* 00111000 */
+	},{ 0x06,8,8,SF_BITMAP,/* 6 0x06 '^F' */
+	0x10, /* 00010000 */
+	0x38, /* 00111000 */
+	0x7c, /* 01111100 */
+	0xfe, /* 11111110 */
+	0xfe, /* 11111110 */
+	0x7c, /* 01111100 */
+	0x10, /* 00010000 */
+	0x38, /* 00111000 */
+	},{ 0x2666,8,8,SF_BITMAP,/* 9830 0x2666 BLACK DIAMOND */
+	0x00, /* 00000000 */
+	0x00, /* 00000000 */
+	0x18, /* 00011000 */
+	0x3c, /* 00111100 */
+	0x3c, /* 00111100 */
+	0x18, /* 00011000 */
+	0x00, /* 00000000 */
+	0x00, /* 00000000 */
+	},{ 0x07,8,8,SF_BITMAP,/* 7 0x07 '^G' */
+	0x00, /* 00000000 */
+	0x00, /* 00000000 */
+	0x18, /* 00011000 */
+	0x3c, /* 00111100 */
+	0x3c, /* 00111100 */
+	0x18, /* 00011000 */
+	0x00, /* 00000000 */
+	0x00, /* 00000000 */
+	},{ 0x08,8,8,SF_BITMAP,/* 8 0x08 '^H' */
+	0xff, /* 11111111 */
+	0xff, /* 11111111 */
+	0xe7, /* 11100111 */
+	0xc3, /* 11000011 */
+	0xc3, /* 11000011 */
+	0xe7, /* 11100111 */
+	0xff, /* 11111111 */
+	0xff, /* 11111111 */
+	},{ 0x09,8,8,SF_BITMAP,/* 9 0x09 '^I' */
+	0x00, /* 00000000 */
+	0x3c, /* 00111100 */
+	0x66, /* 01100110 */
+	0x42, /* 01000010 */
+	0x42, /* 01000010 */
+	0x66, /* 01100110 */
+	0x3c, /* 00111100 */
+	0x00, /* 00000000 */
+	},{ 0x0a,8,8,SF_BITMAP,/* 10 0x0a '^J' */
+	0xff, /* 11111111 */
+	0xc3, /* 11000011 */
+	0x99, /* 10011001 */
+	0xbd, /* 10111101 */
+	0xbd, /* 10111101 */
+	0x99, /* 10011001 */
+	0xc3, /* 11000011 */
+	0xff, /* 11111111 */
+	},{ 0x0b,8,8,SF_BITMAP,/* 11 0x0b '^K' */
+	0x0f, /* 00001111 */
+	0x07, /* 00000111 */
+	0x0f, /* 00001111 */
+	0x7d, /* 01111101 */
+	0xcc, /* 11001100 */
+	0xcc, /* 11001100 */
+	0xcc, /* 11001100 */
+	0x78, /* 01111000 */
+	},{ 0x0c,8,8,SF_BITMAP,/* 12 0x0c '^L' */
+	0x3c, /* 00111100 */
+	0x66, /* 01100110 */
+	0x66, /* 01100110 */
+	0x66, /* 01100110 */
+	0x3c, /* 00111100 */
+	0x18, /* 00011000 */
+	0x7e, /* 01111110 */
+	0x18, /* 00011000 */
+	},{ 0x0d,8,8,SF_BITMAP,/* 13 0x0d '^M' */
+	0x3f, /* 00111111 */
+	0x33, /* 00110011 */
+	0x3f, /* 00111111 */
+	0x30, /* 00110000 */
+	0x30, /* 00110000 */
+	0x70, /* 01110000 */
+	0xf0, /* 11110000 */
+	0xe0, /* 11100000 */
+	},{ 0x0e,8,8,SF_BITMAP,/* 14 0x0e '^N' */
+	0x7f, /* 01111111 */
+	0x63, /* 01100011 */
+	0x7f, /* 01111111 */
+	0x63, /* 01100011 */
+	0x63, /* 01100011 */
+	0x67, /* 01100111 */
+	0xe6, /* 11100110 */
+	0xc0, /* 11000000 */
+	},{ 0x0f,8,8,SF_BITMAP,/* 15 0x0f '^O' */
+	0x18, /* 00011000 */
+	0xdb, /* 11011011 */
+	0x3c, /* 00111100 */
+	0xe7, /* 11100111 */
+	0xe7, /* 11100111 */
+	0x3c, /* 00111100 */
+	0xdb, /* 11011011 */
+	0x18, /* 00011000 */
+	},{ 0x10,8,8,SF_BITMAP,/* 16 0x10 '^P' */
+	0x80, /* 10000000 */
+	0xe0, /* 11100000 */
+	0xf8, /* 11111000 */
+	0xfe, /* 11111110 */
+	0xf8, /* 11111000 */
+	0xe0, /* 11100000 */
+	0x80, /* 10000000 */
+	0x00, /* 00000000 */
+	},{ 0x11,8,8,SF_BITMAP,/* 17 0x11 '^Q' */
+	0x02, /* 00000010 */
+	0x0e, /* 00001110 */
+	0x3e, /* 00111110 */
+	0xfe, /* 11111110 */
+	0x3e, /* 00111110 */
+	0x0e, /* 00001110 */
+	0x02, /* 00000010 */
+	0x00, /* 00000000 */
+	},{ 0x12,8,8,SF_BITMAP,/* 18 0x12 '^R' */
+	0x18, /* 00011000 */
+	0x3c, /* 00111100 */
+	0x7e, /* 01111110 */
+	0x18, /* 00011000 */
+	0x18, /* 00011000 */
+	0x7e, /* 01111110 */
+	0x3c, /* 00111100 */
+	0x18, /* 00011000 */
+	},{ 0x13,8,8,SF_BITMAP,/* 19 0x13 '^S' */
+	0x66, /* 01100110 */
+	0x66, /* 01100110 */
+	0x66, /* 01100110 */
+	0x66, /* 01100110 */
+	0x66, /* 01100110 */
+	0x00, /* 00000000 */
+	0x66, /* 01100110 */
+	0x00, /* 00000000 */
+	},{ 0x14,8,8,SF_BITMAP,/* 20 0x14 '^T' */
+	0x7f, /* 01111111 */
+	0xdb, /* 11011011 */
+	0xdb, /* 11011011 */
+	0x7b, /* 01111011 */
+	0x1b, /* 00011011 */
+	0x1b, /* 00011011 */
+	0x1b, /* 00011011 */
+	0x00, /* 00000000 */
+	},{ 0x15,8,8,SF_BITMAP,/* 21 0x15 '^U' */
+	0x3e, /* 00111110 */
+	0x61, /* 01100001 */
+	0x3c, /* 00111100 */
+	0x66, /* 01100110 */
+	0x66, /* 01100110 */
+	0x3c, /* 00111100 */
+	0x86, /* 10000110 */
+	0x7c, /* 01111100 */
+	},{ 0x16,8,8,SF_BITMAP,/* 22 0x16 '^V' */
+	0x00, /* 00000000 */
+	0x00, /* 00000000 */
+	0x00, /* 00000000 */
+	0x00, /* 00000000 */
+	0x7e, /* 01111110 */
+	0x7e, /* 01111110 */
+	0x7e, /* 01111110 */
+	0x00, /* 00000000 */
+	},{ 0x17,8,8,SF_BITMAP,/* 23 0x17 '^W' */
+	0x18, /* 00011000 */
+	0x3c, /* 00111100 */
+	0x7e, /* 01111110 */
+	0x18, /* 00011000 */
+	0x7e, /* 01111110 */
+	0x3c, /* 00111100 */
+	0x18, /* 00011000 */
+	0xff, /* 11111111 */
+	},{ 0x18,8,8,SF_BITMAP,/* 24 0x18 '^X' */
+	0x18, /* 00011000 */
+	0x3c, /* 00111100 */
+	0x7e, /* 01111110 */
+	0x18, /* 00011000 */
+	0x18, /* 00011000 */
+	0x18, /* 00011000 */
+	0x18, /* 00011000 */
+	0x00, /* 00000000 */
+	},{ 0x19,8,8,SF_BITMAP,/* 25 0x19 '^Y' */
+	0x18, /* 00011000 */
+	0x18, /* 00011000 */
+	0x18, /* 00011000 */
+	0x18, /* 00011000 */
+	0x7e, /* 01111110 */
+	0x3c, /* 00111100 */
+	0x18, /* 00011000 */
+	0x00, /* 00000000 */
+	},{ 0x1a,8,8,SF_BITMAP,/* 26 0x1a '^Z' */
+	0x00, /* 00000000 */
+	0x18, /* 00011000 */
+	0x0c, /* 00001100 */
+	0xfe, /* 11111110 */
+	0x0c, /* 00001100 */
+	0x18, /* 00011000 */
+	0x00, /* 00000000 */
+	0x00, /* 00000000 */
+	},{ 0x1b,8,8,SF_BITMAP,/* 27 0x1b '^[' */
+	0x00, /* 00000000 */
+	0x30, /* 00110000 */
+	0x60, /* 01100000 */
+	0xfe, /* 11111110 */
+	0x60, /* 01100000 */
+	0x30, /* 00110000 */
+	0x00, /* 00000000 */
+	0x00, /* 00000000 */
+	},{ 0x1c,8,8,SF_BITMAP,/* 28 0x1c '^\' */
+	0x00, /* 00000000 */
+	0x00, /* 00000000 */
+	0xc0, /* 11000000 */
+	0xc0, /* 11000000 */
+	0xc0, /* 11000000 */
+	0xfe, /* 11111110 */
+	0x00, /* 00000000 */
+	0x00, /* 00000000 */
+	},{ 0x1d,8,8,SF_BITMAP,/* 29 0x1d '^]' */
+	0x00, /* 00000000 */
+	0x24, /* 00100100 */
+	0x66, /* 01100110 */
+	0xff, /* 11111111 */
+	0x66, /* 01100110 */
+	0x24, /* 00100100 */
+	0x00, /* 00000000 */
+	0x00, /* 00000000 */
+	},{ 0x1e,8,8,SF_BITMAP,/* 30 0x1e '^^' */
+	0x00, /* 00000000 */
+	0x18, /* 00011000 */
+	0x3c, /* 00111100 */
+	0x7e, /* 01111110 */
+	0xff, /* 11111111 */
+	0xff, /* 11111111 */
+	0x00, /* 00000000 */
+	0x00, /* 00000000 */
+	},{ 0x1f,8,8,SF_BITMAP,/* 31 0x1f '^_' */
+	0x00, /* 00000000 */
+	0xff, /* 11111111 */
+	0xff, /* 11111111 */
+	0x7e, /* 01111110 */
+	0x3c, /* 00111100 */
+	0x18, /* 00011000 */
+	0x00, /* 00000000 */
+	0x00, /* 00000000 */
+	},{ 0x7f,8,8,SF_BITMAP,/* 127 0x7f '' */
+	0x00, /* 00000000 */
+	0x10, /* 00010000 */
+	0x38, /* 00111000 */
+	0x6c, /* 01101100 */
+	0xc6, /* 11000110 */
+	0xc6, /* 11000110 */
+	0xfe, /* 11111110 */
+	0x00, /* 00000000 */
+	},{ 0x2591,8,8,SF_BITMAP,/* LIGHT SHADE */
+	0x22, /* 00100010 */
+	0x88, /* 10001000 */
+	0x22, /* 00100010 */
+	0x88, /* 10001000 */
+	0x22, /* 00100010 */
+	0x88, /* 10001000 */
+	0x22, /* 00100010 */
+	0x88, /* 10001000 */
+	},{ 0x2592,8,8,SF_BITMAP,/* MEDIUM SHADE */
+	0x55, /* 01010101 */
+	0xaa, /* 10101010 */
+	0x55, /* 01010101 */
+	0xaa, /* 10101010 */
+	0x55, /* 01010101 */
+	0xaa, /* 10101010 */
+	0x55, /* 01010101 */
+	0xaa, /* 10101010 */
+	},{ 0x2593,8,8,SF_BITMAP,/* DARK SHADE */
+	0x77, /* 01110111 */
+	0xdd, /* 11011101 */
+	0x77, /* 01110111 */
+	0xdd, /* 11011101 */
+	0x77, /* 01110111 */
+	0xdd, /* 11011101 */
+	0x77, /* 01110111 */
+	0xdd, /* 11011101 */
+	},{ 0x221a,8,8,SF_BITMAP,/* SQUARE ROOT */
+	0x78, /* 01111000 */
+	0x0c, /* 00001100 */
+	0x18, /* 00011000 */
+	0x30, /* 00110000 */
+	0x7c, /* 01111100 */
+	0x00, /* 00000000 */
+	0x00, /* 00000000 */
+	0x00, /* 00000000 */
+	},{ 0x2320,8,8,SF_FILLRECT,/* UPPER INTERVAL*/
+		0x4031,
+		0x3127,
+		0x6122,
+		/* 00001110 */
+		/* 00011011 */
+		/* 00011011 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+	},{ 0x2321,8,8,SF_FILLRECT,/* BOTTOM HALF INTEGRAL */
+		0x3027,
+		0x0522,
+		0x1731,
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 11011000 */
+		/* 11011000 */
+		/* 01110000 */
+	},{ 0x25a0,8,8,SF_FILLRECT,/* BLACK SQUARE */
+		0x2244,
+		/* 00000000 */
+		/* 00000000 */
+		/* 00111100 */
+		/* 00111100 */
+		/* 00111100 */
+		/* 00111100 */
+		/* 00000000 */
+		/* 00000000 */
+	},{ 0x2502,8,8,SF_FILLRECT,/*BOX DRAWINGS LIGHT VERTICAL*/
+		0x3028,
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+	},{ 0x2524,8,8,SF_FILLRECT,/* BOX DRAWINGS LIGHT VERTICAL AND LEFT */
+		0x3028,
+		0x0431,
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 11111000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+	},{ 0x2561,8,8,SF_FILLRECT,/*BOX DRAWINGS VERTICAL SINGLE AND LEFT DOUBLE*/
+		0x3028,
+		0x0231,
+		0x0431,
+		/* 00011000 */
+		/* 00011000 */
+		/* 11111000 */
+		/* 00011000 */
+		/* 11111000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+	},{ 0x2562,8,8,SF_FILLRECT,/* BOX DRAWINGS VERTICAL DOUBLE AND LEFT SINGLE */
+		0x2028,
+		0x5028,
+		0x0421,
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 11110110 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+	},{ 0x2556,8,8,SF_FILLRECT,/* BOX DRAWINGS DOWN DOUBLE AND LEFT SINGLE */
+		0x0471,
+		0x2523,
+		0x5523,
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 11111110 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+	},{ 0x2555,8,8,SF_FILLRECT,/* BOX DRAWINGS DOWN SINGLE AND LEFT DOUBLE */
+		0x3226,
+		0x0231,
+		0x0431,
+		/* 00000000 */
+		/* 00000000 */
+		/* 11111000 */
+		/* 00011000 */
+		/* 11111000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+	},{ 0x2563,8,8,SF_FILLRECT,/* BOX DRAWINGS DOUBLE VERTICAL AND LEFT*/
+		0x2022,
+		0x0221,
+		0x0421,
+		0x2424,
+		0x5028,
+		/* 00110110 */
+		/* 00110110 */
+		/* 11110110 */
+		/* 00000110 */
+		/* 11110110 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+	},{ 0x2551,8,8,SF_FILLRECT,/* BOX DRAWINGS DOUBLE VERTICAL */
+		0x2028,
+		0x5028,
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+	},{ 0x2557,8,8,SF_FILLRECT,/*  BOX DRAWINGS DOUBLE DOWN AND LEFT */
+		0x0271,
+		0x5325,
+		0x0441,
+		0x2523,
+		/* 00000000 */
+		/* 00000000 */
+		/* 11111110 */
+		/* 00000110 */
+		/* 11110110 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+	},{ 0x255d,8,8,SF_FILLRECT,/* BOX DRAWINGS DOUBLE UP AND LEFT */
+		0x2022,
+		0x0241,
+		0x5025,
+		0x0451,
+		/* 00110110 */
+		/* 00110110 */
+		/* 11110110 */
+		/* 00000110 */
+		/* 11111110 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+	},{ 0x255c,8,8,SF_FILLRECT,/* BOX DRAWINGS UP DOUBLE AND LEFT SINGLE */
+		0x2024,
+		0x5024,
+		0x0471,
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 11111110 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+	},{ 0x255b,8,8,SF_FILLRECT,/* BOX DRAWINGS UP SINGLE AND LEFT DOUBLE */
+		0x3025,
+		0x0231,
+		0x0431,
+		/* 00011000 */
+		/* 00011000 */
+		/* 11111000 */
+		/* 00011000 */
+		/* 11111000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+	},{ 0x2510,8,8,SF_FILLRECT,/* BOX DRAWINGS LIGHT DOWN AND LEFT */
+		0x0451,
+		0x3523,
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 11111000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+	},{ 0x2514,8,8,SF_FILLRECT,/* BOX DRAWINGS LIGHT UP AND RIGHT */
+		0x3025,
+		0x5431,
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011111 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+	},{ 0x2534,8,8,SF_FILLRECT,/* BOX DRAWINGS LIGHT UP AND HORIZONTAL */
+		0x3024,
+		0x0481,
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 11111111 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+	},{ 0x252c,8,8,SF_FILLRECT,/* BOX DRAWINGS LIGHT DOWN AND HORIZONTAL */
+		0x0481,
+		0x3523,
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 11111111 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+	},{ 0x251c,8,8,SF_FILLRECT,/* BOX DRAWINGS LIGHT VERTICAL AND RIGHT */
+		0x3028,
+		0x5431,
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011111 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+	},{ 0x2500,8,8,SF_FILLRECT,/* BOX DRAWINGS LIGHT HORIZONTAL */
+		0x0481,
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 11111111 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+	},{ 0x2594,8,8,SF_FILLRECT,/* UPPER 1/8 (1st scanline) */
+		0x0081,
+		/* 11111111 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+	},{ 0x25ac,8,8,SF_FILLRECT,/* LOWER 1/8 (7nd scanline) */
+		0x0781,
+		/* 11111111 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+	},{ 0x253c,8,8,SF_FILLRECT,/* BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL */
+		0x3028,
+		0x0481,
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 11111111 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+	},{ 0x255e,8,8,SF_FILLRECT,/* BOX DRAWINGS VERTICAL SINGLE AND RIGHT DOUBLE */
+		0x3028,
+		0x5231,
+		0x5431,
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011111 */
+		/* 00011000 */
+		/* 00011111 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+	},{ 0x255f,8,8,SF_FILLRECT,/* BOX DRAWINGS VERTICAL DOUBLE AND RIGHT SINGLE */
+		0x2028,
+		0x5028,
+		0x7411,
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110111 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+	},{ 0x255a,8,8,SF_FILLRECT,/* BOX DRAWINGS DOUBLE UP AND RIGHT */
+		0x2025,
+		0x5023,
+		0x7211,
+		0x4441,
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110111 */
+		/* 00110000 */
+		/* 00111111 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+	},{ 0x2554,8,8,SF_FILLRECT,/* BOX DRAWINGS DOUBLE DOWN AND RIGHT */
+		0x2261,
+		0x2325,
+		0x5424,
+		0x7411,
+		/* 00000000 */
+		/* 00000000 */
+		/* 00111111 */
+		/* 00110000 */
+		/* 00110111 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+	},{ 0x2569,8,8,SF_FILLRECT,/* BOX DRAWINGS DOUBLE UP AND HORIZONTAL */
+		0x2022,
+		0x0241,
+		0x5022,
+		0x5231,
+		0x0481,
+		/* 00110110 */
+		/* 00110110 */
+		/* 11110111 */
+		/* 00000000 */
+		/* 11111111 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+	},{ 0x2566,8,8,SF_FILLRECT,/* BOX DRAWINGS DOUBLE DOWN AND HORIZONTAL */
+		0x0281,
+		0x0441,
+		0x2523,
+		0x5431,
+		0x5523,
+		/* 00000000 */
+		/* 00000000 */
+		/* 11111111 */
+		/* 00000000 */
+		/* 11110111 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+	},{ 0x2560,8,8,SF_FILLRECT,/* BOX DRAWINGS DOUBLE VERTICAL AND RIGHT */
+		0x2028,
+		0x5022,
+		0x5231,
+		0x5431,
+		0x5623,
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110111 */
+		/* 00110000 */
+		/* 00110111 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+	},{ 0x2550,8,8,SF_FILLRECT,/* BOX DRAWINGS DOUBLE HORIZONTAL */
+		0x0281,
+		0x0481,
+		/* 00000000 */
+		/* 00000000 */
+		/* 11111111 */
+		/* 00000000 */
+		/* 11111111 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+	},{ 0x256c,8,8,SF_FILLRECT,/* BOX DRAWINGS DOUBLE VERTICAL AND HORIZONTAL */
+		0x2022,
+		0x0241,
+		0x5022,
+		0x5231,
+		0x0441,
+		0x2523,
+		0x5431,
+		0x5523,
+		/* 00110110 */
+		/* 00110110 */
+		/* 11110111 */
+		/* 00000000 */
+		/* 11110111 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+	},{ 0x2567,8,8,SF_FILLRECT,/* BOX DRAWINGS UP SINGLE AND HORIZONTAL DOUBLE */
+		0x3022,
+		0x0281,
+		0x0481,
+		/* 00011000 */
+		/* 00011000 */
+		/* 11111111 */
+		/* 00000000 */
+		/* 11111111 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+	},{ 0x2568,8,8,SF_FILLRECT,/* BOX DRAWINGS UP DOUBLE AND HORIZONTAL SINGLE */
+		0x2024,
+		0x5024,
+		0x0481,
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 11111111 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+	},{ 0x2564,8,8,SF_FILLRECT,/* BOX DRAWINGS DOWN SINGLE AND HORIZONTAL DOUBLE */
+		0x0281,
+		0x0481,
+		0x3523,
+		/* 00000000 */
+		/* 00000000 */
+		/* 11111111 */
+		/* 00000000 */
+		/* 11111111 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+	},{ 0x2565,8,8,SF_FILLRECT,/* BOX DRAWINGS DOWN DOUBLE AND HORIZONTAL SINGLE */
+		0x0481,
+		0x2523,
+		0x5523,
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 11111111 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+	},{ 0x2559,8,8,SF_FILLRECT,/* BOX DRAWINGS UP DOUBLE AND RIGHT SINGLE */
+		0x2024,
+		0x5024,
+		0x2461,
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00111111 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+	},{ 0x2558,8,8,SF_FILLRECT,/* BOX DRAWINGS UP SINGLE AND RIGHT DOUBLE */
+		0x3025,
+		0x5231,
+		0x5431,
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011111 */
+		/* 00011000 */
+		/* 00011111 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+	},{ 0x2552,8,8,SF_FILLRECT,/* BOX DRAWINGS DOWN SINGLE AND RIGHT DOUBLE */
+		0x3226,
+		0x5231,
+		0x5431,
+		/* 00000000 */
+		/* 00000000 */
+		/* 00011111 */
+		/* 00011000 */
+		/* 00011111 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+	},{ 0x2553,8,8,SF_FILLRECT,/* BOX DRAWINGS DOWN DOUBLE AND RIGHT SINGLE */
+		0x2461,
+		0x2523,
+		0x5523,
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00111111 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+	},{ 0x256b,8,8,SF_FILLRECT,/* BOX DRAWINGS VERTICAL DOUBLE AND HORIZONTAL SINGLE */
+		0x2028,
+		0x5028,
+		0x0481,
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 11111111 */
+		/* 00110110 */
+		/* 00110110 */
+		/* 00110110 */
+	},{ 0x256a,8,8,SF_FILLRECT,/* BOX DRAWINGS VERTICAL SINGLE AND HORIZONTAL DOUBLE */
+		0x3028,
+		0x0281,
+		0x0481,
+		/* 00011000 */
+		/* 00011000 */
+		/* 11111111 */
+		/* 00011000 */
+		/* 11111111 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+	},{ 0x2518,8,8,SF_FILLRECT,/* BOX DRAWINGS LIGHT UP AND LEFT */
+		0x3025,
+		0x0431,
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 11111000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+	},{ 0x250c,8,8,SF_FILLRECT,/* BOX DRAWINGS LIGHT DOWN AND RIGHT */
+		0x3451,
+		0x3523,
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00011111 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00011000 */
+	},{ 0x2588,8,8,SF_FILLRECT,/* FULL BLOCK */
+		0x0088,
+		/* 11111111 */
+		/* 11111111 */
+		/* 11111111 */
+		/* 11111111 */
+		/* 11111111 */
+		/* 11111111 */
+		/* 11111111 */
+		/* 11111111 */
+	},{ 0x2584,8,8,SF_FILLRECT,/* LOWER HALF BLOCK */
+		0x0484,
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 11111111 */
+		/* 11111111 */
+		/* 11111111 */
+		/* 11111111 */
+	},{ 0x258c,8,8,SF_FILLRECT,/* LEFT HALF BLOCK */
+		0x0048,
+		/* 11110000 */
+		/* 11110000 */
+		/* 11110000 */
+		/* 11110000 */
+		/* 11110000 */
+		/* 11110000 */
+		/* 11110000 */
+		/* 11110000 */
+	},{ 0x2590,8,8,SF_FILLRECT,/* RIGHT HALF BLOCK */
+		0x4048,
+		/* 00001111 */
+		/* 00001111 */
+		/* 00001111 */
+		/* 00001111 */
+		/* 00001111 */
+		/* 00001111 */
+		/* 00001111 */
+		/* 00001111 */
+	},{ 0x2580,8,8,SF_FILLRECT,/* UPPER HALF BLOCK */
+		0x0084,
+		/* 11111111 */
+		/* 11111111 */
+		/* 11111111 */
+		/* 11111111 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+	},{ 0x2261,8,8,SF_FILLRECT,/* EQUIVALENT SIGN */
+		0x2081,
+		0x4081,
+		0x6081,
+		/* 00000000 */
+		/* 00000000 */
+		/* 11111111 */
+		/* 00000000 */
+		/* 11111111 */
+		/* 00000000 */
+		/* 11111111 */
+		/* 00000000 */
+	},{ 0x221e,8,8,SF_BITMAP,/* INFINITY */
+		0x00,
+		0x00,
+		0x7e,
+		0xdb,
+		0xdb,
+		0x7e,
+		0x00,
+		0x00,
+		/* 00000000 */
+		/* 00000000 */
+		/* 01111110 */
+		/* 11011011 */
+		/* 11011011 */
+		/* 01111110 */
+		/* 00000000 */
+		/* 00000000 */
+	},{ 0x207f,8,8,SF_FILLRECT,/* small superscript n */
+		0x1041,
+		0x1124,
+		0x4124,
+		/* 01111000 */
+		/* 01101100 */
+		/* 01101100 */
+		/* 01101100 */
+		/* 01101100 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+	},{ 0x00b2,8,8,SF_BITMAP,/* small superscript 2 */
+		0x70, /* 01110000 */
+		0x1c, /* 00011100 */
+		0x38, /* 00111000 */
+		0x60, /* 01100000 */
+		0x78, /* 01111000 */
+		0x00, /* 00000000 */
+		0x00, /* 00000000 */
+		0x00, /* 00000000 */
+	},{ 0x2219,8,8,SF_FILLRECT,/* BULLET OPERATOR */
+		0x3322,
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00011000 */
+		/* 00011000 */
+		/* 00000000 */
+		/* 00000000 */
+		/* 00000000 */
+	},{ 0x2191,8,8,SF_BITMAP,/* UP ARROW */
+		0x08, /* 00001000 */
+		0x1c, /* 00011100 */
+		0x3e, /* 00111110 */
+		0x7f, /* 01111111 */
+		0x1c, /* 00011100 */
+		0x1c, /* 00011100 */
+		0x1c, /* 00011100 */
+		0x1c, /* 00011100 */
+	},{ 0x2193,8,8,SF_BITMAP,/* DOWN ARROW */
+		0x1c, /* 00011100 */
+		0x1c, /* 00011100 */
+		0x1c, /* 00011100 */
+		0x1c, /* 00011100 */
+		0x7f, /* 01111111 */
+		0x3e, /* 00111110 */
+		0x1c, /* 00011100 */
+		0x08, /* 00001000 */
+	},{ 0x25ba,8,8,SF_BITMAP,/* RIGHT ARROW (TRIANGLE ONLY) */
+		0x00, /* 00000000 */
+		0x40, /* 01000000 */
+		0x60, /* 01100000 */
+		0x7c, /* 01111100 */
+		0x70, /* 01110000 */
+		0x60, /* 01100000 */
+		0x40, /* 01000000 */
+		0x00, /* 00000000 */
+	},{ 0x25c4,8,8,SF_BITMAP,/* LEFT ARROW (TRIANGLE ONLY) */
+		0x00, /* 00000000 */
+		0x02, /* 00000010 */
+		0x06, /* 00000110 */
+		0x3e, /* 00111110 */
+		0x0e, /* 00001110 */
+		0x06, /* 00000110 */
+		0x02, /* 00000010 */
+		0x00, /* 00000000 */
+	}};
+
+	public SoftFont() {
+		font = new java.util.Hashtable<Integer, Integer>();
+		for (int i=0;i<fontdata.length;i++)
+			font.put(new Integer(fontdata[i][0]),new Integer(i));
+	}
+
+	public boolean inSoftFont(char c) {
+		boolean insoftfont;
+
+		insoftfont = (null!=font.get(new Integer(c)));
+		if (!insoftfont && (int)c>=0x100) {
+			System.out.println("Character "+((int)c)+" not in softfont");
+		}
+		return insoftfont;
+	}
+
+	public void drawChar(Canvas g, Paint p, char c,int x,int y,int cw,int ch) {
+		double	dw,dh;
+		Object	Ientry;
+		int	w,h,entry,i,fontwidth,fontheight;
+		
+		Ientry = font.get(new Integer(c));
+		if (Ientry == null)
+			return;
+		entry = ((Integer)Ientry).intValue();
+		fontwidth = fontdata[entry][SF_WIDTH];
+		fontheight = fontdata[entry][SF_HEIGHT];
+
+		dw = cw*1.0/fontwidth;
+		dh = ch*1.0/fontheight;
+
+		switch (fontdata[entry][SF_TYPE]) {
+		case SF_BITMAP:
+			for (h=0;h<fontheight;h++) {
+				for (w=0;w<fontwidth;w++) {
+					//FIXME: 8 bit max currently...
+					if (0!=(fontdata[entry][h+SF_DATA] & (1<<(7-w)))) {
+						g.drawRect(
+							x+(int)(w*dw),
+							y+(int)(h*dh),
+							((int)((w+1)*dw))-(int)(w*dw),
+							((int)((h+1)*dh))-(int)(h*dh),
+							p
+						);
+					}
+				}
+			}
+			break;
+		case SF_FILLRECT:
+			i=SF_DATA;
+			while (i<fontdata[entry].length) {
+				int	xw,xh;
+
+				w=(fontdata[entry][i]&0xF000)>>12;
+				h=(fontdata[entry][i]&0x0F00)>>8;
+				xw = (fontdata[entry][i]&0x00F0)>>4;
+				xh = (fontdata[entry][i]&0x000F);
+				g.drawRect(
+					x+(int)(w*dw),
+					y+(int)(h*dh),
+					((int)((w+xw)*dw))-(int)(w*dw),
+					((int)((h+xh)*dh))-(int)(h*dh),
+					p
+				);
+				i++;
+			}
+			break;
+		default:
+			break;
+		}
+	}
+}
diff --git a/src/de/mud/terminal/VDUBuffer.java b/src/de/mud/terminal/VDUBuffer.java
new file mode 100644
index 0000000..7f203e6
--- /dev/null
+++ b/src/de/mud/terminal/VDUBuffer.java
@@ -0,0 +1,791 @@
+/*
+ * This file is part of "JTA - Telnet/SSH for the JAVA(tm) platform".
+ *
+ * (c) Matthias L. Jugel, Marcus Meißner 1996-2005. All Rights Reserved.
+ *
+ * Please visit http://javatelnet.org/ for updates and contact.
+ *
+ * --LICENSE NOTICE--
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * --LICENSE NOTICE--
+ *
+ */
+
+package de.mud.terminal;
+
+/**
+ * Implementation of a Video Display Unit (VDU) buffer. This class contains
+ * all methods to manipulate the buffer that stores characters and their
+ * attributes as well as the regions displayed.
+ *
+ * @author Matthias L. Jugel, Marcus Mei�ner
+ * @version $Id: VDUBuffer.java 503 2005-10-24 07:34:13Z marcus $
+ */
+public class VDUBuffer {
+
+  /** The current version id tag */
+  public final static String ID = "$Id: VDUBuffer.java 503 2005-10-24 07:34:13Z marcus $";
+
+  /** Enable debug messages. */
+  public final static int debug = 0;
+
+  public int height, width;                          /* rows and columns */
+  public boolean[] update;        /* contains the lines that need update */
+  public char[][] charArray;                  /* contains the characters */
+  public int[][] charAttributes;             /* contains character attrs */
+  public int bufSize;
+  public int maxBufSize;                                 /* buffer sizes */
+  public int screenBase;                      /* the actual screen start */
+  public int windowBase;                   /* where the start displaying */
+  public int scrollMarker;               /* marks the last line inserted */
+
+  private int topMargin;                               /* top scroll margin */
+  private int bottomMargin;                         /* bottom scroll margin */
+
+  // cursor variables
+  protected boolean showcursor = true;
+  protected int cursorX, cursorY;
+
+  /** Scroll up when inserting a line. */
+  public final static boolean SCROLL_UP = false;
+  /** Scroll down when inserting a line. */
+  public final static boolean SCROLL_DOWN = true;
+
+  /** Make character normal. */
+  public final static int NORMAL = 0x00;
+  /** Make character bold. */
+  public final static int BOLD = 0x01;
+  /** Underline character. */
+  public final static int UNDERLINE = 0x02;
+  /** Invert character. */
+  public final static int INVERT = 0x04;
+  /** Lower intensity character. */
+  public final static int LOW = 0x08;
+  /** Invisible character. */
+  public final static int INVISIBLE = 0x10;
+
+  /** how much to left shift the foreground color */
+  public final static int COLOR_FG_SHIFT = 5;
+  /** how much to left shift the background color */
+  public final static int COLOR_BG_SHIFT = 9;
+  /** color mask */
+  public final static int COLOR = 0x1fe0;
+  /** foreground color mask */
+  public final static int COLOR_FG = 0x1e0;
+  /** background color mask */
+  public final static int COLOR_BG = 0x1e00;
+
+  /**
+   * Create a new video display buffer with the passed width and height in
+   * characters.
+   * @param width the length of the character lines
+   * @param height the amount of lines on the screen
+   */
+  public VDUBuffer(int width, int height) {
+    // set the display screen size
+    setScreenSize(width, height, false);
+  }
+
+  /**
+   * Create a standard video display buffer with 80 columns and 24 lines.
+   */
+  public VDUBuffer() {
+    this(80, 24);
+  }
+
+  /**
+   * Put a character on the screen with normal font and outline.
+   * The character previously on that position will be overwritten.
+   * You need to call redraw() to update the screen.
+   * @param c x-coordinate (column)
+   * @param l y-coordinate (line)
+   * @param ch the character to show on the screen
+   * @see #insertChar
+   * @see #deleteChar
+   * @see #redraw
+   */
+  public void putChar(int c, int l, char ch) {
+    putChar(c, l, ch, NORMAL);
+  }
+
+  /**
+   * Put a character on the screen with specific font and outline.
+   * The character previously on that position will be overwritten.
+   * You need to call redraw() to update the screen.
+   * @param c x-coordinate (column)
+   * @param l y-coordinate (line)
+   * @param ch the character to show on the screen
+   * @param attributes the character attributes
+   * @see #BOLD
+   * @see #UNDERLINE
+   * @see #INVERT
+   * @see #INVISIBLE
+   * @see #NORMAL
+   * @see #LOW
+   * @see #insertChar
+   * @see #deleteChar
+   * @see #redraw
+   */
+
+  public void putChar(int c, int l, char ch, int attributes) {
+    c = checkBounds(c, 0, width - 1);
+    l = checkBounds(l, 0, height - 1);
+    charArray[screenBase + l][c] = ch;
+    charAttributes[screenBase + l][c] = attributes;
+    markLine(l, 1);
+  }
+
+  /**
+   * Get the character at the specified position.
+   * @param c x-coordinate (column)
+   * @param l y-coordinate (line)
+   * @see #putChar
+   */
+  public char getChar(int c, int l) {
+    c = checkBounds(c, 0, width - 1);
+    l = checkBounds(l, 0, height - 1);
+    return charArray[screenBase + l][c];
+  }
+
+  /**
+   * Get the attributes for the specified position.
+   * @param c x-coordinate (column)
+   * @param l y-coordinate (line)
+   * @see #putChar
+   */
+  public int getAttributes(int c, int l) {
+    c = checkBounds(c, 0, width - 1);
+    l = checkBounds(l, 0, height - 1);
+    return charAttributes[screenBase + l][c];
+  }
+
+  /**
+   * Insert a character at a specific position on the screen.
+   * All character right to from this position will be moved one to the right.
+   * You need to call redraw() to update the screen.
+   * @param c x-coordinate (column)
+   * @param l y-coordinate (line)
+   * @param ch the character to insert
+   * @param attributes the character attributes
+   * @see #BOLD
+   * @see #UNDERLINE
+   * @see #INVERT
+   * @see #INVISIBLE
+   * @see #NORMAL
+   * @see #LOW
+   * @see #putChar
+   * @see #deleteChar
+   * @see #redraw
+   */
+  public void insertChar(int c, int l, char ch, int attributes) {
+    c = checkBounds(c, 0, width - 1);
+    l = checkBounds(l, 0, height - 1);
+    System.arraycopy(charArray[screenBase + l], c,
+                     charArray[screenBase + l], c + 1, width - c - 1);
+    System.arraycopy(charAttributes[screenBase + l], c,
+                     charAttributes[screenBase + l], c + 1, width - c - 1);
+    putChar(c, l, ch, attributes);
+  }
+
+  /**
+   * Delete a character at a given position on the screen.
+   * All characters right to the position will be moved one to the left.
+   * You need to call redraw() to update the screen.
+   * @param c x-coordinate (column)
+   * @param l y-coordinate (line)
+   * @see #putChar
+   * @see #insertChar
+   * @see #redraw
+   */
+  public void deleteChar(int c, int l) {
+    c = checkBounds(c, 0, width - 1);
+    l = checkBounds(l, 0, height - 1);
+    if (c < width - 1) {
+      System.arraycopy(charArray[screenBase + l], c + 1,
+                       charArray[screenBase + l], c, width - c - 1);
+      System.arraycopy(charAttributes[screenBase + l], c + 1,
+                       charAttributes[screenBase + l], c, width - c - 1);
+    }
+    putChar(width - 1, l, (char) 0);
+  }
+
+  /**
+   * Put a String at a specific position. Any characters previously on that
+   * position will be overwritten. You need to call redraw() for screen update.
+   * @param c x-coordinate (column)
+   * @param l y-coordinate (line)
+   * @param s the string to be shown on the screen
+   * @see #BOLD
+   * @see #UNDERLINE
+   * @see #INVERT
+   * @see #INVISIBLE
+   * @see #NORMAL
+   * @see #LOW
+   * @see #putChar
+   * @see #insertLine
+   * @see #deleteLine
+   * @see #redraw
+   */
+  public void putString(int c, int l, String s) {
+    putString(c, l, s, NORMAL);
+  }
+
+  /**
+   * Put a String at a specific position giving all characters the same
+   * attributes. Any characters previously on that position will be
+   * overwritten. You need to call redraw() to update the screen.
+   * @param c x-coordinate (column)
+   * @param l y-coordinate (line)
+   * @param s the string to be shown on the screen
+   * @param attributes character attributes
+   * @see #BOLD
+   * @see #UNDERLINE
+   * @see #INVERT
+   * @see #INVISIBLE
+   * @see #NORMAL
+   * @see #LOW
+   * @see #putChar
+   * @see #insertLine
+   * @see #deleteLine
+   * @see #redraw
+   */
+  public void putString(int c, int l, String s, int attributes) {
+    for (int i = 0; i < s.length() && c + i < width; i++)
+      putChar(c + i, l, s.charAt(i), attributes);
+  }
+
+  /**
+   * Insert a blank line at a specific position.
+   * The current line and all previous lines are scrolled one line up. The
+   * top line is lost. You need to call redraw() to update the screen.
+   * @param l the y-coordinate to insert the line
+   * @see #deleteLine
+   * @see #redraw
+   */
+  public void insertLine(int l) {
+    insertLine(l, 1, SCROLL_UP);
+  }
+
+  /**
+   * Insert blank lines at a specific position.
+   * You need to call redraw() to update the screen
+   * @param l the y-coordinate to insert the line
+   * @param n amount of lines to be inserted
+   * @see #deleteLine
+   * @see #redraw
+   */
+  public void insertLine(int l, int n) {
+    insertLine(l, n, SCROLL_UP);
+  }
+
+  /**
+   * Insert a blank line at a specific position. Scroll text according to
+   * the argument.
+   * You need to call redraw() to update the screen
+   * @param l the y-coordinate to insert the line
+   * @param scrollDown scroll down
+   * @see #deleteLine
+   * @see #SCROLL_UP
+   * @see #SCROLL_DOWN
+   * @see #redraw
+   */
+  public void insertLine(int l, boolean scrollDown) {
+    insertLine(l, 1, scrollDown);
+  }
+
+  /**
+   * Insert blank lines at a specific position.
+   * The current line and all previous lines are scrolled one line up. The
+   * top line is lost. You need to call redraw() to update the screen.
+   * @param l the y-coordinate to insert the line
+   * @param n number of lines to be inserted
+   * @param scrollDown scroll down
+   * @see #deleteLine
+   * @see #SCROLL_UP
+   * @see #SCROLL_DOWN
+   * @see #redraw
+   */
+  public synchronized void insertLine(int l, int n, boolean scrollDown) {
+    l = checkBounds(l, 0, height - 1);
+
+    char cbuf[][] = null;
+    int abuf[][] = null;
+    int offset = 0;
+    int oldBase = screenBase;
+
+    if (l > bottomMargin) /* We do not scroll below bottom margin (below the scrolling region). */
+      return;
+    int top = (l < topMargin ?
+            0 : (l > bottomMargin ?
+            (bottomMargin + 1 < height ?
+            bottomMargin + 1 : height - 1) : topMargin));
+    int bottom = (l > bottomMargin ?
+            height - 1 : (l < topMargin ?
+            (topMargin > 0 ?
+            topMargin - 1 : 0) : bottomMargin));
+
+    // System.out.println("l is "+l+", top is "+top+", bottom is "+bottom+", bottomargin is "+bottomMargin+", topMargin is "+topMargin);
+
+    if (scrollDown) {
+      if (n > (bottom - top)) n = (bottom - top);
+      cbuf = new char[bottom - l - (n - 1)][width];
+      abuf = new int[bottom - l - (n - 1)][width];
+
+      System.arraycopy(charArray, oldBase + l, cbuf, 0, bottom - l - (n - 1));
+      System.arraycopy(charAttributes, oldBase + l,
+                       abuf, 0, bottom - l - (n - 1));
+      System.arraycopy(cbuf, 0, charArray, oldBase + l + n,
+                       bottom - l - (n - 1));
+      System.arraycopy(abuf, 0, charAttributes, oldBase + l + n,
+                       bottom - l - (n - 1));
+      cbuf = charArray;
+      abuf = charAttributes;
+    } else {
+      try {
+        if (n > (bottom - top) + 1) n = (bottom - top) + 1;
+        if (bufSize < maxBufSize) {
+          if (bufSize + n > maxBufSize) {
+            offset = n - (maxBufSize - bufSize);
+            scrollMarker += offset;
+            bufSize = maxBufSize;
+            screenBase = maxBufSize - height - 1;
+            windowBase = screenBase;
+          } else {
+            scrollMarker += n;
+            screenBase += n;
+            windowBase += n;
+            bufSize += n;
+          }
+
+          cbuf = new char[bufSize][width];
+          abuf = new int[bufSize][width];
+        } else {
+          offset = n;
+          cbuf = charArray;
+          abuf = charAttributes;
+        }
+        // copy anything from the top of the buffer (+offset) to the new top
+        // up to the screenBase.
+        if (oldBase > 0) {
+          System.arraycopy(charArray, offset,
+                           cbuf, 0,
+                           oldBase - offset);
+          System.arraycopy(charAttributes, offset,
+                           abuf, 0,
+                           oldBase - offset);
+        }
+        // copy anything from the top of the screen (screenBase) up to the
+        // topMargin to the new screen
+        if (top > 0) {
+          System.arraycopy(charArray, oldBase,
+                           cbuf, screenBase,
+                           top);
+          System.arraycopy(charAttributes, oldBase,
+                           abuf, screenBase,
+                           top);
+        }
+        // copy anything from the topMargin up to the amount of lines inserted
+        // to the gap left over between scrollback buffer and screenBase
+        if (oldBase > 0) {
+          System.arraycopy(charArray, oldBase + top,
+                           cbuf, oldBase - offset,
+                           n);
+          System.arraycopy(charAttributes, oldBase + top,
+                           abuf, oldBase - offset,
+                           n);
+        }
+        // copy anything from topMargin + n up to the line linserted to the
+        // topMargin
+        System.arraycopy(charArray, oldBase + top + n,
+                         cbuf, screenBase + top,
+                         l - top - (n - 1));
+        System.arraycopy(charAttributes, oldBase + top + n,
+                         abuf, screenBase + top,
+                         l - top - (n - 1));
+        //
+        // copy the all lines next to the inserted to the new buffer
+        if (l < height - 1) {
+          System.arraycopy(charArray, oldBase + l + 1,
+                           cbuf, screenBase + l + 1,
+                           (height - 1) - l);
+          System.arraycopy(charAttributes, oldBase + l + 1,
+                           abuf, screenBase + l + 1,
+                           (height - 1) - l);
+        }
+      } catch (ArrayIndexOutOfBoundsException e) {
+        // this should not happen anymore, but I will leave the code
+        // here in case something happens anyway. That code above is
+        // so complex I always have a hard time understanding what
+        // I did, even though there are comments
+        System.err.println("*** Error while scrolling up:");
+        System.err.println("--- BEGIN STACK TRACE ---");
+        e.printStackTrace();
+        System.err.println("--- END STACK TRACE ---");
+        System.err.println("bufSize=" + bufSize + ", maxBufSize=" + maxBufSize);
+        System.err.println("top=" + top + ", bottom=" + bottom);
+        System.err.println("n=" + n + ", l=" + l);
+        System.err.println("screenBase=" + screenBase + ", windowBase=" + windowBase);
+        System.err.println("oldBase=" + oldBase);
+        System.err.println("size.width=" + width + ", size.height=" + height);
+        System.err.println("abuf.length=" + abuf.length + ", cbuf.length=" + cbuf.length);
+        System.err.println("*** done dumping debug information");
+      }
+    }
+
+    // this is a little helper to mark the scrolling
+    scrollMarker -= n;
+
+
+    for (int i = 0; i < n; i++) {
+      cbuf[(screenBase + l) + (scrollDown ? i : -i)] = new char[width];
+      abuf[(screenBase + l) + (scrollDown ? i : -i)] = new int[width];
+    }
+
+    charArray = cbuf;
+    charAttributes = abuf;
+
+    if (scrollDown)
+      markLine(l, bottom - l + 1);
+    else
+      markLine(top, l - top + 1);
+
+    display.updateScrollBar();
+  }
+
+  /**
+   * Delete a line at a specific position. Subsequent lines will be scrolled
+   * up to fill the space and a blank line is inserted at the end of the
+   * screen.
+   * @param l the y-coordinate to insert the line
+   * @see #deleteLine
+   */
+  public void deleteLine(int l) {
+    l = checkBounds(l, 0, height - 1);
+
+    int bottom = (l > bottomMargin ? height - 1:
+            (l < topMargin?topMargin:bottomMargin + 1));
+    System.arraycopy(charArray, screenBase + l + 1,
+                     charArray, screenBase + l, bottom - l - 1);
+    System.arraycopy(charAttributes, screenBase + l + 1,
+                     charAttributes, screenBase + l, bottom - l - 1);
+    charArray[screenBase + bottom - 1] = new char[width];
+    charAttributes[screenBase + bottom - 1] = new int[width];
+    markLine(l, bottom - l);
+  }
+
+  /**
+   * Delete a rectangular portion of the screen.
+   * You need to call redraw() to update the screen.
+   * @param c x-coordinate (column)
+   * @param l y-coordinate (row)
+   * @param w with of the area in characters
+   * @param h height of the area in characters
+   * @param curAttr attribute to fill
+   * @see #deleteChar
+   * @see #deleteLine
+   * @see #redraw
+   */
+  public void deleteArea(int c, int l, int w, int h, int curAttr) {
+    c = checkBounds(c, 0, width - 1);
+    l = checkBounds(l, 0, height - 1);
+
+    char cbuf[] = new char[w];
+    int abuf[] = new int[w];
+
+    for (int i = 0; i < w; i++) abuf[i] = curAttr;
+    for (int i = 0; i < h && l + i < height; i++) {
+      System.arraycopy(cbuf, 0, charArray[screenBase + l + i], c, w);
+      System.arraycopy(abuf, 0, charAttributes[screenBase + l + i], c, w);
+    }
+    markLine(l, h);
+  }
+
+  /**
+   * Delete a rectangular portion of the screen.
+   * You need to call redraw() to update the screen.
+   * @param c x-coordinate (column)
+   * @param l y-coordinate (row)
+   * @param w with of the area in characters
+   * @param h height of the area in characters
+   * @see #deleteChar
+   * @see #deleteLine
+   * @see #redraw
+   */
+  public void deleteArea(int c, int l, int w, int h) {
+    c = checkBounds(c, 0, width - 1);
+    l = checkBounds(l, 0, height - 1);
+
+    char cbuf[] = new char[w];
+    int abuf[] = new int[w];
+
+    for (int i = 0; i < h && l + i < height; i++) {
+      System.arraycopy(cbuf, 0, charArray[screenBase + l + i], c, w);
+      System.arraycopy(abuf, 0, charAttributes[screenBase + l + i], c, w);
+    }
+    markLine(l, h);
+  }
+
+  /**
+   * Sets whether the cursor is visible or not.
+   * @param doshow
+   */
+  public void showCursor(boolean doshow) {
+    if (doshow != showcursor)
+      markLine(cursorY, 1);
+    showcursor = doshow;
+  }
+
+  /**
+   * Puts the cursor at the specified position.
+   * @param c column
+   * @param l line
+   */
+  public void setCursorPosition(int c, int l) {
+    cursorX = checkBounds(c, 0, width - 1);
+    cursorY = checkBounds(l, 0, height - 1);
+    markLine(cursorY, 1);
+  }
+
+  /**
+   * Get the current column of the cursor position.
+   */
+  public int getCursorColumn() {
+    return cursorX;
+  }
+
+  /**
+   * Get the current line of the cursor position.
+   */
+  public int getCursorRow() {
+    return cursorY;
+  }
+
+  /**
+   * Set the current window base. This allows to view the scrollback buffer.
+   * @param line the line where the screen window starts
+   * @see #setBufferSize
+   * @see #getBufferSize
+   */
+  public void setWindowBase(int line) {
+    if (line > screenBase)
+      line = screenBase;
+    else if (line < 0) line = 0;
+    windowBase = line;
+    update[0] = true;
+    redraw();
+  }
+
+  /**
+   * Get the current window base.
+   * @see #setWindowBase
+   */
+  public int getWindowBase() {
+    return windowBase;
+  }
+
+  /**
+   * Set the top scroll margin for the screen. If the current bottom margin
+   * is smaller it will become the top margin and the line will become the
+   * bottom margin.
+   * @param l line that is the margin
+   */
+  public void setTopMargin(int l) {
+    if (l > bottomMargin) {
+      topMargin = bottomMargin;
+      bottomMargin = l;
+    } else
+      topMargin = l;
+    if (topMargin < 0) topMargin = 0;
+    if (bottomMargin > height - 1) bottomMargin = height - 1;
+  }
+
+  /**
+   * Get the top scroll margin.
+   */
+  public int getTopMargin() {
+    return topMargin;
+  }
+
+  /**
+   * Set the bottom scroll margin for the screen. If the current top margin
+   * is bigger it will become the bottom margin and the line will become the
+   * top margin.
+   * @param l line that is the margin
+   */
+  public void setBottomMargin(int l) {
+    if (l < topMargin) {
+      bottomMargin = topMargin;
+      topMargin = l;
+    } else
+      bottomMargin = l;
+    if (topMargin < 0) topMargin = 0;
+    if (bottomMargin > height - 1) bottomMargin = height - 1;
+  }
+
+  /**
+   * Get the bottom scroll margin.
+   */
+  public int getBottomMargin() {
+    return bottomMargin;
+  }
+
+  /**
+   * Set scrollback buffer size.
+   * @param amount new size of the buffer
+   */
+  public void setBufferSize(int amount) {
+    if (amount < height) amount = height;
+    if (amount < maxBufSize) {
+      char cbuf[][] = new char[amount][width];
+      int abuf[][] = new int[amount][width];
+      int copyStart = bufSize - amount < 0 ? 0 : bufSize - amount;
+      int copyCount = bufSize - amount < 0 ? bufSize : amount;
+      if (charArray != null)
+        System.arraycopy(charArray, copyStart, cbuf, 0, copyCount);
+      if (charAttributes != null)
+        System.arraycopy(charAttributes, copyStart, abuf, 0, copyCount);
+      charArray = cbuf;
+      charAttributes = abuf;
+      bufSize = copyCount;
+      screenBase = bufSize - height;
+      windowBase = screenBase;
+    }
+    maxBufSize = amount;
+
+    update[0] = true;
+    redraw();
+  }
+
+  /**
+   * Retrieve current scrollback buffer size.
+   * @see #setBufferSize
+   */
+  public int getBufferSize() {
+    return bufSize;
+  }
+
+  /**
+   * Retrieve maximum buffer Size.
+   * @see #getBufferSize
+   */
+  public int getMaxBufferSize() {
+    return maxBufSize;
+  }
+
+  /**
+   * Change the size of the screen. This will include adjustment of the
+   * scrollback buffer.
+   * @param w of the screen
+   * @param h of the screen
+   */
+  public void setScreenSize(int w, int h, boolean broadcast) {
+    char cbuf[][];
+    int abuf[][];
+    int bsize = bufSize;
+
+    if (w < 1 || h < 1) return;
+
+    if (debug > 0)
+      System.err.println("VDU: screen size [" + w + "," + h + "]");
+
+    if (h > maxBufSize)
+      maxBufSize = h;
+
+    if (h > bufSize) {
+      bufSize = h;
+      screenBase = 0;
+      windowBase = 0;
+    }
+
+    if (windowBase + h >= bufSize)
+      windowBase = bufSize - h;
+
+    if (screenBase + h >= bufSize)
+      screenBase = bufSize - h;
+
+
+    cbuf = new char[bufSize][w];
+    abuf = new int[bufSize][w];
+
+    if (charArray != null && charAttributes != null) {
+      for (int i = 0; i < bsize && i < bufSize; i++) {
+        System.arraycopy(charArray[i], 0, cbuf[i], 0,
+                         w < width ? w : width);
+        System.arraycopy(charAttributes[i], 0, abuf[i], 0,
+                         w < width ? w : width);
+      }
+    }
+
+    charArray = cbuf;
+    charAttributes = abuf;
+    width = w;
+    height = h;
+    topMargin = 0;
+    bottomMargin = h - 1;
+    update = new boolean[h + 1];
+    update[0] = true;
+    /*  FIXME: ???
+    if(resizeStrategy == RESIZE_FONT)
+      setBounds(getBounds());
+    */
+  }
+
+  /**
+   * Get amount of rows on the screen.
+   */
+  public int getRows() {
+    return height;
+  }
+
+  /**
+   * Get amount of columns on the screen.
+   */
+  public int getColumns() {
+    return width;
+  }
+
+  /**
+   * Mark lines to be updated with redraw().
+   * @param l starting line
+   * @param n amount of lines to be updated
+   * @see #redraw
+   */
+  public void markLine(int l, int n) {
+    l = checkBounds(l, 0, height - 1);
+    for (int i = 0; (i < n) && (l + i < height); i++)
+      update[l + i + 1] = true;
+  }
+
+  private int checkBounds(int value, int lower, int upper) {
+    if (value < lower) return lower;
+    if (value > upper) return upper;
+    return value;
+  }
+
+  /** a generic display that should redraw on demand */
+  protected VDUDisplay display;
+
+  public void setDisplay(VDUDisplay display) {
+    this.display = display;
+  }
+
+  /**
+   * Trigger a redraw on the display.
+   */
+  protected void redraw() {
+    if (display != null)
+      display.redraw();
+  }
+}
diff --git a/src/de/mud/terminal/VDUDisplay.java b/src/de/mud/terminal/VDUDisplay.java
new file mode 100644
index 0000000..4323465
--- /dev/null
+++ b/src/de/mud/terminal/VDUDisplay.java
@@ -0,0 +1,37 @@
+/*
+ * This file is part of "JTA - Telnet/SSH for the JAVA(tm) platform".
+ *
+ * (c) Matthias L. Jugel, Marcus Meißner 1996-2005. All Rights Reserved.
+ *
+ * Please visit http://javatelnet.org/ for updates and contact.
+ *
+ * --LICENSE NOTICE--
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * --LICENSE NOTICE--
+ *
+ */
+
+package de.mud.terminal;
+
+/**
+ * Generic display
+ */
+public interface VDUDisplay {
+  public void redraw();
+  public void updateScrollBar();
+
+  public void setVDUBuffer(VDUBuffer buffer);
+  public VDUBuffer getVDUBuffer();
+}
diff --git a/src/de/mud/terminal/VDUInput.java b/src/de/mud/terminal/VDUInput.java
new file mode 100644
index 0000000..79a8bb7
--- /dev/null
+++ b/src/de/mud/terminal/VDUInput.java
@@ -0,0 +1,89 @@
+/*
+ * This file is part of "JTA - Telnet/SSH for the JAVA(tm) platform".
+ *
+ * (c) Matthias L. Jugel, Marcus Meißner 1996-2005. All Rights Reserved.
+ *
+ * Please visit http://javatelnet.org/ for updates and contact.
+ *
+ * --LICENSE NOTICE--
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * --LICENSE NOTICE--
+ *
+ */
+package de.mud.terminal;
+
+import java.util.Properties;
+
+/**
+ * An interface for a terminal that accepts input from keyboard and mouse.
+ *
+ * @author Matthias L. Jugel, Marcus Mei�ner
+ * @version $Id: VDUInput.java 499 2005-09-29 08:24:54Z leo $
+ */
+public interface VDUInput {
+
+  public final static int KEY_CONTROL = 0x01;
+  public final static int KEY_SHIFT = 0x02;
+  public final static int KEY_ALT = 0x04;
+  public final static int KEY_ACTION = 0x08;
+
+
+  /**
+   * Direct access to writing data ...
+   * @param b
+   */
+  void write(byte b[]);
+
+  /**
+   * Terminal is mouse-aware and requires (x,y) coordinates of
+   * on the terminal (character coordinates) and the button clicked.
+   * @param x
+   * @param y
+   * @param modifiers
+   */
+  void mousePressed(int x, int y, int modifiers);
+
+  /**
+   * Terminal is mouse-aware and requires the coordinates and button
+   * of the release.
+   * @param x
+   * @param y
+   * @param modifiers
+   */
+  void mouseReleased(int x, int y, int modifiers);
+
+  /**
+   * Override the standard key codes used by the terminal emulation.
+   * @param codes a properties object containing key code definitions
+   */
+  void setKeyCodes(Properties codes);
+
+  /**
+   * main keytyping event handler...
+   * @param keyCode the key code
+   * @param keyChar the character represented by the key
+   * @param modifiers shift/alt/control modifiers
+   */
+  void keyPressed(int keyCode, char keyChar, int modifiers);
+
+  /**
+   * Handle key Typed events for the terminal, this will get
+   * all normal key types, but no shift/alt/control/numlock.
+   * @param keyCode the key code
+   * @param keyChar the character represented by the key
+   * @param modifiers shift/alt/control modifiers
+   */
+  void keyTyped(int keyCode, char keyChar, int modifiers);
+}
diff --git a/src/de/mud/terminal/vt320.java b/src/de/mud/terminal/vt320.java
new file mode 100644
index 0000000..099c877
--- /dev/null
+++ b/src/de/mud/terminal/vt320.java
@@ -0,0 +1,2722 @@
+/*
+ * This file is part of "JTA - Telnet/SSH for the JAVA(tm) platform".
+ *
+ * (c) Matthias L. Jugel, Marcus Meißner 1996-2005. All Rights Reserved.
+ *
+ * Please visit http://javatelnet.org/ for updates and contact.
+ *
+ * --LICENSE NOTICE--
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * --LICENSE NOTICE--
+ *
+ */
+
+package de.mud.terminal;
+
+import java.util.Properties;
+
+/**
+ * Implementation of a VT terminal emulation plus ANSI compatible.
+ * <P>
+ * <B>Maintainer:</B> Marcus Mei\u00dfner
+ *
+ * @version $Id: vt320.java 507 2005-10-25 10:14:52Z marcus $
+ * @author  Matthias L. Jugel, Marcus Mei\u00dfner
+ */
+public abstract class vt320 extends VDUBuffer implements VDUInput {
+  /** The current version id tag.<P>
+   * $Id: vt320.java 507 2005-10-25 10:14:52Z marcus $
+   */
+  public final static String ID = "$Id: vt320.java 507 2005-10-25 10:14:52Z marcus $";
+
+  /** the debug level */
+  private final static int debug = 0;
+
+  /**
+   * Write an answer back to the remote host. This is needed to be able to
+   * send terminal answers requests like status and type information.
+   * @param b the array of bytes to be sent
+   */
+  public abstract void write(byte[] b);
+
+  /**
+   * Play the beep sound ...
+   */
+  public void beep() { /* do nothing by default */
+  }
+
+  /**
+   * Put string at current cursor position. Moves cursor
+   * according to the String. Does NOT wrap.
+   * @param s the string
+   */
+  public void putString(String s) {
+    int len = s.length();
+    // System.err.println("'"+s+"'");
+
+    if (len > 0) {
+      markLine(R, 1);
+      for (int i = 0; i < len; i++) {
+        // System.err.print(s.charAt(i)+"("+(int)s.charAt(i)+")");
+        putChar(s.charAt(i), false);
+      }
+      setCursorPosition(C, R);
+      redraw();
+    }
+  }
+
+  protected void sendTelnetCommand(byte cmd) {
+  }
+
+  /** 
+   * Sent the changed window size from the terminal to all listeners.
+   */
+  protected void setWindowSize(int c, int r) {
+    /* To be overridden by Terminal.java */
+  }
+
+  public void setScreenSize(int c, int r, boolean broadcast) {
+    int oldrows = getRows();
+    //int oldcols = getColumns();
+
+    if (debug>2) System.err.println("setscreensize ("+c+","+r+","+broadcast+")");
+
+    super.setScreenSize(c,r,false);
+
+    /* Tricky, since the VDUBuffer works strangely. */
+    if (r > oldrows) {
+      setCursorPosition(C, R + (r-oldrows)); 
+      redraw();
+    }
+    if (broadcast) {
+      setWindowSize(c, r); /* broadcast up */
+    }
+  }
+
+
+  /**
+   * Create a new vt320 terminal and intialize it with useful settings.
+   */
+  public vt320(int width, int height) {
+    super(width, height);
+    setVMS(false);
+    setIBMCharset(false);
+    setTerminalID("vt320");
+    setBufferSize(100);
+    //setBorder(2, false);
+
+    int nw = getColumns();
+    if (nw < 132) nw = 132; //catch possible later 132/80 resizes
+    Tabs = new byte[nw];
+    for (int i = 0; i < nw; i += 8) {
+      Tabs[i] = 1;
+    }
+
+    /* top row of numpad */
+    PF1 = "\u001bOP";
+    PF2 = "\u001bOQ";
+    PF3 = "\u001bOR";
+    PF4 = "\u001bOS";
+
+    /* the 3x2 keyblock on PC keyboards */
+    Insert = new String[4];
+    Remove = new String[4];
+    KeyHome = new String[4];
+    KeyEnd = new String[4];
+    NextScn = new String[4];
+    PrevScn = new String[4];
+    Escape = new String[4];
+    BackSpace = new String[4];
+    TabKey = new String[4];
+    Insert[0] = Insert[1] = Insert[2] = Insert[3] = "\u001b[2~";
+    Remove[0] = Remove[1] = Remove[2] = Remove[3] = "\u001b[3~";
+    PrevScn[0] = PrevScn[1] = PrevScn[2] = PrevScn[3] = "\u001b[5~";
+    NextScn[0] = NextScn[1] = NextScn[2] = NextScn[3] = "\u001b[6~";
+    KeyHome[0] = KeyHome[1] = KeyHome[2] = KeyHome[3] = "\u001b[H";
+    KeyEnd[0] = KeyEnd[1] = KeyEnd[2] = KeyEnd[3] = "\u001b[F";
+    Escape[0] = Escape[1] = Escape[2] = Escape[3] = "\u001b";
+    if (vms) {
+      BackSpace[1] = "" + (char) 10;	//  VMS shift deletes word back
+      BackSpace[2] = "\u0018";	//  VMS control deletes line back
+      BackSpace[0] = BackSpace[3] = "\u007f";	//  VMS other is delete
+    } else {
+      BackSpace[0] = BackSpace[1] = BackSpace[2] = BackSpace[3] = "\b";
+    }
+
+    /* some more VT100 keys */
+    Find = "\u001b[1~";
+    Select = "\u001b[4~";
+    Help = "\u001b[28~";
+    Do = "\u001b[29~";
+
+    FunctionKey = new String[21];
+    FunctionKey[0] = "";
+    FunctionKey[1] = PF1;
+    FunctionKey[2] = PF2;
+    FunctionKey[3] = PF3;
+    FunctionKey[4] = PF4;
+    /* following are defined differently for vt220 / vt132 ... */
+    FunctionKey[5] = "\u001b[15~";
+    FunctionKey[6] = "\u001b[17~";
+    FunctionKey[7] = "\u001b[18~";
+    FunctionKey[8] = "\u001b[19~";
+    FunctionKey[9] = "\u001b[20~";
+    FunctionKey[10] = "\u001b[21~";
+    FunctionKey[11] = "\u001b[23~";
+    FunctionKey[12] = "\u001b[24~";
+    FunctionKey[13] = "\u001b[25~";
+    FunctionKey[14] = "\u001b[26~";
+    FunctionKey[15] = Help;
+    FunctionKey[16] = Do;
+    FunctionKey[17] = "\u001b[31~";
+    FunctionKey[18] = "\u001b[32~";
+    FunctionKey[19] = "\u001b[33~";
+    FunctionKey[20] = "\u001b[34~";
+
+    FunctionKeyShift = new String[21];
+    FunctionKeyAlt = new String[21];
+    FunctionKeyCtrl = new String[21];
+
+    for (int i = 0; i < 20; i++) {
+      FunctionKeyShift[i] = "";
+      FunctionKeyAlt[i] = "";
+      FunctionKeyCtrl[i] = "";
+    }
+    FunctionKeyShift[15] = Find;
+    FunctionKeyShift[16] = Select;
+
+
+    TabKey[0] = "\u0009";
+    TabKey[1] = "\u001bOP\u0009";
+    TabKey[2] = TabKey[3] = "";
+
+    KeyUp = new String[4];
+    KeyUp[0] = "\u001b[A";
+    KeyDown = new String[4];
+    KeyDown[0] = "\u001b[B";
+    KeyRight = new String[4];
+    KeyRight[0] = "\u001b[C";
+    KeyLeft = new String[4];
+    KeyLeft[0] = "\u001b[D";
+    Numpad = new String[10];
+    Numpad[0] = "\u001bOp";
+    Numpad[1] = "\u001bOq";
+    Numpad[2] = "\u001bOr";
+    Numpad[3] = "\u001bOs";
+    Numpad[4] = "\u001bOt";
+    Numpad[5] = "\u001bOu";
+    Numpad[6] = "\u001bOv";
+    Numpad[7] = "\u001bOw";
+    Numpad[8] = "\u001bOx";
+    Numpad[9] = "\u001bOy";
+    KPMinus = PF4;
+    KPComma = "\u001bOl";
+    KPPeriod = "\u001bOn";
+    KPEnter = "\u001bOM";
+
+    NUMPlus = new String[4];
+    NUMPlus[0] = "+";
+    NUMDot = new String[4];
+    NUMDot[0] = ".";
+  }
+
+  /**
+   * Create a default vt320 terminal with 80 columns and 24 lines.
+   */
+  public vt320() {
+    this(80, 24);
+  }
+
+  /**
+   * Terminal is mouse-aware and requires (x,y) coordinates of
+   * on the terminal (character coordinates) and the button clicked.
+   * @param x
+   * @param y
+   * @param modifiers
+   */
+  public void mousePressed(int x, int y, int modifiers) {
+    if (mouserpt == 0)
+      return;
+
+    int mods = modifiers;
+    mousebut = 3;
+    if ((mods & 16) == 16) mousebut = 0;
+    if ((mods & 8) == 8) mousebut = 1;
+    if ((mods & 4) == 4) mousebut = 2;
+
+    int mousecode;
+    if (mouserpt == 9)	/* X10 Mouse */
+      mousecode = 0x20 | mousebut;
+    else			/* normal xterm mouse reporting */
+      mousecode = mousebut | 0x20 | ((mods & 7) << 2);
+
+    byte b[] = new byte[6];
+
+    b[0] = 27;
+    b[1] = (byte) '[';
+    b[2] = (byte) 'M';
+    b[3] = (byte) mousecode;
+    b[4] = (byte) (0x20 + x + 1);
+    b[5] = (byte) (0x20 + y + 1);
+
+    write(b); // FIXME: writeSpecial here
+  }
+
+  /**
+   * Terminal is mouse-aware and requires the coordinates and button
+   * of the release.
+   * @param x
+   * @param y
+   * @param modifiers
+   */
+  public void mouseReleased(int x, int y, int modifiers) {
+    if (mouserpt == 0)
+      return;
+
+    /* problem is tht modifiers still have the released button set in them.
+    int mods = modifiers;
+    mousebut = 3;
+    if ((mods & 16)==16) mousebut=0;
+    if ((mods &  8)==8 ) mousebut=1;
+    if ((mods &  4)==4 ) mousebut=2;
+    */
+
+    int mousecode;
+    if (mouserpt == 9)
+      mousecode = 0x20 + mousebut;	/* same as press? appears so. */
+    else
+      mousecode = '#';
+
+    byte b[] = new byte[6];
+    b[0] = 27;
+    b[1] = (byte) '[';
+    b[2] = (byte) 'M';
+    b[3] = (byte) mousecode;
+    b[4] = (byte) (0x20 + x + 1);
+    b[5] = (byte) (0x20 + y + 1);
+    write(b); // FIXME: writeSpecial here
+    mousebut = 0;
+  }
+
+
+  /** we should do localecho (passed from other modules). false is default */
+  private boolean localecho = false;
+
+  /**
+   * Enable or disable the local echo property of the terminal.
+   * @param echo true if the terminal should echo locally
+   */
+  public void setLocalEcho(boolean echo) {
+    localecho = echo;
+  }
+
+  /**
+   * Enable the VMS mode of the terminal to handle some things differently
+   * for VMS hosts.
+   * @param vms true for vms mode, false for normal mode
+   */
+  public void setVMS(boolean vms) {
+    this.vms = vms;
+  }
+
+  /**
+   * Enable the usage of the IBM character set used by some BBS's. Special
+   * graphical character are available in this mode.
+   * @param ibm true to use the ibm character set
+   */
+  public void setIBMCharset(boolean ibm) {
+    useibmcharset = ibm;
+  }
+
+  /**
+   * Override the standard key codes used by the terminal emulation.
+   * @param codes a properties object containing key code definitions
+   */
+  public void setKeyCodes(Properties codes) {
+    String res, prefixes[] = {"", "S", "C", "A"};
+    int i;
+
+    for (i = 0; i < 10; i++) {
+      res = codes.getProperty("NUMPAD" + i);
+      if (res != null) Numpad[i] = unEscape(res);
+    }
+    for (i = 1; i < 20; i++) {
+      res = codes.getProperty("F" + i);
+      if (res != null) FunctionKey[i] = unEscape(res);
+      res = codes.getProperty("SF" + i);
+      if (res != null) FunctionKeyShift[i] = unEscape(res);
+      res = codes.getProperty("CF" + i);
+      if (res != null) FunctionKeyCtrl[i] = unEscape(res);
+      res = codes.getProperty("AF" + i);
+      if (res != null) FunctionKeyAlt[i] = unEscape(res);
+    }
+    for (i = 0; i < 4; i++) {
+      res = codes.getProperty(prefixes[i] + "PGUP");
+      if (res != null) PrevScn[i] = unEscape(res);
+      res = codes.getProperty(prefixes[i] + "PGDOWN");
+      if (res != null) NextScn[i] = unEscape(res);
+      res = codes.getProperty(prefixes[i] + "END");
+      if (res != null) KeyEnd[i] = unEscape(res);
+      res = codes.getProperty(prefixes[i] + "HOME");
+      if (res != null) KeyHome[i] = unEscape(res);
+      res = codes.getProperty(prefixes[i] + "INSERT");
+      if (res != null) Insert[i] = unEscape(res);
+      res = codes.getProperty(prefixes[i] + "REMOVE");
+      if (res != null) Remove[i] = unEscape(res);
+      res = codes.getProperty(prefixes[i] + "UP");
+      if (res != null) KeyUp[i] = unEscape(res);
+      res = codes.getProperty(prefixes[i] + "DOWN");
+      if (res != null) KeyDown[i] = unEscape(res);
+      res = codes.getProperty(prefixes[i] + "LEFT");
+      if (res != null) KeyLeft[i] = unEscape(res);
+      res = codes.getProperty(prefixes[i] + "RIGHT");
+      if (res != null) KeyRight[i] = unEscape(res);
+      res = codes.getProperty(prefixes[i] + "ESCAPE");
+      if (res != null) Escape[i] = unEscape(res);
+      res = codes.getProperty(prefixes[i] + "BACKSPACE");
+      if (res != null) BackSpace[i] = unEscape(res);
+      res = codes.getProperty(prefixes[i] + "TAB");
+      if (res != null) TabKey[i] = unEscape(res);
+      res = codes.getProperty(prefixes[i] + "NUMPLUS");
+      if (res != null) NUMPlus[i] = unEscape(res);
+      res = codes.getProperty(prefixes[i] + "NUMDECIMAL");
+      if (res != null) NUMDot[i] = unEscape(res);
+    }
+  }
+
+  /**
+   * Set the terminal id used to identify this terminal.
+   * @param terminalID the id string
+   */
+  public void setTerminalID(String terminalID) {
+    this.terminalID = terminalID;
+
+    if (terminalID.equals("scoansi")) {
+      FunctionKey[1] = "\u001b[M";  FunctionKey[2] = "\u001b[N";
+      FunctionKey[3] = "\u001b[O";  FunctionKey[4] = "\u001b[P";
+      FunctionKey[5] = "\u001b[Q";  FunctionKey[6] = "\u001b[R";
+      FunctionKey[7] = "\u001b[S";  FunctionKey[8] = "\u001b[T";
+      FunctionKey[9] = "\u001b[U";  FunctionKey[10] = "\u001b[V";
+      FunctionKey[11] = "\u001b[W"; FunctionKey[12] = "\u001b[X";
+      FunctionKey[13] = "\u001b[Y"; FunctionKey[14] = "?";
+      FunctionKey[15] = "\u001b[a"; FunctionKey[16] = "\u001b[b";
+      FunctionKey[17] = "\u001b[c"; FunctionKey[18] = "\u001b[d";
+      FunctionKey[19] = "\u001b[e"; FunctionKey[20] = "\u001b[f";
+      PrevScn[0] = PrevScn[1] = PrevScn[2] = PrevScn[3] = "\u001b[I";
+      NextScn[0] = NextScn[1] = NextScn[2] = NextScn[3] = "\u001b[G";
+      // more theoretically.
+    }
+  }
+
+  public void setAnswerBack(String ab) {
+    this.answerBack = unEscape(ab);
+  }
+
+  /**
+   * Get the terminal id used to identify this terminal.
+   */
+  public String getTerminalID() {
+    return terminalID;
+  }
+
+  /**
+   * A small conveniance method thar converts the string to a byte array
+   * for sending.
+   * @param s the string to be sent
+   */
+  private boolean write(String s, boolean doecho) {
+    if (debug > 2) System.out.println("write(|" + s + "|," + doecho);
+    if (s == null) // aka the empty string.
+      return true;
+    /* NOTE: getBytes() honours some locale, it *CONVERTS* the string.
+     * However, we output only 7bit stuff towards the target, and *some*
+     * 8 bit control codes. We must not mess up the latter, so we do hand
+     * by hand copy.
+     */
+
+    byte arr[] = new byte[s.length()];
+    for (int i = 0; i < s.length(); i++) {
+      arr[i] = (byte) s.charAt(i);
+    }
+    write(arr);
+
+    if (doecho)
+      putString(s);
+    return true;
+  }
+
+  private boolean write(String s) {
+    return write(s, localecho);
+  }
+
+  // ===================================================================
+  // the actual terminal emulation code comes here:
+  // ===================================================================
+
+  private String terminalID = "vt320";
+  private String answerBack = "Use Terminal.answerback to set ...\n";
+
+  // X - COLUMNS, Y - ROWS
+  int R,C;
+  int attributes = 0;
+
+  int Sc,Sr,Sa,Stm,Sbm;
+  char Sgr,Sgl;
+  char Sgx[];
+
+  int insertmode = 0;
+  int statusmode = 0;
+  boolean vt52mode = false;
+  boolean keypadmode = false; /* false - numeric, true - application */
+  boolean output8bit = false;
+  int normalcursor = 0;
+  boolean moveoutsidemargins = true;
+  boolean wraparound = true;
+  boolean sendcrlf = true;
+  boolean capslock = false;
+  boolean numlock = false;
+  int mouserpt = 0;
+  byte mousebut = 0;
+
+  boolean useibmcharset = false;
+
+  int lastwaslf = 0;
+  boolean usedcharsets = false;
+
+  private final static char ESC = 27;
+  private final static char IND = 132;
+  private final static char NEL = 133;
+  private final static char RI = 141;
+  private final static char SS2 = 142;
+  private final static char SS3 = 143;
+  private final static char DCS = 144;
+  private final static char HTS = 136;
+  private final static char CSI = 155;
+  private final static char OSC = 157;
+  private final static int TSTATE_DATA = 0;
+  private final static int TSTATE_ESC = 1; /* ESC */
+  private final static int TSTATE_CSI = 2; /* ESC [ */
+  private final static int TSTATE_DCS = 3; /* ESC P */
+  private final static int TSTATE_DCEQ = 4; /* ESC [? */
+  private final static int TSTATE_ESCSQUARE = 5; /* ESC # */
+  private final static int TSTATE_OSC = 6;       /* ESC ] */
+  private final static int TSTATE_SETG0 = 7;     /* ESC (? */
+  private final static int TSTATE_SETG1 = 8;     /* ESC )? */
+  private final static int TSTATE_SETG2 = 9;     /* ESC *? */
+  private final static int TSTATE_SETG3 = 10;    /* ESC +? */
+  private final static int TSTATE_CSI_DOLLAR = 11; /* ESC [ Pn $ */
+  private final static int TSTATE_CSI_EX = 12; /* ESC [ ! */
+  private final static int TSTATE_ESCSPACE = 13; /* ESC <space> */
+  private final static int TSTATE_VT52X = 14;
+  private final static int TSTATE_VT52Y = 15;
+  private final static int TSTATE_CSI_TICKS = 16;
+  private final static int TSTATE_CSI_EQUAL = 17; /* ESC [ = */
+
+  /* Keys we support */
+  public final static int KEY_PAUSE = 1;
+  public final static int KEY_F1 = 2;
+  public final static int KEY_F2 = 3;
+  public final static int KEY_F3 = 4;
+  public final static int KEY_F4 = 5;
+  public final static int KEY_F5 = 6;
+  public final static int KEY_F6 = 7;
+  public final static int KEY_F7 = 8;
+  public final static int KEY_F8 = 9;
+  public final static int KEY_F9 = 10;
+  public final static int KEY_F10 = 11;
+  public final static int KEY_F11 = 12;
+  public final static int KEY_F12 = 13;
+  public final static int KEY_UP = 14;
+  public final static int KEY_DOWN =15 ;
+  public final static int KEY_LEFT = 16;
+  public final static int KEY_RIGHT = 17;
+  public final static int KEY_PAGE_DOWN = 18;
+  public final static int KEY_PAGE_UP = 19;
+  public final static int KEY_INSERT = 20;
+  public final static int KEY_DELETE = 21;
+  public final static int KEY_BACK_SPACE = 22;
+  public final static int KEY_HOME = 23;
+  public final static int KEY_END = 24;
+  public final static int KEY_NUM_LOCK = 25;
+  public final static int KEY_CAPS_LOCK = 26;
+  public final static int KEY_SHIFT = 27;
+  public final static int KEY_CONTROL = 28;
+  public final static int KEY_ALT = 29;
+  public final static int KEY_ENTER = 30;
+  public final static int KEY_NUMPAD0 = 31;
+  public final static int KEY_NUMPAD1 = 32;
+  public final static int KEY_NUMPAD2 = 33;
+  public final static int KEY_NUMPAD3 = 34;
+  public final static int KEY_NUMPAD4 = 35;
+  public final static int KEY_NUMPAD5 = 36;
+  public final static int KEY_NUMPAD6 = 37;
+  public final static int KEY_NUMPAD7 = 38;
+  public final static int KEY_NUMPAD8 = 39;
+  public final static int KEY_NUMPAD9 = 40;
+  public final static int KEY_DECIMAL = 41;
+  public final static int KEY_ADD = 42;
+  public final static int KEY_ESCAPE = 43;
+
+  /* The graphics charsets
+   * B - default ASCII
+   * A - ISO Latin 1
+   * 0 - DEC SPECIAL
+   * < - User defined
+   * ....
+   */
+  char gx[] = {// same initial set as in XTERM.
+    'B', // g0
+    '0', // g1
+    'B', // g2
+    'B', // g3
+  };
+  char gl = 0;		// default GL to G0
+  char gr = 2;		// default GR to G2
+  int onegl = -1;	// single shift override for GL.
+
+  // Map from scoansi linedrawing to DEC _and_ unicode (for the stuff which
+  // is not in linedrawing). Got from experimenting with scoadmin.
+  private final static String scoansi_acs = "Tm7k3x4u?kZl@mYjEnB\u2566DqCtAvM\u2550:\u2551N\u2557I\u2554;\u2557H\u255a0a<\u255d";
+  // array to store DEC Special -> Unicode mapping
+  //  Unicode   DEC  Unicode name    (DEC name)
+  private static char DECSPECIAL[] = {
+    '\u0040', //5f blank
+    '\u2666', //60 black diamond
+    '\u2592', //61 grey square
+    '\u2409', //62 Horizontal tab  (ht) pict. for control
+    '\u240c', //63 Form Feed       (ff) pict. for control
+    '\u240d', //64 Carriage Return (cr) pict. for control
+    '\u240a', //65 Line Feed       (lf) pict. for control
+    '\u00ba', //66 Masculine ordinal indicator
+    '\u00b1', //67 Plus or minus sign
+    '\u2424', //68 New Line        (nl) pict. for control
+    '\u240b', //69 Vertical Tab    (vt) pict. for control
+    '\u2518', //6a Forms light up   and left
+    '\u2510', //6b Forms light down and left
+    '\u250c', //6c Forms light down and right
+    '\u2514', //6d Forms light up   and right
+    '\u253c', //6e Forms light vertical and horizontal
+    '\u2594', //6f Upper 1/8 block                        (Scan 1)
+    '\u2580', //70 Upper 1/2 block                        (Scan 3)
+    '\u2500', //71 Forms light horizontal or ?em dash?    (Scan 5)
+    '\u25ac', //72 \u25ac black rect. or \u2582 lower 1/4 (Scan 7)
+    '\u005f', //73 \u005f underscore  or \u2581 lower 1/8 (Scan 9)
+    '\u251c', //74 Forms light vertical and right
+    '\u2524', //75 Forms light vertical and left
+    '\u2534', //76 Forms light up   and horizontal
+    '\u252c', //77 Forms light down and horizontal
+    '\u2502', //78 vertical bar
+    '\u2264', //79 less than or equal
+    '\u2265', //7a greater than or equal
+    '\u00b6', //7b paragraph
+    '\u2260', //7c not equal
+    '\u00a3', //7d Pound Sign (british)
+    '\u00b7'  //7e Middle Dot
+  };
+
+  /** Strings to send on function key pressing */
+  private String Numpad[];
+  private String FunctionKey[];
+  private String FunctionKeyShift[];
+  private String FunctionKeyCtrl[];
+  private String FunctionKeyAlt[];
+  private String TabKey[];
+  private String KeyUp[],KeyDown[],KeyLeft[],KeyRight[];
+  private String KPMinus, KPComma, KPPeriod, KPEnter;
+  private String PF1, PF2, PF3, PF4;
+  private String Help, Do, Find, Select;
+
+  private String KeyHome[], KeyEnd[], Insert[], Remove[], PrevScn[], NextScn[];
+  private String Escape[], BackSpace[], NUMDot[], NUMPlus[];
+
+  private String osc,dcs;  /* to memorize OSC & DCS control sequence */
+
+  /** vt320 state variable (internal) */
+  private int term_state = TSTATE_DATA;
+  /** in vms mode, set by Terminal.VMS property */
+  private boolean vms = false;
+  /** Tabulators */
+  private byte[] Tabs;
+  /** The list of integers as used by CSI */
+  private int[] DCEvars = new int[30];
+  private int DCEvar;
+
+  /**
+   * Replace escape code characters (backslash + identifier) with their
+   * respective codes.
+   * @param tmp the string to be parsed
+   * @return a unescaped string
+   */
+  static String unEscape(String tmp) {
+    int idx = 0, oldidx = 0;
+    String cmd;
+    // System.err.println("unescape("+tmp+")");
+    cmd = "";
+    while ((idx = tmp.indexOf('\\', oldidx)) >= 0 &&
+            ++idx <= tmp.length()) {
+      cmd += tmp.substring(oldidx, idx - 1);
+      if (idx == tmp.length()) return cmd;
+      switch (tmp.charAt(idx)) {
+        case 'b':
+          cmd += "\b";
+          break;
+        case 'e':
+          cmd += "\u001b";
+          break;
+        case 'n':
+          cmd += "\n";
+          break;
+        case 'r':
+          cmd += "\r";
+          break;
+        case 't':
+          cmd += "\t";
+          break;
+        case 'v':
+          cmd += "\u000b";
+          break;
+        case 'a':
+          cmd += "\u0012";
+          break;
+        default :
+          if ((tmp.charAt(idx) >= '0') && (tmp.charAt(idx) <= '9')) {
+            int i;
+            for (i = idx; i < tmp.length(); i++)
+              if ((tmp.charAt(i) < '0') || (tmp.charAt(i) > '9'))
+                break;
+            cmd += (char) Integer.parseInt(tmp.substring(idx, i));
+            idx = i - 1;
+          } else
+            cmd += tmp.substring(idx, ++idx);
+          break;
+      }
+      oldidx = ++idx;
+    }
+    if (oldidx <= tmp.length()) cmd += tmp.substring(oldidx);
+    return cmd;
+  }
+
+  /**
+   * A small conveniance method thar converts a 7bit string to the 8bit
+   * version depending on VT52/Output8Bit mode.
+   *
+   * @param s the string to be sent
+   */
+  private boolean writeSpecial(String s) {
+    if (s == null)
+      return true;
+    if (((s.length() >= 3) && (s.charAt(0) == 27) && (s.charAt(1) == 'O'))) {
+      if (vt52mode) {
+        if ((s.charAt(2) >= 'P') && (s.charAt(2) <= 'S')) {
+          s = "\u001b" + s.substring(2); /* ESC x */
+        } else {
+          s = "\u001b?" + s.substring(2); /* ESC ? x */
+        }
+      } else {
+        if (output8bit) {
+          s = "\u008f" + s.substring(2);  /* SS3 x */
+        } /* else keep string as it is */
+      }
+    }
+    if (((s.length() >= 3) && (s.charAt(0) == 27) && (s.charAt(1) == '['))) {
+      if (output8bit) {
+        s = "\u009b" + s.substring(2); /* CSI ... */
+      } /* else keep */
+    }
+    return write(s, false);
+  }
+
+  /**
+   * main keytyping event handler...
+   */
+  public void keyPressed(int keyCode, char keyChar, int modifiers) {
+    boolean control = (modifiers & VDUInput.KEY_CONTROL) != 0;
+    boolean shift = (modifiers & VDUInput.KEY_SHIFT) != 0;
+    boolean alt = (modifiers & VDUInput.KEY_ALT) != 0;
+
+    if (debug > 1) System.out.println("keyPressed("+keyCode+", "+(int)keyChar+", "+modifiers+")");
+
+    int xind;
+    String fmap[];
+    xind = 0;
+    fmap = FunctionKey;
+    if (shift) {
+      fmap = FunctionKeyShift;
+      xind = 1;
+    }
+    if (control) {
+      fmap = FunctionKeyCtrl;
+      xind = 2;
+    }
+    if (alt) {
+      fmap = FunctionKeyAlt;
+      xind = 3;
+    }
+
+    switch (keyCode) {
+      case KEY_PAUSE:
+        if (shift || control)
+          sendTelnetCommand((byte) 243); // BREAK
+        break;
+      case KEY_F1:
+        writeSpecial(fmap[1]);
+        break;
+      case KEY_F2:
+        writeSpecial(fmap[2]);
+        break;
+      case KEY_F3:
+        writeSpecial(fmap[3]);
+        break;
+      case KEY_F4:
+        writeSpecial(fmap[4]);
+        break;
+      case KEY_F5:
+        writeSpecial(fmap[5]);
+        break;
+      case KEY_F6:
+        writeSpecial(fmap[6]);
+        break;
+      case KEY_F7:
+        writeSpecial(fmap[7]);
+        break;
+      case KEY_F8:
+        writeSpecial(fmap[8]);
+        break;
+      case KEY_F9:
+        writeSpecial(fmap[9]);
+        break;
+      case KEY_F10:
+        writeSpecial(fmap[10]);
+        break;
+      case KEY_F11:
+        writeSpecial(fmap[11]);
+        break;
+      case KEY_F12:
+        writeSpecial(fmap[12]);
+        break;
+      case KEY_UP:
+        writeSpecial(KeyUp[xind]);
+        break;
+      case KEY_DOWN:
+        writeSpecial(KeyDown[xind]);
+        break;
+      case KEY_LEFT:
+        writeSpecial(KeyLeft[xind]);
+        break;
+      case KEY_RIGHT:
+        writeSpecial(KeyRight[xind]);
+        break;
+      case KEY_PAGE_DOWN:
+        writeSpecial(NextScn[xind]);
+        break;
+      case KEY_PAGE_UP:
+        writeSpecial(PrevScn[xind]);
+        break;
+      case KEY_INSERT:
+        writeSpecial(Insert[xind]);
+        break;
+      case KEY_DELETE:
+        writeSpecial(Remove[xind]);
+        break;
+      case KEY_BACK_SPACE:
+        writeSpecial(BackSpace[xind]);
+	if (localecho) {
+	  if (BackSpace[xind] == "\b") {
+	    putString("\b \b"); // make the last char 'deleted'
+	  } else {
+	    putString(BackSpace[xind]); // echo it
+	  }
+	}
+        break;
+      case KEY_HOME:
+        writeSpecial(KeyHome[xind]);
+        break;
+      case KEY_END:
+        writeSpecial(KeyEnd[xind]);
+        break;
+      case KEY_NUM_LOCK:
+        if (vms && control) {
+          writeSpecial(PF1);
+        }
+        if (!control)
+          numlock = !numlock;
+        break;
+      case KEY_CAPS_LOCK:
+        capslock = !capslock;
+        return;
+      case KEY_SHIFT:
+      case KEY_CONTROL:
+      case KEY_ALT:
+        return;
+      default:
+        break;
+    }
+  }
+/*
+  public void keyReleased(KeyEvent evt) {
+    if (debug > 1) System.out.println("keyReleased("+evt+")");
+    // ignore
+  }
+*/
+  /**
+   * Handle key Typed events for the terminal, this will get
+   * all normal key types, but no shift/alt/control/numlock.
+   */
+  public void keyTyped(int keyCode, char keyChar, int modifiers) {
+    boolean control = (modifiers & VDUInput.KEY_CONTROL) != 0;
+    boolean shift = (modifiers & VDUInput.KEY_SHIFT) != 0;
+    boolean alt = (modifiers & VDUInput.KEY_ALT) != 0;
+
+    if (debug > 1) System.out.println("keyTyped("+keyCode+", "+(int)keyChar+", "+modifiers+")");
+
+    if (keyChar == '\t') {
+      if (shift) {
+        write(TabKey[1], false);
+      } else {
+        if (control) {
+          write(TabKey[2], false);
+        } else {
+          if (alt) {
+            write(TabKey[3], false);
+          } else {
+            write(TabKey[0], false);
+          }
+        }
+      }
+      return;
+    }
+    if (alt) {
+      write("" + ((char) (keyChar | 0x80)));
+      return;
+    }
+
+    if (((keyCode == KEY_ENTER) || (keyChar == 10))
+            && !control) {
+      write("\r", false);
+      if (localecho) putString("\r\n"); // bad hack
+      return;
+    }
+
+    if ((keyCode == 10) && !control) {
+      System.out.println("Sending \\r");
+      write("\r", false);
+      return;
+    }
+
+    // FIXME: on german PC keyboards you have to use Alt-Ctrl-q to get an @,
+    // so we can't just use it here... will probably break some other VMS
+    // codes.  -Marcus
+    // if(((!vms && keyChar == '2') || keyChar == '@' || keyChar == ' ')
+    //    && control)
+    if (((!vms && keyChar == '2') || keyChar == ' ') && control)
+      write("" + (char) 0);
+
+    if (vms) {
+      if (keyChar == 127 && !control) {
+        if (shift)
+          writeSpecial(Insert[0]);        //  VMS shift delete = insert
+        else
+          writeSpecial(Remove[0]);        //  VMS delete = remove
+        return;
+      } else if (control)
+        switch (keyChar) {
+          case '0':
+            writeSpecial(Numpad[0]);
+            return;
+          case '1':
+            writeSpecial(Numpad[1]);
+            return;
+          case '2':
+            writeSpecial(Numpad[2]);
+            return;
+          case '3':
+            writeSpecial(Numpad[3]);
+            return;
+          case '4':
+            writeSpecial(Numpad[4]);
+            return;
+          case '5':
+            writeSpecial(Numpad[5]);
+            return;
+          case '6':
+            writeSpecial(Numpad[6]);
+            return;
+          case '7':
+            writeSpecial(Numpad[7]);
+            return;
+          case '8':
+            writeSpecial(Numpad[8]);
+            return;
+          case '9':
+            writeSpecial(Numpad[9]);
+            return;
+          case '.':
+            writeSpecial(KPPeriod);
+            return;
+          case '-':
+          case 31:
+            writeSpecial(KPMinus);
+            return;
+          case '+':
+            writeSpecial(KPComma);
+            return;
+          case 10:
+            writeSpecial(KPEnter);
+            return;
+          case '/':
+            writeSpecial(PF2);
+            return;
+          case '*':
+            writeSpecial(PF3);
+            return;
+            /* NUMLOCK handled in keyPressed */
+          default:
+            break;
+        }
+      /* Now what does this do and how did it get here. -Marcus
+      if (shift && keyChar < 32) {
+        write(PF1+(char)(keyChar + 64));
+        return;
+      }
+      */
+    }
+
+    // FIXME: not used?
+    //String fmap[];
+    int xind;
+    xind = 0;
+    //fmap = FunctionKey;
+    if (shift) {
+      //fmap = FunctionKeyShift;
+      xind = 1;
+    }
+    if (control) {
+      //fmap = FunctionKeyCtrl;
+      xind = 2;
+    }
+    if (alt) {
+      //fmap = FunctionKeyAlt;
+      xind = 3;
+    }
+
+    if (keyCode == KEY_ESCAPE) {
+      writeSpecial(Escape[xind]);
+      return;
+    }
+
+    if ((modifiers & VDUInput.KEY_ACTION) != 0)
+      switch (keyCode) {
+        case KEY_NUMPAD0:
+          writeSpecial(Numpad[0]);
+          return;
+        case KEY_NUMPAD1:
+          writeSpecial(Numpad[1]);
+          return;
+        case KEY_NUMPAD2:
+          writeSpecial(Numpad[2]);
+          return;
+        case KEY_NUMPAD3:
+          writeSpecial(Numpad[3]);
+          return;
+        case KEY_NUMPAD4:
+          writeSpecial(Numpad[4]);
+          return;
+        case KEY_NUMPAD5:
+          writeSpecial(Numpad[5]);
+          return;
+        case KEY_NUMPAD6:
+          writeSpecial(Numpad[6]);
+          return;
+        case KEY_NUMPAD7:
+          writeSpecial(Numpad[7]);
+          return;
+        case KEY_NUMPAD8:
+          writeSpecial(Numpad[8]);
+          return;
+        case KEY_NUMPAD9:
+          writeSpecial(Numpad[9]);
+          return;
+        case KEY_DECIMAL:
+          writeSpecial(NUMDot[xind]);
+          return;
+        case KEY_ADD:
+          writeSpecial(NUMPlus[xind]);
+          return;
+      }
+
+    if (!((keyChar == 8) || (keyChar == 127) || (keyChar == '\r') || (keyChar == '\n'))) {
+      write("" + keyChar);
+      return;
+    }
+  }
+
+  private void handle_dcs(String dcs) {
+    System.out.println("DCS: " + dcs);
+  }
+
+  private void handle_osc(String osc) {
+    System.out.println("OSC: " + osc);
+  }
+
+  private final static char unimap[] = {
+    //#
+    //#    Name:     cp437_DOSLatinUS to Unicode table
+    //#    Unicode version: 1.1
+    //#    Table version: 1.1
+    //#    Table format:  Format A
+    //#    Date:          03/31/95
+    //#    Authors:       Michel Suignard <michelsu@microsoft.com>
+    //#                   Lori Hoerth <lorih@microsoft.com>
+    //#    General notes: none
+    //#
+    //#    Format: Three tab-separated columns
+    //#        Column #1 is the cp1255_WinHebrew code (in hex)
+    //#        Column #2 is the Unicode (in hex as 0xXXXX)
+    //#        Column #3 is the Unicode name (follows a comment sign, '#')
+    //#
+    //#    The entries are in cp437_DOSLatinUS order
+    //#
+
+    0x0000, // #NULL
+    0x0001, // #START OF HEADING
+    0x0002, // #START OF TEXT
+    0x0003, // #END OF TEXT
+    0x0004, // #END OF TRANSMISSION
+    0x0005, // #ENQUIRY
+    0x0006, // #ACKNOWLEDGE
+    0x0007, // #BELL
+    0x0008, // #BACKSPACE
+    0x0009, // #HORIZONTAL TABULATION
+    0x000a, // #LINE FEED
+    0x000b, // #VERTICAL TABULATION
+    0x000c, // #FORM FEED
+    0x000d, // #CARRIAGE RETURN
+    0x000e, // #SHIFT OUT
+    0x000f, // #SHIFT IN
+    0x0010, // #DATA LINK ESCAPE
+    0x0011, // #DEVICE CONTROL ONE
+    0x0012, // #DEVICE CONTROL TWO
+    0x0013, // #DEVICE CONTROL THREE
+    0x0014, // #DEVICE CONTROL FOUR
+    0x0015, // #NEGATIVE ACKNOWLEDGE
+    0x0016, // #SYNCHRONOUS IDLE
+    0x0017, // #END OF TRANSMISSION BLOCK
+    0x0018, // #CANCEL
+    0x0019, // #END OF MEDIUM
+    0x001a, // #SUBSTITUTE
+    0x001b, // #ESCAPE
+    0x001c, // #FILE SEPARATOR
+    0x001d, // #GROUP SEPARATOR
+    0x001e, // #RECORD SEPARATOR
+    0x001f, // #UNIT SEPARATOR
+    0x0020, // #SPACE
+    0x0021, // #EXCLAMATION MARK
+    0x0022, // #QUOTATION MARK
+    0x0023, // #NUMBER SIGN
+    0x0024, // #DOLLAR SIGN
+    0x0025, // #PERCENT SIGN
+    0x0026, // #AMPERSAND
+    0x0027, // #APOSTROPHE
+    0x0028, // #LEFT PARENTHESIS
+    0x0029, // #RIGHT PARENTHESIS
+    0x002a, // #ASTERISK
+    0x002b, // #PLUS SIGN
+    0x002c, // #COMMA
+    0x002d, // #HYPHEN-MINUS
+    0x002e, // #FULL STOP
+    0x002f, // #SOLIDUS
+    0x0030, // #DIGIT ZERO
+    0x0031, // #DIGIT ONE
+    0x0032, // #DIGIT TWO
+    0x0033, // #DIGIT THREE
+    0x0034, // #DIGIT FOUR
+    0x0035, // #DIGIT FIVE
+    0x0036, // #DIGIT SIX
+    0x0037, // #DIGIT SEVEN
+    0x0038, // #DIGIT EIGHT
+    0x0039, // #DIGIT NINE
+    0x003a, // #COLON
+    0x003b, // #SEMICOLON
+    0x003c, // #LESS-THAN SIGN
+    0x003d, // #EQUALS SIGN
+    0x003e, // #GREATER-THAN SIGN
+    0x003f, // #QUESTION MARK
+    0x0040, // #COMMERCIAL AT
+    0x0041, // #LATIN CAPITAL LETTER A
+    0x0042, // #LATIN CAPITAL LETTER B
+    0x0043, // #LATIN CAPITAL LETTER C
+    0x0044, // #LATIN CAPITAL LETTER D
+    0x0045, // #LATIN CAPITAL LETTER E
+    0x0046, // #LATIN CAPITAL LETTER F
+    0x0047, // #LATIN CAPITAL LETTER G
+    0x0048, // #LATIN CAPITAL LETTER H
+    0x0049, // #LATIN CAPITAL LETTER I
+    0x004a, // #LATIN CAPITAL LETTER J
+    0x004b, // #LATIN CAPITAL LETTER K
+    0x004c, // #LATIN CAPITAL LETTER L
+    0x004d, // #LATIN CAPITAL LETTER M
+    0x004e, // #LATIN CAPITAL LETTER N
+    0x004f, // #LATIN CAPITAL LETTER O
+    0x0050, // #LATIN CAPITAL LETTER P
+    0x0051, // #LATIN CAPITAL LETTER Q
+    0x0052, // #LATIN CAPITAL LETTER R
+    0x0053, // #LATIN CAPITAL LETTER S
+    0x0054, // #LATIN CAPITAL LETTER T
+    0x0055, // #LATIN CAPITAL LETTER U
+    0x0056, // #LATIN CAPITAL LETTER V
+    0x0057, // #LATIN CAPITAL LETTER W
+    0x0058, // #LATIN CAPITAL LETTER X
+    0x0059, // #LATIN CAPITAL LETTER Y
+    0x005a, // #LATIN CAPITAL LETTER Z
+    0x005b, // #LEFT SQUARE BRACKET
+    0x005c, // #REVERSE SOLIDUS
+    0x005d, // #RIGHT SQUARE BRACKET
+    0x005e, // #CIRCUMFLEX ACCENT
+    0x005f, // #LOW LINE
+    0x0060, // #GRAVE ACCENT
+    0x0061, // #LATIN SMALL LETTER A
+    0x0062, // #LATIN SMALL LETTER B
+    0x0063, // #LATIN SMALL LETTER C
+    0x0064, // #LATIN SMALL LETTER D
+    0x0065, // #LATIN SMALL LETTER E
+    0x0066, // #LATIN SMALL LETTER F
+    0x0067, // #LATIN SMALL LETTER G
+    0x0068, // #LATIN SMALL LETTER H
+    0x0069, // #LATIN SMALL LETTER I
+    0x006a, // #LATIN SMALL LETTER J
+    0x006b, // #LATIN SMALL LETTER K
+    0x006c, // #LATIN SMALL LETTER L
+    0x006d, // #LATIN SMALL LETTER M
+    0x006e, // #LATIN SMALL LETTER N
+    0x006f, // #LATIN SMALL LETTER O
+    0x0070, // #LATIN SMALL LETTER P
+    0x0071, // #LATIN SMALL LETTER Q
+    0x0072, // #LATIN SMALL LETTER R
+    0x0073, // #LATIN SMALL LETTER S
+    0x0074, // #LATIN SMALL LETTER T
+    0x0075, // #LATIN SMALL LETTER U
+    0x0076, // #LATIN SMALL LETTER V
+    0x0077, // #LATIN SMALL LETTER W
+    0x0078, // #LATIN SMALL LETTER X
+    0x0079, // #LATIN SMALL LETTER Y
+    0x007a, // #LATIN SMALL LETTER Z
+    0x007b, // #LEFT CURLY BRACKET
+    0x007c, // #VERTICAL LINE
+    0x007d, // #RIGHT CURLY BRACKET
+    0x007e, // #TILDE
+    0x007f, // #DELETE
+    0x00c7, // #LATIN CAPITAL LETTER C WITH CEDILLA
+    0x00fc, // #LATIN SMALL LETTER U WITH DIAERESIS
+    0x00e9, // #LATIN SMALL LETTER E WITH ACUTE
+    0x00e2, // #LATIN SMALL LETTER A WITH CIRCUMFLEX
+    0x00e4, // #LATIN SMALL LETTER A WITH DIAERESIS
+    0x00e0, // #LATIN SMALL LETTER A WITH GRAVE
+    0x00e5, // #LATIN SMALL LETTER A WITH RING ABOVE
+    0x00e7, // #LATIN SMALL LETTER C WITH CEDILLA
+    0x00ea, // #LATIN SMALL LETTER E WITH CIRCUMFLEX
+    0x00eb, // #LATIN SMALL LETTER E WITH DIAERESIS
+    0x00e8, // #LATIN SMALL LETTER E WITH GRAVE
+    0x00ef, // #LATIN SMALL LETTER I WITH DIAERESIS
+    0x00ee, // #LATIN SMALL LETTER I WITH CIRCUMFLEX
+    0x00ec, // #LATIN SMALL LETTER I WITH GRAVE
+    0x00c4, // #LATIN CAPITAL LETTER A WITH DIAERESIS
+    0x00c5, // #LATIN CAPITAL LETTER A WITH RING ABOVE
+    0x00c9, // #LATIN CAPITAL LETTER E WITH ACUTE
+    0x00e6, // #LATIN SMALL LIGATURE AE
+    0x00c6, // #LATIN CAPITAL LIGATURE AE
+    0x00f4, // #LATIN SMALL LETTER O WITH CIRCUMFLEX
+    0x00f6, // #LATIN SMALL LETTER O WITH DIAERESIS
+    0x00f2, // #LATIN SMALL LETTER O WITH GRAVE
+    0x00fb, // #LATIN SMALL LETTER U WITH CIRCUMFLEX
+    0x00f9, // #LATIN SMALL LETTER U WITH GRAVE
+    0x00ff, // #LATIN SMALL LETTER Y WITH DIAERESIS
+    0x00d6, // #LATIN CAPITAL LETTER O WITH DIAERESIS
+    0x00dc, // #LATIN CAPITAL LETTER U WITH DIAERESIS
+    0x00a2, // #CENT SIGN
+    0x00a3, // #POUND SIGN
+    0x00a5, // #YEN SIGN
+    0x20a7, // #PESETA SIGN
+    0x0192, // #LATIN SMALL LETTER F WITH HOOK
+    0x00e1, // #LATIN SMALL LETTER A WITH ACUTE
+    0x00ed, // #LATIN SMALL LETTER I WITH ACUTE
+    0x00f3, // #LATIN SMALL LETTER O WITH ACUTE
+    0x00fa, // #LATIN SMALL LETTER U WITH ACUTE
+    0x00f1, // #LATIN SMALL LETTER N WITH TILDE
+    0x00d1, // #LATIN CAPITAL LETTER N WITH TILDE
+    0x00aa, // #FEMININE ORDINAL INDICATOR
+    0x00ba, // #MASCULINE ORDINAL INDICATOR
+    0x00bf, // #INVERTED QUESTION MARK
+    0x2310, // #REVERSED NOT SIGN
+    0x00ac, // #NOT SIGN
+    0x00bd, // #VULGAR FRACTION ONE HALF
+    0x00bc, // #VULGAR FRACTION ONE QUARTER
+    0x00a1, // #INVERTED EXCLAMATION MARK
+    0x00ab, // #LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
+    0x00bb, // #RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+    0x2591, // #LIGHT SHADE
+    0x2592, // #MEDIUM SHADE
+    0x2593, // #DARK SHADE
+    0x2502, // #BOX DRAWINGS LIGHT VERTICAL
+    0x2524, // #BOX DRAWINGS LIGHT VERTICAL AND LEFT
+    0x2561, // #BOX DRAWINGS VERTICAL SINGLE AND LEFT DOUBLE
+    0x2562, // #BOX DRAWINGS VERTICAL DOUBLE AND LEFT SINGLE
+    0x2556, // #BOX DRAWINGS DOWN DOUBLE AND LEFT SINGLE
+    0x2555, // #BOX DRAWINGS DOWN SINGLE AND LEFT DOUBLE
+    0x2563, // #BOX DRAWINGS DOUBLE VERTICAL AND LEFT
+    0x2551, // #BOX DRAWINGS DOUBLE VERTICAL
+    0x2557, // #BOX DRAWINGS DOUBLE DOWN AND LEFT
+    0x255d, // #BOX DRAWINGS DOUBLE UP AND LEFT
+    0x255c, // #BOX DRAWINGS UP DOUBLE AND LEFT SINGLE
+    0x255b, // #BOX DRAWINGS UP SINGLE AND LEFT DOUBLE
+    0x2510, // #BOX DRAWINGS LIGHT DOWN AND LEFT
+    0x2514, // #BOX DRAWINGS LIGHT UP AND RIGHT
+    0x2534, // #BOX DRAWINGS LIGHT UP AND HORIZONTAL
+    0x252c, // #BOX DRAWINGS LIGHT DOWN AND HORIZONTAL
+    0x251c, // #BOX DRAWINGS LIGHT VERTICAL AND RIGHT
+    0x2500, // #BOX DRAWINGS LIGHT HORIZONTAL
+    0x253c, // #BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL
+    0x255e, // #BOX DRAWINGS VERTICAL SINGLE AND RIGHT DOUBLE
+    0x255f, // #BOX DRAWINGS VERTICAL DOUBLE AND RIGHT SINGLE
+    0x255a, // #BOX DRAWINGS DOUBLE UP AND RIGHT
+    0x2554, // #BOX DRAWINGS DOUBLE DOWN AND RIGHT
+    0x2569, // #BOX DRAWINGS DOUBLE UP AND HORIZONTAL
+    0x2566, // #BOX DRAWINGS DOUBLE DOWN AND HORIZONTAL
+    0x2560, // #BOX DRAWINGS DOUBLE VERTICAL AND RIGHT
+    0x2550, // #BOX DRAWINGS DOUBLE HORIZONTAL
+    0x256c, // #BOX DRAWINGS DOUBLE VERTICAL AND HORIZONTAL
+    0x2567, // #BOX DRAWINGS UP SINGLE AND HORIZONTAL DOUBLE
+    0x2568, // #BOX DRAWINGS UP DOUBLE AND HORIZONTAL SINGLE
+    0x2564, // #BOX DRAWINGS DOWN SINGLE AND HORIZONTAL DOUBLE
+    0x2565, // #BOX DRAWINGS DOWN DOUBLE AND HORIZONTAL SINGLE
+    0x2559, // #BOX DRAWINGS UP DOUBLE AND RIGHT SINGLE
+    0x2558, // #BOX DRAWINGS UP SINGLE AND RIGHT DOUBLE
+    0x2552, // #BOX DRAWINGS DOWN SINGLE AND RIGHT DOUBLE
+    0x2553, // #BOX DRAWINGS DOWN DOUBLE AND RIGHT SINGLE
+    0x256b, // #BOX DRAWINGS VERTICAL DOUBLE AND HORIZONTAL SINGLE
+    0x256a, // #BOX DRAWINGS VERTICAL SINGLE AND HORIZONTAL DOUBLE
+    0x2518, // #BOX DRAWINGS LIGHT UP AND LEFT
+    0x250c, // #BOX DRAWINGS LIGHT DOWN AND RIGHT
+    0x2588, // #FULL BLOCK
+    0x2584, // #LOWER HALF BLOCK
+    0x258c, // #LEFT HALF BLOCK
+    0x2590, // #RIGHT HALF BLOCK
+    0x2580, // #UPPER HALF BLOCK
+    0x03b1, // #GREEK SMALL LETTER ALPHA
+    0x00df, // #LATIN SMALL LETTER SHARP S
+    0x0393, // #GREEK CAPITAL LETTER GAMMA
+    0x03c0, // #GREEK SMALL LETTER PI
+    0x03a3, // #GREEK CAPITAL LETTER SIGMA
+    0x03c3, // #GREEK SMALL LETTER SIGMA
+    0x00b5, // #MICRO SIGN
+    0x03c4, // #GREEK SMALL LETTER TAU
+    0x03a6, // #GREEK CAPITAL LETTER PHI
+    0x0398, // #GREEK CAPITAL LETTER THETA
+    0x03a9, // #GREEK CAPITAL LETTER OMEGA
+    0x03b4, // #GREEK SMALL LETTER DELTA
+    0x221e, // #INFINITY
+    0x03c6, // #GREEK SMALL LETTER PHI
+    0x03b5, // #GREEK SMALL LETTER EPSILON
+    0x2229, // #INTERSECTION
+    0x2261, // #IDENTICAL TO
+    0x00b1, // #PLUS-MINUS SIGN
+    0x2265, // #GREATER-THAN OR EQUAL TO
+    0x2264, // #LESS-THAN OR EQUAL TO
+    0x2320, // #TOP HALF INTEGRAL
+    0x2321, // #BOTTOM HALF INTEGRAL
+    0x00f7, // #DIVISION SIGN
+    0x2248, // #ALMOST EQUAL TO
+    0x00b0, // #DEGREE SIGN
+    0x2219, // #BULLET OPERATOR
+    0x00b7, // #MIDDLE DOT
+    0x221a, // #SQUARE ROOT
+    0x207f, // #SUPERSCRIPT LATIN SMALL LETTER N
+    0x00b2, // #SUPERSCRIPT TWO
+    0x25a0, // #BLACK SQUARE
+    0x00a0, // #NO-BREAK SPACE
+  };
+
+  public char map_cp850_unicode(char x) {
+    if (x >= 0x100)
+      return x;
+    return unimap[x];
+  }
+
+  private void _SetCursor(int row, int col) {
+    int maxr = getRows();
+    int tm = getTopMargin();
+
+    R = (row < 0)?0:row;
+    C = (col < 0)?0:col;
+
+    if (!moveoutsidemargins) {
+      R += tm;
+      maxr = getBottomMargin();
+    }
+    if (R > maxr) R = maxr;
+  }
+
+  private void putChar(char c, boolean doshowcursor) {
+    int rows = getRows(); //statusline
+    int columns = getColumns();
+    int tm = getTopMargin();
+    int bm = getBottomMargin();
+    // byte msg[];
+    boolean mapped = false;
+
+    if (debug > 4) System.out.println("putChar(" + c + " [" + ((int) c) + "]) at R=" + R + " , C=" + C + ", columns=" + columns + ", rows=" + rows);
+    markLine(R, 1);
+    if (c > 255) {
+      if (debug > 0)
+        System.out.println("char > 255:" + (int) c);
+      //return;
+    }
+
+
+    switch (term_state) {
+      case TSTATE_DATA:
+        /* FIXME: we shouldn't use chars with bit 8 set if ibmcharset.
+         * probably... but some BBS do anyway...
+         */
+        if (!useibmcharset) {
+          boolean doneflag = true;
+          switch (c) {
+            case OSC:
+              osc = "";
+              term_state = TSTATE_OSC;
+              break;
+            case RI:
+              if (R > tm)
+                R--;
+              else
+                insertLine(R, 1, SCROLL_DOWN);
+              if (debug > 1)
+                System.out.println("RI");
+              break;
+            case IND:
+              if (debug > 2)
+                System.out.println("IND at " + R + ", tm is " + tm + ", bm is " + bm);
+              if (R == bm || R == rows - 1)
+                insertLine(R, 1, SCROLL_UP);
+              else
+                R++;
+              if (debug > 1)
+                System.out.println("IND (at " + R + " )");
+              break;
+            case NEL:
+              if (R == bm || R == rows - 1)
+                insertLine(R, 1, SCROLL_UP);
+              else
+                R++;
+              C = 0;
+              if (debug > 1)
+                System.out.println("NEL (at " + R + " )");
+              break;
+            case HTS:
+              Tabs[C] = 1;
+              if (debug > 1)
+                System.out.println("HTS");
+              break;
+            case DCS:
+              dcs = "";
+              term_state = TSTATE_DCS;
+              break;
+            default:
+              doneflag = false;
+              break;
+          }
+          if (doneflag) break;
+        }
+        switch (c) {
+          case SS3:
+            onegl = 3;
+            break;
+          case SS2:
+            onegl = 2;
+            break;
+          case CSI: // should be in the 8bit section, but some BBS use this
+            DCEvar = 0;
+            DCEvars[0] = 0;
+            DCEvars[1] = 0;
+            DCEvars[2] = 0;
+            DCEvars[3] = 0;
+            term_state = TSTATE_CSI;
+            break;
+          case ESC:
+            term_state = TSTATE_ESC;
+            lastwaslf = 0;
+            break;
+          case 5: /* ENQ */
+            write(answerBack, false);
+            break;
+          case 12:
+            /* FormFeed, Home for the BBS world */
+            deleteArea(0, 0, columns, rows, attributes);
+            C = R = 0;
+            break;
+          case '\b': /* 8 */
+            C--;
+            if (C < 0)
+              C = 0;
+            lastwaslf = 0;
+            break;
+          case '\t':
+            do {
+              // Don't overwrite or insert! TABS are not destructive, but movement!
+              C++;
+            } while (C < columns && (Tabs[C] == 0));
+            lastwaslf = 0;
+            break;
+          case '\r':
+            C = 0;
+            break;
+          case '\n':
+            if (debug > 3)
+              System.out.println("R= " + R + ", bm " + bm + ", tm=" + tm + ", rows=" + rows);
+            if (!vms) {
+              if (lastwaslf != 0 && lastwaslf != c)   //  Ray: I do not understand this logic.
+                break;
+              lastwaslf = c;
+              /*C = 0;*/
+            }
+            if (R == bm || R >= rows - 1)
+              insertLine(R, 1, SCROLL_UP);
+            else
+              R++;
+            break;
+          case 7:
+            beep();
+            break;
+          case '\016': /* SMACS , as */
+            /* ^N, Shift out - Put G1 into GL */
+            gl = 1;
+            usedcharsets = true;
+            break;
+          case '\017': /* RMACS , ae */
+            /* ^O, Shift in - Put G0 into GL */
+            gl = 0;
+            usedcharsets = true;
+            break;
+          default:
+            {
+              int thisgl = gl;
+
+              if (onegl >= 0) {
+                thisgl = onegl;
+                onegl = -1;
+              }
+              lastwaslf = 0;
+              if (c < 32) {
+                if (c != 0)
+                  if (debug > 0)
+                    System.out.println("TSTATE_DATA char: " + ((int) c));
+                /*break; some BBS really want those characters, like hearst etc. */
+                if (c == 0) /* print 0 ... you bet */
+                  break;
+              }
+              if (C >= columns) {
+                if (wraparound) {
+                  if (R < rows - 1)
+                    R++;
+                  else
+                    insertLine(R, 1, SCROLL_UP);
+                  C = 0;
+                } else {
+                  // cursor stays on last character.
+                  C = columns - 1;
+                }
+              }
+
+              // Mapping if DEC Special is chosen charset
+              if (usedcharsets) {
+                if (c >= '\u0020' && c <= '\u007f') {
+                  switch (gx[thisgl]) {
+                    case '0':
+                      // Remap SCOANSI line drawing to VT100 line drawing chars
+                      // for our SCO using customers.
+                      if (terminalID.equals("scoansi") || terminalID.equals("ansi")) {
+                        for (int i = 0; i < scoansi_acs.length(); i += 2) {
+                          if (c == scoansi_acs.charAt(i)) {
+                            c = scoansi_acs.charAt(i + 1);
+                            break;
+                          }
+                        }
+                      }
+                      if (c >= '\u005f' && c <= '\u007e') {
+                        c = DECSPECIAL[(short) c - 0x5f];
+                        mapped = true;
+                      }
+                      break;
+                    case '<': // 'user preferred' is currently 'ISO Latin-1 suppl
+                      c = (char) (((int) c & 0x7f) | 0x80);
+                      mapped = true;
+                      break;
+                    case 'A':
+                    case 'B': // Latin-1 , ASCII -> fall through
+                      mapped = true;
+                      break;
+                    default:
+                      System.out.println("Unsupported GL mapping: " + gx[thisgl]);
+                      break;
+                  }
+                }
+                if (!mapped && (c >= '\u0080' && c <= '\u00ff')) {
+                  switch (gx[gr]) {
+                    case '0':
+                      if (c >= '\u00df' && c <= '\u00fe') {
+                        c = DECSPECIAL[c - '\u00df'];
+                        mapped = true;
+                      }
+                      break;
+                    case '<':
+                    case 'A':
+                    case 'B':
+                      mapped = true;
+                      break;
+                    default:
+                      System.out.println("Unsupported GR mapping: " + gx[gr]);
+                      break;
+                  }
+                }
+              }
+              if (!mapped && useibmcharset)
+                c = map_cp850_unicode(c);
+
+              /*if(true || (statusmode == 0)) { */
+              if (insertmode == 1) {
+                insertChar(C, R, c, attributes);
+              } else {
+                putChar(C, R, c, attributes);
+              }
+              /*
+                } else {
+                if (insertmode==1) {
+                insertChar(C, rows, c, attributes);
+                } else {
+                putChar(C, rows, c, attributes);
+                }
+                }
+              */
+              C++;
+              break;
+            }
+        } /* switch(c) */
+        break;
+      case TSTATE_OSC:
+        if ((c < 0x20) && (c != ESC)) {// NP - No printing character
+          handle_osc(osc);
+          term_state = TSTATE_DATA;
+          break;
+        }
+        //but check for vt102 ESC \
+        if (c == '\\' && osc.charAt(osc.length() - 1) == ESC) {
+          handle_osc(osc);
+          term_state = TSTATE_DATA;
+          break;
+        }
+        osc = osc + c;
+        break;
+      case TSTATE_ESCSPACE:
+        term_state = TSTATE_DATA;
+        switch (c) {
+          case 'F': /* S7C1T, Disable output of 8-bit controls, use 7-bit */
+            output8bit = false;
+            break;
+          case 'G': /* S8C1T, Enable output of 8-bit control codes*/
+            output8bit = true;
+            break;
+          default:
+            System.out.println("ESC <space> " + c + " unhandled.");
+        }
+        break;
+      case TSTATE_ESC:
+        term_state = TSTATE_DATA;
+        switch (c) {
+          case ' ':
+            term_state = TSTATE_ESCSPACE;
+            break;
+          case '#':
+            term_state = TSTATE_ESCSQUARE;
+            break;
+          case 'c':
+            /* Hard terminal reset */
+            /* reset character sets */
+            gx[0] = 'B';
+            gx[1] = '0';
+            gx[2] = 'B';
+            gx[3] = 'B';
+            gl = 0;  // default GL to G0
+            gr = 1;  // default GR to G1
+            /* reset tabs */
+            int nw = getColumns();
+            if (nw < 132) nw = 132;
+            Tabs = new byte[nw];
+            for (int i = 0; i < nw; i += 8) {
+              Tabs[i] = 1;
+            }
+            /*FIXME:*/
+            break;
+          case '[':
+            DCEvar = 0;
+            DCEvars[0] = 0;
+            DCEvars[1] = 0;
+            DCEvars[2] = 0;
+            DCEvars[3] = 0;
+            term_state = TSTATE_CSI;
+            break;
+          case ']':
+            osc = "";
+            term_state = TSTATE_OSC;
+            break;
+          case 'P':
+            dcs = "";
+            term_state = TSTATE_DCS;
+            break;
+          case 'A': /* CUU */
+            R--;
+            if (R < 0) R = 0;
+            break;
+          case 'B': /* CUD */
+            R++;
+            if (R > rows - 1) R = rows - 1;
+            break;
+          case 'C':
+            C++;
+            if (C >= columns) C = columns - 1;
+            break;
+          case 'I': // RI
+            insertLine(R, 1, SCROLL_DOWN);
+            break;
+          case 'E': /* NEL */
+            if (R == bm || R == rows - 1)
+              insertLine(R, 1, SCROLL_UP);
+            else
+              R++;
+            C = 0;
+            if (debug > 1)
+              System.out.println("ESC E (at " + R + ")");
+            break;
+          case 'D': /* IND */
+            if (R == bm || R == rows - 1)
+              insertLine(R, 1, SCROLL_UP);
+            else
+              R++;
+            if (debug > 1)
+              System.out.println("ESC D (at " + R + " )");
+            break;
+          case 'J': /* erase to end of screen */
+            if (R < rows - 1)
+              deleteArea(0, R + 1, columns, rows - R - 1, attributes);
+            if (C < columns - 1)
+              deleteArea(C, R, columns - C, 1, attributes);
+            break;
+          case 'K':
+            if (C < columns - 1)
+              deleteArea(C, R, columns - C, 1, attributes);
+            break;
+          case 'M': // RI
+            System.out.println("ESC M : R is "+R+", tm is "+tm+", bm is "+bm);
+            if (R > bm) // outside scrolling region
+              break;
+            if (R > tm) { // just go up 1 line.
+              R--;
+            } else { // scroll down
+              insertLine(R, 1, SCROLL_DOWN);
+            }
+            /* else do nothing ; */
+            if (debug > 2)
+              System.out.println("ESC M ");
+            break;
+          case 'H':
+            if (debug > 1)
+              System.out.println("ESC H at " + C);
+            /* right border probably ...*/
+            if (C >= columns)
+              C = columns - 1;
+            Tabs[C] = 1;
+            break;
+          case 'N': // SS2
+            onegl = 2;
+            break;
+          case 'O': // SS3
+            onegl = 3;
+            break;
+          case '=':
+            /*application keypad*/
+            if (debug > 0)
+              System.out.println("ESC =");
+            keypadmode = true;
+            break;
+          case '<': /* vt52 mode off */
+            vt52mode = false;
+            break;
+          case '>': /*normal keypad*/
+            if (debug > 0)
+              System.out.println("ESC >");
+            keypadmode = false;
+            break;
+          case '7': /*save cursor, attributes, margins */
+            Sc = C;
+            Sr = R;
+            Sgl = gl;
+            Sgr = gr;
+            Sa = attributes;
+            Sgx = new char[4];
+            for (int i = 0; i < 4; i++) Sgx[i] = gx[i];
+            Stm = getTopMargin();
+            Sbm = getBottomMargin();
+            if (debug > 1)
+              System.out.println("ESC 7");
+            break;
+          case '8': /*restore cursor, attributes, margins */
+            C = Sc;
+            R = Sr;
+            gl = Sgl;
+            gr = Sgr;
+            for (int i = 0; i < 4; i++) gx[i] = Sgx[i];
+            setTopMargin(Stm);
+            setBottomMargin(Sbm);
+            attributes = Sa;
+            if (debug > 1)
+              System.out.println("ESC 8");
+            break;
+          case '(': /* Designate G0 Character set (ISO 2022) */
+            term_state = TSTATE_SETG0;
+            usedcharsets = true;
+            break;
+          case ')': /* Designate G1 character set (ISO 2022) */
+            term_state = TSTATE_SETG1;
+            usedcharsets = true;
+            break;
+          case '*': /* Designate G2 Character set (ISO 2022) */
+            term_state = TSTATE_SETG2;
+            usedcharsets = true;
+            break;
+          case '+': /* Designate G3 Character set (ISO 2022) */
+            term_state = TSTATE_SETG3;
+            usedcharsets = true;
+            break;
+          case '~': /* Locking Shift 1, right */
+            gr = 1;
+            usedcharsets = true;
+            break;
+          case 'n': /* Locking Shift 2 */
+            gl = 2;
+            usedcharsets = true;
+            break;
+          case '}': /* Locking Shift 2, right */
+            gr = 2;
+            usedcharsets = true;
+            break;
+          case 'o': /* Locking Shift 3 */
+            gl = 3;
+            usedcharsets = true;
+            break;
+          case '|': /* Locking Shift 3, right */
+            gr = 3;
+            usedcharsets = true;
+            break;
+          case 'Y': /* vt52 cursor address mode , next chars are x,y */
+            term_state = TSTATE_VT52Y;
+            break;
+          default:
+            System.out.println("ESC unknown letter: " + c + " (" + ((int) c) + ")");
+            break;
+        }
+        break;
+      case TSTATE_VT52X:
+        C = c - 37;
+        term_state = TSTATE_VT52Y;
+        break;
+      case TSTATE_VT52Y:
+        R = c - 37;
+        term_state = TSTATE_DATA;
+        break;
+      case TSTATE_SETG0:
+        if (c != '0' && c != 'A' && c != 'B' && c != '<')
+          System.out.println("ESC ( " + c + ": G0 char set?  (" + ((int) c) + ")");
+        else {
+          if (debug > 2) System.out.println("ESC ( : G0 char set  (" + c + " " + ((int) c) + ")");
+          gx[0] = c;
+        }
+        term_state = TSTATE_DATA;
+        break;
+      case TSTATE_SETG1:
+        if (c != '0' && c != 'A' && c != 'B' && c != '<') {
+          System.out.println("ESC ) " + c + " (" + ((int) c) + ") :G1 char set?");
+        } else {
+          if (debug > 2) System.out.println("ESC ) :G1 char set  (" + c + " " + ((int) c) + ")");
+          gx[1] = c;
+        }
+        term_state = TSTATE_DATA;
+        break;
+      case TSTATE_SETG2:
+        if (c != '0' && c != 'A' && c != 'B' && c != '<')
+          System.out.println("ESC*:G2 char set?  (" + ((int) c) + ")");
+        else {
+          if (debug > 2) System.out.println("ESC*:G2 char set  (" + c + " " + ((int) c) + ")");
+          gx[2] = c;
+        }
+        term_state = TSTATE_DATA;
+        break;
+      case TSTATE_SETG3:
+        if (c != '0' && c != 'A' && c != 'B' && c != '<')
+          System.out.println("ESC+:G3 char set?  (" + ((int) c) + ")");
+        else {
+          if (debug > 2) System.out.println("ESC+:G3 char set  (" + c + " " + ((int) c) + ")");
+          gx[3] = c;
+        }
+        term_state = TSTATE_DATA;
+        break;
+      case TSTATE_ESCSQUARE:
+        switch (c) {
+          case '8':
+            for (int i = 0; i < columns; i++)
+              for (int j = 0; j < rows; j++)
+                putChar(i, j, 'E', 0);
+            break;
+          default:
+            System.out.println("ESC # " + c + " not supported.");
+            break;
+        }
+        term_state = TSTATE_DATA;
+        break;
+      case TSTATE_DCS:
+        if (c == '\\' && dcs.charAt(dcs.length() - 1) == ESC) {
+          handle_dcs(dcs);
+          term_state = TSTATE_DATA;
+          break;
+        }
+        dcs = dcs + c;
+        break;
+
+      case TSTATE_DCEQ:
+        term_state = TSTATE_DATA;
+        switch (c) {
+          case '0':
+          case '1':
+          case '2':
+          case '3':
+          case '4':
+          case '5':
+          case '6':
+          case '7':
+          case '8':
+          case '9':
+            DCEvars[DCEvar] = DCEvars[DCEvar] * 10 + ((int) c) - 48;
+            term_state = TSTATE_DCEQ;
+            break;
+          case ';':
+            DCEvar++;
+            DCEvars[DCEvar] = 0;
+            term_state = TSTATE_DCEQ;
+            break;
+          case 's': // XTERM_SAVE missing!
+            if (true || debug > 1)
+              System.out.println("ESC [ ? " + DCEvars[0] + " s unimplemented!");
+            break;
+          case 'r': // XTERM_RESTORE
+            if (true || debug > 1)
+              System.out.println("ESC [ ? " + DCEvars[0] + " r");
+            /* DEC Mode reset */
+            for (int i = 0; i <= DCEvar; i++) {
+              switch (DCEvars[i]) {
+                case 3: /* 80 columns*/
+                  setScreenSize(80, getRows(), true);
+                  break;
+                case 4: /* scrolling mode, smooth */
+                  break;
+                case 5: /* light background */
+                  break;
+                case 6: /* DECOM (Origin Mode) move inside margins. */
+                  moveoutsidemargins = true;
+                  break;
+                case 7: /* DECAWM: Autowrap Mode */
+                  wraparound = false;
+                  break;
+                case 12:/* local echo off */
+                  break;
+                case 9: 	/* X10 mouse */
+                case 1000:	/* xterm style mouse report on */
+                case 1001:
+                case 1002:
+                case 1003:
+                  mouserpt = DCEvars[i];
+                  break;
+                default:
+                  System.out.println("ESC [ ? " + DCEvars[0] + " r, unimplemented!");
+              }
+            }
+            break;
+          case 'h': // DECSET
+            if (debug > 0)
+              System.out.println("ESC [ ? " + DCEvars[0] + " h");
+            /* DEC Mode set */
+            for (int i = 0; i <= DCEvar; i++) {
+              switch (DCEvars[i]) {
+                case 1:  /* Application cursor keys */
+                  KeyUp[0] = "\u001bOA";
+                  KeyDown[0] = "\u001bOB";
+                  KeyRight[0] = "\u001bOC";
+                  KeyLeft[0] = "\u001bOD";
+                  break;
+                case 2: /* DECANM */
+                  vt52mode = false;
+                  break;
+                case 3: /* 132 columns*/
+                  setScreenSize(132, getRows(), true);
+                  break;
+                case 6: /* DECOM: move inside margins. */
+                  moveoutsidemargins = false;
+                  break;
+                case 7: /* DECAWM: Autowrap Mode */
+                  wraparound = true;
+                  break;
+                case 25: /* turn cursor on */
+                  showCursor(true);
+                  break;
+                case 9: 	/* X10 mouse */
+                case 1000:	/* xterm style mouse report on */
+                case 1001:
+                case 1002:
+                case 1003:
+                  mouserpt = DCEvars[i];
+                  break;
+
+                  /* unimplemented stuff, fall through */
+                  /* 4  - scrolling mode, smooth */
+                  /* 5  - light background */
+                  /* 12 - local echo off */
+                  /* 18 - DECPFF - Printer Form Feed Mode -> On */
+                  /* 19 - DECPEX - Printer Extent Mode -> Screen */
+                default:
+                  System.out.println("ESC [ ? " + DCEvars[0] + " h, unsupported.");
+                  break;
+              }
+            }
+            break;
+          case 'i': // DEC Printer Control, autoprint, echo screenchars to printer
+            // This is different to CSI i!
+            // Also: "Autoprint prints a final display line only when the
+            // cursor is moved off the line by an autowrap or LF, FF, or
+            // VT (otherwise do not print the line)."
+            switch (DCEvars[0]) {
+              case 1:
+                if (debug > 1)
+                  System.out.println("CSI ? 1 i : Print line containing cursor");
+                break;
+              case 4:
+                if (debug > 1)
+                  System.out.println("CSI ? 4 i : Start passthrough printing");
+                break;
+              case 5:
+                if (debug > 1)
+                  System.out.println("CSI ? 4 i : Stop passthrough printing");
+                break;
+            }
+            break;
+          case 'l':	//DECRST
+            /* DEC Mode reset */
+            if (debug > 0)
+              System.out.println("ESC [ ? " + DCEvars[0] + " l");
+            for (int i = 0; i <= DCEvar; i++) {
+              switch (DCEvars[i]) {
+                case 1:  /* Application cursor keys */
+                  KeyUp[0] = "\u001b[A";
+                  KeyDown[0] = "\u001b[B";
+                  KeyRight[0] = "\u001b[C";
+                  KeyLeft[0] = "\u001b[D";
+                  break;
+                case 2: /* DECANM */
+                  vt52mode = true;
+                  break;
+                case 3: /* 80 columns*/
+                  setScreenSize(80, getRows(), true);
+                  break;
+                case 6: /* DECOM: move outside margins. */
+                  moveoutsidemargins = true;
+                  break;
+                case 7: /* DECAWM: Autowrap Mode OFF */
+                  wraparound = false;
+                  break;
+                case 25: /* turn cursor off */
+                  showCursor(false);
+                  break;
+                  /* Unimplemented stuff: */
+                  /* 4  - scrolling mode, jump */
+                  /* 5  - dark background */
+                  /* 7  - DECAWM - no wrap around mode */
+                  /* 12 - local echo on */
+                  /* 18 - DECPFF - Printer Form Feed Mode -> Off*/
+                  /* 19 - DECPEX - Printer Extent Mode -> Scrolling Region */
+                case 9: 	/* X10 mouse */
+                case 1000:	/* xterm style mouse report OFF */
+                case 1001:
+                case 1002:
+                case 1003:
+                  mouserpt = 0;
+                  break;
+                default:
+                  System.out.println("ESC [ ? " + DCEvars[0] + " l, unsupported.");
+                  break;
+              }
+            }
+            break;
+          case 'n':
+            if (debug > 0)
+              System.out.println("ESC [ ? " + DCEvars[0] + " n");
+            switch (DCEvars[0]) {
+              case 15:
+                /* printer? no printer. */
+                write(((char) ESC) + "[?13n", false);
+                System.out.println("ESC[5n");
+                break;
+              default:
+                System.out.println("ESC [ ? " + DCEvars[0] + " n, unsupported.");
+                break;
+            }
+            break;
+          default:
+            System.out.println("ESC [ ? " + DCEvars[0] + " " + c + ", unsupported.");
+            break;
+        }
+        break;
+      case TSTATE_CSI_EX:
+        term_state = TSTATE_DATA;
+        switch (c) {
+          case ESC:
+            term_state = TSTATE_ESC;
+            break;
+          default:
+            System.out.println("Unknown character ESC[! character is " + (int) c);
+            break;
+        }
+        break;
+      case TSTATE_CSI_TICKS:
+        term_state = TSTATE_DATA;
+        switch (c) {
+          case 'p':
+            System.out.println("Conformance level: " + DCEvars[0] + " (unsupported)," + DCEvars[1]);
+            if (DCEvars[0] == 61) {
+              output8bit = false;
+              break;
+            }
+            if (DCEvars[1] == 1) {
+              output8bit = false;
+            } else {
+              output8bit = true; /* 0 or 2 */
+            }
+            break;
+          default:
+            System.out.println("Unknown ESC [...  \"" + c);
+            break;
+        }
+        break;
+      case TSTATE_CSI_EQUAL:
+        term_state = TSTATE_DATA;
+        switch (c) {
+          case '0':
+          case '1':
+          case '2':
+          case '3':
+          case '4':
+          case '5':
+          case '6':
+          case '7':
+          case '8':
+          case '9':
+            DCEvars[DCEvar] = DCEvars[DCEvar] * 10 + ((int) c) - 48;
+            term_state = TSTATE_CSI_EQUAL;
+            break;
+          case ';':
+            DCEvar++;
+            DCEvars[DCEvar] = 0;
+            term_state = TSTATE_CSI_EQUAL;
+            break;
+
+          case 'F': /* SCO ANSI foreground */
+	  {
+	    int newcolor;
+
+            System.out.println("ESC [ = "+DCEvars[0]+" F");
+
+            attributes &= ~COLOR_FG;
+	    newcolor =	((DCEvars[0] & 1) << 2)	|
+	    		 (DCEvars[0] & 2)	|
+	    		((DCEvars[0] & 4) >> 2) ;
+            attributes |= (newcolor+1) << COLOR_FG_SHIFT;
+
+	    break;
+	  }
+          case 'G': /* SCO ANSI background */
+	  {
+	    int newcolor;
+
+            System.out.println("ESC [ = "+DCEvars[0]+" G");
+
+            attributes &= ~COLOR_BG;
+	    newcolor =	((DCEvars[0] & 1) << 2)	|
+	    		 (DCEvars[0] & 2)	|
+	    		((DCEvars[0] & 4) >> 2) ;
+            attributes |= (newcolor+1) << COLOR_BG_SHIFT;
+	    break;
+          }
+
+          default:
+            System.out.print("Unknown ESC [ = ");
+	    for (int i=0;i<=DCEvar;i++)
+		System.out.print(DCEvars[i]+",");
+	    System.out.println("" + c);
+            break;
+        }
+        break;
+      case TSTATE_CSI_DOLLAR:
+        term_state = TSTATE_DATA;
+        switch (c) {
+          case '}':
+            System.out.println("Active Status Display now " + DCEvars[0]);
+            statusmode = DCEvars[0];
+            break;
+            /* bad documentation?
+               case '-':
+               System.out.println("Set Status Display now "+DCEvars[0]);
+               break;
+            */
+          case '~':
+            System.out.println("Status Line mode now " + DCEvars[0]);
+            break;
+          default:
+            System.out.println("UNKNOWN Status Display code " + c + ", with Pn=" + DCEvars[0]);
+            break;
+        }
+        break;
+      case TSTATE_CSI:
+        term_state = TSTATE_DATA;
+        switch (c) {
+          case '"':
+            term_state = TSTATE_CSI_TICKS;
+            break;
+          case '$':
+            term_state = TSTATE_CSI_DOLLAR;
+            break;
+          case '=':
+            term_state = TSTATE_CSI_EQUAL;
+            break;
+          case '!':
+            term_state = TSTATE_CSI_EX;
+            break;
+          case '?':
+            DCEvar = 0;
+            DCEvars[0] = 0;
+            term_state = TSTATE_DCEQ;
+            break;
+          case '0':
+          case '1':
+          case '2':
+          case '3':
+          case '4':
+          case '5':
+          case '6':
+          case '7':
+          case '8':
+          case '9':
+            DCEvars[DCEvar] = DCEvars[DCEvar] * 10 + ((int) c) - 48;
+            term_state = TSTATE_CSI;
+            break;
+          case ';':
+            DCEvar++;
+            DCEvars[DCEvar] = 0;
+            term_state = TSTATE_CSI;
+            break;
+          case 'c':/* send primary device attributes */
+            /* send (ESC[?61c) */
+
+            String subcode = "";
+            if (terminalID.equals("vt320")) subcode = "63;";
+            if (terminalID.equals("vt220")) subcode = "62;";
+            if (terminalID.equals("vt100")) subcode = "61;";
+            write(((char) ESC) + "[?" + subcode + "1;2c", false);
+            if (debug > 1)
+              System.out.println("ESC [ " + DCEvars[0] + " c");
+            break;
+          case 'q':
+            if (debug > 1)
+              System.out.println("ESC [ " + DCEvars[0] + " q");
+            break;
+          case 'g':
+            /* used for tabsets */
+            switch (DCEvars[0]) {
+              case 3:/* clear them */
+                Tabs = new byte[getColumns()];
+                break;
+              case 0:
+                Tabs[C] = 0;
+                break;
+            }
+            if (debug > 1)
+              System.out.println("ESC [ " + DCEvars[0] + " g");
+            break;
+          case 'h':
+            switch (DCEvars[0]) {
+              case 4:
+                insertmode = 1;
+                break;
+              case 20:
+                System.out.println("Setting CRLF to TRUE");
+                sendcrlf = true;
+                break;
+              default:
+                System.out.println("unsupported: ESC [ " + DCEvars[0] + " h");
+                break;
+            }
+            if (debug > 1)
+              System.out.println("ESC [ " + DCEvars[0] + " h");
+            break;
+          case 'i': // Printer Controller mode.
+            // "Transparent printing sends all output, except the CSI 4 i
+            //  termination string, to the printer and not the screen,
+            //  uses an 8-bit channel if no parity so NUL and DEL will be
+            //  seen by the printer and by the termination recognizer code,
+            //  and all translation and character set selections are
+            //  bypassed."
+            switch (DCEvars[0]) {
+              case 0:
+                if (debug > 1)
+                  System.out.println("CSI 0 i:  Print Screen, not implemented.");
+                break;
+              case 4:
+                if (debug > 1)
+                  System.out.println("CSI 4 i:  Enable Transparent Printing, not implemented.");
+                break;
+              case 5:
+                if (debug > 1)
+                  System.out.println("CSI 4/5 i:  Disable Transparent Printing, not implemented.");
+                break;
+              default:
+                System.out.println("ESC [ " + DCEvars[0] + " i, unimplemented!");
+            }
+            break;
+          case 'l':
+            switch (DCEvars[0]) {
+              case 4:
+                insertmode = 0;
+                break;
+              case 20:
+                System.out.println("Setting CRLF to FALSE");
+                sendcrlf = false;
+                break;
+              default:
+                System.out.println("ESC [ " + DCEvars[0] + " l, unimplemented!");
+                break;
+            }
+            break;
+          case 'A': // CUU
+            {
+              int limit;
+              /* FIXME: xterm only cares about 0 and topmargin */
+              if (R > bm)
+                limit = bm + 1;
+              else if (R >= tm) {
+                limit = tm;
+              } else
+                limit = 0;
+              if (DCEvars[0] == 0)
+                R--;
+              else
+                R -= DCEvars[0];
+              if (R < limit)
+                R = limit;
+              if (debug > 1)
+                System.out.println("ESC [ " + DCEvars[0] + " A");
+              break;
+            }
+          case 'B':	// CUD
+            /* cursor down n (1) times */
+            {
+              int limit;
+              if (R < tm)
+                limit = tm - 1;
+              else if (R <= bm) {
+                limit = bm;
+              } else
+                limit = rows - 1;
+              if (DCEvars[0] == 0)
+                R++;
+              else
+                R += DCEvars[0];
+              if (R > limit)
+                R = limit;
+              else {
+                if (debug > 2) System.out.println("Not limited.");
+              }
+              if (debug > 2) System.out.println("to: " + R);
+              if (debug > 1)
+                System.out.println("ESC [ " + DCEvars[0] + " B (at C=" + C + ")");
+              break;
+            }
+          case 'C':
+            if (DCEvars[0] == 0)
+              C++;
+            else
+              C += DCEvars[0];
+            if (C > columns - 1)
+              C = columns - 1;
+            if (debug > 1)
+              System.out.println("ESC [ " + DCEvars[0] + " C");
+            break;
+          case 'd': // CVA
+            R = DCEvars[0];
+            if (debug > 1)
+              System.out.println("ESC [ " + DCEvars[0] + " d");
+            break;
+          case 'D':
+            if (DCEvars[0] == 0)
+              C--;
+            else
+              C -= DCEvars[0];
+            if (C < 0) C = 0;
+            if (debug > 1)
+              System.out.println("ESC [ " + DCEvars[0] + " D");
+            break;
+          case 'r': // DECSTBM
+            if (DCEvar > 0)   //  Ray:  Any argument is optional
+            {
+              R = DCEvars[1] - 1;
+              if (R < 0)
+                R = rows - 1;
+              else if (R >= rows) {
+                R = rows - 1;
+              }
+            } else
+              R = rows - 1;
+            setBottomMargin(R);
+            if (R >= DCEvars[0]) {
+              R = DCEvars[0] - 1;
+              if (R < 0)
+                R = 0;
+            }
+            setTopMargin(R);
+            _SetCursor(0, 0);
+            if (debug > 1)
+              System.out.println("ESC [" + DCEvars[0] + " ; " + DCEvars[1] + " r");
+            break;
+          case 'G':  /* CUP  / cursor absolute column */
+            C = DCEvars[0];
+            if (debug > 1) System.out.println("ESC [ " + DCEvars[0] + " G");
+            break;
+          case 'H':  /* CUP  / cursor position */
+            /* gets 2 arguments */
+            _SetCursor(DCEvars[0] - 1, DCEvars[1] - 1);
+            if (debug > 2) {
+              System.out.println("ESC [ " + DCEvars[0] + ";" + DCEvars[1] + " H, moveoutsidemargins " + moveoutsidemargins);
+              System.out.println("	-> R now " + R + ", C now " + C);
+            }
+            break;
+          case 'f':  /* move cursor 2 */
+            /* gets 2 arguments */
+            R = DCEvars[0] - 1;
+            C = DCEvars[1] - 1;
+            if (C < 0) C = 0;
+            if (R < 0) R = 0;
+            if (debug > 2)
+              System.out.println("ESC [ " + DCEvars[0] + ";" + DCEvars[1] + " f");
+            break;
+          case 'S': /* ind aka 'scroll forward' */
+            if (DCEvars[0] == 0)
+              insertLine(rows - 1, SCROLL_UP);
+            else
+              insertLine(rows - 1, DCEvars[0], SCROLL_UP);
+            break;
+          case 'L':
+            /* insert n lines */
+            if (DCEvars[0] == 0)
+              insertLine(R, SCROLL_DOWN);
+            else
+              insertLine(R, DCEvars[0], SCROLL_DOWN);
+            if (debug > 1)
+              System.out.println("ESC [ " + DCEvars[0] + "" + (c) + " (at R " + R + ")");
+            break;
+          case 'T': /* 'ri' aka scroll backward */
+            if (DCEvars[0] == 0)
+              insertLine(0, SCROLL_DOWN);
+            else
+              insertLine(0, DCEvars[0], SCROLL_DOWN);
+            break;
+          case 'M':
+            if (debug > 1)
+              System.out.println("ESC [ " + DCEvars[0] + "" + (c) + " at R=" + R);
+            if (DCEvars[0] == 0)
+              deleteLine(R);
+            else
+              for (int i = 0; i < DCEvars[0]; i++)
+                deleteLine(R);
+            break;
+          case 'K':
+            if (debug > 1)
+              System.out.println("ESC [ " + DCEvars[0] + " K");
+            /* clear in line */
+            switch (DCEvars[0]) {
+              case 6: /* 97801 uses ESC[6K for delete to end of line */
+              case 0:/*clear to right*/
+                if (C < columns - 1)
+                  deleteArea(C, R, columns - C, 1, attributes);
+                break;
+              case 1:/*clear to the left, including this */
+                if (C > 0)
+                  deleteArea(0, R, C + 1, 1, attributes);
+                break;
+              case 2:/*clear whole line */
+                deleteArea(0, R, columns, 1, attributes);
+                break;
+            }
+            break;
+          case 'J':
+            /* clear below current line */
+            switch (DCEvars[0]) {
+              case 0:
+                if (R < rows - 1)
+                  deleteArea(0, R + 1, columns, rows - R - 1, attributes);
+                if (C < columns - 1)
+                  deleteArea(C, R, columns - C, 1, attributes);
+                break;
+              case 1:
+                if (R > 0)
+                  deleteArea(0, 0, columns, R, attributes);
+                if (C > 0)
+                  deleteArea(0, R, C + 1, 1, attributes);// include up to and including current
+                break;
+              case 2:
+                deleteArea(0, 0, columns, rows, attributes);
+                break;
+            }
+            if (debug > 1)
+              System.out.println("ESC [ " + DCEvars[0] + " J");
+            break;
+          case '@':
+            if (debug > 1)
+              System.out.println("ESC [ " + DCEvars[0] + " @");
+            for (int i = 0; i < DCEvars[0]; i++)
+              insertChar(C, R, ' ', attributes);
+            break;
+          case 'X':
+            {
+              int toerase = DCEvars[0];
+              if (debug > 1)
+                System.out.println("ESC [ " + DCEvars[0] + " X, C=" + C + ",R=" + R);
+              if (toerase == 0)
+                toerase = 1;
+              if (toerase + C > columns)
+                toerase = columns - C;
+              deleteArea(C, R, toerase, 1, attributes);
+              // does not change cursor position
+              break;
+            }
+          case 'P':
+            if (debug > 1)
+              System.out.println("ESC [ " + DCEvars[0] + " P, C=" + C + ",R=" + R);
+            if (DCEvars[0] == 0) DCEvars[0] = 1;
+            for (int i = 0; i < DCEvars[0]; i++)
+              deleteChar(C, R);
+            break;
+          case 'n':
+            switch (DCEvars[0]) {
+              case 5: /* malfunction? No malfunction. */
+                writeSpecial(((char) ESC) + "[0n");
+                if (debug > 1)
+                  System.out.println("ESC[5n");
+                break;
+              case 6:
+                // DO NOT offset R and C by 1! (checked against /usr/X11R6/bin/resize
+                // FIXME check again.
+                // FIXME: but vttest thinks different???
+                writeSpecial(((char) ESC) + "[" + R + ";" + C + "R");
+                if (debug > 1)
+                  System.out.println("ESC[6n");
+                break;
+              default:
+                if (debug > 0)
+                  System.out.println("ESC [ " + DCEvars[0] + " n??");
+                break;
+            }
+            break;
+          case 's':  /* DECSC - save cursor */
+            Sc = C;
+            Sr = R;
+            Sa = attributes;
+            if (debug > 3)
+              System.out.println("ESC[s");
+            break;
+          case 'u': /* DECRC - restore cursor */
+            C = Sc;
+            R = Sr;
+            attributes = Sa;
+            if (debug > 3)
+              System.out.println("ESC[u");
+            break;
+          case 'm':  /* attributes as color, bold , blink,*/
+            if (debug > 3)
+              System.out.print("ESC [ ");
+            if (DCEvar == 0 && DCEvars[0] == 0)
+              attributes = 0;
+            for (int i = 0; i <= DCEvar; i++) {
+              switch (DCEvars[i]) {
+                case 0:
+                  if (DCEvar > 0) {
+                    if (terminalID.equals("scoansi")) {
+                      attributes &= COLOR; /* Keeps color. Strange but true. */
+                    } else {
+                      attributes = 0;
+                    }
+                  }
+                  break;
+                case 1:
+                  attributes |= BOLD;
+                  attributes &= ~LOW;
+                  break;
+                case 2:
+                  /* SCO color hack mode */
+                  if (terminalID.equals("scoansi") && ((DCEvar - i) >= 2)) {
+                    int ncolor;
+                    attributes &= ~(COLOR | BOLD);
+
+                    ncolor = DCEvars[i + 1];
+                    if ((ncolor & 8) == 8)
+                      attributes |= BOLD;
+                    ncolor = ((ncolor & 1) << 2) | (ncolor & 2) | ((ncolor & 4) >> 2);
+                    attributes |= ((ncolor) + 1) << COLOR_FG_SHIFT;
+                    ncolor = DCEvars[i + 2];
+                    ncolor = ((ncolor & 1) << 2) | (ncolor & 2) | ((ncolor & 4) >> 2);
+                    attributes |= ((ncolor) + 1) << COLOR_BG_SHIFT;
+                    i += 2;
+                  } else {
+                    attributes |= LOW;
+                  }
+                  break;
+                case 4:
+                  attributes |= UNDERLINE;
+                  break;
+                case 7:
+                  attributes |= INVERT;
+                  break;
+                case 8:
+                  attributes |= INVISIBLE;
+                  break;
+                case 5: /* blink on */
+                  break;
+                  /* 10 - ANSI X3.64-1979, select primary font, don't display control
+                   *      chars, don't set bit 8 on output */
+                case 10:
+                  gl = 0;
+                  usedcharsets = true;
+                  break;
+                  /* 11 - ANSI X3.64-1979, select second alt. font, display control
+                   *      chars, set bit 8 on output */
+                case 11: /* SMACS , as */
+                case 12:
+                  gl = 1;
+                  usedcharsets = true;
+                  break;
+                case 21: /* normal intensity */
+                  attributes &= ~(LOW | BOLD);
+                  break;
+                case 25: /* blinking off */
+                  break;
+                case 27:
+                  attributes &= ~INVERT;
+                  break;
+                case 28:
+                  attributes &= ~INVISIBLE;
+                  break;
+                case 24:
+                  attributes &= ~UNDERLINE;
+                  break;
+                case 22:
+                  attributes &= ~BOLD;
+                  break;
+                case 30:
+                case 31:
+                case 32:
+                case 33:
+                case 34:
+                case 35:
+                case 36:
+                case 37:
+                  attributes &= ~COLOR_FG;
+                  attributes |= ((DCEvars[i] - 30) + 1) << COLOR_FG_SHIFT;
+                  break;
+                case 39:
+                  attributes &= ~COLOR_FG;
+                  break;
+                case 40:
+                case 41:
+                case 42:
+                case 43:
+                case 44:
+                case 45:
+                case 46:
+                case 47:
+                  attributes &= ~COLOR_BG;
+                  attributes |= ((DCEvars[i] - 40) + 1) << COLOR_BG_SHIFT;
+                  break;
+                case 49:
+                  attributes &= ~COLOR_BG;
+                  break;
+
+                default:
+                  System.out.println("ESC [ " + DCEvars[i] + " m unknown...");
+                  break;
+              }
+              if (debug > 3)
+                System.out.print("" + DCEvars[i] + ";");
+            }
+            if (debug > 3)
+              System.out.print(" (attributes = " + attributes + ")m \n");
+            break;
+          default:
+            System.out.println("ESC [ unknown letter:" + c + " (" + ((int) c) + ")");
+            break;
+        }
+        break;
+      default:
+        term_state = TSTATE_DATA;
+        break;
+    }
+    if (C > columns) C = columns;
+    if (R > rows) R = rows;
+    if (C < 0) C = 0;
+    if (R < 0) R = 0;
+    if (doshowcursor)
+      setCursorPosition(C, R);
+    markLine(R, 1);
+  }
+
+  /* hard reset the terminal */
+  public void reset() {
+    gx[0] = 'B';
+    gx[1] = '0';
+    gx[2] = 'B';
+    gx[3] = 'B';
+    gl = 0;  // default GL to G0
+    gr = 1;  // default GR to G1
+    /* reset tabs */
+    int nw = getColumns();
+    if (nw < 132) nw = 132;
+    Tabs = new byte[nw];
+    for (int i = 0; i < nw; i += 8) {
+      Tabs[i] = 1;
+    }
+    /*FIXME:*/
+    term_state = TSTATE_DATA;
+  }
+}
diff --git a/src/org/theb/provider/HostDb.java b/src/org/theb/provider/HostDb.java
index 3bed790..e38396c 100644
--- a/src/org/theb/provider/HostDb.java
+++ b/src/org/theb/provider/HostDb.java
@@ -1,3 +1,21 @@
+/*
+ * Copyright (C) 2007 Kenny Root (kenny at the-b.org)
+ * 
+ * This file is part of Connectbot.
+ *
+ *  Connectbot 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.
+ *
+ *  Connectbot 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 Connectbot.  If not, see <http://www.gnu.org/licenses/>.
+ */
 package org.theb.provider;
 
 import android.net.ContentURI;
diff --git a/src/org/theb/ssh/ConnectionThread.java b/src/org/theb/ssh/ConnectionThread.java
new file mode 100644
index 0000000..a201e62
--- /dev/null
+++ b/src/org/theb/ssh/ConnectionThread.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2007 Kenny Root (kenny at the-b.org)
+ * 
+ * This file is part of Connectbot.
+ *
+ *  Connectbot 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.
+ *
+ *  Connectbot 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 Connectbot.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.theb.ssh;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public abstract class ConnectionThread extends Thread {
+	public ConnectionThread(FeedbackUI ui, String hostname, String username, int port) {}
+	public abstract void finish();
+	public abstract InputStream getReader();
+	public abstract OutputStream getWriter();
+	public abstract void setPassword(String password);
+}
diff --git a/src/org/theb/ssh/FeedbackUI.java b/src/org/theb/ssh/FeedbackUI.java
new file mode 100644
index 0000000..ba4ae03
--- /dev/null
+++ b/src/org/theb/ssh/FeedbackUI.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2007 Kenny Root (kenny at the-b.org)
+ * 
+ * This file is part of Connectbot.
+ *
+ *  Connectbot 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.
+ *
+ *  Connectbot 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 Connectbot.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.theb.ssh;
+
+public interface FeedbackUI {
+	public void connectionLost(Throwable reason);
+	public void setWaiting(boolean isWaiting, String title, String message);
+	public void askPassword();
+}
diff --git a/src/org/theb/ssh/HostDbProvider.java b/src/org/theb/ssh/HostDbProvider.java
index 20ec224..f0eac73 100644
--- a/src/org/theb/ssh/HostDbProvider.java
+++ b/src/org/theb/ssh/HostDbProvider.java
@@ -1,3 +1,21 @@
+/*
+ * Copyright (C) 2007 Kenny Root (kenny at the-b.org)
+ * 
+ * This file is part of Connectbot.
+ *
+ *  Connectbot 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.
+ *
+ *  Connectbot 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 Connectbot.  If not, see <http://www.gnu.org/licenses/>.
+ */
 package org.theb.ssh;
 
 import java.util.HashMap;
diff --git a/src/org/theb/ssh/HostEditor.java b/src/org/theb/ssh/HostEditor.java
index d642fd4..967cf5b 100644
--- a/src/org/theb/ssh/HostEditor.java
+++ b/src/org/theb/ssh/HostEditor.java
@@ -1,3 +1,21 @@
+/*
+ * Copyright (C) 2007 Kenny Root (kenny at the-b.org)
+ * 
+ * This file is part of Connectbot.
+ *
+ *  Connectbot 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.
+ *
+ *  Connectbot 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 Connectbot.  If not, see <http://www.gnu.org/licenses/>.
+ */
 package org.theb.ssh;
 
 import org.theb.provider.HostDb;
diff --git a/src/org/theb/ssh/HostsList.java b/src/org/theb/ssh/HostsList.java
index 4d9e398..7114497 100644
--- a/src/org/theb/ssh/HostsList.java
+++ b/src/org/theb/ssh/HostsList.java
@@ -1,3 +1,21 @@
+/*
+ * Copyright (C) 2007 Kenny Root (kenny at the-b.org)
+ * 
+ * This file is part of Connectbot.
+ *
+ *  Connectbot 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.
+ *
+ *  Connectbot 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 Connectbot.  If not, see <http://www.gnu.org/licenses/>.
+ */
 package org.theb.ssh;
 
 import org.theb.provider.HostDb;
diff --git a/src/org/theb/ssh/InteractiveHostKeyVerifier.java b/src/org/theb/ssh/InteractiveHostKeyVerifier.java
index a461724..7c21f80 100644
--- a/src/org/theb/ssh/InteractiveHostKeyVerifier.java
+++ b/src/org/theb/ssh/InteractiveHostKeyVerifier.java
@@ -1,3 +1,21 @@
+/*
+ * Copyright (C) 2007 Kenny Root (kenny at the-b.org)
+ * 
+ * This file is part of Connectbot.
+ *
+ *  Connectbot 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.
+ *
+ *  Connectbot 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 Connectbot.  If not, see <http://www.gnu.org/licenses/>.
+ */
 package org.theb.ssh;
 
 import com.trilead.ssh2.ServerHostKeyVerifier;
diff --git a/src/org/theb/ssh/JCTerminalView.java b/src/org/theb/ssh/JCTerminalView.java
new file mode 100644
index 0000000..47d12aa
--- /dev/null
+++ b/src/org/theb/ssh/JCTerminalView.java
@@ -0,0 +1,329 @@
+/*
+ * Copyright (C) 2007 Kenny Root (kenny at the-b.org)
+ * 
+ * This file is part of Connectbot.
+ *
+ *  Connectbot 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.
+ *
+ *  Connectbot 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 Connectbot.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.theb.ssh;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.UnsupportedEncodingException;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.PixelXorXfermode;
+import android.graphics.Typeface;
+import android.graphics.Paint.FontMetricsInt;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.View;
+
+import com.jcraft.jcterm.Emulator;
+import com.jcraft.jcterm.EmulatorVT100;
+import com.jcraft.jcterm.Term;
+
+public class JCTerminalView extends View implements Term, Terminal {
+	private final Paint mPaint;
+	private Bitmap mBitmap;
+	private Canvas mCanvas;
+
+	private final Paint mCursorPaint;
+	
+	private Emulator emulator = null;
+	
+	private boolean mBold = false;
+	private boolean mUnderline = false;
+	private boolean mReverse = false;
+	
+	private int mDefaultForeground = Color.WHITE;
+	private int mDefaultBackground = Color.BLACK;
+	private int mForeground = Color.WHITE;
+	private int mBackground = Color.BLACK;
+	
+	private boolean mAntialias = true;
+	
+	private int mTermWidth = 80;
+	private int mTermHeight = 24;
+	
+	private int mCharHeight;
+	private int mCharWidth;
+	private int mDescent;
+	
+	
+	// Cursor location
+	private int x = 0;
+	private int y = 0;
+	
+	private final Object[] mColors = {Color.BLACK, Color.RED, Color.GREEN, Color.YELLOW,
+			Color.BLUE, Color.MAGENTA, Color.CYAN, Color.WHITE};
+	
+	public JCTerminalView(Context c) {
+		super(c);
+		mPaint = new Paint();
+		mPaint.setAntiAlias(mAntialias);
+		mPaint.setColor(mDefaultForeground);
+		
+		mCursorPaint = new Paint();
+		mCursorPaint.setAntiAlias(mAntialias);
+		mCursorPaint.setColor(mDefaultForeground);
+		mCursorPaint.setXfermode(new PixelXorXfermode(mDefaultBackground));
+		
+		setFont(Typeface.MONOSPACE);
+	}
+
+	@Override
+	protected void onDraw(Canvas canvas) {
+		if (mBitmap != null) {
+			canvas.drawBitmap(mBitmap, 0, 0, null);
+			
+			if (mCharHeight > 0 && y > mCharHeight) {
+				// Invert pixels for cursor position.
+				canvas.drawRect(x, y - mCharHeight, x + mCharWidth, y, mCursorPaint);
+			}
+		}
+	}
+ 
+	@Override
+	protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+		Log.d("SSH/TerminalView", "onSizeChanged called");
+		Bitmap newBitmap = Bitmap.createBitmap(w, h, false);
+		Canvas newCanvas = new Canvas();
+		
+		newCanvas.setDevice(newBitmap);
+		
+		if (mBitmap != null)
+			newCanvas.drawBitmap(mBitmap, 0, 0, mPaint);
+		
+		mBitmap = newBitmap;
+		mCanvas = newCanvas;
+		
+		setSize(w, h);
+	}
+	
+	private void setSize(int w, int h) {
+		int column = w / getCharWidth();
+		int row = h / getCharHeight();
+		
+		mTermWidth = column;
+		mTermHeight = row;
+		
+		if (emulator != null)
+			emulator.reset();
+		
+		clear_area(0, 0, w, h);
+		
+		// TODO: finish this method
+	}
+
+	private void setFont(Typeface typeface) {
+		mPaint.setTypeface(typeface);
+		mPaint.setTextSize(8);
+		FontMetricsInt fm = mPaint.getFontMetricsInt();
+		mDescent = fm.descent;
+		
+		float[] widths = new float[1];
+		mPaint.getTextWidths("X", widths);
+		mCharWidth = (int)widths[0];
+		
+		// Is this right?
+		mCharHeight = Math.abs(fm.top) + Math.abs(fm.descent);
+		Log.d("SSH", "character height is " + mCharHeight);
+		// mCharHeight += mLineSpace * 2;
+		// mDescent += mLineSpace;
+	}
+
+	public void beep() {
+		// TODO Auto-generated method stub
+		
+	}
+
+	public void clear() {
+		mPaint.setColor(getBackgroundColor());
+		mCanvas.drawRect(0, 0, mCanvas.getBitmapWidth(),
+				mCanvas.getBitmapHeight(), mPaint);
+		mPaint.setColor(getForegroundColor());
+	}
+
+	private int getBackgroundColor() {
+		if (mReverse)
+			return mForeground;
+		return mBackground;
+	}
+	
+	private int getForegroundColor() {
+		if (mReverse)
+			return mBackground;
+		return mForeground;
+	}
+
+	public void clear_area(int x1, int y1, int x2, int y2) {
+		mPaint.setColor(getBackgroundColor());
+		if (mCanvas != null)
+			mCanvas.drawRect(x1, y1, x2, y2, mPaint);
+		mPaint.setColor(getForegroundColor());
+	}
+
+	public void drawBytes(byte[] buf, int s, int len, int x, int y) {
+		String chars = null;
+		try {
+			chars = new String(buf, "ASCII");
+			drawString(chars.substring(s, s+len), x, y);
+		} catch (UnsupportedEncodingException e) {
+			// TODO Auto-generated catch block
+			Log.e("SSH", "Can't convert bytes to ASCII");
+		}
+	}
+
+	public void drawString(String str, int x, int y) {
+		mPaint.setFakeBoldText(mBold);
+		mPaint.setUnderlineText(mUnderline);
+		mCanvas.drawText(str, x, y - mDescent, mPaint);
+	}
+
+	public void draw_cursor() {
+		postInvalidate();
+	}
+
+	public int getCharHeight() {
+		return mCharHeight;
+	}
+
+	public int getCharWidth() {
+		return mCharWidth;
+	}
+
+	public Object getColor(int index) {
+		if (mColors == null || index < 0 || mColors.length <= index)
+			return null;
+		return mColors[index];
+	}
+
+	public int getColumnCount() {
+		return mTermWidth;
+	}
+
+	public int getRowCount() {
+		return mTermHeight;
+	}
+
+	public int getTermHeight() {
+		return mTermHeight * mCharHeight;
+	}
+
+	public int getTermWidth() {
+		return mTermWidth * mCharWidth;
+	}
+
+	public void redraw(int x, int y, int width, int height) {
+		//invalidate(x, y, x+width, y+height);
+		postInvalidate();
+	}
+
+	public void resetAllAttributes() {
+		mBold = false;
+		mUnderline = false;
+		mReverse = false;
+		
+		mBackground = mDefaultBackground;
+		mForeground = mDefaultForeground;
+		
+		if (mPaint != null)
+			mPaint.setColor(mForeground);
+	}
+
+	public void scroll_area(int x, int y, int w, int h, int dx, int dy) {
+		// TODO: make scrolling more efficient (memory-wise)
+		mCanvas.drawBitmap(Bitmap.createBitmap(mBitmap, x, y, w, h), x+dx, y+dy, null);
+	}
+
+	private int toColor(Object o) {
+		if (o instanceof Integer) {
+			return ((Integer)o).intValue();
+		}
+		
+		if (o instanceof String) {
+			return Color.parseColor((String)o);
+		}
+		
+		return Color.WHITE;
+	}
+	
+	public void setBackGround(Object background) {
+		mBackground = toColor(background);
+	}
+
+	public void setBold() {
+		mBold = true;
+	}
+
+	public void setCursor(int x, int y) {
+		// Make sure we don't go outside the bounds of the window.
+		this.x = Math.max(
+				Math.min(x, getWidth() - mCharWidth),
+				0);
+		this.y = Math.max(
+				Math.min(y, getHeight()),
+				mCharHeight);
+	}
+
+	public void setDefaultBackGround(Object background) {
+		mDefaultBackground = toColor(background);
+	}
+
+	public void setDefaultForeGround(Object foreground) {
+		mDefaultForeground = toColor(foreground);
+	}
+
+	public void setForeGround(Object foreground) {
+		mForeground = toColor(foreground);
+	}
+
+	public void setReverse() {
+		mReverse = true;
+		if (mPaint != null)
+			mPaint.setColor(getForegroundColor());
+	}
+
+	public void setUnderline() {
+		mUnderline = true;
+	}
+
+	public void start(InputStream in, OutputStream out) {
+		emulator = new EmulatorVT100(this, in);
+		emulator.reset();
+		emulator.start();
+		
+		clear();
+	}
+
+	public byte[] getKeyCode(int keyCode, int meta) {
+		if (keyCode == KeyEvent.KEYCODE_NEWLINE)
+			return emulator.getCodeENTER();
+		else if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT)
+			return emulator.getCodeLEFT();
+		else if (keyCode == KeyEvent.KEYCODE_DPAD_UP)
+			return emulator.getCodeUP();
+		else if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN)
+			return emulator.getCodeDOWN();
+		else if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT)
+			return emulator.getCodeRIGHT();
+		else
+			return null;
+	}
+}
diff --git a/src/org/theb/ssh/JTATerminalView.java b/src/org/theb/ssh/JTATerminalView.java
new file mode 100644
index 0000000..2238f02
--- /dev/null
+++ b/src/org/theb/ssh/JTATerminalView.java
@@ -0,0 +1,323 @@
+package org.theb.ssh;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import de.mud.terminal.SoftFont;
+import de.mud.terminal.VDUBuffer;
+import de.mud.terminal.VDUDisplay;
+import de.mud.terminal.vt320;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.Typeface;
+import android.graphics.Paint.FontMetricsInt;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.View;
+
+public class JTATerminalView extends View implements VDUDisplay, Terminal, Runnable {
+	private Paint paint;
+	private Canvas canvas;
+	private Bitmap bitmap;
+	
+	protected vt320 emulation;
+	private VDUBuffer buffer;
+	
+	private InputStream in;
+	private OutputStream out;
+
+	private String encoding = "ASCII";
+	private SoftFont sf = new SoftFont();
+	
+	private Thread reader = null;
+	
+	private int charWidth;
+	private int charHeight;
+	private int charDescent;
+	
+	private int termWidth;
+	private int termHeight;
+	
+	private int color[] = {
+			Color.BLACK,
+			Color.RED,
+			Color.GREEN,
+			Color.YELLOW,
+			Color.BLUE,
+			Color.MAGENTA,
+			Color.CYAN,
+			Color.WHITE,
+	};
+	
+	private final static int COLOR_FG_STD = 7;
+	private final static int COLOR_BG_STD = 0;
+	
+	public JTATerminalView(Context context) {
+		super(context);
+		
+		paint = new Paint();
+		paint.setAntiAlias(true);
+		setFont(Typeface.MONOSPACE, 8);
+
+		emulation = new vt320() {
+			public void write(byte[] b) {
+				try {
+					JTATerminalView.this.write(b);
+				} catch (IOException e) {
+					Log.e("SSH", "couldn't write" + b.toString());
+					reader = null;
+				}
+			}
+			
+			public void sendTelnetCommand(byte cmd) {
+				// TODO: implement telnet command sending
+			}
+			
+			public void setWindowSize(int c, int r) {
+				// TODO: implement window sizing
+			}
+		};
+		
+		setVDUBuffer(emulation);
+		emulation.setDisplay(this);
+	}
+
+	@Override
+	protected void onDraw(Canvas canvas) {
+		if (bitmap != null) {
+			canvas.drawBitmap(bitmap, 0, 0, null);
+			/*
+			if (charHeight > 0 && y > charHeight) {
+				// Invert pixels for cursor position.
+				Bitmap cursor = Bitmap.createBitmap(mBitmap, x, y - mCharHeight, mCharWidth, mCharHeight);
+				for (int cy = 0; cy < mCharHeight; cy++)
+					for (int cx = 0; cx < mCharWidth; cx++)
+						cursor.setPixel(cx, cy, (~cursor.getPixel(cx, cy) & 0xFFFFFFFF) | 0xFF000000);
+				canvas.drawBitmap(cursor, x, y - mCharHeight, null);
+				cursor = null;
+			}
+			*/
+		}
+	}
+ 
+	@Override
+	protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+		Log.d("SSH/TerminalView", "onSizeChanged called");
+		Bitmap newBitmap = Bitmap.createBitmap(w, h, false);
+		Canvas newCanvas = new Canvas();
+		
+		newCanvas.setDevice(newBitmap);
+		
+		if (bitmap != null)
+			newCanvas.drawBitmap(bitmap, 0, 0, paint);
+		
+		bitmap = newBitmap;
+		canvas = newCanvas;
+		
+		setSize(w, h);
+	}
+	
+	private void setSize(int w, int h) {
+		termWidth = w / charWidth;
+		termHeight = h / charHeight;
+		
+		buffer.setScreenSize(termWidth, buffer.height = termHeight, true);
+	}
+
+	private void setFont(Typeface typeface, int size) {
+		paint.setTypeface(typeface);
+		paint.setTextSize(size);
+		
+		FontMetricsInt fm = paint.getFontMetricsInt();
+		
+		charDescent = fm.descent;
+		
+		float[] widths = new float[1];
+		paint.getTextWidths("X", widths);
+		charWidth = (int)widths[0];
+		
+		charHeight = Math.abs(fm.top) + Math.abs(fm.descent);
+	}
+	
+	public void write(byte[] b) throws IOException {
+		Log.e("SSH/JTATerm/write", "Trying to write" + b.toString());
+		out.write(b);
+	}
+	
+	public int getColumnCount() {
+		return termWidth;
+	}
+
+	public InputStream getInput() {
+		return in;
+	}
+
+	public byte[] getKeyCode(int keyCode, int meta) {
+		switch (keyCode) {
+		case KeyEvent.KEYCODE_NEWLINE:
+			emulation.keyTyped(vt320.KEY_ENTER, ' ', meta);
+			break;
+		case KeyEvent.KEYCODE_DPAD_LEFT:
+			emulation.keyPressed(vt320.KEY_LEFT, ' ', meta);
+			break;
+		case KeyEvent.KEYCODE_DPAD_UP:
+			emulation.keyPressed(vt320.KEY_UP, ' ', meta);
+			break;
+		case KeyEvent.KEYCODE_DPAD_DOWN:
+			emulation.keyPressed(vt320.KEY_DOWN, ' ', meta) ;
+			break;
+		case KeyEvent.KEYCODE_DPAD_RIGHT:
+			emulation.keyPressed(vt320.KEY_RIGHT, ' ', meta);
+			break;
+		}
+		return null;
+	}
+
+	public OutputStream getOutput() {
+		return out;
+	}
+
+	public int getRowCount() {
+		return termHeight;
+	}
+
+	private int darken(int color) {
+		return Color.argb(0xFF,
+			(int)(Color.red(color) * 0.8),
+			(int)(Color.green(color) * 0.8),
+			(int)(Color.blue(color) * 0.8)
+		);
+	}
+	
+	/*
+	private int brighten(int color) {
+		return Color.argb(0xFF,
+			(int)(Color.red(color) * 1.2),
+			(int)(Color.green(color) * 1.2),
+			(int)(Color.blue(color) * 1.2)
+		);
+	}
+	*/
+	
+	public void redraw() {
+		// Make sure the buffer is in the center of the screen.
+		int xoffset = (getWidth() - buffer.width * charWidth) / 2;
+		int yoffset = (getHeight() - buffer.height * charHeight) / 2;
+		
+		// Draw the mouse-selection
+		//int selectStartLine = selectBegin.y - buffer.windowBase;
+		//int selectEndLine = selectEnd.y - buffer.windowBase;
+		
+		int fg, bg;
+		
+		for (int l = 0; l < buffer.height; l++) {
+			if (!buffer.update[0] && !buffer.update[l + 1]) continue;
+			
+			for (int c = 0; c < buffer.width; c++) {
+				int addr = 0;
+				int currAttr = buffer.charAttributes[buffer.windowBase + l][c];
+				
+				fg = darken(color[COLOR_FG_STD]);
+				bg = darken(color[COLOR_BG_STD]);
+				
+				if ((currAttr & VDUBuffer.COLOR_FG) != 0)
+					fg = darken(color[((currAttr & VDUBuffer.COLOR_FG) >> VDUBuffer.COLOR_FG_SHIFT) - 1]);
+				if ((currAttr & VDUBuffer.COLOR_BG) != 0)
+					bg = darken(darken(color[((currAttr & VDUBuffer.COLOR_BG) >> VDUBuffer.COLOR_BG_SHIFT) - 1]));
+				paint.setFakeBoldText((currAttr & VDUBuffer.BOLD) != 0);
+				
+				if ((currAttr & VDUBuffer.LOW) != 0)
+					fg = darken(fg);
+				
+				if ((currAttr & VDUBuffer.INVERT) != 0) {
+					int swapc = bg;
+					bg = fg;
+					fg = swapc;
+				}
+				
+				// If this character is in the special font, print it and continue to the next character.
+				if (sf.inSoftFont(buffer.charArray[buffer.windowBase + l][c])) {
+					paint.setColor(bg);
+					canvas.drawRect(c * charWidth + xoffset, l * charHeight + yoffset,
+							c * (charWidth + 1) + xoffset, (l+1) * charHeight + yoffset, paint);
+					paint.setColor(fg);
+					paint.setUnderlineText((currAttr & VDUBuffer.UNDERLINE) != 0);
+					if ((currAttr & VDUBuffer.INVISIBLE) == 0)
+						sf.drawChar(canvas, paint, buffer.charArray[buffer.windowBase + l][c], xoffset + c * charWidth, l * charHeight + yoffset, charWidth, charHeight);
+					continue;
+				}
+				
+				// Determine the amount of continuous characters with the same settings and print them all at once.
+				while ((c + addr < buffer.width) &&
+						((buffer.charArray[buffer.windowBase + l][c + addr] < ' ') ||
+								(buffer.charAttributes[buffer.windowBase + l][c + addr] == currAttr)) &&
+								!sf.inSoftFont(buffer.charArray[buffer.windowBase + l][c + addr])) {
+					if (buffer.charArray[buffer.windowBase + l][c + addr] < ' ') {
+						buffer.charArray[buffer.windowBase + l][c + addr] = ' ';
+						buffer.charAttributes[buffer.windowBase + l][c + addr] = 0;
+						continue;
+					}
+					addr++;
+				}
+				
+				paint.setColor(bg);
+				canvas.drawRect(c * charWidth + xoffset, l * charHeight + yoffset,
+						addr * (charWidth + 1) + xoffset, (l+1) * charHeight + yoffset, paint);
+				paint.setColor(fg);
+				
+				paint.setUnderlineText((currAttr & VDUBuffer.UNDERLINE) != 0);
+				if ((currAttr & VDUBuffer.INVISIBLE) == 0)
+					canvas.drawText(buffer.charArray[buffer.windowBase + l],
+							c, addr,
+							c * charWidth + xoffset,
+							(l + 1) * charHeight - charDescent + yoffset,
+							paint);
+				
+				c += addr - 1;
+			}
+		}
+		
+		buffer.update[0] = false;
+		
+		postInvalidate();
+	}
+
+	public void updateScrollBar() {
+		// TODO Auto-generated method stub
+	}
+
+	public void start(InputStream in, OutputStream out) {
+		this.in = in;
+		this.out = out;
+		
+		reader = new Thread(this);
+		reader.start();
+	}
+
+	public VDUBuffer getVDUBuffer() {
+		return buffer;
+	}
+
+	public void setVDUBuffer(VDUBuffer buffer) {
+		this.buffer = buffer;
+	}
+
+	public void run() {
+		byte[] b = new byte[256];
+		int n = 0;
+		while (n >= 0)
+			try {
+				n = in.read(b);
+				if (n > 0) emulation.putString(new String(b, 0, n, encoding));
+				redraw();
+			} catch (IOException e) {
+				reader = null;
+				break;
+			}
+	}
+}
diff --git a/src/org/theb/ssh/PasswordDialog.java b/src/org/theb/ssh/PasswordDialog.java
index 87839b7..faf636a 100644
--- a/src/org/theb/ssh/PasswordDialog.java
+++ b/src/org/theb/ssh/PasswordDialog.java
@@ -1,3 +1,21 @@
+/*
+ * Copyright (C) 2007 Kenny Root (kenny at the-b.org)
+ * 
+ * This file is part of Connectbot.
+ *
+ *  Connectbot 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.
+ *
+ *  Connectbot 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 Connectbot.  If not, see <http://www.gnu.org/licenses/>.
+ */
 package org.theb.ssh;
 
 import android.app.Activity;
diff --git a/src/org/theb/ssh/PreferencesDialog.java b/src/org/theb/ssh/PreferencesDialog.java
new file mode 100644
index 0000000..06bc229
--- /dev/null
+++ b/src/org/theb/ssh/PreferencesDialog.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2007 Kenny Root (kenny at the-b.org)
+ * 
+ * This file is part of Connectbot.
+ *
+ *  Connectbot 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.
+ *
+ *  Connectbot 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 Connectbot.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.theb.ssh;
+
+import android.app.Dialog;
+import android.content.Context;
+
+public class PreferencesDialog extends Dialog {
+
+	public PreferencesDialog(Context context) {
+		super(context);
+		// TODO Auto-generated constructor stub
+	}
+
+	public PreferencesDialog(Context context, int theme) {
+		super(context, theme);
+		// TODO Auto-generated constructor stub
+	}
+
+	public PreferencesDialog(Context context, boolean cancelable,
+			OnCancelListener cancelListener) {
+		super(context, cancelable, cancelListener);
+		// TODO Auto-generated constructor stub
+	}
+
+}
diff --git a/src/org/theb/ssh/SecureShell.java b/src/org/theb/ssh/SecureShell.java
index 31625f9..8d4dda6 100644
--- a/src/org/theb/ssh/SecureShell.java
+++ b/src/org/theb/ssh/SecureShell.java
@@ -1,12 +1,30 @@
+/*
+ * Copyright (C) 2007 Kenny Root (kenny at the-b.org)
+ * 
+ * This file is part of Connectbot.
+ *
+ *  Connectbot 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.
+ *
+ *  Connectbot 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 Connectbot.  If not, see <http://www.gnu.org/licenses/>.
+ */
 package org.theb.ssh;
 
 import java.io.IOException;
-import java.io.InputStream;
 import java.io.OutputStream;
-import java.util.concurrent.Semaphore;
 
 import org.theb.provider.HostDb;
 
+import com.trilead.ssh2.ConnectionMonitor;
+
 import android.app.Activity;
 import android.app.AlertDialog;
 import android.app.ProgressDialog;
@@ -17,22 +35,16 @@ import android.os.Handler;
 import android.text.method.KeyCharacterMap;
 import android.util.Log;
 import android.view.KeyEvent;
+import android.view.View;
 import android.view.Window;
-import android.widget.TextView;
-
-import com.trilead.ssh2.ChannelCondition;
-import com.trilead.ssh2.Connection;
-import com.trilead.ssh2.ConnectionMonitor;
-import com.trilead.ssh2.Session;
 
-public class SecureShell extends Activity {
-	private TextView mOutput;
+public class SecureShell extends Activity implements FeedbackUI, ConnectionMonitor {
 	private ConnectionThread mConn;
-	private String mBuffer;
-	private KeyCharacterMap mKMap;
 	
+	// Activities we support.
 	static final int PASSWORD_REQUEST = 0;
 	
+	// Database projection indices.
 	private static final int HOSTNAME_INDEX = 1;
 	private static final int USERNAME_INDEX = 2;
 	private static final int PORT_INDEX = 3;
@@ -46,6 +58,15 @@ public class SecureShell extends Activity {
 	
 	private Cursor mCursor;
 	
+	// Map to convert from keyboard presses to actual characters.
+	private KeyCharacterMap mKMap;
+
+	// Terminal window
+	private Terminal mTerminal;
+	
+	// We change the meta state when the user presses the center button.
+	private boolean mMetaState = false;
+	
 	// Store the username, hostname, and port from the database.
 	private String mHostname;
 	private String mUsername;
@@ -56,241 +77,21 @@ public class SecureShell extends Activity {
 	private boolean mIsWaiting;
 	private String mWaitingTitle;
 	private String mWaitingMessage;
-	
-	// Connection lost reason.
-	private String mDisconnectReason;
-	
-	// This is for the password dialog.
-	Semaphore sPass;
-	String mPassword = null;
-	
-	Connection conn;
-	Session sess;
-	InputStream stdin;
-	InputStream stderr;
-	OutputStream stdout;
-	int x;
-	int y;
-		
+
 	final Handler mHandler = new Handler();
 	
-	final Runnable mUpdateView = new Runnable() {
-		public void run() {
-			updateViewInUI();
-		}
-	};
-	
-	class ConnectionThread extends Thread {
-		String hostname;
-		String username;
-		int port;
-		
-		char[][] lines;
-		int posy = 0;
-		int posx = 0;
-		
-		public ConnectionThread(String hostname, String username, int port) {
-			this.hostname = hostname;
-			this.username = username;
-			this.port = port;
-		}
-		
-		public void run() {
-			conn = new Connection(hostname, port);
-
-			conn.addConnectionMonitor(mConnectionMonitor);
-			
-            setWaiting(true, "Connection",
-            		"Connecting to " + hostname + "...");
-			
-			Log.d("SSH", "Starting connection attempt...");
-
-	        try {
-				conn.connect(new InteractiveHostKeyVerifier());
-
-				setWaiting(true, "Authenticating",
-						"Trying to authenticate...");
-				
-				Log.d("SSH", "Starting authentication...");
-				
-//				boolean enableKeyboardInteractive = true;
-//				boolean enableDSA = true;
-//				boolean enableRSA = true;
-				
-				while (true) {
-					/*
-					if ((enableDSA || enableRSA ) &&
-							mConn.isAuthMethodAvailable(username, "publickey");
-							*/
-					
-					if (conn.isAuthMethodAvailable(username, "password")) {
-						Log.d("SSH", "Trying password authentication...");
-						setWaiting(true, "Authenticating",
-								"Trying to authenticate using password...");
-						
-						// Set a semaphore that is unset by the returning dialog.
-						sPass = new Semaphore(0);
-						askPassword();
-						
-						// Wait for the user to answer.
-						sPass.acquire();
-						sPass = null;
-						if (mPassword == null)
-							continue;
-						
-						boolean res = conn.authenticateWithPassword(username, mPassword);
-						if (res == true)
-							break;
-						
-						continue;
-					}
-					
-					throw new IOException("No supported authentication methods available.");
-				}
-				
-				Log.d("SSH", "Opening session...");
-				setWaiting(true, "Session", "Requesting shell...");
-				
-				sess = conn.openSession();
-				
-		        y = (int)(mOutput.getHeight() / mOutput.getLineHeight());
-		        // TODO: figure out how to get the width of monospace font characters.
-		        x = y * 3;
-		        Log.d("SSH", "Requesting PTY of size " + x + "x" + y);
-		        
-				sess.requestPTY("dumb", x, y, 0, 0, null);
-				
-				Log.d("SSH", "Requesting shell...");
-				sess.startShell();
-
-				stdout = sess.getStdin();
-				stderr = sess.getStderr();
-				stdin = sess.getStdout();
-
-				setWaiting(false, null, null);
-			} catch (IOException e) {
-				Log.e("SSH", e.getMessage());
-				setWaiting(false, null, null);
-				return;
-			} catch (InterruptedException e) {
-				// This thread is coming to an end. Let us exit.
-				Log.e("SSH", "Connection thread interrupted.");
-				return;
-			}
-			
-			byte[] buff = new byte[8192];
-			lines = new char[y][];
-			
-			try {
-				while (true) {
-					if ((stdin.available() == 0) && (stderr.available() == 0)) {
-						int conditions = sess.waitForCondition(
-								ChannelCondition.STDOUT_DATA
-								| ChannelCondition.STDERR_DATA
-								| ChannelCondition.EOF, 2000);
-						if ((conditions & ChannelCondition.TIMEOUT) != 0)
-							continue;
-						if ((conditions & ChannelCondition.EOF) != 0)
-							if ((conditions &
-									(ChannelCondition.STDERR_DATA
-											| ChannelCondition.STDOUT_DATA)) == 0)
-								break;
-					}
-					
-					if (stdin.available() > 0) {
-						int len = stdin.read(buff);
-						addText(buff, len);
-					}
-					if (stderr.available() > 0) {
-						int len = stderr.read(buff);
-						addText(buff, len);
-					}
-				}
-			} catch (Exception e) {
-				Log.e("SSH", "Got exception reading: " + e.getMessage());
-			}
-		}
-		
-		public void addText(byte[] data, int len) {
-			for (int i = 0; i < len; i++) {
-				char c = (char) (data[i] & 0xff);
-			
-				if (c == 8) { // Backspace, VERASE
-					if (posx < 0)
-						continue;
-					posx--;
-					continue;
-				}
-				if (c == '\r') {
-					posx = 0;
-					continue;
-				}
-
-				if (c == '\n') {
-					posy++;
-					if (posy >= y) {
-						for (int k = 1; k < y; k++)
-							lines[k - 1] = lines[k];
-						
-						posy--;
-						lines[y - 1] = new char[x];
-						
-						for (int k = 0; k < x; k++)
-							lines[y - 1][k] = ' ';
-					}
-					continue;
-				}
-
-				if (c < 32) {
-					continue;
-				}
-
-				if (posx >= x) {
-					posx = 0;
-					posy++;
-					if (posy >= y) {
-						posy--;
-						
-						for (int k = 1; k < y; k++)
-							lines[k - 1] = lines[k];
-						lines[y - 1] = new char[x];
-						for (int k = 0; k < x; k++)
-							lines[y - 1][k] = ' ';
-					}
-				}
-
-				if (lines[posy] == null) {
-					lines[posy] = new char[x];
-					for (int k = 0; k < x; k++)
-						lines[posy][k] = ' ';
-				}
+	// Tell the user why we disconnected.
+	private String mDisconnectReason;
 
-				lines[posy][posx] = c;
-				posx++;
-			}
-			
-			StringBuffer sb = new StringBuffer(x * y);
-			
-			for (int i = 0; i < lines.length; i++) {
-				if (i != 0)
-					sb.append('\n');
-				
-				if (lines[i] != null)
-					sb.append(lines[i]);
-			}
-			
-			mBuffer = sb.toString();
-			mHandler.post(mUpdateView);
-		}
-	}
-	
     @Override
     public void onCreate(Bundle savedValues) {
         super.onCreate(savedValues);
         
         requestWindowFeature(Window.FEATURE_PROGRESS);
-        setContentView(R.layout.secure_shell);
-        mOutput  = (TextView) findViewById(R.id.output);
+        mTerminal = new JTATerminalView(this);
+        
+        // TODO: implement scroll bar on right.
+        setContentView((View)mTerminal);
         
         Log.d("SSH", "using URI " + getIntent().getData().toString());
         
@@ -307,7 +108,7 @@ public class SecureShell extends Activity {
         
         this.setTitle(title);
         
-        mConn = new ConnectionThread(mHostname, mUsername, mPort);
+        mConn = new TrileadConnectionThread(this, mTerminal, mHostname, mUsername, mPort);
         
         mKMap = KeyCharacterMap.load(KeyCharacterMap.BUILT_IN_KEYBOARD);
 
@@ -340,10 +141,9 @@ public class SecureShell extends Activity {
 		}
 	};
 
-	public String askPassword() {
+	public void askPassword() {
     	Intent intent = new Intent(this, PasswordDialog.class);
     	this.startSubActivity(intent, PASSWORD_REQUEST);
-    	return null;
 	}
 
     @Override
@@ -351,55 +151,71 @@ public class SecureShell extends Activity {
             String data, Bundle extras)
 	{
 	    if (requestCode == PASSWORD_REQUEST) {
-	
-	        // If the request was cancelled, then we didn't get anything.
-	        if (resultCode == RESULT_CANCELED)
-				mPassword = "";
-			else
-	            mPassword = data;
-	        
-            sPass.release();
+	    	mConn.setPassword(data);
 	    }
 	}
     
 	@Override
     public void onDestroy() {
     	super.onDestroy();
-    	
-    	if (sess != null) {
-    		sess.close();
-    		sess = null;
-    	}
-    	
-    	if (conn != null) {
-    		conn.close();
-    		conn = null;
-    	}
+
+    	mConn.finish();
+    	mConn = null;
     	
     	finish();
     }
     
     @Override
     public boolean onKeyDown(int keyCode, KeyEvent msg) {
-    	if (stdout != null) {
-	    	int c = mKMap.get(keyCode, msg.getMetaState());
+    	final OutputStream out = mConn.getWriter();
+    	if (out != null) {
 	    	try {
-				stdout.write(c);
+	    		if (mKMap.isPrintingKey(keyCode)
+	    				|| keyCode == KeyEvent.KEYCODE_SPACE) {
+			    	int c = mKMap.get(keyCode, msg.getMetaState());
+			    	if (mMetaState) {
+			    		// Support CTRL-A through CTRL-Z
+			    		if (c >= 0x61 && c <= 0x79)
+			    			c -= 0x60;
+			    		else if (c >= 0x40 && c <= 0x59)
+			    			c -= 0x39;
+			    		mMetaState = false;
+			    	}
+					out.write(c);
+	    		} else	if (keyCode == KeyEvent.KEYCODE_DEL) {
+					out.write(0x08); // CTRL-H
+	    		} else if (keyCode == KeyEvent.KEYCODE_NEWLINE
+	    				|| keyCode == KeyEvent.KEYCODE_DPAD_LEFT
+	    				|| keyCode == KeyEvent.KEYCODE_DPAD_UP
+	    				|| keyCode == KeyEvent.KEYCODE_DPAD_DOWN
+	    				|| keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
+	    			byte[] output = mTerminal.getKeyCode(keyCode, msg.getMetaState());
+	    			if (output != null)
+	    				out.write(output);
+	    		} else if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
+	    			if (mMetaState) {
+	    				out.write(0x1B); // ESCAPE
+	    				mMetaState = false;
+	    			} else {
+	    				mMetaState = true;
+	    			}
+	    		} else {
+	    			// This is not something we handle.
+	    			return super.onKeyDown(keyCode, msg);
+	    		}
+				return true;
 			} catch (IOException e) {
-				// TODO Auto-generated catch block
-				e.printStackTrace();
+				Log.e("SSH", "Can't write to stdout: "+ e.getMessage());
 			}
     	}
-    	
-    	return super.onKeyDown(keyCode, msg);
-    }
-    
-    public void updateViewInUI() {
-    	mOutput.setText(mBuffer);
+		return super.onKeyDown(keyCode, msg);
     }
 
     final Runnable mDisconnectAlert = new Runnable() {
     	public void run() {
+    		if (SecureShell.this.isFinishing())
+    			return;
+    		
 			AlertDialog d = AlertDialog.show(SecureShell.this,
 					"Connection Lost", mDisconnectReason, "Ok", false);
 			d.show();
@@ -407,11 +223,9 @@ public class SecureShell extends Activity {
 	    }
     };
     
-    final ConnectionMonitor mConnectionMonitor = new ConnectionMonitor() {
-    	public void connectionLost(Throwable reason) {
-    		Log.d("SSH", "Connection ended.");
-    		mDisconnectReason = reason.getMessage();
-    		mHandler.post(mDisconnectAlert);
-    	}
-    };
+	public void connectionLost(Throwable reason) {
+		Log.d("SSH", "Connection ended.");
+		mDisconnectReason = reason.getMessage();
+		mHandler.post(mDisconnectAlert);
+	}
 }
diff --git a/src/org/theb/ssh/ShellView.java b/src/org/theb/ssh/ShellView.java
deleted file mode 100644
index 15d783b..0000000
--- a/src/org/theb/ssh/ShellView.java
+++ /dev/null
@@ -1,77 +0,0 @@
-package org.theb.ssh;
-
-import java.io.IOException;
-
-import com.trilead.ssh2.Connection;
-import com.trilead.ssh2.Session;
-
-import android.content.Context;
-import android.graphics.Canvas;
-import android.util.Log;
-import android.widget.EditText;
-import android.widget.TextView;
-
-public class ShellView extends EditText {
-
-	private Connection mConn;
-	private Session mSess;
-	
-	private String mHostname;
-	private String mUsername;
-	private String mPassword;
-
-	public ShellView(Context context) {
-		super(context);
-		// TODO Auto-generated constructor stub
-		
-		mPassword = "OEfmP07-";
-	}
-	
-	@Override
-	public void onDraw(Canvas canvas) {
-		super.onDraw(canvas);
-		
-		append("Connecting... ");
-		mConn = new Connection(mHostname);
-		
-        try {
-			mConn.connect(new InteractiveHostKeyVerifier());
-			append("OK\n");
-		} catch (IOException e) {
-			append("Failed.\n");
-			Log.e("SSH", e.getMessage());
-			append("\nWhoops: " + e.getCause().getMessage() + "\n");
-		}
-			
-		boolean enableKeyboardInteractive = true;
-		boolean enableDSA = true;
-		boolean enableRSA = true;
-		
-		try {
-			while (true) {
-				/*
-				if ((enableDSA || enableRSA ) &&
-						mConn.isAuthMethodAvailable(username, "publickey");
-						*/
-				
-				if (mConn.isAuthMethodAvailable(mUsername, "password")) {
-					boolean res = mConn.authenticateWithPassword(mUsername, mPassword);
-					if (res == true)
-						break;
-					
-					append("Login failed.\n");
-					continue;
-				}
-				
-				throw new IOException("No supported authentication methods available.");
-			}
-			
-			mSess = mConn.openSession();
-			append("Logged in as " + mUsername + ".\n");
-		} catch (IOException e) {
-			Log.e("SSH", e.getMessage());
-		}
-		append("Exiting\n");
-	}
-
-}
diff --git a/src/org/theb/ssh/Terminal.java b/src/org/theb/ssh/Terminal.java
new file mode 100644
index 0000000..1212aa2
--- /dev/null
+++ b/src/org/theb/ssh/Terminal.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2007 Kenny Root (kenny at the-b.org)
+ * 
+ * This file is part of Connectbot.
+ *
+ *  Connectbot 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.
+ *
+ *  Connectbot 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 Connectbot.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.theb.ssh;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public interface Terminal {
+	public int getWidth();
+	public int getHeight();
+	public int getRowCount();
+	public int getColumnCount();
+	public void start(InputStream in, OutputStream out);
+	public byte[] getKeyCode(int keyCode, int meta);
+}
diff --git a/src/org/theb/ssh/TrileadConnectionThread.java b/src/org/theb/ssh/TrileadConnectionThread.java
new file mode 100644
index 0000000..63180b0
--- /dev/null
+++ b/src/org/theb/ssh/TrileadConnectionThread.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright (C) 2007 Kenny Root (kenny at the-b.org)
+ * 
+ * This file is part of Connectbot.
+ *
+ *  Connectbot 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.
+ *
+ *  Connectbot 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 Connectbot.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.theb.ssh;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.concurrent.Semaphore;
+
+import com.trilead.ssh2.Connection;
+import com.trilead.ssh2.ConnectionMonitor;
+import com.trilead.ssh2.Session;
+
+public class TrileadConnectionThread extends ConnectionThread {
+	private String hostname;
+	private String username;
+	private String password;
+	private int port;
+
+	private Connection connection;
+	private Session session;
+
+	private InputStream stdOut;
+	private OutputStream stdIn;
+
+	private Semaphore sPass;
+	
+	protected FeedbackUI ui;
+	protected Terminal term;
+	
+	public TrileadConnectionThread(FeedbackUI ui, Terminal term, String hostname, String username, int port) {
+		super(ui, hostname, username, port);
+		this.ui = ui;
+		this.term = term;
+		this.hostname = hostname;
+		this.username = username;
+		this.port = port;
+	}
+
+	@Override
+	public void finish() {
+		if (session != null) {
+			session.close();
+			session = null;
+		}
+
+		if (connection != null) {
+			connection.close();
+			connection = null;
+		}
+	}
+
+	@Override
+	public InputStream getReader() {
+		return stdOut;
+	}
+
+	@Override
+	public OutputStream getWriter() {
+		return stdIn;
+	}
+
+	@Override
+	public void run() {
+		connection = new Connection(hostname, port);
+
+		connection.addConnectionMonitor((ConnectionMonitor) ui);
+
+		ui.setWaiting(true, "Connection", "Connecting to " + hostname + "...");
+
+		try {
+			connection.connect(new InteractiveHostKeyVerifier());
+
+			ui.setWaiting(true, "Authenticating", "Trying to authenticate...");
+
+			// boolean enableKeyboardInteractive = true;
+			// boolean enableDSA = true;
+			// boolean enableRSA = true;
+
+			while (true) {
+				/*
+				 * if ((enableDSA || enableRSA ) &&
+				 * mConn.isAuthMethodAvailable(username, "publickey");
+				 */
+
+				if (connection.isAuthMethodAvailable(username, "password")) {
+					ui.setWaiting(true, "Authenticating",
+							"Trying to authenticate using password...");
+
+					// Set a semaphore that is unset by the returning dialog.
+					sPass = new Semaphore(0);
+					ui.askPassword();
+
+					// Wait for the user to answer.
+					sPass.acquire();
+					sPass = null;
+					if (password == null)
+						continue;
+
+					boolean res = connection.authenticateWithPassword(username,
+							password);
+					password = null;
+					if (res == true)
+						break;
+
+					continue;
+				}
+
+				throw new IOException(
+						"No supported authentication methods available.");
+			}
+
+			ui.setWaiting(true, "Session", "Requesting shell...");
+
+			session = connection.openSession();
+			
+			session.requestPTY("vt100",
+					term.getColumnCount(), term.getRowCount(),
+					term.getWidth(), term.getHeight(),
+					null);
+
+			session.startShell();
+
+			stdIn = session.getStdin();
+			// stderr = session.getStderr();
+			stdOut = session.getStdout();
+
+			ui.setWaiting(false, null, null);
+		} catch (IOException e) {
+			ui.setWaiting(false, null, null);
+			return;
+		} catch (InterruptedException e) {
+			// This thread is coming to an end. Let us exit.
+			return;
+		}
+
+		term.start(stdOut, stdIn);
+	}
+
+	@Override
+	public void setPassword(String password) {
+		if (password == null)
+			this.password = "";
+		else
+			this.password = password;
+		sPass.release();
+	}
+}