Print this page
| Split |
Close |
| Expand all |
| Collapse all |
--- old/src/share/classes/javax/swing/text/StyleContext.java
+++ new/src/share/classes/javax/swing/text/StyleContext.java
1 1 /*
2 2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
3 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 4 *
5 5 * This code is free software; you can redistribute it and/or modify it
6 6 * under the terms of the GNU General Public License version 2 only, as
7 7 * published by the Free Software Foundation. Oracle designates this
8 8 * particular file as subject to the "Classpath" exception as provided
9 9 * by Oracle in the LICENSE file that accompanied this code.
10 10 *
11 11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 14 * version 2 for more details (a copy is included in the LICENSE file that
15 15 * accompanied this code).
16 16 *
17 17 * You should have received a copy of the GNU General Public License version
18 18 * 2 along with this work; if not, write to the Free Software Foundation,
19 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 20 *
21 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 22 * or visit www.oracle.com if you need additional information or have any
23 23 * questions.
24 24 */
25 25 package javax.swing.text;
26 26
27 27 import java.awt.*;
28 28 import java.util.*;
29 29 import java.io.*;
30 30
31 31 import javax.swing.SwingUtilities;
32 32 import javax.swing.event.ChangeListener;
33 33 import javax.swing.event.EventListenerList;
34 34 import javax.swing.event.ChangeEvent;
35 35 import java.lang.ref.WeakReference;
36 36 import java.util.WeakHashMap;
37 37
38 38 import sun.font.FontUtilities;
39 39
40 40 /**
41 41 * A pool of styles and their associated resources. This class determines
42 42 * the lifetime of a group of resources by being a container that holds
43 43 * caches for various resources such as font and color that get reused
44 44 * by the various style definitions. This can be shared by multiple
45 45 * documents if desired to maximize the sharing of related resources.
46 46 * <p>
47 47 * This class also provides efficient support for small sets of attributes
48 48 * and compresses them by sharing across uses and taking advantage of
49 49 * their immutable nature. Since many styles are replicated, the potential
50 50 * for sharing is significant, and copies can be extremely cheap.
51 51 * Larger sets reduce the possibility of sharing, and therefore revert
52 52 * automatically to a less space-efficient implementation.
53 53 * <p>
54 54 * <strong>Warning:</strong>
55 55 * Serialized objects of this class will not be compatible with
56 56 * future Swing releases. The current serialization support is
57 57 * appropriate for short term storage or RMI between applications running
58 58 * the same version of Swing. As of 1.4, support for long term storage
59 59 * of all JavaBeans™
60 60 * has been added to the <code>java.beans</code> package.
61 61 * Please see {@link java.beans.XMLEncoder}.
62 62 *
63 63 * @author Timothy Prinzing
64 64 */
65 65 public class StyleContext implements Serializable, AbstractDocument.AttributeContext {
66 66
67 67 /**
68 68 * Returns default AttributeContext shared by all documents that
69 69 * don't bother to define/supply their own context.
70 70 *
71 71 * @return the context
72 72 */
73 73 public static final StyleContext getDefaultStyleContext() {
74 74 if (defaultContext == null) {
75 75 defaultContext = new StyleContext();
76 76 }
77 77 return defaultContext;
78 78 }
79 79
80 80 private static StyleContext defaultContext;
81 81
82 82 /**
83 83 * Creates a new StyleContext object.
84 84 */
85 85 public StyleContext() {
86 86 styles = new NamedStyle(null);
87 87 addStyle(DEFAULT_STYLE, null);
88 88 }
89 89
90 90 /**
91 91 * Adds a new style into the style hierarchy. Style attributes
92 92 * resolve from bottom up so an attribute specified in a child
93 93 * will override an attribute specified in the parent.
94 94 *
95 95 * @param nm the name of the style (must be unique within the
96 96 * collection of named styles in the document). The name may
97 97 * be null if the style is unnamed, but the caller is responsible
98 98 * for managing the reference returned as an unnamed style can't
99 99 * be fetched by name. An unnamed style may be useful for things
100 100 * like character attribute overrides such as found in a style
101 101 * run.
102 102 * @param parent the parent style. This may be null if unspecified
103 103 * attributes need not be resolved in some other style.
104 104 * @return the created style
105 105 */
106 106 public Style addStyle(String nm, Style parent) {
107 107 Style style = new NamedStyle(nm, parent);
108 108 if (nm != null) {
109 109 // add a named style, a class of attributes
110 110 styles.addAttribute(nm, style);
111 111 }
112 112 return style;
113 113 }
114 114
115 115 /**
116 116 * Removes a named style previously added to the document.
117 117 *
118 118 * @param nm the name of the style to remove
119 119 */
120 120 public void removeStyle(String nm) {
121 121 styles.removeAttribute(nm);
122 122 }
123 123
124 124 /**
125 125 * Fetches a named style previously added to the document
126 126 *
127 127 * @param nm the name of the style
128 128 * @return the style
129 129 */
130 130 public Style getStyle(String nm) {
131 131 return (Style) styles.getAttribute(nm);
132 132 }
133 133
134 134 /**
135 135 * Fetches the names of the styles defined.
136 136 *
137 137 * @return the list of names as an enumeration
138 138 */
139 139 public Enumeration<?> getStyleNames() {
140 140 return styles.getAttributeNames();
141 141 }
142 142
143 143 /**
144 144 * Adds a listener to track when styles are added
145 145 * or removed.
146 146 *
147 147 * @param l the change listener
148 148 */
149 149 public void addChangeListener(ChangeListener l) {
150 150 styles.addChangeListener(l);
151 151 }
152 152
153 153 /**
154 154 * Removes a listener that was tracking styles being
155 155 * added or removed.
156 156 *
157 157 * @param l the change listener
158 158 */
159 159 public void removeChangeListener(ChangeListener l) {
160 160 styles.removeChangeListener(l);
161 161 }
162 162
163 163 /**
164 164 * Returns an array of all the <code>ChangeListener</code>s added
165 165 * to this StyleContext with addChangeListener().
166 166 *
167 167 * @return all of the <code>ChangeListener</code>s added or an empty
168 168 * array if no listeners have been added
169 169 * @since 1.4
170 170 */
171 171 public ChangeListener[] getChangeListeners() {
172 172 return ((NamedStyle)styles).getChangeListeners();
173 173 }
174 174
175 175 /**
176 176 * Gets the font from an attribute set. This is
177 177 * implemented to try and fetch a cached font
178 178 * for the given AttributeSet, and if that fails
179 179 * the font features are resolved and the
180 180 * font is fetched from the low-level font cache.
181 181 *
182 182 * @param attr the attribute set
183 183 * @return the font
184 184 */
185 185 public Font getFont(AttributeSet attr) {
186 186 // PENDING(prinz) add cache behavior
187 187 int style = Font.PLAIN;
188 188 if (StyleConstants.isBold(attr)) {
189 189 style |= Font.BOLD;
190 190 }
191 191 if (StyleConstants.isItalic(attr)) {
192 192 style |= Font.ITALIC;
193 193 }
194 194 String family = StyleConstants.getFontFamily(attr);
195 195 int size = StyleConstants.getFontSize(attr);
196 196
197 197 /**
198 198 * if either superscript or subscript is
199 199 * is set, we need to reduce the font size
200 200 * by 2.
201 201 */
202 202 if (StyleConstants.isSuperscript(attr) ||
203 203 StyleConstants.isSubscript(attr)) {
204 204 size -= 2;
205 205 }
206 206
207 207 return getFont(family, style, size);
208 208 }
209 209
210 210 /**
211 211 * Takes a set of attributes and turn it into a foreground color
212 212 * specification. This might be used to specify things
213 213 * like brighter, more hue, etc. By default it simply returns
214 214 * the value specified by the StyleConstants.Foreground attribute.
215 215 *
216 216 * @param attr the set of attributes
217 217 * @return the color
218 218 */
219 219 public Color getForeground(AttributeSet attr) {
220 220 return StyleConstants.getForeground(attr);
221 221 }
222 222
223 223 /**
224 224 * Takes a set of attributes and turn it into a background color
225 225 * specification. This might be used to specify things
226 226 * like brighter, more hue, etc. By default it simply returns
227 227 * the value specified by the StyleConstants.Background attribute.
228 228 *
229 229 * @param attr the set of attributes
230 230 * @return the color
231 231 */
232 232 public Color getBackground(AttributeSet attr) {
233 233 return StyleConstants.getBackground(attr);
234 234 }
235 235
236 236 /**
237 237 * Gets a new font. This returns a Font from a cache
238 238 * if a cached font exists. If not, a Font is added to
239 239 * the cache. This is basically a low-level cache for
240 240 * 1.1 font features.
241 241 *
242 242 * @param family the font family (such as "Monospaced")
243 243 * @param style the style of the font (such as Font.PLAIN)
244 244 * @param size the point size >= 1
245 245 * @return the new font
246 246 */
247 247 public Font getFont(String family, int style, int size) {
248 248 fontSearch.setValue(family, style, size);
249 249 Font f = fontTable.get(fontSearch);
250 250 if (f == null) {
251 251 // haven't seen this one yet.
252 252 Style defaultStyle =
253 253 getStyle(StyleContext.DEFAULT_STYLE);
254 254 if (defaultStyle != null) {
255 255 final String FONT_ATTRIBUTE_KEY = "FONT_ATTRIBUTE_KEY";
256 256 Font defaultFont =
257 257 (Font) defaultStyle.getAttribute(FONT_ATTRIBUTE_KEY);
258 258 if (defaultFont != null
259 259 && defaultFont.getFamily().equalsIgnoreCase(family)) {
260 260 f = defaultFont.deriveFont(style, size);
261 261 }
262 262 }
263 263 if (f == null) {
264 264 f = new Font(family, style, size);
265 265 }
266 266 if (! FontUtilities.fontSupportsDefaultEncoding(f)) {
267 267 f = FontUtilities.getCompositeFontUIResource(f);
268 268 }
269 269 FontKey key = new FontKey(family, style, size);
270 270 fontTable.put(key, f);
271 271 }
272 272 return f;
273 273 }
274 274
275 275 /**
276 276 * Returns font metrics for a font.
277 277 *
278 278 * @param f the font
279 279 * @return the metrics
280 280 */
281 281 public FontMetrics getFontMetrics(Font f) {
282 282 // The Toolkit implementations cache, so we just forward
283 283 // to the default toolkit.
284 284 return Toolkit.getDefaultToolkit().getFontMetrics(f);
|
↓ open down ↓ |
284 lines elided |
↑ open up ↑ |
285 285 }
286 286
287 287 // --- AttributeContext methods --------------------
288 288
289 289 /**
290 290 * Adds an attribute to the given set, and returns
291 291 * the new representative set.
292 292 * <p>
293 293 * This method is thread safe, although most Swing methods
294 294 * are not. Please see
295 - * <A HREF="http://docs.oracle.com/javase/tutorial/uiswing/concurrency/index.html">Concurrency
295 + * <A HREF="https://docs.oracle.com/javase/tutorial/uiswing/concurrency/index.html">Concurrency
296 296 * in Swing</A> for more information.
297 297 *
298 298 * @param old the old attribute set
299 299 * @param name the non-null attribute name
300 300 * @param value the attribute value
301 301 * @return the updated attribute set
302 302 * @see MutableAttributeSet#addAttribute
303 303 */
304 304 public synchronized AttributeSet addAttribute(AttributeSet old, Object name, Object value) {
305 305 if ((old.getAttributeCount() + 1) <= getCompressionThreshold()) {
306 306 // build a search key and find/create an immutable and unique
307 307 // set.
308 308 search.removeAttributes(search);
309 309 search.addAttributes(old);
310 310 search.addAttribute(name, value);
311 311 reclaim(old);
312 312 return getImmutableUniqueSet();
313 313 }
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
314 314 MutableAttributeSet ma = getMutableAttributeSet(old);
315 315 ma.addAttribute(name, value);
316 316 return ma;
317 317 }
318 318
319 319 /**
320 320 * Adds a set of attributes to the element.
321 321 * <p>
322 322 * This method is thread safe, although most Swing methods
323 323 * are not. Please see
324 - * <A HREF="http://docs.oracle.com/javase/tutorial/uiswing/concurrency/index.html">Concurrency
324 + * <A HREF="https://docs.oracle.com/javase/tutorial/uiswing/concurrency/index.html">Concurrency
325 325 * in Swing</A> for more information.
326 326 *
327 327 * @param old the old attribute set
328 328 * @param attr the attributes to add
329 329 * @return the updated attribute set
330 330 * @see MutableAttributeSet#addAttribute
331 331 */
332 332 public synchronized AttributeSet addAttributes(AttributeSet old, AttributeSet attr) {
333 333 if ((old.getAttributeCount() + attr.getAttributeCount()) <= getCompressionThreshold()) {
334 334 // build a search key and find/create an immutable and unique
335 335 // set.
336 336 search.removeAttributes(search);
337 337 search.addAttributes(old);
338 338 search.addAttributes(attr);
339 339 reclaim(old);
340 340 return getImmutableUniqueSet();
341 341 }
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
342 342 MutableAttributeSet ma = getMutableAttributeSet(old);
343 343 ma.addAttributes(attr);
344 344 return ma;
345 345 }
346 346
347 347 /**
348 348 * Removes an attribute from the set.
349 349 * <p>
350 350 * This method is thread safe, although most Swing methods
351 351 * are not. Please see
352 - * <A HREF="http://docs.oracle.com/javase/tutorial/uiswing/concurrency/index.html">Concurrency
352 + * <A HREF="https://docs.oracle.com/javase/tutorial/uiswing/concurrency/index.html">Concurrency
353 353 * in Swing</A> for more information.
354 354 *
355 355 * @param old the old set of attributes
356 356 * @param name the non-null attribute name
357 357 * @return the updated attribute set
358 358 * @see MutableAttributeSet#removeAttribute
359 359 */
360 360 public synchronized AttributeSet removeAttribute(AttributeSet old, Object name) {
361 361 if ((old.getAttributeCount() - 1) <= getCompressionThreshold()) {
362 362 // build a search key and find/create an immutable and unique
363 363 // set.
364 364 search.removeAttributes(search);
365 365 search.addAttributes(old);
366 366 search.removeAttribute(name);
367 367 reclaim(old);
368 368 return getImmutableUniqueSet();
369 369 }
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
370 370 MutableAttributeSet ma = getMutableAttributeSet(old);
371 371 ma.removeAttribute(name);
372 372 return ma;
373 373 }
374 374
375 375 /**
376 376 * Removes a set of attributes for the element.
377 377 * <p>
378 378 * This method is thread safe, although most Swing methods
379 379 * are not. Please see
380 - * <A HREF="http://docs.oracle.com/javase/tutorial/uiswing/concurrency/index.html">Concurrency
380 + * <A HREF="https://docs.oracle.com/javase/tutorial/uiswing/concurrency/index.html">Concurrency
381 381 * in Swing</A> for more information.
382 382 *
383 383 * @param old the old attribute set
384 384 * @param names the attribute names
385 385 * @return the updated attribute set
386 386 * @see MutableAttributeSet#removeAttributes
387 387 */
388 388 public synchronized AttributeSet removeAttributes(AttributeSet old, Enumeration<?> names) {
389 389 if (old.getAttributeCount() <= getCompressionThreshold()) {
390 390 // build a search key and find/create an immutable and unique
391 391 // set.
392 392 search.removeAttributes(search);
393 393 search.addAttributes(old);
394 394 search.removeAttributes(names);
395 395 reclaim(old);
396 396 return getImmutableUniqueSet();
397 397 }
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
398 398 MutableAttributeSet ma = getMutableAttributeSet(old);
399 399 ma.removeAttributes(names);
400 400 return ma;
401 401 }
402 402
403 403 /**
404 404 * Removes a set of attributes for the element.
405 405 * <p>
406 406 * This method is thread safe, although most Swing methods
407 407 * are not. Please see
408 - * <A HREF="http://docs.oracle.com/javase/tutorial/uiswing/concurrency/index.html">Concurrency
408 + * <A HREF="https://docs.oracle.com/javase/tutorial/uiswing/concurrency/index.html">Concurrency
409 409 * in Swing</A> for more information.
410 410 *
411 411 * @param old the old attribute set
412 412 * @param attrs the attributes
413 413 * @return the updated attribute set
414 414 * @see MutableAttributeSet#removeAttributes
415 415 */
416 416 public synchronized AttributeSet removeAttributes(AttributeSet old, AttributeSet attrs) {
417 417 if (old.getAttributeCount() <= getCompressionThreshold()) {
418 418 // build a search key and find/create an immutable and unique
419 419 // set.
420 420 search.removeAttributes(search);
421 421 search.addAttributes(old);
422 422 search.removeAttributes(attrs);
423 423 reclaim(old);
424 424 return getImmutableUniqueSet();
425 425 }
426 426 MutableAttributeSet ma = getMutableAttributeSet(old);
427 427 ma.removeAttributes(attrs);
428 428 return ma;
429 429 }
430 430
431 431 /**
432 432 * Fetches an empty AttributeSet.
433 433 *
434 434 * @return the set
435 435 */
436 436 public AttributeSet getEmptySet() {
437 437 return SimpleAttributeSet.EMPTY;
|
↓ open down ↓ |
19 lines elided |
↑ open up ↑ |
438 438 }
439 439
440 440 /**
441 441 * Returns a set no longer needed by the MutableAttributeSet implementation.
442 442 * This is useful for operation under 1.1 where there are no weak
443 443 * references. This would typically be called by the finalize method
444 444 * of the MutableAttributeSet implementation.
445 445 * <p>
446 446 * This method is thread safe, although most Swing methods
447 447 * are not. Please see
448 - * <A HREF="http://docs.oracle.com/javase/tutorial/uiswing/concurrency/index.html">Concurrency
448 + * <A HREF="https://docs.oracle.com/javase/tutorial/uiswing/concurrency/index.html">Concurrency
449 449 * in Swing</A> for more information.
450 450 *
451 451 * @param a the set to reclaim
452 452 */
453 453 public void reclaim(AttributeSet a) {
454 454 if (SwingUtilities.isEventDispatchThread()) {
455 455 attributesPool.size(); // force WeakHashMap to expunge stale entries
456 456 }
457 457 // if current thread is not event dispatching thread
458 458 // do not bother with expunging stale entries.
459 459 }
460 460
461 461 // --- local methods -----------------------------------------------
462 462
463 463 /**
464 464 * Returns the maximum number of key/value pairs to try and
465 465 * compress into unique/immutable sets. Any sets above this
466 466 * limit will use hashtables and be a MutableAttributeSet.
467 467 *
468 468 * @return the threshold
469 469 */
470 470 protected int getCompressionThreshold() {
471 471 return THRESHOLD;
472 472 }
473 473
474 474 /**
475 475 * Create a compact set of attributes that might be shared.
476 476 * This is a hook for subclasses that want to alter the
477 477 * behavior of SmallAttributeSet. This can be reimplemented
478 478 * to return an AttributeSet that provides some sort of
479 479 * attribute conversion.
480 480 *
481 481 * @param a The set of attributes to be represented in the
482 482 * the compact form.
483 483 */
484 484 protected SmallAttributeSet createSmallAttributeSet(AttributeSet a) {
485 485 return new SmallAttributeSet(a);
486 486 }
487 487
488 488 /**
489 489 * Create a large set of attributes that should trade off
490 490 * space for time. This set will not be shared. This is
491 491 * a hook for subclasses that want to alter the behavior
492 492 * of the larger attribute storage format (which is
493 493 * SimpleAttributeSet by default). This can be reimplemented
494 494 * to return a MutableAttributeSet that provides some sort of
495 495 * attribute conversion.
496 496 *
497 497 * @param a The set of attributes to be represented in the
498 498 * the larger form.
499 499 */
500 500 protected MutableAttributeSet createLargeAttributeSet(AttributeSet a) {
501 501 return new SimpleAttributeSet(a);
502 502 }
503 503
504 504 /**
505 505 * Clean the unused immutable sets out of the hashtable.
506 506 */
507 507 synchronized void removeUnusedSets() {
508 508 attributesPool.size(); // force WeakHashMap to expunge stale entries
509 509 }
510 510
511 511 /**
512 512 * Search for an existing attribute set using the current search
513 513 * parameters. If a matching set is found, return it. If a match
514 514 * is not found, we create a new set and add it to the pool.
515 515 */
516 516 AttributeSet getImmutableUniqueSet() {
517 517 // PENDING(prinz) should consider finding a alternative to
518 518 // generating extra garbage on search key.
519 519 SmallAttributeSet key = createSmallAttributeSet(search);
520 520 WeakReference<SmallAttributeSet> reference = attributesPool.get(key);
521 521 SmallAttributeSet a;
522 522 if (reference == null || (a = reference.get()) == null) {
523 523 a = key;
524 524 attributesPool.put(a, new WeakReference<SmallAttributeSet>(a));
525 525 }
526 526 return a;
527 527 }
528 528
529 529 /**
530 530 * Creates a mutable attribute set to hand out because the current
531 531 * needs are too big to try and use a shared version.
532 532 */
533 533 MutableAttributeSet getMutableAttributeSet(AttributeSet a) {
534 534 if (a instanceof MutableAttributeSet &&
535 535 a != SimpleAttributeSet.EMPTY) {
536 536 return (MutableAttributeSet) a;
537 537 }
538 538 return createLargeAttributeSet(a);
539 539 }
540 540
541 541 /**
542 542 * Converts a StyleContext to a String.
543 543 *
544 544 * @return the string
545 545 */
546 546 public String toString() {
547 547 removeUnusedSets();
548 548 String s = "";
549 549 for (SmallAttributeSet set : attributesPool.keySet()) {
550 550 s = s + set + "\n";
551 551 }
552 552 return s;
553 553 }
554 554
555 555 // --- serialization ---------------------------------------------
556 556
557 557 /**
558 558 * Context-specific handling of writing out attributes
559 559 */
560 560 public void writeAttributes(ObjectOutputStream out,
561 561 AttributeSet a) throws IOException {
562 562 writeAttributeSet(out, a);
563 563 }
564 564
565 565 /**
566 566 * Context-specific handling of reading in attributes
567 567 */
568 568 public void readAttributes(ObjectInputStream in,
569 569 MutableAttributeSet a) throws ClassNotFoundException, IOException {
570 570 readAttributeSet(in, a);
571 571 }
572 572
573 573 /**
574 574 * Writes a set of attributes to the given object stream
575 575 * for the purpose of serialization. This will take
576 576 * special care to deal with static attribute keys that
577 577 * have been registered wit the
578 578 * <code>registerStaticAttributeKey</code> method.
579 579 * Any attribute key not registered as a static key
580 580 * will be serialized directly. All values are expected
581 581 * to be serializable.
582 582 *
583 583 * @param out the output stream
584 584 * @param a the attribute set
585 585 * @exception IOException on any I/O error
586 586 */
587 587 public static void writeAttributeSet(ObjectOutputStream out,
588 588 AttributeSet a) throws IOException {
589 589 int n = a.getAttributeCount();
590 590 out.writeInt(n);
591 591 Enumeration keys = a.getAttributeNames();
592 592 while (keys.hasMoreElements()) {
593 593 Object key = keys.nextElement();
594 594 if (key instanceof Serializable) {
595 595 out.writeObject(key);
596 596 } else {
597 597 Object ioFmt = freezeKeyMap.get(key);
598 598 if (ioFmt == null) {
599 599 throw new NotSerializableException(key.getClass().
600 600 getName() + " is not serializable as a key in an AttributeSet");
601 601 }
602 602 out.writeObject(ioFmt);
603 603 }
604 604 Object value = a.getAttribute(key);
605 605 Object ioFmt = freezeKeyMap.get(value);
606 606 if (value instanceof Serializable) {
607 607 out.writeObject((ioFmt != null) ? ioFmt : value);
608 608 } else {
609 609 if (ioFmt == null) {
610 610 throw new NotSerializableException(value.getClass().
611 611 getName() + " is not serializable as a value in an AttributeSet");
612 612 }
613 613 out.writeObject(ioFmt);
614 614 }
615 615 }
616 616 }
617 617
618 618 /**
619 619 * Reads a set of attributes from the given object input
620 620 * stream that have been previously written out with
621 621 * <code>writeAttributeSet</code>. This will try to restore
622 622 * keys that were static objects to the static objects in
623 623 * the current virtual machine considering only those keys
624 624 * that have been registered with the
625 625 * <code>registerStaticAttributeKey</code> method.
626 626 * The attributes retrieved from the stream will be placed
627 627 * into the given mutable set.
628 628 *
629 629 * @param in the object stream to read the attribute data from.
630 630 * @param a the attribute set to place the attribute
631 631 * definitions in.
632 632 * @exception ClassNotFoundException passed upward if encountered
633 633 * when reading the object stream.
634 634 * @exception IOException passed upward if encountered when
635 635 * reading the object stream.
636 636 */
637 637 public static void readAttributeSet(ObjectInputStream in,
638 638 MutableAttributeSet a) throws ClassNotFoundException, IOException {
639 639
640 640 int n = in.readInt();
641 641 for (int i = 0; i < n; i++) {
642 642 Object key = in.readObject();
643 643 Object value = in.readObject();
644 644 if (thawKeyMap != null) {
645 645 Object staticKey = thawKeyMap.get(key);
646 646 if (staticKey != null) {
647 647 key = staticKey;
648 648 }
649 649 Object staticValue = thawKeyMap.get(value);
650 650 if (staticValue != null) {
651 651 value = staticValue;
652 652 }
653 653 }
654 654 a.addAttribute(key, value);
655 655 }
656 656 }
657 657
658 658 /**
659 659 * Registers an object as a static object that is being
660 660 * used as a key in attribute sets. This allows the key
661 661 * to be treated specially for serialization.
662 662 * <p>
663 663 * For operation under a 1.1 virtual machine, this
664 664 * uses the value returned by <code>toString</code>
665 665 * concatenated to the classname. The value returned
666 666 * by toString should not have the class reference
667 667 * in it (ie it should be reimplemented from the
668 668 * definition in Object) in order to be the same when
669 669 * recomputed later.
670 670 *
671 671 * @param key the non-null object key
672 672 */
673 673 public static void registerStaticAttributeKey(Object key) {
674 674 String ioFmt = key.getClass().getName() + "." + key.toString();
675 675 if (freezeKeyMap == null) {
676 676 freezeKeyMap = new Hashtable<Object, String>();
677 677 thawKeyMap = new Hashtable<String, Object>();
678 678 }
679 679 freezeKeyMap.put(key, ioFmt);
680 680 thawKeyMap.put(ioFmt, key);
681 681 }
682 682
683 683 /**
684 684 * Returns the object previously registered with
685 685 * <code>registerStaticAttributeKey</code>.
686 686 */
687 687 public static Object getStaticAttribute(Object key) {
688 688 if (thawKeyMap == null || key == null) {
689 689 return null;
690 690 }
691 691 return thawKeyMap.get(key);
692 692 }
693 693
694 694 /**
695 695 * Returns the String that <code>key</code> will be registered with
696 696 * @see #getStaticAttribute
697 697 * @see #registerStaticAttributeKey
698 698 */
699 699 public static Object getStaticAttributeKey(Object key) {
700 700 return key.getClass().getName() + "." + key.toString();
701 701 }
702 702
703 703 private void writeObject(java.io.ObjectOutputStream s)
704 704 throws IOException
705 705 {
706 706 // clean out unused sets before saving
707 707 removeUnusedSets();
708 708
709 709 s.defaultWriteObject();
710 710 }
711 711
712 712 private void readObject(ObjectInputStream s)
713 713 throws ClassNotFoundException, IOException
714 714 {
715 715 fontSearch = new FontKey(null, 0, 0);
716 716 fontTable = new Hashtable<FontKey, Font>();
717 717 search = new SimpleAttributeSet();
718 718 attributesPool = Collections.
719 719 synchronizedMap(new WeakHashMap<SmallAttributeSet, WeakReference<SmallAttributeSet>>());
720 720 s.defaultReadObject();
721 721 }
722 722
723 723 // --- variables ---------------------------------------------------
724 724
725 725 /**
726 726 * The name given to the default logical style attached
727 727 * to paragraphs.
728 728 */
729 729 public static final String DEFAULT_STYLE = "default";
730 730
731 731 private static Hashtable<Object, String> freezeKeyMap;
732 732 private static Hashtable<String, Object> thawKeyMap;
733 733
734 734 private Style styles;
735 735 private transient FontKey fontSearch = new FontKey(null, 0, 0);
736 736 private transient Hashtable<FontKey, Font> fontTable = new Hashtable<FontKey, Font>();
737 737
738 738 private transient Map<SmallAttributeSet, WeakReference<SmallAttributeSet>> attributesPool = Collections.
739 739 synchronizedMap(new WeakHashMap<SmallAttributeSet, WeakReference<SmallAttributeSet>>());
740 740 private transient MutableAttributeSet search = new SimpleAttributeSet();
741 741
742 742 /**
743 743 * Number of immutable sets that are not currently
744 744 * being used. This helps indicate when the sets need
745 745 * to be cleaned out of the hashtable they are stored
746 746 * in.
747 747 */
748 748 private int unusedSets;
749 749
750 750 /**
751 751 * The threshold for no longer sharing the set of attributes
752 752 * in an immutable table.
753 753 */
754 754 static final int THRESHOLD = 9;
755 755
756 756 /**
757 757 * This class holds a small number of attributes in an array.
758 758 * The storage format is key, value, key, value, etc. The size
759 759 * of the set is the length of the array divided by two. By
760 760 * default, this is the class that will be used to store attributes
761 761 * when held in the compact sharable form.
762 762 */
763 763 public class SmallAttributeSet implements AttributeSet {
764 764
765 765 public SmallAttributeSet(Object[] attributes) {
766 766 this.attributes = attributes;
767 767 updateResolveParent();
768 768 }
769 769
770 770 public SmallAttributeSet(AttributeSet attrs) {
771 771 int n = attrs.getAttributeCount();
772 772 Object[] tbl = new Object[2 * n];
773 773 Enumeration names = attrs.getAttributeNames();
774 774 int i = 0;
775 775 while (names.hasMoreElements()) {
776 776 tbl[i] = names.nextElement();
777 777 tbl[i+1] = attrs.getAttribute(tbl[i]);
778 778 i += 2;
779 779 }
780 780 attributes = tbl;
781 781 updateResolveParent();
782 782 }
783 783
784 784 private void updateResolveParent() {
785 785 resolveParent = null;
786 786 Object[] tbl = attributes;
787 787 for (int i = 0; i < tbl.length; i += 2) {
788 788 if (tbl[i] == StyleConstants.ResolveAttribute) {
789 789 resolveParent = (AttributeSet)tbl[i + 1];
790 790 break;
791 791 }
792 792 }
793 793 }
794 794
795 795 Object getLocalAttribute(Object nm) {
796 796 if (nm == StyleConstants.ResolveAttribute) {
797 797 return resolveParent;
798 798 }
799 799 Object[] tbl = attributes;
800 800 for (int i = 0; i < tbl.length; i += 2) {
801 801 if (nm.equals(tbl[i])) {
802 802 return tbl[i+1];
803 803 }
804 804 }
805 805 return null;
806 806 }
807 807
808 808 // --- Object methods -------------------------
809 809
810 810 /**
811 811 * Returns a string showing the key/value pairs
812 812 */
813 813 public String toString() {
814 814 String s = "{";
815 815 Object[] tbl = attributes;
816 816 for (int i = 0; i < tbl.length; i += 2) {
817 817 if (tbl[i+1] instanceof AttributeSet) {
818 818 // don't recurse
819 819 s = s + tbl[i] + "=" + "AttributeSet" + ",";
820 820 } else {
821 821 s = s + tbl[i] + "=" + tbl[i+1] + ",";
822 822 }
823 823 }
824 824 s = s + "}";
825 825 return s;
826 826 }
827 827
828 828 /**
829 829 * Returns a hashcode for this set of attributes.
830 830 * @return a hashcode value for this set of attributes.
831 831 */
832 832 public int hashCode() {
833 833 int code = 0;
834 834 Object[] tbl = attributes;
835 835 for (int i = 1; i < tbl.length; i += 2) {
836 836 code ^= tbl[i].hashCode();
837 837 }
838 838 return code;
839 839 }
840 840
841 841 /**
842 842 * Compares this object to the specified object.
843 843 * The result is <code>true</code> if the object is an equivalent
844 844 * set of attributes.
845 845 * @param obj the object to compare with.
846 846 * @return <code>true</code> if the objects are equal;
847 847 * <code>false</code> otherwise.
848 848 */
849 849 public boolean equals(Object obj) {
850 850 if (obj instanceof AttributeSet) {
851 851 AttributeSet attrs = (AttributeSet) obj;
852 852 return ((getAttributeCount() == attrs.getAttributeCount()) &&
853 853 containsAttributes(attrs));
854 854 }
855 855 return false;
856 856 }
857 857
858 858 /**
859 859 * Clones a set of attributes. Since the set is immutable, a
860 860 * clone is basically the same set.
861 861 *
862 862 * @return the set of attributes
863 863 */
864 864 public Object clone() {
865 865 return this;
866 866 }
867 867
868 868 // --- AttributeSet methods ----------------------------
869 869
870 870 /**
871 871 * Gets the number of attributes that are defined.
872 872 *
873 873 * @return the number of attributes
874 874 * @see AttributeSet#getAttributeCount
875 875 */
876 876 public int getAttributeCount() {
877 877 return attributes.length / 2;
878 878 }
879 879
880 880 /**
881 881 * Checks whether a given attribute is defined.
882 882 *
883 883 * @param key the attribute key
884 884 * @return true if the attribute is defined
885 885 * @see AttributeSet#isDefined
886 886 */
887 887 public boolean isDefined(Object key) {
888 888 Object[] a = attributes;
889 889 int n = a.length;
890 890 for (int i = 0; i < n; i += 2) {
891 891 if (key.equals(a[i])) {
892 892 return true;
893 893 }
894 894 }
895 895 return false;
896 896 }
897 897
898 898 /**
899 899 * Checks whether two attribute sets are equal.
900 900 *
901 901 * @param attr the attribute set to check against
902 902 * @return true if the same
903 903 * @see AttributeSet#isEqual
904 904 */
905 905 public boolean isEqual(AttributeSet attr) {
906 906 if (attr instanceof SmallAttributeSet) {
907 907 return attr == this;
908 908 }
909 909 return ((getAttributeCount() == attr.getAttributeCount()) &&
910 910 containsAttributes(attr));
911 911 }
912 912
913 913 /**
914 914 * Copies a set of attributes.
915 915 *
916 916 * @return the copy
917 917 * @see AttributeSet#copyAttributes
918 918 */
919 919 public AttributeSet copyAttributes() {
920 920 return this;
921 921 }
922 922
923 923 /**
924 924 * Gets the value of an attribute.
925 925 *
926 926 * @param key the attribute name
927 927 * @return the attribute value
928 928 * @see AttributeSet#getAttribute
929 929 */
930 930 public Object getAttribute(Object key) {
931 931 Object value = getLocalAttribute(key);
932 932 if (value == null) {
933 933 AttributeSet parent = getResolveParent();
934 934 if (parent != null)
935 935 value = parent.getAttribute(key);
936 936 }
937 937 return value;
938 938 }
939 939
940 940 /**
941 941 * Gets the names of all attributes.
942 942 *
943 943 * @return the attribute names
944 944 * @see AttributeSet#getAttributeNames
945 945 */
946 946 public Enumeration<?> getAttributeNames() {
947 947 return new KeyEnumeration(attributes);
948 948 }
949 949
950 950 /**
951 951 * Checks whether a given attribute name/value is defined.
952 952 *
953 953 * @param name the attribute name
954 954 * @param value the attribute value
955 955 * @return true if the name/value is defined
956 956 * @see AttributeSet#containsAttribute
957 957 */
958 958 public boolean containsAttribute(Object name, Object value) {
959 959 return value.equals(getAttribute(name));
960 960 }
961 961
962 962 /**
963 963 * Checks whether the attribute set contains all of
964 964 * the given attributes.
965 965 *
966 966 * @param attrs the attributes to check
967 967 * @return true if the element contains all the attributes
968 968 * @see AttributeSet#containsAttributes
969 969 */
970 970 public boolean containsAttributes(AttributeSet attrs) {
971 971 boolean result = true;
972 972
973 973 Enumeration names = attrs.getAttributeNames();
974 974 while (result && names.hasMoreElements()) {
975 975 Object name = names.nextElement();
976 976 result = attrs.getAttribute(name).equals(getAttribute(name));
977 977 }
978 978
979 979 return result;
980 980 }
981 981
982 982 /**
983 983 * If not overriden, the resolving parent defaults to
984 984 * the parent element.
985 985 *
986 986 * @return the attributes from the parent
987 987 * @see AttributeSet#getResolveParent
988 988 */
989 989 public AttributeSet getResolveParent() {
990 990 return resolveParent;
991 991 }
992 992
993 993 // --- variables -----------------------------------------
994 994
995 995 Object[] attributes;
996 996 // This is also stored in attributes
997 997 AttributeSet resolveParent;
998 998 }
999 999
1000 1000 /**
1001 1001 * An enumeration of the keys in a SmallAttributeSet.
1002 1002 */
1003 1003 class KeyEnumeration implements Enumeration<Object> {
1004 1004
1005 1005 KeyEnumeration(Object[] attr) {
1006 1006 this.attr = attr;
1007 1007 i = 0;
1008 1008 }
1009 1009
1010 1010 /**
1011 1011 * Tests if this enumeration contains more elements.
1012 1012 *
1013 1013 * @return <code>true</code> if this enumeration contains more elements;
1014 1014 * <code>false</code> otherwise.
1015 1015 * @since JDK1.0
1016 1016 */
1017 1017 public boolean hasMoreElements() {
1018 1018 return i < attr.length;
1019 1019 }
1020 1020
1021 1021 /**
1022 1022 * Returns the next element of this enumeration.
1023 1023 *
1024 1024 * @return the next element of this enumeration.
1025 1025 * @exception NoSuchElementException if no more elements exist.
1026 1026 * @since JDK1.0
1027 1027 */
1028 1028 public Object nextElement() {
1029 1029 if (i < attr.length) {
1030 1030 Object o = attr[i];
1031 1031 i += 2;
1032 1032 return o;
1033 1033 }
1034 1034 throw new NoSuchElementException();
1035 1035 }
1036 1036
1037 1037 Object[] attr;
1038 1038 int i;
1039 1039 }
1040 1040
1041 1041 /**
1042 1042 * Sorts the key strings so that they can be very quickly compared
1043 1043 * in the attribute set searches.
1044 1044 */
1045 1045 class KeyBuilder {
1046 1046
1047 1047 public void initialize(AttributeSet a) {
1048 1048 if (a instanceof SmallAttributeSet) {
1049 1049 initialize(((SmallAttributeSet)a).attributes);
1050 1050 } else {
1051 1051 keys.removeAllElements();
1052 1052 data.removeAllElements();
1053 1053 Enumeration names = a.getAttributeNames();
1054 1054 while (names.hasMoreElements()) {
1055 1055 Object name = names.nextElement();
1056 1056 addAttribute(name, a.getAttribute(name));
1057 1057 }
1058 1058 }
1059 1059 }
1060 1060
1061 1061 /**
1062 1062 * Initialize with a set of already sorted
1063 1063 * keys (data from an existing SmallAttributeSet).
1064 1064 */
1065 1065 private void initialize(Object[] sorted) {
1066 1066 keys.removeAllElements();
1067 1067 data.removeAllElements();
1068 1068 int n = sorted.length;
1069 1069 for (int i = 0; i < n; i += 2) {
1070 1070 keys.addElement(sorted[i]);
1071 1071 data.addElement(sorted[i+1]);
1072 1072 }
1073 1073 }
1074 1074
1075 1075 /**
1076 1076 * Creates a table of sorted key/value entries
1077 1077 * suitable for creation of an instance of
1078 1078 * SmallAttributeSet.
1079 1079 */
1080 1080 public Object[] createTable() {
1081 1081 int n = keys.size();
1082 1082 Object[] tbl = new Object[2 * n];
1083 1083 for (int i = 0; i < n; i ++) {
1084 1084 int offs = 2 * i;
1085 1085 tbl[offs] = keys.elementAt(i);
1086 1086 tbl[offs + 1] = data.elementAt(i);
1087 1087 }
1088 1088 return tbl;
1089 1089 }
1090 1090
1091 1091 /**
1092 1092 * The number of key/value pairs contained
1093 1093 * in the current key being forged.
1094 1094 */
1095 1095 int getCount() {
1096 1096 return keys.size();
1097 1097 }
1098 1098
1099 1099 /**
1100 1100 * Adds a key/value to the set.
1101 1101 */
1102 1102 public void addAttribute(Object key, Object value) {
1103 1103 keys.addElement(key);
1104 1104 data.addElement(value);
1105 1105 }
1106 1106
1107 1107 /**
1108 1108 * Adds a set of key/value pairs to the set.
1109 1109 */
1110 1110 public void addAttributes(AttributeSet attr) {
1111 1111 if (attr instanceof SmallAttributeSet) {
1112 1112 // avoid searching the keys, they are already interned.
1113 1113 Object[] tbl = ((SmallAttributeSet)attr).attributes;
1114 1114 int n = tbl.length;
1115 1115 for (int i = 0; i < n; i += 2) {
1116 1116 addAttribute(tbl[i], tbl[i+1]);
1117 1117 }
1118 1118 } else {
1119 1119 Enumeration names = attr.getAttributeNames();
1120 1120 while (names.hasMoreElements()) {
1121 1121 Object name = names.nextElement();
1122 1122 addAttribute(name, attr.getAttribute(name));
1123 1123 }
1124 1124 }
1125 1125 }
1126 1126
1127 1127 /**
1128 1128 * Removes the given name from the set.
1129 1129 */
1130 1130 public void removeAttribute(Object key) {
1131 1131 int n = keys.size();
1132 1132 for (int i = 0; i < n; i++) {
1133 1133 if (keys.elementAt(i).equals(key)) {
1134 1134 keys.removeElementAt(i);
1135 1135 data.removeElementAt(i);
1136 1136 return;
1137 1137 }
1138 1138 }
1139 1139 }
1140 1140
1141 1141 /**
1142 1142 * Removes the set of keys from the set.
1143 1143 */
1144 1144 public void removeAttributes(Enumeration names) {
1145 1145 while (names.hasMoreElements()) {
1146 1146 Object name = names.nextElement();
1147 1147 removeAttribute(name);
1148 1148 }
1149 1149 }
1150 1150
1151 1151 /**
1152 1152 * Removes the set of matching attributes from the set.
1153 1153 */
1154 1154 public void removeAttributes(AttributeSet attr) {
1155 1155 Enumeration names = attr.getAttributeNames();
1156 1156 while (names.hasMoreElements()) {
1157 1157 Object name = names.nextElement();
1158 1158 Object value = attr.getAttribute(name);
1159 1159 removeSearchAttribute(name, value);
1160 1160 }
1161 1161 }
1162 1162
1163 1163 private void removeSearchAttribute(Object ikey, Object value) {
1164 1164 int n = keys.size();
1165 1165 for (int i = 0; i < n; i++) {
1166 1166 if (keys.elementAt(i).equals(ikey)) {
1167 1167 if (data.elementAt(i).equals(value)) {
1168 1168 keys.removeElementAt(i);
1169 1169 data.removeElementAt(i);
1170 1170 }
1171 1171 return;
1172 1172 }
1173 1173 }
1174 1174 }
1175 1175
1176 1176 private Vector<Object> keys = new Vector<Object>();
1177 1177 private Vector<Object> data = new Vector<Object>();
1178 1178 }
1179 1179
1180 1180 /**
1181 1181 * key for a font table
1182 1182 */
1183 1183 static class FontKey {
1184 1184
1185 1185 private String family;
1186 1186 private int style;
1187 1187 private int size;
1188 1188
1189 1189 /**
1190 1190 * Constructs a font key.
1191 1191 */
1192 1192 public FontKey(String family, int style, int size) {
1193 1193 setValue(family, style, size);
1194 1194 }
1195 1195
1196 1196 public void setValue(String family, int style, int size) {
1197 1197 this.family = (family != null) ? family.intern() : null;
1198 1198 this.style = style;
1199 1199 this.size = size;
1200 1200 }
1201 1201
1202 1202 /**
1203 1203 * Returns a hashcode for this font.
1204 1204 * @return a hashcode value for this font.
1205 1205 */
1206 1206 public int hashCode() {
1207 1207 int fhash = (family != null) ? family.hashCode() : 0;
1208 1208 return fhash ^ style ^ size;
1209 1209 }
1210 1210
1211 1211 /**
1212 1212 * Compares this object to the specified object.
1213 1213 * The result is <code>true</code> if and only if the argument is not
1214 1214 * <code>null</code> and is a <code>Font</code> object with the same
1215 1215 * name, style, and point size as this font.
1216 1216 * @param obj the object to compare this font with.
1217 1217 * @return <code>true</code> if the objects are equal;
1218 1218 * <code>false</code> otherwise.
1219 1219 */
1220 1220 public boolean equals(Object obj) {
1221 1221 if (obj instanceof FontKey) {
1222 1222 FontKey font = (FontKey)obj;
1223 1223 return (size == font.size) && (style == font.style) && (family == font.family);
1224 1224 }
1225 1225 return false;
1226 1226 }
1227 1227
1228 1228 }
1229 1229
1230 1230 /**
1231 1231 * A collection of attributes, typically used to represent
1232 1232 * character and paragraph styles. This is an implementation
1233 1233 * of MutableAttributeSet that can be observed if desired.
1234 1234 * These styles will take advantage of immutability while
1235 1235 * the sets are small enough, and may be substantially more
1236 1236 * efficient than something like SimpleAttributeSet.
1237 1237 * <p>
1238 1238 * <strong>Warning:</strong>
1239 1239 * Serialized objects of this class will not be compatible with
1240 1240 * future Swing releases. The current serialization support is
1241 1241 * appropriate for short term storage or RMI between applications running
1242 1242 * the same version of Swing. As of 1.4, support for long term storage
1243 1243 * of all JavaBeans™
1244 1244 * has been added to the <code>java.beans</code> package.
1245 1245 * Please see {@link java.beans.XMLEncoder}.
1246 1246 */
1247 1247 public class NamedStyle implements Style, Serializable {
1248 1248
1249 1249 /**
1250 1250 * Creates a new named style.
1251 1251 *
1252 1252 * @param name the style name, null for unnamed
1253 1253 * @param parent the parent style, null if none
1254 1254 * @since 1.4
1255 1255 */
1256 1256 public NamedStyle(String name, Style parent) {
1257 1257 attributes = getEmptySet();
1258 1258 if (name != null) {
1259 1259 setName(name);
1260 1260 }
1261 1261 if (parent != null) {
1262 1262 setResolveParent(parent);
1263 1263 }
1264 1264 }
1265 1265
1266 1266 /**
1267 1267 * Creates a new named style.
1268 1268 *
1269 1269 * @param parent the parent style, null if none
1270 1270 * @since 1.4
1271 1271 */
1272 1272 public NamedStyle(Style parent) {
1273 1273 this(null, parent);
1274 1274 }
1275 1275
1276 1276 /**
1277 1277 * Creates a new named style, with a null name and parent.
1278 1278 */
1279 1279 public NamedStyle() {
1280 1280 attributes = getEmptySet();
1281 1281 }
1282 1282
1283 1283 /**
1284 1284 * Converts the style to a string.
1285 1285 *
1286 1286 * @return the string
1287 1287 */
1288 1288 public String toString() {
1289 1289 return "NamedStyle:" + getName() + " " + attributes;
1290 1290 }
1291 1291
1292 1292 /**
1293 1293 * Fetches the name of the style. A style is not required to be named,
1294 1294 * so null is returned if there is no name associated with the style.
1295 1295 *
1296 1296 * @return the name
1297 1297 */
1298 1298 public String getName() {
1299 1299 if (isDefined(StyleConstants.NameAttribute)) {
1300 1300 return getAttribute(StyleConstants.NameAttribute).toString();
1301 1301 }
1302 1302 return null;
1303 1303 }
1304 1304
1305 1305 /**
1306 1306 * Changes the name of the style. Does nothing with a null name.
1307 1307 *
1308 1308 * @param name the new name
1309 1309 */
1310 1310 public void setName(String name) {
1311 1311 if (name != null) {
1312 1312 this.addAttribute(StyleConstants.NameAttribute, name);
1313 1313 }
1314 1314 }
1315 1315
1316 1316 /**
1317 1317 * Adds a change listener.
1318 1318 *
1319 1319 * @param l the change listener
1320 1320 */
1321 1321 public void addChangeListener(ChangeListener l) {
1322 1322 listenerList.add(ChangeListener.class, l);
1323 1323 }
1324 1324
1325 1325 /**
1326 1326 * Removes a change listener.
1327 1327 *
1328 1328 * @param l the change listener
1329 1329 */
1330 1330 public void removeChangeListener(ChangeListener l) {
1331 1331 listenerList.remove(ChangeListener.class, l);
1332 1332 }
1333 1333
1334 1334
1335 1335 /**
1336 1336 * Returns an array of all the <code>ChangeListener</code>s added
1337 1337 * to this NamedStyle with addChangeListener().
1338 1338 *
1339 1339 * @return all of the <code>ChangeListener</code>s added or an empty
1340 1340 * array if no listeners have been added
1341 1341 * @since 1.4
1342 1342 */
1343 1343 public ChangeListener[] getChangeListeners() {
1344 1344 return listenerList.getListeners(ChangeListener.class);
1345 1345 }
1346 1346
1347 1347
1348 1348 /**
1349 1349 * Notifies all listeners that have registered interest for
1350 1350 * notification on this event type. The event instance
1351 1351 * is lazily created using the parameters passed into
1352 1352 * the fire method.
1353 1353 *
1354 1354 * @see EventListenerList
1355 1355 */
1356 1356 protected void fireStateChanged() {
1357 1357 // Guaranteed to return a non-null array
1358 1358 Object[] listeners = listenerList.getListenerList();
1359 1359 // Process the listeners last to first, notifying
1360 1360 // those that are interested in this event
1361 1361 for (int i = listeners.length-2; i>=0; i-=2) {
1362 1362 if (listeners[i]==ChangeListener.class) {
1363 1363 // Lazily create the event:
1364 1364 if (changeEvent == null)
1365 1365 changeEvent = new ChangeEvent(this);
1366 1366 ((ChangeListener)listeners[i+1]).stateChanged(changeEvent);
1367 1367 }
1368 1368 }
1369 1369 }
1370 1370
1371 1371 /**
1372 1372 * Return an array of all the listeners of the given type that
1373 1373 * were added to this model.
1374 1374 *
1375 1375 * @return all of the objects receiving <em>listenerType</em> notifications
1376 1376 * from this model
1377 1377 *
1378 1378 * @since 1.3
1379 1379 */
1380 1380 public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
1381 1381 return listenerList.getListeners(listenerType);
1382 1382 }
1383 1383
1384 1384 // --- AttributeSet ----------------------------
1385 1385 // delegated to the immutable field "attributes"
1386 1386
1387 1387 /**
1388 1388 * Gets the number of attributes that are defined.
1389 1389 *
1390 1390 * @return the number of attributes >= 0
1391 1391 * @see AttributeSet#getAttributeCount
1392 1392 */
1393 1393 public int getAttributeCount() {
1394 1394 return attributes.getAttributeCount();
1395 1395 }
1396 1396
1397 1397 /**
1398 1398 * Checks whether a given attribute is defined.
1399 1399 *
1400 1400 * @param attrName the non-null attribute name
1401 1401 * @return true if the attribute is defined
1402 1402 * @see AttributeSet#isDefined
1403 1403 */
1404 1404 public boolean isDefined(Object attrName) {
1405 1405 return attributes.isDefined(attrName);
1406 1406 }
1407 1407
1408 1408 /**
1409 1409 * Checks whether two attribute sets are equal.
1410 1410 *
1411 1411 * @param attr the attribute set to check against
1412 1412 * @return true if the same
1413 1413 * @see AttributeSet#isEqual
1414 1414 */
1415 1415 public boolean isEqual(AttributeSet attr) {
1416 1416 return attributes.isEqual(attr);
1417 1417 }
1418 1418
1419 1419 /**
1420 1420 * Copies a set of attributes.
1421 1421 *
1422 1422 * @return the copy
1423 1423 * @see AttributeSet#copyAttributes
1424 1424 */
1425 1425 public AttributeSet copyAttributes() {
1426 1426 NamedStyle a = new NamedStyle();
1427 1427 a.attributes = attributes.copyAttributes();
1428 1428 return a;
1429 1429 }
1430 1430
1431 1431 /**
1432 1432 * Gets the value of an attribute.
1433 1433 *
1434 1434 * @param attrName the non-null attribute name
1435 1435 * @return the attribute value
1436 1436 * @see AttributeSet#getAttribute
1437 1437 */
1438 1438 public Object getAttribute(Object attrName) {
1439 1439 return attributes.getAttribute(attrName);
1440 1440 }
1441 1441
1442 1442 /**
1443 1443 * Gets the names of all attributes.
1444 1444 *
1445 1445 * @return the attribute names as an enumeration
1446 1446 * @see AttributeSet#getAttributeNames
1447 1447 */
1448 1448 public Enumeration<?> getAttributeNames() {
1449 1449 return attributes.getAttributeNames();
1450 1450 }
1451 1451
1452 1452 /**
1453 1453 * Checks whether a given attribute name/value is defined.
1454 1454 *
1455 1455 * @param name the non-null attribute name
1456 1456 * @param value the attribute value
1457 1457 * @return true if the name/value is defined
1458 1458 * @see AttributeSet#containsAttribute
1459 1459 */
1460 1460 public boolean containsAttribute(Object name, Object value) {
1461 1461 return attributes.containsAttribute(name, value);
1462 1462 }
1463 1463
1464 1464
1465 1465 /**
1466 1466 * Checks whether the element contains all the attributes.
1467 1467 *
1468 1468 * @param attrs the attributes to check
1469 1469 * @return true if the element contains all the attributes
1470 1470 * @see AttributeSet#containsAttributes
1471 1471 */
1472 1472 public boolean containsAttributes(AttributeSet attrs) {
1473 1473 return attributes.containsAttributes(attrs);
1474 1474 }
1475 1475
1476 1476 /**
1477 1477 * Gets attributes from the parent.
1478 1478 * If not overriden, the resolving parent defaults to
1479 1479 * the parent element.
1480 1480 *
1481 1481 * @return the attributes from the parent
1482 1482 * @see AttributeSet#getResolveParent
1483 1483 */
1484 1484 public AttributeSet getResolveParent() {
1485 1485 return attributes.getResolveParent();
1486 1486 }
1487 1487
1488 1488 // --- MutableAttributeSet ----------------------------------
1489 1489 // should fetch a new immutable record for the field
1490 1490 // "attributes".
1491 1491
1492 1492 /**
1493 1493 * Adds an attribute.
1494 1494 *
1495 1495 * @param name the non-null attribute name
1496 1496 * @param value the attribute value
1497 1497 * @see MutableAttributeSet#addAttribute
1498 1498 */
1499 1499 public void addAttribute(Object name, Object value) {
1500 1500 StyleContext context = StyleContext.this;
1501 1501 attributes = context.addAttribute(attributes, name, value);
1502 1502 fireStateChanged();
1503 1503 }
1504 1504
1505 1505 /**
1506 1506 * Adds a set of attributes to the element.
1507 1507 *
1508 1508 * @param attr the attributes to add
1509 1509 * @see MutableAttributeSet#addAttribute
1510 1510 */
1511 1511 public void addAttributes(AttributeSet attr) {
1512 1512 StyleContext context = StyleContext.this;
1513 1513 attributes = context.addAttributes(attributes, attr);
1514 1514 fireStateChanged();
1515 1515 }
1516 1516
1517 1517 /**
1518 1518 * Removes an attribute from the set.
1519 1519 *
1520 1520 * @param name the non-null attribute name
1521 1521 * @see MutableAttributeSet#removeAttribute
1522 1522 */
1523 1523 public void removeAttribute(Object name) {
1524 1524 StyleContext context = StyleContext.this;
1525 1525 attributes = context.removeAttribute(attributes, name);
1526 1526 fireStateChanged();
1527 1527 }
1528 1528
1529 1529 /**
1530 1530 * Removes a set of attributes for the element.
1531 1531 *
1532 1532 * @param names the attribute names
1533 1533 * @see MutableAttributeSet#removeAttributes
1534 1534 */
1535 1535 public void removeAttributes(Enumeration<?> names) {
1536 1536 StyleContext context = StyleContext.this;
1537 1537 attributes = context.removeAttributes(attributes, names);
1538 1538 fireStateChanged();
1539 1539 }
1540 1540
1541 1541 /**
1542 1542 * Removes a set of attributes for the element.
1543 1543 *
1544 1544 * @param attrs the attributes
1545 1545 * @see MutableAttributeSet#removeAttributes
1546 1546 */
1547 1547 public void removeAttributes(AttributeSet attrs) {
1548 1548 StyleContext context = StyleContext.this;
1549 1549 if (attrs == this) {
1550 1550 attributes = context.getEmptySet();
1551 1551 } else {
1552 1552 attributes = context.removeAttributes(attributes, attrs);
1553 1553 }
1554 1554 fireStateChanged();
1555 1555 }
1556 1556
1557 1557 /**
1558 1558 * Sets the resolving parent.
1559 1559 *
1560 1560 * @param parent the parent, null if none
1561 1561 * @see MutableAttributeSet#setResolveParent
1562 1562 */
1563 1563 public void setResolveParent(AttributeSet parent) {
1564 1564 if (parent != null) {
1565 1565 addAttribute(StyleConstants.ResolveAttribute, parent);
1566 1566 } else {
1567 1567 removeAttribute(StyleConstants.ResolveAttribute);
1568 1568 }
1569 1569 }
1570 1570
1571 1571 // --- serialization ---------------------------------------------
1572 1572
1573 1573 private void writeObject(ObjectOutputStream s) throws IOException {
1574 1574 s.defaultWriteObject();
1575 1575 writeAttributeSet(s, attributes);
1576 1576 }
1577 1577
1578 1578 private void readObject(ObjectInputStream s)
1579 1579 throws ClassNotFoundException, IOException
1580 1580 {
1581 1581 s.defaultReadObject();
1582 1582 attributes = SimpleAttributeSet.EMPTY;
1583 1583 readAttributeSet(s, this);
1584 1584 }
1585 1585
1586 1586 // --- member variables -----------------------------------------------
1587 1587
1588 1588 /**
1589 1589 * The change listeners for the model.
1590 1590 */
1591 1591 protected EventListenerList listenerList = new EventListenerList();
1592 1592
1593 1593 /**
1594 1594 * Only one ChangeEvent is needed per model instance since the
1595 1595 * event's only (read-only) state is the source property. The source
1596 1596 * of events generated here is always "this".
1597 1597 */
1598 1598 protected transient ChangeEvent changeEvent = null;
1599 1599
1600 1600 /**
1601 1601 * Inner AttributeSet implementation, which may be an
1602 1602 * immutable unique set being shared.
1603 1603 */
1604 1604 private transient AttributeSet attributes;
1605 1605
1606 1606 }
1607 1607
1608 1608 static {
1609 1609 // initialize the static key registry with the StyleConstants keys
1610 1610 try {
1611 1611 int n = StyleConstants.keys.length;
1612 1612 for (int i = 0; i < n; i++) {
1613 1613 StyleContext.registerStaticAttributeKey(StyleConstants.keys[i]);
1614 1614 }
1615 1615 } catch (Throwable e) {
1616 1616 e.printStackTrace();
1617 1617 }
1618 1618 }
1619 1619
1620 1620
1621 1621 }
|
↓ open down ↓ |
1163 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX