| Methods Summary |
|---|
| public synchronized javax.swing.text.AttributeSet | addAttribute(javax.swing.text.AttributeSet old, java.lang.Object name, java.lang.Object value)Adds an attribute to the given set, and returns
the new representative set.
This method is thread safe, although most Swing methods
are not. Please see
How
to Use Threads for more information.
if ((old.getAttributeCount() + 1) <= getCompressionThreshold()) {
// build a search key and find/create an immutable and unique
// set.
search.removeAttributes(search);
search.addAttributes(old);
search.addAttribute(name, value);
reclaim(old);
return getImmutableUniqueSet();
}
MutableAttributeSet ma = getMutableAttributeSet(old);
ma.addAttribute(name, value);
return ma;
|
| public synchronized javax.swing.text.AttributeSet | addAttributes(javax.swing.text.AttributeSet old, javax.swing.text.AttributeSet attr)Adds a set of attributes to the element.
This method is thread safe, although most Swing methods
are not. Please see
How
to Use Threads for more information.
if ((old.getAttributeCount() + attr.getAttributeCount()) <= getCompressionThreshold()) {
// build a search key and find/create an immutable and unique
// set.
search.removeAttributes(search);
search.addAttributes(old);
search.addAttributes(attr);
reclaim(old);
return getImmutableUniqueSet();
}
MutableAttributeSet ma = getMutableAttributeSet(old);
ma.addAttributes(attr);
return ma;
|
| public void | addChangeListener(javax.swing.event.ChangeListener l)Adds a listener to track when styles are added
or removed.
styles.addChangeListener(l);
|
| public javax.swing.text.Style | addStyle(java.lang.String nm, javax.swing.text.Style parent)Adds a new style into the style hierarchy. Style attributes
resolve from bottom up so an attribute specified in a child
will override an attribute specified in the parent.
Style style = new NamedStyle(nm, parent);
if (nm != null) {
// add a named style, a class of attributes
styles.addAttribute(nm, style);
}
return style;
|
| protected javax.swing.text.MutableAttributeSet | createLargeAttributeSet(javax.swing.text.AttributeSet a)Create a large set of attributes that should trade off
space for time. This set will not be shared. This is
a hook for subclasses that want to alter the behavior
of the larger attribute storage format (which is
SimpleAttributeSet by default). This can be reimplemented
to return a MutableAttributeSet that provides some sort of
attribute conversion.
return new SimpleAttributeSet(a);
|
| protected javax.swing.text.StyleContext$SmallAttributeSet | createSmallAttributeSet(javax.swing.text.AttributeSet a)Create a compact set of attributes that might be shared.
This is a hook for subclasses that want to alter the
behavior of SmallAttributeSet. This can be reimplemented
to return an AttributeSet that provides some sort of
attribute conversion.
return new SmallAttributeSet(a);
|
| public java.awt.Color | getBackground(javax.swing.text.AttributeSet attr)Takes a set of attributes and turn it into a background color
specification. This might be used to specify things
like brighter, more hue, etc. By default it simply returns
the value specified by the StyleConstants.Background attribute.
return StyleConstants.getBackground(attr);
|
| public javax.swing.event.ChangeListener[] | getChangeListeners()Returns an array of all the ChangeListeners added
to this StyleContext with addChangeListener().
return ((NamedStyle)styles).getChangeListeners();
|
| protected int | getCompressionThreshold()Returns the maximum number of key/value pairs to try and
compress into unique/immutable sets. Any sets above this
limit will use hashtables and be a MutableAttributeSet.
return THRESHOLD;
|
| public static final javax.swing.text.StyleContext | getDefaultStyleContext()Returns default AttributeContext shared by all documents that
don't bother to define/supply their own context.
if (defaultContext == null) {
defaultContext = new StyleContext();
}
return defaultContext;
|
| public javax.swing.text.AttributeSet | getEmptySet()Fetches an empty AttributeSet.
return SimpleAttributeSet.EMPTY;
|
| public java.awt.Font | getFont(javax.swing.text.AttributeSet attr)Gets the font from an attribute set. This is
implemented to try and fetch a cached font
for the given AttributeSet, and if that fails
the font features are resolved and the
font is fetched from the low-level font cache.
// PENDING(prinz) add cache behavior
int style = Font.PLAIN;
if (StyleConstants.isBold(attr)) {
style |= Font.BOLD;
}
if (StyleConstants.isItalic(attr)) {
style |= Font.ITALIC;
}
String family = StyleConstants.getFontFamily(attr);
int size = StyleConstants.getFontSize(attr);
/**
* if either superscript or subscript is
* is set, we need to reduce the font size
* by 2.
*/
if (StyleConstants.isSuperscript(attr) ||
StyleConstants.isSubscript(attr)) {
size -= 2;
}
return getFont(family, style, size);
|
| public java.awt.Font | getFont(java.lang.String family, int style, int size)Gets a new font. This returns a Font from a cache
if a cached font exists. If not, a Font is added to
the cache. This is basically a low-level cache for
1.1 font features.
fontSearch.setValue(family, style, size);
Font f = (Font) fontTable.get(fontSearch);
if (f == null) {
// haven't seen this one yet.
Style defaultStyle =
getStyle(StyleContext.DEFAULT_STYLE);
if (defaultStyle != null) {
final String FONT_ATTRIBUTE_KEY = "FONT_ATTRIBUTE_KEY";
Font defaultFont =
(Font) defaultStyle.getAttribute(FONT_ATTRIBUTE_KEY);
if (defaultFont != null
&& defaultFont.getFamily().equalsIgnoreCase(family)) {
f = defaultFont.deriveFont(style, size);
}
}
if (f == null) {
f = new Font(family, style, size);
}
if (! FontManager.fontSupportsDefaultEncoding(f)) {
f = FontManager.getCompositeFontUIResource(f);
}
FontKey key = new FontKey(family, style, size);
fontTable.put(key, f);
}
return f;
|
| public java.awt.FontMetrics | getFontMetrics(java.awt.Font f)Returns font metrics for a font.
// The Toolkit implementations cache, so we just forward
// to the default toolkit.
return Toolkit.getDefaultToolkit().getFontMetrics(f);
|
| public java.awt.Color | getForeground(javax.swing.text.AttributeSet attr)Takes a set of attributes and turn it into a foreground color
specification. This might be used to specify things
like brighter, more hue, etc. By default it simply returns
the value specified by the StyleConstants.Foreground attribute.
return StyleConstants.getForeground(attr);
|
| javax.swing.text.AttributeSet | getImmutableUniqueSet()Search for an existing attribute set using the current search
parameters. If a matching set is found, return it. If a match
is not found, we create a new set and add it to the pool.
// PENDING(prinz) should consider finding a alternative to
// generating extra garbage on search key.
SmallAttributeSet key = createSmallAttributeSet(search);
WeakReference reference = (WeakReference)attributesPool.get(key);
SmallAttributeSet a;
if (reference == null
|| (a = (SmallAttributeSet)reference.get()) == null) {
a = key;
attributesPool.put(a, new WeakReference(a));
}
return a;
|
| javax.swing.text.MutableAttributeSet | getMutableAttributeSet(javax.swing.text.AttributeSet a)Creates a mutable attribute set to hand out because the current
needs are too big to try and use a shared version.
if (a instanceof MutableAttributeSet &&
a != SimpleAttributeSet.EMPTY) {
return (MutableAttributeSet) a;
}
return createLargeAttributeSet(a);
|
| public static java.lang.Object | getStaticAttribute(java.lang.Object key)Returns the object previously registered with
registerStaticAttributeKey.
if (thawKeyMap == null || key == null) {
return null;
}
return thawKeyMap.get(key);
|
| public static java.lang.Object | getStaticAttributeKey(java.lang.Object key)Returns the String that key will be registered with
return key.getClass().getName() + "." + key.toString();
|
| public javax.swing.text.Style | getStyle(java.lang.String nm)Fetches a named style previously added to the document
return (Style) styles.getAttribute(nm);
|
| public java.util.Enumeration | getStyleNames()Fetches the names of the styles defined.
return styles.getAttributeNames();
|
| public static void | readAttributeSet(java.io.ObjectInputStream in, javax.swing.text.MutableAttributeSet a)Reads a set of attributes from the given object input
stream that have been previously written out with
writeAttributeSet. This will try to restore
keys that were static objects to the static objects in
the current virtual machine considering only those keys
that have been registered with the
registerStaticAttributeKey method.
The attributes retrieved from the stream will be placed
into the given mutable set.
int n = in.readInt();
for (int i = 0; i < n; i++) {
Object key = in.readObject();
Object value = in.readObject();
if (thawKeyMap != null) {
Object staticKey = thawKeyMap.get(key);
if (staticKey != null) {
key = staticKey;
}
Object staticValue = thawKeyMap.get(value);
if (staticValue != null) {
value = staticValue;
}
}
a.addAttribute(key, value);
}
|
| public void | readAttributes(java.io.ObjectInputStream in, javax.swing.text.MutableAttributeSet a)Context-specific handling of reading in attributes
readAttributeSet(in, a);
|
| private void | readObject(java.io.ObjectInputStream s)
fontSearch = new FontKey(null, 0, 0);
fontTable = new Hashtable();
search = new SimpleAttributeSet();
attributesPool = Collections.
synchronizedMap(new WeakHashMap());
s.defaultReadObject();
|
| public void | reclaim(javax.swing.text.AttributeSet a)Returns a set no longer needed by the MutableAttributeSet implmentation.
This is useful for operation under 1.1 where there are no weak
references. This would typically be called by the finalize method
of the MutableAttributeSet implementation.
This method is thread safe, although most Swing methods
are not. Please see
How
to Use Threads for more information.
if (SwingUtilities.isEventDispatchThread()) {
attributesPool.size(); // force WeakHashMap to expunge stale entries
}
// if current thread is not event dispatching thread
// do not bother with expunging stale entries.
|
| public static void | registerStaticAttributeKey(java.lang.Object key)Registers an object as a static object that is being
used as a key in attribute sets. This allows the key
to be treated specially for serialization.
For operation under a 1.1 virtual machine, this
uses the value returned by toString
concatenated to the classname. The value returned
by toString should not have the class reference
in it (ie it should be reimplemented from the
definition in Object) in order to be the same when
recomputed later.
String ioFmt = key.getClass().getName() + "." + key.toString();
if (freezeKeyMap == null) {
freezeKeyMap = new Hashtable();
thawKeyMap = new Hashtable();
}
freezeKeyMap.put(key, ioFmt);
thawKeyMap.put(ioFmt, key);
|
| public synchronized javax.swing.text.AttributeSet | removeAttribute(javax.swing.text.AttributeSet old, java.lang.Object name)Removes an attribute from the set.
This method is thread safe, although most Swing methods
are not. Please see
How
to Use Threads for more information.
if ((old.getAttributeCount() - 1) <= getCompressionThreshold()) {
// build a search key and find/create an immutable and unique
// set.
search.removeAttributes(search);
search.addAttributes(old);
search.removeAttribute(name);
reclaim(old);
return getImmutableUniqueSet();
}
MutableAttributeSet ma = getMutableAttributeSet(old);
ma.removeAttribute(name);
return ma;
|
| public synchronized javax.swing.text.AttributeSet | removeAttributes(javax.swing.text.AttributeSet old, java.util.Enumeration names)Removes a set of attributes for the element.
This method is thread safe, although most Swing methods
are not. Please see
How
to Use Threads for more information.
if (old.getAttributeCount() <= getCompressionThreshold()) {
// build a search key and find/create an immutable and unique
// set.
search.removeAttributes(search);
search.addAttributes(old);
search.removeAttributes(names);
reclaim(old);
return getImmutableUniqueSet();
}
MutableAttributeSet ma = getMutableAttributeSet(old);
ma.removeAttributes(names);
return ma;
|
| public synchronized javax.swing.text.AttributeSet | removeAttributes(javax.swing.text.AttributeSet old, javax.swing.text.AttributeSet attrs)Removes a set of attributes for the element.
This method is thread safe, although most Swing methods
are not. Please see
How
to Use Threads for more information.
if (old.getAttributeCount() <= getCompressionThreshold()) {
// build a search key and find/create an immutable and unique
// set.
search.removeAttributes(search);
search.addAttributes(old);
search.removeAttributes(attrs);
reclaim(old);
return getImmutableUniqueSet();
}
MutableAttributeSet ma = getMutableAttributeSet(old);
ma.removeAttributes(attrs);
return ma;
|
| public void | removeChangeListener(javax.swing.event.ChangeListener l)Removes a listener that was tracking styles being
added or removed.
styles.removeChangeListener(l);
|
| public void | removeStyle(java.lang.String nm)Removes a named style previously added to the document.
styles.removeAttribute(nm);
|
| synchronized void | removeUnusedSets()Clean the unused immutable sets out of the hashtable.
attributesPool.size(); // force WeakHashMap to expunge stale entries
|
| public java.lang.String | toString()Converts a StyleContext to a String.
removeUnusedSets();
String s = "";
Iterator iterator = attributesPool.keySet().iterator();
while (iterator.hasNext()) {
SmallAttributeSet set = (SmallAttributeSet)iterator.next();
s = s + set + "\n";
}
return s;
|
| public static void | writeAttributeSet(java.io.ObjectOutputStream out, javax.swing.text.AttributeSet a)Writes a set of attributes to the given object stream
for the purpose of serialization. This will take
special care to deal with static attribute keys that
have been registered wit the
registerStaticAttributeKey method.
Any attribute key not regsitered as a static key
will be serialized directly. All values are expected
to be serializable.
int n = a.getAttributeCount();
out.writeInt(n);
Enumeration keys = a.getAttributeNames();
while (keys.hasMoreElements()) {
Object key = keys.nextElement();
if (key instanceof Serializable) {
out.writeObject(key);
} else {
Object ioFmt = freezeKeyMap.get(key);
if (ioFmt == null) {
throw new NotSerializableException(key.getClass().
getName() + " is not serializable as a key in an AttributeSet");
}
out.writeObject(ioFmt);
}
Object value = a.getAttribute(key);
Object ioFmt = freezeKeyMap.get(value);
if (value instanceof Serializable) {
out.writeObject((ioFmt != null) ? ioFmt : value);
} else {
if (ioFmt == null) {
throw new NotSerializableException(value.getClass().
getName() + " is not serializable as a value in an AttributeSet");
}
out.writeObject(ioFmt);
}
}
|
| public void | writeAttributes(java.io.ObjectOutputStream out, javax.swing.text.AttributeSet a)Context-specific handling of writing out attributes
writeAttributeSet(out, a);
|
| private void | writeObject(java.io.ObjectOutputStream s)
// clean out unused sets before saving
removeUnusedSets();
s.defaultWriteObject();
|
