1 /*
2 * Copyright (c) 1998, 2008, 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 java.awt.Color;
28 import java.awt.Font;
29 import java.awt.GraphicsEnvironment;
30 import java.awt.Toolkit;
31 import java.awt.HeadlessException;
32 import java.awt.Image;
33 import java.io.*;
34 import java.lang.reflect.Method;
35 import java.net.URL;
36 import java.net.MalformedURLException;
37 import java.util.Enumeration;
38 import java.util.Hashtable;
39 import java.util.Vector;
40 import java.util.Locale;
41 import javax.swing.ImageIcon;
42 import javax.swing.SizeRequirements;
43 import javax.swing.text.*;
44
45 /**
46 * Defines a set of
47 * <a href="http://www.w3.org/TR/REC-CSS1">CSS attributes</a>
48 * as a typesafe enumeration. The HTML View implementations use
49 * CSS attributes to determine how they will render. This also defines
50 * methods to map between CSS/HTML/StyleConstants. Any shorthand
51 * properties, such as font, are mapped to the intrinsic properties.
52 * <p>The following describes the CSS properties that are supported by the
53 * rendering engine:
54 * <ul><li>font-family
55 * <li>font-style
56 * <li>font-size (supports relative units)
57 * <li>font-weight
58 * <li>font
59 * <li>color
60 * <li>background-color (with the exception of transparent)
61 * <li>background-image
62 * <li>background-repeat
63 * <li>background-position
64 * <li>background
65 * <li>text-decoration (with the exception of blink and overline)
66 * <li>vertical-align (only sup and super)
67 * <li>text-align (justify is treated as center)
68 * <li>margin-top
69 * <li>margin-right
70 * <li>margin-bottom
71 * <li>margin-left
72 * <li>margin
73 * <li>padding-top
74 * <li>padding-right
75 * <li>padding-bottom
76 * <li>padding-left
77 * <li>padding
78 * <li>border-top-style
79 * <li>border-right-style
80 * <li>border-bottom-style
81 * <li>border-left-style
82 * <li>border-style (only supports inset, outset and none)
83 * <li>border-top-color
84 * <li>border-right-color
85 * <li>border-bottom-color
86 * <li>border-left-color
87 * <li>border-color
88 * <li>list-style-image
89 * <li>list-style-type
90 * <li>list-style-position
91 * </ul>
92 * The following are modeled, but currently not rendered.
93 * <ul><li>font-variant
94 * <li>background-attachment (background always treated as scroll)
95 * <li>word-spacing
96 * <li>letter-spacing
97 * <li>text-indent
98 * <li>text-transform
99 * <li>line-height
100 * <li>border-top-width (this is used to indicate if a border should be used)
101 * <li>border-right-width
102 * <li>border-bottom-width
103 * <li>border-left-width
104 * <li>border-width
105 * <li>border-top
106 * <li>border-right
107 * <li>border-bottom
108 * <li>border-left
109 * <li>border
110 * <li>width
111 * <li>height
112 * <li>float
113 * <li>clear
114 * <li>display
115 * <li>white-space
116 * <li>list-style
117 * </ul>
118 * <p><b>Note: for the time being we do not fully support relative units,
119 * unless noted, so that
120 * p { margin-top: 10% } will be treated as if no margin-top was specified.</b>
121 *
122 * @author Timothy Prinzing
123 * @author Scott Violet
124 * @see StyleSheet
125 */
126 public class CSS implements Serializable {
127
128 /**
129 * Definitions to be used as a key on AttributeSet's
130 * that might hold CSS attributes. Since this is a
131 * closed set (i.e. defined exactly by the specification),
132 * it is final and cannot be extended.
133 */
134 public static final class Attribute {
135
136 private Attribute(String name, String defaultValue, boolean inherited) {
137 this.name = name;
138 this.defaultValue = defaultValue;
139 this.inherited = inherited;
140 }
141
142 /**
143 * The string representation of the attribute. This
144 * should exactly match the string specified in the
145 * CSS specification.
146 */
147 public String toString() {
148 return name;
149 }
150
151 /**
152 * Fetch the default value for the attribute.
153 * If there is no default value (such as for
154 * composite attributes), null will be returned.
155 */
156 public String getDefaultValue() {
157 return defaultValue;
158 }
159
160 /**
161 * Indicates if the attribute should be inherited
162 * from the parent or not.
163 */
164 public boolean isInherited() {
165 return inherited;
166 }
167
168 private String name;
169 private String defaultValue;
170 private boolean inherited;
171
172
173 public static final Attribute BACKGROUND =
174 new Attribute("background", null, false);
175
176 public static final Attribute BACKGROUND_ATTACHMENT =
177 new Attribute("background-attachment", "scroll", false);
178
179 public static final Attribute BACKGROUND_COLOR =
180 new Attribute("background-color", "transparent", false);
181
182 public static final Attribute BACKGROUND_IMAGE =
183 new Attribute("background-image", "none", false);
184
185 public static final Attribute BACKGROUND_POSITION =
186 new Attribute("background-position", null, false);
187
188 public static final Attribute BACKGROUND_REPEAT =
189 new Attribute("background-repeat", "repeat", false);
190
191 public static final Attribute BORDER =
192 new Attribute("border", null, false);
193
194 public static final Attribute BORDER_BOTTOM =
195 new Attribute("border-bottom", null, false);
196
197 public static final Attribute BORDER_BOTTOM_COLOR =
198 new Attribute("border-bottom-color", null, false);
199
200 public static final Attribute BORDER_BOTTOM_STYLE =
201 new Attribute("border-bottom-style", "none", false);
202
203 public static final Attribute BORDER_BOTTOM_WIDTH =
204 new Attribute("border-bottom-width", "medium", false);
205
206 public static final Attribute BORDER_COLOR =
207 new Attribute("border-color", null, false);
208
209 public static final Attribute BORDER_LEFT =
210 new Attribute("border-left", null, false);
211
212 public static final Attribute BORDER_LEFT_COLOR =
213 new Attribute("border-left-color", null, false);
214
215 public static final Attribute BORDER_LEFT_STYLE =
216 new Attribute("border-left-style", "none", false);
217
218 public static final Attribute BORDER_LEFT_WIDTH =
219 new Attribute("border-left-width", "medium", false);
220
221 public static final Attribute BORDER_RIGHT =
222 new Attribute("border-right", null, false);
223
224 public static final Attribute BORDER_RIGHT_COLOR =
225 new Attribute("border-right-color", null, false);
226
227 public static final Attribute BORDER_RIGHT_STYLE =
228 new Attribute("border-right-style", "none", false);
229
230 public static final Attribute BORDER_RIGHT_WIDTH =
231 new Attribute("border-right-width", "medium", false);
232
233 public static final Attribute BORDER_STYLE =
234 new Attribute("border-style", "none", false);
235
236 public static final Attribute BORDER_TOP =
237 new Attribute("border-top", null, false);
238
239 public static final Attribute BORDER_TOP_COLOR =
240 new Attribute("border-top-color", null, false);
241
242 public static final Attribute BORDER_TOP_STYLE =
243 new Attribute("border-top-style", "none", false);
244
245 public static final Attribute BORDER_TOP_WIDTH =
246 new Attribute("border-top-width", "medium", false);
247
248 public static final Attribute BORDER_WIDTH =
249 new Attribute("border-width", "medium", false);
250
251 public static final Attribute CLEAR =
252 new Attribute("clear", "none", false);
253
254 public static final Attribute COLOR =
255 new Attribute("color", "black", true);
256
257 public static final Attribute DISPLAY =
258 new Attribute("display", "block", false);
259
260 public static final Attribute FLOAT =
261 new Attribute("float", "none", false);
262
263 public static final Attribute FONT =
264 new Attribute("font", null, true);
265
266 public static final Attribute FONT_FAMILY =
267 new Attribute("font-family", null, true);
268
269 public static final Attribute FONT_SIZE =
270 new Attribute("font-size", "medium", true);
271
272 public static final Attribute FONT_STYLE =
273 new Attribute("font-style", "normal", true);
274
275 public static final Attribute FONT_VARIANT =
276 new Attribute("font-variant", "normal", true);
277
278 public static final Attribute FONT_WEIGHT =
279 new Attribute("font-weight", "normal", true);
280
281 public static final Attribute HEIGHT =
282 new Attribute("height", "auto", false);
283
284 public static final Attribute LETTER_SPACING =
285 new Attribute("letter-spacing", "normal", true);
286
287 public static final Attribute LINE_HEIGHT =
288 new Attribute("line-height", "normal", true);
289
290 public static final Attribute LIST_STYLE =
291 new Attribute("list-style", null, true);
292
293 public static final Attribute LIST_STYLE_IMAGE =
294 new Attribute("list-style-image", "none", true);
295
296 public static final Attribute LIST_STYLE_POSITION =
297 new Attribute("list-style-position", "outside", true);
298
299 public static final Attribute LIST_STYLE_TYPE =
300 new Attribute("list-style-type", "disc", true);
301
302 public static final Attribute MARGIN =
303 new Attribute("margin", null, false);
304
305 public static final Attribute MARGIN_BOTTOM =
306 new Attribute("margin-bottom", "0", false);
307
308 public static final Attribute MARGIN_LEFT =
309 new Attribute("margin-left", "0", false);
310
311 public static final Attribute MARGIN_RIGHT =
312 new Attribute("margin-right", "0", false);
313
314 /*
315 * made up css attributes to describe orientation depended
316 * margins. used for <dir>, <menu>, <ul> etc. see
317 * 5088268 for more details
318 */
319 static final Attribute MARGIN_LEFT_LTR =
320 new Attribute("margin-left-ltr",
321 Integer.toString(Integer.MIN_VALUE), false);
322
323 static final Attribute MARGIN_LEFT_RTL =
324 new Attribute("margin-left-rtl",
325 Integer.toString(Integer.MIN_VALUE), false);
326
327 static final Attribute MARGIN_RIGHT_LTR =
328 new Attribute("margin-right-ltr",
329 Integer.toString(Integer.MIN_VALUE), false);
330
331 static final Attribute MARGIN_RIGHT_RTL =
332 new Attribute("margin-right-rtl",
333 Integer.toString(Integer.MIN_VALUE), false);
334
335
336 public static final Attribute MARGIN_TOP =
337 new Attribute("margin-top", "0", false);
338
339 public static final Attribute PADDING =
340 new Attribute("padding", null, false);
341
342 public static final Attribute PADDING_BOTTOM =
343 new Attribute("padding-bottom", "0", false);
344
345 public static final Attribute PADDING_LEFT =
346 new Attribute("padding-left", "0", false);
347
348 public static final Attribute PADDING_RIGHT =
349 new Attribute("padding-right", "0", false);
350
351 public static final Attribute PADDING_TOP =
352 new Attribute("padding-top", "0", false);
353
354 public static final Attribute TEXT_ALIGN =
355 new Attribute("text-align", null, true);
356
357 public static final Attribute TEXT_DECORATION =
358 new Attribute("text-decoration", "none", true);
359
360 public static final Attribute TEXT_INDENT =
361 new Attribute("text-indent", "0", true);
362
363 public static final Attribute TEXT_TRANSFORM =
364 new Attribute("text-transform", "none", true);
365
366 public static final Attribute VERTICAL_ALIGN =
367 new Attribute("vertical-align", "baseline", false);
368
369 public static final Attribute WORD_SPACING =
370 new Attribute("word-spacing", "normal", true);
371
372 public static final Attribute WHITE_SPACE =
373 new Attribute("white-space", "normal", true);
374
375 public static final Attribute WIDTH =
376 new Attribute("width", "auto", false);
377
378 /*public*/ static final Attribute BORDER_SPACING =
379 new Attribute("border-spacing", "0", true);
380
381 /*public*/ static final Attribute CAPTION_SIDE =
382 new Attribute("caption-side", "left", true);
383
384 // All possible CSS attribute keys.
385 static final Attribute[] allAttributes = {
386 BACKGROUND, BACKGROUND_ATTACHMENT, BACKGROUND_COLOR,
387 BACKGROUND_IMAGE, BACKGROUND_POSITION, BACKGROUND_REPEAT,
388 BORDER, BORDER_BOTTOM, BORDER_BOTTOM_WIDTH, BORDER_COLOR,
389 BORDER_LEFT, BORDER_LEFT_WIDTH, BORDER_RIGHT, BORDER_RIGHT_WIDTH,
390 BORDER_STYLE, BORDER_TOP, BORDER_TOP_WIDTH, BORDER_WIDTH,
391 BORDER_TOP_STYLE, BORDER_RIGHT_STYLE, BORDER_BOTTOM_STYLE,
392 BORDER_LEFT_STYLE,
393 BORDER_TOP_COLOR, BORDER_RIGHT_COLOR, BORDER_BOTTOM_COLOR,
394 BORDER_LEFT_COLOR,
395 CLEAR, COLOR, DISPLAY, FLOAT, FONT, FONT_FAMILY, FONT_SIZE,
396 FONT_STYLE, FONT_VARIANT, FONT_WEIGHT, HEIGHT, LETTER_SPACING,
397 LINE_HEIGHT, LIST_STYLE, LIST_STYLE_IMAGE, LIST_STYLE_POSITION,
398 LIST_STYLE_TYPE, MARGIN, MARGIN_BOTTOM, MARGIN_LEFT, MARGIN_RIGHT,
399 MARGIN_TOP, PADDING, PADDING_BOTTOM, PADDING_LEFT, PADDING_RIGHT,
400 PADDING_TOP, TEXT_ALIGN, TEXT_DECORATION, TEXT_INDENT, TEXT_TRANSFORM,
401 VERTICAL_ALIGN, WORD_SPACING, WHITE_SPACE, WIDTH,
402 BORDER_SPACING, CAPTION_SIDE,
403 MARGIN_LEFT_LTR, MARGIN_LEFT_RTL, MARGIN_RIGHT_LTR, MARGIN_RIGHT_RTL
404 };
405
406 private static final Attribute[] ALL_MARGINS =
407 { MARGIN_TOP, MARGIN_RIGHT, MARGIN_BOTTOM, MARGIN_LEFT };
408 private static final Attribute[] ALL_PADDING =
409 { PADDING_TOP, PADDING_RIGHT, PADDING_BOTTOM, PADDING_LEFT };
410 private static final Attribute[] ALL_BORDER_WIDTHS =
411 { BORDER_TOP_WIDTH, BORDER_RIGHT_WIDTH, BORDER_BOTTOM_WIDTH,
412 BORDER_LEFT_WIDTH };
413 private static final Attribute[] ALL_BORDER_STYLES =
414 { BORDER_TOP_STYLE, BORDER_RIGHT_STYLE, BORDER_BOTTOM_STYLE,
415 BORDER_LEFT_STYLE };
416 private static final Attribute[] ALL_BORDER_COLORS =
417 { BORDER_TOP_COLOR, BORDER_RIGHT_COLOR, BORDER_BOTTOM_COLOR,
418 BORDER_LEFT_COLOR };
419
420 }
421
422 static final class Value {
423
424 private Value(String name) {
425 this.name = name;
426 }
427
428 /**
429 * The string representation of the attribute. This
430 * should exactly match the string specified in the
431 * CSS specification.
432 */
433 public String toString() {
434 return name;
435 }
436
437 static final Value INHERITED = new Value("inherited");
438 static final Value NONE = new Value("none");
439 static final Value HIDDEN = new Value("hidden");
440 static final Value DOTTED = new Value("dotted");
441 static final Value DASHED = new Value("dashed");
442 static final Value SOLID = new Value("solid");
443 static final Value DOUBLE = new Value("double");
444 static final Value GROOVE = new Value("groove");
445 static final Value RIDGE = new Value("ridge");
446 static final Value INSET = new Value("inset");
447 static final Value OUTSET = new Value("outset");
448 // Lists.
449 static final Value DISC = new Value("disc");
450 static final Value CIRCLE = new Value("circle");
451 static final Value SQUARE = new Value("square");
452 static final Value DECIMAL = new Value("decimal");
453 static final Value LOWER_ROMAN = new Value("lower-roman");
454 static final Value UPPER_ROMAN = new Value("upper-roman");
455 static final Value LOWER_ALPHA = new Value("lower-alpha");
456 static final Value UPPER_ALPHA = new Value("upper-alpha");
457 // background-repeat
458 static final Value BACKGROUND_NO_REPEAT = new Value("no-repeat");
459 static final Value BACKGROUND_REPEAT = new Value("repeat");
460 static final Value BACKGROUND_REPEAT_X = new Value("repeat-x");
461 static final Value BACKGROUND_REPEAT_Y = new Value("repeat-y");
462 // background-attachment
463 static final Value BACKGROUND_SCROLL = new Value("scroll");
464 static final Value BACKGROUND_FIXED = new Value("fixed");
465
466 private String name;
467
468 static final Value[] allValues = {
469 INHERITED, NONE, DOTTED, DASHED, SOLID, DOUBLE, GROOVE,
470 RIDGE, INSET, OUTSET, DISC, CIRCLE, SQUARE, DECIMAL,
471 LOWER_ROMAN, UPPER_ROMAN, LOWER_ALPHA, UPPER_ALPHA,
472 BACKGROUND_NO_REPEAT, BACKGROUND_REPEAT,
473 BACKGROUND_REPEAT_X, BACKGROUND_REPEAT_Y,
474 BACKGROUND_FIXED, BACKGROUND_FIXED
475 };
476 }
477
478 public CSS() {
479 baseFontSize = baseFontSizeIndex + 1;
480 // setup the css conversion table
481 valueConvertor = new Hashtable<Object, Object>();
482 valueConvertor.put(CSS.Attribute.FONT_SIZE, new FontSize());
483 valueConvertor.put(CSS.Attribute.FONT_FAMILY, new FontFamily());
484 valueConvertor.put(CSS.Attribute.FONT_WEIGHT, new FontWeight());
485 Object bs = new BorderStyle();
486 valueConvertor.put(CSS.Attribute.BORDER_TOP_STYLE, bs);
487 valueConvertor.put(CSS.Attribute.BORDER_RIGHT_STYLE, bs);
488 valueConvertor.put(CSS.Attribute.BORDER_BOTTOM_STYLE, bs);
489 valueConvertor.put(CSS.Attribute.BORDER_LEFT_STYLE, bs);
490 Object cv = new ColorValue();
491 valueConvertor.put(CSS.Attribute.COLOR, cv);
492 valueConvertor.put(CSS.Attribute.BACKGROUND_COLOR, cv);
493 valueConvertor.put(CSS.Attribute.BORDER_TOP_COLOR, cv);
494 valueConvertor.put(CSS.Attribute.BORDER_RIGHT_COLOR, cv);
495 valueConvertor.put(CSS.Attribute.BORDER_BOTTOM_COLOR, cv);
496 valueConvertor.put(CSS.Attribute.BORDER_LEFT_COLOR, cv);
497 Object lv = new LengthValue();
498 valueConvertor.put(CSS.Attribute.MARGIN_TOP, lv);
499 valueConvertor.put(CSS.Attribute.MARGIN_BOTTOM, lv);
500 valueConvertor.put(CSS.Attribute.MARGIN_LEFT, lv);
501 valueConvertor.put(CSS.Attribute.MARGIN_LEFT_LTR, lv);
502 valueConvertor.put(CSS.Attribute.MARGIN_LEFT_RTL, lv);
503 valueConvertor.put(CSS.Attribute.MARGIN_RIGHT, lv);
504 valueConvertor.put(CSS.Attribute.MARGIN_RIGHT_LTR, lv);
505 valueConvertor.put(CSS.Attribute.MARGIN_RIGHT_RTL, lv);
506 valueConvertor.put(CSS.Attribute.PADDING_TOP, lv);
507 valueConvertor.put(CSS.Attribute.PADDING_BOTTOM, lv);
508 valueConvertor.put(CSS.Attribute.PADDING_LEFT, lv);
509 valueConvertor.put(CSS.Attribute.PADDING_RIGHT, lv);
510 Object bv = new BorderWidthValue(null, 0);
511 valueConvertor.put(CSS.Attribute.BORDER_TOP_WIDTH, bv);
512 valueConvertor.put(CSS.Attribute.BORDER_BOTTOM_WIDTH, bv);
513 valueConvertor.put(CSS.Attribute.BORDER_LEFT_WIDTH, bv);
514 valueConvertor.put(CSS.Attribute.BORDER_RIGHT_WIDTH, bv);
515 Object nlv = new LengthValue(true);
516 valueConvertor.put(CSS.Attribute.TEXT_INDENT, nlv);
517 valueConvertor.put(CSS.Attribute.WIDTH, lv);
518 valueConvertor.put(CSS.Attribute.HEIGHT, lv);
519 valueConvertor.put(CSS.Attribute.BORDER_SPACING, lv);
520 Object sv = new StringValue();
521 valueConvertor.put(CSS.Attribute.FONT_STYLE, sv);
522 valueConvertor.put(CSS.Attribute.TEXT_DECORATION, sv);
523 valueConvertor.put(CSS.Attribute.TEXT_ALIGN, sv);
524 valueConvertor.put(CSS.Attribute.VERTICAL_ALIGN, sv);
525 Object valueMapper = new CssValueMapper();
526 valueConvertor.put(CSS.Attribute.LIST_STYLE_TYPE,
527 valueMapper);
528 valueConvertor.put(CSS.Attribute.BACKGROUND_IMAGE,
529 new BackgroundImage());
530 valueConvertor.put(CSS.Attribute.BACKGROUND_POSITION,
531 new BackgroundPosition());
532 valueConvertor.put(CSS.Attribute.BACKGROUND_REPEAT,
533 valueMapper);
534 valueConvertor.put(CSS.Attribute.BACKGROUND_ATTACHMENT,
535 valueMapper);
536 Object generic = new CssValue();
537 int n = CSS.Attribute.allAttributes.length;
538 for (int i = 0; i < n; i++) {
539 CSS.Attribute key = CSS.Attribute.allAttributes[i];
540 if (valueConvertor.get(key) == null) {
541 valueConvertor.put(key, generic);
542 }
543 }
544 }
545
546 /**
547 * Sets the base font size. <code>sz</code> is a CSS value, and is
548 * not necessarily the point size. Use getPointSize to determine the
549 * point size corresponding to <code>sz</code>.
550 */
551 void setBaseFontSize(int sz) {
552 if (sz < 1)
553 baseFontSize = 0;
554 else if (sz > 7)
555 baseFontSize = 7;
556 else
557 baseFontSize = sz;
558 }
559
560 /**
561 * Sets the base font size from the passed in string.
562 */
563 void setBaseFontSize(String size) {
564 int relSize, absSize, diff;
565
566 if (size != null) {
567 if (size.startsWith("+")) {
568 relSize = Integer.valueOf(size.substring(1)).intValue();
569 setBaseFontSize(baseFontSize + relSize);
570 } else if (size.startsWith("-")) {
571 relSize = -Integer.valueOf(size.substring(1)).intValue();
572 setBaseFontSize(baseFontSize + relSize);
573 } else {
574 setBaseFontSize(Integer.valueOf(size).intValue());
575 }
576 }
577 }
578
579 /**
580 * Returns the base font size.
581 */
582 int getBaseFontSize() {
583 return baseFontSize;
584 }
585
586 /**
587 * Parses the CSS property <code>key</code> with value
588 * <code>value</code> placing the result in <code>att</code>.
589 */
590 void addInternalCSSValue(MutableAttributeSet attr,
591 CSS.Attribute key, String value) {
592 if (key == CSS.Attribute.FONT) {
593 ShorthandFontParser.parseShorthandFont(this, value, attr);
594 }
595 else if (key == CSS.Attribute.BACKGROUND) {
596 ShorthandBackgroundParser.parseShorthandBackground
597 (this, value, attr);
598 }
599 else if (key == CSS.Attribute.MARGIN) {
600 ShorthandMarginParser.parseShorthandMargin(this, value, attr,
601 CSS.Attribute.ALL_MARGINS);
602 }
603 else if (key == CSS.Attribute.PADDING) {
604 ShorthandMarginParser.parseShorthandMargin(this, value, attr,
605 CSS.Attribute.ALL_PADDING);
606 }
607 else if (key == CSS.Attribute.BORDER_WIDTH) {
608 ShorthandMarginParser.parseShorthandMargin(this, value, attr,
609 CSS.Attribute.ALL_BORDER_WIDTHS);
610 }
611 else if (key == CSS.Attribute.BORDER_COLOR) {
612 ShorthandMarginParser.parseShorthandMargin(this, value, attr,
613 CSS.Attribute.ALL_BORDER_COLORS);
614 }
615 else if (key == CSS.Attribute.BORDER_STYLE) {
616 ShorthandMarginParser.parseShorthandMargin(this, value, attr,
617 CSS.Attribute.ALL_BORDER_STYLES);
618 }
619 else if ((key == CSS.Attribute.BORDER) ||
620 (key == CSS.Attribute.BORDER_TOP) ||
621 (key == CSS.Attribute.BORDER_RIGHT) ||
622 (key == CSS.Attribute.BORDER_BOTTOM) ||
623 (key == CSS.Attribute.BORDER_LEFT)) {
624 ShorthandBorderParser.parseShorthandBorder(attr, key, value);
625 }
626 else {
627 Object iValue = getInternalCSSValue(key, value);
628 if (iValue != null) {
629 attr.addAttribute(key, iValue);
630 }
631 }
632 }
633
634 /**
635 * Gets the internal CSS representation of <code>value</code> which is
636 * a CSS value of the CSS attribute named <code>key</code>. The receiver
637 * should not modify <code>value</code>, and the first <code>count</code>
638 * strings are valid.
639 */
640 Object getInternalCSSValue(CSS.Attribute key, String value) {
641 CssValue conv = (CssValue) valueConvertor.get(key);
642 Object r = conv.parseCssValue(value);
643 return r != null ? r : conv.parseCssValue(key.getDefaultValue());
644 }
645
646 /**
647 * Maps from a StyleConstants to a CSS Attribute.
648 */
649 Attribute styleConstantsKeyToCSSKey(StyleConstants sc) {
650 return styleConstantToCssMap.get(sc);
651 }
652
653 /**
654 * Maps from a StyleConstants value to a CSS value.
655 */
656 Object styleConstantsValueToCSSValue(StyleConstants sc,
657 Object styleValue) {
658 Attribute cssKey = styleConstantsKeyToCSSKey(sc);
659 if (cssKey != null) {
660 CssValue conv = (CssValue)valueConvertor.get(cssKey);
661 return conv.fromStyleConstants(sc, styleValue);
662 }
663 return null;
664 }
665
666 /**
667 * Converts the passed in CSS value to a StyleConstants value.
668 * <code>key</code> identifies the CSS attribute being mapped.
669 */
670 Object cssValueToStyleConstantsValue(StyleConstants key, Object value) {
671 if (value instanceof CssValue) {
672 return ((CssValue)value).toStyleConstants(key, null);
673 }
674 return null;
675 }
676
677 /**
678 * Returns the font for the values in the passed in AttributeSet.
679 * It is assumed the keys will be CSS.Attribute keys.
680 * <code>sc</code> is the StyleContext that will be messaged to get
681 * the font once the size, name and style have been determined.
682 */
683 Font getFont(StyleContext sc, AttributeSet a, int defaultSize, StyleSheet ss) {
684 ss = getStyleSheet(ss);
685 int size = getFontSize(a, defaultSize, ss);
686
687 /*
688 * If the vertical alignment is set to either superscirpt or
689 * subscript we reduce the font size by 2 points.
690 */
691 StringValue vAlignV = (StringValue)a.getAttribute
692 (CSS.Attribute.VERTICAL_ALIGN);
693 if ((vAlignV != null)) {
694 String vAlign = vAlignV.toString();
695 if ((vAlign.indexOf("sup") >= 0) ||
696 (vAlign.indexOf("sub") >= 0)) {
697 size -= 2;
698 }
699 }
700
701 FontFamily familyValue = (FontFamily)a.getAttribute
702 (CSS.Attribute.FONT_FAMILY);
703 String family = (familyValue != null) ? familyValue.getValue() :
704 Font.SANS_SERIF;
705 int style = Font.PLAIN;
706 FontWeight weightValue = (FontWeight) a.getAttribute
707 (CSS.Attribute.FONT_WEIGHT);
708 if ((weightValue != null) && (weightValue.getValue() > 400)) {
709 style |= Font.BOLD;
710 }
711 Object fs = a.getAttribute(CSS.Attribute.FONT_STYLE);
712 if ((fs != null) && (fs.toString().indexOf("italic") >= 0)) {
713 style |= Font.ITALIC;
714 }
715 if (family.equalsIgnoreCase("monospace")) {
716 family = Font.MONOSPACED;
717 }
718 Font f = sc.getFont(family, style, size);
719 if (f == null
720 || (f.getFamily().equals(Font.DIALOG)
721 && ! family.equalsIgnoreCase(Font.DIALOG))) {
722 family = Font.SANS_SERIF;
723 f = sc.getFont(family, style, size);
724 }
725 return f;
726 }
727
728 static int getFontSize(AttributeSet attr, int defaultSize, StyleSheet ss) {
729 // PENDING(prinz) this is a 1.1 based implementation, need to also
730 // have a 1.2 version.
731 FontSize sizeValue = (FontSize)attr.getAttribute(CSS.Attribute.
732 FONT_SIZE);
733
734 return (sizeValue != null) ? sizeValue.getValue(attr, ss)
735 : defaultSize;
736 }
737
738 /**
739 * Takes a set of attributes and turn it into a color
740 * specification. This might be used to specify things
741 * like brighter, more hue, etc.
742 * This will return null if there is no value for <code>key</code>.
743 *
744 * @param key CSS.Attribute identifying where color is stored.
745 * @param a the set of attributes
746 * @return the color
747 */
748 Color getColor(AttributeSet a, CSS.Attribute key) {
749 ColorValue cv = (ColorValue) a.getAttribute(key);
750 if (cv != null) {
751 return cv.getValue();
752 }
753 return null;
754 }
755
756 /**
757 * Returns the size of a font from the passed in string.
758 *
759 * @param size CSS string describing font size
760 * @param baseFontSize size to use for relative units.
761 */
762 float getPointSize(String size, StyleSheet ss) {
763 int relSize, absSize, diff, index;
764 ss = getStyleSheet(ss);
765 if (size != null) {
766 if (size.startsWith("+")) {
767 relSize = Integer.valueOf(size.substring(1)).intValue();
768 return getPointSize(baseFontSize + relSize, ss);
769 } else if (size.startsWith("-")) {
770 relSize = -Integer.valueOf(size.substring(1)).intValue();
771 return getPointSize(baseFontSize + relSize, ss);
772 } else {
773 absSize = Integer.valueOf(size).intValue();
774 return getPointSize(absSize, ss);
775 }
776 }
777 return 0;
778 }
779
780 /**
781 * Returns the length of the attribute in <code>a</code> with
782 * key <code>key</code>.
783 */
784 float getLength(AttributeSet a, CSS.Attribute key, StyleSheet ss) {
785 ss = getStyleSheet(ss);
786 LengthValue lv = (LengthValue) a.getAttribute(key);
787 boolean isW3CLengthUnits = (ss == null) ? false : ss.isW3CLengthUnits();
788 float len = (lv != null) ? lv.getValue(isW3CLengthUnits) : 0;
789 return len;
790 }
791
792 /**
793 * Convert a set of HTML attributes to an equivalent
794 * set of CSS attributes.
795 *
796 * @param htmlAttrSet AttributeSet containing the HTML attributes.
797 * @return AttributeSet containing the corresponding CSS attributes.
798 * The AttributeSet will be empty if there are no mapping
799 * CSS attributes.
800 */
801 AttributeSet translateHTMLToCSS(AttributeSet htmlAttrSet) {
802 MutableAttributeSet cssAttrSet = new SimpleAttributeSet();
803 Element elem = (Element)htmlAttrSet;
804 HTML.Tag tag = getHTMLTag(htmlAttrSet);
805 if ((tag == HTML.Tag.TD) || (tag == HTML.Tag.TH)) {
806 // translate border width into the cells, if it has non-zero value.
807 AttributeSet tableAttr = elem.getParentElement().
808 getParentElement().getAttributes();
809
810 int borderWidth = getTableBorder(tableAttr);
811 if (borderWidth > 0) {
812 // If table contains the BORDER attribute cells should have border width equals 1
813 translateAttribute(HTML.Attribute.BORDER, "1", cssAttrSet);
814 }
815 String pad = (String)tableAttr.getAttribute(HTML.Attribute.CELLPADDING);
816 if (pad != null) {
817 LengthValue v =
818 (LengthValue)getInternalCSSValue(CSS.Attribute.PADDING_TOP, pad);
819 v.span = (v.span < 0) ? 0 : v.span;
820 cssAttrSet.addAttribute(CSS.Attribute.PADDING_TOP, v);
821 cssAttrSet.addAttribute(CSS.Attribute.PADDING_BOTTOM, v);
822 cssAttrSet.addAttribute(CSS.Attribute.PADDING_LEFT, v);
823 cssAttrSet.addAttribute(CSS.Attribute.PADDING_RIGHT, v);
824 }
825 }
826 if (elem.isLeaf()) {
827 translateEmbeddedAttributes(htmlAttrSet, cssAttrSet);
828 } else {
829 translateAttributes(tag, htmlAttrSet, cssAttrSet);
830 }
831 if (tag == HTML.Tag.CAPTION) {
832 /*
833 * Navigator uses ALIGN for caption placement and IE uses VALIGN.
834 */
835 Object v = htmlAttrSet.getAttribute(HTML.Attribute.ALIGN);
836 if ((v != null) && (v.equals("top") || v.equals("bottom"))) {
837 cssAttrSet.addAttribute(CSS.Attribute.CAPTION_SIDE, v);
838 cssAttrSet.removeAttribute(CSS.Attribute.TEXT_ALIGN);
839 } else {
840 v = htmlAttrSet.getAttribute(HTML.Attribute.VALIGN);
841 if (v != null) {
842 cssAttrSet.addAttribute(CSS.Attribute.CAPTION_SIDE, v);
843 }
844 }
845 }
846 return cssAttrSet;
847 }
848
849 private static int getTableBorder(AttributeSet tableAttr) {
850 String borderValue = (String) tableAttr.getAttribute(HTML.Attribute.BORDER);
851
852 if (borderValue == HTML.NULL_ATTRIBUTE_VALUE || "".equals(borderValue)) {
853 // Some browsers accept <TABLE BORDER> and <TABLE BORDER=""> with the same semantics as BORDER=1
854 return 1;
855 }
856
857 try {
858 return Integer.parseInt(borderValue);
859 } catch (NumberFormatException e) {
860 return 0;
861 }
862 }
863
864 private static final Hashtable<String, Attribute> attributeMap = new Hashtable<String, Attribute>();
865 private static final Hashtable<String, Value> valueMap = new Hashtable<String, Value>();
866
867 /**
868 * The hashtable and the static initalization block below,
869 * set up a mapping from well-known HTML attributes to
870 * CSS attributes. For the most part, there is a 1-1 mapping
871 * between the two. However in the case of certain HTML
872 * attributes for example HTML.Attribute.VSPACE or
873 * HTML.Attribute.HSPACE, end up mapping to two CSS.Attribute's.
874 * Therefore, the value associated with each HTML.Attribute.
875 * key ends up being an array of CSS.Attribute.* objects.
876 */
877 private static final Hashtable<HTML.Attribute, CSS.Attribute[]> htmlAttrToCssAttrMap = new Hashtable<HTML.Attribute, CSS.Attribute[]>(20);
878
879 /**
880 * The hashtable and static initialization that follows sets
881 * up a translation from StyleConstants (i.e. the <em>well known</em>
882 * attributes) to the associated CSS attributes.
883 */
884 private static final Hashtable<Object, Attribute> styleConstantToCssMap = new Hashtable<Object, Attribute>(17);
885 /** Maps from HTML value to a CSS value. Used in internal mapping. */
886 private static final Hashtable<String, CSS.Value> htmlValueToCssValueMap = new Hashtable<String, CSS.Value>(8);
887 /** Maps from CSS value (string) to internal value. */
888 private static final Hashtable<String, CSS.Value> cssValueToInternalValueMap = new Hashtable<String, CSS.Value>(13);
889
890 static {
891 // load the attribute map
892 for (int i = 0; i < Attribute.allAttributes.length; i++ ) {
893 attributeMap.put(Attribute.allAttributes[i].toString(),
894 Attribute.allAttributes[i]);
895 }
896 // load the value map
897 for (int i = 0; i < Value.allValues.length; i++ ) {
898 valueMap.put(Value.allValues[i].toString(),
899 Value.allValues[i]);
900 }
901
902 htmlAttrToCssAttrMap.put(HTML.Attribute.COLOR,
903 new CSS.Attribute[]{CSS.Attribute.COLOR});
904 htmlAttrToCssAttrMap.put(HTML.Attribute.TEXT,
905 new CSS.Attribute[]{CSS.Attribute.COLOR});
906 htmlAttrToCssAttrMap.put(HTML.Attribute.CLEAR,
907 new CSS.Attribute[]{CSS.Attribute.CLEAR});
908 htmlAttrToCssAttrMap.put(HTML.Attribute.BACKGROUND,
909 new CSS.Attribute[]{CSS.Attribute.BACKGROUND_IMAGE});
910 htmlAttrToCssAttrMap.put(HTML.Attribute.BGCOLOR,
911 new CSS.Attribute[]{CSS.Attribute.BACKGROUND_COLOR});
912 htmlAttrToCssAttrMap.put(HTML.Attribute.WIDTH,
913 new CSS.Attribute[]{CSS.Attribute.WIDTH});
914 htmlAttrToCssAttrMap.put(HTML.Attribute.HEIGHT,
915 new CSS.Attribute[]{CSS.Attribute.HEIGHT});
916 htmlAttrToCssAttrMap.put(HTML.Attribute.BORDER,
917 new CSS.Attribute[]{CSS.Attribute.BORDER_TOP_WIDTH, CSS.Attribute.BORDER_RIGHT_WIDTH, CSS.Attribute.BORDER_BOTTOM_WIDTH, CSS.Attribute.BORDER_LEFT_WIDTH});
918 htmlAttrToCssAttrMap.put(HTML.Attribute.CELLPADDING,
919 new CSS.Attribute[]{CSS.Attribute.PADDING});
920 htmlAttrToCssAttrMap.put(HTML.Attribute.CELLSPACING,
921 new CSS.Attribute[]{CSS.Attribute.BORDER_SPACING});
922 htmlAttrToCssAttrMap.put(HTML.Attribute.MARGINWIDTH,
923 new CSS.Attribute[]{CSS.Attribute.MARGIN_LEFT,
924 CSS.Attribute.MARGIN_RIGHT});
925 htmlAttrToCssAttrMap.put(HTML.Attribute.MARGINHEIGHT,
926 new CSS.Attribute[]{CSS.Attribute.MARGIN_TOP,
927 CSS.Attribute.MARGIN_BOTTOM});
928 htmlAttrToCssAttrMap.put(HTML.Attribute.HSPACE,
929 new CSS.Attribute[]{CSS.Attribute.PADDING_LEFT,
930 CSS.Attribute.PADDING_RIGHT});
931 htmlAttrToCssAttrMap.put(HTML.Attribute.VSPACE,
932 new CSS.Attribute[]{CSS.Attribute.PADDING_BOTTOM,
933 CSS.Attribute.PADDING_TOP});
934 htmlAttrToCssAttrMap.put(HTML.Attribute.FACE,
935 new CSS.Attribute[]{CSS.Attribute.FONT_FAMILY});
936 htmlAttrToCssAttrMap.put(HTML.Attribute.SIZE,
937 new CSS.Attribute[]{CSS.Attribute.FONT_SIZE});
938 htmlAttrToCssAttrMap.put(HTML.Attribute.VALIGN,
939 new CSS.Attribute[]{CSS.Attribute.VERTICAL_ALIGN});
940 htmlAttrToCssAttrMap.put(HTML.Attribute.ALIGN,
941 new CSS.Attribute[]{CSS.Attribute.VERTICAL_ALIGN,
942 CSS.Attribute.TEXT_ALIGN,
943 CSS.Attribute.FLOAT});
944 htmlAttrToCssAttrMap.put(HTML.Attribute.TYPE,
945 new CSS.Attribute[]{CSS.Attribute.LIST_STYLE_TYPE});
946 htmlAttrToCssAttrMap.put(HTML.Attribute.NOWRAP,
947 new CSS.Attribute[]{CSS.Attribute.WHITE_SPACE});
948
949 // initialize StyleConstants mapping
950 styleConstantToCssMap.put(StyleConstants.FontFamily,
951 CSS.Attribute.FONT_FAMILY);
952 styleConstantToCssMap.put(StyleConstants.FontSize,
953 CSS.Attribute.FONT_SIZE);
954 styleConstantToCssMap.put(StyleConstants.Bold,
955 CSS.Attribute.FONT_WEIGHT);
956 styleConstantToCssMap.put(StyleConstants.Italic,
957 CSS.Attribute.FONT_STYLE);
958 styleConstantToCssMap.put(StyleConstants.Underline,
959 CSS.Attribute.TEXT_DECORATION);
960 styleConstantToCssMap.put(StyleConstants.StrikeThrough,
961 CSS.Attribute.TEXT_DECORATION);
962 styleConstantToCssMap.put(StyleConstants.Superscript,
963 CSS.Attribute.VERTICAL_ALIGN);
964 styleConstantToCssMap.put(StyleConstants.Subscript,
965 CSS.Attribute.VERTICAL_ALIGN);
966 styleConstantToCssMap.put(StyleConstants.Foreground,
967 CSS.Attribute.COLOR);
968 styleConstantToCssMap.put(StyleConstants.Background,
969 CSS.Attribute.BACKGROUND_COLOR);
970 styleConstantToCssMap.put(StyleConstants.FirstLineIndent,
971 CSS.Attribute.TEXT_INDENT);
972 styleConstantToCssMap.put(StyleConstants.LeftIndent,
973 CSS.Attribute.MARGIN_LEFT);
974 styleConstantToCssMap.put(StyleConstants.RightIndent,
975 CSS.Attribute.MARGIN_RIGHT);
976 styleConstantToCssMap.put(StyleConstants.SpaceAbove,
977 CSS.Attribute.MARGIN_TOP);
978 styleConstantToCssMap.put(StyleConstants.SpaceBelow,
979 CSS.Attribute.MARGIN_BOTTOM);
980 styleConstantToCssMap.put(StyleConstants.Alignment,
981 CSS.Attribute.TEXT_ALIGN);
982
983 // HTML->CSS
984 htmlValueToCssValueMap.put("disc", CSS.Value.DISC);
985 htmlValueToCssValueMap.put("square", CSS.Value.SQUARE);
986 htmlValueToCssValueMap.put("circle", CSS.Value.CIRCLE);
987 htmlValueToCssValueMap.put("1", CSS.Value.DECIMAL);
988 htmlValueToCssValueMap.put("a", CSS.Value.LOWER_ALPHA);
989 htmlValueToCssValueMap.put("A", CSS.Value.UPPER_ALPHA);
990 htmlValueToCssValueMap.put("i", CSS.Value.LOWER_ROMAN);
991 htmlValueToCssValueMap.put("I", CSS.Value.UPPER_ROMAN);
992
993 // CSS-> internal CSS
994 cssValueToInternalValueMap.put("none", CSS.Value.NONE);
995 cssValueToInternalValueMap.put("disc", CSS.Value.DISC);
996 cssValueToInternalValueMap.put("square", CSS.Value.SQUARE);
997 cssValueToInternalValueMap.put("circle", CSS.Value.CIRCLE);
998 cssValueToInternalValueMap.put("decimal", CSS.Value.DECIMAL);
999 cssValueToInternalValueMap.put("lower-roman", CSS.Value.LOWER_ROMAN);
1000 cssValueToInternalValueMap.put("upper-roman", CSS.Value.UPPER_ROMAN);
1001 cssValueToInternalValueMap.put("lower-alpha", CSS.Value.LOWER_ALPHA);
1002 cssValueToInternalValueMap.put("upper-alpha", CSS.Value.UPPER_ALPHA);
1003 cssValueToInternalValueMap.put("repeat", CSS.Value.BACKGROUND_REPEAT);
1004 cssValueToInternalValueMap.put("no-repeat",
1005 CSS.Value.BACKGROUND_NO_REPEAT);
1006 cssValueToInternalValueMap.put("repeat-x",
1007 CSS.Value.BACKGROUND_REPEAT_X);
1008 cssValueToInternalValueMap.put("repeat-y",
1009 CSS.Value.BACKGROUND_REPEAT_Y);
1010 cssValueToInternalValueMap.put("scroll",
1011 CSS.Value.BACKGROUND_SCROLL);
1012 cssValueToInternalValueMap.put("fixed",
1013 CSS.Value.BACKGROUND_FIXED);
1014
1015 // Register all the CSS attribute keys for archival/unarchival
1016 Object[] keys = CSS.Attribute.allAttributes;
1017 try {
1018 for (Object key : keys) {
1019 StyleContext.registerStaticAttributeKey(key);
1020 }
1021 } catch (Throwable e) {
1022 e.printStackTrace();
1023 }
1024
1025 // Register all the CSS Values for archival/unarchival
1026 keys = CSS.Value.allValues;
1027 try {
1028 for (Object key : keys) {
1029 StyleContext.registerStaticAttributeKey(key);
1030 }
1031 } catch (Throwable e) {
1032 e.printStackTrace();
1033 }
1034 }
1035
1036 /**
1037 * Return the set of all possible CSS attribute keys.
1038 */
1039 public static Attribute[] getAllAttributeKeys() {
1040 Attribute[] keys = new Attribute[Attribute.allAttributes.length];
1041 System.arraycopy(Attribute.allAttributes, 0, keys, 0, Attribute.allAttributes.length);
1042 return keys;
1043 }
1044
1045 /**
1046 * Translates a string to a <code>CSS.Attribute</code> object.
1047 * This will return <code>null</code> if there is no attribute
1048 * by the given name.
1049 *
1050 * @param name the name of the CSS attribute to fetch the
1051 * typesafe enumeration for
1052 * @return the <code>CSS.Attribute</code> object,
1053 * or <code>null</code> if the string
1054 * doesn't represent a valid attribute key
1055 */
1056 public static final Attribute getAttribute(String name) {
1057 return attributeMap.get(name);
1058 }
1059
1060 /**
1061 * Translates a string to a <code>CSS.Value</code> object.
1062 * This will return <code>null</code> if there is no value
1063 * by the given name.
1064 *
1065 * @param name the name of the CSS value to fetch the
1066 * typesafe enumeration for
1067 * @return the <code>CSS.Value</code> object,
1068 * or <code>null</code> if the string
1069 * doesn't represent a valid CSS value name; this does
1070 * not mean that it doesn't represent a valid CSS value
1071 */
1072 static final Value getValue(String name) {
1073 return valueMap.get(name);
1074 }
1075
1076
1077 //
1078 // Conversion related methods/classes
1079 //
1080
1081 /**
1082 * Returns a URL for the given CSS url string. If relative,
1083 * <code>base</code> is used as the parent. If a valid URL can not
1084 * be found, this will not throw a MalformedURLException, instead
1085 * null will be returned.
1086 */
1087 static URL getURL(URL base, String cssString) {
1088 if (cssString == null) {
1089 return null;
1090 }
1091 if (cssString.startsWith("url(") &&
1092 cssString.endsWith(")")) {
1093 cssString = cssString.substring(4, cssString.length() - 1);
1094 }
1095 // Absolute first
1096 try {
1097 URL url = new URL(cssString);
1098 if (url != null) {
1099 return url;
1100 }
1101 } catch (MalformedURLException mue) {
1102 }
1103 // Then relative
1104 if (base != null) {
1105 // Relative URL, try from base
1106 try {
1107 URL url = new URL(base, cssString);
1108 return url;
1109 }
1110 catch (MalformedURLException muee) {
1111 }
1112 }
1113 return null;
1114 }
1115
1116 /**
1117 * Converts a type Color to a hex string
1118 * in the format "#RRGGBB"
1119 */
1120 static String colorToHex(Color color) {
1121
1122 String colorstr = "#";
1123
1124 // Red
1125 String str = Integer.toHexString(color.getRed());
1126 if (str.length() > 2)
1127 str = str.substring(0, 2);
1128 else if (str.length() < 2)
1129 colorstr += "0" + str;
1130 else
1131 colorstr += str;
1132
1133 // Green
1134 str = Integer.toHexString(color.getGreen());
1135 if (str.length() > 2)
1136 str = str.substring(0, 2);
1137 else if (str.length() < 2)
1138 colorstr += "0" + str;
1139 else
1140 colorstr += str;
1141
1142 // Blue
1143 str = Integer.toHexString(color.getBlue());
1144 if (str.length() > 2)
1145 str = str.substring(0, 2);
1146 else if (str.length() < 2)
1147 colorstr += "0" + str;
1148 else
1149 colorstr += str;
1150
1151 return colorstr;
1152 }
1153
1154 /**
1155 * Convert a "#FFFFFF" hex string to a Color.
1156 * If the color specification is bad, an attempt
1157 * will be made to fix it up.
1158 */
1159 static final Color hexToColor(String value) {
1160 String digits;
1161 int n = value.length();
1162 if (value.startsWith("#")) {
1163 digits = value.substring(1, Math.min(value.length(), 7));
1164 } else {
1165 digits = value;
1166 }
1167 String hstr = "0x" + digits;
1168 Color c;
1169 try {
1170 c = Color.decode(hstr);
1171 } catch (NumberFormatException nfe) {
1172 c = null;
1173 }
1174 return c;
1175 }
1176
1177 /**
1178 * Convert a color string such as "RED" or "#NNNNNN" or "rgb(r, g, b)"
1179 * to a Color.
1180 */
1181 static Color stringToColor(String str) {
1182 Color color;
1183
1184 if (str == null) {
1185 return null;
1186 }
1187 if (str.length() == 0)
1188 color = Color.black;
1189 else if (str.startsWith("rgb(")) {
1190 color = parseRGB(str);
1191 }
1192 else if (str.charAt(0) == '#')
1193 color = hexToColor(str);
1194 else if (str.equalsIgnoreCase("Black"))
1195 color = hexToColor("#000000");
1196 else if(str.equalsIgnoreCase("Silver"))
1197 color = hexToColor("#C0C0C0");
1198 else if(str.equalsIgnoreCase("Gray"))
1199 color = hexToColor("#808080");
1200 else if(str.equalsIgnoreCase("White"))
1201 color = hexToColor("#FFFFFF");
1202 else if(str.equalsIgnoreCase("Maroon"))
1203 color = hexToColor("#800000");
1204 else if(str.equalsIgnoreCase("Red"))
1205 color = hexToColor("#FF0000");
1206 else if(str.equalsIgnoreCase("Purple"))
1207 color = hexToColor("#800080");
1208 else if(str.equalsIgnoreCase("Fuchsia"))
1209 color = hexToColor("#FF00FF");
1210 else if(str.equalsIgnoreCase("Green"))
1211 color = hexToColor("#008000");
1212 else if(str.equalsIgnoreCase("Lime"))
1213 color = hexToColor("#00FF00");
1214 else if(str.equalsIgnoreCase("Olive"))
1215 color = hexToColor("#808000");
1216 else if(str.equalsIgnoreCase("Yellow"))
1217 color = hexToColor("#FFFF00");
1218 else if(str.equalsIgnoreCase("Navy"))
1219 color = hexToColor("#000080");
1220 else if(str.equalsIgnoreCase("Blue"))
1221 color = hexToColor("#0000FF");
1222 else if(str.equalsIgnoreCase("Teal"))
1223 color = hexToColor("#008080");
1224 else if(str.equalsIgnoreCase("Aqua"))
1225 color = hexToColor("#00FFFF");
1226 else if(str.equalsIgnoreCase("Orange"))
1227 color = hexToColor("#FF8000");
1228 else
1229 color = hexToColor(str); // sometimes get specified without leading #
1230 return color;
1231 }
1232
1233 /**
1234 * Parses a String in the format <code>rgb(r, g, b)</code> where
1235 * each of the Color components is either an integer, or a floating number
1236 * with a % after indicating a percentage value of 255. Values are
1237 * constrained to fit with 0-255. The resulting Color is returned.
1238 */
1239 private static Color parseRGB(String string) {
1240 // Find the next numeric char
1241 int[] index = new int[1];
1242
1243 index[0] = 4;
1244 int red = getColorComponent(string, index);
1245 int green = getColorComponent(string, index);
1246 int blue = getColorComponent(string, index);
1247
1248 return new Color(red, green, blue);
1249 }
1250
1251 /**
1252 * Returns the next integer value from <code>string</code> starting
1253 * at <code>index[0]</code>. The value can either can an integer, or
1254 * a percentage (floating number ending with %), in which case it is
1255 * multiplied by 255.
1256 */
1257 private static int getColorComponent(String string, int[] index) {
1258 int length = string.length();
1259 char aChar;
1260
1261 // Skip non-decimal chars
1262 while(index[0] < length && (aChar = string.charAt(index[0])) != '-' &&
1263 !Character.isDigit(aChar) && aChar != '.') {
1264 index[0]++;
1265 }
1266
1267 int start = index[0];
1268
1269 if (start < length && string.charAt(index[0]) == '-') {
1270 index[0]++;
1271 }
1272 while(index[0] < length &&
1273 Character.isDigit(string.charAt(index[0]))) {
1274 index[0]++;
1275 }
1276 if (index[0] < length && string.charAt(index[0]) == '.') {
1277 // Decimal value
1278 index[0]++;
1279 while(index[0] < length &&
1280 Character.isDigit(string.charAt(index[0]))) {
1281 index[0]++;
1282 }
1283 }
1284 if (start != index[0]) {
1285 try {
1286 float value = Float.parseFloat(string.substring
1287 (start, index[0]));
1288
1289 if (index[0] < length && string.charAt(index[0]) == '%') {
1290 index[0]++;
1291 value = value * 255f / 100f;
1292 }
1293 return Math.min(255, Math.max(0, (int)value));
1294 } catch (NumberFormatException nfe) {
1295 // Treat as 0
1296 }
1297 }
1298 return 0;
1299 }
1300
1301 static int getIndexOfSize(float pt, int[] sizeMap) {
1302 for (int i = 0; i < sizeMap.length; i ++ )
1303 if (pt <= sizeMap[i])
1304 return i + 1;
1305 return sizeMap.length;
1306 }
1307
1308 static int getIndexOfSize(float pt, StyleSheet ss) {
1309 int[] sizeMap = (ss != null) ? ss.getSizeMap() :
1310 StyleSheet.sizeMapDefault;
1311 return getIndexOfSize(pt, sizeMap);
1312 }
1313
1314
1315 /**
1316 * @return an array of all the strings in <code>value</code>
1317 * that are separated by whitespace.
1318 */
1319 static String[] parseStrings(String value) {
1320 int current, last;
1321 int length = (value == null) ? 0 : value.length();
1322 Vector<String> temp = new Vector<String>(4);
1323
1324 current = 0;
1325 while (current < length) {
1326 // Skip ws
1327 while (current < length && Character.isWhitespace
1328 (value.charAt(current))) {
1329 current++;
1330 }
1331 last = current;
1332 while (current < length && !Character.isWhitespace
1333 (value.charAt(current))) {
1334 current++;
1335 }
1336 if (last != current) {
1337 temp.addElement(value.substring(last, current));
1338 }
1339 current++;
1340 }
1341 String[] retValue = new String[temp.size()];
1342 temp.copyInto(retValue);
1343 return retValue;
1344 }
1345
1346 /**
1347 * Return the point size, given a size index. Legal HTML index sizes
1348 * are 1-7.
1349 */
1350 float getPointSize(int index, StyleSheet ss) {
1351 ss = getStyleSheet(ss);
1352 int[] sizeMap = (ss != null) ? ss.getSizeMap() :
1353 StyleSheet.sizeMapDefault;
1354 --index;
1355 if (index < 0)
1356 return sizeMap[0];
1357 else if (index > sizeMap.length - 1)
1358 return sizeMap[sizeMap.length - 1];
1359 else
1360 return sizeMap[index];
1361 }
1362
1363
1364 private void translateEmbeddedAttributes(AttributeSet htmlAttrSet,
1365 MutableAttributeSet cssAttrSet) {
1366 Enumeration keys = htmlAttrSet.getAttributeNames();
1367 if (htmlAttrSet.getAttribute(StyleConstants.NameAttribute) ==
1368 HTML.Tag.HR) {
1369 // HR needs special handling due to us treating it as a leaf.
1370 translateAttributes(HTML.Tag.HR, htmlAttrSet, cssAttrSet);
1371 }
1372 while (keys.hasMoreElements()) {
1373 Object key = keys.nextElement();
1374 if (key instanceof HTML.Tag) {
1375 HTML.Tag tag = (HTML.Tag)key;
1376 Object o = htmlAttrSet.getAttribute(tag);
1377 if (o != null && o instanceof AttributeSet) {
1378 translateAttributes(tag, (AttributeSet)o, cssAttrSet);
1379 }
1380 } else if (key instanceof CSS.Attribute) {
1381 cssAttrSet.addAttribute(key, htmlAttrSet.getAttribute(key));
1382 }
1383 }
1384 }
1385
1386 private void translateAttributes(HTML.Tag tag,
1387 AttributeSet htmlAttrSet,
1388 MutableAttributeSet cssAttrSet) {
1389 Enumeration names = htmlAttrSet.getAttributeNames();
1390 while (names.hasMoreElements()) {
1391 Object name = names.nextElement();
1392
1393 if (name instanceof HTML.Attribute) {
1394 HTML.Attribute key = (HTML.Attribute)name;
1395
1396 /*
1397 * HTML.Attribute.ALIGN needs special processing.
1398 * It can map to to 1 of many(3) possible CSS attributes
1399 * depending on the nature of the tag the attribute is
1400 * part off and depending on the value of the attribute.
1401 */
1402 if (key == HTML.Attribute.ALIGN) {
1403 String htmlAttrValue = (String)htmlAttrSet.getAttribute(HTML.Attribute.ALIGN);
1404 if (htmlAttrValue != null) {
1405 CSS.Attribute cssAttr = getCssAlignAttribute(tag, htmlAttrSet);
1406 if (cssAttr != null) {
1407 Object o = getCssValue(cssAttr, htmlAttrValue);
1408 if (o != null) {
1409 cssAttrSet.addAttribute(cssAttr, o);
1410 }
1411 }
1412 }
1413 } else {
1414 if (key == HTML.Attribute.SIZE && !isHTMLFontTag(tag)) {
1415 /*
1416 * The html size attribute has a mapping in the CSS world only
1417 * if it is par of a font or base font tag.
1418 */
1419 } else if (tag == HTML.Tag.TABLE && key == HTML.Attribute.BORDER) {
1420 int borderWidth = getTableBorder(htmlAttrSet);
1421
1422 if (borderWidth > 0) {
1423 translateAttribute(HTML.Attribute.BORDER, Integer.toString(borderWidth), cssAttrSet);
1424 }
1425 } else {
1426 translateAttribute(key, (String) htmlAttrSet.getAttribute(key), cssAttrSet);
1427 }
1428 }
1429 } else if (name instanceof CSS.Attribute) {
1430 cssAttrSet.addAttribute(name, htmlAttrSet.getAttribute(name));
1431 }
1432 }
1433 }
1434
1435 private void translateAttribute(HTML.Attribute key,
1436 String htmlAttrValue,
1437 MutableAttributeSet cssAttrSet) {
1438 /*
1439 * In the case of all remaining HTML.Attribute's they
1440 * map to 1 or more CCS.Attribute.
1441 */
1442 CSS.Attribute[] cssAttrList = getCssAttribute(key);
1443
1444 if (cssAttrList == null || htmlAttrValue == null) {
1445 return;
1446 }
1447 for (Attribute cssAttr : cssAttrList) {
1448 Object o = getCssValue(cssAttr, htmlAttrValue);
1449 if (o != null) {
1450 cssAttrSet.addAttribute(cssAttr , o);
1451 }
1452 }
1453 }
1454
1455 /**
1456 * Given a CSS.Attribute object and its corresponding HTML.Attribute's
1457 * value, this method returns a CssValue object to associate with the
1458 * CSS attribute.
1459 *
1460 * @param the CSS.Attribute
1461 * @param a String containing the value associated HTML.Attribtue.
1462 */
1463 Object getCssValue(CSS.Attribute cssAttr, String htmlAttrValue) {
1464 CssValue value = (CssValue)valueConvertor.get(cssAttr);
1465 Object o = value.parseHtmlValue(htmlAttrValue);
1466 return o;
1467 }
1468
1469 /**
1470 * Maps an HTML.Attribute object to its appropriate CSS.Attributes.
1471 *
1472 * @param HTML.Attribute
1473 * @return CSS.Attribute[]
1474 */
1475 private CSS.Attribute[] getCssAttribute(HTML.Attribute hAttr) {
1476 return htmlAttrToCssAttrMap.get(hAttr);
1477 }
1478
1479 /**
1480 * Maps HTML.Attribute.ALIGN to either:
1481 * CSS.Attribute.TEXT_ALIGN
1482 * CSS.Attribute.FLOAT
1483 * CSS.Attribute.VERTICAL_ALIGN
1484 * based on the tag associated with the attribute and the
1485 * value of the attribute.
1486 *
1487 * @param AttributeSet containing HTML attributes.
1488 * @return CSS.Attribute mapping for HTML.Attribute.ALIGN.
1489 */
1490 private CSS.Attribute getCssAlignAttribute(HTML.Tag tag,
1491 AttributeSet htmlAttrSet) {
1492 return CSS.Attribute.TEXT_ALIGN;
1493 /*
1494 String htmlAttrValue = (String)htmlAttrSet.getAttribute(HTML.Attribute.ALIGN);
1495 CSS.Attribute cssAttr = CSS.Attribute.TEXT_ALIGN;
1496 if (htmlAttrValue != null && htmlAttrSet instanceof Element) {
1497 Element elem = (Element)htmlAttrSet;
1498 if (!elem.isLeaf() && tag.isBlock() && validTextAlignValue(htmlAttrValue)) {
1499 return CSS.Attribute.TEXT_ALIGN;
1500 } else if (isFloater(htmlAttrValue)) {
1501 return CSS.Attribute.FLOAT;
1502 } else if (elem.isLeaf()) {
1503 return CSS.Attribute.VERTICAL_ALIGN;
1504 }
1505 }
1506 return null;
1507 */
1508 }
1509
1510 /**
1511 * Fetches the tag associated with the HTML AttributeSet.
1512 *
1513 * @param AttributeSet containing the HTML attributes.
1514 * @return HTML.Tag
1515 */
1516 private HTML.Tag getHTMLTag(AttributeSet htmlAttrSet) {
1517 Object o = htmlAttrSet.getAttribute(StyleConstants.NameAttribute);
1518 if (o instanceof HTML.Tag) {
1519 HTML.Tag tag = (HTML.Tag) o;
1520 return tag;
1521 }
1522 return null;
1523 }
1524
1525
1526 private boolean isHTMLFontTag(HTML.Tag tag) {
1527 return (tag != null && ((tag == HTML.Tag.FONT) || (tag == HTML.Tag.BASEFONT)));
1528 }
1529
1530
1531 private boolean isFloater(String alignValue) {
1532 return (alignValue.equals("left") || alignValue.equals("right"));
1533 }
1534
1535 private boolean validTextAlignValue(String alignValue) {
1536 return (isFloater(alignValue) || alignValue.equals("center"));
1537 }
1538
1539 /**
1540 * Base class to CSS values in the attribute sets. This
1541 * is intended to act as a convertor to/from other attribute
1542 * formats.
1543 * <p>
1544 * The CSS parser uses the parseCssValue method to convert
1545 * a string to whatever format is appropriate a given key
1546 * (i.e. these convertors are stored in a map using the
1547 * CSS.Attribute as a key and the CssValue as the value).
1548 * <p>
1549 * The HTML to CSS conversion process first converts the
1550 * HTML.Attribute to a CSS.Attribute, and then calls
1551 * the parseHtmlValue method on the value of the HTML
1552 * attribute to produce the corresponding CSS value.
1553 * <p>
1554 * The StyleConstants to CSS conversion process first
1555 * converts the StyleConstants attribute to a
1556 * CSS.Attribute, and then calls the fromStyleConstants
1557 * method to convert the StyleConstants value to a
1558 * CSS value.
1559 * <p>
1560 * The CSS to StyleConstants conversion process first
1561 * converts the StyleConstants attribute to a
1562 * CSS.Attribute, and then calls the toStyleConstants
1563 * method to convert the CSS value to a StyleConstants
1564 * value.
1565 */
1566 static class CssValue implements Serializable {
1567
1568 /**
1569 * Convert a CSS value string to the internal format
1570 * (for fast processing) used in the attribute sets.
1571 * The fallback storage for any value that we don't
1572 * have a special binary format for is a String.
1573 */
1574 Object parseCssValue(String value) {
1575 return value;
1576 }
1577
1578 /**
1579 * Convert an HTML attribute value to a CSS attribute
1580 * value. If there is no conversion, return null.
1581 * This is implemented to simply forward to the CSS
1582 * parsing by default (since some of the attribute
1583 * values are the same). If the attribute value
1584 * isn't recognized as a CSS value it is generally
1585 * returned as null.
1586 */
1587 Object parseHtmlValue(String value) {
1588 return parseCssValue(value);
1589 }
1590
1591 /**
1592 * Converts a <code>StyleConstants</code> attribute value to
1593 * a CSS attribute value. If there is no conversion,
1594 * returns <code>null</code>. By default, there is no conversion.
1595 *
1596 * @param key the <code>StyleConstants</code> attribute
1597 * @param value the value of a <code>StyleConstants</code>
1598 * attribute to be converted
1599 * @return the CSS value that represents the
1600 * <code>StyleConstants</code> value
1601 */
1602 Object fromStyleConstants(StyleConstants key, Object value) {
1603 return null;
1604 }
1605
1606 /**
1607 * Converts a CSS attribute value to a
1608 * <code>StyleConstants</code>
1609 * value. If there is no conversion, returns
1610 * <code>null</code>.
1611 * By default, there is no conversion.
1612 *
1613 * @param key the <code>StyleConstants</code> attribute
1614 * @param v the view containing <code>AttributeSet</code>
1615 * @return the <code>StyleConstants</code> attribute value that
1616 * represents the CSS attribute value
1617 */
1618 Object toStyleConstants(StyleConstants key, View v) {
1619 return null;
1620 }
1621
1622 /**
1623 * Return the CSS format of the value
1624 */
1625 public String toString() {
1626 return svalue;
1627 }
1628
1629 /**
1630 * The value as a string... before conversion to a
1631 * binary format.
1632 */
1633 String svalue;
1634 }
1635
1636 /**
1637 * By default CSS attributes are represented as simple
1638 * strings. They also have no conversion to/from
1639 * StyleConstants by default. This class represents the
1640 * value as a string (via the superclass), but
1641 * provides StyleConstants conversion support for the
1642 * CSS attributes that are held as strings.
1643 */
1644 static class StringValue extends CssValue {
1645
1646 /**
1647 * Convert a CSS value string to the internal format
1648 * (for fast processing) used in the attribute sets.
1649 * This produces a StringValue, so that it can be
1650 * used to convert from CSS to StyleConstants values.
1651 */
1652 Object parseCssValue(String value) {
1653 StringValue sv = new StringValue();
1654 sv.svalue = value;
1655 return sv;
1656 }
1657
1658 /**
1659 * Converts a <code>StyleConstants</code> attribute value to
1660 * a CSS attribute value. If there is no conversion
1661 * returns <code>null</code>.
1662 *
1663 * @param key the <code>StyleConstants</code> attribute
1664 * @param value the value of a <code>StyleConstants</code>
1665 * attribute to be converted
1666 * @return the CSS value that represents the
1667 * <code>StyleConstants</code> value
1668 */
1669 Object fromStyleConstants(StyleConstants key, Object value) {
1670 if (key == StyleConstants.Italic) {
1671 if (value.equals(Boolean.TRUE)) {
1672 return parseCssValue("italic");
1673 }
1674 return parseCssValue("");
1675 } else if (key == StyleConstants.Underline) {
1676 if (value.equals(Boolean.TRUE)) {
1677 return parseCssValue("underline");
1678 }
1679 return parseCssValue("");
1680 } else if (key == StyleConstants.Alignment) {
1681 int align = ((Integer)value).intValue();
1682 String ta;
1683 switch(align) {
1684 case StyleConstants.ALIGN_LEFT:
1685 ta = "left";
1686 break;
1687 case StyleConstants.ALIGN_RIGHT:
1688 ta = "right";
1689 break;
1690 case StyleConstants.ALIGN_CENTER:
1691 ta = "center";
1692 break;
1693 case StyleConstants.ALIGN_JUSTIFIED:
1694 ta = "justify";
1695 break;
1696 default:
1697 ta = "left";
1698 }
1699 return parseCssValue(ta);
1700 } else if (key == StyleConstants.StrikeThrough) {
1701 if (value.equals(Boolean.TRUE)) {
1702 return parseCssValue("line-through");
1703 }
1704 return parseCssValue("");
1705 } else if (key == StyleConstants.Superscript) {
1706 if (value.equals(Boolean.TRUE)) {
1707 return parseCssValue("super");
1708 }
1709 return parseCssValue("");
1710 } else if (key == StyleConstants.Subscript) {
1711 if (value.equals(Boolean.TRUE)) {
1712 return parseCssValue("sub");
1713 }
1714 return parseCssValue("");
1715 }
1716 return null;
1717 }
1718
1719 /**
1720 * Converts a CSS attribute value to a
1721 * <code>StyleConstants</code> value.
1722 * If there is no conversion, returns <code>null</code>.
1723 * By default, there is no conversion.
1724 *
1725 * @param key the <code>StyleConstants</code> attribute
1726 * @return the <code>StyleConstants</code> attribute value that
1727 * represents the CSS attribute value
1728 */
1729 Object toStyleConstants(StyleConstants key, View v) {
1730 if (key == StyleConstants.Italic) {
1731 if (svalue.indexOf("italic") >= 0) {
1732 return Boolean.TRUE;
1733 }
1734 return Boolean.FALSE;
1735 } else if (key == StyleConstants.Underline) {
1736 if (svalue.indexOf("underline") >= 0) {
1737 return Boolean.TRUE;
1738 }
1739 return Boolean.FALSE;
1740 } else if (key == StyleConstants.Alignment) {
1741 if (svalue.equals("right")) {
1742 return new Integer(StyleConstants.ALIGN_RIGHT);
1743 } else if (svalue.equals("center")) {
1744 return new Integer(StyleConstants.ALIGN_CENTER);
1745 } else if (svalue.equals("justify")) {
1746 return new Integer(StyleConstants.ALIGN_JUSTIFIED);
1747 }
1748 return new Integer(StyleConstants.ALIGN_LEFT);
1749 } else if (key == StyleConstants.StrikeThrough) {
1750 if (svalue.indexOf("line-through") >= 0) {
1751 return Boolean.TRUE;
1752 }
1753 return Boolean.FALSE;
1754 } else if (key == StyleConstants.Superscript) {
1755 if (svalue.indexOf("super") >= 0) {
1756 return Boolean.TRUE;
1757 }
1758 return Boolean.FALSE;
1759 } else if (key == StyleConstants.Subscript) {
1760 if (svalue.indexOf("sub") >= 0) {
1761 return Boolean.TRUE;
1762 }
1763 return Boolean.FALSE;
1764 }
1765 return null;
1766 }
1767
1768 // Used by ViewAttributeSet
1769 boolean isItalic() {
1770 return (svalue.indexOf("italic") != -1);
1771 }
1772
1773 boolean isStrike() {
1774 return (svalue.indexOf("line-through") != -1);
1775 }
1776
1777 boolean isUnderline() {
1778 return (svalue.indexOf("underline") != -1);
1779 }
1780
1781 boolean isSub() {
1782 return (svalue.indexOf("sub") != -1);
1783 }
1784
1785 boolean isSup() {
1786 return (svalue.indexOf("sup") != -1);
1787 }
1788 }
1789
1790 /**
1791 * Represents a value for the CSS.FONT_SIZE attribute.
1792 * The binary format of the value can be one of several
1793 * types. If the type is Float,
1794 * the value is specified in terms of point or
1795 * percentage, depending upon the ending of the
1796 * associated string.
1797 * If the type is Integer, the value is specified
1798 * in terms of a size index.
1799 */
1800 class FontSize extends CssValue {
1801
1802 /**
1803 * Returns the size in points. This is ultimately
1804 * what we need for the purpose of creating/fetching
1805 * a Font object.
1806 *
1807 * @param a the attribute set the value is being
1808 * requested from. We may need to walk up the
1809 * resolve hierarchy if it's relative.
1810 */
1811 int getValue(AttributeSet a, StyleSheet ss) {
1812 ss = getStyleSheet(ss);
1813 if (index) {
1814 // it's an index, translate from size table
1815 return Math.round(getPointSize((int) value, ss));
1816 }
1817 else if (lu == null) {
1818 return Math.round(value);
1819 }
1820 else {
1821 if (lu.type == 0) {
1822 boolean isW3CLengthUnits = (ss == null) ? false : ss.isW3CLengthUnits();
1823 return Math.round(lu.getValue(isW3CLengthUnits));
1824 }
1825 if (a != null) {
1826 AttributeSet resolveParent = a.getResolveParent();
1827
1828 if (resolveParent != null) {
1829 int pValue = StyleConstants.getFontSize(resolveParent);
1830
1831 float retValue;
1832 if (lu.type == 1 || lu.type == 3) {
1833 retValue = lu.value * (float)pValue;
1834 }
1835 else {
1836 retValue = lu.value + (float)pValue;
1837 }
1838 return Math.round(retValue);
1839 }
1840 }
1841 // a is null, or no resolve parent.
1842 return 12;
1843 }
1844 }
1845
1846 Object parseCssValue(String value) {
1847 FontSize fs = new FontSize();
1848 fs.svalue = value;
1849 try {
1850 if (value.equals("xx-small")) {
1851 fs.value = 1;
1852 fs.index = true;
1853 } else if (value.equals("x-small")) {
1854 fs.value = 2;
1855 fs.index = true;
1856 } else if (value.equals("small")) {
1857 fs.value = 3;
1858 fs.index = true;
1859 } else if (value.equals("medium")) {
1860 fs.value = 4;
1861 fs.index = true;
1862 } else if (value.equals("large")) {
1863 fs.value = 5;
1864 fs.index = true;
1865 } else if (value.equals("x-large")) {
1866 fs.value = 6;
1867 fs.index = true;
1868 } else if (value.equals("xx-large")) {
1869 fs.value = 7;
1870 fs.index = true;
1871 } else {
1872 fs.lu = new LengthUnit(value, (short)1, 1f);
1873 }
1874 // relative sizes, larger | smaller (adjust from parent by
1875 // 1.5 pixels)
1876 // em, ex refer to parent sizes
1877 // lengths: pt, mm, cm, pc, in, px
1878 // em (font height 3em would be 3 times font height)
1879 // ex (height of X)
1880 // lengths are (+/-) followed by a number and two letter
1881 // unit identifier
1882 } catch (NumberFormatException nfe) {
1883 fs = null;
1884 }
1885 return fs;
1886 }
1887
1888 Object parseHtmlValue(String value) {
1889 if ((value == null) || (value.length() == 0)) {
1890 return null;
1891 }
1892 FontSize fs = new FontSize();
1893 fs.svalue = value;
1894
1895 try {
1896 /*
1897 * relative sizes in the size attribute are relative
1898 * to the <basefont>'s size.
1899 */
1900 int baseFontSize = getBaseFontSize();
1901 if (value.charAt(0) == '+') {
1902 int relSize = Integer.valueOf(value.substring(1)).intValue();
1903 fs.value = baseFontSize + relSize;
1904 fs.index = true;
1905 } else if (value.charAt(0) == '-') {
1906 int relSize = -Integer.valueOf(value.substring(1)).intValue();
1907 fs.value = baseFontSize + relSize;
1908 fs.index = true;
1909 } else {
1910 fs.value = Integer.parseInt(value);
1911 if (fs.value > 7) {
1912 fs.value = 7;
1913 } else if (fs.value < 0) {
1914 fs.value = 0;
1915 }
1916 fs.index = true;
1917 }
1918
1919 } catch (NumberFormatException nfe) {
1920 fs = null;
1921 }
1922 return fs;
1923 }
1924
1925 /**
1926 * Converts a <code>StyleConstants</code> attribute value to
1927 * a CSS attribute value. If there is no conversion
1928 * returns <code>null</code>. By default, there is no conversion.
1929 *
1930 * @param key the <code>StyleConstants</code> attribute
1931 * @param value the value of a <code>StyleConstants</code>
1932 * attribute to be converted
1933 * @return the CSS value that represents the
1934 * <code>StyleConstants</code> value
1935 */
1936 Object fromStyleConstants(StyleConstants key, Object value) {
1937 if (value instanceof Number) {
1938 FontSize fs = new FontSize();
1939
1940 fs.value = getIndexOfSize(((Number)value).floatValue(), StyleSheet.sizeMapDefault);
1941 fs.svalue = Integer.toString((int)fs.value);
1942 fs.index = true;
1943 return fs;
1944 }
1945 return parseCssValue(value.toString());
1946 }
1947
1948 /**
1949 * Converts a CSS attribute value to a <code>StyleConstants</code>
1950 * value. If there is no conversion, returns <code>null</code>.
1951 * By default, there is no conversion.
1952 *
1953 * @param key the <code>StyleConstants</code> attribute
1954 * @return the <code>StyleConstants</code> attribute value that
1955 * represents the CSS attribute value
1956 */
1957 Object toStyleConstants(StyleConstants key, View v) {
1958 if (v != null) {
1959 return Integer.valueOf(getValue(v.getAttributes(), null));
1960 }
1961 return Integer.valueOf(getValue(null, null));
1962 }
1963
1964 float value;
1965 boolean index;
1966 LengthUnit lu;
1967 }
1968
1969 static class FontFamily extends CssValue {
1970
1971 /**
1972 * Returns the font family to use.
1973 */
1974 String getValue() {
1975 return family;
1976 }
1977
1978 Object parseCssValue(String value) {
1979 int cIndex = value.indexOf(',');
1980 FontFamily ff = new FontFamily();
1981 ff.svalue = value;
1982 ff.family = null;
1983
1984 if (cIndex == -1) {
1985 setFontName(ff, value);
1986 }
1987 else {
1988 boolean done = false;
1989 int lastIndex;
1990 int length = value.length();
1991 cIndex = 0;
1992 while (!done) {
1993 // skip ws.
1994 while (cIndex < length &&
1995 Character.isWhitespace(value.charAt(cIndex)))
1996 cIndex++;
1997 // Find next ','
1998 lastIndex = cIndex;
1999 cIndex = value.indexOf(',', cIndex);
2000 if (cIndex == -1) {
2001 cIndex = length;
2002 }
2003 if (lastIndex < length) {
2004 if (lastIndex != cIndex) {
2005 int lastCharIndex = cIndex;
2006 if (cIndex > 0 && value.charAt(cIndex - 1) == ' '){
2007 lastCharIndex--;
2008 }
2009 setFontName(ff, value.substring
2010 (lastIndex, lastCharIndex));
2011 done = (ff.family != null);
2012 }
2013 cIndex++;
2014 }
2015 else {
2016 done = true;
2017 }
2018 }
2019 }
2020 if (ff.family == null) {
2021 ff.family = Font.SANS_SERIF;
2022 }
2023 return ff;
2024 }
2025
2026 private void setFontName(FontFamily ff, String fontName) {
2027 ff.family = fontName;
2028 }
2029
2030 Object parseHtmlValue(String value) {
2031 // TBD
2032 return parseCssValue(value);
2033 }
2034
2035 /**
2036 * Converts a <code>StyleConstants</code> attribute value to
2037 * a CSS attribute value. If there is no conversion
2038 * returns <code>null</code>. By default, there is no conversion.
2039 *
2040 * @param key the <code>StyleConstants</code> attribute
2041 * @param value the value of a <code>StyleConstants</code>
2042 * attribute to be converted
2043 * @return the CSS value that represents the
2044 * <code>StyleConstants</code> value
2045 */
2046 Object fromStyleConstants(StyleConstants key, Object value) {
2047 return parseCssValue(value.toString());
2048 }
2049
2050 /**
2051 * Converts a CSS attribute value to a <code>StyleConstants</code>
2052 * value. If there is no conversion, returns <code>null</code>.
2053 * By default, there is no conversion.
2054 *
2055 * @param key the <code>StyleConstants</code> attribute
2056 * @return the <code>StyleConstants</code> attribute value that
2057 * represents the CSS attribute value
2058 */
2059 Object toStyleConstants(StyleConstants key, View v) {
2060 return family;
2061 }
2062
2063 String family;
2064 }
2065
2066 static class FontWeight extends CssValue {
2067
2068 int getValue() {
2069 return weight;
2070 }
2071
2072 Object parseCssValue(String value) {
2073 FontWeight fw = new FontWeight();
2074 fw.svalue = value;
2075 if (value.equals("bold")) {
2076 fw.weight = 700;
2077 } else if (value.equals("normal")) {
2078 fw.weight = 400;
2079 } else {
2080 // PENDING(prinz) add support for relative values
2081 try {
2082 fw.weight = Integer.parseInt(value);
2083 } catch (NumberFormatException nfe) {
2084 fw = null;
2085 }
2086 }
2087 return fw;
2088 }
2089
2090 /**
2091 * Converts a <code>StyleConstants</code> attribute value to
2092 * a CSS attribute value. If there is no conversion
2093 * returns <code>null</code>. By default, there is no conversion.
2094 *
2095 * @param key the <code>StyleConstants</code> attribute
2096 * @param value the value of a <code>StyleConstants</code>
2097 * attribute to be converted
2098 * @return the CSS value that represents the
2099 * <code>StyleConstants</code> value
2100 */
2101 Object fromStyleConstants(StyleConstants key, Object value) {
2102 if (value.equals(Boolean.TRUE)) {
2103 return parseCssValue("bold");
2104 }
2105 return parseCssValue("normal");
2106 }
2107
2108 /**
2109 * Converts a CSS attribute value to a <code>StyleConstants</code>
2110 * value. If there is no conversion, returns <code>null</code>.
2111 * By default, there is no conversion.
2112 *
2113 * @param key the <code>StyleConstants</code> attribute
2114 * @return the <code>StyleConstants</code> attribute value that
2115 * represents the CSS attribute value
2116 */
2117 Object toStyleConstants(StyleConstants key, View v) {
2118 return (weight > 500) ? Boolean.TRUE : Boolean.FALSE;
2119 }
2120
2121 boolean isBold() {
2122 return (weight > 500);
2123 }
2124
2125 int weight;
2126 }
2127
2128 static class ColorValue extends CssValue {
2129
2130 /**
2131 * Returns the color to use.
2132 */
2133 Color getValue() {
2134 return c;
2135 }
2136
2137 Object parseCssValue(String value) {
2138
2139 Color c = stringToColor(value);
2140 if (c != null) {
2141 ColorValue cv = new ColorValue();
2142 cv.svalue = value;
2143 cv.c = c;
2144 return cv;
2145 }
2146 return null;
2147 }
2148
2149 Object parseHtmlValue(String value) {
2150 return parseCssValue(value);
2151 }
2152
2153 /**
2154 * Converts a <code>StyleConstants</code> attribute value to
2155 * a CSS attribute value. If there is no conversion
2156 * returns <code>null</code>. By default, there is no conversion.
2157 *
2158 * @param key the <code>StyleConstants</code> attribute
2159 * @param value the value of a <code>StyleConstants</code>
2160 * attribute to be converted
2161 * @return the CSS value that represents the
2162 * <code>StyleConstants</code> value
2163 */
2164 Object fromStyleConstants(StyleConstants key, Object value) {
2165 ColorValue colorValue = new ColorValue();
2166 colorValue.c = (Color)value;
2167 colorValue.svalue = colorToHex(colorValue.c);
2168 return colorValue;
2169 }
2170
2171 /**
2172 * Converts a CSS attribute value to a <code>StyleConstants</code>
2173 * value. If there is no conversion, returns <code>null</code>.
2174 * By default, there is no conversion.
2175 *
2176 * @param key the <code>StyleConstants</code> attribute
2177 * @return the <code>StyleConstants</code> attribute value that
2178 * represents the CSS attribute value
2179 */
2180 Object toStyleConstants(StyleConstants key, View v) {
2181 return c;
2182 }
2183
2184 Color c;
2185 }
2186
2187 static class BorderStyle extends CssValue {
2188
2189 CSS.Value getValue() {
2190 return style;
2191 }
2192
2193 Object parseCssValue(String value) {
2194 CSS.Value cssv = CSS.getValue(value);
2195 if (cssv != null) {
2196 if ((cssv == CSS.Value.INSET) ||
2197 (cssv == CSS.Value.OUTSET) ||
2198 (cssv == CSS.Value.NONE) ||
2199 (cssv == CSS.Value.DOTTED) ||
2200 (cssv == CSS.Value.DASHED) ||
2201 (cssv == CSS.Value.SOLID) ||
2202 (cssv == CSS.Value.DOUBLE) ||
2203 (cssv == CSS.Value.GROOVE) ||
2204 (cssv == CSS.Value.RIDGE)) {
2205
2206 BorderStyle bs = new BorderStyle();
2207 bs.svalue = value;
2208 bs.style = cssv;
2209 return bs;
2210 }
2211 }
2212 return null;
2213 }
2214
2215 private void writeObject(java.io.ObjectOutputStream s)
2216 throws IOException {
2217 s.defaultWriteObject();
2218 if (style == null) {
2219 s.writeObject(null);
2220 }
2221 else {
2222 s.writeObject(style.toString());
2223 }
2224 }
2225
2226 private void readObject(ObjectInputStream s)
2227 throws ClassNotFoundException, IOException {
2228 s.defaultReadObject();
2229 Object value = s.readObject();
2230 if (value != null) {
2231 style = CSS.getValue((String)value);
2232 }
2233 }
2234
2235 // CSS.Values are static, don't archive it.
2236 transient private CSS.Value style;
2237 }
2238
2239 static class LengthValue extends CssValue {
2240
2241 /**
2242 * if this length value may be negative.
2243 */
2244 boolean mayBeNegative;
2245
2246 LengthValue() {
2247 this(false);
2248 }
2249
2250 LengthValue(boolean mayBeNegative) {
2251 this.mayBeNegative = mayBeNegative;
2252 }
2253
2254 /**
2255 * Returns the length (span) to use.
2256 */
2257 float getValue() {
2258 return getValue(false);
2259 }
2260
2261 float getValue(boolean isW3CLengthUnits) {
2262 return getValue(0, isW3CLengthUnits);
2263 }
2264
2265 /**
2266 * Returns the length (span) to use. If the value represents
2267 * a percentage, it is scaled based on <code>currentValue</code>.
2268 */
2269 float getValue(float currentValue) {
2270 return getValue(currentValue, false);
2271 }
2272 float getValue(float currentValue, boolean isW3CLengthUnits) {
2273 if (percentage) {
2274 return span * currentValue;
2275 }
2276 return LengthUnit.getValue(span, units, isW3CLengthUnits);
2277 }
2278
2279 /**
2280 * Returns true if the length represents a percentage of the
2281 * containing box.
2282 */
2283 boolean isPercentage() {
2284 return percentage;
2285 }
2286
2287 Object parseCssValue(String value) {
2288 LengthValue lv;
2289 try {
2290 // Assume pixels
2291 float absolute = Float.valueOf(value).floatValue();
2292 lv = new LengthValue();
2293 lv.span = absolute;
2294 } catch (NumberFormatException nfe) {
2295 // Not pixels, use LengthUnit
2296 LengthUnit lu = new LengthUnit(value,
2297 LengthUnit.UNINITALIZED_LENGTH,
2298 0);
2299
2300 // PENDING: currently, we only support absolute values and
2301 // percentages.
2302 switch (lu.type) {
2303 case 0:
2304 // Absolute
2305 lv = new LengthValue();
2306 lv.span =
2307 (mayBeNegative) ? lu.value : Math.max(0, lu.value);
2308 lv.units = lu.units;
2309 break;
2310 case 1:
2311 // %
2312 lv = new LengthValue();
2313 lv.span = Math.max(0, Math.min(1, lu.value));
2314 lv.percentage = true;
2315 break;
2316 default:
2317 return null;
2318 }
2319 }
2320 lv.svalue = value;
2321 return lv;
2322 }
2323
2324 Object parseHtmlValue(String value) {
2325 if (value.equals(HTML.NULL_ATTRIBUTE_VALUE)) {
2326 value = "1";
2327 }
2328 return parseCssValue(value);
2329 }
2330 /**
2331 * Converts a <code>StyleConstants</code> attribute value to
2332 * a CSS attribute value. If there is no conversion,
2333 * returns <code>null</code>. By default, there is no conversion.
2334 *
2335 * @param key the <code>StyleConstants</code> attribute
2336 * @param value the value of a <code>StyleConstants</code>
2337 * attribute to be converted
2338 * @return the CSS value that represents the
2339 * <code>StyleConstants</code> value
2340 */
2341 Object fromStyleConstants(StyleConstants key, Object value) {
2342 LengthValue v = new LengthValue();
2343 v.svalue = value.toString();
2344 v.span = ((Float)value).floatValue();
2345 return v;
2346 }
2347
2348 /**
2349 * Converts a CSS attribute value to a <code>StyleConstants</code>
2350 * value. If there is no conversion, returns <code>null</code>.
2351 * By default, there is no conversion.
2352 *
2353 * @param key the <code>StyleConstants</code> attribute
2354 * @return the <code>StyleConstants</code> attribute value that
2355 * represents the CSS attribute value
2356 */
2357 Object toStyleConstants(StyleConstants key, View v) {
2358 return new Float(getValue(false));
2359 }
2360
2361 /** If true, span is a percentage value, and that to determine
2362 * the length another value needs to be passed in. */
2363 boolean percentage;
2364 /** Either the absolute value (percentage == false) or
2365 * a percentage value. */
2366 float span;
2367
2368 String units = null;
2369 }
2370
2371
2372 /**
2373 * BorderWidthValue is used to model BORDER_XXX_WIDTH and adds support
2374 * for the thin/medium/thick values.
2375 */
2376 static class BorderWidthValue extends LengthValue {
2377 BorderWidthValue(String svalue, int index) {
2378 this.svalue = svalue;
2379 span = values[index];
2380 percentage = false;
2381 }
2382
2383 Object parseCssValue(String value) {
2384 if (value != null) {
2385 if (value.equals("thick")) {
2386 return new BorderWidthValue(value, 2);
2387 }
2388 else if (value.equals("medium")) {
2389 return new BorderWidthValue(value, 1);
2390 }
2391 else if (value.equals("thin")) {
2392 return new BorderWidthValue(value, 0);
2393 }
2394 }
2395 // Assume its a length.
2396 return super.parseCssValue(value);
2397 }
2398
2399 Object parseHtmlValue(String value) {
2400 if (value == HTML.NULL_ATTRIBUTE_VALUE) {
2401 return parseCssValue("medium");
2402 }
2403 return parseCssValue(value);
2404 }
2405
2406 /** Values used to represent border width. */
2407 private static final float[] values = { 1, 2, 4 };
2408 }
2409
2410
2411 /**
2412 * Handles uniquing of CSS values, like lists, and background image
2413 * repeating.
2414 */
2415 static class CssValueMapper extends CssValue {
2416 Object parseCssValue(String value) {
2417 Object retValue = cssValueToInternalValueMap.get(value);
2418 if (retValue == null) {
2419 retValue = cssValueToInternalValueMap.get(value.toLowerCase());
2420 }
2421 return retValue;
2422 }
2423
2424
2425 Object parseHtmlValue(String value) {
2426 Object retValue = htmlValueToCssValueMap.get(value);
2427 if (retValue == null) {
2428 retValue = htmlValueToCssValueMap.get(value.toLowerCase());
2429 }
2430 return retValue;
2431 }
2432 }
2433
2434
2435 /**
2436 * Used for background images, to represent the position.
2437 */
2438 static class BackgroundPosition extends CssValue {
2439 float horizontalPosition;
2440 float verticalPosition;
2441 // bitmask: bit 0, horizontal relative, bit 1 horizontal relative to
2442 // font size, 2 vertical relative to size, 3 vertical relative to
2443 // font size.
2444 //
2445 short relative;
2446
2447 Object parseCssValue(String value) {
2448 // 'top left' and 'left top' both mean the same as '0% 0%'.
2449 // 'top', 'top center' and 'center top' mean the same as '50% 0%'.
2450 // 'right top' and 'top right' mean the same as '100% 0%'.
2451 // 'left', 'left center' and 'center left' mean the same as
2452 // '0% 50%'.
2453 // 'center' and 'center center' mean the same as '50% 50%'.
2454 // 'right', 'right center' and 'center right' mean the same as
2455 // '100% 50%'.
2456 // 'bottom left' and 'left bottom' mean the same as '0% 100%'.
2457 // 'bottom', 'bottom center' and 'center bottom' mean the same as
2458 // '50% 100%'.
2459 // 'bottom right' and 'right bottom' mean the same as '100% 100%'.
2460 String[] strings = CSS.parseStrings(value);
2461 int count = strings.length;
2462 BackgroundPosition bp = new BackgroundPosition();
2463 bp.relative = 5;
2464 bp.svalue = value;
2465
2466 if (count > 0) {
2467 // bit 0 for vert, 1 hor, 2 for center
2468 short found = 0;
2469 int index = 0;
2470 while (index < count) {
2471 // First, check for keywords
2472 String string = strings[index++];
2473 if (string.equals("center")) {
2474 found |= 4;
2475 continue;
2476 }
2477 else {
2478 if ((found & 1) == 0) {
2479 if (string.equals("top")) {
2480 found |= 1;
2481 }
2482 else if (string.equals("bottom")) {
2483 found |= 1;
2484 bp.verticalPosition = 1;
2485 continue;
2486 }
2487 }
2488 if ((found & 2) == 0) {
2489 if (string.equals("left")) {
2490 found |= 2;
2491 bp.horizontalPosition = 0;
2492 }
2493 else if (string.equals("right")) {
2494 found |= 2;
2495 bp.horizontalPosition = 1;
2496 }
2497 }
2498 }
2499 }
2500 if (found != 0) {
2501 if ((found & 1) == 1) {
2502 if ((found & 2) == 0) {
2503 // vert and no horiz.
2504 bp.horizontalPosition = .5f;
2505 }
2506 }
2507 else if ((found & 2) == 2) {
2508 // horiz and no vert.
2509 bp.verticalPosition = .5f;
2510 }
2511 else {
2512 // no horiz, no vert, but center
2513 bp.horizontalPosition = bp.verticalPosition = .5f;
2514 }
2515 }
2516 else {
2517 // Assume lengths
2518 LengthUnit lu = new LengthUnit(strings[0], (short)0, 0f);
2519
2520 if (lu.type == 0) {
2521 bp.horizontalPosition = lu.value;
2522 bp.relative = (short)(1 ^ bp.relative);
2523 }
2524 else if (lu.type == 1) {
2525 bp.horizontalPosition = lu.value;
2526 }
2527 else if (lu.type == 3) {
2528 bp.horizontalPosition = lu.value;
2529 bp.relative = (short)((1 ^ bp.relative) | 2);
2530 }
2531 if (count > 1) {
2532 lu = new LengthUnit(strings[1], (short)0, 0f);
2533
2534 if (lu.type == 0) {
2535 bp.verticalPosition = lu.value;
2536 bp.relative = (short)(4 ^ bp.relative);
2537 }
2538 else if (lu.type == 1) {
2539 bp.verticalPosition = lu.value;
2540 }
2541 else if (lu.type == 3) {
2542 bp.verticalPosition = lu.value;
2543 bp.relative = (short)((4 ^ bp.relative) | 8);
2544 }
2545 }
2546 else {
2547 bp.verticalPosition = .5f;
2548 }
2549 }
2550 }
2551 return bp;
2552 }
2553
2554 boolean isHorizontalPositionRelativeToSize() {
2555 return ((relative & 1) == 1);
2556 }
2557
2558 boolean isHorizontalPositionRelativeToFontSize() {
2559 return ((relative & 2) == 2);
2560 }
2561
2562 float getHorizontalPosition() {
2563 return horizontalPosition;
2564 }
2565
2566 boolean isVerticalPositionRelativeToSize() {
2567 return ((relative & 4) == 4);
2568 }
2569
2570 boolean isVerticalPositionRelativeToFontSize() {
2571 return ((relative & 8) == 8);
2572 }
2573
2574 float getVerticalPosition() {
2575 return verticalPosition;
2576 }
2577 }
2578
2579
2580 /**
2581 * Used for BackgroundImages.
2582 */
2583 static class BackgroundImage extends CssValue {
2584 private boolean loadedImage;
2585 private ImageIcon image;
2586
2587 Object parseCssValue(String value) {
2588 BackgroundImage retValue = new BackgroundImage();
2589 retValue.svalue = value;
2590 return retValue;
2591 }
2592
2593 Object parseHtmlValue(String value) {
2594 return parseCssValue(value);
2595 }
2596
2597 // PENDING: this base is wrong for linked style sheets.
2598 ImageIcon getImage(URL base) {
2599 if (!loadedImage) {
2600 synchronized(this) {
2601 if (!loadedImage) {
2602 URL url = CSS.getURL(base, svalue);
2603 loadedImage = true;
2604 if (url != null) {
2605 image = new ImageIcon();
2606 Image tmpImg = Toolkit.getDefaultToolkit().createImage(url);
2607 if (tmpImg != null) {
2608 image.setImage(tmpImg);
2609 }
2610 }
2611 }
2612 }
2613 }
2614 return image;
2615 }
2616 }
2617
2618 /**
2619 * Parses a length value, this is used internally, and never added
2620 * to an AttributeSet or returned to the developer.
2621 */
2622 static class LengthUnit implements Serializable {
2623 static Hashtable<String, Float> lengthMapping = new Hashtable<String, Float>(6);
2624 static Hashtable<String, Float> w3cLengthMapping = new Hashtable<String, Float>(6);
2625 static {
2626 lengthMapping.put("pt", new Float(1f));
2627 // Not sure about 1.3, determined by experiementation.
2628 lengthMapping.put("px", new Float(1.3f));
2629 lengthMapping.put("mm", new Float(2.83464f));
2630 lengthMapping.put("cm", new Float(28.3464f));
2631 lengthMapping.put("pc", new Float(12f));
2632 lengthMapping.put("in", new Float(72f));
2633 int res = 72;
2634 try {
2635 res = Toolkit.getDefaultToolkit().getScreenResolution();
2636 } catch (HeadlessException e) {
2637 }
2638 // mapping according to the CSS2 spec
2639 w3cLengthMapping.put("pt", new Float(res/72f));
2640 w3cLengthMapping.put("px", new Float(1f));
2641 w3cLengthMapping.put("mm", new Float(res/25.4f));
2642 w3cLengthMapping.put("cm", new Float(res/2.54f));
2643 w3cLengthMapping.put("pc", new Float(res/6f));
2644 w3cLengthMapping.put("in", new Float(res));
2645 }
2646
2647 LengthUnit(String value, short defaultType, float defaultValue) {
2648 parse(value, defaultType, defaultValue);
2649 }
2650
2651 void parse(String value, short defaultType, float defaultValue) {
2652 type = defaultType;
2653 this.value = defaultValue;
2654
2655 int length = value.length();
2656 if (length > 0 && value.charAt(length - 1) == '%') {
2657 try {
2658 this.value = Float.valueOf(value.substring(0, length - 1)).
2659 floatValue() / 100.0f;
2660 type = 1;
2661 }
2662 catch (NumberFormatException nfe) { }
2663 }
2664 if (length >= 2) {
2665 units = value.substring(length - 2, length);
2666 Float scale = lengthMapping.get(units);
2667 if (scale != null) {
2668 try {
2669 this.value = Float.valueOf(value.substring(0,
2670 length - 2)).floatValue();
2671 type = 0;
2672 }
2673 catch (NumberFormatException nfe) { }
2674 }
2675 else if (units.equals("em") ||
2676 units.equals("ex")) {
2677 try {
2678 this.value = Float.valueOf(value.substring(0,
2679 length - 2)).floatValue();
2680 type = 3;
2681 }
2682 catch (NumberFormatException nfe) { }
2683 }
2684 else if (value.equals("larger")) {
2685 this.value = 2f;
2686 type = 2;
2687 }
2688 else if (value.equals("smaller")) {
2689 this.value = -2;
2690 type = 2;
2691 }
2692 else {
2693 // treat like points.
2694 try {
2695 this.value = Float.valueOf(value).floatValue();
2696 type = 0;
2697 } catch (NumberFormatException nfe) {}
2698 }
2699 }
2700 else if (length > 0) {
2701 // treat like points.
2702 try {
2703 this.value = Float.valueOf(value).floatValue();
2704 type = 0;
2705 } catch (NumberFormatException nfe) {}
2706 }
2707 }
2708
2709 float getValue(boolean w3cLengthUnits) {
2710 Hashtable<String, Float> mapping = (w3cLengthUnits) ? w3cLengthMapping : lengthMapping;
2711 float scale = 1;
2712 if (units != null) {
2713 Float scaleFloat = mapping.get(units);
2714 if (scaleFloat != null) {
2715 scale = scaleFloat.floatValue();
2716 }
2717 }
2718 return this.value * scale;
2719
2720 }
2721
2722 static float getValue(float value, String units, Boolean w3cLengthUnits) {
2723 Hashtable<String, Float> mapping = (w3cLengthUnits) ? w3cLengthMapping : lengthMapping;
2724 float scale = 1;
2725 if (units != null) {
2726 Float scaleFloat = mapping.get(units);
2727 if (scaleFloat != null) {
2728 scale = scaleFloat.floatValue();
2729 }
2730 }
2731 return value * scale;
2732 }
2733
2734 public String toString() {
2735 return type + " " + value;
2736 }
2737
2738 // 0 - value indicates real value
2739 // 1 - % value, value relative to depends upon key.
2740 // 50% will have a value = .5
2741 // 2 - add value to parent value.
2742 // 3 - em/ex relative to font size of element (except for
2743 // font-size, which is relative to parent).
2744 short type;
2745 float value;
2746 String units = null;
2747
2748
2749 static final short UNINITALIZED_LENGTH = (short)10;
2750 }
2751
2752
2753 /**
2754 * Class used to parse font property. The font property is shorthand
2755 * for the other font properties. This expands the properties, placing
2756 * them in the attributeset.
2757 */
2758 static class ShorthandFontParser {
2759 /**
2760 * Parses the shorthand font string <code>value</code>, placing the
2761 * result in <code>attr</code>.
2762 */
2763 static void parseShorthandFont(CSS css, String value,
2764 MutableAttributeSet attr) {
2765 // font is of the form:
2766 // [ <font-style> || <font-variant> || <font-weight> ]? <font-size>
2767 // [ / <line-height> ]? <font-family>
2768 String[] strings = CSS.parseStrings(value);
2769 int count = strings.length;
2770 int index = 0;
2771 // bitmask, 1 for style, 2 for variant, 3 for weight
2772 short found = 0;
2773 int maxC = Math.min(3, count);
2774
2775 // Check for font-style font-variant font-weight
2776 while (index < maxC) {
2777 if ((found & 1) == 0 && isFontStyle(strings[index])) {
2778 css.addInternalCSSValue(attr, CSS.Attribute.FONT_STYLE,
2779 strings[index++]);
2780 found |= 1;
2781 }
2782 else if ((found & 2) == 0 && isFontVariant(strings[index])) {
2783 css.addInternalCSSValue(attr, CSS.Attribute.FONT_VARIANT,
2784 strings[index++]);
2785 found |= 2;
2786 }
2787 else if ((found & 4) == 0 && isFontWeight(strings[index])) {
2788 css.addInternalCSSValue(attr, CSS.Attribute.FONT_WEIGHT,
2789 strings[index++]);
2790 found |= 4;
2791 }
2792 else if (strings[index].equals("normal")) {
2793 index++;
2794 }
2795 else {
2796 break;
2797 }
2798 }
2799 if ((found & 1) == 0) {
2800 css.addInternalCSSValue(attr, CSS.Attribute.FONT_STYLE,
2801 "normal");
2802 }
2803 if ((found & 2) == 0) {
2804 css.addInternalCSSValue(attr, CSS.Attribute.FONT_VARIANT,
2805 "normal");
2806 }
2807 if ((found & 4) == 0) {
2808 css.addInternalCSSValue(attr, CSS.Attribute.FONT_WEIGHT,
2809 "normal");
2810 }
2811
2812 // string at index should be the font-size
2813 if (index < count) {
2814 String fontSize = strings[index];
2815 int slashIndex = fontSize.indexOf('/');
2816
2817 if (slashIndex != -1) {
2818 fontSize = fontSize.substring(0, slashIndex);
2819 strings[index] = strings[index].substring(slashIndex);
2820 }
2821 else {
2822 index++;
2823 }
2824 css.addInternalCSSValue(attr, CSS.Attribute.FONT_SIZE,
2825 fontSize);
2826 }
2827 else {
2828 css.addInternalCSSValue(attr, CSS.Attribute.FONT_SIZE,
2829 "medium");
2830 }
2831
2832 // Check for line height
2833 if (index < count && strings[index].startsWith("/")) {
2834 String lineHeight = null;
2835 if (strings[index].equals("/")) {
2836 if (++index < count) {
2837 lineHeight = strings[index++];
2838 }
2839 }
2840 else {
2841 lineHeight = strings[index++].substring(1);
2842 }
2843 // line height
2844 if (lineHeight != null) {
2845 css.addInternalCSSValue(attr, CSS.Attribute.LINE_HEIGHT,
2846 lineHeight);
2847 }
2848 else {
2849 css.addInternalCSSValue(attr, CSS.Attribute.LINE_HEIGHT,
2850 "normal");
2851 }
2852 }
2853 else {
2854 css.addInternalCSSValue(attr, CSS.Attribute.LINE_HEIGHT,
2855 "normal");
2856 }
2857
2858 // remainder of strings are font-family
2859 if (index < count) {
2860 String family = strings[index++];
2861
2862 while (index < count) {
2863 family += " " + strings[index++];
2864 }
2865 css.addInternalCSSValue(attr, CSS.Attribute.FONT_FAMILY,
2866 family);
2867 }
2868 else {
2869 css.addInternalCSSValue(attr, CSS.Attribute.FONT_FAMILY,
2870 Font.SANS_SERIF);
2871 }
2872 }
2873
2874 private static boolean isFontStyle(String string) {
2875 return (string.equals("italic") ||
2876 string.equals("oblique"));
2877 }
2878
2879 private static boolean isFontVariant(String string) {
2880 return (string.equals("small-caps"));
2881 }
2882
2883 private static boolean isFontWeight(String string) {
2884 if (string.equals("bold") || string.equals("bolder") ||
2885 string.equals("italic") || string.equals("lighter")) {
2886 return true;
2887 }
2888 // test for 100-900
2889 return (string.length() == 3 &&
2890 string.charAt(0) >= '1' && string.charAt(0) <= '9' &&
2891 string.charAt(1) == '0' && string.charAt(2) == '0');
2892 }
2893
2894 }
2895
2896
2897 /**
2898 * Parses the background property into its intrinsic values.
2899 */
2900 static class ShorthandBackgroundParser {
2901 /**
2902 * Parses the shorthand font string <code>value</code>, placing the
2903 * result in <code>attr</code>.
2904 */
2905 static void parseShorthandBackground(CSS css, String value,
2906 MutableAttributeSet attr) {
2907 String[] strings = parseStrings(value);
2908 int count = strings.length;
2909 int index = 0;
2910 // bitmask: 0 for image, 1 repeat, 2 attachment, 3 position,
2911 // 4 color
2912 short found = 0;
2913
2914 while (index < count) {
2915 String string = strings[index++];
2916 if ((found & 1) == 0 && isImage(string)) {
2917 css.addInternalCSSValue(attr, CSS.Attribute.
2918 BACKGROUND_IMAGE, string);
2919 found |= 1;
2920 }
2921 else if ((found & 2) == 0 && isRepeat(string)) {
2922 css.addInternalCSSValue(attr, CSS.Attribute.
2923 BACKGROUND_REPEAT, string);
2924 found |= 2;
2925 }
2926 else if ((found & 4) == 0 && isAttachment(string)) {
2927 css.addInternalCSSValue(attr, CSS.Attribute.
2928 BACKGROUND_ATTACHMENT, string);
2929 found |= 4;
2930 }
2931 else if ((found & 8) == 0 && isPosition(string)) {
2932 if (index < count && isPosition(strings[index])) {
2933 css.addInternalCSSValue(attr, CSS.Attribute.
2934 BACKGROUND_POSITION,
2935 string + " " +
2936 strings[index++]);
2937 }
2938 else {
2939 css.addInternalCSSValue(attr, CSS.Attribute.
2940 BACKGROUND_POSITION, string);
2941 }
2942 found |= 8;
2943 }
2944 else if ((found & 16) == 0 && isColor(string)) {
2945 css.addInternalCSSValue(attr, CSS.Attribute.
2946 BACKGROUND_COLOR, string);
2947 found |= 16;
2948 }
2949 }
2950 if ((found & 1) == 0) {
2951 css.addInternalCSSValue(attr, CSS.Attribute.BACKGROUND_IMAGE,
2952 null);
2953 }
2954 if ((found & 2) == 0) {
2955 css.addInternalCSSValue(attr, CSS.Attribute.BACKGROUND_REPEAT,
2956 "repeat");
2957 }
2958 if ((found & 4) == 0) {
2959 css.addInternalCSSValue(attr, CSS.Attribute.
2960 BACKGROUND_ATTACHMENT, "scroll");
2961 }
2962 if ((found & 8) == 0) {
2963 css.addInternalCSSValue(attr, CSS.Attribute.
2964 BACKGROUND_POSITION, null);
2965 }
2966 // Currently, there is no good way to express this.
2967 /*
2968 if ((found & 16) == 0) {
2969 css.addInternalCSSValue(attr, CSS.Attribute.BACKGROUND_COLOR,
2970 null);
2971 }
2972 */
2973 }
2974
2975 static boolean isImage(String string) {
2976 return (string.startsWith("url(") && string.endsWith(")"));
2977 }
2978
2979 static boolean isRepeat(String string) {
2980 return (string.equals("repeat-x") || string.equals("repeat-y") ||
2981 string.equals("repeat") || string.equals("no-repeat"));
2982 }
2983
2984 static boolean isAttachment(String string) {
2985 return (string.equals("fixed") || string.equals("scroll"));
2986 }
2987
2988 static boolean isPosition(String string) {
2989 return (string.equals("top") || string.equals("bottom") ||
2990 string.equals("left") || string.equals("right") ||
2991 string.equals("center") ||
2992 (string.length() > 0 &&
2993 Character.isDigit(string.charAt(0))));
2994 }
2995
2996 static boolean isColor(String string) {
2997 return (CSS.stringToColor(string) != null);
2998 }
2999 }
3000
3001
3002 /**
3003 * Used to parser margin and padding.
3004 */
3005 static class ShorthandMarginParser {
3006 /**
3007 * Parses the shorthand margin/padding/border string
3008 * <code>value</code>, placing the result in <code>attr</code>.
3009 * <code>names</code> give the 4 instrinsic property names.
3010 */
3011 static void parseShorthandMargin(CSS css, String value,
3012 MutableAttributeSet attr,
3013 CSS.Attribute[] names) {
3014 String[] strings = parseStrings(value);
3015 int count = strings.length;
3016 int index = 0;
3017 switch (count) {
3018 case 0:
3019 // empty string
3020 return;
3021 case 1:
3022 // Identifies all values.
3023 for (int counter = 0; counter < 4; counter++) {
3024 css.addInternalCSSValue(attr, names[counter], strings[0]);
3025 }
3026 break;
3027 case 2:
3028 // 0 & 2 = strings[0], 1 & 3 = strings[1]
3029 css.addInternalCSSValue(attr, names[0], strings[0]);
3030 css.addInternalCSSValue(attr, names[2], strings[0]);
3031 css.addInternalCSSValue(attr, names[1], strings[1]);
3032 css.addInternalCSSValue(attr, names[3], strings[1]);
3033 break;
3034 case 3:
3035 css.addInternalCSSValue(attr, names[0], strings[0]);
3036 css.addInternalCSSValue(attr, names[1], strings[1]);
3037 css.addInternalCSSValue(attr, names[2], strings[2]);
3038 css.addInternalCSSValue(attr, names[3], strings[1]);
3039 break;
3040 default:
3041 for (int counter = 0; counter < 4; counter++) {
3042 css.addInternalCSSValue(attr, names[counter],
3043 strings[counter]);
3044 }
3045 break;
3046 }
3047 }
3048 }
3049
3050 static class ShorthandBorderParser {
3051 static Attribute[] keys = {
3052 Attribute.BORDER_TOP, Attribute.BORDER_RIGHT,
3053 Attribute.BORDER_BOTTOM, Attribute.BORDER_LEFT,
3054 };
3055
3056 static void parseShorthandBorder(MutableAttributeSet attributes,
3057 CSS.Attribute key, String value) {
3058 Object[] parts = new Object[CSSBorder.PARSERS.length];
3059 String[] strings = parseStrings(value);
3060 for (String s : strings) {
3061 boolean valid = false;
3062 for (int i = 0; i < parts.length; i++) {
3063 Object v = CSSBorder.PARSERS[i].parseCssValue(s);
3064 if (v != null) {
3065 if (parts[i] == null) {
3066 parts[i] = v;
3067 valid = true;
3068 }
3069 break;
3070 }
3071 }
3072 if (!valid) {
3073 // Part is non-parseable or occurred more than once.
3074 return;
3075 }
3076 }
3077
3078 // Unspecified parts get default values.
3079 for (int i = 0; i < parts.length; i++) {
3080 if (parts[i] == null) {
3081 parts[i] = CSSBorder.DEFAULTS[i];
3082 }
3083 }
3084
3085 // Dispatch collected values to individual properties.
3086 for (int i = 0; i < keys.length; i++) {
3087 if ((key == Attribute.BORDER) || (key == keys[i])) {
3088 for (int k = 0; k < parts.length; k++) {
3089 attributes.addAttribute(
3090 CSSBorder.ATTRIBUTES[k][i], parts[k]);
3091 }
3092 }
3093 }
3094 }
3095 }
3096
3097 /**
3098 * Calculate the requirements needed to tile the requirements
3099 * given by the iterator that would be tiled. The calculation
3100 * takes into consideration margin and border spacing.
3101 */
3102 static SizeRequirements calculateTiledRequirements(LayoutIterator iter, SizeRequirements r) {
3103 long minimum = 0;
3104 long maximum = 0;
3105 long preferred = 0;
3106 int lastMargin = 0;
3107 int totalSpacing = 0;
3108 int n = iter.getCount();
3109 for (int i = 0; i < n; i++) {
3110 iter.setIndex(i);
3111 int margin0 = lastMargin;
3112 int margin1 = (int) iter.getLeadingCollapseSpan();
3113 totalSpacing += Math.max(margin0, margin1);
3114 preferred += (int) iter.getPreferredSpan(0);
3115 minimum += iter.getMinimumSpan(0);
3116 maximum += iter.getMaximumSpan(0);
3117
3118 lastMargin = (int) iter.getTrailingCollapseSpan();
3119 }
3120 totalSpacing += lastMargin;
3121 totalSpacing += 2 * iter.getBorderWidth();
3122
3123 // adjust for the spacing area
3124 minimum += totalSpacing;
3125 preferred += totalSpacing;
3126 maximum += totalSpacing;
3127
3128 // set return value
3129 if (r == null) {
3130 r = new SizeRequirements();
3131 }
3132 r.minimum = (minimum > Integer.MAX_VALUE) ? Integer.MAX_VALUE : (int)minimum;
3133 r.preferred = (preferred > Integer.MAX_VALUE) ? Integer.MAX_VALUE :(int) preferred;
3134 r.maximum = (maximum > Integer.MAX_VALUE) ? Integer.MAX_VALUE :(int) maximum;
3135 return r;
3136 }
3137
3138 /**
3139 * Calculate a tiled layout for the given iterator.
3140 * This should be done collapsing the neighboring
3141 * margins to be a total of the maximum of the two
3142 * neighboring margin areas as described in the CSS spec.
3143 */
3144 static void calculateTiledLayout(LayoutIterator iter, int targetSpan) {
3145
3146 /*
3147 * first pass, calculate the preferred sizes, adjustments needed because
3148 * of margin collapsing, and the flexibility to adjust the sizes.
3149 */
3150 long preferred = 0;
3151 long currentPreferred;
3152 int lastMargin = 0;
3153 int totalSpacing = 0;
3154 int n = iter.getCount();
3155 int adjustmentWeightsCount = LayoutIterator.WorstAdjustmentWeight + 1;
3156 //max gain we can get adjusting elements with adjustmentWeight <= i
3157 long gain[] = new long[adjustmentWeightsCount];
3158 //max loss we can get adjusting elements with adjustmentWeight <= i
3159 long loss[] = new long[adjustmentWeightsCount];
3160
3161 for (int i = 0; i < adjustmentWeightsCount; i++) {
3162 gain[i] = loss[i] = 0;
3163 }
3164 for (int i = 0; i < n; i++) {
3165 iter.setIndex(i);
3166 int margin0 = lastMargin;
3167 int margin1 = (int) iter.getLeadingCollapseSpan();
3168
3169 iter.setOffset(Math.max(margin0, margin1));
3170 totalSpacing += iter.getOffset();
3171
3172 currentPreferred = (long)iter.getPreferredSpan(targetSpan);
3173 iter.setSpan((int) currentPreferred);
3174 preferred += currentPreferred;
3175 gain[iter.getAdjustmentWeight()] +=
3176 (long)iter.getMaximumSpan(targetSpan) - currentPreferred;
3177 loss[iter.getAdjustmentWeight()] +=
3178 currentPreferred - (long)iter.getMinimumSpan(targetSpan);
3179 lastMargin = (int) iter.getTrailingCollapseSpan();
3180 }
3181 totalSpacing += lastMargin;
3182 totalSpacing += 2 * iter.getBorderWidth();
3183
3184 for (int i = 1; i < adjustmentWeightsCount; i++) {
3185 gain[i] += gain[i - 1];
3186 loss[i] += loss[i - 1];
3187 }
3188
3189 /*
3190 * Second pass, expand or contract by as much as possible to reach
3191 * the target span. This takes the margin collapsing into account
3192 * prior to adjusting the span.
3193 */
3194
3195 // determine the adjustment to be made
3196 int allocated = targetSpan - totalSpacing;
3197 long desiredAdjustment = allocated - preferred;
3198 long adjustmentsArray[] = (desiredAdjustment > 0) ? gain : loss;
3199 desiredAdjustment = Math.abs(desiredAdjustment);
3200 int adjustmentLevel = 0;
3201 for (;adjustmentLevel <= LayoutIterator.WorstAdjustmentWeight;
3202 adjustmentLevel++) {
3203 // adjustmentsArray[] is sorted. I do not bother about
3204 // binary search though
3205 if (adjustmentsArray[adjustmentLevel] >= desiredAdjustment) {
3206 break;
3207 }
3208 }
3209 float adjustmentFactor = 0.0f;
3210 if (adjustmentLevel <= LayoutIterator.WorstAdjustmentWeight) {
3211 desiredAdjustment -= (adjustmentLevel > 0) ?
3212 adjustmentsArray[adjustmentLevel - 1] : 0;
3213 if (desiredAdjustment != 0) {
3214 float maximumAdjustment =
3215 adjustmentsArray[adjustmentLevel] -
3216 ((adjustmentLevel > 0) ?
3217 adjustmentsArray[adjustmentLevel - 1] : 0
3218 );
3219 adjustmentFactor = desiredAdjustment / maximumAdjustment;
3220 }
3221 }
3222 // make the adjustments
3223 int totalOffset = (int)iter.getBorderWidth();
3224 for (int i = 0; i < n; i++) {
3225 iter.setIndex(i);
3226 iter.setOffset( iter.getOffset() + totalOffset);
3227 if (iter.getAdjustmentWeight() < adjustmentLevel) {
3228 iter.setSpan((int)
3229 ((allocated > preferred) ?
3230 Math.floor(iter.getMaximumSpan(targetSpan)) :
3231 Math.ceil(iter.getMinimumSpan(targetSpan))
3232 )
3233 );
3234 } else if (iter.getAdjustmentWeight() == adjustmentLevel) {
3235 int availableSpan = (allocated > preferred) ?
3236 (int) iter.getMaximumSpan(targetSpan) - iter.getSpan() :
3237 iter.getSpan() - (int) iter.getMinimumSpan(targetSpan);
3238 int adj = (int)Math.floor(adjustmentFactor * availableSpan);
3239 iter.setSpan(iter.getSpan() +
3240 ((allocated > preferred) ? adj : -adj));
3241 }
3242 totalOffset = (int) Math.min((long) iter.getOffset() +
3243 (long) iter.getSpan(),
3244 Integer.MAX_VALUE);
3245 }
3246
3247 // while rounding we could lose several pixels.
3248 int roundError = targetSpan - totalOffset -
3249 (int)iter.getTrailingCollapseSpan() -
3250 (int)iter.getBorderWidth();
3251 int adj = (roundError > 0) ? 1 : -1;
3252 roundError *= adj;
3253
3254 boolean canAdjust = true;
3255 while (roundError > 0 && canAdjust) {
3256 // check for infinite loop
3257 canAdjust = false;
3258 int offsetAdjust = 0;
3259 // try to distribute roundError. one pixel per cell
3260 for (int i = 0; i < n; i++) {
3261 iter.setIndex(i);
3262 iter.setOffset(iter.getOffset() + offsetAdjust);
3263 int curSpan = iter.getSpan();
3264 if (roundError > 0) {
3265 int boundGap = (adj > 0) ?
3266 (int)Math.floor(iter.getMaximumSpan(targetSpan)) - curSpan :
3267 curSpan - (int)Math.ceil(iter.getMinimumSpan(targetSpan));
3268 if (boundGap >= 1) {
3269 canAdjust = true;
3270 iter.setSpan(curSpan + adj);
3271 offsetAdjust += adj;
3272 roundError--;
3273 }
3274 }
3275 }
3276 }
3277 }
3278
3279 /**
3280 * An iterator to express the requirements to use when computing
3281 * layout.
3282 */
3283 interface LayoutIterator {
3284
3285 void setOffset(int offs);
3286
3287 int getOffset();
3288
3289 void setSpan(int span);
3290
3291 int getSpan();
3292
3293 int getCount();
3294
3295 void setIndex(int i);
3296
3297 float getMinimumSpan(float parentSpan);
3298
3299 float getPreferredSpan(float parentSpan);
3300
3301 float getMaximumSpan(float parentSpan);
3302
3303 int getAdjustmentWeight(); //0 is the best weight WorstAdjustmentWeight is a worst one
3304
3305 //float getAlignment();
3306
3307 float getBorderWidth();
3308
3309 float getLeadingCollapseSpan();
3310
3311 float getTrailingCollapseSpan();
3312 public static final int WorstAdjustmentWeight = 2;
3313 }
3314
3315 //
3316 // Serialization support
3317 //
3318
3319 private void writeObject(java.io.ObjectOutputStream s)
3320 throws IOException
3321 {
3322 s.defaultWriteObject();
3323
3324 // Determine what values in valueConvertor need to be written out.
3325 Enumeration keys = valueConvertor.keys();
3326 s.writeInt(valueConvertor.size());
3327 if (keys != null) {
3328 while (keys.hasMoreElements()) {
3329 Object key = keys.nextElement();
3330 Object value = valueConvertor.get(key);
3331 if (!(key instanceof Serializable) &&
3332 (key = StyleContext.getStaticAttributeKey(key)) == null) {
3333 // Should we throw an exception here?
3334 key = null;
3335 value = null;
3336 }
3337 else if (!(value instanceof Serializable) &&
3338 (value = StyleContext.getStaticAttributeKey(value)) == null){
3339 // Should we throw an exception here?
3340 key = null;
3341 value = null;
3342 }
3343 s.writeObject(key);
3344 s.writeObject(value);
3345 }
3346 }
3347 }
3348
3349 private void readObject(ObjectInputStream s)
3350 throws ClassNotFoundException, IOException
3351 {
3352 s.defaultReadObject();
3353 // Reconstruct the hashtable.
3354 int numValues = s.readInt();
3355 valueConvertor = new Hashtable<Object, Object>(Math.max(1, numValues));
3356 while (numValues-- > 0) {
3357 Object key = s.readObject();
3358 Object value = s.readObject();
3359 Object staticKey = StyleContext.getStaticAttribute(key);
3360 if (staticKey != null) {
3361 key = staticKey;
3362 }
3363 Object staticValue = StyleContext.getStaticAttribute(value);
3364 if (staticValue != null) {
3365 value = staticValue;
3366 }
3367 if (key != null && value != null) {
3368 valueConvertor.put(key, value);
3369 }
3370 }
3371 }
3372
3373
3374 /*
3375 * we need StyleSheet for resolving lenght units. (see
3376 * isW3CLengthUnits)
3377 * we can not pass stylesheet for handling relative sizes. (do not
3378 * think changing public API is necessary)
3379 * CSS is not likely to be accessed from more then one thread.
3380 * Having local storage for StyleSheet for resolving relative
3381 * sizes is safe
3382 *
3383 * idk 08/30/2004
3384 */
3385 private StyleSheet getStyleSheet(StyleSheet ss) {
3386 if (ss != null) {
3387 styleSheet = ss;
3388 }
3389 return styleSheet;
3390 }
3391 //
3392 // Instance variables
3393 //
3394
3395 /** Maps from CSS key to CssValue. */
3396 private transient Hashtable<Object, Object> valueConvertor;
3397
3398 /** Size used for relative units. */
3399 private int baseFontSize;
3400
3401 private transient StyleSheet styleSheet = null;
3402
3403 static int baseFontSizeIndex = 3;
3404 }