KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > javax > swing > text > StyleConstants


1 /*
2  * @(#)StyleConstants.java 1.36 03/12/19
3  *
4  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
5  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
6  */

7 package javax.swing.text;
8
9 import java.awt.Color JavaDoc;
10 import java.awt.Component JavaDoc;
11 import java.awt.Toolkit JavaDoc;
12 import javax.swing.Icon JavaDoc;
13
14 /**
15  * <p>
16  * A collection of <em>well known</em> or common attribute keys
17  * and methods to apply to an AttributeSet or MutableAttributeSet
18  * to get/set the properties in a typesafe manner.
19  * <p>
20  * The paragraph attributes form the definition of a paragraph to be rendered.
21  * All sizes are specified in points (such as found in postscript), a
22  * device independent measure.
23  * </p>
24  * <p align=center><img SRC="doc-files/paragraph.gif"
25  * alt="Diagram shows SpaceAbove, FirstLineIndent, LeftIndent, RightIndent,
26  * and SpaceBelow a paragraph."></p>
27  * <p>
28  *
29  * @author Timothy Prinzing
30  * @version 1.36 12/19/03
31  */

32 public class StyleConstants {
33
34     /**
35      * Name of elements used to represent components.
36      */

37     public static final String JavaDoc ComponentElementName = "component";
38     
39     /**
40      * Name of elements used to represent icons.
41      */

42     public static final String JavaDoc IconElementName = "icon";
43
44     /**
45      * Attribute name used to name the collection of
46      * attributes.
47      */

48     public static final Object JavaDoc NameAttribute = new StyleConstants JavaDoc("name");
49
50     /**
51      * Attribute name used to identifiy the resolving parent
52      * set of attributes, if one is defined.
53      */

54     public static final Object JavaDoc ResolveAttribute = new StyleConstants JavaDoc("resolver");
55
56     /**
57      * Attribute used to identify the model for embedded
58      * objects that have a model view separation.
59      */

60     public static final Object JavaDoc ModelAttribute = new StyleConstants JavaDoc("model");
61
62     /**
63      * Returns the string representation.
64      *
65      * @return the string
66      */

67     public String JavaDoc toString() {
68         return representation;
69     }
70
71     // ---- character constants -----------------------------------
72

73     /**
74      * Bidirectional level of a character as assigned by the Unicode bidi
75      * algorithm.
76      */

77     public static final Object JavaDoc BidiLevel = new CharacterConstants("bidiLevel");
78
79     /**
80      * Name of the font family.
81      */

82     public static final Object JavaDoc FontFamily = new FontConstants("family");
83  
84     /**
85      * Name of the font family.
86      *
87      * @since 1.5
88      */

89     public static final Object JavaDoc Family = FontFamily;
90
91     /**
92      * Name of the font size.
93      */

94     public static final Object JavaDoc FontSize = new FontConstants("size");
95
96     /**
97      * Name of the font size.
98      *
99      * @since 1.5
100      */

101     public static final Object JavaDoc Size = FontSize;
102
103     /**
104      * Name of the bold attribute.
105      */

106     public static final Object JavaDoc Bold = new FontConstants("bold");
107
108     /**
109      * Name of the italic attribute.
110      */

111     public static final Object JavaDoc Italic = new FontConstants("italic");
112
113     /**
114      * Name of the underline attribute.
115      */

116     public static final Object JavaDoc Underline = new CharacterConstants("underline");
117
118     /**
119      * Name of the Strikethrough attribute.
120      */

121     public static final Object JavaDoc StrikeThrough = new CharacterConstants("strikethrough");
122
123     /**
124      * Name of the Superscript attribute.
125      */

126     public static final Object JavaDoc Superscript = new CharacterConstants("superscript");
127
128     /**
129      * Name of the Subscript attribute.
130      */

131     public static final Object JavaDoc Subscript = new CharacterConstants("subscript");
132
133     /**
134      * Name of the foreground color attribute.
135      */

136     public static final Object JavaDoc Foreground = new ColorConstants("foreground");
137
138     /**
139      * Name of the background color attribute.
140      */

141     public static final Object JavaDoc Background = new ColorConstants("background");
142
143     /**
144      * Name of the component attribute.
145      */

146     public static final Object JavaDoc ComponentAttribute = new CharacterConstants("component");
147
148     /**
149      * Name of the icon attribute.
150      */

151     public static final Object JavaDoc IconAttribute = new CharacterConstants("icon");
152
153     /**
154      * Name of the input method composed text attribute. The value of
155      * this attribute is an instance of AttributedString which represents
156      * the composed text.
157      */

158     public static final Object JavaDoc ComposedTextAttribute = new StyleConstants JavaDoc("composed text");
159
160     /**
161      * The amount of space to indent the first
162      * line of the paragraph. This value may be negative
163      * to offset in the reverse direction. The type
164      * is Float and specifies the size of the space
165      * in points.
166      */

167     public static final Object JavaDoc FirstLineIndent = new ParagraphConstants("FirstLineIndent");
168
169     /**
170      * The amount to indent the left side
171      * of the paragraph.
172      * Type is float and specifies the size in points.
173      */

174     public static final Object JavaDoc LeftIndent = new ParagraphConstants("LeftIndent");
175
176     /**
177      * The amount to indent the right side
178      * of the paragraph.
179      * Type is float and specifies the size in points.
180      */

181     public static final Object JavaDoc RightIndent = new ParagraphConstants("RightIndent");
182
183     /**
184      * The amount of space between lines
185      * of the paragraph.
186      * Type is float and specifies the size as a factor of the line height
187      */

188     public static final Object JavaDoc LineSpacing = new ParagraphConstants("LineSpacing");
189
190     /**
191      * The amount of space above the paragraph.
192      * Type is float and specifies the size in points.
193      */

194     public static final Object JavaDoc SpaceAbove = new ParagraphConstants("SpaceAbove");
195
196     /**
197      * The amount of space below the paragraph.
198      * Type is float and specifies the size in points.
199      */

200     public static final Object JavaDoc SpaceBelow = new ParagraphConstants("SpaceBelow");
201
202     /**
203      * Alignment for the paragraph. The type is
204      * Integer. Valid values are:
205      * <ul>
206      * <li>ALIGN_LEFT
207      * <li>ALIGN_RIGHT
208      * <li>ALIGN_CENTER
209      * <li>ALIGN_JUSTIFED
210      * </ul>
211      *
212      */

213     public static final Object JavaDoc Alignment = new ParagraphConstants("Alignment");
214
215     /**
216      * TabSet for the paragraph, type is a TabSet containing
217      * TabStops.
218      */

219     public static final Object JavaDoc TabSet = new ParagraphConstants("TabSet");
220
221     /**
222      * Orientation for a paragraph.
223      */

224     public static final Object JavaDoc Orientation = new ParagraphConstants("Orientation");
225     /**
226      * A possible value for paragraph alignment. This
227      * specifies that the text is aligned to the left
228      * indent and extra whitespace should be placed on
229      * the right.
230      */

231     public static final int ALIGN_LEFT = 0;
232
233     /**
234      * A possible value for paragraph alignment. This
235      * specifies that the text is aligned to the center
236      * and extra whitespace should be placed equally on
237      * the left and right.
238      */

239     public static final int ALIGN_CENTER = 1;
240
241     /**
242      * A possible value for paragraph alignment. This
243      * specifies that the text is aligned to the right
244      * indent and extra whitespace should be placed on
245      * the left.
246      */

247     public static final int ALIGN_RIGHT = 2;
248
249     /**
250      * A possible value for paragraph alignment. This
251      * specifies that extra whitespace should be spread
252      * out through the rows of the paragraph with the
253      * text lined up with the left and right indent
254      * except on the last line which should be aligned
255      * to the left.
256      */

257     public static final int ALIGN_JUSTIFIED = 3;
258
259     // --- character attribute accessors ---------------------------
260

261     /**
262      * Gets the BidiLevel setting.
263      *
264      * @param a the attribute set
265      * @return the value
266      */

267     public static int getBidiLevel(AttributeSet JavaDoc a) {
268         Integer JavaDoc o = (Integer JavaDoc) a.getAttribute(BidiLevel);
269         if (o != null) {
270             return o.intValue();
271         }
272         return 0; // Level 0 is base level (non-embedded) left-to-right
273
}
274     
275     /**
276      * Sets the BidiLevel.
277      *
278      * @param a the attribute set
279      * @param o the bidi level value
280      */

281     public static void setBidiLevel(MutableAttributeSet JavaDoc a, int o) {
282         a.addAttribute(BidiLevel, new Integer JavaDoc(o));
283     }
284
285     /**
286      * Gets the component setting from the attribute list.
287      *
288      * @param a the attribute set
289      * @return the component, null if none
290      */

291     public static Component JavaDoc getComponent(AttributeSet JavaDoc a) {
292         return (Component JavaDoc) a.getAttribute(ComponentAttribute);
293     }
294
295     /**
296      * Sets the component attribute.
297      *
298      * @param a the attribute set
299      * @param c the component
300      */

301     public static void setComponent(MutableAttributeSet JavaDoc a, Component JavaDoc c) {
302         a.addAttribute(AbstractDocument.ElementNameAttribute, ComponentElementName);
303         a.addAttribute(ComponentAttribute, c);
304     }
305
306     /**
307      * Gets the icon setting from the attribute list.
308      *
309      * @param a the attribute set
310      * @return the icon, null if none
311      */

312     public static Icon JavaDoc getIcon(AttributeSet JavaDoc a) {
313         return (Icon JavaDoc) a.getAttribute(IconAttribute);
314     }
315
316     /**
317      * Sets the icon attribute.
318      *
319      * @param a the attribute set
320      * @param c the icon
321      */

322     public static void setIcon(MutableAttributeSet JavaDoc a, Icon JavaDoc c) {
323         a.addAttribute(AbstractDocument.ElementNameAttribute, IconElementName);
324         a.addAttribute(IconAttribute, c);
325     }
326
327     /**
328      * Gets the font family setting from the attribute list.
329      *
330      * @param a the attribute set
331      * @return the font family, "Monospaced" as the default
332      */

333     public static String JavaDoc getFontFamily(AttributeSet JavaDoc a) {
334         String JavaDoc family = (String JavaDoc) a.getAttribute(FontFamily);
335         if (family == null) {
336             family = "Monospaced";
337         }
338         return family;
339     }
340
341     /**
342      * Sets the font attribute.
343      *
344      * @param a the attribute set
345      * @param fam the font
346      */

347     public static void setFontFamily(MutableAttributeSet JavaDoc a, String JavaDoc fam) {
348         a.addAttribute(FontFamily, fam);
349     }
350
351     /**
352      * Gets the font size setting from the attribute list.
353      *
354      * @param a the attribute set
355      * @return the font size, 12 as the default
356      */

357     public static int getFontSize(AttributeSet JavaDoc a) {
358         Integer JavaDoc size = (Integer JavaDoc) a.getAttribute(FontSize);
359         if (size != null) {
360             return size.intValue();
361         }
362         return 12;
363     }
364
365     /**
366      * Sets the font size attribute.
367      *
368      * @param a the attribute set
369      * @param s the font size
370      */

371     public static void setFontSize(MutableAttributeSet JavaDoc a, int s) {
372         a.addAttribute(FontSize, new Integer JavaDoc(s));
373     }
374
375     /**
376      * Checks whether the bold attribute is set.
377      *
378      * @param a the attribute set
379      * @return true if set else false
380      */

381     public static boolean isBold(AttributeSet JavaDoc a) {
382         Boolean JavaDoc bold = (Boolean JavaDoc) a.getAttribute(Bold);
383         if (bold != null) {
384             return bold.booleanValue();
385         }
386         return false;
387     }
388
389     /**
390      * Sets the bold attribute.
391      *
392      * @param a the attribute set
393      * @param b specifies true/false for setting the attribute
394      */

395     public static void setBold(MutableAttributeSet JavaDoc a, boolean b) {
396         a.addAttribute(Bold, Boolean.valueOf(b));
397     }
398
399     /**
400      * Checks whether the italic attribute is set.
401      *
402      * @param a the attribute set
403      * @return true if set else false
404      */

405     public static boolean isItalic(AttributeSet JavaDoc a) {
406         Boolean JavaDoc italic = (Boolean JavaDoc) a.getAttribute(Italic);
407         if (italic != null) {
408             return italic.booleanValue();
409         }
410         return false;
411     }
412
413     /**
414      * Sets the italic attribute.
415      *
416      * @param a the attribute set
417      * @param b specifies true/false for setting the attribute
418      */

419     public static void setItalic(MutableAttributeSet JavaDoc a, boolean b) {
420         a.addAttribute(Italic, Boolean.valueOf(b));
421     }
422
423     /**
424      * Checks whether the underline attribute is set.
425      *
426      * @param a the attribute set
427      * @return true if set else false
428      */

429     public static boolean isUnderline(AttributeSet JavaDoc a) {
430         Boolean JavaDoc underline = (Boolean JavaDoc) a.getAttribute(Underline);
431         if (underline != null) {
432             return underline.booleanValue();
433         }
434         return false;
435     }
436
437     /**
438      * Checks whether the strikethrough attribute is set.
439      *
440      * @param a the attribute set
441      * @return true if set else false
442      */

443     public static boolean isStrikeThrough(AttributeSet JavaDoc a) {
444         Boolean JavaDoc strike = (Boolean JavaDoc) a.getAttribute(StrikeThrough);
445         if (strike != null) {
446             return strike.booleanValue();
447         }
448         return false;
449     }
450
451
452     /**
453      * Checks whether the superscript attribute is set.
454      *
455      * @param a the attribute set
456      * @return true if set else false
457      */

458     public static boolean isSuperscript(AttributeSet JavaDoc a) {
459         Boolean JavaDoc superscript = (Boolean JavaDoc) a.getAttribute(Superscript);
460         if (superscript != null) {
461             return superscript.booleanValue();
462         }
463         return false;
464     }
465
466
467     /**
468      * Checks whether the subscript attribute is set.
469      *
470      * @param a the attribute set
471      * @return true if set else false
472      */

473     public static boolean isSubscript(AttributeSet JavaDoc a) {
474         Boolean JavaDoc subscript = (Boolean JavaDoc) a.getAttribute(Subscript);
475         if (subscript != null) {
476             return subscript.booleanValue();
477         }
478         return false;
479     }
480
481
482     /**
483      * Sets the underline attribute.
484      *
485      * @param a the attribute set
486      * @param b specifies true/false for setting the attribute
487      */

488     public static void setUnderline(MutableAttributeSet JavaDoc a, boolean b) {
489         a.addAttribute(Underline, Boolean.valueOf(b));
490     }
491
492     /**
493      * Sets the strikethrough attribute.
494      *
495      * @param a the attribute set
496      * @param b specifies true/false for setting the attribute
497      */

498     public static void setStrikeThrough(MutableAttributeSet JavaDoc a, boolean b) {
499         a.addAttribute(StrikeThrough, Boolean.valueOf(b));
500     }
501
502     /**
503      * Sets the superscript attribute.
504      *
505      * @param a the attribute set
506      * @param b specifies true/false for setting the attribute
507      */

508     public static void setSuperscript(MutableAttributeSet JavaDoc a, boolean b) {
509         a.addAttribute(Superscript, Boolean.valueOf(b));
510     }
511
512     /**
513      * Sets the subscript attribute.
514      *
515      * @param a the attribute set
516      * @param b specifies true/false for setting the attribute
517      */

518     public static void setSubscript(MutableAttributeSet JavaDoc a, boolean b) {
519         a.addAttribute(Subscript, Boolean.valueOf(b));
520     }
521
522
523     /**
524      * Gets the foreground color setting from the attribute list.
525      *
526      * @param a the attribute set
527      * @return the color, Color.black as the default
528      */

529     public static Color JavaDoc getForeground(AttributeSet JavaDoc a) {
530         Color JavaDoc fg = (Color JavaDoc) a.getAttribute(Foreground);
531         if (fg == null) {
532             fg = Color.black;
533         }
534         return fg;
535     }
536
537     /**
538      * Sets the foreground color.
539      *
540      * @param a the attribute set
541      * @param fg the color
542      */

543     public static void setForeground(MutableAttributeSet JavaDoc a, Color JavaDoc fg) {
544         a.addAttribute(Foreground, fg);
545     }
546
547     /**
548      * Gets the background color setting from the attribute list.
549      *
550      * @param a the attribute set
551      * @return the color, Color.black as the default
552      */

553     public static Color JavaDoc getBackground(AttributeSet JavaDoc a) {
554         Color JavaDoc fg = (Color JavaDoc) a.getAttribute(Background);
555         if (fg == null) {
556             fg = Color.black;
557         }
558         return fg;
559     }
560
561     /**
562      * Sets the background color.
563      *
564      * @param a the attribute set
565      * @param fg the color
566      */

567     public static void setBackground(MutableAttributeSet JavaDoc a, Color JavaDoc fg) {
568         a.addAttribute(Background, fg);
569     }
570
571
572     // --- paragraph attribute accessors ----------------------------
573

574     /**
575      * Gets the first line indent setting.
576      *
577      * @param a the attribute set
578      * @return the value, 0 if not set
579      */

580     public static float getFirstLineIndent(AttributeSet JavaDoc a) {
581         Float JavaDoc indent = (Float JavaDoc) a.getAttribute(FirstLineIndent);
582         if (indent != null) {
583             return indent.floatValue();
584         }
585         return 0;
586     }
587     
588     /**
589      * Sets the first line indent.
590      *
591      * @param a the attribute set
592      * @param i the value
593      */

594     public static void setFirstLineIndent(MutableAttributeSet JavaDoc a, float i) {
595         a.addAttribute(FirstLineIndent, new Float JavaDoc(i));
596     }
597
598     /**
599      * Gets the right indent setting.
600      *
601      * @param a the attribute set
602      * @return the value, 0 if not set
603      */

604     public static float getRightIndent(AttributeSet JavaDoc a) {
605         Float JavaDoc indent = (Float JavaDoc) a.getAttribute(RightIndent);
606         if (indent != null) {
607             return indent.floatValue();
608         }
609         return 0;
610     }
611
612     /**
613      * Sets right indent.
614      *
615      * @param a the attribute set
616      * @param i the value
617      */

618     public static void setRightIndent(MutableAttributeSet JavaDoc a, float i) {
619         a.addAttribute(RightIndent, new Float JavaDoc(i));
620     }
621
622     /**
623      * Gets the left indent setting.
624      *
625      * @param a the attribute set
626      * @return the value, 0 if not set
627      */

628     public static float getLeftIndent(AttributeSet JavaDoc a) {
629         Float JavaDoc indent = (Float JavaDoc) a.getAttribute(LeftIndent);
630         if (indent != null) {
631             return indent.floatValue();
632         }
633         return 0;
634     }
635
636     /**
637      * Sets left indent.
638      *
639      * @param a the attribute set
640      * @param i the value
641      */

642     public static void setLeftIndent(MutableAttributeSet JavaDoc a, float i) {
643         a.addAttribute(LeftIndent, new Float JavaDoc(i));
644     }
645
646     /**
647      * Gets the line spacing setting.
648      *
649      * @param a the attribute set
650      * @return the value, 0 if not set
651      */

652     public static float getLineSpacing(AttributeSet JavaDoc a) {
653         Float JavaDoc space = (Float JavaDoc) a.getAttribute(LineSpacing);
654         if (space != null) {
655             return space.floatValue();
656         }
657         return 0;
658     }
659
660     /**
661      * Sets line spacing.
662      *
663      * @param a the attribute set
664      * @param i the value
665      */

666     public static void setLineSpacing(MutableAttributeSet JavaDoc a, float i) {
667         a.addAttribute(LineSpacing, new Float JavaDoc(i));
668     }
669
670     /**
671      * Gets the space above setting.
672      *
673      * @param a the attribute set
674      * @return the value, 0 if not set
675      */

676     public static float getSpaceAbove(AttributeSet JavaDoc a) {
677         Float JavaDoc space = (Float JavaDoc) a.getAttribute(SpaceAbove);
678         if (space != null) {
679             return space.floatValue();
680         }
681         return 0;
682     }
683
684     /**
685      * Sets space above.
686      *
687      * @param a the attribute set
688      * @param i the value
689      */

690     public static void setSpaceAbove(MutableAttributeSet JavaDoc a, float i) {
691         a.addAttribute(SpaceAbove, new Float JavaDoc(i));
692     }
693
694     /**
695      * Gets the space below setting.
696      *
697      * @param a the attribute set
698      * @return the value, 0 if not set
699      */

700     public static float getSpaceBelow(AttributeSet JavaDoc a) {
701         Float JavaDoc space = (Float JavaDoc) a.getAttribute(SpaceBelow);
702         if (space != null) {
703             return space.floatValue();
704         }
705         return 0;
706     }
707
708     /**
709      * Sets space below.
710      *
711      * @param a the attribute set
712      * @param i the value
713      */

714     public static void setSpaceBelow(MutableAttributeSet JavaDoc a, float i) {
715         a.addAttribute(SpaceBelow, new Float JavaDoc(i));
716     }
717
718     /**
719      * Gets the alignment setting.
720      *
721      * @param a the attribute set
722      * @return the value <code>StyleConstants.ALIGN_LEFT</code> if not set
723      */

724     public static int getAlignment(AttributeSet JavaDoc a) {
725         Integer JavaDoc align = (Integer JavaDoc) a.getAttribute(Alignment);
726         if (align != null) {
727             return align.intValue();
728         }
729         return ALIGN_LEFT;
730     }
731     
732     /**
733      * Sets alignment.
734      *
735      * @param a the attribute set
736      * @param align the alignment value
737      */

738     public static void setAlignment(MutableAttributeSet JavaDoc a, int align) {
739         a.addAttribute(Alignment, new Integer JavaDoc(align));
740     }
741
742     /**
743      * Gets the TabSet.
744      *
745      * @param a the attribute set
746      * @return the <code>TabSet</code>
747      */

748     public static TabSet JavaDoc getTabSet(AttributeSet JavaDoc a) {
749         TabSet JavaDoc tabs = (TabSet JavaDoc)a.getAttribute(TabSet);
750         // PENDING: should this return a default?
751
return tabs;
752     }
753
754     /**
755      * Sets the TabSet.
756      *
757      * @param a the attribute set.
758      * @param tabs the TabSet
759      */

760     public static void setTabSet(MutableAttributeSet JavaDoc a, TabSet JavaDoc tabs) {
761         a.addAttribute(TabSet, tabs);
762     }
763
764     // --- privates ---------------------------------------------
765

766     static Object JavaDoc[] keys = {
767         NameAttribute, ResolveAttribute, BidiLevel,
768         FontFamily, FontSize, Bold, Italic, Underline,
769     StrikeThrough, Superscript, Subscript, Foreground,
770     Background, ComponentAttribute, IconAttribute,
771     FirstLineIndent, LeftIndent, RightIndent, LineSpacing,
772     SpaceAbove, SpaceBelow, Alignment, TabSet, Orientation,
773     ModelAttribute, ComposedTextAttribute
774     };
775
776     StyleConstants(String JavaDoc representation) {
777         this.representation = representation;
778     }
779
780     private String JavaDoc representation;
781
782     /**
783      * This is a typesafe enumeration of the <em>well-known</em>
784      * attributes that contribute to a paragraph style. These are
785      * aliased by the outer class for general presentation.
786      */

787     public static class ParagraphConstants extends StyleConstants JavaDoc
788         implements AttributeSet.ParagraphAttribute JavaDoc {
789
790         private ParagraphConstants(String JavaDoc representation) {
791             super(representation);
792         }
793     }
794
795     /**
796      * This is a typesafe enumeration of the <em>well-known</em>
797      * attributes that contribute to a character style. These are
798      * aliased by the outer class for general presentation.
799      */

800     public static class CharacterConstants extends StyleConstants JavaDoc
801         implements AttributeSet.CharacterAttribute JavaDoc {
802
803         private CharacterConstants(String JavaDoc representation) {
804         super(representation);
805         }
806     }
807
808     /**
809      * This is a typesafe enumeration of the <em>well-known</em>
810      * attributes that contribute to a color. These are aliased
811      * by the outer class for general presentation.
812      */

813     public static class ColorConstants extends StyleConstants JavaDoc
814         implements AttributeSet.ColorAttribute JavaDoc, AttributeSet.CharacterAttribute JavaDoc {
815
816         private ColorConstants(String JavaDoc representation) {
817             super(representation);
818         }
819     }
820
821     /**
822      * This is a typesafe enumeration of the <em>well-known</em>
823      * attributes that contribute to a font. These are aliased
824      * by the outer class for general presentation.
825      */

826     public static class FontConstants extends StyleConstants JavaDoc
827         implements AttributeSet.FontAttribute JavaDoc, AttributeSet.CharacterAttribute JavaDoc {
828
829         private FontConstants(String JavaDoc representation) {
830             super(representation);
831         }
832     }
833
834
835 }
836
Popular Tags