libjava/classpath/javax/swing/text/html/HTML.java

   1 /* HTML.java -- HTML document tag constants
   2    Copyright (C) 2002 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package javax.swing.text.html;
  40
  41 import java.io.Serializable;
  42
  43 import java.lang.reflect.Field;
  44 import java.lang.reflect.Modifier;
  45
  46 import java.util.Map;
  47 import java.util.TreeMap;
  48
  49 import javax.swing.text.AttributeSet;
  50
  51 /**
  52  * HTML attribute and tag definitions.
  53  * @author Audrius Meskauskas (AudriusA@Bioinformatics.org)
  54  */
  55 public class HTML
  56 {
  57   /**
  58    * Represents a HTML attribute.
  59    */
  60   public static class Attribute
  61     implements Serializable
  62   {
  63     /**
  64      * The action attribute
  65      */
  66     public static final Attribute ACTION = new Attribute("action");
  67
  68     /**
  69      * The align attribute
  70      */
  71     public static final Attribute ALIGN = new Attribute("align");
  72
  73     /**
  74      * The alink attribute
  75      */
  76     public static final Attribute ALINK = new Attribute("alink");
  77
  78     /**
  79      * The alt attribute
  80      */
  81     public static final Attribute ALT = new Attribute("alt");
  82
  83     /**
  84      * The archive attribute
  85      */
  86     public static final Attribute ARCHIVE = new Attribute("archive");
  87
  88     /**
  89      * The background attribute
  90      */
  91     public static final Attribute BACKGROUND = new Attribute("background");
  92
  93     /**
  94      * The bgcolor attribute
  95      */
  96     public static final Attribute BGCOLOR = new Attribute("bgcolor");
  97
  98     /**
  99      * The border attribute
 100      */
 101     public static final Attribute BORDER = new Attribute("border");
 102
 103     /**
 104      * The cellpadding attribute
 105      */
 106     public static final Attribute CELLPADDING = new Attribute("cellpadding");
 107
 108     /**
 109      * The cellspacing attribute
 110      */
 111     public static final Attribute CELLSPACING = new Attribute("cellspacing");
 112
 113     /**
 114      * The checked attribute
 115      */
 116     public static final Attribute CHECKED = new Attribute("checked");
 117
 118     /**
 119      * The class attribute
 120      */
 121     public static final Attribute CLASS = new Attribute("class");
 122
 123     /**
 124      * The classid attribute
 125      */
 126     public static final Attribute CLASSID = new Attribute("classid");
 127
 128     /**
 129      * The clear attribute
 130      */
 131     public static final Attribute CLEAR = new Attribute("clear");
 132
 133     /**
 134      * The code attribute
 135      */
 136     public static final Attribute CODE = new Attribute("code");
 137
 138     /**
 139      * The codebase attribute
 140      */
 141     public static final Attribute CODEBASE = new Attribute("codebase");
 142
 143     /**
 144      * The codetype attribute
 145      */
 146     public static final Attribute CODETYPE = new Attribute("codetype");
 147
 148     /**
 149      * The color attribute
 150      */
 151     public static final Attribute COLOR = new Attribute("color");
 152
 153     /**
 154      * The cols attribute
 155      */
 156     public static final Attribute COLS = new Attribute("cols");
 157
 158     /**
 159      * The colspan attribute
 160      */
 161     public static final Attribute COLSPAN = new Attribute("colspan");
 162
 163     /**
 164      * The comment attribute
 165      */
 166     public static final Attribute COMMENT = new Attribute("comment");
 167
 168     /**
 169      * The compact attribute
 170      */
 171     public static final Attribute COMPACT = new Attribute("compact");
 172
 173     /**
 174      * The content attribute
 175      */
 176     public static final Attribute CONTENT = new Attribute("content");
 177
 178     /**
 179      * The coords attribute
 180      */
 181     public static final Attribute COORDS = new Attribute("coords");
 182
 183     /**
 184      * The data attribute
 185      */
 186     public static final Attribute DATA = new Attribute("data");
 187
 188     /**
 189      * The declare attribute
 190      */
 191     public static final Attribute DECLARE = new Attribute("declare");
 192
 193     /**
 194      * The dir attribute
 195      */
 196     public static final Attribute DIR = new Attribute("dir");
 197
 198     /**
 199      * The dummy attribute
 200      */
 201     public static final Attribute DUMMY = new Attribute("dummy");
 202
 203     /**
 204      * The enctype attribute
 205      */
 206     public static final Attribute ENCTYPE = new Attribute("enctype");
 207
 208     /**
 209      * The endtag attribute
 210      */
 211     public static final Attribute ENDTAG = new Attribute("endtag");
 212
 213     /**
 214      *  The face attribute
 215      */
 216     public static final Attribute FACE = new Attribute("face");
 217
 218     /**
 219      *  The frameborder attribute
 220      */
 221     public static final Attribute FRAMEBORDER = new Attribute("frameborder");
 222
 223     /**
 224      *  The halign attribute
 225      */
 226     public static final Attribute HALIGN = new Attribute("halign");
 227
 228     /**
 229      *  The height attribute
 230      */
 231     public static final Attribute HEIGHT = new Attribute("height");
 232
 233     /**
 234      *  The href attribute
 235      */
 236     public static final Attribute HREF = new Attribute("href");
 237
 238     /**
 239      *  The hspace attribute
 240      */
 241     public static final Attribute HSPACE = new Attribute("hspace");
 242
 243     /**
 244      *  The http-equiv attribute
 245      */
 246     public static final Attribute HTTPEQUIV = new Attribute("http-equiv");
 247
 248     /**
 249      *  The id attribute
 250      */
 251     public static final Attribute ID = new Attribute("id");
 252
 253     /**
 254      *  The ismap attribute
 255      */
 256     public static final Attribute ISMAP = new Attribute("ismap");
 257
 258     /**
 259      *  The lang attribute
 260      */
 261     public static final Attribute LANG = new Attribute("lang");
 262
 263     /**
 264      *  The language attribute
 265      */
 266     public static final Attribute LANGUAGE = new Attribute("language");
 267
 268     /**
 269      *  The link attribute
 270      */
 271     public static final Attribute LINK = new Attribute("link");
 272
 273     /**
 274      *  The lowsrc attribute
 275      */
 276     public static final Attribute LOWSRC = new Attribute("lowsrc");
 277
 278     /**
 279      *  The marginheight attribute
 280      */
 281     public static final Attribute MARGINHEIGHT = new Attribute("marginheight");
 282
 283     /**
 284      *  The marginwidth attribute
 285      */
 286     public static final Attribute MARGINWIDTH = new Attribute("marginwidth");
 287
 288     /**
 289      *  The maxlength attribute
 290      */
 291     public static final Attribute MAXLENGTH = new Attribute("maxlength");
 292
 293     /**
 294      *  The media attribute
 295      */
 296     public static final Attribute MEDIA = new Attribute("media");
 297
 298     /**
 299      *  The method attribute
 300      */
 301     public static final Attribute METHOD = new Attribute("method");
 302
 303     /**
 304      *  The multiple attribute
 305      */
 306     public static final Attribute MULTIPLE = new Attribute("multiple");
 307
 308     /**
 309      *  The n attribute
 310      */
 311     public static final Attribute N = new Attribute("n");
 312
 313     /**
 314      *  The name attribute
 315      */
 316     public static final Attribute NAME = new Attribute("name");
 317
 318     /**
 319      *  The nohref attribute
 320      */
 321     public static final Attribute NOHREF = new Attribute("nohref");
 322
 323     /**
 324      *  The noresize attribute
 325      */
 326     public static final Attribute NORESIZE = new Attribute("noresize");
 327
 328     /**
 329      *  The noshade attribute
 330      */
 331     public static final Attribute NOSHADE = new Attribute("noshade");
 332
 333     /**
 334      *  The nowrap attribute
 335      */
 336     public static final Attribute NOWRAP = new Attribute("nowrap");
 337
 338     /**
 339      *  The prompt attribute
 340      */
 341     public static final Attribute PROMPT = new Attribute("prompt");
 342
 343     /**
 344      *  The rel attribute
 345      */
 346     public static final Attribute REL = new Attribute("rel");
 347
 348     /**
 349      *  The rev attribute
 350      */
 351     public static final Attribute REV = new Attribute("rev");
 352
 353     /**
 354      *  The rows attribute
 355      */
 356     public static final Attribute ROWS = new Attribute("rows");
 357
 358     /**
 359      *  The rowspan attribute
 360      */
 361     public static final Attribute ROWSPAN = new Attribute("rowspan");
 362
 363     /**
 364      *  The scrolling attribute
 365      */
 366     public static final Attribute SCROLLING = new Attribute("scrolling");
 367
 368     /**
 369      *  The selected attribute
 370      */
 371     public static final Attribute SELECTED = new Attribute("selected");
 372
 373     /**
 374      *  The shape attribute
 375      */
 376     public static final Attribute SHAPE = new Attribute("shape");
 377
 378     /**
 379      *  The shapes attribute
 380      */
 381     public static final Attribute SHAPES = new Attribute("shapes");
 382
 383     /**
 384      *  The size attribute
 385      */
 386     public static final Attribute SIZE = new Attribute("size");
 387
 388     /**
 389      *  The src attribute
 390      */
 391     public static final Attribute SRC = new Attribute("src");
 392
 393     /**
 394      *  The standby attribute
 395      */
 396     public static final Attribute STANDBY = new Attribute("standby");
 397
 398     /**
 399      *  The start attribute
 400      */
 401     public static final Attribute START = new Attribute("start");
 402
 403     /**
 404      *  The style attribute
 405      */
 406     public static final Attribute STYLE = new Attribute("style");
 407
 408     /**
 409      *  The target attribute
 410      */
 411     public static final Attribute TARGET = new Attribute("target");
 412
 413     /**
 414      *  The text attribute
 415      */
 416     public static final Attribute TEXT = new Attribute("text");
 417
 418     /**
 419      *  The title attribute
 420      */
 421     public static final Attribute TITLE = new Attribute("title");
 422
 423     /**
 424      *  The type attribute
 425      */
 426     public static final Attribute TYPE = new Attribute("type");
 427
 428     /**
 429      *  The usemap attribute
 430      */
 431     public static final Attribute USEMAP = new Attribute("usemap");
 432
 433     /**
 434      *  The valign attribute
 435      */
 436     public static final Attribute VALIGN = new Attribute("valign");
 437
 438     /**
 439      *  The value attribute
 440      */
 441     public static final Attribute VALUE = new Attribute("value");
 442
 443     /**
 444      *  The valuetype attribute
 445      */
 446     public static final Attribute VALUETYPE = new Attribute("valuetype");
 447
 448     /**
 449      *  The version attribute
 450      */
 451     public static final Attribute VERSION = new Attribute("version");
 452
 453     /**
 454      *  The vlink attribute
 455      */
 456     public static final Attribute VLINK = new Attribute("vlink");
 457
 458     /**
 459      *  The vspace attribute
 460      */
 461     public static final Attribute VSPACE = new Attribute("vspace");
 462
 463     /**
 464      *  The width attribute
 465      */
 466     public static final Attribute WIDTH = new Attribute("width");
 467     private final String name;
 468
 469     /**
 470      * Creates the attribute with the given name.
 471      */
 472     protected Attribute(String a_name)
 473     {
 474       name = a_name;
 475     }
 476
 477     /**
 478      * Calls compareTo on the tag names (Strings)
 479      */
 480     public int compareTo(Object other)
 481     {
 482       return name.compareTo(((Attribute) other).name);
 483     }
 484
 485     /**
 486      * The attributes are equal if the names are equal
 487      * (ignoring case)
 488      */
 489     public boolean equals(Object other)
 490     {
 491       if (other == this)
 492         return true;
 493
 494       if (!(other instanceof Attribute))
 495         return false;
 496
 497       Attribute that = (Attribute) other;
 498
 499       return that.name.equalsIgnoreCase(name);
 500     }
 501
 502     /**
 503      * Returns the hash code which corresponds to the string for this tag.
 504      */
 505     public int hashCode()
 506     {
 507       return name == null ? 0 : name.hashCode();
 508     }
 509
 510     /**
 511      * Returns the attribute name. The names of the built-in attributes
 512      * are always returned in lowercase.
 513      */
 514     public String toString()
 515     {
 516       return name;
 517     }
 518
 519     /**
 520      *  Return an array of all attributes, declared in the HTML.Attribute
 521      *  class. WARNING: attributes are the only public fields,
 522      *  expected in this class.
 523      */
 524     static Attribute[] getAllAttributes()
 525     {
 526       Field[] f = Attribute.class.getFields();
 527       Attribute[] attrs = new Attribute[ f.length ];
 528       Field x;
 529       int p = 0;
 530       Attribute a;
 531
 532       for (int i = 0; i < f.length; i++)
 533         {
 534           x = f [ i ];
 535
 536           if ((x.getModifiers() & Modifier.STATIC) != 0)
 537             {
 538               if (x.getType().equals(Attribute.class))
 539                 {
 540                   try
 541                     {
 542                       a = (Attribute) x.get(null);
 543                       attrs [ p++ ] = a;
 544                     }
 545                   catch (Exception ex)
 546                     {
 547                       ex.printStackTrace(System.err);
 548                       throw new Error("This should never happen, report a bug");
 549                     }
 550                 }
 551             }
 552         }
 553
 554       return attrs;
 555     }
 556   }
 557
 558   /**
 559    * Represents a HTML tag.
 560    */
 561   public static class Tag
 562     implements Comparable, Serializable
 563   {
 564     /**
 565      * The &lt;a&gt; tag
 566      */
 567     public static final Tag A = new Tag("a");
 568
 569     /**
 570      * The &lt;address&gt; tag
 571      */
 572     public static final Tag ADDRESS = new Tag("address");
 573
 574     /**
 575      * The &lt;applet&gt; tag
 576      */
 577     public static final Tag APPLET = new Tag("applet");
 578
 579     /**
 580      * The &lt;area&gt; tag
 581      */
 582     public static final Tag AREA = new Tag("area");
 583
 584     /**
 585      * The &lt;b&gt; tag
 586      */
 587     public static final Tag B = new Tag("b");
 588
 589     /**
 590      * The &lt;base&gt; tag
 591      */
 592     public static final Tag BASE = new Tag("base");
 593
 594     /**
 595      * The &lt;basefont&gt; tag
 596      */
 597     public static final Tag BASEFONT = new Tag("basefont");
 598
 599     /**
 600      * The &lt;big&gt; tag
 601      */
 602     public static final Tag BIG = new Tag("big");
 603
 604     /**
 605      * The &lt;blockquote&gt; tag , breaks flow, block tag.
 606      */
 607     public static final Tag BLOCKQUOTE = new Tag("blockquote", BREAKS | BLOCK);
 608
 609     /**
 610      * The &lt;body&gt; tag , breaks flow, block tag.
 611      */
 612     public static final Tag BODY = new Tag("body", BREAKS | BLOCK);
 613
 614     /**
 615      * The &lt;br&gt; tag , breaks flow.
 616      */
 617     public static final Tag BR = new Tag("br", BREAKS);
 618
 619     /**
 620      * The &lt;caption&gt; tag
 621      */
 622     public static final Tag CAPTION = new Tag("caption");
 623
 624     /**
 625      * The &lt;center&gt; tag , breaks flow.
 626      */
 627     public static final Tag CENTER = new Tag("center", BREAKS);
 628
 629     /**
 630      * The &lt;cite&gt; tag
 631      */
 632     public static final Tag CITE = new Tag("cite");
 633
 634     /**
 635      * The &lt;code&gt; tag
 636      */
 637     public static final Tag CODE = new Tag("code");
 638
 639     /**
 640      * The &lt;dd&gt; tag , breaks flow, block tag.
 641      */
 642     public static final Tag DD = new Tag("dd", BREAKS | BLOCK);
 643
 644     /**
 645      * The &lt;dfn&gt; tag
 646      */
 647     public static final Tag DFN = new Tag("dfn");
 648
 649     /**
 650      * The &lt;dir&gt; tag , breaks flow, block tag.
 651      */
 652     public static final Tag DIR = new Tag("dir", BREAKS | BLOCK);
 653
 654     /**
 655      * The &lt;div&gt; tag , breaks flow, block tag.
 656      */
 657     public static final Tag DIV = new Tag("div", BREAKS | BLOCK);
 658
 659     /**
 660      * The &lt;dl&gt; tag , breaks flow, block tag.
 661      */
 662     public static final Tag DL = new Tag("dl", BREAKS | BLOCK);
 663
 664     /**
 665      * The &lt;dt&gt; tag , breaks flow, block tag.
 666      */
 667     public static final Tag DT = new Tag("dt", BREAKS | BLOCK);
 668
 669     /**
 670      * The &lt;em&gt; tag
 671      */
 672     public static final Tag EM = new Tag("em");
 673
 674     /**
 675      * The &lt;font&gt; tag
 676      */
 677     public static final Tag FONT = new Tag("font");
 678
 679     /**
 680      * The &lt;form&gt; tag , breaks flow.
 681      */
 682     public static final Tag FORM = new Tag("form", BREAKS);
 683
 684     /**
 685      * The &lt;frame&gt; tag
 686      */
 687     public static final Tag FRAME = new Tag("frame");
 688
 689     /**
 690      * The &lt;frameset&gt; tag
 691      */
 692     public static final Tag FRAMESET = new Tag("frameset");
 693
 694     /**
 695      * The &lt;h1&gt; tag , breaks flow, block tag.
 696      */
 697     public static final Tag H1 = new Tag("h1", BREAKS | BLOCK);
 698
 699     /**
 700      * The &lt;h2&gt; tag , breaks flow, block tag.
 701      */
 702     public static final Tag H2 = new Tag("h2", BREAKS | BLOCK);
 703
 704     /**
 705      * The &lt;h3&gt; tag , breaks flow, block tag.
 706      */
 707     public static final Tag H3 = new Tag("h3", BREAKS | BLOCK);
 708
 709     /**
 710      * The &lt;h4&gt; tag , breaks flow, block tag.
 711      */
 712     public static final Tag H4 = new Tag("h4", BREAKS | BLOCK);
 713
 714     /**
 715      * The &lt;h5&gt; tag , breaks flow, block tag.
 716      */
 717     public static final Tag H5 = new Tag("h5", BREAKS | BLOCK);
 718
 719     /**
 720      * The &lt;h6&gt; tag , breaks flow, block tag.
 721      */
 722     public static final Tag H6 = new Tag("h6", BREAKS | BLOCK);
 723
 724     /**
 725      * The &lt;head&gt; tag , breaks flow, block tag.
 726      */
 727     public static final Tag HEAD = new Tag("head", BREAKS | BLOCK);
 728
 729     /**
 730      * The &lt;hr&gt; tag , breaks flow.
 731      */
 732     public static final Tag HR = new Tag("hr", BREAKS);
 733
 734     /**
 735      * The &lt;html&gt; tag , breaks flow.
 736      */
 737     public static final Tag HTML = new Tag("html", BREAKS);
 738
 739     /**
 740      * The &lt;i&gt; tag
 741      */
 742     public static final Tag I = new Tag("i");
 743
 744     /**
 745      * The &lt;img&gt; tag
 746      */
 747     public static final Tag IMG = new Tag("img");
 748
 749     /**
 750      * The &lt;input&gt; tag
 751      */
 752     public static final Tag INPUT = new Tag("input");
 753
 754     /**
 755      * The &lt;isindex&gt; tag , breaks flow.
 756      */
 757     public static final Tag ISINDEX = new Tag("isindex", BREAKS);
 758
 759     /**
 760      * The &lt;kbd&gt; tag
 761      */
 762     public static final Tag KBD = new Tag("kbd");
 763
 764     /**
 765      * The &lt;li&gt; tag , breaks flow, block tag.
 766      */
 767     public static final Tag LI = new Tag("li", BREAKS | BLOCK);
 768
 769     /**
 770      * The &lt;link&gt; tag
 771      */
 772     public static final Tag LINK = new Tag("link");
 773
 774     /**
 775      * The &lt;map&gt; tag
 776      */
 777     public static final Tag MAP = new Tag("map");
 778
 779     /**
 780      * The &lt;menu&gt; tag , breaks flow, block tag.
 781      */
 782     public static final Tag MENU = new Tag("menu", BREAKS | BLOCK);
 783
 784     /**
 785      * The &lt;meta&gt; tag
 786      */
 787     public static final Tag META = new Tag("meta");
 788
 789     /**
 790      * The &lt;nobr&gt; tag
 791      */
 792     public static final Tag NOBR = new Tag("nobr");
 793
 794     /**
 795      * The &lt;noframes&gt; tag , breaks flow, block tag.
 796      */
 797     public static final Tag NOFRAMES = new Tag("noframes", BREAKS | BLOCK);
 798
 799     /**
 800      * The &lt;object&gt; tag
 801      */
 802     public static final Tag OBJECT = new Tag("object");
 803
 804     /**
 805      * The &lt;ol&gt; tag , breaks flow, block tag.
 806      */
 807     public static final Tag OL = new Tag("ol", BREAKS | BLOCK);
 808
 809     /**
 810      * The &lt;option&gt; tag
 811      */
 812     public static final Tag OPTION = new Tag("option");
 813
 814     /**
 815      * The &lt;p&gt; tag , breaks flow, block tag.
 816      */
 817     public static final Tag P = new Tag("p", BREAKS | BLOCK);
 818
 819     /**
 820      * The &lt;param&gt; tag
 821      */
 822     public static final Tag PARAM = new Tag("param");
 823
 824     /**
 825      * The &lt;pre&gt; tag , breaks flow, block tag, preformatted.
 826      */
 827     public static final Tag PRE = new Tag("pre", BREAKS | BLOCK | PREFORMATTED);
 828
 829     /**
 830      * The &lt;s&gt; tag
 831      */
 832     public static final Tag S = new Tag("s");
 833
 834     /**
 835      * The &lt;samp&gt; tag
 836      */
 837     public static final Tag SAMP = new Tag("samp");
 838
 839     /**
 840      * The &lt;script&gt; tag
 841      */
 842     public static final Tag SCRIPT = new Tag("script");
 843
 844     /**
 845      * The &lt;select&gt; tag
 846      */
 847     public static final Tag SELECT = new Tag("select");
 848
 849     /**
 850      * The &lt;small&gt; tag
 851      */
 852     public static final Tag SMALL = new Tag("small");
 853
 854     /**
 855      * The &lt;span&gt; tag
 856      */
 857     public static final Tag SPAN = new Tag("span");
 858
 859     /**
 860      * The &lt;strike&gt; tag
 861      */
 862     public static final Tag STRIKE = new Tag("strike");
 863
 864     /**
 865      * The &lt;strong&gt; tag
 866      */
 867     public static final Tag STRONG = new Tag("strong");
 868
 869     /**
 870      * The &lt;style&gt; tag
 871      */
 872     public static final Tag STYLE = new Tag("style");
 873
 874     /**
 875      * The &lt;sub&gt; tag
 876      */
 877     public static final Tag SUB = new Tag("sub");
 878
 879     /**
 880      * The &lt;sup&gt; tag
 881      */
 882     public static final Tag SUP = new Tag("sup");
 883
 884     /**
 885      * The &lt;table&gt; tag , block tag.
 886      */
 887     public static final Tag TABLE = new Tag("table", BLOCK);
 888
 889     /**
 890      * The &lt;td&gt; tag , breaks flow, block tag.
 891      */
 892     public static final Tag TD = new Tag("td", BREAKS | BLOCK);
 893
 894     /**
 895      * The &lt;textarea&gt; tag , preformatted.
 896      */
 897     public static final Tag TEXTAREA = new Tag("textarea", PREFORMATTED);
 898
 899     /**
 900      * The &lt;th&gt; tag , breaks flow, block tag.
 901      */
 902     public static final Tag TH = new Tag("th", BREAKS | BLOCK);
 903
 904     /**
 905      * The &lt;title&gt; tag , breaks flow, block tag.
 906      */
 907     public static final Tag TITLE = new Tag("title", BREAKS | BLOCK);
 908
 909     /**
 910      * The &lt;tr&gt; tag , block tag.
 911      */
 912     public static final Tag TR = new Tag("tr", BLOCK);
 913
 914     /**
 915      * The &lt;tt&gt; tag
 916      */
 917     public static final Tag TT = new Tag("tt");
 918
 919     /**
 920      * The &lt;u&gt; tag
 921      */
 922     public static final Tag U = new Tag("u");
 923
 924     /**
 925      * The &lt;ul&gt; tag , breaks flow, block tag.
 926      */
 927     public static final Tag UL = new Tag("ul", BREAKS | BLOCK);
 928
 929     /**
 930      * The &lt;var&gt; tag
 931      */
 932     public static final Tag VAR = new Tag("var");
 933
 934     /* Special tags */
 935
 936     /**
 937      * Total number of syntetic tags, delared in the Tag class.
 938      * This must be adjusted if the new synthetic tags are declared.
 939      * Otherwise the HTML.getAllTags() will not work as expected.
 940      */
 941     private static final int TOTAL_SYNTHETIC_TAGS = 3;
 942
 943     /**
 944      * All comments are labeled with this tag.
 945      * This tag is not included into the array, returned by getAllTags().
 946      * toString() returns 'comment'. HTML reader synthesizes this tag.
 947      */
 948     public static final Tag COMMENT = new Tag("comment", SYNTHETIC);
 949
 950     /**
 951      *  All text content is labeled with this tag.
 952      *  This tag is not included into the array, returned by getAllTags().
 953      *  toString() returns 'content'. HTML reader synthesizes this tag.
 954      */
 955     public static final Tag CONTENT = new Tag("content", SYNTHETIC);
 956
 957     /**
 958      * All text content must be in a paragraph element.
 959      * If a paragraph didn't exist when content was encountered,
 960      * a paragraph is manufactured.
 961      * toString() returns 'p-implied'. HTML reader synthesizes this tag.
 962      */
 963     public static final Tag IMPLIED = new Tag("p-implied", SYNTHETIC);
 964     final String name;
 965     final int flags;
 966
 967     /**
 968      * Create the unitialised instance of HTML.Tag.
 969      *
 970      * The {@link #breaksFlow()}, {@link #isBlock()}
 971      * and {@link #isPreformatted()} will always return false.
 972      * The {@link #toString()} will return <code>null</code>.
 973      *
 974      * @since 1.3
 975      */
 976     public Tag()
 977     {
 978       name = null;
 979       flags = 0;
 980     }
 981
 982     /**
 983      * Creates a new Tag with the specified id, and with causesBreak
 984      * and isBlock set to false.
 985      */
 986     protected Tag(String id)
 987     {
 988       name = id;
 989       flags = 0;
 990     }
 991
 992     /**
 993      * Creates a new Tag with the specified tag name and
 994      * causesBreak and isBlock properties.
 995      */
 996     protected Tag(String id, boolean causesBreak, boolean isBlock)
 997     {
 998       int f = 0;
 999
1000       if (causesBreak)
1001         {
1002           f |= BREAKS;
1003         }
1004
1005       if (isBlock)
1006         {
1007           f |= BLOCK;
1008         }
1009
1010       flags = f;
1011       name = id;
1012     }
1013
1014     /**
1015      * Create a tag taking flags.
1016      */
1017     Tag(String id, int a_flags)
1018     {
1019       name = id;
1020       flags = a_flags;
1021     }
1022
1023     /**
1024      * Returns true if this tag is a block tag, which is a tag used to
1025      * add structure to a document.
1026      */
1027     public boolean isBlock()
1028     {
1029       return (flags & BLOCK) != 0;
1030     }
1031
1032     /**
1033      * Returns true if this tag is pre-formatted, which is true if
1034      * the tag is either PRE or TEXTAREA
1035      */
1036     public boolean isPreformatted()
1037     {
1038       return (flags & PREFORMATTED) != 0;
1039     }
1040
1041     /**
1042      * Returns true if this tag causes a line break to the flow of text
1043      */
1044     public boolean breaksFlow()
1045     {
1046       return (flags & BREAKS) != 0;
1047     }
1048
1049     /**
1050      * Calls compareTo on the tag names (Strings)
1051      */
1052     public int compareTo(Object other)
1053     {
1054       return name.compareTo(((Tag) other).name);
1055     }
1056
1057     /**
1058      * The tags are equal if the names are equal (ignoring case).
1059      */
1060     public boolean equals(Object other)
1061     {
1062       if (other == this)
1063         {
1064           return true;
1065         }
1066
1067       if (!(other instanceof Tag))
1068         {
1069           return false;
1070         }
1071
1072       Tag that = (Tag) other;
1073
1074       return that.name.equalsIgnoreCase(name);
1075     }
1076
1077     /**
1078      * Returns the hash code which corresponds to the string for this tag.
1079      */
1080     public int hashCode()
1081     {
1082       return name == null ? 0 : name.hashCode();
1083     }
1084
1085     /**
1086      * Returns the tag name. The names of the built-in tags are always
1087      * returned in lowercase.
1088      */
1089     public String toString()
1090     {
1091       return name;
1092     }
1093
1094     /**
1095      * Return an array of HTML tags, declared in HTML.Tag class.
1096      * WARNING: This method expects that the Tags are the only
1097      * public fields declared in the Tag class.
1098      */
1099     static Tag[] getAllTags()
1100     {
1101       Field[] f = Tag.class.getFields();
1102       Field x;
1103
1104       // The syntetic tags are not included.
1105       Tag[] tags = new Tag[ f.length - TOTAL_SYNTHETIC_TAGS ];
1106       int p = 0;
1107       Tag t;
1108
1109       for (int i = 0; i < f.length; i++)
1110         {
1111           x = f [ i ];
1112
1113           if ((x.getModifiers() & Modifier.STATIC) != 0)
1114             {
1115               if (x.getType().equals(Tag.class))
1116                 {
1117                   try
1118                     {
1119                       t = (Tag) x.get(null);
1120
1121                       if (!t.isSyntetic())
1122                         {
1123                           tags [ p++ ] = t;
1124                         }
1125                     }
1126                   catch (IllegalAccessException ex)
1127                     {
1128                       unexpected(ex);
1129                     }
1130                   catch (IllegalArgumentException ex)
1131                     {
1132                       unexpected(ex);
1133                     }
1134                 }
1135             }
1136         }
1137
1138       return tags;
1139     }
1140
1141     /**
1142      * Returns true for tags, generated by the html reader
1143      * (COMMENT, CONTENT and IMPLIED).
1144      */
1145     boolean isSyntetic()
1146     {
1147       return (flags & SYNTHETIC) != 0;
1148     }
1149
1150     private static void unexpected(Exception ex)
1151                             throws Error
1152     {
1153       throw new Error("This should never happen, report a bug", ex);
1154     }
1155   }
1156
1157   /**
1158    * Represents an unknown HTML tag.
1159    * @author Mark Wielaard (mark@klomp.org)
1160    */
1161   public static class UnknownTag
1162     extends Tag
1163     implements Serializable
1164   {
1165     private static final long serialVersionUID = -1534369342247250625L;
1166
1167     /**
1168      * Creates a new UnknownTag with the specified name
1169      * @param name The tag name.
1170      *
1171      */
1172     public UnknownTag(String name)
1173     {
1174       super(name);
1175     }
1176   }
1177
1178   /**
1179    * This value is returned for attributes without value that have no
1180    * default value defined in the DTD.
1181    */
1182   public static final String NULL_ATTRIBUTE_VALUE = "#DEFAULT";
1183
1184   /* Package level html tag flags */
1185   static final int BREAKS = 1;
1186   static final int BLOCK = 2;
1187   static final int PREFORMATTED = 4;
1188   static final int SYNTHETIC = 8;
1189   private static Map tagMap;
1190   private static Map attrMap;
1191
1192   /**
1193    * The public constructor (does nothing). It it seldom required to have
1194    * an instance of this class, because all public fields and methods
1195    * are static.
1196    */
1197   public HTML()
1198   {
1199     // Nothing to do here.
1200   }
1201
1202   /**
1203    * Returns the set of the recognized HTML attributes.
1204    */
1205   public static HTML.Attribute[] getAllAttributeKeys()
1206   {
1207     return Attribute.getAllAttributes();
1208   }
1209
1210   /**
1211    * Returns the set of actual HTML tags that are recognized by
1212    * the default HTML reader. The returned array does not include the
1213    * COMMENT, CONTENT and IMPLIED tags.
1214    */
1215   public static HTML.Tag[] getAllTags()
1216   {
1217     return Tag.getAllTags();
1218   }
1219
1220   /**
1221    * Returns an htl attribute constant for the given attribute name.
1222    * @param attName the attribute name, case insensitive
1223    */
1224   public static Attribute getAttributeKey(String attName)
1225   {
1226     if (attrMap == null)
1227       {
1228         // Create the map on demand.
1229         attrMap = new TreeMap();
1230
1231         Attribute[] attrs = getAllAttributeKeys();
1232
1233         for (int i = 0; i < attrs.length; i++)
1234           {
1235             attrMap.put(attrs [ i ].toString(), attrs [ i ]);
1236           }
1237       }
1238
1239     return (Attribute) attrMap.get(attName.toLowerCase());
1240   }
1241
1242   /**
1243    * Searches the value of given attribute in the provided set.
1244    * If the value is found (String type expected), tries to parse it as
1245    * an integer value. If succeded, returns the obtained integer value.
1246    *
1247    * For example:<p><code>
1248    * SimpleAttributeSet ase = new SimpleAttributeSet();
1249    * ase.addAttribute(HTML.getAttributeKey("size"),"222");
1250    * System.out.println(
1251    *  HTML.getIntegerAttributeValue
1252    *     (ase, HTML.getAttributeKey("size"), 333)); // prints "222"
1253    * System.out.println(
1254    *  HTML.getIntegerAttributeValue
1255    *     (ase, HTML.getAttributeKey("width"), 333)); // prints "333".
1256    * </code></p>
1257    *
1258    *
1259    * @param set The attribute set to search in. If the set contains the
1260    * given attribute, it must by a type of String.
1261    * @param attribute The html attribute to search in
1262    * @param defaultValue The value that is returned if the attribute is not
1263    * found in the given set or if the NumberFormatException was thrown
1264    * during the parsing.
1265    */
1266   public static int getIntegerAttributeValue(AttributeSet set,
1267                                              HTML.Attribute attribute,
1268                                              int defaultValue
1269                                             )
1270   {
1271     Object v = set.getAttribute(attribute);
1272
1273     if (v == null)
1274       {
1275         return defaultValue;
1276       }
1277
1278     try
1279       {
1280         return Integer.parseInt(v.toString().trim());
1281       }
1282     catch (Exception ex)
1283       {
1284         return defaultValue;
1285       }
1286   }
1287
1288   /**
1289    * Returns a HTML tag constant for the given HTML attribute name.
1290    * If the tag is unknown, the null is returned.
1291    * @param tagName the tag name, case insensitive
1292    */
1293   public static Tag getTag(String tagName)
1294   {
1295     if (tagMap == null)
1296       {
1297         // Create the mao on demand.
1298         tagMap = new TreeMap();
1299
1300         Tag[] tags = getAllTags();
1301
1302         for (int i = 0; i < tags.length; i++)
1303           {
1304             tagMap.put(tags [ i ].toString(), tags [ i ]);
1305           }
1306       }
1307
1308     return (Tag) tagMap.get(tagName.toLowerCase());
1309   }
1310 }