/*
* @(#)MuxingAttributeSet.java 1.4 03/12/19
*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/
package javax.swing.text.html;
import javax.swing.text.*;
import java.io.Serializable;
import java.util.*;
/**
* An implementation of <code>AttributeSet</code> that can multiplex
* across a set of <code>AttributeSet</code>s.
*
* @version 1.4 12/19/03
*/
class MuxingAttributeSet implements AttributeSet, Serializable {
/**
* Creates a <code>MuxingAttributeSet</code> with the passed in
* attributes.
*/
public MuxingAttributeSet(AttributeSet[] attrs) {
this.attrs = attrs;
}
/**
* Creates an empty <code>MuxingAttributeSet</code>. This is intended for
* use by subclasses only, and it is also intended that subclasses will
* set the constituent <code>AttributeSet</code>s before invoking any
* of the <code>AttributeSet</code> methods.
*/
protected MuxingAttributeSet() {
}
/**
* Directly sets the <code>AttributeSet</code>s that comprise this
* <code>MuxingAttributeSet</code>.
*/
protected synchronized void setAttributes(AttributeSet[] attrs) {
this.attrs = attrs;
}
/**
* Returns the <code>AttributeSet</code>s multiplexing too. When the
* <code>AttributeSet</code>s need to be referenced, this should be called.
*/
protected synchronized AttributeSet[] getAttributes() {
return attrs;
}
/**
* Inserts <code>as</code> at <code>index</code>. This assumes
* the value of <code>index</code> is between 0 and attrs.length,
* inclusive.
*/
protected synchronized void insertAttributeSetAt(AttributeSet as,
int index) {
int numAttrs = attrs.length;
AttributeSet newAttrs[] = new AttributeSet[numAttrs + 1];
if (index < numAttrs) {
if (index > 0) {
System.arraycopy(attrs, 0, newAttrs, 0, index);
System.arraycopy(attrs, index, newAttrs, index + 1,
numAttrs - index);
}
else {
System.arraycopy(attrs, 0, newAttrs, 1, numAttrs);
}
}
else {
System.arraycopy(attrs, 0, newAttrs, 0, numAttrs);
}
newAttrs[index] = as;
attrs = newAttrs;
}
/**
* Removes the AttributeSet at <code>index</code>. This assumes
* the value of <code>index</code> is greater than or equal to 0,
* and less than attrs.length.
*/
protected synchronized void removeAttributeSetAt(int index) {
int numAttrs = attrs.length;
AttributeSet[] newAttrs = new AttributeSet[numAttrs - 1];
if (numAttrs > 0) {
if (index == 0) {
// FIRST
System.arraycopy(attrs, 1, newAttrs, 0, numAttrs - 1);
}
else if (index < (numAttrs - 1)) {
// MIDDLE
System.arraycopy(attrs, 0, newAttrs, 0, index);
System.arraycopy(attrs, index + 1, newAttrs, index,
numAttrs - index - 1);
}
else {
// END
System.arraycopy(attrs, 0, newAttrs, 0, numAttrs - 1);
}
}
attrs = newAttrs;
}
// --- AttributeSet methods ----------------------------
/**
* Gets the number of attributes that are defined.
*
* @return the number of attributes
* @see AttributeSet#getAttributeCount
*/
public int getAttributeCount() {
AttributeSet[] as = getAttributes();
int n = 0;
for (int i = 0; i < as.length; i++) {
n += as[i].getAttributeCount();
}
return n;
}
/**
* Checks whether a given attribute is defined.
* This will convert the key over to CSS if the
* key is a StyleConstants key that has a CSS
* mapping.
*
* @param key the attribute key
* @return true if the attribute is defined
* @see AttributeSet#isDefined
*/
public boolean isDefined(Object key) {
AttributeSet[] as = getAttributes();
for (int i = 0; i < as.length; i++) {
if (as[i].isDefined(key)) {
return true;
}
}
return false;
}
/**
* Checks whether two attribute sets are equal.
*
* @param attr the attribute set to check against
* @return true if the same
* @see AttributeSet#isEqual
*/
public boolean isEqual(AttributeSet attr) {
return ((getAttributeCount() == attr.getAttributeCount()) &&
containsAttributes(attr));
}
/**
* Copies a set of attributes.
*
* @return the copy
* @see AttributeSet#copyAttributes
*/
public AttributeSet copyAttributes() {
AttributeSet[] as = getAttributes();
MutableAttributeSet a = new SimpleAttributeSet();
int n = 0;
for (int i = as.length - 1; i >= 0; i--) {
a.addAttributes(as[i]);
}
return a;
}
/**
* Gets the value of an attribute. If the requested
* attribute is a StyleConstants attribute that has
* a CSS mapping, the request will be converted.
*
* @param key the attribute name
* @return the attribute value
* @see AttributeSet#getAttribute
*/
public Object getAttribute(Object key) {
AttributeSet[] as = getAttributes();
int n = as.length;
for (int i = 0; i < n; i++) {
Object o = as[i].getAttribute(key);
if (o != null) {
return o;
}
}
return null;
}
/**
* Gets the names of all attributes.
*
* @return the attribute names
* @see AttributeSet#getAttributeNames
*/
public Enumeration getAttributeNames() {
return new MuxingAttributeNameEnumeration();
}
/**
* Checks whether a given attribute name/value is defined.
*
* @param name the attribute name
* @param value the attribute value
* @return true if the name/value is defined
* @see AttributeSet#containsAttribute
*/
public boolean containsAttribute(Object name, Object value) {
return value.equals(getAttribute(name));
}
/**
* Checks whether the attribute set contains all of
* the given attributes.
*
* @param attrs the attributes to check
* @return true if the element contains all the attributes
* @see AttributeSet#containsAttributes
*/
public boolean containsAttributes(AttributeSet attrs) {
boolean result = true;
Enumeration names = attrs.getAttributeNames();
while (result && names.hasMoreElements()) {
Object name = names.nextElement();
result = attrs.getAttribute(name).equals(getAttribute(name));
}
return result;
}
/**
* Returns null, subclasses may wish to do something more
* intelligent with this.
*/
public AttributeSet getResolveParent() {
return null;
}
/**
* The <code>AttributeSet</code>s that make up the resulting
* <code>AttributeSet</code>.
*/
private AttributeSet[] attrs;
/**
* An Enumeration of the Attribute names in a MuxingAttributeSet.
* This may return the same name more than once.
*/
private class MuxingAttributeNameEnumeration implements Enumeration {
MuxingAttributeNameEnumeration() {
updateEnum();
}
public boolean hasMoreElements() {
if (currentEnum == null) {
return false;
}
return currentEnum.hasMoreElements();
}
public Object nextElement() {
if (currentEnum == null) {
throw new NoSuchElementException("No more names");
}
Object retObject = currentEnum.nextElement();
if (!currentEnum.hasMoreElements()) {
updateEnum();
}
return retObject;
}
void updateEnum() {
AttributeSet[] as = getAttributes();
currentEnum = null;
while (currentEnum == null && attrIndex < as.length) {
currentEnum = as[attrIndex++].getAttributeNames();
if (!currentEnum.hasMoreElements()) {
currentEnum = null;
}
}
}
/** Index into attrs the current Enumeration came from. */
private int attrIndex;
/** Enumeration from attrs. */
private Enumeration currentEnum;
}
}
|
