1 /*

     2  * Copyright 1997-2006 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Sun designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Sun in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22  * CA 95054 USA or visit www.sun.com if you need additional information or

    23  * have any questions.

    24  */

    25 package javax.swing.text;

    26 

    27 import java.awt.*;

    28 import java.util.*;

    29 import java.io.*;

    30 

    31 import javax.swing.SwingUtilities;

    32 import javax.swing.event.ChangeListener;

    33 import javax.swing.event.EventListenerList;

    34 import javax.swing.event.ChangeEvent;

    35 import java.lang.ref.WeakReference;

    36 import java.util.WeakHashMap;

    37 

    38 import sun.font.FontManager;

    39 

    40 /**

    41  * A pool of styles and their associated resources.  This class determines

    42  * the lifetime of a group of resources by being a container that holds

    43  * caches for various resources such as font and color that get reused

    44  * by the various style definitions.  This can be shared by multiple

    45  * documents if desired to maximize the sharing of related resources.

    46  * <p>

    47  * This class also provides efficient support for small sets of attributes

    48  * and compresses them by sharing across uses and taking advantage of

    49  * their immutable nature.  Since many styles are replicated, the potential

    50  * for sharing is significant, and copies can be extremely cheap.

    51  * Larger sets reduce the possibility of sharing, and therefore revert

    52  * automatically to a less space-efficient implementation.

    53  * <p>

    54  * <strong>Warning:</strong>

    55  * Serialized objects of this class will not be compatible with

    56  * future Swing releases. The current serialization support is

    57  * appropriate for short term storage or RMI between applications running

    58  * the same version of Swing.  As of 1.4, support for long term storage

    59  * of all JavaBeans<sup><font size="-2">TM</font></sup>

    60  * has been added to the <code>java.beans</code> package.

    61  * Please see {@link java.beans.XMLEncoder}.

    62  *

    63  * @author  Timothy Prinzing

    64  */

    65 public class StyleContext implements Serializable, AbstractDocument.AttributeContext {

    66 

    67     /**

    68      * Returns default AttributeContext shared by all documents that

    69      * don't bother to define/supply their own context.

    70      *

    71      * @return the context

    72      */

    73     public static final StyleContext getDefaultStyleContext() {

    74         if (defaultContext == null) {

    75             defaultContext = new StyleContext();

    76         }

    77         return defaultContext;

    78     }

    79 

    80     private static StyleContext defaultContext;

    81 

    82     /**

    83      * Creates a new StyleContext object.

    84      */

    85     public StyleContext() {

    86         styles = new NamedStyle(null);

    87         addStyle(DEFAULT_STYLE, null);

    88     }

    89 

    90     /**

    91      * Adds a new style into the style hierarchy.  Style attributes

    92      * resolve from bottom up so an attribute specified in a child

    93      * will override an attribute specified in the parent.

    94      *

    95      * @param nm   the name of the style (must be unique within the

    96      *   collection of named styles in the document).  The name may

    97      *   be null if the style is unnamed, but the caller is responsible

    98      *   for managing the reference returned as an unnamed style can't

    99      *   be fetched by name.  An unnamed style may be useful for things

   100      *   like character attribute overrides such as found in a style

   101      *   run.

   102      * @param parent the parent style.  This may be null if unspecified

   103      *   attributes need not be resolved in some other style.

   104      * @return the created style

   105      */

   106     public Style addStyle(String nm, Style parent) {

   107         Style style = new NamedStyle(nm, parent);

   108         if (nm != null) {

   109             // add a named style, a class of attributes

   110             styles.addAttribute(nm, style);

   111         }

   112         return style;

   113     }

   114 

   115     /**

   116      * Removes a named style previously added to the document.

   117      *

   118      * @param nm  the name of the style to remove

   119      */

   120     public void removeStyle(String nm) {

   121         styles.removeAttribute(nm);

   122     }

   123 

   124     /**

   125      * Fetches a named style previously added to the document

   126      *

   127      * @param nm  the name of the style

   128      * @return the style

   129      */

   130     public Style getStyle(String nm) {

   131         return (Style) styles.getAttribute(nm);

   132     }

   133 

   134     /**

   135      * Fetches the names of the styles defined.

   136      *

   137      * @return the list of names as an enumeration

   138      */

   139     public Enumeration<?> getStyleNames() {

   140         return styles.getAttributeNames();

   141     }

   142 

   143     /**

   144      * Adds a listener to track when styles are added

   145      * or removed.

   146      *

   147      * @param l the change listener

   148      */

   149     public void addChangeListener(ChangeListener l) {

   150         styles.addChangeListener(l);

   151     }

   152 

   153     /**

   154      * Removes a listener that was tracking styles being

   155      * added or removed.

   156      *

   157      * @param l the change listener

   158      */

   159     public void removeChangeListener(ChangeListener l) {

   160         styles.removeChangeListener(l);

   161     }

   162 

   163     /**

   164      * Returns an array of all the <code>ChangeListener</code>s added

   165      * to this StyleContext with addChangeListener().

   166      *

   167      * @return all of the <code>ChangeListener</code>s added or an empty

   168      *         array if no listeners have been added

   169      * @since 1.4

   170      */

   171     public ChangeListener[] getChangeListeners() {

   172         return ((NamedStyle)styles).getChangeListeners();

   173     }

   174 

   175     /**

   176      * Gets the font from an attribute set.  This is

   177      * implemented to try and fetch a cached font

   178      * for the given AttributeSet, and if that fails

   179      * the font features are resolved and the

   180      * font is fetched from the low-level font cache.

   181      *

   182      * @param attr the attribute set

   183      * @return the font

   184      */

   185     public Font getFont(AttributeSet attr) {

   186         // PENDING(prinz) add cache behavior

   187         int style = Font.PLAIN;

   188         if (StyleConstants.isBold(attr)) {

   189             style |= Font.BOLD;

   190         }

   191         if (StyleConstants.isItalic(attr)) {

   192             style |= Font.ITALIC;

   193         }

   194         String family = StyleConstants.getFontFamily(attr);

   195         int size = StyleConstants.getFontSize(attr);

   196 

   197         /**

   198          * if either superscript or subscript is

   199          * is set, we need to reduce the font size

   200          * by 2.

   201          */

   202         if (StyleConstants.isSuperscript(attr) ||

   203             StyleConstants.isSubscript(attr)) {

   204             size -= 2;

   205         }

   206 

   207         return getFont(family, style, size);

   208     }

   209 

   210     /**

   211      * Takes a set of attributes and turn it into a foreground color

   212      * specification.  This might be used to specify things

   213      * like brighter, more hue, etc.  By default it simply returns

   214      * the value specified by the StyleConstants.Foreground attribute.

   215      *

   216      * @param attr the set of attributes

   217      * @return the color

   218      */

   219     public Color getForeground(AttributeSet attr) {

   220         return StyleConstants.getForeground(attr);

   221     }

   222 

   223     /**

   224      * Takes a set of attributes and turn it into a background color

   225      * specification.  This might be used to specify things

   226      * like brighter, more hue, etc.  By default it simply returns

   227      * the value specified by the StyleConstants.Background attribute.

   228      *

   229      * @param attr the set of attributes

   230      * @return the color

   231      */

   232     public Color getBackground(AttributeSet attr) {

   233         return StyleConstants.getBackground(attr);

   234     }

   235 

   236     /**

   237      * Gets a new font.  This returns a Font from a cache

   238      * if a cached font exists.  If not, a Font is added to

   239      * the cache.  This is basically a low-level cache for

   240      * 1.1 font features.

   241      *

   242      * @param family the font family (such as "Monospaced")

   243      * @param style the style of the font (such as Font.PLAIN)

   244      * @param size the point size >= 1

   245      * @return the new font

   246      */

   247     public Font getFont(String family, int style, int size) {

   248         fontSearch.setValue(family, style, size);

   249         Font f = (Font) fontTable.get(fontSearch);

   250         if (f == null) {

   251             // haven't seen this one yet.

   252             Style defaultStyle =

   253                 getStyle(StyleContext.DEFAULT_STYLE);

   254             if (defaultStyle != null) {

   255                 final String FONT_ATTRIBUTE_KEY = "FONT_ATTRIBUTE_KEY";

   256                 Font defaultFont =

   257                     (Font) defaultStyle.getAttribute(FONT_ATTRIBUTE_KEY);

   258                 if (defaultFont != null

   259                       && defaultFont.getFamily().equalsIgnoreCase(family)) {

   260                     f = defaultFont.deriveFont(style, size);

   261                 }

   262             }

   263             if (f == null) {

   264                 f = new Font(family, style, size);

   265             }

   266             if (! FontManager.fontSupportsDefaultEncoding(f)) {

   267                 f = FontManager.getCompositeFontUIResource(f);

   268             }

   269             FontKey key = new FontKey(family, style, size);

   270             fontTable.put(key, f);

   271         }

   272         return f;

   273     }

   274 

   275     /**

   276      * Returns font metrics for a font.

   277      *

   278      * @param f the font

   279      * @return the metrics

   280      */

   281     public FontMetrics getFontMetrics(Font f) {

   282         // The Toolkit implementations cache, so we just forward

   283         // to the default toolkit.

   284         return Toolkit.getDefaultToolkit().getFontMetrics(f);

   285     }

   286 

   287     // --- AttributeContext methods --------------------

   288 

   289     /**

   290      * Adds an attribute to the given set, and returns

   291      * the new representative set.

   292      * <p>

   293      * This method is thread safe, although most Swing methods

   294      * are not. Please see

   295      * <A HREF="http://java.sun.com/docs/books/tutorial/uiswing/misc/threads.html">How

   296      * to Use Threads</A> for more information.

   297      *

   298      * @param old the old attribute set

   299      * @param name the non-null attribute name

   300      * @param value the attribute value

   301      * @return the updated attribute set

   302      * @see MutableAttributeSet#addAttribute

   303      */

   304     public synchronized AttributeSet addAttribute(AttributeSet old, Object name, Object value) {

   305         if ((old.getAttributeCount() + 1) <= getCompressionThreshold()) {

   306             // build a search key and find/create an immutable and unique

   307             // set.

   308             search.removeAttributes(search);

   309             search.addAttributes(old);

   310             search.addAttribute(name, value);

   311             reclaim(old);

   312             return getImmutableUniqueSet();

   313         }

   314         MutableAttributeSet ma = getMutableAttributeSet(old);

   315         ma.addAttribute(name, value);

   316         return ma;

   317     }

   318 

   319     /**

   320      * Adds a set of attributes to the element.

   321      * <p>

   322      * This method is thread safe, although most Swing methods

   323      * are not. Please see

   324      * <A HREF="http://java.sun.com/docs/books/tutorial/uiswing/misc/threads.html">How

   325      * to Use Threads</A> for more information.

   326      *

   327      * @param old the old attribute set

   328      * @param attr the attributes to add

   329      * @return the updated attribute set

   330      * @see MutableAttributeSet#addAttribute

   331      */

   332     public synchronized AttributeSet addAttributes(AttributeSet old, AttributeSet attr) {

   333         if ((old.getAttributeCount() + attr.getAttributeCount()) <= getCompressionThreshold()) {

   334             // build a search key and find/create an immutable and unique

   335             // set.

   336             search.removeAttributes(search);

   337             search.addAttributes(old);

   338             search.addAttributes(attr);

   339             reclaim(old);

   340             return getImmutableUniqueSet();

   341         }

   342         MutableAttributeSet ma = getMutableAttributeSet(old);

   343         ma.addAttributes(attr);

   344         return ma;

   345     }

   346 

   347     /**

   348      * Removes an attribute from the set.

   349      * <p>

   350      * This method is thread safe, although most Swing methods

   351      * are not. Please see

   352      * <A HREF="http://java.sun.com/docs/books/tutorial/uiswing/misc/threads.html">How

   353      * to Use Threads</A> for more information.

   354      *

   355      * @param old the old set of attributes

   356      * @param name the non-null attribute name

   357      * @return the updated attribute set

   358      * @see MutableAttributeSet#removeAttribute

   359      */

   360     public synchronized AttributeSet removeAttribute(AttributeSet old, Object name) {

   361         if ((old.getAttributeCount() - 1) <= getCompressionThreshold()) {

   362             // build a search key and find/create an immutable and unique

   363             // set.

   364             search.removeAttributes(search);

   365             search.addAttributes(old);

   366             search.removeAttribute(name);

   367             reclaim(old);

   368             return getImmutableUniqueSet();

   369         }

   370         MutableAttributeSet ma = getMutableAttributeSet(old);

   371         ma.removeAttribute(name);

   372         return ma;

   373     }

   374 

   375     /**

   376      * Removes a set of attributes for the element.

   377      * <p>

   378      * This method is thread safe, although most Swing methods

   379      * are not. Please see

   380      * <A HREF="http://java.sun.com/docs/books/tutorial/uiswing/misc/threads.html">How

   381      * to Use Threads</A> for more information.

   382      *

   383      * @param old the old attribute set

   384      * @param names the attribute names

   385      * @return the updated attribute set

   386      * @see MutableAttributeSet#removeAttributes

   387      */

   388     public synchronized AttributeSet removeAttributes(AttributeSet old, Enumeration<?> names) {

   389         if (old.getAttributeCount() <= getCompressionThreshold()) {

   390             // build a search key and find/create an immutable and unique

   391             // set.

   392             search.removeAttributes(search);

   393             search.addAttributes(old);

   394             search.removeAttributes(names);

   395             reclaim(old);

   396             return getImmutableUniqueSet();

   397         }

   398         MutableAttributeSet ma = getMutableAttributeSet(old);

   399         ma.removeAttributes(names);

   400         return ma;

   401     }

   402 

   403     /**

   404      * Removes a set of attributes for the element.

   405      * <p>

   406      * This method is thread safe, although most Swing methods

   407      * are not. Please see

   408      * <A HREF="http://java.sun.com/docs/books/tutorial/uiswing/misc/threads.html">How

   409      * to Use Threads</A> for more information.

   410      *

   411      * @param old the old attribute set

   412      * @param attrs the attributes

   413      * @return the updated attribute set

   414      * @see MutableAttributeSet#removeAttributes

   415      */

   416     public synchronized AttributeSet removeAttributes(AttributeSet old, AttributeSet attrs) {

   417         if (old.getAttributeCount() <= getCompressionThreshold()) {

   418             // build a search key and find/create an immutable and unique

   419             // set.

   420             search.removeAttributes(search);

   421             search.addAttributes(old);

   422             search.removeAttributes(attrs);

   423             reclaim(old);

   424             return getImmutableUniqueSet();

   425         }

   426         MutableAttributeSet ma = getMutableAttributeSet(old);

   427         ma.removeAttributes(attrs);

   428         return ma;

   429     }

   430 

   431     /**

   432      * Fetches an empty AttributeSet.

   433      *

   434      * @return the set

   435      */

   436     public AttributeSet getEmptySet() {

   437         return SimpleAttributeSet.EMPTY;

   438     }

   439 

   440     /**

   441      * Returns a set no longer needed by the MutableAttributeSet implmentation.

   442      * This is useful for operation under 1.1 where there are no weak

   443      * references.  This would typically be called by the finalize method

   444      * of the MutableAttributeSet implementation.

   445      * <p>

   446      * This method is thread safe, although most Swing methods

   447      * are not. Please see

   448      * <A HREF="http://java.sun.com/docs/books/tutorial/uiswing/misc/threads.html">How

   449      * to Use Threads</A> for more information.

   450      *

   451      * @param a the set to reclaim

   452      */

   453     public void reclaim(AttributeSet a) {

   454         if (SwingUtilities.isEventDispatchThread()) {

   455             attributesPool.size(); // force WeakHashMap to expunge stale entries

   456         }

   457         // if current thread is not event dispatching thread

   458         // do not bother with expunging stale entries.

   459     }

   460 

   461     // --- local methods -----------------------------------------------

   462 

   463     /**

   464      * Returns the maximum number of key/value pairs to try and

   465      * compress into unique/immutable sets.  Any sets above this

   466      * limit will use hashtables and be a MutableAttributeSet.

   467      *

   468      * @return the threshold

   469      */

   470     protected int getCompressionThreshold() {

   471         return THRESHOLD;

   472     }

   473 

   474     /**

   475      * Create a compact set of attributes that might be shared.

   476      * This is a hook for subclasses that want to alter the

   477      * behavior of SmallAttributeSet.  This can be reimplemented

   478      * to return an AttributeSet that provides some sort of

   479      * attribute conversion.

   480      *

   481      * @param a The set of attributes to be represented in the

   482      *  the compact form.

   483      */

   484     protected SmallAttributeSet createSmallAttributeSet(AttributeSet a) {

   485         return new SmallAttributeSet(a);

   486     }

   487 

   488     /**

   489      * Create a large set of attributes that should trade off

   490      * space for time.  This set will not be shared.  This is

   491      * a hook for subclasses that want to alter the behavior

   492      * of the larger attribute storage format (which is

   493      * SimpleAttributeSet by default).   This can be reimplemented

   494      * to return a MutableAttributeSet that provides some sort of

   495      * attribute conversion.

   496      *

   497      * @param a The set of attributes to be represented in the

   498      *  the larger form.

   499      */

   500     protected MutableAttributeSet createLargeAttributeSet(AttributeSet a) {

   501         return new SimpleAttributeSet(a);

   502     }

   503 

   504     /**

   505      * Clean the unused immutable sets out of the hashtable.

   506      */

   507     synchronized void removeUnusedSets() {

   508         attributesPool.size(); // force WeakHashMap to expunge stale entries

   509     }

   510 

   511     /**

   512      * Search for an existing attribute set using the current search

   513      * parameters.  If a matching set is found, return it.  If a match

   514      * is not found, we create a new set and add it to the pool.

   515      */

   516     AttributeSet getImmutableUniqueSet() {

   517         // PENDING(prinz) should consider finding a alternative to

   518         // generating extra garbage on search key.

   519         SmallAttributeSet key = createSmallAttributeSet(search);

   520         WeakReference reference = (WeakReference)attributesPool.get(key);

   521         SmallAttributeSet a;

   522         if (reference == null

   523             || (a = (SmallAttributeSet)reference.get()) == null) {

   524             a = key;

   525             attributesPool.put(a, new WeakReference(a));

   526         }

   527         return a;

   528     }

   529 

   530     /**

   531      * Creates a mutable attribute set to hand out because the current

   532      * needs are too big to try and use a shared version.

   533      */

   534     MutableAttributeSet getMutableAttributeSet(AttributeSet a) {

   535         if (a instanceof MutableAttributeSet &&

   536             a != SimpleAttributeSet.EMPTY) {

   537             return (MutableAttributeSet) a;

   538         }

   539         return createLargeAttributeSet(a);

   540     }

   541 

   542     /**

   543      * Converts a StyleContext to a String.

   544      *

   545      * @return the string

   546      */

   547     public String toString() {

   548         removeUnusedSets();

   549         String s = "";

   550         Iterator iterator = attributesPool.keySet().iterator();

   551         while (iterator.hasNext()) {

   552             SmallAttributeSet set = (SmallAttributeSet)iterator.next();

   553             s = s + set + "\n";

   554         }

   555         return s;

   556     }

   557 

   558     // --- serialization ---------------------------------------------

   559 

   560     /**

   561      * Context-specific handling of writing out attributes

   562      */

   563     public void writeAttributes(ObjectOutputStream out,

   564                                   AttributeSet a) throws IOException {

   565         writeAttributeSet(out, a);

   566     }

   567 

   568     /**

   569      * Context-specific handling of reading in attributes

   570      */

   571     public void readAttributes(ObjectInputStream in,

   572                                MutableAttributeSet a) throws ClassNotFoundException, IOException {

   573         readAttributeSet(in, a);

   574     }

   575 

   576     /**

   577      * Writes a set of attributes to the given object stream

   578      * for the purpose of serialization.  This will take

   579      * special care to deal with static attribute keys that

   580      * have been registered wit the

   581      * <code>registerStaticAttributeKey</code> method.

   582      * Any attribute key not regsitered as a static key

   583      * will be serialized directly.  All values are expected

   584      * to be serializable.

   585      *

   586      * @param out the output stream

   587      * @param a the attribute set

   588      * @exception IOException on any I/O error

   589      */

   590     public static void writeAttributeSet(ObjectOutputStream out,

   591                                          AttributeSet a) throws IOException {

   592         int n = a.getAttributeCount();

   593         out.writeInt(n);

   594         Enumeration keys = a.getAttributeNames();

   595         while (keys.hasMoreElements()) {

   596             Object key = keys.nextElement();

   597             if (key instanceof Serializable) {

   598                 out.writeObject(key);

   599             } else {

   600                 Object ioFmt = freezeKeyMap.get(key);

   601                 if (ioFmt == null) {

   602                     throw new NotSerializableException(key.getClass().

   603                                  getName() + " is not serializable as a key in an AttributeSet");

   604                 }

   605                 out.writeObject(ioFmt);

   606             }

   607             Object value = a.getAttribute(key);

   608             Object ioFmt = freezeKeyMap.get(value);

   609             if (value instanceof Serializable) {

   610                 out.writeObject((ioFmt != null) ? ioFmt : value);

   611             } else {

   612                 if (ioFmt == null) {

   613                     throw new NotSerializableException(value.getClass().

   614                                  getName() + " is not serializable as a value in an AttributeSet");

   615                 }

   616                 out.writeObject(ioFmt);

   617             }

   618         }

   619     }

   620 

   621     /**

   622      * Reads a set of attributes from the given object input

   623      * stream that have been previously written out with

   624      * <code>writeAttributeSet</code>.  This will try to restore

   625      * keys that were static objects to the static objects in

   626      * the current virtual machine considering only those keys

   627      * that have been registered with the

   628      * <code>registerStaticAttributeKey</code> method.

   629      * The attributes retrieved from the stream will be placed

   630      * into the given mutable set.

   631      *

   632      * @param in the object stream to read the attribute data from.

   633      * @param a  the attribute set to place the attribute

   634      *   definitions in.

   635      * @exception ClassNotFoundException passed upward if encountered

   636      *  when reading the object stream.

   637      * @exception IOException passed upward if encountered when

   638      *  reading the object stream.

   639      */

   640     public static void readAttributeSet(ObjectInputStream in,

   641         MutableAttributeSet a) throws ClassNotFoundException, IOException {

   642 

   643         int n = in.readInt();

   644         for (int i = 0; i < n; i++) {

   645             Object key = in.readObject();

   646             Object value = in.readObject();

   647             if (thawKeyMap != null) {

   648                 Object staticKey = thawKeyMap.get(key);

   649                 if (staticKey != null) {

   650                     key = staticKey;

   651                 }

   652                 Object staticValue = thawKeyMap.get(value);

   653                 if (staticValue != null) {

   654                     value = staticValue;

   655                 }

   656             }

   657             a.addAttribute(key, value);

   658         }

   659     }

   660 

   661     /**

   662      * Registers an object as a static object that is being

   663      * used as a key in attribute sets.  This allows the key

   664      * to be treated specially for serialization.

   665      * <p>

   666      * For operation under a 1.1 virtual machine, this

   667      * uses the value returned by <code>toString</code>

   668      * concatenated to the classname.  The value returned

   669      * by toString should not have the class reference

   670      * in it (ie it should be reimplemented from the

   671      * definition in Object) in order to be the same when

   672      * recomputed later.

   673      *

   674      * @param key the non-null object key

   675      */

   676     public static void registerStaticAttributeKey(Object key) {

   677         String ioFmt = key.getClass().getName() + "." + key.toString();

   678         if (freezeKeyMap == null) {

   679             freezeKeyMap = new Hashtable();

   680             thawKeyMap = new Hashtable();

   681         }

   682         freezeKeyMap.put(key, ioFmt);

   683         thawKeyMap.put(ioFmt, key);

   684     }

   685 

   686     /**

   687      * Returns the object previously registered with

   688      * <code>registerStaticAttributeKey</code>.

   689      */

   690     public static Object getStaticAttribute(Object key) {

   691         if (thawKeyMap == null || key == null) {

   692             return null;

   693         }

   694         return thawKeyMap.get(key);

   695     }

   696 

   697     /**

   698      * Returns the String that <code>key</code> will be registered with

   699      * @see #getStaticAttribute

   700      * @see #registerStaticAttributeKey

   701      */

   702     public static Object getStaticAttributeKey(Object key) {

   703         return key.getClass().getName() + "." + key.toString();

   704     }

   705 

   706     private void writeObject(java.io.ObjectOutputStream s)

   707         throws IOException

   708     {

   709         // clean out unused sets before saving

   710         removeUnusedSets();

   711 

   712         s.defaultWriteObject();

   713     }

   714 

   715     private void readObject(ObjectInputStream s)

   716       throws ClassNotFoundException, IOException

   717     {

   718         fontSearch = new FontKey(null, 0, 0);

   719         fontTable = new Hashtable();

   720         search = new SimpleAttributeSet();

   721         attributesPool = Collections.

   722             synchronizedMap(new WeakHashMap());

   723         s.defaultReadObject();

   724     }

   725 

   726     // --- variables ---------------------------------------------------

   727 

   728     /**

   729      * The name given to the default logical style attached

   730      * to paragraphs.

   731      */

   732     public static final String DEFAULT_STYLE = "default";

   733 

   734     private static Hashtable freezeKeyMap;

   735     private static Hashtable thawKeyMap;

   736 

   737     private Style styles;

   738     private transient FontKey fontSearch = new FontKey(null, 0, 0);

   739     private transient Hashtable fontTable = new Hashtable();

   740 

   741     private transient Map attributesPool = Collections.

   742         synchronizedMap(new WeakHashMap());

   743     private transient MutableAttributeSet search = new SimpleAttributeSet();

   744 

   745     /**

   746      * Number of immutable sets that are not currently

   747      * being used.  This helps indicate when the sets need

   748      * to be cleaned out of the hashtable they are stored

   749      * in.

   750      */

   751     private int unusedSets;

   752 

   753     /**

   754      * The threshold for no longer sharing the set of attributes

   755      * in an immutable table.

   756      */

   757     static final int THRESHOLD = 9;

   758 

   759     /**

   760      * This class holds a small number of attributes in an array.

   761      * The storage format is key, value, key, value, etc.  The size

   762      * of the set is the length of the array divided by two.  By

   763      * default, this is the class that will be used to store attributes

   764      * when held in the compact sharable form.

   765      */

   766     public class SmallAttributeSet implements AttributeSet {

   767 

   768         public SmallAttributeSet(Object[] attributes) {

   769             this.attributes = attributes;

   770             updateResolveParent();

   771         }

   772 

   773         public SmallAttributeSet(AttributeSet attrs) {

   774             int n = attrs.getAttributeCount();

   775             Object[] tbl = new Object[2 * n];

   776             Enumeration names = attrs.getAttributeNames();

   777             int i = 0;

   778             while (names.hasMoreElements()) {

   779                 tbl[i] = names.nextElement();

   780                 tbl[i+1] = attrs.getAttribute(tbl[i]);

   781                 i += 2;

   782             }

   783             attributes = tbl;

   784             updateResolveParent();

   785         }

   786 

   787         private void updateResolveParent() {

   788             resolveParent = null;

   789             Object[] tbl = attributes;

   790             for (int i = 0; i < tbl.length; i += 2) {

   791                 if (tbl[i] == StyleConstants.ResolveAttribute) {

   792                     resolveParent = (AttributeSet)tbl[i + 1];

   793                     break;

   794                 }

   795             }

   796         }

   797 

   798         Object getLocalAttribute(Object nm) {

   799             if (nm == StyleConstants.ResolveAttribute) {

   800                 return resolveParent;

   801             }

   802             Object[] tbl = attributes;

   803             for (int i = 0; i < tbl.length; i += 2) {

   804                 if (nm.equals(tbl[i])) {

   805                     return tbl[i+1];

   806                 }

   807             }

   808             return null;

   809         }

   810 

   811         // --- Object methods -------------------------

   812 

   813         /**

   814          * Returns a string showing the key/value pairs

   815          */

   816         public String toString() {

   817             String s = "{";

   818             Object[] tbl = attributes;

   819             for (int i = 0; i < tbl.length; i += 2) {

   820                 if (tbl[i+1] instanceof AttributeSet) {

   821                     // don't recurse

   822                     s = s + tbl[i] + "=" + "AttributeSet" + ",";

   823                 } else {

   824                     s = s + tbl[i] + "=" + tbl[i+1] + ",";

   825                 }

   826             }

   827             s = s + "}";

   828             return s;

   829         }

   830 

   831         /**

   832          * Returns a hashcode for this set of attributes.

   833          * @return     a hashcode value for this set of attributes.

   834          */

   835         public int hashCode() {

   836             int code = 0;

   837             Object[] tbl = attributes;

   838             for (int i = 1; i < tbl.length; i += 2) {

   839                 code ^= tbl[i].hashCode();

   840             }

   841             return code;

   842         }

   843 

   844         /**

   845          * Compares this object to the specifed object.

   846          * The result is <code>true</code> if the object is an equivalent

   847          * set of attributes.

   848          * @param     obj   the object to compare with.

   849          * @return    <code>true</code> if the objects are equal;

   850          *            <code>false</code> otherwise.

   851          */

   852         public boolean equals(Object obj) {

   853             if (obj instanceof AttributeSet) {

   854                 AttributeSet attrs = (AttributeSet) obj;

   855                 return ((getAttributeCount() == attrs.getAttributeCount()) &&

   856                         containsAttributes(attrs));

   857             }

   858             return false;

   859         }

   860 

   861         /**

   862          * Clones a set of attributes.  Since the set is immutable, a

   863          * clone is basically the same set.

   864          *

   865          * @return the set of attributes

   866          */

   867         public Object clone() {

   868             return this;

   869         }

   870 

   871         //  --- AttributeSet methods ----------------------------

   872 

   873         /**

   874          * Gets the number of attributes that are defined.

   875          *

   876          * @return the number of attributes

   877          * @see AttributeSet#getAttributeCount

   878          */

   879         public int getAttributeCount() {

   880             return attributes.length / 2;

   881         }

   882 

   883         /**

   884          * Checks whether a given attribute is defined.

   885          *

   886          * @param key the attribute key

   887          * @return true if the attribute is defined

   888          * @see AttributeSet#isDefined

   889          */

   890         public boolean isDefined(Object key) {

   891             Object[] a = attributes;

   892             int n = a.length;

   893             for (int i = 0; i < n; i += 2) {

   894                 if (key.equals(a[i])) {

   895                     return true;

   896                 }

   897             }

   898             return false;

   899         }

   900 

   901         /**

   902          * Checks whether two attribute sets are equal.

   903          *

   904          * @param attr the attribute set to check against

   905          * @return true if the same

   906          * @see AttributeSet#isEqual

   907          */

   908         public boolean isEqual(AttributeSet attr) {

   909             if (attr instanceof SmallAttributeSet) {

   910                 return attr == this;

   911             }

   912             return ((getAttributeCount() == attr.getAttributeCount()) &&

   913                     containsAttributes(attr));

   914         }

   915 

   916         /**

   917          * Copies a set of attributes.

   918          *

   919          * @return the copy

   920          * @see AttributeSet#copyAttributes

   921          */

   922         public AttributeSet copyAttributes() {

   923             return this;

   924         }

   925 

   926         /**

   927          * Gets the value of an attribute.

   928          *

   929          * @param key the attribute name

   930          * @return the attribute value

   931          * @see AttributeSet#getAttribute

   932          */

   933         public Object getAttribute(Object key) {

   934             Object value = getLocalAttribute(key);

   935             if (value == null) {

   936                 AttributeSet parent = getResolveParent();

   937                 if (parent != null)

   938                     value = parent.getAttribute(key);

   939             }

   940             return value;

   941         }

   942 

   943         /**

   944          * Gets the names of all attributes.

   945          *

   946          * @return the attribute names

   947          * @see AttributeSet#getAttributeNames

   948          */

   949         public Enumeration<?> getAttributeNames() {

   950             return new KeyEnumeration(attributes);

   951         }

   952 

   953         /**

   954          * Checks whether a given attribute name/value is defined.

   955          *

   956          * @param name the attribute name

   957          * @param value the attribute value

   958          * @return true if the name/value is defined

   959          * @see AttributeSet#containsAttribute

   960          */

   961         public boolean containsAttribute(Object name, Object value) {

   962             return value.equals(getAttribute(name));

   963         }

   964 

   965         /**

   966          * Checks whether the attribute set contains all of

   967          * the given attributes.

   968          *

   969          * @param attrs the attributes to check

   970          * @return true if the element contains all the attributes

   971          * @see AttributeSet#containsAttributes

   972          */

   973         public boolean containsAttributes(AttributeSet attrs) {

   974             boolean result = true;

   975 

   976             Enumeration names = attrs.getAttributeNames();

   977             while (result && names.hasMoreElements()) {

   978                 Object name = names.nextElement();

   979                 result = attrs.getAttribute(name).equals(getAttribute(name));

   980             }

   981 

   982             return result;

   983         }

   984 

   985         /**

   986          * If not overriden, the resolving parent defaults to

   987          * the parent element.

   988          *

   989          * @return the attributes from the parent

   990          * @see AttributeSet#getResolveParent

   991          */

   992         public AttributeSet getResolveParent() {

   993             return resolveParent;

   994         }

   995 

   996         // --- variables -----------------------------------------

   997 

   998         Object[] attributes;

   999         // This is also stored in attributes

  1000         AttributeSet resolveParent;

  1001     }

  1002 

  1003     /**

  1004      * An enumeration of the keys in a SmallAttributeSet.

  1005      */

  1006     class KeyEnumeration implements Enumeration<Object> {

  1007 

  1008         KeyEnumeration(Object[] attr) {

  1009             this.attr = attr;

  1010             i = 0;

  1011         }

  1012 

  1013         /**

  1014          * Tests if this enumeration contains more elements.

  1015          *

  1016          * @return  <code>true</code> if this enumeration contains more elements;

  1017          *          <code>false</code> otherwise.

  1018          * @since   JDK1.0

  1019          */

  1020         public boolean hasMoreElements() {

  1021             return i < attr.length;

  1022         }

  1023 

  1024         /**

  1025          * Returns the next element of this enumeration.

  1026          *

  1027          * @return     the next element of this enumeration.

  1028          * @exception  NoSuchElementException  if no more elements exist.

  1029          * @since      JDK1.0

  1030          */

  1031         public Object nextElement() {

  1032             if (i < attr.length) {

  1033                 Object o = attr[i];

  1034                 i += 2;

  1035                 return o;

  1036             }

  1037             throw new NoSuchElementException();

  1038         }

  1039 

  1040         Object[] attr;

  1041         int i;

  1042     }

  1043 

  1044     /**

  1045      * Sorts the key strings so that they can be very quickly compared

  1046      * in the attribute set searchs.

  1047      */

  1048     class KeyBuilder {

  1049 

  1050         public void initialize(AttributeSet a) {

  1051             if (a instanceof SmallAttributeSet) {

  1052                 initialize(((SmallAttributeSet)a).attributes);

  1053             } else {

  1054                 keys.removeAllElements();

  1055                 data.removeAllElements();

  1056                 Enumeration names = a.getAttributeNames();

  1057                 while (names.hasMoreElements()) {

  1058                     Object name = names.nextElement();

  1059                     addAttribute(name, a.getAttribute(name));

  1060                 }

  1061             }

  1062         }

  1063 

  1064         /**

  1065          * Initialize with a set of already sorted

  1066          * keys (data from an existing SmallAttributeSet).

  1067          */

  1068         private void initialize(Object[] sorted) {

  1069             keys.removeAllElements();

  1070             data.removeAllElements();

  1071             int n = sorted.length;

  1072             for (int i = 0; i < n; i += 2) {

  1073                 keys.addElement(sorted[i]);

  1074                 data.addElement(sorted[i+1]);

  1075             }

  1076         }

  1077 

  1078         /**

  1079          * Creates a table of sorted key/value entries

  1080          * suitable for creation of an instance of

  1081          * SmallAttributeSet.

  1082          */

  1083         public Object[] createTable() {

  1084             int n = keys.size();

  1085             Object[] tbl = new Object[2 * n];

  1086             for (int i = 0; i < n; i ++) {

  1087                 int offs = 2 * i;

  1088                 tbl[offs] = keys.elementAt(i);

  1089                 tbl[offs + 1] = data.elementAt(i);

  1090             }

  1091             return tbl;

  1092         }

  1093 

  1094         /**

  1095          * The number of key/value pairs contained

  1096          * in the current key being forged.

  1097          */

  1098         int getCount() {

  1099             return keys.size();

  1100         }

  1101 

  1102         /**

  1103          * Adds a key/value to the set.

  1104          */

  1105         public void addAttribute(Object key, Object value) {

  1106             keys.addElement(key);

  1107             data.addElement(value);

  1108         }

  1109 

  1110         /**

  1111          * Adds a set of key/value pairs to the set.

  1112          */

  1113         public void addAttributes(AttributeSet attr) {

  1114             if (attr instanceof SmallAttributeSet) {

  1115                 // avoid searching the keys, they are already interned.

  1116                 Object[] tbl = ((SmallAttributeSet)attr).attributes;

  1117                 int n = tbl.length;

  1118                 for (int i = 0; i < n; i += 2) {

  1119                     addAttribute(tbl[i], tbl[i+1]);

  1120                 }

  1121             } else {

  1122                 Enumeration names = attr.getAttributeNames();

  1123                 while (names.hasMoreElements()) {

  1124                     Object name = names.nextElement();

  1125                     addAttribute(name, attr.getAttribute(name));

  1126                 }

  1127             }

  1128         }

  1129 

  1130         /**

  1131          * Removes the given name from the set.

  1132          */

  1133         public void removeAttribute(Object key) {

  1134             int n = keys.size();

  1135             for (int i = 0; i < n; i++) {