Merge lp:~g-poussel/analysesi/devel into lp:analysesi

[Guillaume Poussel]

Correction de bugs : dessin des relations ternaires (#370373), clic droit pendant le dessin (#692553)
Ajout des raccourcis claviers globaux (#700992, #666424)

[lp:~g-poussel/analysesi/devel]

7. By Guillaume Poussel on 2011-12-11

Remove useless attributes and use enum instead of string constants.

8. By Guillaume Poussel on 2011-12-11

Huge cleanup, based on static code analysis.

9. By Guillaume Poussel on 2011-12-11

Cleaning up all Eclipse warnings: unused attributes and functions, version ID in Serializable classes.

10. By Guillaume Poussel on 2011-12-11

Bug fixes for class types in table model

11. By Guillaume Poussel on 2011-12-11

Remove commented out code

12. By Guillaume Poussel on 2011-12-12

Improving row adding with an empty row always at the bottom of the table

13. By Guillaume Poussel on 2011-12-12

Fix bug #712583: removing row in data dictionary is now working, even if table is sorted.

14. By Guillaume Poussel on 2011-12-12

Replace mouse button test with more semantic stuff.

15. By Guillaume Poussel on 2011-12-13

Organizing icons + fresh new icon set.

16. By Guillaume Poussel on 2011-12-14

Editing icon set.

17. By Guillaume Poussel on 2011-12-14

Side-effect from editing table model. Loops are now properly written.

18. By Guillaume Poussel on 2011-12-15

Smaller icons and text label improved.

19. By Guillaume Poussel on 2011-12-16

Remove almost all useless inner classes.

20. By Guillaume Poussel on 2011-12-16

Remove again a new useless inner classe.

21. By Guillaume Poussel on 2011-12-16

Fix bug and encoding in properties file.

22. By Guillaume Poussel on 2011-12-16

Buttons on navigator are now toggled on click.

23. By Guillaume Poussel on 2011-12-16

Cleanup constant and deprecated methods.

24. By Guillaume Poussel on 2011-12-17

Refactor i18n: remove useless constants, properties reordering…

25. By Guillaume Poussel on 2011-12-17

Cleanup Utilities class: removing useless methods, better name on translation function.

26. By Guillaume Poussel on 2011-12-17

Workspace cleanup.

27. By Guillaume Poussel on 2011-12-18

Trying to solve bug #848394. Let's see if it works!

28. By Guillaume Poussel on 2011-12-20

Get rid of uncovered code

29. By Guillaume Poussel on 2011-12-20

Fixing translation bug, and message arguments

30. By Guillaume Poussel on 2011-12-20

Better selection handling on moving dictionary rows

31. By Guillaume Poussel on 2011-12-20

Customize cursor when adding links and moving elements

32. By Guillaume Poussel on 2011-12-20

Again, properties file fixed.

33. By Guillaume Poussel on 2011-12-25

Remove static constants from main class.

34. By Guillaume Poussel on 2011-12-25

Few optimizations

35. By Guillaume Poussel on 2011-12-26

Remove all iterators loop, add Java 6 syntax

36. By Guillaume Poussel on 2011-12-26

GlobalActionCollection is now a singleton

37. By Guillaume Poussel on 2011-12-27

Huge cleanup: clear almost all warnings, remove useless comments (bug number are stored in commit messages)

38. By Guillaume Poussel on 2011-12-27

Remove all trailing whitespaces.

39. By Guillaume Poussel on 2011-12-27

Antialiasing on MLD/MCD

Unmerged revisions

39. By Guillaume Poussel on 2011-12-27

Antialiasing on MLD/MCD

38. By Guillaume Poussel on 2011-12-27

Remove all trailing whitespaces.

37. By Guillaume Poussel on 2011-12-27

Huge cleanup: clear almost all warnings, remove useless comments (bug number are stored in commit messages)

36. By Guillaume Poussel on 2011-12-26

GlobalActionCollection is now a singleton

35. By Guillaume Poussel on 2011-12-26

Remove all iterators loop, add Java 6 syntax

34. By Guillaume Poussel on 2011-12-25

Few optimizations

33. By Guillaume Poussel on 2011-12-25

Remove static constants from main class.

32. By Guillaume Poussel on 2011-12-20

Again, properties file fixed.

31. By Guillaume Poussel on 2011-12-20

Customize cursor when adding links and moving elements

30. By Guillaume Poussel on 2011-12-20

Better selection handling on moving dictionary rows

=== added file '.DS_Store'
Binary files .DS_Store	1970-01-01 00:00:00 +0000 and .DS_Store	2011-12-27 11:11:23 +0000 differ
=== renamed file '.DS_Store' => '.DS_Store.moved'
=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2011-12-27 11:11:23 +0000
@@ -0,0 +1,4 @@
+build
+build/com
+build/langue
+build/org

=== renamed file '.bzrignore' => '.bzrignore.moved'
=== added file '.classpath'
--- .classpath	1970-01-01 00:00:00 +0000
+++ .classpath	2011-12-27 11:11:23 +0000
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry exported="true" kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry exported="true" kind="lib" path="lib/looks-1.2.2.jar"/>
+	<classpathentry exported="true" kind="lib" path="lib/forms-1.0.5.jar"/>
+	<classpathentry exported="true" kind="lib" path="lib/mysql-connector-java-5.1.10-bin.jar"/>
+	<classpathentry exported="true" kind="lib" path="lib/postgresql-8.4-701.jdbc4.jar"/>
+	<classpathentry kind="output" path="build"/>
+</classpath>

=== renamed file '.classpath' => '.classpath.moved'
=== added file '.project'
--- .project	1970-01-01 00:00:00 +0000
+++ .project	2011-12-27 11:11:23 +0000
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>AnalyseSI</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

=== renamed file '.project' => '.project.moved'
=== added directory '.settings'
=== renamed directory '.settings' => '.settings.moved'
=== added file '.settings/org.eclipse.core.resources.prefs'
--- .settings/org.eclipse.core.resources.prefs	1970-01-01 00:00:00 +0000
+++ .settings/org.eclipse.core.resources.prefs	2011-12-27 11:11:23 +0000
@@ -0,0 +1,5 @@
+#Wed Dec 29 22:26:40 CET 2010
+eclipse.preferences.version=1
+encoding//src/langue/messages_fr.properties=UTF-8
+encoding/<project>=UTF-8
+encoding/README=ISO-8859-1

=== added file '.settings/org.eclipse.core.runtime.prefs'
--- .settings/org.eclipse.core.runtime.prefs	1970-01-01 00:00:00 +0000
+++ .settings/org.eclipse.core.runtime.prefs	2011-12-27 11:11:23 +0000
@@ -0,0 +1,3 @@
+#Sun Mar 02 00:15:18 GMT 2008
+eclipse.preferences.version=1
+line.separator=\n

=== added file 'GPL.txt'
--- GPL.txt	1970-01-01 00:00:00 +0000
+++ GPL.txt	2011-12-27 11:11:23 +0000
@@ -0,0 +1,339 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  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
+this service 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 make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  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.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute 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 and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+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
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the 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 a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE 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.
+
+		     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
+convey 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 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.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision 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, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This 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.

=== renamed file 'GPL.txt' => 'GPL.txt.moved'
=== added file 'README'
--- README	1970-01-01 00:00:00 +0000
+++ README	2011-12-27 11:11:23 +0000
@@ -0,0 +1,13 @@
+Auteur : Bruno Dabo
+
+Le projet est hébergé sur https://launchpad.net/analysesi
+N'hésitez pas à participer au groupe AnalyseSI ( https://launchpad.net/~analysesi ) 
+Une mailing-list est ouverte sur [e-mail]
+
+----------------------
+Corrections apportées
+RELEASE : 0.75 ( Rockhampton )
+Date : janvier 2011
+----------------------
+#505822	Utiliser l'outil curseur par défaut dans la vue MCD
+#517141	Ajouter le modèle MLDR

=== renamed file 'README' => 'README.moved'
=== added directory 'cases'
=== renamed directory 'cases' => 'cases.moved'
=== added file 'cases/.DS_Store'
Binary files cases/.DS_Store	1970-01-01 00:00:00 +0000 and cases/.DS_Store	2011-12-27 11:11:23 +0000 differ
=== added file 'cases/test-001.asi'
Binary files cases/test-001.asi	1970-01-01 00:00:00 +0000 and cases/test-001.asi	2011-12-27 11:11:23 +0000 differ
=== added file 'cases/test-001.png'
Binary files cases/test-001.png	1970-01-01 00:00:00 +0000 and cases/test-001.png	2011-12-27 11:11:23 +0000 differ
=== added file 'cases/test-001.sql'
--- cases/test-001.sql	1970-01-01 00:00:00 +0000
+++ cases/test-001.sql	2011-12-27 11:11:23 +0000
@@ -0,0 +1,19 @@
+# script créé le : Thu Dec 23 15:22:52 CET 2010 ;
+
+# use  VOTRE_BASE_DE_DONNEE ;
+
+DROP TABLE IF EXISTS SOCIETE ;
+
+CREATE TABLE SOCIETE (id_societe INT NOT NULL,
+nom_societe VARCHAR(30),
+PRIMARY KEY (id_societe) ) ENGINE=InnoDB;
+
+DROP TABLE IF EXISTS EMPLOYE ;
+
+CREATE TABLE EMPLOYE (id_employe INT NOT NULL,
+nom_employe VARCHAR(30),
+id_societe INT,
+PRIMARY KEY (id_employe) ) ENGINE=InnoDB;
+
+ALTER TABLE EMPLOYE ADD CONSTRAINT FK_EMPLOYE_id_societe FOREIGN KEY (id_societe) REFERENCES SOCIETE (id_societe);
+

=== added file 'cases/test-002.asi'
Binary files cases/test-002.asi	1970-01-01 00:00:00 +0000 and cases/test-002.asi	2011-12-27 11:11:23 +0000 differ
=== added file 'cases/test-002.png'
Binary files cases/test-002.png	1970-01-01 00:00:00 +0000 and cases/test-002.png	2011-12-27 11:11:23 +0000 differ
=== added file 'cases/test-002.sql'
--- cases/test-002.sql	1970-01-01 00:00:00 +0000
+++ cases/test-002.sql	2011-12-27 11:11:23 +0000
@@ -0,0 +1,19 @@
+# script créé le : Thu Dec 23 15:23:06 CET 2010 ;
+
+# use  VOTRE_BASE_DE_DONNEE ;
+
+DROP TABLE IF EXISTS SOCIETE ;
+
+CREATE TABLE SOCIETE (id_societe INT NOT NULL,
+nom_societe VARCHAR(30),
+PRIMARY KEY (id_societe) ) ENGINE=InnoDB;
+
+DROP TABLE IF EXISTS EMPLOYE ;
+
+CREATE TABLE EMPLOYE (id_employe INT NOT NULL,
+nom_employe VARCHAR(30),
+id_societe INT NOT NULL,
+PRIMARY KEY (id_employe) ) ENGINE=InnoDB;
+
+ALTER TABLE EMPLOYE ADD CONSTRAINT FK_EMPLOYE_id_societe FOREIGN KEY (id_societe) REFERENCES SOCIETE (id_societe);
+

=== added file 'cases/test-003.asi'
Binary files cases/test-003.asi	1970-01-01 00:00:00 +0000 and cases/test-003.asi	2011-12-27 11:11:23 +0000 differ
=== added file 'cases/test-003.png'
Binary files cases/test-003.png	1970-01-01 00:00:00 +0000 and cases/test-003.png	2011-12-27 11:11:23 +0000 differ
=== added file 'cases/test-003.sql'
--- cases/test-003.sql	1970-01-01 00:00:00 +0000
+++ cases/test-003.sql	2011-12-27 11:11:23 +0000
@@ -0,0 +1,28 @@
+# script créé le : Thu Dec 23 15:23:26 CET 2010 ;
+
+# use  VOTRE_BASE_DE_DONNEE ;
+
+DROP TABLE IF EXISTS COMMANDE ;
+
+CREATE TABLE COMMANDE (id_commande INT NOT NULL,
+date_commande DATETIME,
+PRIMARY KEY (id_commande) ) ENGINE=InnoDB;
+
+DROP TABLE IF EXISTS PRODUIT ;
+
+CREATE TABLE PRODUIT (id_produit INT NOT NULL,
+libelle_produit VARCHAR(30),
+PRIMARY KEY (id_produit) ) ENGINE=InnoDB;
+
+DROP TABLE IF EXISTS compose ;
+
+CREATE TABLE compose (id_commande INT NOT NULL,
+id_produit INT NOT NULL,
+quantite INT,
+PRIMARY KEY (id_commande,
+ id_produit) ) ENGINE=InnoDB;
+
+ALTER TABLE compose ADD CONSTRAINT FK_compose_id_commande FOREIGN KEY (id_commande) REFERENCES COMMANDE (id_commande);
+
+ALTER TABLE compose ADD CONSTRAINT FK_compose_id_produit FOREIGN KEY (id_produit) REFERENCES PRODUIT (id_produit);
+

=== added file 'cases/test-004.asi'
Binary files cases/test-004.asi	1970-01-01 00:00:00 +0000 and cases/test-004.asi	2011-12-27 11:11:23 +0000 differ
=== added file 'cases/test-004.png'
Binary files cases/test-004.png	1970-01-01 00:00:00 +0000 and cases/test-004.png	2011-12-27 11:11:23 +0000 differ
=== added file 'cases/test-004.sql'
--- cases/test-004.sql	1970-01-01 00:00:00 +0000
+++ cases/test-004.sql	2011-12-27 11:11:23 +0000
@@ -0,0 +1,37 @@
+# script créé le : Thu Dec 23 15:16:07 CET 2010 ;
+
+# use  VOTRE_BASE_DE_DONNEE ;
+
+DROP TABLE IF EXISTS ETUDIANT ;
+
+CREATE TABLE ETUDIANT (id_etudiant INT NOT NULL,
+nom_etudiant VARCHAR(30),
+PRIMARY KEY (id_etudiant) ) ENGINE=InnoDB;
+
+DROP TABLE IF EXISTS LANGUE ;
+
+CREATE TABLE LANGUE (id_langue INT NOT NULL,
+nom_langue VARCHAR(30),
+PRIMARY KEY (id_langue) ) ENGINE=InnoDB;
+
+DROP TABLE IF EXISTS NIVEAU ;
+
+CREATE TABLE NIVEAU (id_niveau INT NOT NULL,
+nom_niveau VARCHAR(30),
+PRIMARY KEY (id_niveau) ) ENGINE=InnoDB;
+
+DROP TABLE IF EXISTS parle ;
+
+CREATE TABLE parle (id_etudiant INT NOT NULL,
+id_langue INT NOT NULL,
+id_niveau INT NOT NULL,
+PRIMARY KEY (id_etudiant,
+ id_langue,
+ id_niveau) ) ENGINE=InnoDB;
+
+ALTER TABLE parle ADD CONSTRAINT FK_parle_id_etudiant FOREIGN KEY (id_etudiant) REFERENCES ETUDIANT (id_etudiant);
+
+ALTER TABLE parle ADD CONSTRAINT FK_parle_id_langue FOREIGN KEY (id_langue) REFERENCES LANGUE (id_langue);
+
+ALTER TABLE parle ADD CONSTRAINT FK_parle_id_niveau FOREIGN KEY (id_niveau) REFERENCES NIVEAU (id_niveau);
+

=== added file 'cases/test-005.asi'
Binary files cases/test-005.asi	1970-01-01 00:00:00 +0000 and cases/test-005.asi	2011-12-27 11:11:23 +0000 differ
=== added file 'cases/test-005.png'
Binary files cases/test-005.png	1970-01-01 00:00:00 +0000 and cases/test-005.png	2011-12-27 11:11:23 +0000 differ
=== added file 'cases/test-005.sql'
--- cases/test-005.sql	1970-01-01 00:00:00 +0000
+++ cases/test-005.sql	2011-12-27 11:11:23 +0000
@@ -0,0 +1,22 @@
+# script créé le : Thu Dec 23 15:23:44 CET 2010 ;
+
+# use  VOTRE_BASE_DE_DONNEE ;
+
+DROP TABLE IF EXISTS ANIMATEUR ;
+
+CREATE TABLE ANIMATEUR (id_animateur INT NOT NULL,
+nom_animateur VARCHAR(30),
+id_groupe INT,
+PRIMARY KEY (id_animateur) ) ENGINE=InnoDB;
+
+DROP TABLE IF EXISTS GROUPE ;
+
+CREATE TABLE GROUPE (id_groupe INT NOT NULL,
+nom_groupe VARCHAR(30),
+id_animateur INT,
+PRIMARY KEY (id_groupe) ) ENGINE=InnoDB;
+
+ALTER TABLE ANIMATEUR ADD CONSTRAINT FK_ANIMATEUR_id_groupe FOREIGN KEY (id_groupe) REFERENCES GROUPE (id_groupe);
+
+ALTER TABLE GROUPE ADD CONSTRAINT FK_GROUPE_id_animateur FOREIGN KEY (id_animateur) REFERENCES ANIMATEUR (id_animateur);
+

=== added file 'cases/test-006.asi'
Binary files cases/test-006.asi	1970-01-01 00:00:00 +0000 and cases/test-006.asi	2011-12-27 11:11:23 +0000 differ
=== added file 'cases/test-006.png'
Binary files cases/test-006.png	1970-01-01 00:00:00 +0000 and cases/test-006.png	2011-12-27 11:11:23 +0000 differ
=== added file 'cases/test-006.sql'
--- cases/test-006.sql	1970-01-01 00:00:00 +0000
+++ cases/test-006.sql	2011-12-27 11:11:23 +0000
@@ -0,0 +1,22 @@
+# script créé le : Thu Dec 23 15:24:35 CET 2010 ;
+
+# use  VOTRE_BASE_DE_DONNEE ;
+
+DROP TABLE IF EXISTS ANIMATEUR ;
+
+CREATE TABLE ANIMATEUR (id_animateur INT NOT NULL,
+nom_animateur VARCHAR(30),
+id_groupe INT,
+PRIMARY KEY (id_animateur) ) ENGINE=InnoDB;
+
+DROP TABLE IF EXISTS GROUPE ;
+
+CREATE TABLE GROUPE (id_groupe INT NOT NULL,
+nom_groupe VARCHAR(30),
+id_animateur INT,
+PRIMARY KEY (id_groupe) ) ENGINE=InnoDB;
+
+ALTER TABLE ANIMATEUR ADD CONSTRAINT FK_ANIMATEUR_id_groupe FOREIGN KEY (id_groupe) REFERENCES GROUPE (id_groupe);
+
+ALTER TABLE GROUPE ADD CONSTRAINT FK_GROUPE_id_animateur FOREIGN KEY (id_animateur) REFERENCES ANIMATEUR (id_animateur);
+

=== added file 'cases/test-007.asi'
Binary files cases/test-007.asi	1970-01-01 00:00:00 +0000 and cases/test-007.asi	2011-12-27 11:11:23 +0000 differ
=== added file 'cases/test-007.png'
Binary files cases/test-007.png	1970-01-01 00:00:00 +0000 and cases/test-007.png	2011-12-27 11:11:23 +0000 differ
=== added file 'cases/test-007.sql'
--- cases/test-007.sql	1970-01-01 00:00:00 +0000
+++ cases/test-007.sql	2011-12-27 11:11:23 +0000
@@ -0,0 +1,17 @@
+# script créé le : Thu Dec 23 15:24:52 CET 2010 ;
+
+# use  VOTRE_BASE_DE_DONNEE ;
+
+DROP TABLE IF EXISTS A ;
+
+CREATE TABLE A (id_a BIGINT NOT NULL,
+PRIMARY KEY (id_a) ) ENGINE=InnoDB;
+
+DROP TABLE IF EXISTS B ;
+
+CREATE TABLE B (id_b BIGINT NOT NULL,
+id_a BIGINT,
+PRIMARY KEY (id_b) ) ENGINE=InnoDB;
+
+ALTER TABLE B ADD CONSTRAINT FK_B_id_a FOREIGN KEY (id_a) REFERENCES A (id_a);
+

=== added file 'cases/test-008.asi'
Binary files cases/test-008.asi	1970-01-01 00:00:00 +0000 and cases/test-008.asi	2011-12-27 11:11:23 +0000 differ
=== added file 'cases/test-008.png'
Binary files cases/test-008.png	1970-01-01 00:00:00 +0000 and cases/test-008.png	2011-12-27 11:11:23 +0000 differ
=== added file 'cases/test-008.sql'
--- cases/test-008.sql	1970-01-01 00:00:00 +0000
+++ cases/test-008.sql	2011-12-27 11:11:23 +0000
@@ -0,0 +1,23 @@
+# script créé le : Thu Dec 23 15:25:20 CET 2010 ;
+
+# use  VOTRE_BASE_DE_DONNEE ;
+
+DROP TABLE IF EXISTS E1 ;
+
+CREATE TABLE E1 (id_E1 BIGINT NOT NULL,
+PRIMARY KEY (id_E1) ) ENGINE=InnoDB;
+
+DROP TABLE IF EXISTS E2 ;
+
+CREATE TABLE E2 (id_E2 BIGINT NOT NULL,
+id_E1 BIGINT NOT NULL,
+id_E1_a2 BIGINT NOT NULL,
+id_E1_a3 BIGINT NOT NULL,
+PRIMARY KEY (id_E2) ) ENGINE=InnoDB;
+
+ALTER TABLE E2 ADD CONSTRAINT FK_E2_id_E1 FOREIGN KEY (id_E1) REFERENCES E1 (id_E1);
+
+ALTER TABLE E2 ADD CONSTRAINT FK_E2_id_E1_a2 FOREIGN KEY (id_E1_a2) REFERENCES E1 (id_E1);
+
+ALTER TABLE E2 ADD CONSTRAINT FK_E2_id_E1_a3 FOREIGN KEY (id_E1_a3) REFERENCES E1 (id_E1);
+

=== added file 'cases/test-009.asi'
Binary files cases/test-009.asi	1970-01-01 00:00:00 +0000 and cases/test-009.asi	2011-12-27 11:11:23 +0000 differ
=== added file 'cases/test-009.png'
Binary files cases/test-009.png	1970-01-01 00:00:00 +0000 and cases/test-009.png	2011-12-27 11:11:23 +0000 differ
=== added file 'cases/test-009.sql'
--- cases/test-009.sql	1970-01-01 00:00:00 +0000
+++ cases/test-009.sql	2011-12-27 11:11:23 +0000
@@ -0,0 +1,25 @@
+# script créé le : Thu Dec 23 15:26:48 CET 2010 ;
+
+# use  VOTRE_BASE_DE_DONNEE ;
+
+DROP TABLE IF EXISTS a ;
+
+CREATE TABLE a (id_a int AUTO_INCREMENT NOT NULL,
+id_c int NOT NULL,
+PRIMARY KEY (id_a) ) ENGINE=InnoDB;
+
+DROP TABLE IF EXISTS b ;
+
+CREATE TABLE b (id_b int AUTO_INCREMENT NOT NULL,
+id_a int NOT NULL,
+PRIMARY KEY (id_b) ) ENGINE=InnoDB;
+
+DROP TABLE IF EXISTS c ;
+
+CREATE TABLE c (id_c int AUTO_INCREMENT NOT NULL,
+PRIMARY KEY (id_c) ) ENGINE=InnoDB;
+
+ALTER TABLE a ADD CONSTRAINT FK_a_id_c FOREIGN KEY (id_c) REFERENCES c (id_c);
+
+ALTER TABLE b ADD CONSTRAINT FK_b_id_a FOREIGN KEY (id_a) REFERENCES a (id_a);
+

=== added directory 'lib'
=== renamed directory 'lib' => 'lib.moved'
=== added file 'lib/forms-1.0.5.jar'
Binary files lib/forms-1.0.5.jar	1970-01-01 00:00:00 +0000 and lib/forms-1.0.5.jar	2011-12-27 11:11:23 +0000 differ
=== added file 'lib/looks-1.2.2.jar'
Binary files lib/looks-1.2.2.jar	1970-01-01 00:00:00 +0000 and lib/looks-1.2.2.jar	2011-12-27 11:11:23 +0000 differ
=== added file 'lib/mysql-connector-java-5.1.10-bin.jar'
Binary files lib/mysql-connector-java-5.1.10-bin.jar	1970-01-01 00:00:00 +0000 and lib/mysql-connector-java-5.1.10-bin.jar	2011-12-27 11:11:23 +0000 differ
=== added file 'lib/postgresql-8.4-701.jdbc4.jar'
Binary files lib/postgresql-8.4-701.jdbc4.jar	1970-01-01 00:00:00 +0000 and lib/postgresql-8.4-701.jdbc4.jar	2011-12-27 11:11:23 +0000 differ
=== added directory 'src'
=== renamed directory 'src' => 'src.moved'
=== added file 'src/.DS_Store'
Binary files src/.DS_Store	1970-01-01 00:00:00 +0000 and src/.DS_Store	2011-12-27 11:11:23 +0000 differ
=== added directory 'src/com'
=== added directory 'src/com/jgoodies'
=== added directory 'src/com/jgoodies/uif'
=== added directory 'src/com/jgoodies/uif/lite'
=== added directory 'src/com/jgoodies/uif/lite/panel'
=== added file 'src/com/jgoodies/uif/lite/panel/SimpleInternalFrame.java'
--- src/com/jgoodies/uif/lite/panel/SimpleInternalFrame.java	1970-01-01 00:00:00 +0000
+++ src/com/jgoodies/uif/lite/panel/SimpleInternalFrame.java	2011-12-27 11:11:23 +0000
@@ -0,0 +1,534 @@
+/*
+ * Copyright (c) 2003 JGoodies Karsten Lentzsch. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  o Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ *  o Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ *  o Neither the name of JGoodies Karsten Lentzsch nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package com.jgoodies.uif.lite.panel;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.GradientPaint;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Insets;
+import java.awt.LayoutManager;
+import java.awt.Paint;
+
+import javax.swing.BorderFactory;
+import javax.swing.Icon;
+import javax.swing.JComponent;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JToolBar;
+import javax.swing.SwingConstants;
+import javax.swing.UIManager;
+import javax.swing.border.AbstractBorder;
+
+import com.jgoodies.plaf.LookUtils;
+
+/**
+ * A <code>JPanel</code> subclass that has a drop shadow border and that
+ * provides a header with icon, title and tool bar.
+ * <p>
+ *
+ * This class can be used to replace the <code>JInternalFrame</code>, for use
+ * outside of a <code>JDesktopPane</code>. The
+ * <code>SimpleInternalFrame</code> is less flexible but often more usable; it
+ * avoids overlapping windows and scales well up to IDE size. Several customers
+ * have reported that they and their clients feel much better with both the
+ * appearance and the UI feel.
+ * <p>
+ *
+ * The SimpleInternalFrame provides the following bound properties:
+ * <i>frameIcon, title, toolBar, content, selected. </i>
+ * <p>
+ *
+ * By default the SimpleInternalFrame is in <i>selected </i> state. If you don't
+ * do anything, multiple simple internal frames will be displayed as selected.
+ *
+ * @author Karsten Lentzsch
+ * @version $Revision: 1.1 $
+ *
+ * @see javax.swing.JInternalFrame
+ * @see javax.swing.JDesktopPane
+ */
+
+public class SimpleInternalFrame extends JPanel
+{
+
+    /**
+	 *
+	 */
+	private static final long serialVersionUID = 6209018648321926386L;
+
+	private JLabel titleLabel;
+
+    private GradientPanel gradientPanel;
+
+    private JPanel headerPanel;
+
+    private boolean isSelected;
+
+    // Instance Creation ****************************************************
+
+    /**
+     * Constructs a <code>SimpleInternalFrame</code> with the specified title.
+     *
+     * @param title
+     *            the initial title
+     */
+    public SimpleInternalFrame(String title)
+    {
+        this(null, title, null, null);
+    }
+
+    /**
+     * Constructs a <code>SimpleInternalFrame</code> with the specified icon,
+     * and title.
+     *
+     * @param icon
+     *            the initial icon
+     * @param title
+     *            the initial title
+     */
+    public SimpleInternalFrame(Icon icon, String title)
+    {
+        this(icon, title, null, null);
+    }
+
+    /**
+     * Constructs a <code>SimpleInternalFrame</code> with the specified title,
+     * tool bar, and content panel.
+     *
+     * @param title
+     *            the initial title
+     * @param bar
+     *            the initial tool bar
+     * @param content
+     *            the initial content pane
+     */
+    public SimpleInternalFrame(String title, JToolBar bar, JComponent content)
+    {
+        this(null, title, bar, content);
+    }
+
+    /**
+     * Constructs a <code>SimpleInternalFrame</code> with the specified icon,
+     * title, tool bar, and content panel.
+     *
+     * @param icon
+     *            the initial icon
+     * @param title
+     *            the initial title
+     * @param bar
+     *            the initial tool bar
+     * @param content
+     *            the initial content pane
+     */
+    public SimpleInternalFrame(Icon icon, String title, JToolBar bar,
+            JComponent content)
+    {
+        super(new BorderLayout());
+        this.isSelected = false;
+        this.titleLabel = new JLabel(title, icon, SwingConstants.LEADING);
+        JPanel top = buildHeader(this.titleLabel, bar);
+
+        add(top, BorderLayout.NORTH);
+        if (content != null) {
+            setContent(content);
+        }
+        setBorder(new ShadowBorder());
+        setSelected(true);
+        updateHeader();
+    }
+
+    // Public API ***********************************************************
+
+    /**
+     * Returns the frame's icon.
+     *
+     * @return the frame's icon
+     */
+    public Icon getFrameIcon()
+    {
+        return this.titleLabel.getIcon();
+    }
+
+    /**
+     * Sets a new frame icon.
+     *
+     * @param newIcon
+     *            the icon to be set
+     */
+    public void setFrameIcon(Icon newIcon)
+    {
+        Icon oldIcon = getFrameIcon();
+        this.titleLabel.setIcon(newIcon);
+        firePropertyChange("frameIcon", oldIcon, newIcon);
+    }
+
+    /**
+     * Returns the frame's title text.
+     *
+     * @return String the current title text
+     */
+    public String getTitle()
+    {
+        return this.titleLabel.getText();
+    }
+
+    /**
+     * Sets a new title text.
+     *
+     * @param newText
+     *            the title text tp be set
+     */
+    public void setTitle(String newText)
+    {
+        String oldText = getTitle();
+        this.titleLabel.setText(newText);
+        firePropertyChange("title", oldText, newText);
+    }
+
+    /**
+     * Returns the current toolbar, null if none has been set before.
+     *
+     * @return the current toolbar - if any
+     */
+    public JToolBar getToolBar()
+    {
+        return this.headerPanel.getComponentCount() > 1 ? (JToolBar) this.headerPanel
+                .getComponent(1) : null;
+    }
+
+    /**
+     * Sets a new tool bar in the header.
+     *
+     * @param newToolBar
+     *            the tool bar to be set in the header
+     */
+    public void setToolBar(JToolBar newToolBar)
+    {
+        JToolBar oldToolBar = getToolBar();
+        if (oldToolBar == newToolBar) {
+            return;
+        }
+        if (oldToolBar != null) {
+            this.headerPanel.remove(oldToolBar);
+        }
+        if (newToolBar != null) {
+            newToolBar.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));
+            this.headerPanel.add(newToolBar, BorderLayout.EAST);
+        }
+        updateHeader();
+        firePropertyChange("toolBar", oldToolBar, newToolBar);
+    }
+
+    /**
+     * Returns the content - null, if none has been set.
+     *
+     * @return the current content
+     */
+    public Component getContent()
+    {
+        return hasContent() ? getComponent(1) : null;
+    }
+
+    /**
+     * Sets a new panel content; replaces any existing content, if existing.
+     *
+     * @param newContent
+     *            the panel's new content
+     */
+    public void setContent(Component newContent)
+    {
+        Component oldContent = getContent();
+        if (hasContent()) {
+            remove(oldContent);
+        }
+        add(newContent, BorderLayout.CENTER);
+        firePropertyChange("content", oldContent, newContent);
+    }
+
+    /**
+     * Answers if the panel is currently selected (or in other words active) or
+     * not. In the selected state, the header background will be rendered
+     * differently.
+     *
+     * @return boolean a boolean, where true means the frame is selected
+     *         (currently active) and false means it is not
+     */
+    public boolean isSelected()
+    {
+        return this.isSelected;
+    }
+
+    /**
+     * This panel draws its title bar differently if it is selected, which may
+     * be used to indicate to the user that this panel has the focus, or should
+     * get more attention than other simple internal frames.
+     *
+     * @param newValue
+     *            a boolean, where true means the frame is selected (currently
+     *            active) and false means it is not
+     */
+    public void setSelected(boolean newValue)
+    {
+        boolean oldValue = isSelected();
+        this.isSelected = newValue;
+        updateHeader();
+        firePropertyChange("selected", oldValue, newValue);
+    }
+
+    // Building *************************************************************
+
+    /**
+     * Creates and answers the header panel, that consists of: an icon, a title
+     * label, a tool bar, and a gradient background.
+     *
+     * @param label
+     *            the label to paint the icon and text
+     * @param bar
+     *            the panel's tool bar
+     * @return the panel's built header area
+     */
+    private JPanel buildHeader(JLabel label, JToolBar bar)
+    {
+        this.gradientPanel = new GradientPanel(new BorderLayout(),
+                getHeaderBackground());
+        label.setOpaque(false);
+
+        this.gradientPanel.add(label, BorderLayout.WEST);
+        this.gradientPanel.setBorder(BorderFactory.createEmptyBorder(3, 4, 3, 1));
+
+        this.headerPanel = new JPanel(new BorderLayout());
+        this.headerPanel.add(this.gradientPanel, BorderLayout.CENTER);
+        setToolBar(bar);
+        this.headerPanel.setBorder(new RaisedHeaderBorder());
+        this.headerPanel.setOpaque(false);
+        return this.headerPanel;
+    }
+
+    /**
+     * Updates the header.
+     */
+    private void updateHeader()
+    {
+        this.gradientPanel.setBackground(getHeaderBackground());
+        this.gradientPanel.setOpaque(isSelected());
+        this.titleLabel.setForeground(getTextForeground(isSelected()));
+        this.headerPanel.repaint();
+    }
+
+    /**
+     * Updates the UI. In addition to the superclass behavior, we need to update
+     * the header component.
+     */
+    @Override
+	public void updateUI()
+    {
+        super.updateUI();
+        if (this.titleLabel != null) {
+            updateHeader();
+        }
+    }
+
+    // Helper Code **********************************************************
+
+    /**
+     * Checks and answers if the panel has a content component set.
+     *
+     * @return true if the panel has a content, false if it's empty
+     */
+    private boolean hasContent()
+    {
+        return getComponentCount() > 1;
+    }
+
+    /**
+     * Determines and answers the header's text foreground color. Tries to
+     * lookup a special color from the L&amp;F. In case it is absent, it uses
+     * the standard internal frame forground.
+     *
+     * @param selected
+     *            true to lookup the active color, false for the inactive
+     * @return the color of the foreground text
+     */
+    protected static Color getTextForeground(boolean selected)
+    {
+        Color c = UIManager
+                .getColor(selected ? "SimpleInternalFrame.activeTitleForeground"
+                        : "SimpleInternalFrame.inactiveTitleForeground");
+        if (c != null) {
+            return c;
+        }
+        return UIManager
+                .getColor(selected ? "InternalFrame.activeTitleForeground"
+                        : "Label.foreground");
+
+    }
+
+    /**
+     * Determines and answers the header's background color. Tries to lookup a
+     * special color from the L&amp;F. In case it is absent, it uses the
+     * standard internal frame background.
+     *
+     * @return the color of the header's background
+     */
+    protected static Color getHeaderBackground()
+    {
+        Color c = UIManager
+                .getColor("SimpleInternalFrame.activeTitleBackground");
+        if (c != null)
+            return c;
+        if (LookUtils.IS_LAF_WINDOWS_XP_ENABLED)
+            c = UIManager.getColor("InternalFrame.activeTitleGradient");
+        return c != null ? c : UIManager
+                .getColor("InternalFrame.activeTitleBackground");
+    }
+
+    // Helper Classes *******************************************************
+
+    // A custom border for the raised header pseudo 3D effect.
+    private static class RaisedHeaderBorder extends AbstractBorder
+    {
+
+        /**
+		 *
+		 */
+		private static final long serialVersionUID = -1586862789455436604L;
+		private static final Insets INSETS = new Insets(1, 1, 1, 0);
+
+        @Override
+		public Insets getBorderInsets(Component c)
+        {
+            return INSETS;
+        }
+
+        @Override
+		public void paintBorder(Component c, Graphics g, int x, int y, int w,
+                int h)
+        {
+
+            g.translate(x, y);
+            g.setColor(UIManager.getColor("controlLtHighlight"));
+            g.fillRect(0, 0, w, 1);
+            g.fillRect(0, 1, 1, h - 1);
+            g.setColor(UIManager.getColor("controlShadow"));
+            g.fillRect(0, h - 1, w, 1);
+            g.translate(-x, -y);
+        }
+    }
+
+    // A custom border that has a shadow on the right and lower sides.
+    private static class ShadowBorder extends AbstractBorder
+    {
+
+		private static final long serialVersionUID = -4816334256619360379L;
+		private static final Insets INSETS = new Insets(1, 1, 3, 3);
+
+        @Override
+		public Insets getBorderInsets(Component c)
+        {
+            return INSETS;
+        }
+
+        @Override
+		public void paintBorder(Component c, Graphics g, int x, int y, int w,
+                int h)
+        {
+
+            Color shadow = UIManager.getColor("controlShadow");
+            if (shadow == null) {
+                shadow = Color.GRAY;
+            }
+            Color lightShadow = new Color(shadow.getRed(), shadow.getGreen(),
+                    shadow.getBlue(), 170);
+            Color lighterShadow = new Color(shadow.getRed(), shadow.getGreen(),
+                    shadow.getBlue(), 70);
+            g.translate(x, y);
+
+            g.setColor(shadow);
+            g.fillRect(0, 0, w - 3, 1);
+            g.fillRect(0, 0, 1, h - 3);
+            g.fillRect(w - 3, 1, 1, h - 3);
+            g.fillRect(1, h - 3, w - 3, 1);
+            // Shadow line 1
+            g.setColor(lightShadow);
+            g.fillRect(w - 3, 0, 1, 1);
+            g.fillRect(0, h - 3, 1, 1);
+            g.fillRect(w - 2, 1, 1, h - 3);
+            g.fillRect(1, h - 2, w - 3, 1);
+            // Shadow line2
+            g.setColor(lighterShadow);
+            g.fillRect(w - 2, 0, 1, 1);
+            g.fillRect(0, h - 2, 1, 1);
+            g.fillRect(w - 2, h - 2, 1, 1);
+            g.fillRect(w - 1, 1, 1, h - 2);
+            g.fillRect(1, h - 1, w - 2, 1);
+            g.translate(-x, -y);
+        }
+    }
+
+    // A panel with a horizontal gradient background.
+    private static class GradientPanel extends JPanel
+    {
+
+        /**
+		 *
+		 */
+		private static final long serialVersionUID = 6424967938581512289L;
+
+		private GradientPanel(LayoutManager lm, Color background)
+        {
+            super(lm);
+            setBackground(background);
+        }
+
+        @Override
+		public void paintComponent(Graphics g)
+        {
+            super.paintComponent(g);
+            if (!isOpaque()) {
+                return;
+            }
+            Color control = UIManager.getColor("control");
+            int width = getWidth();
+            int height = getHeight();
+
+            Graphics2D g2 = (Graphics2D) g;
+            Paint storedPaint = g2.getPaint();
+            g2.setPaint(new GradientPaint(0, 0, getBackground(), width, 0,
+                    control));
+            g2.fillRect(0, 0, width, height);
+            g2.setPaint(storedPaint);
+        }
+    }
+
+}
\ No newline at end of file

=== added directory 'src/com/microstar'
=== added directory 'src/com/microstar/xml'
=== added file 'src/com/microstar/xml/HandlerBase.java'
--- src/com/microstar/xml/HandlerBase.java	1970-01-01 00:00:00 +0000
+++ src/com/microstar/xml/HandlerBase.java	2011-12-27 11:11:23 +0000
@@ -0,0 +1,193 @@
+// HandlerBase.java: Simple base class for AElfred processors.
+// NO WARRANTY! See README, and copyright below.
+// $Id: HandlerBase.java,v 1.1 2008-03-02 00:22:50 lywoon Exp $
+
+package com.microstar.xml;
+
+/**
+ * Convenience base class for AElfred handlers.
+ * <p>
+ * This base class implements the XmlHandler interface with (mostly empty)
+ * default handlers. You are not required to use this, but if you need to handle
+ * only a few events, you might find it convenient to extend this class rather
+ * than implementing the entire interface. This example overrides only the
+ * <code>charData</code> method, using the defaults for the others:
+ * 
+ * <pre>
+ * 
+ * import com.microstar.xml.HandlerBase;
+ * 
+ * public class MyHandler extends HandlerBase {
+ * 	public void charData(char ch[], int start, int length) {
+ * 		System.out.println(&quot;Data: &quot; + new String(ch, start, length));
+ * 	}
+ * }
+ * </pre>
+ * 
+ * <p>
+ * This class is optional, but if you use it, you must also include the
+ * <code>XmlException</code> class.
+ * <p>
+ * Do not extend this if you are using SAX; extend
+ * <code>org.xml.sax.HandlerBase</code> instead.
+ * 
+ * @author Copyright (c) 1998 by Microstar Software Ltd.
+ * @author written by David Megginson &lt;[e-mail]&gt;
+ * @version 1.1
+ * @see XmlHandler
+ * @see XmlException
+ * @see org.xml.sax.HandlerBase
+ */
+public abstract class HandlerBase implements XmlHandler {
+
+	/**
+	 * Handle the start of the document.
+	 * <p>
+	 * The default implementation does nothing.
+	 * 
+	 * @see com.microstar.xml.XmlHandler#startDocument
+	 */
+	@Override
+	public void startDocument() {
+	}
+
+	/**
+	 * Handle the end of the document.
+	 * <p>
+	 * The default implementation does nothing.
+	 * 
+	 * @see com.microstar.xml.XmlHandler#endDocument
+	 */
+	@Override
+	public void endDocument() {
+	}
+
+	/**
+	 * Resolve an external entity.
+	 * <p>
+	 * The default implementation simply returns the supplied system identifier.
+	 * 
+	 * @see com.microstar.xml.XmlHandler#resolveEntity
+	 */
+	@Override
+	public Object resolveEntity(String publicId, String systemId) {
+		return null;
+	}
+
+	/**
+	 * Handle the start of an external entity.
+	 * <p>
+	 * The default implementation does nothing.
+	 * 
+	 * @see com.microstar.xml.XmlHandler#startExternalEntity
+	 */
+	@Override
+	public void startExternalEntity(String systemId) {
+	}
+
+	/**
+	 * Handle the end of an external entity.
+	 * <p>
+	 * The default implementation does nothing.
+	 * 
+	 * @see com.microstar.xml.XmlHandler#endExternalEntity
+	 */
+	@Override
+	public void endExternalEntity(String systemId) {
+	}
+
+	/**
+	 * Handle a document type declaration.
+	 * <p>
+	 * The default implementation does nothing.
+	 * 
+	 * @see com.microstar.xml.XmlHandler#doctypeDecl
+	 */
+	@Override
+	public void doctypeDecl(String name, String publicId, String systemId) {
+	}
+
+	/**
+	 * Handle an attribute assignment.
+	 * <p>
+	 * The default implementation does nothing.
+	 * 
+	 * @see com.microstar.xml.XmlHandler#attribute
+	 */
+	@Override
+	public void attribute(String aname, String value, boolean isSpecified) {
+	}
+
+	/**
+	 * Handle the start of an element.
+	 * <p>
+	 * The default implementation does nothing.
+	 * 
+	 * @see com.microstar.xml.XmlHandler#startElement
+	 */
+	@Override
+	public void startElement(String elname) {
+	}
+
+	/**
+	 * Handle the end of an element.
+	 * <p>
+	 * The default implementation does nothing.
+	 * 
+	 * @see com.microstar.xml.XmlHandler#endElement
+	 */
+	@Override
+	public void endElement(String elname) {
+	}
+
+	/**
+	 * Handle character data.
+	 * <p>
+	 * The default implementation does nothing.
+	 * 
+	 * @see com.microstar.xml.XmlHandler#charData
+	 */
+	@Override
+	public void charData(char ch[], int start, int length) {
+	}
+
+	/**
+	 * Handle ignorable whitespace.
+	 * <p>
+	 * The default implementation does nothing.
+	 * 
+	 * @see com.microstar.xml.XmlHandler#ignorableWhitespace
+	 */
+	@Override
+	public void ignorableWhitespace(char ch[], int start, int length) {
+	}
+
+	/**
+	 * Handle a processing instruction.
+	 * <p>
+	 * The default implementation does nothing.
+	 * 
+	 * @see com.microstar.xml.XmlHandler#processingInstruction
+	 */
+	@Override
+	public void processingInstruction(String target, String data) {
+	}
+
+	/**
+	 * Throw an exception for a fatal error.
+	 * <p>
+	 * The default implementation throws <code>XmlException</code>.
+	 * 
+	 * @see com.microstar.xml.XmlHandler#error
+	 * @exception com.microstar.xml.XmlException
+	 *                A specific parsing error.
+	 * @exception java.lang.Exception
+	 *                Derived methods may throw exceptions.
+	 */
+	@Override
+	public void error(String message, String systemId, int line, int column)
+			throws XmlException, java.lang.Exception {
+		throw new XmlException(message, systemId, line, column);
+	}
+
+}
\ No newline at end of file

=== added file 'src/com/microstar/xml/XmlException.java'
--- src/com/microstar/xml/XmlException.java	1970-01-01 00:00:00 +0000
+++ src/com/microstar/xml/XmlException.java	2011-12-27 11:11:23 +0000
@@ -0,0 +1,99 @@
+// XmlException.java: Simple base class for AElfred processors.
+// NO WARRANTY! See README, and copyright below.
+// $Id: XmlException.java,v 1.1 2008-03-02 00:22:50 lywoon Exp $
+
+package com.microstar.xml;
+
+/**
+ * Convenience exception class for reporting XML parsing errors.
+ * <p>
+ * This is an exception class that you can use to encapsulate all of the
+ * information from &AElig;lfred's <code>error</code> callback. This is not
+ * necessary for routine use of &AElig;lfred, but it is used by the optional
+ * <code>HandlerBase</code> class.
+ * <p>
+ * Note that the core &AElig;lfred classes do <em>not</em> use this exception.
+ *
+ * @author Copyright (c) 1998 by Microstar Software Ltd.
+ * @author written by David Megginson &lt;[e-mail]&gt;
+ * @version 1.1
+ * @see XmlHandler#error
+ * @see HandlerBase
+ */
+public class XmlException extends Exception
+{
+    /**
+	 *
+	 */
+	private static final long serialVersionUID = 296196241316747669L;
+
+	private String message;
+
+    private String systemId;
+
+    private int line;
+
+    private int column;
+
+    /**
+     * Construct a new XML parsing exception.
+     *
+     * @param message
+     *            The error message from the parser.
+     * @param systemId
+     *            The URI of the entity containing the error.
+     * @param line
+     *            The line number where the error appeared.
+     * @param column
+     *            The column number where the error appeared.
+     */
+    public XmlException(String message, String systemId, int line, int column)
+    {
+        this.message = message;
+        this.systemId = systemId;
+        this.line = line;
+        this.column = column;
+    }
+
+    /**
+     * Get the error message from the parser.
+     *
+     * @return A string describing the error.
+     */
+    @Override
+	public String getMessage()
+    {
+        return this.message;
+    }
+
+    /**
+     * Get the URI of the entity containing the error.
+     *
+     * @return The URI as a string.
+     */
+    public String getSystemId()
+    {
+        return this.systemId;
+    }
+
+    /**
+     * Get the line number containing the error.
+     *
+     * @return The line number as an integer.
+     */
+    public int getLine()
+    {
+        return this.line;
+    }
+
+    /**
+     * Get the column number containing the error.
+     *
+     * @return The column number as an integer.
+     */
+    public int getColumn()
+    {
+        return this.column;
+    }
+
+}
\ No newline at end of file

=== added file 'src/com/microstar/xml/XmlHandler.java'
--- src/com/microstar/xml/XmlHandler.java	1970-01-01 00:00:00 +0000
+++ src/com/microstar/xml/XmlHandler.java	2011-12-27 11:11:23 +0000
@@ -0,0 +1,291 @@
+// XmlHandler.java: the callback interface.
+// NO WARRANTY! See README, and copyright below.
+// $Id: XmlHandler.java,v 1.1 2008-03-02 00:22:50 lywoon Exp $
+
+package com.microstar.xml;
+
+/**
+ * XML Processing Interface.
+ * <p>
+ * Whenever you parse an XML document, you must provide an object from a class
+ * that implements this interface to receive the parsing events.
+ * <p>
+ * If you do not want to implement this entire interface, you can extend the
+ * <code>HandlerBase</code> convenience class and then implement only what you
+ * need.
+ * <p>
+ * If you are using SAX, you should implement the SAX handler interfaces rather
+ * than this one.
+ *
+ * @author Copyright (c) 1997, 1998 by Microstar Software Ltd.
+ * @author written by David Megginson &lt;[e-mail]&gt;
+ * @version 1.1
+ * @see XmlParser
+ * @see HandlerBase
+ * @see org.xml.sax.EntityHandler
+ * @see org.xml.sax.DocumentHandler
+ * @see org.xml.sax.ErrorHandler
+ */
+public interface XmlHandler
+{
+
+    /**
+     * Start the document.
+     * <p>
+     * &AElig;lfred will call this method just before it attempts to read the
+     * first entity (the root of the document). It is guaranteed that this will
+     * be the first method called.
+     *
+     * @exception java.lang.Exception
+     *                The handler may throw any exception.
+     * @see #endDocument
+     */
+    public void startDocument() throws java.lang.Exception;
+
+    /**
+     * End the document.
+     * <p>
+     * &AElig;lfred will call this method once, when it has finished parsing the
+     * XML document. It is guaranteed that this will be the last method called.
+     *
+     * @exception java.lang.Exception
+     *                The handler may throw any exception.
+     * @see #startDocument
+     */
+    public void endDocument() throws java.lang.Exception;
+
+    /**
+     * Resolve an External Entity.
+     * <p>
+     * Give the handler a chance to redirect external entities to different
+     * URIs. &AElig;lfred will call this method for the top-level document
+     * entity, for external text (XML) entities, and the external DTD subset (if
+     * any).
+     *
+     * @param publicId
+     *            The public identifier, or null if none was supplied.
+     * @param systemId
+     *            The system identifier.
+     * @return The replacement system identifier, or null to use the default.
+     * @exception java.lang.Exception
+     *                The handler may throw any exception.
+     * @see #startExternalEntity
+     * @see #endExternalEntity
+     */
+    public Object resolveEntity(String publicId, String systemId)
+            throws java.lang.Exception;
+
+    /**
+     * Begin an external entity.
+     * <p>
+     * &AElig;lfred will call this method at the beginning of each external
+     * entity, including the top-level document entity and the external DTD
+     * subset (if any).
+     * <p>
+     * If necessary, you can use this method to track the location of the
+     * current entity so that you can resolve relative URIs correctly.
+     *
+     * @param systemId
+     *            The URI of the external entity that is starting.
+     * @exception java.lang.Exception
+     *                The handler may throw any exception.
+     * @see #endExternalEntity
+     * @see #resolveEntity
+     */
+    public void startExternalEntity(String systemId) throws java.lang.Exception;
+
+    /**
+     * End an external entity.
+     * <p>
+     * &AElig;lfred will call this method at the end of each external entity,
+     * including the top-level document entity and the external DTD subset.
+     * <p>
+     * If necessary, you can use this method to track the location of the
+     * current entity so that you can resolve relative URIs correctly.
+     *
+     * @param systemId
+     *            The URI of the external entity that is ending.
+     * @exception java.lang.Exception
+     *                The handler may throw any exception.
+     * @see #startExternalEntity
+     * @see #resolveEntity
+     */
+    public void endExternalEntity(String systemId) throws java.lang.Exception;
+
+    /**
+     * Document type declaration.
+     * <p>
+     * &AElig;lfred will call this method when or if it encounters the document
+     * type (DOCTYPE) declaration.
+     * <p>
+     * Please note that the public and system identifiers will not always be a
+     * reliable indication of the DTD in use.
+     *
+     * @param name
+     *            The document type name.
+     * @param publicId
+     *            The public identifier, or null if unspecified.
+     * @param systemId
+     *            The system identifier, or null if unspecified.
+     * @exception java.lang.Exception
+     *                The handler may throw any exception.
+     */
+    public void doctypeDecl(String name, String publicId, String systemId)
+            throws java.lang.Exception;
+
+    /**
+     * Attribute.
+     * <p>
+     * &AElig;lfred will call this method once for each attribute (specified or
+     * defaulted) before reporting a startElement event. It is up to your
+     * handler to collect the attributes, if necessary.
+     * <p>
+     * You may use XmlParser.getAttributeType() to find the attribute's declared
+     * type.
+     *
+     * @param name
+     *            The name of the attribute.
+     * @param type
+     *            The type of the attribute (see below).
+     * @param value
+     *            The value of the attribute, or null if the attribute is
+     *            <code>#IMPLIED</code>.
+     * @param isSpecified
+     *            True if the value was specified, false if it was defaulted
+     *            from the DTD.
+     * @exception java.lang.Exception
+     *                The handler may throw any exception.
+     * @see #startElement
+     * @see XmlParser#declaredAttributes
+     * @see XmlParser#getAttributeType
+     * @see XmlParser#getAttributeDefaultValue
+     */
+    public void attribute(String aname, String value, boolean isSpecified)
+            throws java.lang.Exception;
+
+    /**
+     * Start an element.
+     * <p>
+     * &AElig;lfred will call this method at the beginning of each element. By
+     * the time this is called, all of the attributes for the element will
+     * already have been reported using the <code>attribute</code> method.
+     *
+     * @param elname
+     *            The element type name.
+     * @exception java.lang.Exception
+     *                The handler may throw any exception.
+     * @see #attribute
+     * @see #endElement
+     * @see XmlParser#declaredElements
+     * @see XmlParser#getElementContentType
+     */
+    public void startElement(String elname) throws java.lang.Exception;
+
+    /**
+     * End an element.
+     * <p>
+     * &AElig;lfred will call this method at the end of each element (including
+     * EMPTY elements).
+     *
+     * @param elname
+     *            The element type name.
+     * @exception java.lang.Exception
+     *                The handler may throw any exception.
+     * @see #startElement
+     * @see XmlParser#declaredElements
+     * @see XmlParser#getElementContentType
+     */
+    public void endElement(String elname) throws java.lang.Exception;
+
+    /**
+     * Character data.
+     * <p>
+     * &AElig;lfred will call this method once for each chunk of character data
+     * found in the contents of elements. Note that the parser may break up a
+     * long sequence of characters into smaller chunks and call this method once
+     * for each chunk.
+     * <p>
+     * Do <em>not</em> attempt to read more than <var>length </var> characters
+     * from the array, or to read before the <var>start </var> position.
+     *
+     * @param ch
+     *            The character data.
+     * @param start
+     *            The starting position in the array.
+     * @param length
+     *            The number of characters available.
+     * @exception java.lang.Exception
+     *                The handler may throw any exception.
+     */
+    public void charData(char ch[], int start, int length)
+            throws java.lang.Exception;
+
+    /**
+     * Ignorable whitespace.
+     * <p>
+     * &AElig;lfred will call this method once for each sequence of ignorable
+     * whitespace in element content (never in mixed content).
+     * <p>
+     * For details, see section 2.10 of the XML 1.0 recommendation.
+     * <p>
+     * Do <em>not</em> attempt to read more than <var>length </var> characters
+     * from the array or to read before the <var>start </var> position.
+     *
+     * @param ch
+     *            The literal whitespace characters.
+     * @param start
+     *            The starting position in the array.
+     * @param length
+     *            The number of whitespace characters available.
+     * @exception java.lang.Exception
+     *                The handler may throw any exception.
+     */
+    public void ignorableWhitespace(char ch[], int start, int length)
+            throws java.lang.Exception;
+
+    /**
+     * Processing instruction.
+     * <p>
+     * &AElig;lfred will call this method once for each processing instruction.
+     * Note that processing instructions may appear outside of the top-level
+     * element. The
+     *
+     * @param target
+     *            The target (the name at the start of the PI).
+     * @param data
+     *            The data, if any (the rest of the PI).
+     * @exception java.lang.Exception
+     *                The handler may throw any exception.
+     */
+    public void processingInstruction(String target, String data)
+            throws java.lang.Exception;
+
+    /**
+     * Fatal XML parsing error.
+     * <p>
+     * &AElig;lfred will call this method whenever it encounters a serious
+     * error. The parser will attempt to continue past this point so that you
+     * can find more possible error points, but if this method is called you
+     * should assume that the document is corrupt and you should not try to use
+     * its contents.
+     * <p>
+     * Note that you can use the <code>XmlException</code> class to
+     * encapsulate all of the information provided, though the use of the class
+     * is not mandatory.
+     *
+     * @param message
+     *            The error message.
+     * @param systemId
+     *            The system identifier of the entity that contains the error.
+     * @param line
+     *            The approximate line number of the error.
+     * @param column
+     *            The approximate column number of the error.
+     * @exception java.lang.Exception
+     *                The handler may throw any exception.
+     * @see XmlException
+     */
+    public void error(String message, String systemId, int line, int column)
+            throws java.lang.Exception;
+
+}
\ No newline at end of file

=== added file 'src/com/microstar/xml/XmlParser.java'
--- src/com/microstar/xml/XmlParser.java	1970-01-01 00:00:00 +0000
+++ src/com/microstar/xml/XmlParser.java	2011-12-27 11:11:23 +0000
@@ -0,0 +1,4312 @@
+// XmlParser.java: the main parser class.
+// NO WARRANTY! See README, and copyright below.
+// $Id: XmlParser.java,v 1.3 2009-12-16 21:59:29 bruno Exp $
+
+package com.microstar.xml;
+
+import java.io.BufferedInputStream;
+import java.io.EOFException;
+import java.io.InputStream;
+import java.io.Reader;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Stack;
+
+/**
+ * Parse XML documents and return parse events through call-backs.
+ * <p>
+ * You need to define a class implementing the <code>XmlHandler</code>
+ * interface: an object belonging to this class will receive the callbacks for
+ * the events. (As an alternative to implementing the full XmlHandler interface,
+ * you can simply extend the <code>HandlerBase</code> convenience class.)
+ * <p>
+ * Usage (assuming that <code>MyHandler</code> is your implementation of the
+ * <code>XmlHandler</code> interface):
+ *
+ * <pre>
+ *
+ *
+ *
+ *    XmlHandler handler = new MyHandler();
+ *    XmlParser parser = new XmlParser();
+ *    parser.setHandler(handler);
+ *    try {
+ *      parser.parse(&quot;http://www.host.com/doc.xml&quot;, null);
+ *    } catch (Exception e) {
+ *      [do something interesting]
+ *    }
+ *
+ *
+ *
+ * </pre>
+ *
+ * <p>
+ * Alternatively, you can use the standard SAX interfaces with the
+ * <code>SAXDriver</code> class as your entry point.
+ *
+ * @author Copyright (c) 1997, 1998 by Microstar Software Ltd.
+ * @author Written by David Megginson &lt;[e-mail]&gt;
+ * @version 1.1
+ * @see XmlHandler
+ * @see HandlerBase
+ * @see SAXDriver
+ */
+public class XmlParser
+{
+
+    //
+    // Use special cheats that speed up the code (currently about 50%),
+    // but may cause problems with future maintenance and add to the
+    // class file size (about 500 bytes).
+    //
+    private final static boolean USE_CHEATS = true;
+
+    //////////////////////////////////////////////////////////////////////
+    // Constructors.
+    ////////////////////////////////////////////////////////////////////////
+
+    /**
+     * Construct a new parser with no associated handler.
+     *
+     * @see #setHandler
+     * @see #parse
+     */
+    public XmlParser()
+    {
+    }
+
+    /**
+     * Set the handler that will receive parsing events.
+     *
+     * @param handler
+     *            The handler to receive callback events.
+     * @see #parse
+     * @see XmlHandler
+     */
+    public void setHandler(XmlHandler handler)
+    {
+        this.handler = handler;
+    }
+
+    /**
+     * Parse an XML document from a URI.
+     * <p>
+     * You may parse a document more than once, but only one thread may call
+     * this method for an object at one time.
+     *
+     * @param systemId
+     *            The URI of the document.
+     * @param publicId
+     *            The public identifier of the document, or null.
+     * @param encoding
+     *            The suggested encoding, or null if unknown.
+     * @exception java.lang.Exception
+     *                Any exception thrown by your own handlers, or any
+     *                derivation of java.io.IOException thrown by the parser
+     *                itself.
+     */
+    public void parse(String systemId, String publicId, String encoding)
+            throws java.lang.Exception
+    {
+        doParse(systemId, publicId, null, null, encoding);
+    }
+
+    /**
+     * Parse an XML document from a byte stream.
+     * <p>
+     * The URI that you supply will become the base URI for resolving relative
+     * links, but &AElig;lfred will actually read the document from the supplied
+     * input stream.
+     * <p>
+     * You may parse a document more than once, but only one thread may call
+     * this method for an object at one time.
+     *
+     * @param systemId
+     *            The base URI of the document, or null if not known.
+     * @param publicId
+     *            The public identifier of the document, or null if not known.
+     * @param stream
+     *            A byte input stream.
+     * @param encoding
+     *            The suggested encoding, or null if unknown.
+     * @exception java.lang.Exception
+     *                Any exception thrown by your own handlers, or any
+     *                derivation of java.io.IOException thrown by the parser
+     *                itself.
+     */
+    public void parse(String systemId, String publicId, InputStream stream,
+            String encoding) throws java.lang.Exception
+    {
+        doParse(systemId, publicId, null, stream, encoding);
+    }
+
+    /**
+     * Parse an XML document from a character stream.
+     * <p>
+     * The URI that you supply will become the base URI for resolving relative
+     * links, but &AElig;lfred will actually read the document from the supplied
+     * input stream.
+     * <p>
+     * You may parse a document more than once, but only one thread may call
+     * this method for an object at one time.
+     *
+     * @param systemId
+     *            The base URI of the document, or null if not known.
+     * @param publicId
+     *            The public identifier of the document, or null if not known.
+     * @param reader
+     *            A character stream.
+     * @exception java.lang.Exception
+     *                Any exception thrown by your own handlers, or any
+     *                derivation of java.io.IOException thrown by the parser
+     *                itself.
+     */
+    public void parse(String systemId, String publicId, Reader reader)
+            throws java.lang.Exception
+    {
+        doParse(systemId, publicId, reader, null, null);
+    }
+
+    private synchronized void doParse(String systemId, String publicId,
+            Reader reader, InputStream stream, String encoding)
+            throws java.lang.Exception
+    {
+        this.basePublicId = publicId;
+        this.baseURI = systemId;
+        this.baseReader = reader;
+        this.baseInputStream = stream;
+
+        initializeVariables();
+
+        // Set the default entities here.
+        setInternalEntity(intern("amp"), "&#38;");
+        setInternalEntity(intern("lt"), "&#60;");
+        setInternalEntity(intern("gt"), "&#62;");
+        setInternalEntity(intern("apos"), "&#39;");
+        setInternalEntity(intern("quot"), "&#34;");
+
+        if (this.handler != null) {
+            this.handler.startDocument();
+        }
+
+        pushURL("[document]", this.basePublicId, this.baseURI, this.baseReader,
+                this.baseInputStream, encoding);
+
+        parseDocument();
+
+        if (this.handler != null) {
+            this.handler.endDocument();
+        }
+        cleanupVariables();
+    }
+
+    ////////////////////////////////////////////////////////////////////////
+    // Constants.
+    ////////////////////////////////////////////////////////////////////////
+
+    //
+    // Constants for element content type.
+    //
+
+    /**
+     * Constant: an element has not been declared.
+     *
+     * @see #getElementContentType
+     */
+    public final static int CONTENT_UNDECLARED = 0;
+
+    /**
+     * Constant: the element has a content model of ANY.
+     *
+     * @see #getElementContentType
+     */
+    public final static int CONTENT_ANY = 1;
+
+    /**
+     * Constant: the element has declared content of EMPTY.
+     *
+     * @see #getElementContentType
+     */
+    public final static int CONTENT_EMPTY = 2;
+
+    /**
+     * Constant: the element has mixed content.
+     *
+     * @see #getElementContentType
+     */
+    public final static int CONTENT_MIXED = 3;
+
+    /**
+     * Constant: the element has element content.
+     *
+     * @see #getElementContentType
+     */
+    public final static int CONTENT_ELEMENTS = 4;
+
+    //
+    // Constants for the entity type.
+    //
+
+    /**
+     * Constant: the entity has not been declared.
+     *
+     * @see #getEntityType
+     */
+    public final static int ENTITY_UNDECLARED = 0;
+
+    /**
+     * Constant: the entity is internal.
+     *
+     * @see #getEntityType
+     */
+    public final static int ENTITY_INTERNAL = 1;
+
+    /**
+     * Constant: the entity is external, non-XML data.
+     *
+     * @see #getEntityType
+     */
+    public final static int ENTITY_NDATA = 2;
+
+    /**
+     * Constant: the entity is external XML data.
+     *
+     * @see #getEntityType
+     */
+    public final static int ENTITY_TEXT = 3;
+
+    //
+    // Constants for attribute type.
+    //
+
+    /**
+     * Constant: the attribute has not been declared for this element type.
+     *
+     * @see #getAttributeType
+     */
+    public final static int ATTRIBUTE_UNDECLARED = 0;
+
+    /**
+     * Constant: the attribute value is a string value.
+     *
+     * @see #getAttributeType
+     */
+    public final static int ATTRIBUTE_CDATA = 1;
+
+    /**
+     * Constant: the attribute value is a unique identifier.
+     *
+     * @see #getAttributeType
+     */
+    public final static int ATTRIBUTE_ID = 2;
+
+    /**
+     * Constant: the attribute value is a reference to a unique identifier.
+     *
+     * @see #getAttributeType
+     */
+    public final static int ATTRIBUTE_IDREF = 3;
+
+    /**
+     * Constant: the attribute value is a list of ID references.
+     *
+     * @see #getAttributeType
+     */
+    public final static int ATTRIBUTE_IDREFS = 4;
+
+    /**
+     * Constant: the attribute value is the name of an entity.
+     *
+     * @see #getAttributeType
+     */
+    public final static int ATTRIBUTE_ENTITY = 5;
+
+    /**
+     * Constant: the attribute value is a list of entity names.
+     *
+     * @see #getAttributeType
+     */
+    public final static int ATTRIBUTE_ENTITIES = 6;
+
+    /**
+     * Constant: the attribute value is a name token.
+     *
+     * @see #getAttributeType
+     */
+    public final static int ATTRIBUTE_NMTOKEN = 7;
+
+    /**
+     * Constant: the attribute value is a list of name tokens.
+     *
+     * @see #getAttributeType
+     */
+    public final static int ATTRIBUTE_NMTOKENS = 8;
+
+    /**
+     * Constant: the attribute value is a token from an enumeration.
+     *
+     * @see #getAttributeType
+     */
+    public final static int ATTRIBUTE_ENUMERATED = 9;
+
+    /**
+     * Constant: the attribute is the name of a notation.
+     *
+     * @see #getAttributeType
+     */
+    public final static int ATTRIBUTE_NOTATION = 10;
+
+    //
+    // When the class is loaded, populate the hash table of
+    // attribute types.
+    //
+
+    /**
+     * Hash table of attribute types.
+     */
+    private static Hashtable<String, Integer> attributeTypeHash;
+    static {
+        attributeTypeHash = new Hashtable<String, Integer>();
+        attributeTypeHash.put("CDATA", new Integer(ATTRIBUTE_CDATA));
+        attributeTypeHash.put("ID", new Integer(ATTRIBUTE_ID));
+        attributeTypeHash.put("IDREF", new Integer(ATTRIBUTE_IDREF));
+        attributeTypeHash.put("IDREFS", new Integer(ATTRIBUTE_IDREFS));
+        attributeTypeHash.put("ENTITY", new Integer(ATTRIBUTE_ENTITY));
+        attributeTypeHash.put("ENTITIES", new Integer(ATTRIBUTE_ENTITIES));
+        attributeTypeHash.put("NMTOKEN", new Integer(ATTRIBUTE_NMTOKEN));
+        attributeTypeHash.put("NMTOKENS", new Integer(ATTRIBUTE_NMTOKENS));
+        attributeTypeHash.put("NOTATION", new Integer(ATTRIBUTE_NOTATION));
+    }
+
+    //
+    // Constants for supported encodings.
+    //
+    private final static int ENCODING_UTF_8 = 1;
+
+    private final static int ENCODING_ISO_8859_1 = 2;
+
+    private final static int ENCODING_UCS_2_12 = 3;
+
+    private final static int ENCODING_UCS_2_21 = 4;
+
+    private final static int ENCODING_UCS_4_1234 = 5;
+
+    private final static int ENCODING_UCS_4_4321 = 6;
+
+    private final static int ENCODING_UCS_4_2143 = 7;
+
+    private final static int ENCODING_UCS_4_3412 = 8;
+
+
+
+    //
+    // Constants for attribute default value.
+    //
+
+    /**
+     * Constant: the attribute is not declared.
+     *
+     * @see #getAttributeDefaultValueType
+     */
+    public final static int ATTRIBUTE_DEFAULT_UNDECLARED = 0;
+
+    /**
+     * Constant: the attribute has a literal default value specified.
+     *
+     * @see #getAttributeDefaultValueType
+     * @see #getAttributeDefaultValue
+     */
+    public final static int ATTRIBUTE_DEFAULT_SPECIFIED = 1;
+
+    /**
+     * Constant: the attribute was declared #IMPLIED.
+     *
+     * @see #getAttributeDefaultValueType
+     */
+    public final static int ATTRIBUTE_DEFAULT_IMPLIED = 2;
+
+    /**
+     * Constant: the attribute was declared #REQUIRED.
+     *
+     * @see #getAttributeDefaultValueType
+     */
+    public final static int ATTRIBUTE_DEFAULT_REQUIRED = 3;
+
+    /**
+     * Constant: the attribute was declared #FIXED.
+     *
+     * @see #getAttributeDefaultValueType
+     * @see #getAttributeDefaultValue
+     */
+    public final static int ATTRIBUTE_DEFAULT_FIXED = 4;
+
+    //
+    // Constants for input.
+    //
+    private final static int INPUT_NONE = 0;
+
+    private final static int INPUT_INTERNAL = 1;
+
+    private final static int INPUT_EXTERNAL = 2;
+
+    private final static int INPUT_STREAM = 3;
+
+    private final static int INPUT_BUFFER = 4;
+
+    private final static int INPUT_READER = 5;
+
+    //
+    // Flags for reading literals.
+    //
+    private final static int LIT_CHAR_REF = 1;
+
+    private final static int LIT_ENTITY_REF = 2;
+
+    private final static int LIT_PE_REF = 4;
+
+    private final static int LIT_NORMALIZE = 8;
+
+    //
+    // Flags for parsing context.
+    //
+    private final static int CONTEXT_NONE = 0;
+
+    private final static int CONTEXT_DTD = 1;
+
+    private final static int CONTEXT_ENTITYVALUE = 2;
+
+    private final static int CONTEXT_ATTRIBUTEVALUE = 3;
+
+    //////////////////////////////////////////////////////////////////////
+    // Error reporting.
+    //////////////////////////////////////////////////////////////////////
+
+    /**
+     * Report an error.
+     *
+     * @param message
+     *            The error message.
+     * @param textFound
+     *            The text that caused the error (or null).
+     * @see XmlHandler#error
+     * @see #line
+     */
+    void error(String message, String textFound, String textExpected)
+            throws java.lang.Exception
+    {
+        if (textFound != null) {
+            message = message + " (found \"" + textFound + "\")";
+        }
+        if (textExpected != null) {
+            message = message + " (expected \"" + textExpected + "\")";
+        }
+        if (this.handler != null) {
+            String uri = null;
+
+            if (this.externalEntity != null) {
+                uri = this.externalEntity.getURL().toString();
+            }
+            this.handler.error(message, uri, this.line, this.column);
+        }
+    }
+
+    /**
+     * Report a serious error.
+     *
+     * @param message
+     *            The error message.
+     * @param textFound
+     *            The text that caused the error (or null).
+     */
+    void error(String message, char textFound, String textExpected)
+            throws java.lang.Exception
+    {
+        error(message, new Character(textFound).toString(), textExpected);
+    }
+
+    //////////////////////////////////////////////////////////////////////
+    // Major syntactic productions.
+    //////////////////////////////////////////////////////////////////////
+
+    /**
+     * Parse an XML document.
+     *
+     * <pre>
+     *
+     *
+     *
+     *    [1] document ::= prolog element Misc*
+     *
+     *
+     *
+     * </pre>
+     *
+     * <p>
+     * This is the top-level parsing function for a single XML document. As a
+     * minimum, a well-formed document must have a document element, and a valid
+     * document must have a prolog as well.
+     */
+    void parseDocument() throws java.lang.Exception
+    {
+        char c;
+
+        parseProlog();
+        require('<');
+        parseElement();
+        try {
+            parseMisc(); //skip all white, PIs, and comments
+            c = readCh(); //if this doesn't throw an exception...
+            error("unexpected characters after document end", c, null);
+        } catch (EOFException e) {
+            return;
+        }
+    }
+
+    /**
+     * Skip a comment.
+     *
+     * <pre>
+     *
+     *
+     *
+     *    [18] Comment ::= '&lt;!--' ((Char - '-') | ('-' (Char - '-')))* &quot;--&gt;&quot;
+     *
+     *
+     *
+     * </pre>
+     *
+     * <p>
+     * (The <code>&lt;!--</code> has already been read.)
+     */
+    void parseComment() throws java.lang.Exception
+    {
+        skipUntil("-->");
+    }
+
+    /**
+     * Parse a processing instruction and do a call-back.
+     *
+     * <pre>
+     *
+     *
+     *
+     *    [19] PI ::= '&lt;?' Name (S (Char* - (Char* '?&gt;' Char*)))? '?&gt;'
+     *
+     *
+     *
+     * </pre>
+     *
+     * <p>
+     * (The <code>&lt;?</code> has already been read.)
+     * <p>
+     * An XML processing instruction <em>must</em> begin with a Name, which is
+     * the instruction's target.
+     */
+    void parsePI() throws java.lang.Exception
+    {
+        String name;
+
+        name = readNmtoken(true);
+        if (!tryRead("?>")) {
+            requireWhitespace();
+            parseUntil("?>");
+        }
+        if (this.handler != null) {
+            this.handler.processingInstruction(name, dataBufferToString());
+        }
+    }
+
+    /**
+     * Parse a CDATA marked section.
+     *
+     * <pre>
+     *
+     *
+     *
+     *    [20] CDSect ::= CDStart CData CDEnd
+     *    [21] CDStart ::= '&lt;![CDATA['
+     *    [22] CData ::= (Char* - (Char* ']]&gt;' Char*))
+     *    [23] CDEnd ::= ']]&gt;'
+     *
+     *
+     *
+     * </pre>
+     *
+     * <p>
+     * (The '&lt;![CDATA[' has already been read.)
+     * <p>
+     * Note that this just appends characters to the dataBuffer, without
+     * actually generating an event.
+     */
+    void parseCDSect() throws java.lang.Exception
+    {
+        parseUntil("]]>");
+    }
+
+    /**
+     * Parse the prolog of an XML document.
+     *
+     * <pre>
+     *
+     *
+     *
+     *    [24] prolog ::= XMPDecl? Misc* (Doctypedecl Misc*)?
+     *
+     *
+     *
+     * </pre>
+     *
+     * <p>
+     * There are a couple of tricks here. First, it is necessary to declare the
+     * XML default attributes after the DTD (if present) has been read. Second,
+     * it is not possible to expand general references in attribute value
+     * literals until after the entire DTD (if present) has been parsed.
+     * <p>
+     * We do not look for the XML declaration here, because it is handled by
+     * pushURL().
+     *
+     * @see pushURL
+     */
+    void parseProlog() throws java.lang.Exception
+    {
+        parseMisc();
+
+        if (tryRead("<!DOCTYPE")) {
+            parseDoctypedecl();
+            parseMisc();
+        }
+    }
+
+    /**
+     * Parse the XML declaration.
+     *
+     * <pre>
+     *
+     *
+     *
+     *    [25] XMPDecl ::= '&lt;?xml' VersionInfo EncodingDecl? SDDecl? S? '?&gt;'
+     *    [26] VersionInfo ::= S 'version' Eq ('&quot;1.0&quot;' | &quot;'1.0'&quot;)
+     *    [33] SDDecl ::= S 'standalone' Eq &quot;'&quot; ('yes' | 'no') &quot;'&quot;
+     *                  | S 'standalone' Eq '&quot;' (&quot;yes&quot; | &quot;no&quot;) '&quot;'
+     *    [78] EncodingDecl ::= S 'encoding' Eq QEncoding
+     *
+     *
+     *
+     * </pre>
+     *
+     * <p>
+     * ([80] to [82] are also significant.)
+     * <p>
+     * (The <code>&lt;?xml</code> and whitespace have already been read.)
+     *
+     * @see #parseTextDecl
+     * @see #checkEncoding
+     */
+    void parseXMPDecl(boolean ignoreEncoding) throws java.lang.Exception
+    {
+        String version;
+        String encodingName = null;
+        // Read the version.
+        require("version");
+        parseEq();
+        version = readLiteral(0);
+        if (!version.equals("1.0")) {
+            error("unsupported XML version", version, "1.0");
+        }
+
+        // Try reading an encoding declaration.
+        skipWhitespace();
+        if (tryRead("encoding")) {
+            parseEq();
+            encodingName = readLiteral(0);
+            checkEncoding(encodingName, ignoreEncoding);
+        }
+
+        // Try reading a standalone declaration
+        skipWhitespace();
+        if (tryRead("standalone")) {
+            parseEq();
+            readLiteral(0);
+        }
+
+        skipWhitespace();
+        require("?>");
+    }
+
+    /**
+     * Parse the Encoding PI.
+     *
+     * <pre>
+     *
+     *
+     *
+     *    [78] EncodingDecl ::= S 'encoding' Eq QEncoding
+     *    [79] EncodingPI ::= '&lt;?xml' S 'encoding' Eq QEncoding S? '?&gt;'
+     *    [80] QEncoding ::= '&quot;' Encoding '&quot;' | &quot;'&quot; Encoding &quot;'&quot;
+     *    [81] Encoding ::= LatinName
+     *    [82] LatinName ::= [A-Za-z] ([A-Za-z0-9._] | '-')*
+     *
+     *
+     *
+     * </pre>
+     *
+     * <p>
+     * (The <code>&lt;?xml</code>' and whitespace have already been read.)
+     *
+     * @see #parseXMPDecl
+     * @see #checkEncoding
+     */
+    void parseTextDecl(boolean ignoreEncoding) throws java.lang.Exception
+    {
+        String encodingName = null;
+
+        // Read an optional version.
+        if (tryRead("version")) {
+            String version;
+            parseEq();
+            version = readLiteral(0);
+            if (!version.equals("1.0")) {
+                error("unsupported XML version", version, "1.0");
+            }
+            requireWhitespace();
+        }
+
+        // Read the encoding.
+        require("encoding");
+        parseEq();
+        encodingName = readLiteral(0);
+        checkEncoding(encodingName, ignoreEncoding);
+
+        skipWhitespace();
+        require("?>");
+    }
+
+    /**
+     * Check that the encoding specified makes sense.
+     * <p>
+     * Compare what the author has specified in the XML declaration or encoding
+     * PI with what we have detected.
+     * <p>
+     * This is also important for distinguishing among the various 7- and 8-bit
+     * encodings, such as ISO-LATIN-1 (I cannot autodetect those).
+     *
+     * @param encodingName
+     *            The name of the encoding specified by the user.
+     * @see #parseXMPDecl
+     * @see #parseTextDecl
+     */
+    void checkEncoding(String encodingName, boolean ignoreEncoding)
+            throws java.lang.Exception
+    {
+        encodingName = encodingName.toUpperCase();
+
+        if (ignoreEncoding) {
+            return;
+        }
+
+        switch (this.encoding) {
+            // 8-bit encodings
+            case ENCODING_UTF_8:
+                if (encodingName.equals("ISO-8859-1")) {
+                    this.encoding = ENCODING_ISO_8859_1;
+                } else if (!encodingName.equals("UTF-8")) {
+                    error("unsupported 8-bit encoding", encodingName,
+                            "UTF-8 or ISO-8859-1");
+                }
+                break;
+            // 16-bit encodings
+            case ENCODING_UCS_2_12:
+            case ENCODING_UCS_2_21:
+                if (!encodingName.equals("ISO-10646-UCS-2")
+                        && !encodingName.equals("UTF-16")) {
+                    error("unsupported 16-bit encoding", encodingName,
+                            "ISO-10646-UCS-2");
+                }
+                break;
+            // 32-bit encodings
+            case ENCODING_UCS_4_1234:
+            case ENCODING_UCS_4_4321:
+            case ENCODING_UCS_4_2143:
+            case ENCODING_UCS_4_3412:
+                if (!encodingName.equals("ISO-10646-UCS-4")) {
+                    error("unsupported 32-bit encoding", encodingName,
+                            "ISO-10646-UCS-4");
+                }
+        }
+    }
+
+    /**
+     * Parse miscellaneous markup outside the document element and DOCTYPE
+     * declaration.
+     *
+     * <pre>
+     *
+     *
+     *
+     *    [27] Misc ::= Comment | PI | S
+     *
+     *
+     *
+     * </pre>
+     */
+    void parseMisc() throws java.lang.Exception
+    {
+        while (true) {
+            skipWhitespace();
+            if (tryRead("<?")) {
+                parsePI();
+            } else if (tryRead("<!--")) {
+                parseComment();
+            } else {
+                return;
+            }
+        }
+    }
+
+    /**
+     * Parse a document type declaration.
+     *
+     * <pre>
+     *
+     *
+     *
+     *    [28] doctypedecl ::= '&lt;!DOCTYPE' S Name (S ExternalID)? S?
+     *                         ('[' %markupdecl* ']' S?)? '&gt;'
+     *
+     *
+     *
+     * </pre>
+     *
+     * <p>
+     * (The <code>&lt;!DOCTYPE</code> has already been read.)
+     */
+    void parseDoctypedecl() throws java.lang.Exception
+    {
+        String doctypeName, ids[];
+
+        // Read the document type name.
+        requireWhitespace();
+        doctypeName = readNmtoken(true);
+
+        // Read the ExternalIDs.
+        skipWhitespace();
+        ids = readExternalIds(false);
+
+        // Look for a declaration subset.
+        skipWhitespace();
+        if (tryRead('[')) {
+
+            // loop until the subset ends
+            while (true) {
+                this.context = CONTEXT_DTD;
+                skipWhitespace();
+                this.context = CONTEXT_NONE;
+                if (tryRead(']')) {
+                    break; // end of subset
+                }
+				this.context = CONTEXT_DTD;
+				parseMarkupdecl();
+				this.context = CONTEXT_NONE;
+            }
+        }
+
+        // Read the external subset, if any
+        if (ids[1] != null) {
+            pushURL("[external subset]", ids[0], ids[1], null, null, null);
+
+            // Loop until we end up back at '>'
+            while (true) {
+                this.context = CONTEXT_DTD;
+                skipWhitespace();
+                this.context = CONTEXT_NONE;
+                if (tryRead('>')) {
+                    break;
+                }
+				this.context = CONTEXT_DTD;
+				parseMarkupdecl();
+				this.context = CONTEXT_NONE;
+            }
+        } else {
+            // No external subset.
+            skipWhitespace();
+            require('>');
+        }
+
+        if (this.handler != null) {
+            this.handler.doctypeDecl(doctypeName, ids[0], ids[1]);
+        }
+
+        // Expand general entities in
+        // default values of attributes.
+        // (Do this after the doctypeDecl
+        // event!).
+        // expandAttributeDefaultValues();
+    }
+
+    /**
+     * Parse a markup declaration in the internal or external DTD subset.
+     *
+     * <pre>
+     *
+     *
+     *
+     *    [29] markupdecl ::= ( %elementdecl | %AttlistDecl | %EntityDecl |
+     *                          %NotationDecl | %PI | %S | %Comment |
+     *                          InternalPERef )
+     *    [30] InternalPERef ::= PEReference
+     *    [31] extSubset ::= (%markupdecl | %conditionalSect)*
+     *
+     *
+     *
+     * </pre>
+     */
+    void parseMarkupdecl() throws java.lang.Exception
+    {
+        if (tryRead("<!ELEMENT")) {
+            parseElementdecl();
+        } else if (tryRead("<!ATTLIST")) {
+            parseAttlistDecl();
+        } else if (tryRead("<!ENTITY")) {
+            parseEntityDecl();
+        } else if (tryRead("<!NOTATION")) {
+            parseNotationDecl();
+        } else if (tryRead("<?")) {
+            parsePI();
+        } else if (tryRead("<!--")) {
+            parseComment();
+        } else if (tryRead("<![")) {
+            parseConditionalSect();
+        } else {
+            error("expected markup declaration", null, null);
+        }
+    }
+
+    /**
+     * Parse an element, with its tags.
+     *
+     * <pre>
+     *
+     *
+     *
+     *    [33] STag ::= '&lt;' Name (S Attribute)* S? '&gt;' [WFC: unique Att spec]
+     *    [38] element ::= EmptyElement | STag content ETag
+     *    [39] EmptyElement ::= '&lt;' Name (S Attribute)* S? '/&gt;'
+     *                          [WFC: unique Att spec]
+     *
+     *
+     *
+     * </pre>
+     *
+     * <p>
+     * (The '&lt;' has already been read.)
+     * <p>
+     * NOTE: this method actually chains onto parseContent(), if necessary, and
+     * parseContent() will take care of calling parseETag().
+     */
+    void parseElement() throws java.lang.Exception
+    {
+        String gi;
+        char c;
+        int oldElementContent = this.currentElementContent;
+        String oldElement = this.currentElement;
+
+        // This is the (global) counter for the
+        // array of specified attributes.
+        this.tagAttributePos = 0;
+
+        // Read the element type name.
+        gi = readNmtoken(true);
+
+        // Determine the current content type.
+        this.currentElement = gi;
+        this.currentElementContent = getElementContentType(gi);
+        if (this.currentElementContent == CONTENT_UNDECLARED) {
+            this.currentElementContent = CONTENT_ANY;
+        }
+
+        // Read the attributes, if any.
+        // After this loop, we should be just
+        // in front of the closing delimiter.
+        skipWhitespace();
+        c = readCh();
+        while (c != '/' && c != '>') {
+            unread(c);
+            parseAttribute(gi);
+            skipWhitespace();
+            c = readCh();
+        }
+        unread(c);
+
+        // Supply any defaulted attributes.
+        Enumeration<String> atts = declaredAttributes(gi);
+        if (atts != null) {
+            String aname;
+            loop: while (atts.hasMoreElements()) {
+                aname = atts.nextElement();
+                // See if it was specified.
+                for (int i = 0; i < this.tagAttributePos; i++) {
+                    if (this.tagAttributes[i] == aname) {
+                        continue loop;
+                    }
+                }
+                // I guess not...
+                if (this.handler != null) {
+                    this.handler.attribute(aname, getAttributeExpandedValue(gi,
+                            aname), false);
+                }
+            }
+        }
+
+        // Figure out if this is a start tag
+        // or an empty element, and dispatch an
+        // event accordingly.
+        c = readCh();
+        switch (c) {
+            case '>':
+                if (this.handler != null) {
+                    this.handler.startElement(gi);
+                }
+                parseContent();
+                break;
+            case '/':
+                require('>');
+                if (this.handler != null) {
+                    this.handler.startElement(gi);
+                    this.handler.endElement(gi);
+                }
+                break;
+        }
+
+        // Restore the previous state.
+        this.currentElement = oldElement;
+        this.currentElementContent = oldElementContent;
+    }
+
+    /**
+     * Parse an attribute assignment.
+     *
+     * <pre>
+     *
+     *
+     *
+     *    [34] Attribute ::= Name Eq AttValue
+     *
+     *
+     *
+     * </pre>
+     *
+     * @param name
+     *            The name of the attribute's element.
+     * @see XmlHandler#attribute
+     */
+    void parseAttribute(String name) throws java.lang.Exception
+    {
+        String aname;
+        int type;
+        String value;
+
+        // Read the attribute name.
+        aname = readNmtoken(true).intern();
+        type = getAttributeDefaultValueType(name, aname);
+
+        // Parse '='
+        parseEq();
+
+        // Read the value, normalizing whitespace
+        // if it is not CDATA.
+        if (type == ATTRIBUTE_CDATA || type == ATTRIBUTE_UNDECLARED) {
+            value = readLiteral(LIT_CHAR_REF | LIT_ENTITY_REF);
+        } else {
+            value = readLiteral(LIT_CHAR_REF | LIT_ENTITY_REF | LIT_NORMALIZE);
+        }
+
+        // Inform the handler about the
+        // attribute.
+        if (this.handler != null) {
+            this.handler.attribute(aname, value, true);
+        }
+        this.dataBufferPos = 0;
+
+        // Note that the attribute has been
+        // specified.
+        if (this.tagAttributePos == this.tagAttributes.length) {
+            String newAttrib[] = new String[this.tagAttributes.length * 2];
+            System.arraycopy(this.tagAttributes, 0, newAttrib, 0, this.tagAttributePos);
+            this.tagAttributes = newAttrib;
+        }
+        this.tagAttributes[this.tagAttributePos++] = aname;
+    }
+
+    /**
+     * Parse an equals sign surrounded by optional whitespace. [35] Eq ::= S?
+     * '=' S?
+     */
+    void parseEq() throws java.lang.Exception
+    {
+        skipWhitespace();
+        require('=');
+        skipWhitespace();
+    }
+
+    /**
+     * Parse an end tag. [36] ETag ::= ' </' Name S? '>' *NOTE: parseContent()
+     * chains to here.
+     */
+    void parseETag() throws java.lang.Exception
+    {
+        String name;
+        name = readNmtoken(true);
+        if (name != this.currentElement) {
+            error("mismatched end tag", name, this.currentElement);
+        }
+        skipWhitespace();
+        require('>');
+        if (this.handler != null) {
+            this.handler.endElement(name);
+        }
+    }
+
+    /**
+     * Parse the content of an element. [37] content ::= (element | PCData |
+     * Reference | CDSect | PI | Comment)* [68] Reference ::= EntityRef |
+     * CharRef
+     */
+    void parseContent() throws java.lang.Exception
+    {
+        char c;
+
+        while (true) {
+
+            switch (this.currentElementContent) {
+                case CONTENT_ANY:
+                case CONTENT_MIXED:
+                    parsePCData();
+                    break;
+                case CONTENT_ELEMENTS:
+                    parseWhitespace();
+                    break;
+            }
+
+            // Handle delimiters
+            c = readCh();
+            switch (c) {
+
+                case '&': // Found "&"
+                    c = readCh();
+                    if (c != '#') {
+                        unread(c);
+                        parseEntityRef(true);
+                    }
+                    break;
+
+                case '<': // Found "<"
+
+                    c = readCh();
+                    switch (c) {
+
+                        case '!': // Found "<!"
+                            c = readCh();
+                            switch (c) {
+                                case '-': // Found "<!-"
+                                    require('-');
+                                    parseComment();
+                                    break;
+                                case '[': // Found "<!["
+                                    require("CDATA[");
+                                    parseCDSect();
+                                    break;
+                                default:
+                                    error("expected comment or CDATA section",
+                                            c, null);
+                                    break;
+                            }
+                            break;
+
+                        case '?': // Found "<?"
+                            dataBufferFlush();
+                            parsePI();
+                            break;
+
+                        case '/': // Found "</"
+                            dataBufferFlush();
+                            parseETag();
+                            return;
+
+                        default: // Found "<" followed by something else
+                            dataBufferFlush();
+                            unread(c);
+                            parseElement();
+                            break;
+                    }
+            }
+        }
+    }
+
+    /**
+     * Parse an element type declaration. [40] elementdecl ::= ' <!ELEMENT' S
+     * %Name S (%S S)? %contentspec S? '>' [VC: Unique Element Declaration]
+     * *NOTE: the ' <!ELEMENT' has already been read.
+     */
+    void parseElementdecl() throws java.lang.Exception
+    {
+        String name;
+
+        requireWhitespace();
+        // Read the element type name.
+        name = readNmtoken(true);
+
+        requireWhitespace();
+        // Read the content model.
+        parseContentspec(name);
+
+        skipWhitespace();
+        require('>');
+    }
+
+    /**
+     * Content specification. [41] contentspec ::= 'EMPTY' | 'ANY' | Mixed |
+     * elements
+     */
+    void parseContentspec(String name) throws java.lang.Exception
+    {
+        if (tryRead("EMPTY")) {
+            setElement(name, CONTENT_EMPTY, null, null);
+            return;
+        } else if (tryRead("ANY")) {
+            setElement(name, CONTENT_ANY, null, null);
+            return;
+        } else {
+            require('(');
+            dataBufferAppend('(');
+            skipWhitespace();
+            if (tryRead("#PCDATA")) {
+                dataBufferAppend("#PCDATA");
+                parseMixed();
+                setElement(name, CONTENT_MIXED, dataBufferToString(), null);
+            } else {
+                parseElements();
+                setElement(name, CONTENT_ELEMENTS, dataBufferToString(), null);
+            }
+        }
+    }
+
+    /**
+     * Parse an element-content model. [42] elements ::= (choice | seq) ('?' |
+     * '*' | '+')? [44] cps ::= S? %cp S? [45] choice ::= '(' S? %ctokplus (S?
+     * '|' S? %ctoks)* S? ')' [46] ctokplus ::= cps ('|' cps)+ [47] ctoks ::=
+     * cps ('|' cps)* [48] seq ::= '(' S? %stoks (S? ',' S? %stoks)* S? ')' [49]
+     * stoks ::= cps (',' cps)* *NOTE: the opening '(' and S have already been
+     * read.
+     */
+    void parseElements() throws java.lang.Exception
+    {
+        char c;
+        char sep;
+
+        // Parse the first content particle
+        skipWhitespace();
+        parseCp();
+
+        // Check for end or for a separator.
+        skipWhitespace();
+        c = readCh();
+        switch (c) {
+            case ')':
+                dataBufferAppend(')');
+                c = readCh();
+                switch (c) {
+                    case '*':
+                    case '+':
+                    case '?':
+                        dataBufferAppend(c);
+                        break;
+                    default:
+                        unread(c);
+                }
+                return;
+            case ',': // Register the separator.
+            case '|':
+                sep = c;
+                dataBufferAppend(c);
+                break;
+            default:
+                error("bad separator in content model", c, null);
+                return;
+        }
+
+        // Parse the rest of the content model.
+        while (true) {
+            skipWhitespace();
+            parseCp();
+            skipWhitespace();
+            c = readCh();
+            if (c == ')') {
+                dataBufferAppend(')');
+                break;
+            } else if (c != sep) {
+                error("bad separator in content model", c, null);
+                return;
+            } else {
+                dataBufferAppend(c);
+            }
+        }
+
+        // Check for the occurrence indicator.
+        c = readCh();
+        switch (c) {
+            case '?':
+            case '*':
+            case '+':
+                dataBufferAppend(c);
+                return;
+            default:
+                unread(c);
+                return;
+        }
+    }
+
+    /**
+     * Parse a content particle. [43] cp ::= (Name | choice | seq) ('?' | '*' |
+     * '+') *NOTE: I actually use a slightly different production here: cp ::=
+     * (elements | (Name ('?' | '*' | '+')?))
+     */
+    void parseCp() throws java.lang.Exception
+    {
+        char c;
+
+        if (tryRead('(')) {
+            dataBufferAppend('(');
+            parseElements();
+        } else {
+            dataBufferAppend(readNmtoken(true));
+            c = readCh();
+            switch (c) {
+                case '?':
+                case '*':
+                case '+':
+                    dataBufferAppend(c);
+                    break;
+                default:
+                    unread(c);
+                    break;
+            }
+        }
+    }
+
+    /**
+     * Parse mixed content. [50] Mixed ::= '(' S? %( %'#PCDATA' (S? '|' S?
+     * %Mtoks)* ) S? ')*' | '(' S? %('#PCDATA') S? ')' [51] Mtoks ::= %Name (S?
+     * '|' S? %Name)* *NOTE: the S and '#PCDATA' have already been read.
+     */
+    void parseMixed() throws java.lang.Exception
+    {
+        // Check for PCDATA alone.
+        skipWhitespace();
+        if (tryRead(')')) {
+            dataBufferAppend(")*");
+            tryRead('*');
+            return;
+        }
+
+        // Parse mixed content.
+        skipWhitespace();
+        while (!tryRead(")*")) {
+            require('|');
+            dataBufferAppend('|');
+            skipWhitespace();
+            dataBufferAppend(readNmtoken(true));
+            skipWhitespace();
+        }
+        dataBufferAppend(")*");
+    }
+
+    /**
+     * Parse an attribute list declaration. [52] AttlistDecl ::= ' <!ATTLIST' S
+     * %Name S? %AttDef+ S? '>' *NOTE: the ' <!ATTLIST' has already been read.
+     */
+    void parseAttlistDecl() throws java.lang.Exception
+    {
+        String elementName;
+
+        requireWhitespace();
+        elementName = readNmtoken(true);
+        requireWhitespace();
+        while (!tryRead('>')) {
+            parseAttDef(elementName);
+            skipWhitespace();
+        }
+    }
+
+    /**
+     * Parse a single attribute definition. [53] AttDef ::= S %Name S %AttType S
+     * %Default
+     */
+    void parseAttDef(String elementName) throws java.lang.Exception
+    {
+        String name;
+        int type;
+        String enum_ = null;
+
+        // Read the attribute name.
+        name = readNmtoken(true);
+
+        // Read the attribute type.
+        requireWhitespace();
+        type = readAttType();
+
+        // Get the string of enumerated values
+        // if necessary.
+        if (type == ATTRIBUTE_ENUMERATED || type == ATTRIBUTE_NOTATION) {
+        	enum_ = dataBufferToString();
+        }
+
+        // Read the default value.
+        requireWhitespace();
+        parseDefault(elementName, name, type, enum_);
+    }
+
+    /**
+     * Parse the attribute type. [54] AttType ::= StringType | TokenizedType |
+     * EnumeratedType [55] StringType ::= 'CDATA' [56] TokenizedType ::= 'ID' |
+     * 'IDREF' | 'IDREFS' | 'ENTITY' | 'ENTITIES' | 'NMTOKEN' | 'NMTOKENS' [57]
+     * EnumeratedType ::= NotationType | Enumeration*
+     */
+    int readAttType() throws java.lang.Exception
+    {
+        String typeString;
+        Integer type;
+
+        if (tryRead('(')) {
+            parseEnumeration();
+            return ATTRIBUTE_ENUMERATED;
+        }
+		typeString = readNmtoken(true);
+		if (typeString.equals("NOTATION")) {
+		    parseNotationType();
+		}
+		type = attributeTypeHash.get(typeString);
+		if (type == null) {
+		    error("illegal attribute type", typeString, null);
+		    return ATTRIBUTE_UNDECLARED;
+		}
+		return type.intValue();
+    }
+
+    /**
+     * Parse an enumeration. [60] Enumeration ::= '(' S? %Etoks (S? '|' S?
+     * %Etoks)* S? ')' [61] Etoks ::= %Nmtoken (S? '|' S? %Nmtoken)* *NOTE: the
+     * '(' has already been read.
+     */
+    void parseEnumeration() throws java.lang.Exception
+    {
+        dataBufferAppend('(');
+
+        // Read the first token.
+        skipWhitespace();
+        dataBufferAppend(readNmtoken(true));
+        // Read the remaining tokens.
+        skipWhitespace();
+        while (!tryRead(')')) {
+            require('|');
+            dataBufferAppend('|');
+            skipWhitespace();
+            dataBufferAppend(readNmtoken(true));
+            skipWhitespace();
+        }
+        dataBufferAppend(')');
+    }
+
+    /**
+     * Parse a notation type for an attribute. [58] NotationType ::= %'NOTATION'
+     * S '(' S? %Ntoks (S? '|' S? %Ntoks)* S? ')' [59] Ntoks ::= %Name (S? '|'
+     * S? %Name) *NOTE: the 'NOTATION' has already been read
+     */
+    void parseNotationType() throws java.lang.Exception
+    {
+        requireWhitespace();
+        require('(');
+
+        parseEnumeration();
+    }
+
+    /**
+     * Parse the default value for an attribute. [62] Default ::= '#REQUIRED' |
+     * '#IMPLIED' | ((%'#FIXED' S)? %AttValue
+     */
+    void parseDefault(String elementName, String name, int type, String enum_)
+            throws java.lang.Exception
+    {
+        int valueType = ATTRIBUTE_DEFAULT_SPECIFIED;
+        String value = null;
+        if (tryRead('#')) {
+            if (tryRead("FIXED")) {
+                valueType = ATTRIBUTE_DEFAULT_FIXED;
+                requireWhitespace();
+                this.context = CONTEXT_ATTRIBUTEVALUE;
+                value = readLiteral(LIT_CHAR_REF);
+                this.context = CONTEXT_DTD;
+            } else if (tryRead("REQUIRED")) {
+                valueType = ATTRIBUTE_DEFAULT_REQUIRED;
+            } else if (tryRead("IMPLIED")) {
+                valueType = ATTRIBUTE_DEFAULT_IMPLIED;
+            } else {
+                error("illegal keyword for attribute default value", null, null);
+            }
+        } else {
+            this.context = CONTEXT_ATTRIBUTEVALUE;
+            value = readLiteral(LIT_CHAR_REF);
+            this.context = CONTEXT_DTD;
+        }
+        setAttribute(elementName, name, type, enum_, value, valueType);
+    }
+
+    /**
+     * Parse a conditional section. [63] conditionalSect ::= includeSect ||
+     * ignoreSect [64] includeSect ::= ' <![' %'INCLUDE' '[' (%markupdecl*)*
+     * ']]>' [65] ignoreSect ::= ' <![' %'IGNORE' '[' ignoreSectContents* ']]>'
+     * [66] ignoreSectContents ::= ((SkipLit | Comment | PI) -(Char* ']]>')) | ('
+     * <![' ignoreSectContents* ']]>') | (Char - (']' | [ <'"])) | (' <!' (Char -
+     * ('-' | '['))) *NOTE: the ' <![' has already been read.
+     */
+    void parseConditionalSect() throws java.lang.Exception
+    {
+        skipWhitespace();
+        if (tryRead("INCLUDE")) {
+            skipWhitespace();
+            require('[');
+            skipWhitespace();
+            while (!tryRead("]]>")) {
+                parseMarkupdecl();
+                skipWhitespace();
+            }
+        } else if (tryRead("IGNORE")) {
+            skipWhitespace();
+            require('[');
+            char c;
+            for (int nest = 1; nest > 0;) {
+                c = readCh();
+                switch (c) {
+                    case '<':
+                        if (tryRead("![")) {
+                            nest++;
+                        }
+                    //$FALL-THROUGH$
+				case ']':
+                        if (tryRead("]>")) {
+                            nest--;
+                        }
+                }
+            }
+        } else {
+            error("conditional section must begin with INCLUDE or IGNORE",
+                    null, null);
+        }
+    }
+
+    /**
+     * Parse a reference. [69] EntityRef ::= '&' Name ';' *NOTE: the '&' has
+     * already been read.
+     *
+     * @param externalAllowed
+     *            External entities are allowed here.
+     */
+    void parseEntityRef(boolean externalAllowed) throws java.lang.Exception
+    {
+        String name;
+
+        name = readNmtoken(true);
+        require(';');
+        switch (getEntityType(name)) {
+            case ENTITY_UNDECLARED:
+                error("reference to undeclared entity", name, null);
+                break;
+            case ENTITY_INTERNAL:
+                pushString(name, getEntityValue(name));
+                break;
+            case ENTITY_TEXT:
+                if (externalAllowed) {
+                    pushURL(name, getEntityPublicId(name),
+                            getEntitySystemId(name), null, null, null);
+                } else {
+                    error("reference to external entity in attribute value.",
+                            name, null);
+                }
+                break;
+            case ENTITY_NDATA:
+                if (externalAllowed) {
+                    error("data entity reference in content", name, null);
+                } else {
+                    error("reference to external entity in attribute value.",
+                            name, null);
+                }
+                break;
+        }
+    }
+
+    /**
+     * Parse a parameter entity reference. [70] PEReference ::= '%' Name ';'
+     * *NOTE: the '%' has already been read.
+     */
+    void parsePEReference(boolean isEntityValue) throws java.lang.Exception
+    {
+        String name;
+
+        name = "%" + readNmtoken(true);
+        require(';');
+        switch (getEntityType(name)) {
+            case ENTITY_UNDECLARED:
+                error("reference to undeclared parameter entity", name, null);
+                break;
+            case ENTITY_INTERNAL:
+                if (isEntityValue) {
+                    pushString(name, getEntityValue(name));
+                } else {
+                    pushString(name, " " + getEntityValue(name) + ' ');
+                }
+                break;
+            case ENTITY_TEXT:
+                if (isEntityValue) {
+                    pushString(null, " ");
+                }
+                pushURL(name, getEntityPublicId(name), getEntitySystemId(name),
+                        null, null, null);
+                if (isEntityValue) {
+                    pushString(null, " ");
+                }
+                break;
+        }
+    }
+
+    /**
+     * Parse an entity declaration. [71] EntityDecl ::= ' <!ENTITY' S %Name S
+     * %EntityDef S? '>' | ' <!ENTITY' S '%' S %Name S %EntityDef S? '>' [72]
+     * EntityDef ::= EntityValue | ExternalDef [73] ExternalDef ::= ExternalID
+     * %NDataDecl? [74] ExternalID ::= 'SYSTEM' S SystemLiteral | 'PUBLIC' S
+     * PubidLiteral S SystemLiteral [75] NDataDecl ::= S %'NDATA' S %Name *NOTE:
+     * the ' <!ENTITY' has already been read.
+     */
+    void parseEntityDecl() throws java.lang.Exception
+    {
+        char c;
+        boolean peFlag = false;
+        String name, value, notationName, ids[];
+
+        // Check for a parameter entity.
+        requireWhitespace();
+        if (tryRead('%')) {
+            peFlag = true;
+            requireWhitespace();
+        }
+
+        // Read the entity name, and prepend
+        // '%' if necessary.
+        name = readNmtoken(true);
+        if (peFlag) {
+            name = "%" + name;
+        }
+
+        // Read the entity value.
+        requireWhitespace();
+        c = readCh();
+        unread(c);
+        if (c == '"' || c == '\'') {
+            // Internal entity.
+            this.context = CONTEXT_ENTITYVALUE;
+            value = readLiteral(LIT_CHAR_REF | LIT_PE_REF);
+            this.context = CONTEXT_DTD;
+            setInternalEntity(name, value);
+        } else {
+            // Read the external IDs
+            ids = readExternalIds(false);
+            if (ids[1] == null) {
+                error("system identifer missing", name, null);
+            }
+
+            // Check for NDATA declaration.
+            skipWhitespace();
+            if (tryRead("NDATA")) {
+                requireWhitespace();
+                notationName = readNmtoken(true);
+                setExternalDataEntity(name, ids[0], ids[1], notationName);
+            } else {
+                setExternalTextEntity(name, ids[0], ids[1]);
+            }
+        }
+
+        // Finish the declaration.
+        skipWhitespace();
+        require('>');
+    }
+
+    /**
+     * Parse a notation declaration. [81] NotationDecl ::= ' <!NOTATION' S %Name
+     * S %ExternalID S? '>' *NOTE: the ' <!NOTATION' has already been read.
+     */
+    void parseNotationDecl() throws java.lang.Exception
+    {
+        String nname, ids[];
+
+        requireWhitespace();
+        nname = readNmtoken(true);
+
+        requireWhitespace();
+
+        // Read the external identifiers.
+        ids = readExternalIds(true);
+        if (ids[0] == null && ids[1] == null) {
+            error("external identifer missing", nname, null);
+        }
+
+        // Register the notation.
+        setNotation(nname, ids[0], ids[1]);
+
+        skipWhitespace();
+        require('>');
+    }
+
+    /**
+     * Parse PCDATA.
+     *
+     * <pre>
+     *
+     *
+     *
+     *    [16] PCData ::= [&circ;&lt;&amp;]*
+     *
+     *
+     *
+     * </pre>
+     *
+     * <p>
+     * The trick here is that the data stays in the dataBuffer without
+     * necessarily being converted to a string right away.
+     */
+    void parsePCData() throws java.lang.Exception
+    {
+        char c;
+
+        // Start with a little cheat -- in most
+        // cases, the entire sequence of
+        // character data will already be in
+        // the readBuffer; if not, fall through to
+        // the normal approach.
+        if (USE_CHEATS) {
+            int lineAugment = 0;
+            int columnAugment = 0;
+
+            for (int i = this.readBufferPos; i < this.readBufferLength; i++) {
+                switch (this.readBuffer[i]) {
+                    case '\n':
+                        lineAugment++;
+                        columnAugment = 0;
+                        break;
+                    case '&':
+                    case '<':
+                        int start = this.readBufferPos;
+                        columnAugment++;
+                        this.readBufferPos = i;
+                        if (lineAugment > 0) {
+                            this.line += lineAugment;
+                            this.column = columnAugment;
+                        } else {
+                            this.column += columnAugment;
+                        }
+                        dataBufferAppend(this.readBuffer, start, i - start);
+                        return;
+                    default:
+                        columnAugment++;
+                }
+            }
+        }
+
+        // OK, the cheat didn't work; start over
+        // and do it by the book.
+        while (true) {
+            c = readCh();
+            switch (c) {
+                case '<':
+                case '&':
+                    unread(c);
+                    return;
+                default:
+                    dataBufferAppend(c);
+                    break;
+            }
+        }
+    }
+
+    //////////////////////////////////////////////////////////////////////
+    // High-level reading and scanning methods.
+    //////////////////////////////////////////////////////////////////////
+
+    /**
+     * Require whitespace characters. [1] S ::= (#x20 | #x9 | #xd | #xa)+
+     */
+    void requireWhitespace() throws java.lang.Exception
+    {
+        char c = readCh();
+        if (isWhitespace(c)) {
+            skipWhitespace();
+        } else {
+            error("whitespace expected", c, null);
+        }
+    }
+
+    /**
+     * Parse whitespace characters, and leave them in the data buffer.
+     */
+    void parseWhitespace() throws java.lang.Exception
+    {
+        char c = readCh();
+        while (isWhitespace(c)) {
+            dataBufferAppend(c);
+            c = readCh();
+        }
+        unread(c);
+    }
+
+    /**
+     * Skip whitespace characters. [1] S ::= (#x20 | #x9 | #xd | #xa)+
+     */
+    void skipWhitespace() throws java.lang.Exception
+    {
+        // Start with a little cheat. Most of
+        // the time, the white space will fall
+        // within the current read buffer; if
+        // not, then fall through.
+        if (USE_CHEATS) {
+            int lineAugment = 0;
+            int columnAugment = 0;
+
+            loop: for (int i = this.readBufferPos; i < this.readBufferLength; i++) {
+                switch (this.readBuffer[i]) {
+                    case ' ':
+                    case '\t':
+                    case '\r':
+                        columnAugment++;
+                        break;
+                    case '\n':
+                        lineAugment++;
+                        columnAugment = 0;
+                        break;
+                    case '%':
+                        if (this.context == CONTEXT_DTD
+                                || this.context == CONTEXT_ENTITYVALUE) {
+                            break loop;
+                        } // else fall through...
+                    //$FALL-THROUGH$
+				default:
+                        this.readBufferPos = i;
+                        if (lineAugment > 0) {
+                            this.line += lineAugment;
+                            this.column = columnAugment;
+                        } else {
+                            this.column += columnAugment;
+                        }
+                        return;
+                }
+            }
+        }
+
+        // OK, do it by the book.
+        char c = readCh();
+        while (isWhitespace(c)) {
+            c = readCh();
+        }
+        unread(c);
+    }
+
+    /**
+     * Read a name or name token. [5] Name ::= (Letter | '_' | ':') (NameChar)*
+     * [7] Nmtoken ::= (NameChar)+ *NOTE: [6] is implemented implicitly where
+     * required.
+     */
+    String readNmtoken(boolean isName) throws java.lang.Exception
+    {
+        char c;
+
+        if (USE_CHEATS) {
+            loop: for (int i = this.readBufferPos; i < this.readBufferLength; i++) {
+                switch (this.readBuffer[i]) {
+                    case '%':
+                        if (this.context == CONTEXT_DTD
+                                || this.context == CONTEXT_ENTITYVALUE) {
+                            break loop;
+                        } // else fall through...
+                    //$FALL-THROUGH$
+				case '<':
+                    case '>':
+                    case '&':
+                    case ',':
+                    case '|':
+                    case '*':
+                    case '+':
+                    case '?':
+                    case ')':
+                    case '=':
+                    case '\'':
+                    case '"':
+                    case '[':
+                    case ' ':
+                    case '\t':
+                    case '\r':
+                    case '\n':
+                    case ';':
+                    case '/':
+                    case '#':
+                        int start = this.readBufferPos;
+                        if (i == start) {
+                            error("name expected", this.readBuffer[i], null);
+                        }
+                        this.readBufferPos = i;
+                        return intern(this.readBuffer, start, i - start);
+                }
+            }
+        }
+
+        this.nameBufferPos = 0;
+
+        // Read the first character.
+        while (true) {
+            c = readCh();
+            switch (c) {
+                case '%':
+                case '<':
+                case '>':
+                case '&':
+                case ',':
+                case '|':
+                case '*':
+                case '+':
+                case '?':
+                case ')':
+                case '=':
+                case '\'':
+                case '"':
+                case '[':
+                case ' ':
+                case '\t':
+                case '\n':
+                case '\r':
+                case ';':
+                case '/':
+                    unread(c);
+                    if (this.nameBufferPos == 0) {
+                        error("name expected", null, null);
+                    }
+                    String s = intern(this.nameBuffer, 0, this.nameBufferPos);
+                    this.nameBufferPos = 0;
+                    return s;
+                default:
+                    this.nameBuffer = (char[]) extendArray(this.nameBuffer,
+                            this.nameBuffer.length, this.nameBufferPos);
+                    this.nameBuffer[this.nameBufferPos++] = c;
+            }
+        }
+    }
+
+    /**
+     * Read a literal. [10] AttValue ::= '"' ([^ <&"] | Reference)* '"' | "'"
+     * ([^ <&'] | Reference)* "'" [11] SystemLiteral ::= '"' URLchar* '"' | "'"
+     * (URLchar - "'")* "'" [13] PubidLiteral ::= '"' PubidChar* '"' | "'"
+     * (PubidChar - "'")* "'" [9] EntityValue ::= '"' ([^%&"] | PEReference |
+     * Reference)* '"' | "'" ([^%&'] | PEReference | Reference)* "'"
+     */
+    String readLiteral(int flags) throws java.lang.Exception
+    {
+        char delim, c;
+        int startLine = this.line;
+
+        // Find the delimiter.
+        delim = readCh();
+        if (delim != '"' && delim != '\'' && delim != (char) 0) {
+            error("expected '\"' or \"'\"", delim, null);
+            return null;
+        }
+
+        // Read the literal.
+        try {
+            c = readCh();
+
+            loop: while (c != delim) {
+                switch (c) {
+                    // Literals never have line ends
+                    case '\n':
+                    case '\r':
+                        c = ' ';
+                        break;
+                    // References may be allowed
+                    case '&':
+                        if ((flags & LIT_CHAR_REF) > 0) {
+                            c = readCh();
+                            if (c == '#') {
+                                c = readCh();
+                                continue loop; // check the next character
+                            } else if ((flags & LIT_ENTITY_REF) > 0) {
+                                unread(c);
+                                parseEntityRef(false);
+                                c = readCh();
+                                continue loop;
+                            } else {
+                                dataBufferAppend('&');
+                            }
+                        }
+                        break;
+
+                    default:
+                        break;
+                }
+                dataBufferAppend(c);
+                c = readCh();
+            }
+        } catch (EOFException e) {
+            error("end of input while looking for delimiter (started on line "
+                    + startLine + ')', null, new Character(delim).toString());
+        }
+
+        // Normalise whitespace if necessary.
+        if ((flags & LIT_NORMALIZE) > 0) {
+            dataBufferNormalize();
+        }
+
+        // Return the value.
+        return dataBufferToString();
+    }
+
+    /**
+     * Try reading external identifiers.
+     * <p>
+     * The system identifier is not required for notations.
+     *
+     * @param inNotation
+     *            Are we in a notation?
+     * @return A two-member String array containing the identifiers.
+     */
+    String[] readExternalIds(boolean inNotation) throws java.lang.Exception
+    {
+        String ids[] = new String[2];
+
+        if (tryRead("PUBLIC")) {
+            requireWhitespace();
+            ids[0] = readLiteral(LIT_NORMALIZE); // public id
+            if (inNotation) {
+                skipWhitespace();
+                if (tryRead('"') || tryRead('\'')) {
+                    ids[1] = readLiteral(0);
+                }
+            } else {
+                requireWhitespace();
+                ids[1] = readLiteral(0); // system id
+            }
+        } else if (tryRead("SYSTEM")) {
+            requireWhitespace();
+            ids[1] = readLiteral(0); // system id
+        }
+
+        return ids;
+    }
+
+    /**
+     * Test if a character is whitespace.
+     *
+     * <pre>
+     *
+     *
+     *
+     *    [1] S ::= (#x20 | #x9 | #xd | #xa)+
+     *
+     *
+     *
+     * </pre>
+     *
+     * @param c
+     *            The character to test.
+     * @return true if the character is whitespace.
+     */
+    final boolean isWhitespace(char c)
+    {
+        switch (c) {
+            case 0x20:
+            case 0x09:
+            case 0x0d:
+            case 0x0a:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    //////////////////////////////////////////////////////////////////////
+    // Utility routines.
+    //////////////////////////////////////////////////////////////////////
+
+    /**
+     * Add a character to the data buffer.
+     */
+    void dataBufferAppend(char c)
+    {
+        // Expand buffer if necessary.
+        this.dataBuffer = (char[]) extendArray(this.dataBuffer, this.dataBuffer.length,
+                this.dataBufferPos);
+        this.dataBuffer[this.dataBufferPos++] = c;
+    }
+
+    /**
+     * Add a string to the data buffer.
+     */
+    void dataBufferAppend(String s)
+    {
+        dataBufferAppend(s.toCharArray(), 0, s.length());
+    }
+
+    /**
+     * Append (part of) a character array to the data buffer.
+     */
+    void dataBufferAppend(char ch[], int start, int length)
+    {
+        this.dataBuffer = (char[]) extendArray(this.dataBuffer, this.dataBuffer.length,
+                this.dataBufferPos + length);
+        System.arraycopy(ch, start, this.dataBuffer,
+                this.dataBufferPos, length);
+        this.dataBufferPos += length;
+    }
+
+    /**
+     * Normalise whitespace in the data buffer.
+     */
+    void dataBufferNormalize()
+    {
+        int i = 0;
+        int j = 0;
+        int end = this.dataBufferPos;
+
+        // Skip whitespace at the start.
+        while (j < end && isWhitespace(this.dataBuffer[j])) {
+            j++;
+        }
+
+        // Skip whitespace at the end.
+        while (end > j && isWhitespace(this.dataBuffer[end - 1])) {
+            end--;
+        }
+
+        // Start copying to the left.
+        while (j < end) {
+
+            char c = this.dataBuffer[j++];
+
+            // Normalise all other whitespace to
+            // a single space.
+            if (isWhitespace(c)) {
+                while (j < end && isWhitespace(this.dataBuffer[j++])) {
+                }
+                this.dataBuffer[i++] = ' ';
+                this.dataBuffer[i++] = this.dataBuffer[j - 1];
+            } else {
+                this.dataBuffer[i++] = c;
+            }
+        }
+
+        // The new length is <= the old one.
+        this.dataBufferPos = i;
+    }
+
+    /**
+     * Convert the data buffer to a string.
+     *
+     * @param internFlag
+     *            true if the contents should be interned.
+     * @see #intern(char[],int,int)
+     */
+    String dataBufferToString()
+    {
+        String s = new String(this.dataBuffer, 0, this.dataBufferPos);
+        this.dataBufferPos = 0;
+        return s;
+    }
+
+    /**
+     * Flush the contents of the data buffer to the handler, if appropriate, and
+     * reset the buffer for new input.
+     */
+    void dataBufferFlush() throws java.lang.Exception
+    {
+        if (this.dataBufferPos > 0) {
+            switch (this.currentElementContent) {
+                case CONTENT_UNDECLARED:
+                case CONTENT_EMPTY:
+                    // do nothing
+                    break;
+                case CONTENT_MIXED:
+                case CONTENT_ANY:
+                    if (this.handler != null) {
+                        this.handler.charData(this.dataBuffer, 0, this.dataBufferPos);
+                    }
+                    break;
+                case CONTENT_ELEMENTS:
+                    if (this.handler != null) {
+                        this.handler.ignorableWhitespace(this.dataBuffer, 0,
+                                this.dataBufferPos);
+                    }
+                    break;
+            }
+            this.dataBufferPos = 0;
+        }
+    }
+
+    /**
+     * Require a string to appear, or throw an exception.
+     */
+    void require(String delim) throws java.lang.Exception
+    {
+        char ch[] = delim.toCharArray();
+        for (int i = 0; i < ch.length; i++) {
+            require(ch[i]);
+        }
+    }
+
+    /**
+     * Require a character to appear, or throw an exception.
+     */
+    void require(char delim) throws java.lang.Exception
+    {
+        char c = readCh();
+
+        if (c != delim) {
+            error("expected character", c, new Character(delim).toString());
+        }
+    }
+
+    /**
+     * Return an internalised version of a string.
+     * <p>
+     * &AElig;lfred uses this method to create an internalised version of all
+     * names and attribute values, so that it can test equality with
+     * <code>==</code> instead of <code>String.equals()</code>.
+     * <p>
+     * If you want to be able to test for equality in the same way, you can use
+     * this method to internalise your own strings first:
+     *
+     * <pre>
+     * String PARA = handler.intern(&quot;PARA&quot;);
+     * </pre>
+     *
+     * <p>
+     * Note that this will not return the same results as String.intern().
+     *
+     * @param s
+     *            The string to internalise.
+     * @return An internalised version of the string.
+     * @see #intern(char[],int,int)
+     * @see java.lang.String#intern
+     */
+    public String intern(String s)
+    {
+        char ch[] = s.toCharArray();
+        return intern(ch, 0, ch.length);
+    }
+
+    /**
+     * Create an internalised string from a character array.
+     * <p>
+     * This is much more efficient than constructing a non-internalised string
+     * first, and then internalising it.
+     * <p>
+     * Note that this will not return the same results as String.intern().
+     *
+     * @param ch
+     *            an array of characters for building the string.
+     * @param start
+     *            the starting position in the array.
+     * @param length
+     *            the number of characters to place in the string.
+     * @return an internalised string.
+     * @see #intern(String)
+     * @see java.lang.String#intern
+     */
+    public String intern(char ch[], int start, int length)
+    {
+        int index;
+        int hash = 0;
+
+        // Generate a hash code.
+        for (int i = start; i < start + length; i++) {
+            hash = ((hash << 1) & 0xffffff) + ch[i];
+        }
+
+        hash = hash % SYMBOL_TABLE_LENGTH;
+
+        // Get the bucket.
+        Object bucket[] = (Object[]) this.symbolTable[hash];
+        if (bucket == null) {
+            this.symbolTable[hash] = bucket = new Object[8];
+        }
+
+        // Search for a matching tuple, and
+        // return the string if we find one.
+        for (index = 0; index < bucket.length; index += 2) {
+            char chFound[] = (char[]) bucket[index];
+
+            // Stop when we hit a null index.
+            if (chFound == null) {
+                break;
+            }
+
+            // If they're the same length,
+            // check for a match.
+            // If the loop finishes, 'index' will
+            // contain the current bucket
+            // position.
+            if (chFound.length == length) {
+                for (int i = 0; i < chFound.length; i++) {
+                    // Stop if there are no more tuples.
+                    if (ch[start + i] != chFound[i]) {
+                        break;
+                    } else if (i == length - 1) {
+                        // That's it, we have a match!
+                        return (String) bucket[index + 1];
+                    }
+                }
+            }
+        }
+
+        // Not found -- we'll have to add it.
+
+        // Do we have to grow the bucket?
+        bucket = (Object[]) extendArray(bucket, bucket.length, index);
+
+        // OK, add it to the end of the
+        // bucket.
+        String s = new String(ch, start, length);
+        bucket[index] = s.toCharArray();
+        bucket[index + 1] = s;
+        this.symbolTable[hash] = bucket;
+        return s;
+    }
+
+    /**
+     * Ensure the capacity of an array, allocating a new one if necessary.
+     */
+    Object extendArray(Object array, int currentSize, int requiredSize)
+    {
+        if (requiredSize < currentSize) {
+            return array;
+        }
+		Object newArray = null;
+		int newSize = currentSize * 2;
+
+		if (newSize <= requiredSize) {
+		    newSize = requiredSize + 1;
+		}
+
+		if (array instanceof char[]) {
+		    newArray = new char[currentSize * 2];
+		} else if (array instanceof Object[]) {
+		    newArray = new Object[currentSize * 2];
+		}
+
+		System.arraycopy(array, 0, newArray, 0, currentSize);
+		return newArray;
+    }
+
+    //////////////////////////////////////////////////////////////////////
+    // XML query routines.
+    //////////////////////////////////////////////////////////////////////
+
+    //
+    // Elements
+    //
+
+    /**
+     * Get the declared elements for an XML document.
+     * <p>
+     * The results will be valid only after the DTD (if any) has been parsed.
+     *
+     * @return An enumeration of all element types declared for this document
+     *         (as Strings).
+     * @see #getElementContentType
+     * @see #getElementContentModel
+     */
+    public Enumeration<String> declaredElements()
+    {
+        return this.elementInfo.keys();
+    }
+
+    /**
+     * Look up the content type of an element.
+     *
+     * @param name
+     *            The element type name.
+     * @return An integer constant representing the content type.
+     * @see #getElementContentModel
+     * @see #CONTENT_UNDECLARED
+     * @see #CONTENT_ANY
+     * @see #CONTENT_EMPTY
+     * @see #CONTENT_MIXED
+     * @see #CONTENT_ELEMENTS
+     */
+    public int getElementContentType(String name)
+    {
+        Object element[] = this.elementInfo.get(name);
+        if (element == null) {
+            return CONTENT_UNDECLARED;
+        }
+		return ((Integer) element[0]).intValue();
+    }
+
+    /**
+     * Look up the content model of an element.
+     * <p>
+     * The result will always be null unless the content type is
+     * CONTENT_ELEMENTS or CONTENT_MIXED.
+     *
+     * @param name
+     *            The element type name.
+     * @return The normalised content model, as a string.
+     * @see #getElementContentType
+     */
+    public String getElementContentModel(String name)
+    {
+        Object element[] = this.elementInfo.get(name);
+        if (element == null) {
+            return null;
+        }
+		return (String) element[1];
+    }
+
+    /**
+     * Register an element. Array format: element type attribute hash table
+     */
+    void setElement(String name, int contentType, String contentModel,
+            Hashtable<String, Object[]> attributes) throws java.lang.Exception
+    {
+        Object element[];
+
+        // Try looking up the element
+        element = this.elementInfo.get(name);
+
+        // Make a new one if necessary.
+        if (element == null) {
+            element = new Object[3];
+            element[0] = new Integer(CONTENT_UNDECLARED);
+            element[1] = null;
+            element[2] = null;
+        } else if (contentType != CONTENT_UNDECLARED
+                && ((Integer) element[0]).intValue() != CONTENT_UNDECLARED) {
+            error("multiple declarations for element type", name, null);
+            return;
+        }
+
+        // Insert the content type, if any.
+        if (contentType != CONTENT_UNDECLARED) {
+            element[0] = new Integer(contentType);
+        }
+
+        // Insert the content model, if any.
+        if (contentModel != null) {
+            element[1] = contentModel;
+        }
+
+        // Insert the attributes, if any.
+        if (attributes != null) {
+            element[2] = attributes;
+        }
+
+        // Save the element info.
+        this.elementInfo.put(name, element);
+    }
+
+    /**
+     * Look up the attribute hash table for an element. The hash table is the
+     * second item in the element array.
+     */
+    @SuppressWarnings("unchecked")
+	Hashtable<String, Object[]> getElementAttributes(String name)
+    {
+        Object element[] = this.elementInfo.get(name);
+        if (element == null) {
+            return null;
+        }
+		return (Hashtable<String, Object[]>) element[2];
+    }
+
+    //
+    // Attributes
+    //
+
+    /**
+     * Get the declared attributes for an element type.
+     *
+     * @param elname
+     *            The name of the element type.
+     * @return An Enumeration of all the attributes declared for a specific
+     *         element type. The results will be valid only after the DTD (if
+     *         any) has been parsed.
+     * @see #getAttributeType
+     * @see #getAttributeEnumeration
+     * @see #getAttributeDefaultValueType
+     * @see #getAttributeDefaultValue
+     * @see #getAttributeExpandedValue
+     */
+    public Enumeration<String> declaredAttributes(String elname)
+    {
+        Hashtable<String, Object[]> attlist = getElementAttributes(elname);
+
+        if (attlist == null) {
+            return null;
+        }
+		return attlist.keys();
+    }
+
+    /**
+     * Retrieve the declared type of an attribute.
+     *
+     * @param name
+     *            The name of the associated element.
+     * @param aname
+     *            The name of the attribute.
+     * @return An integer constant representing the attribute type.
+     * @see #ATTRIBUTE_UNDECLARED
+     * @see #ATTRIBUTE_CDATA
+     * @see #ATTRIBUTE_ID
+     * @see #ATTRIBUTE_IDREF
+     * @see #ATTRIBUTE_IDREFS
+     * @see #ATTRIBUTE_ENTITY
+     * @see #ATTRIBUTE_ENTITIES
+     * @see #ATTRIBUTE_NMTOKEN
+     * @see #ATTRIBUTE_NMTOKENS
+     * @see #ATTRIBUTE_ENUMERATED
+     * @see #ATTRIBUTE_NOTATION
+     */
+    public int getAttributeType(String name, String aname)
+    {
+        Object attribute[] = getAttribute(name, aname);
+        if (attribute == null) {
+            return ATTRIBUTE_UNDECLARED;
+        }
+		return ((Integer) attribute[0]).intValue();
+    }
+
+    /**
+     * Retrieve the allowed values for an enumerated attribute type.
+     *
+     * @param name
+     *            The name of the associated element.
+     * @param aname
+     *            The name of the attribute.
+     * @return A string containing the token list.
+     * @see #ATTRIBUTE_ENUMERATED
+     * @see #ATTRIBUTE_NOTATION
+     */
+    public String getAttributeEnumeration(String name, String aname)
+    {
+        Object attribute[] = getAttribute(name, aname);
+        if (attribute == null) {
+            return null;
+        }
+		return (String) attribute[3];
+    }
+
+    /**
+     * Retrieve the default value of a declared attribute.
+     *
+     * @param name
+     *            The name of the associated element.
+     * @param aname
+     *            The name of the attribute.
+     * @return The default value, or null if the attribute was #IMPLIED or
+     *         simply undeclared and unspecified.
+     * @see #getAttributeExpandedValue
+     */
+    public String getAttributeDefaultValue(String name, String aname)
+    {
+        Object attribute[] = getAttribute(name, aname);
+        if (attribute == null) {
+            return null;
+        }
+		return (String) attribute[1];
+    }
+
+    /**
+     * Retrieve the expanded value of a declared attribute.
+     * <p>
+     * All general entities will be expanded.
+     *
+     * @param name
+     *            The name of the associated element.
+     * @param aname
+     *            The name of the attribute.
+     * @return The expanded default value, or null if the attribute was #IMPLIED
+     *         or simply undeclared
+     * @see #getAttributeDefaultValue
+     */
+    public String getAttributeExpandedValue(String name, String aname)
+    {
+        Object attribute[] = getAttribute(name, aname);
+        if (attribute == null) {
+            return null;
+        } else if (attribute[4] == null && attribute[1] != null) {
+            try {
+                pushString(null, (char) 0 + (String) attribute[1] + (char) 0);
+                attribute[4] = readLiteral(LIT_NORMALIZE | LIT_CHAR_REF
+                        | LIT_ENTITY_REF);
+            } catch (Exception e) {
+            }
+        }
+        return (String) attribute[4];
+    }
+
+    /**
+     * Retrieve the default value type of a declared attribute.
+     *
+     * @see #ATTRIBUTE_DEFAULT_SPECIFIED
+     * @see #ATTRIBUTE_DEFAULT_IMPLIED
+     * @see #ATTRIBUTE_DEFAULT_REQUIRED
+     * @see #ATTRIBUTE_DEFAULT_FIXED
+     */
+    public int getAttributeDefaultValueType(String name, String aname)
+    {
+        Object attribute[] = getAttribute(name, aname);
+        if (attribute == null) {
+            return ATTRIBUTE_DEFAULT_UNDECLARED;
+        }
+		return ((Integer) attribute[2]).intValue();
+    }
+
+    /**
+     * Register an attribute declaration for later retrieval. Format: - String
+     * type - String default value - int value type
+     */
+    void setAttribute(String elName, String name, int type, String enumeration,
+            String value, int valueType) throws java.lang.Exception
+    {
+        Hashtable<String, Object[]> attlist;
+        Object attribute[];
+
+        // Create a new hashtable if necessary.
+        attlist = getElementAttributes(elName);
+        if (attlist == null) {
+            attlist = new Hashtable<String, Object[]>();
+        }
+
+        // Check that the attribute doesn't
+        // already exist!
+        if (attlist.get(name) != null) {
+            return;
+        }
+		attribute = new Object[5];
+		attribute[0] = new Integer(type);
+		attribute[1] = value;
+		attribute[2] = new Integer(valueType);
+		attribute[3] = enumeration;
+		attribute[4] = null;
+		attlist.put(name.intern(), attribute);
+
+		// Use CONTENT_UNDECLARED to avoid overwriting
+		// existing element declaration.
+		setElement(elName, CONTENT_UNDECLARED, null, attlist);
+    }
+
+    /**
+     * Retrieve the three-member array representing an attribute declaration.
+     */
+    Object[] getAttribute(String elName, String name)
+    {
+        Hashtable<String, Object[]> attlist;
+        Object attribute[];
+
+        attlist = getElementAttributes(elName);
+        if (attlist == null) {
+            return null;
+        }
+
+        attribute = attlist.get(name);
+        return attribute;
+    }
+
+    //
+    // Entities
+    //
+
+    /**
+     * Get declared entities.
+     *
+     * @return An Enumeration of all the entities declared for this XML
+     *         document. The results will be valid only after the DTD (if any)
+     *         has been parsed.
+     * @see #getEntityType
+     * @see #getEntityPublicId
+     * @see #getEntitySystemId
+     * @see #getEntityValue
+     * @see #getEntityNotationName
+     */
+    public Enumeration<String> declaredEntities()
+    {
+        return this.entityInfo.keys();
+    }
+
+    /**
+     * Find the type of an entity.
+     *
+     * @returns An integer constant representing the entity type.
+     * @see #ENTITY_UNDECLARED
+     * @see #ENTITY_INTERNAL
+     * @see #ENTITY_NDATA
+     * @see #ENTITY_TEXT
+     */
+    public int getEntityType(String ename)
+    {
+        Object entity[] = this.entityInfo.get(ename);
+        if (entity == null) {
+            return ENTITY_UNDECLARED;
+        }
+		return ((Integer) entity[0]).intValue();
+    }
+
+    /**
+     * Return an external entity's public identifier, if any.
+     *
+     * @param ename
+     *            The name of the external entity.
+     * @return The entity's system identifier, or null if the entity was not
+     *         declared, if it is not an external entity, or if no public
+     *         identifier was provided.
+     * @see #getEntityType
+     */
+    public String getEntityPublicId(String ename)
+    {
+        Object entity[] = this.entityInfo.get(ename);
+        if (entity == null) {
+            return null;
+        }
+		return (String) entity[1];
+    }
+
+    /**
+     * Return an external entity's system identifier.
+     *
+     * @param ename
+     *            The name of the external entity.
+     * @return The entity's system identifier, or null if the entity was not
+     *         declared, or if it is not an external entity.
+     * @see #getEntityType
+     */
+    public String getEntitySystemId(String ename)
+    {
+        Object entity[] = this.entityInfo.get(ename);
+        if (entity == null) {
+            return null;
+        }
+		return (String) entity[2];
+    }
+
+    /**
+     * Return the value of an internal entity.
+     *
+     * @param ename
+     *            The name of the internal entity.
+     * @return The entity's value, or null if the entity was not declared, or if
+     *         it is not an internal entity.
+     * @see #getEntityType
+     */
+    public String getEntityValue(String ename)
+    {
+        Object entity[] = this.entityInfo.get(ename);
+        if (entity == null) {
+            return null;
+        }
+		return (String) entity[3];
+    }
+
+    /**
+     * Get the notation name associated with an NDATA entity.
+     *
+     * @param ename
+     *            The NDATA entity name.
+     * @return The associated notation name, or null if the entity was not
+     *         declared, or if it is not an NDATA entity.
+     * @see #getEntityType
+     */
+    public String getEntityNotationName(String eName)
+    {
+        Object entity[] = this.entityInfo.get(eName);
+        if (entity == null) {
+            return null;
+        }
+		return (String) entity[4];
+    }
+
+    /**
+     * Register an entity declaration for later retrieval.
+     */
+    void setInternalEntity(String eName, String value)
+    {
+        setEntity(eName, ENTITY_INTERNAL, null, null, value, null);
+    }
+
+    /**
+     * Register an external data entity.
+     */
+    void setExternalDataEntity(String eName, String pubid, String sysid,
+            String nName)
+    {
+        setEntity(eName, ENTITY_NDATA, pubid, sysid, null, nName);
+    }
+
+    /**
+     * Register an external text entity.
+     */
+    void setExternalTextEntity(String eName, String pubid, String sysid)
+    {
+        setEntity(eName, ENTITY_TEXT, pubid, sysid, null, null);
+    }
+
+    /**
+     * Register an entity declaration for later retrieval.
+     */
+    void setEntity(String eName, int eClass, String pubid, String sysid,
+            String value, String nName)
+    {
+        Object entity[];
+
+        if (this.entityInfo.get(eName) == null) {
+            entity = new Object[5];
+            entity[0] = new Integer(eClass);
+            entity[1] = pubid;
+            entity[2] = sysid;
+            entity[3] = value;
+            entity[4] = nName;
+
+            this.entityInfo.put(eName, entity);
+        }
+    }
+
+    //
+    // Notations.
+    //
+
+    /**
+     * Get declared notations.
+     *
+     * @return An Enumeration of all the notations declared for this XML
+     *         document. The results will be valid only after the DTD (if any)
+     *         has been parsed.
+     * @see #getNotationPublicId
+     * @see #getNotationSystemId
+     */
+    public Enumeration<String> declaredNotations()
+    {
+        return this.notationInfo.keys();
+    }
+
+    /**
+     * Look up the public identifier for a notation. You will normally use this
+     * method to look up a notation that was provided as an attribute value or
+     * for an NDATA entity.
+     *
+     * @param nname
+     *            The name of the notation.
+     * @return A string containing the public identifier, or null if none was
+     *         provided or if no such notation was declared.
+     * @see #getNotationSystemId
+     */
+    public String getNotationPublicId(String nname)
+    {
+        Object notation[] = this.notationInfo.get(nname);
+        if (notation == null) {
+            return null;
+        }
+		return (String) notation[0];
+    }
+
+    /**
+     * Look up the system identifier for a notation. You will normally use this
+     * method to look up a notation that was provided as an attribute value or
+     * for an NDATA entity.
+     *
+     * @param nname
+     *            The name of the notation.
+     * @return A string containing the system identifier, or null if no such
+     *         notation was declared.
+     * @see #getNotationPublicId
+     */
+    public String getNotationSystemId(String nname)
+    {
+        Object notation[] = this.notationInfo.get(nname);
+        if (notation == null) {
+            return null;
+        }
+		return (String) notation[1];
+    }
+
+    /**
+     * Register a notation declaration for later retrieval. Format: - public id -
+     * system id
+     */
+    void setNotation(String nname, String pubid, String sysid)
+            throws java.lang.Exception
+    {
+        Object notation[];
+
+        if (this.notationInfo.get(nname) == null) {
+            notation = new Object[2];
+            notation[0] = pubid;
+            notation[1] = sysid;
+            this.notationInfo.put(nname, notation);
+        } else {
+            error("multiple declarations of notation", nname, null);
+        }
+    }
+
+    //
+    // Location.
+    //
+
+    /**
+     * Return the current line number.
+     */
+    public int getLineNumber()
+    {
+        return this.line;
+    }
+
+    /**
+     * Return the current column number.
+     */
+    public int getColumnNumber()
+    {
+        return this.column;
+    }
+
+    //////////////////////////////////////////////////////////////////////
+    // High-level I/O.
+    //////////////////////////////////////////////////////////////////////
+
+    /**
+     * Read a single character from the readBuffer.
+     * <p>
+     * The readDataChunk() method maintains the buffer.
+     * <p>
+     * If we hit the end of an entity, try to pop the stack and keep going.
+     * <p>
+     * (This approach doesn't really enforce XML's rules about entity
+     * boundaries, but this is not currently a validating parser).
+     * <p>
+     * This routine also attempts to keep track of the current position in
+     * external entities, but it's not entirely accurate.
+     *
+     * @return The next available input character.
+     * @see #unread(char)
+     * @see #unread(String)
+     * @see #readDataChunk
+     * @see #readBuffer
+     * @see #line
+     * @return The next character from the current input source.
+     */
+    char readCh() throws java.lang.Exception
+    {
+        char c;
+
+        // As long as there's nothing in the
+        // read buffer, try reading more data
+        // (for an external entity) or popping
+        // the entity stack (for either).
+        while (this.readBufferPos >= this.readBufferLength) {
+            switch (this.sourceType) {
+                case INPUT_READER:
+                case INPUT_EXTERNAL:
+                case INPUT_STREAM:
+                    readDataChunk();
+                    while (this.readBufferLength < 1) {
+                        popInput();
+                        if (this.readBufferLength < 1) {
+                            readDataChunk();
+                        }
+                    }
+                    break;
+
+                default:
+                    popInput();
+                    break;
+            }
+        }
+
+        c = this.readBuffer[this.readBufferPos++];
+
+        // This is a particularly nasty bit
+        // of code, that checks for a parameter
+        // entity reference but peeks ahead to
+        // catch the '%' in parameter entity
+        // declarations.
+        if (c == '%'
+                && (this.context == CONTEXT_DTD || this.context == CONTEXT_ENTITYVALUE)) {
+            char c2 = readCh();
+            unread(c2);
+            if (!isWhitespace(c2)) {
+                parsePEReference(this.context == CONTEXT_ENTITYVALUE);
+                return readCh();
+            }
+        }
+
+        if (c == '\n') {
+            this.line++;
+            this.column = 0;
+        } else {
+            this.column++;
+        }
+
+        return c;
+    }
+
+    /**
+     * Push a single character back onto the current input stream.
+     * <p>
+     * This method usually pushes the character back onto the readBuffer, while
+     * the unread(String) method treats the string as a new internal entity.
+     * <p>
+     * I don't think that this would ever be called with readBufferPos = 0,
+     * because the methods always reads a character before unreading it, but
+     * just in case, I've added a boundary condition.
+     *
+     * @param c
+     *            The character to push back.
+     * @see #readCh
+     * @see #unread(String)
+     * @see #unread(char[])
+     * @see #readBuffer
+     */
+    void unread(char c) throws java.lang.Exception
+    {
+        // Normal condition.
+        if (c == '\n') {
+            this.line--;
+            this.column = -1;
+        }
+        if (this.readBufferPos > 0) {
+            this.readBuffer[--this.readBufferPos] = c;
+        } else {
+            pushString(null, new Character(c).toString());
+        }
+    }
+
+    /**
+     * Push a char array back onto the current input stream.
+     * <p>
+     * NOTE: you must <em>never</em> push back characters that you haven't
+     * actually read: use pushString() instead.
+     *
+     * @see #readCh
+     * @see #unread(char)