1 /*
2 * Copyright (c) 2001, Oracle and/or its affiliates. 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. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 package javax.swing.text.html;
26
27 import javax.swing.text.*;
28 import java.io.Serializable;
29 import java.util.*;
30
31 /**
32 * An implementation of <code>AttributeSet</code> that can multiplex
33 * across a set of <code>AttributeSet</code>s.
34 *
35 */
36 class MuxingAttributeSet implements AttributeSet, Serializable {
37 /**
38 * Creates a <code>MuxingAttributeSet</code> with the passed in
39 * attributes.
40 */
41 public MuxingAttributeSet(AttributeSet[] attrs) {
42 this.attrs = attrs;
43 }
44
45 /**
46 * Creates an empty <code>MuxingAttributeSet</code>. This is intended for
47 * use by subclasses only, and it is also intended that subclasses will
48 * set the constituent <code>AttributeSet</code>s before invoking any
49 * of the <code>AttributeSet</code> methods.
50 */
51 protected MuxingAttributeSet() {
52 }
53
54 /**
55 * Directly sets the <code>AttributeSet</code>s that comprise this
56 * <code>MuxingAttributeSet</code>.
57 */
58 protected synchronized void setAttributes(AttributeSet[] attrs) {
59 this.attrs = attrs;
60 }
61
62 /**
63 * Returns the <code>AttributeSet</code>s multiplexing too. When the
64 * <code>AttributeSet</code>s need to be referenced, this should be called.
65 */
66 protected synchronized AttributeSet[] getAttributes() {
67 return attrs;
68 }
69
70 /**
71 * Inserts <code>as</code> at <code>index</code>. This assumes
72 * the value of <code>index</code> is between 0 and attrs.length,
73 * inclusive.
74 */
75 protected synchronized void insertAttributeSetAt(AttributeSet as,
76 int index) {
77 int numAttrs = attrs.length;
78 AttributeSet newAttrs[] = new AttributeSet[numAttrs + 1];
79 if (index < numAttrs) {
80 if (index > 0) {
81 System.arraycopy(attrs, 0, newAttrs, 0, index);
82 System.arraycopy(attrs, index, newAttrs, index + 1,
83 numAttrs - index);
84 }
85 else {
86 System.arraycopy(attrs, 0, newAttrs, 1, numAttrs);
87 }
88 }
89 else {
90 System.arraycopy(attrs, 0, newAttrs, 0, numAttrs);
91 }
92 newAttrs[index] = as;
93 attrs = newAttrs;
94 }
95
96 /**
97 * Removes the AttributeSet at <code>index</code>. This assumes
98 * the value of <code>index</code> is greater than or equal to 0,
99 * and less than attrs.length.
100 */
101 protected synchronized void removeAttributeSetAt(int index) {
102 int numAttrs = attrs.length;
103 AttributeSet[] newAttrs = new AttributeSet[numAttrs - 1];
104 if (numAttrs > 0) {
105 if (index == 0) {
106 // FIRST
107 System.arraycopy(attrs, 1, newAttrs, 0, numAttrs - 1);
108 }
109 else if (index < (numAttrs - 1)) {
110 // MIDDLE
111 System.arraycopy(attrs, 0, newAttrs, 0, index);
112 System.arraycopy(attrs, index + 1, newAttrs, index,
113 numAttrs - index - 1);
114 }
115 else {
116 // END
117 System.arraycopy(attrs, 0, newAttrs, 0, numAttrs - 1);
118 }
119 }
120 attrs = newAttrs;
121 }
122
123 // --- AttributeSet methods ----------------------------
124
125 /**
126 * Gets the number of attributes that are defined.
127 *
128 * @return the number of attributes
129 * @see AttributeSet#getAttributeCount
130 */
131 public int getAttributeCount() {
132 AttributeSet[] as = getAttributes();
133 int n = 0;
134 for (int i = 0; i < as.length; i++) {
135 n += as[i].getAttributeCount();
136 }
137 return n;
138 }
139
140 /**
141 * Checks whether a given attribute is defined.
142 * This will convert the key over to CSS if the
143 * key is a StyleConstants key that has a CSS
144 * mapping.
145 *
146 * @param key the attribute key
147 * @return true if the attribute is defined
148 * @see AttributeSet#isDefined
149 */
150 public boolean isDefined(Object key) {
151 AttributeSet[] as = getAttributes();
152 for (int i = 0; i < as.length; i++) {
153 if (as[i].isDefined(key)) {
154 return true;
155 }
156 }
157 return false;
158 }
159
160 /**
161 * Checks whether two attribute sets are equal.
162 *
163 * @param attr the attribute set to check against
164 * @return true if the same
165 * @see AttributeSet#isEqual
166 */
167 public boolean isEqual(AttributeSet attr) {
168 return ((getAttributeCount() == attr.getAttributeCount()) &&
169 containsAttributes(attr));
170 }
171
172 /**
173 * Copies a set of attributes.
174 *
175 * @return the copy
176 * @see AttributeSet#copyAttributes
177 */
178 public AttributeSet copyAttributes() {
179 AttributeSet[] as = getAttributes();
180 MutableAttributeSet a = new SimpleAttributeSet();
181 int n = 0;
182 for (int i = as.length - 1; i >= 0; i--) {
183 a.addAttributes(as[i]);
184 }
185 return a;
186 }
187
188 /**
189 * Gets the value of an attribute. If the requested
190 * attribute is a StyleConstants attribute that has
191 * a CSS mapping, the request will be converted.
192 *
193 * @param key the attribute name
194 * @return the attribute value
195 * @see AttributeSet#getAttribute
196 */
197 public Object getAttribute(Object key) {
198 AttributeSet[] as = getAttributes();
199 int n = as.length;
200 for (int i = 0; i < n; i++) {
201 Object o = as[i].getAttribute(key);
202 if (o != null) {
203 return o;
204 }
205 }
206 return null;
207 }
208
209 /**
210 * Gets the names of all attributes.
211 *
212 * @return the attribute names
213 * @see AttributeSet#getAttributeNames
214 */
215 public Enumeration getAttributeNames() {
216 return new MuxingAttributeNameEnumeration();
217 }
218
219 /**
220 * Checks whether a given attribute name/value is defined.
221 *
222 * @param name the attribute name
223 * @param value the attribute value
224 * @return true if the name/value is defined
225 * @see AttributeSet#containsAttribute
226 */
227 public boolean containsAttribute(Object name, Object value) {
228 return value.equals(getAttribute(name));
229 }
230
231 /**
232 * Checks whether the attribute set contains all of
233 * the given attributes.
234 *
235 * @param attrs the attributes to check
236 * @return true if the element contains all the attributes
237 * @see AttributeSet#containsAttributes
238 */
239 public boolean containsAttributes(AttributeSet attrs) {
240 boolean result = true;
241
242 Enumeration names = attrs.getAttributeNames();
243 while (result && names.hasMoreElements()) {
244 Object name = names.nextElement();
245 result = attrs.getAttribute(name).equals(getAttribute(name));
246 }
247
248 return result;
249 }
250
251 /**
252 * Returns null, subclasses may wish to do something more
253 * intelligent with this.
254 */
255 public AttributeSet getResolveParent() {
256 return null;
257 }
258
259 /**
260 * The <code>AttributeSet</code>s that make up the resulting
261 * <code>AttributeSet</code>.
262 */
263 private AttributeSet[] attrs;
264
265
266 /**
267 * An Enumeration of the Attribute names in a MuxingAttributeSet.
268 * This may return the same name more than once.
269 */
270 private class MuxingAttributeNameEnumeration implements Enumeration {
271
272 MuxingAttributeNameEnumeration() {
273 updateEnum();
274 }
275
276 public boolean hasMoreElements() {
277 if (currentEnum == null) {
278 return false;
279 }
280 return currentEnum.hasMoreElements();
281 }
282
283 public Object nextElement() {
284 if (currentEnum == null) {
285 throw new NoSuchElementException("No more names");
286 }
287 Object retObject = currentEnum.nextElement();
288 if (!currentEnum.hasMoreElements()) {
289 updateEnum();
290 }
291 return retObject;
292 }
293
294 void updateEnum() {
295 AttributeSet[] as = getAttributes();
296 currentEnum = null;
297 while (currentEnum == null && attrIndex < as.length) {
298 currentEnum = as[attrIndex++].getAttributeNames();
299 if (!currentEnum.hasMoreElements()) {
300 currentEnum = null;
301 }
302 }
303 }
304
305
306 /** Index into attrs the current Enumeration came from. */
307 private int attrIndex;
308 /** Enumeration from attrs. */
309 private Enumeration currentEnum;
310 }
311 }