Update of /sources/public/2002/css-validator/org/w3c/css/properties/css In directory hutz:/tmp/cvs-serv25562/org/w3c/css/properties/css Added Files: CssBackground.java CssBackgroundAttachment.java CssBackgroundClip.java CssBackgroundColor.java CssBackgroundConstants.java CssBackgroundImage.java CssBackgroundOrigin.java CssBackgroundPosition.java CssBackgroundRepeat.java CssBackgroundSize.java CssBreakAfter.java CssBreakBefore.java CssBreakInside.java CssColumnCount.java CssColumnFill.java CssColumnGap.java CssColumnRule.java CssColumnRuleColor.java CssColumnRuleStyle.java CssColumnRuleWidth.java CssColumnSpan.java CssColumnWidth.java CssColumns.java CssDisplay.java CssProperties.java CssProperty.java CssZIndex.java Log Message: Implementation of css3-background (partial, missing background-color and background, also borders not done) cf. http://www.w3.org/TR/2009/CR-css3-background-20091217/ moved and corrected implementation of css3-multicol cf. http://www.w3.org/TR/2009/CR-css3-multicol-20091217/ Some reorganization of code. --- NEW FILE: CssColumnFill.java --- // $Id: CssColumnFill.java,v 1.1 2010/01/05 13:49:38 ylafon Exp $ // From Sijtsche de Jong (http://www.w3.org/Consortium/Legal/copyright-software-19980720 package org.w3c.css.properties.css; import org.w3c.css.parser.CssStyle; import org.w3c.css.properties.css3.Css3Style; import org.w3c.css.util.ApplContext; import org.w3c.css.util.InvalidParamException; import org.w3c.css.values.CssExpression; import org.w3c.css.values.CssIdent; import org.w3c.css.values.CssTypes; import org.w3c.css.values.CssValue; import java.util.HashMap; /** * http://www.w3.org/TR/2009/CR-css3-multicol-20091217/#filling-columns * <p/> * There are two strategies for filling columns: columns can either be * balanced, or not. If columns are balanced, UAs should minimize the variation * in column length. Otherwise, columns are filled sequentially and will * therefore end up having different lengths. In any case, the user agent * should try to honor the ÔwidowsÕ and ÔorphansÕ properties. * <p/> * Name: column-fill * Value: auto | balance * Initial: balance * Applies to: multi-column elements * Inherited: no * Percentages: N/A * Media: see below * Computed value: as specified */ public class CssColumnFill extends CssProperty { private static final String propertyName = "column-fill"; CssIdent value; static CssIdent balance; public static HashMap<String, CssIdent> allowed_values; static { balance = CssIdent.getIdent("balance"); allowed_values = new HashMap<String, CssIdent>(); allowed_values.put("balance", balance); allowed_values.put("auto", CssIdent.getIdent("auto")); } /** * Create a new CssColumnWidth */ public CssColumnFill() { value = balance; } /** * Create a new CssColumnFill * * @param ac the context * @param expression The expression for this property * @param check if length check is needed * @throws InvalidParamException Incorrect value */ public CssColumnFill(ApplContext ac, CssExpression expression, boolean check) throws InvalidParamException { setByUser(); CssValue val = expression.getValue(); if (check && expression.getCount() > 1) { throw new InvalidParamException("unrecognize", ac); } if (val.getType() != CssTypes.CSS_IDENT) { throw new InvalidParamException("value", expression.getValue(), getPropertyName(), ac); } // ident, so inherit, or allowed value if (inherit.equals(val)) { value = inherit; } else { val = allowed_values.get(val.toString()); if (val == null) { throw new InvalidParamException("value", expression.getValue(), getPropertyName(), ac); } value = (CssIdent) val; } expression.next(); } public CssColumnFill(ApplContext ac, CssExpression expression) throws InvalidParamException { this(ac, expression, false); } /** * Add this property to the CssStyle * * @param style The CssStyle */ public void addToStyle(ApplContext ac, CssStyle style) { if (((Css3Style) style).cssColumnFill != null) style.addRedefinitionWarning(ac, this); ((Css3Style) style).cssColumnFill = this; } /** * Get this property in the style. * * @param style The style where the property is * @param resolve if true, resolve the style to find this property */ public CssProperty getPropertyInStyle(CssStyle style, boolean resolve) { if (resolve) { return ((Css3Style) style).getColumnFill(); } else { return ((Css3Style) style).cssColumnFill; } } /** * Compares two properties for equality. * * @param property The other property. */ public boolean equals(CssProperty property) { return (property instanceof CssColumnFill && value.equals(((CssColumnFill) property).value)); } /** * Returns the name of this property */ public final String getPropertyName() { return propertyName; } /** * Returns the value of this property */ public Object get() { return value; } /** * Returns true if this property is "softly" inherited */ public boolean isSoftlyInherited() { return (inherit == value); } /** * Returns a string representation of the object */ public String toString() { return value.toString(); } /** * Is the value of this property a default value * It is used by all macro for the function <code>print</code> */ public boolean isDefault() { return (balance == value); } } --- NEW FILE: CssBackground.java --- // // $Id: CssBackground.java,v 1.1 2010/01/05 13:49:37 ylafon Exp $ // From Philippe Le Hegaret (http://www.w3.org/Consortium/Legal/copyright-software-19980720 package org.w3c.css.properties.css; import org.w3c.css.parser.CssStyle; import org.w3c.css.properties.css3.Css3Style; import org.w3c.css.util.ApplContext; import org.w3c.css.util.InvalidParamException; import org.w3c.css.values.CssExpression; import org.w3c.css.values.CssIdent; import org.w3c.css.values.CssTypes; import org.w3c.css.values.CssValue; import static org.w3c.css.values.CssOperator.SPACE; /** * http://www.w3.org/TR/2009/CR-css3-multicol-20091217/#columns * <p/> * Name: columns * Value: <Ôcolumn-widthÕ> || <Ôcolumn-countÕ> * Initial: see individual properties * Applies to: non-replaced block-level elements (except table elements), * table cells, and inline-block elements * Inherited: no * Percentages: N/A * Media: visual * Computed value: see individual properties * <p/> * This is a shorthand property for setting Ôcolumn-widthÕ and Ôcolumn-countÕ. * Omitted values are set to their initial values. * * @see CssColumnWidth * @see CssColumnCount */ public class CssColumns extends CssProperty { private static final String propertyName = "columns"; CssIdent value = null; CssColumnWidth width = null; CssColumnCount count = null; /** * Create a new CssColumns */ public CssColumns() { } /** * Create a new CssColumns * * @param ac the context * @param expression The expression for this property * @param check if checking is enforced * @throws InvalidParamException Incorrect values */ public CssColumns(ApplContext ac, CssExpression expression, boolean check) throws InvalidParamException { CssValue val; char op; int nb_val = expression.getCount(); int nb_auto = 0; if (check && nb_val > 2) { throw new InvalidParamException("unrecognize", ac); } setByUser(); while (!expression.end()) { val = expression.getValue(); op = expression.getOperator(); if (op != SPACE) { throw new InvalidParamException("operator", ((new Character(op)).toString()), ac); } switch (val.getType()) { case CssTypes.CSS_NUMBER: if (count != null) { throw new InvalidParamException("unrecognize", ac); } count = new CssColumnCount(ac, expression); break; case CssTypes.CSS_LENGTH: if (width != null) { throw new InvalidParamException("unrecognize", ac); } width = new CssColumnWidth(ac, expression); break; case CssTypes.CSS_IDENT: if (inherit.equals((CssIdent) val)) { if (nb_val > 1) { throw new InvalidParamException("unrecognize", ac); } value = inherit; expression.next(); break; } if (CssColumnCount.auto.equals((CssIdent) val)) { nb_auto++; expression.next(); break; } default: throw new InvalidParamException("value", expression.getValue(), getPropertyName(), ac); } } if (nb_val == 1) { if (nb_auto == 1) { value = CssIdent.getIdent("auto"); } } else { if (nb_auto == 2) { count = new CssColumnCount(); width = new CssColumnWidth(); } else if (nb_auto == 1) { if (count != null) { width = new CssColumnWidth(); } else { count = new CssColumnCount(); } } } } public CssColumns(ApplContext ac, CssExpression expression) throws InvalidParamException { this(ac, expression, false); } /** * Add this property to the CssStyle * * @param style The CssStyle */ public void addToStyle(ApplContext ac, CssStyle style) { if (((Css3Style) style).cssColumns != null) style.addRedefinitionWarning(ac, this); ((Css3Style) style).cssColumns = this; if (count != null) { count.addToStyle(ac, style); } if (width != null) { width.addToStyle(ac, style); } } /** * Get this property in the style. * * @param style The style where the property is * @param resolve if true, resolve the style to find this property */ public CssProperty getPropertyInStyle(CssStyle style, boolean resolve) { if (resolve) { return ((Css3Style) style).getColumns(); } else { return ((Css3Style) style).cssColumns; } } /** * Compares two properties for equality. * * @param property The other property. */ public boolean equals(CssProperty property) { return false; } /** * Returns the name of this property */ public final String getPropertyName() { return propertyName; } /** * Returns the value of this property */ public Object get() { // TODO must use a compound value, like in background properties return value; } /** * Returns true if this property is "softly" inherited */ public boolean isSoftlyInherited() { return (inherit == value); } /** * Returns a string representation of the object */ public String toString() { StringBuilder sb = new StringBuilder(); boolean first = true; if (value != null) { return value.toString(); } if (count != null) { sb.append(count); first = false; } if (width != null) { if (!first) { sb.append(' '); } sb.append(width); } return sb.toString(); } } --- NEW FILE: CssBackgroundPosition.java --- // $Id: CssBackgroundPosition.java,v 1.1 2010/01/05 13:49:37 ylafon Exp $ // From Philippe Le Hegaret (http://www.w3.org/TR/2009/CR-css3-background-20091217/#background-position * * Name: background-position * Value: <bg-position> [ , <bg-position> ]* * Initial: 0% 0% * Applies to: all elements * Inherited: no * Percentages: refer to size of background positioning area minus size of * background image; see text * Media: visual * Computed value: If one or two values are specified, for a <length> * the absolute value, otherwise a percentage. If three or * four values are specified, two pairs of a keyword plus a * length or percentage. * <p/> * <p/> * If background images have been specified, this property specifies their * initial position (after any resizing) within their corresponding * background positioning area. * <p/> * Where * <p/> * <bg-position> = [ * [ [ <percentage> | <length> | left | center | right ] ] * [ [ <percentage> | <length> | top | center | bottom ] ]? * | * [ center | [ left | right ] [ <percentage> | <length> ]? ] || * [ center | [ top | bottom ] [ <percentage> | <length> ]? ] * ] */ public class CssBackgroundPosition extends CssProperty { private static final String propertyName = "background-position"; public static HashMap<String, CssIdent> allowed_values; public static CssIdent center, top, bottom, left, right; private static CssPercentage defaultPercent0, defaultPercent50; private static CssPercentage defaultPercent100; static { top = CssIdent.getIdent("top"); bottom = CssIdent.getIdent("bottom"); left = CssIdent.getIdent("left"); right = CssIdent.getIdent("right"); center = CssIdent.getIdent("center"); allowed_values = new HashMap<String, CssIdent>(); allowed_values.put("top", top); allowed_values.put("bottom", bottom); allowed_values.put("left", left); allowed_values.put("right", right); allowed_values.put("center", center); defaultPercent0 = new CssPercentage(0); defaultPercent50 = new CssPercentage(50); defaultPercent100 = new CssPercentage(100); } Object value; /** * Create a new CssBackgroundPosition */ public CssBackgroundPosition() { value = new CssBackgroundPositionValue(); } /** * Creates a new CssBackgroundPosition * * @param expression The expression for this property * @throws InvalidParamException Values are incorrect */ public CssBackgroundPosition(ApplContext ac, CssExpression expression, boolean check) throws InvalidParamException { setByUser(); CssValue val; ArrayList<CssBackgroundPositionValue> values; CssBackgroundPositionValue b_val = null; char op; values = new ArrayList<CssBackgroundPositionValue>(); // we just accumulate values and check at validation while (!expression.end()) { val = expression.getValue(); op = expression.getOperator(); if (inherit.equals(val)) { if (expression.getCount() > 1) { throw new InvalidParamException("value", val, getPropertyName(), ac); } value = inherit; expression.next(); return; } if (b_val == null) { b_val = new CssBackgroundPositionValue(); } // we will check later b_val.add(val); expression.next(); if (!expression.end()) { // incomplete value followed by a comma... it's complete! if (op == COMMA) { check(b_val, ac); values.add(b_val); b_val = null; } else if (op != SPACE) { throw new InvalidParamException("operator", ((new Character(op)).toString()), ac); } } } // if we reach the end in a value that can come in pair if (b_val != null) { check(b_val, ac); values.add(b_val); } if (values.size() == 1) { value = values.get(0); } else { value = values; } } public CssBackgroundPosition(ApplContext ac, CssExpression expression) throws InvalidParamException { this(ac, expression, false); } /** * Returns the value of this property */ public Object get() { return value; } /** * Returns the name of this property */ public final String getPropertyName() { return propertyName; } /** * Returns true if this property is "softly" inherited * e.g. his value equals inherit */ public boolean isSoftlyInherited() { return (inherit == value); } /** * Returns a string representation of the object. */ public String toString() { if (value instanceof ArrayList) { ArrayList v_list; v_list = (ArrayList) value; StringBuilder sb = new StringBuilder(); for (Object val : v_list) { sb.append(val.toString()).append(", "); } sb.setLength(sb.length() - 2); return sb.toString(); } return value.toString(); } /** * Add this property to the CssStyle. * * @param style The CssStyle */ public void addToStyle(ApplContext ac, CssStyle style) { CssBackground cssBackground = ((Css1Style) style).cssBackground; if (cssBackground.position != null) style.addRedefinitionWarning(ac, this); cssBackground.position = this; } /** * Get this property in the style. * * @param style The style where the property is * @param resolve if true, resolve the style to find this property */ public CssProperty getPropertyInStyle(CssStyle style, boolean resolve) { if (resolve) { return ((Css1Style) style).getBackgroundPosition(); } else { return ((Css1Style) style).cssBackground.position; } } /** * Compares two properties for equality. * * @param property The other property. */ public boolean equals(CssProperty property) { return ((property != null) && (property instanceof CssBackgroundPosition) && (value.equals(((CssBackgroundPosition) property).value))); } /** * Is the value of this property is a default value. * It is used by all macro for the function <code>print</code> */ public boolean isDefault() { if (!(value instanceof CssBackgroundPositionValue)) { return false; } CssBackgroundPositionValue v = (CssBackgroundPositionValue) value; return ((v.val_vertical == defaultPercent0) && (v.val_horizontal == defaultPercent0) && (v.vertical_offset == null) && (v.horizontal_offset == null)); } public void check(CssBackgroundPositionValue v, ApplContext ac) throws InvalidParamException { int nb_keyword = 0; int nb_percentage = 0; int nb_length = 0; int nb_values = v.value.size(); if (nb_values > 4) { throw new InvalidParamException("unrecognize", ac); } // basic check for (CssValue aValue : v.value) { switch (aValue.getType()) { case CssTypes.CSS_NUMBER: aValue = ((CssNumber) aValue).getLength(); case CssTypes.CSS_LENGTH: nb_length++; break; case CssTypes.CSS_PERCENTAGE: nb_percentage++; break; case CssTypes.CSS_IDENT: nb_keyword++; break; default: throw new InvalidParamException("unrecognize", aValue, ac); } } if ((nb_keyword > 2) || (nb_length > 2) || (nb_percentage > 2)) { throw new InvalidParamException("unrecognize", ac); } // this is unnecessary complex, blame it on the CSS3 spec. switch (nb_keyword) { case 0: // no keyword, so it's easy, it depends on the number // of values :) switch (nb_values) { case 1: // If only one value is specified, the second value // is assumed to be ÔcenterÕ. v.horizontal = v.value.get(0); if (v.horizontal.getType() == CssTypes.CSS_NUMBER) { v.horizontal = defaultPercent0; } v.val_horizontal = v.horizontal; v.val_vertical = defaultPercent50; break; case 2: v.horizontal = v.value.get(0); if (v.horizontal.getType() == CssTypes.CSS_NUMBER) { v.horizontal = defaultPercent0; } v.val_horizontal = v.horizontal; v.vertical = v.value.get(1); if (v.vertical.getType() == CssTypes.CSS_NUMBER) { v.vertical = defaultPercent0; } v.val_vertical = v.vertical; break; default: // If three or four values are given, then each // <percentage> or<length> represents an offset and // must be preceded by a keyword throw new InvalidParamException("unrecognize", ac); } break; // we got one keyword... let's have fun... case 1: switch (nb_values) { case 1: CssIdent ident = (CssIdent) v.value.get(0); // ugly as we need to set values for equality tests v.val_vertical = defaultPercent50; v.val_horizontal = defaultPercent50; ident = allowed_values.get(ident.toString()); if (ident != null) { if (isVertical(ident)) { v.vertical = ident; v.val_vertical = identToPercent(ident); } else { // horizontal || center v.horizontal = ident; v.val_horizontal = identToPercent(ident); } break; } throw new InvalidParamException("unrecognize", ident, propertyName, ac); case 2: // one ident, two values... first MUST be horizontal // and second vertical CssValue val0 = v.value.get(0); if (val0.getType() == CssTypes.CSS_IDENT) { ident = allowed_values.get(val0.toString()); if (ident == null) { throw new InvalidParamException("unrecognize", ident, propertyName, ac); } if (isVertical(ident)) { throw new InvalidParamException("incompatible", ident, v.value.get(1), ac); } v.horizontal = ident; v.val_horizontal = identToPercent(ident); // and the vertical value... v.vertical = v.value.get(1); if (v.vertical.getType() == CssTypes.CSS_NUMBER) { v.vertical = defaultPercent0; } v.val_vertical = v.vertical; } else { ident = allowed_values.get(v.value.get(1).toString()); if (ident == null) { throw new InvalidParamException("unrecognize", ident, propertyName, ac); } if (isHorizontal(ident)) { throw new InvalidParamException("incompatible", val0, v.value.get(1), ac); } v.vertical = ident; v.val_vertical = identToPercent(ident); // and the first value v.horizontal = val0; if (v.horizontal.getType() == CssTypes.CSS_NUMBER) { v.horizontal = defaultPercent0; } v.val_horizontal = v.horizontal; } break; default: // one ident, 3 or 4 values is not allowed throw new InvalidParamException("unrecognize", ac); } break; default: // ok so we have two keywords, with possible offsets // we must check that every possible offset is right // after a keyword and also that the two keywords are // not incompatible boolean got_ident = false; CssIdent id1 = null; CssIdent id2 = null; CssValue off1 = null; CssValue off2 = null; for (CssValue aValue : v.value) { switch (aValue.getType()) { case CssTypes.CSS_IDENT: aValue = allowed_values.get(aValue.toString()); if (aValue == null) { throw new InvalidParamException("unrecognize", aValue, propertyName, ac); } got_ident = true; if (id1 == null) { id1 = (CssIdent) aValue; } else { id2 = (CssIdent) aValue; // we got both, let's check. if (((isVertical(id1) && isVertical(id2))) || (isHorizontal(id1) && isHorizontal(id2))) { throw new InvalidParamException("incompatible", id1, id2, ac); } } break; case CssTypes.CSS_NUMBER: aValue = ((CssNumber) aValue).getPercentage(); case CssTypes.CSS_PERCENTAGE: case CssTypes.CSS_LENGTH: if (!got_ident) { throw new InvalidParamException("unrecognize", aValue, propertyName, ac); } if (id2 == null) { off2 = aValue; } else { off1 = aValue; } got_ident = false; break; default: // should never happen } } if (isVertical(id1) || isHorizontal(id2)) { v.horizontal = id2; v.val_horizontal = identToPercent(id2); v.horizontal_offset = off2; v.vertical = id1; v.val_vertical = identToPercent(id1); v.vertical_offset = off1; } else { v.horizontal = id1; v.val_horizontal = identToPercent(id1); v.horizontal_offset = off1; v.vertical = id2; v.val_vertical = identToPercent(id2); v.vertical_offset = off2; } } } public static CssPercentage identToPercent(CssIdent ident) { if (center.equals(ident)) { return defaultPercent50; } else if (top.equals(ident) || left.equals(ident)) { return defaultPercent0; } else if (bottom.equals(ident) || right.equals(ident)) { return defaultPercent100; } return defaultPercent0; // FIXME throw an exception ? } public static boolean isHorizontal(CssIdent ident) { return (left.equals(ident) || right.equals(ident)); } public static boolean isVertical(CssIdent ident) { return (top.equals(ident) || bottom.equals(ident)); } // placeholder for the different values public class CssBackgroundPositionValue extends CssValueList { public CssValue vertical = null; public CssValue horizontal = null; public CssValue vertical_offset = null; public CssValue horizontal_offset = null; public CssValue val_vertical = defaultPercent0; public CssValue val_horizontal = defaultPercent0; public boolean equals(CssBackgroundPositionValue v) { // check vertical compatibility (with optional values) if (!val_vertical.equals(v.val_vertical)) { return false; } if (vertical_offset != null) { if (!vertical_offset.equals(v.vertical_offset)) { return false; } } else if (v.vertical_offset != null) { return false; } if (!val_horizontal.equals(v.val_horizontal)) { return false; } if (horizontal_offset != null) { if (!horizontal_offset.equals(v.horizontal_offset)) { return false; } } else if (v.horizontal_offset != null) { return false; } // yeah! return true; } public String toString() { StringBuilder sb = new StringBuilder(); if (horizontal != null) { sb.append(horizontal); if (horizontal_offset != null) { sb.append(' ').append(horizontal_offset); } if (vertical != null) { sb.append(' '); } } if (vertical != null) { sb.append(vertical); if (vertical_offset != null) { sb.append(' ').append(vertical_offset); } } return sb.toString(); } } } --- NEW FILE: CssColumnRule.java --- // $Id: CssColumnRule.java,v 1.1 2010/01/05 13:49:38 ylafon Exp $ // From Sijtsche de Jong (http://www.w3.org/Consortium/Legal/copyright-software-19980720 package org.w3c.css.properties.css; import org.w3c.css.parser.CssStyle; import org.w3c.css.properties.css3.Css3Style; import org.w3c.css.util.ApplContext; import org.w3c.css.util.InvalidParamException; import org.w3c.css.values.CssExpression; import org.w3c.css.values.CssIdent; import org.w3c.css.values.CssTypes; import org.w3c.css.values.CssValue; import static org.w3c.css.values.CssOperator.SPACE; /** * http://www.w3.org/TR/2009/CR-css3-multicol-20091217/#column-rule * <p/> * Name: column-rule * Value: <column-rule-width> || <border-style> || * [ <color> | transparent ] * Initial: see individual properties * Applies to: multicol elements * Inherited: no * Percentages: N/A * Media: visual * Computed value: see individual properties * <p/> * This property is a shorthand for setting Ôcolumn-rule-widthÕ, * Ôcolumn-rule-styleÕ, and Ôcolumn-rule-colorÕ at the same place in the * style sheet. Omitted values are set to their initial values. */ public class CssColumnRule extends CssProperty { private static final String propertyName = "column-rule"; CssIdent value = null; CssColumnRuleWidth rule_width = null; CssColumnRuleStyle rule_style = null; CssColumnRuleColor rule_color = null; /** * Create a new CssColumnRule */ public CssColumnRule() { } /** * Create a new CssColumnRule * * @param expression The expression for this property * @throws InvalidParamException Incorrect values */ public CssColumnRule(ApplContext ac, CssExpression expression, boolean check) throws InvalidParamException { CssValue val; char op; int nb_val = expression.getCount(); if (check && nb_val > 3) { throw new InvalidParamException("unrecognize", ac); } setByUser(); while (!expression.end()) { val = expression.getValue(); op = expression.getOperator(); if (op != SPACE) { throw new InvalidParamException("operator", ((new Character(op)).toString()), ac); } switch (val.getType()) { case CssTypes.CSS_FUNCTION: case CssTypes.CSS_COLOR: if (rule_color != null) { throw new InvalidParamException("unrecognize", ac); } rule_color = new CssColumnRuleColor(ac, expression); break; case CssTypes.CSS_NUMBER: case CssTypes.CSS_LENGTH: if (rule_width != null) { throw new InvalidParamException("unrecognize", ac); } rule_width = new CssColumnRuleWidth(ac, expression); break; case CssTypes.CSS_IDENT: if (inherit.equals(val)) { if (nb_val > 1) { throw new InvalidParamException("unrecognize", ac); } value = inherit; expression.next(); break; } if (rule_color == null) { try { rule_color = new CssColumnRuleColor(ac, expression); break; } catch (Exception ex) { } } if (rule_width == null) { try { rule_width = new CssColumnRuleWidth(ac, expression); break; } catch (Exception ex) { } } if (rule_style == null) { try { rule_style = new CssColumnRuleStyle(ac, expression); break; } catch (Exception ex) { } } default: throw new InvalidParamException("value", expression.getValue(), getPropertyName(), ac); } } } public CssColumnRule(ApplContext ac, CssExpression expression) throws InvalidParamException { this(ac, expression, false); } /** * Add this property to the CssStyle * * @param style The CssStyle */ public void addToStyle(ApplContext ac, CssStyle style) { if (((Css3Style) style).cssColumnRule != null) style.addRedefinitionWarning(ac, this); ((Css3Style) style).cssColumnRule = this; if (rule_style != null) { rule_style.addToStyle(ac, style); } if (rule_color != null) { rule_color.addToStyle(ac, style); } if (rule_width != null) { rule_width.addToStyle(ac, style); } } /** * Get this property in the style. * * @param style The style where the property is * @param resolve if true, resolve the style to find this property */ public CssProperty getPropertyInStyle(CssStyle style, boolean resolve) { if (resolve) { return ((Css3Style) style).getColumnRule(); } else { return ((Css3Style) style).cssColumnRule; } } /** * Compares two properties for equality. * * @param property The other property. */ public boolean equals(CssProperty property) { return false; } /** * Returns the name of this property */ public final String getPropertyName() { return propertyName; } /** * Returns the value of this property */ public Object get() { return value; } /** * Returns a string representation of the object */ public String toString() { StringBuilder sb = new StringBuilder(); boolean first = true; if (value != null) { return value.toString(); } if (rule_color != null) { sb.append(rule_color); first = false; } if (rule_width != null) { if (!first) { sb.append(' '); } sb.append(rule_width); } if (rule_style != null) { if (!first) { sb.append(' '); } sb.append(rule_style); } return sb.toString(); } } --- NEW FILE: CssColumnCount.java --- // $Id: CssColumnCount.java,v 1.1 2010/01/05 13:49:38 ylafon Exp $ // From Sijtsche de Jong (http://www.w3.org/Consortium/Legal/copyright-software-19980720 package org.w3c.css.properties.css; import org.w3c.css.parser.CssStyle; import org.w3c.css.properties.css3.Css3Style; import org.w3c.css.util.ApplContext; import org.w3c.css.util.InvalidParamException; import org.w3c.css.values.CssExpression; import org.w3c.css.values.CssIdent; import org.w3c.css.values.CssNumber; import org.w3c.css.values.CssTypes; import org.w3c.css.values.CssValue; /** * http://www.w3.org/TR/2009/CR-css3-multicol-20091217/#cc * <p/> * Name: column-count * Value: <integer> | auto * Initial: auto * Applies to: non-replaced block-level elements (except table elements), * table cells, and inline-block elements * Inherited: no * Percentages: N/A * Media: visual * Computed value: specified value * <p/> * This property describes the number of columns of a multicol element. */ public class CssColumnCount extends CssProperty { private static final String propertyName = "column-count"; CssValue count; static CssIdent auto = CssIdent.getIdent("auto"); /** * Create a new CssColumnCount */ public CssColumnCount() { count = auto; } /** * Create a new CssColumnCount * * @param expression The expression for this property * @throws InvalidParamException Incorrect value */ public CssColumnCount(ApplContext ac, CssExpression expression, boolean check) throws InvalidParamException { setByUser(); CssValue val = expression.getValue(); CssNumber num; switch (val.getType()) { case CssTypes.CSS_NUMBER: num = (CssNumber) val; if (!num.isInteger()) { throw new InvalidParamException("integer", expression.getValue(), getPropertyName(), ac); } if (num.getInt() <= 0) { throw new InvalidParamException("strictly-positive", expression.getValue(), getPropertyName(), ac); } count = val; break; case CssTypes.CSS_IDENT: if (auto.equals(val)) { count = auto; break; } if (inherit.equals(val)) { count = inherit; break; } default: throw new InvalidParamException("value", expression.getValue(), getPropertyName(), ac); } expression.next(); } public CssColumnCount(ApplContext ac, CssExpression expression) throws InvalidParamException { this(ac, expression, false); } /** * Add this property to the CssStyle * * @param style The CssStyle */ public void addToStyle(ApplContext ac, CssStyle style) { if (((Css3Style) style).cssColumnCount != null) style.addRedefinitionWarning(ac, this); ((Css3Style) style).cssColumnCount = this; } /** * Get this property in the style. * * @param style The style where the property is * @param resolve if true, resolve the style to find this property */ public CssProperty getPropertyInStyle(CssStyle style, boolean resolve) { if (resolve) { return ((Css3Style) style).getColumnCount(); } else { return ((Css3Style) style).cssColumnCount; } } /** * Compares two properties for equality. * * @param property The other property. */ public boolean equals(CssProperty property) { return (property instanceof CssColumnCount && count.equals(((CssColumnCount) property).count)); } /** * Returns the name of this property */ public final String getPropertyName() { return propertyName; } /** * Returns the value of this property */ public Object get() { return count; } /** * Returns true if this property is "softly" inherited */ public boolean isSoftlyInherited() { return (count == inherit); } /** * Returns a string representation of the object */ public String toString() { return count.toString(); } /** * Is the value of this property a default value * It is used by alle macro for the function <code>print</code> */ public boolean isDefault() { return (count == auto); } } --- NEW FILE: CssProperties.java --- // $Id: CssProperties.java,v 1.1 2010/01/05 13:49:38 ylafon Exp $ // From Philippe Le Hegaret (http://www.w3.org/Consortium/Legal/copyright-software-19980720 package org.w3c.css.properties.css; import org.w3c.css.parser.CssStyle; import org.w3c.css.properties.css1.CssBorderStyleCSS2; import org.w3c.css.properties.css3.Css3Style; import org.w3c.css.util.ApplContext; import org.w3c.css.util.InvalidParamException; import org.w3c.css.values.CssExpression; import org.w3c.css.values.CssIdent; import org.w3c.css.values.CssTypes; import org.w3c.css.values.CssValue; /** * http://www.w3.org/TR/2009/CR-css3-multicol-20091217/#column-rule-style * * Name: column-rule-style * Value: <Ôborder-styleÕ> * Initial: none * Applies to: multicol elements * Inherited: no * Percentages: N/A * Media: visual * Computed value: specified value * * The Ôcolumn-rule-styleÕ property sets the style of the rule between columns * of an element. The <border-style> values are defined in [CSS21]. */ public class CssColumnRuleStyle extends CssProperty { private static final String propertyName = "column-rule-style"; CssIdent value; /** * Create a new CssColumnRuleStyle */ public CssColumnRuleStyle() { value = none; } /** * Create a new CssColumnRuleStyle * * @param ac the context * @param expression The expression for this property * @param check if check on length is required * @throws InvalidParamException Incorrect value */ public CssColumnRuleStyle(ApplContext ac, CssExpression expression, boolean check) throws InvalidParamException { setByUser(); CssValue val = expression.getValue(); // too many values if (check && expression.getCount() > 1) { throw new InvalidParamException("unrecognize", ac); } // we only use Css Ident part of the CssBorderStyle acceptable values if (val.getType() != CssTypes.CSS_IDENT) { throw new InvalidParamException("value", expression.getValue(), getPropertyName(), ac); } CssIdent ident = (CssIdent) val; if (inherit.equals(ident)) { value = inherit; } else if (CssBorderStyleCSS2.acceptable_values.contains(ident)) { value = ident; } else { throw new InvalidParamException("value", expression.getValue(), getPropertyName(), ac); } expression.next(); } public CssColumnRuleStyle(ApplContext ac, CssExpression expression) throws InvalidParamException { this(ac, expression, false); } /** * Add this property to the CssStyle * * @param style The CssStyle */ public void addToStyle(ApplContext ac, CssStyle style) { if (((Css3Style) style).cssColumnRuleStyle != null) style.addRedefinitionWarning(ac, this); ((Css3Style) style).cssColumnRuleStyle = this; } /** * Get this property in the style. * * @param style The style where the property is * @param resolve if true, resolve the style to find this property */ public CssProperty getPropertyInStyle(CssStyle style, boolean resolve) { if (resolve) { return ((Css3Style) style).getColumnRuleStyle(); } else { return ((Css3Style) style).cssColumnRuleStyle; } } /** * Compares two properties for equality. * * @param property The other property. */ public boolean equals(CssProperty property) { return (property instanceof CssColumnRuleStyle && value.equals(((CssColumnRuleStyle) property).value)); } /** * Returns the name of this property */ public final String getPropertyName() { return propertyName; } /** * Returns the value of this property */ public Object get() { return value; } /** * Returns true if this property is "softly" inherited */ public boolean isSoftlyInherited() { return (inherit == value); } /** * Returns a string representation of the object */ public String toString() { return value.toString(); } /** * Is the value of this property a default value * It is used by all macro for the function <code>print</code> */ public boolean isDefault() { return none.equals(value); } } --- NEW FILE: CssBreakBefore.java --- // $Id: CssBreakBefore.java,v 1.1 2010/01/05 13:49:37 ylafon Exp $ // From Sijtsche de Jong (http://www.w3.org/Consortium/Legal/copyright-software-19980720 package org.w3c.css.properties.css; import org.w3c.css.parser.CssStyle; import org.w3c.css.properties.css3.Css3Style; import org.w3c.css.util.ApplContext; import org.w3c.css.util.InvalidParamException; import org.w3c.css.values.CssExpression; import org.w3c.css.values.CssIdent; import org.w3c.css.values.CssTypes; import org.w3c.css.values.CssValue; import java.util.HashMap; /** * http://www.w3.org/TR/2009/CR-css3-multicol-20091217/#column-breaks * <p/> * When content is laid out in multiple columns, the user agent must determine * where column breaks are placed. The problem of breaking content into columns * is similar to breaking content into pages. * <p/> * Three new properties are introduced to allow column breaks to be described * in the same properties as page breaks: ‘break-before’, ‘break-after’, and * ‘break-inside’. These properties take the same values as * ‘page-break-before’, ‘page-break-after’, and ‘page-break-inside’ [CSS21]. * In addition, some new keyword values are added. * <p/> * Name: break-before * Value: auto | always | avoid | left | right | page | column | * avoid-page | avoid-column * Initial: auto * Applies to: block-level elements * Inherited: no * Percentages: N/A * Media: paged * Computed value: specified value */ public class CssBreakBefore extends CssProperty { private static final String propertyName = "break-before"; static CssIdent auto; static HashMap<String, CssIdent> allowed_values; CssIdent value; static { allowed_values = new HashMap<String, CssIdent>(); auto = CssIdent.getIdent("auto"); String id_values[] = {"auto", "always", "avoid", "left", "right", "page", "column", "avoid-page", "avoid-column"}; for (String s : id_values) { allowed_values.put(s, CssIdent.getIdent(s)); } } /** * Create a new CssColumnWidth */ public CssBreakBefore() { value = auto; } /** * Create a new CssBreakBefore * * @param ac the context * @param expression The expression for this property * @param check if checking is needed * @throws InvalidParamException Incorrect value */ public CssBreakBefore(ApplContext ac, CssExpression expression, boolean check) throws InvalidParamException { setByUser(); CssValue val = expression.getValue(); if (check && expression.getCount() > 1) { throw new InvalidParamException("unrecognize", ac); } if (val.getType() != CssTypes.CSS_IDENT) { throw new InvalidParamException("value", expression.getValue(), getPropertyName(), ac); } // ident, so inherit, or allowed value if (inherit.equals(val)) { value = inherit; } else { val = allowed_values.get(val.toString()); if (val == null) { throw new InvalidParamException("value", expression.getValue(), getPropertyName(), ac); } value = (CssIdent) val; } expression.next(); } public CssBreakBefore(ApplContext ac, CssExpression expression) throws InvalidParamException { this(ac, expression, false); } /** * Add this property to the CssStyle * * @param style The CssStyle */ public void addToStyle(ApplContext ac, CssStyle style) { if (((Css3Style) style).cssBreakBefore != null) style.addRedefinitionWarning(ac, this); ((Css3Style) style).cssBreakBefore = this; } /** * Get this property in the style. * * @param style The style where the property is * @param resolve if true, resolve the style to find this property */ public CssProperty getPropertyInStyle(CssStyle style, boolean resolve) { if (resolve) { return ((Css3Style) style).getBreakBefore(); } else { return ((Css3Style) style).cssBreakBefore; } } /** * Compares two properties for equality. * * @param property The other property. */ public boolean equals(CssProperty property) { return (property instanceof CssBreakBefore && value.equals(((CssBreakBefore) property).value)); } /** * Returns the name of this property */ public final String getPropertyName() { return propertyName; } /** * Returns the value of this property */ public Object get() { return value; } /** * Returns true if this property is "softly" inherited */ public boolean isSoftlyInherited() { return (inherit == value); } /** * Returns a string representation of the object */ public String toString() { return value.toString(); } /** * Is the value of this property a default value * It is used by all macro for the function <code>print</code> */ public boolean isDefault() { return (auto == value); } } --- NEW FILE: CssBackgroundRepeat.java --- // $Id: CssBackgroundRepeat.java,v 1.1 2010/01/05 13:49:37 ylafon Exp $ // @author Yves Lafon <http://www.w3.org/TR/2009/CR-css3-background-20091217/#the-background-repeat * * Name: background-repeat * Value: <repeat-style> [ , <repeat-style> ]* * Initial: repeat * Applies to: all elements * Inherited: no * Percentages: N/A * Media: visual * Computed value: as specified * * Specifies how background images are tiled after they have been sized and * positioned. Where * * <repeat-style> = repeat-x | repeat-y | [repeat | space | * round | no-repeat]{1,2} * */ public class CssBackgroundRepeat extends CssProperty { private static final String propertyName = "background-repeat"; public static CssIdent repeat; public static HashMap<String, CssIdent> allowed_simple_values; public static HashMap<String, CssIdent> allowed_double_values; static { allowed_simple_values = new HashMap<String, CssIdent>(); allowed_double_values = new HashMap<String, CssIdent>(); String[] REPEAT = {"repeat", "space", "round", "no-repeat"}; allowed_simple_values.put("repeat-x", CssIdent.getIdent("repeat-x")); allowed_simple_values.put("repeat-y", CssIdent.getIdent("repeat-y")); for (String aREPEAT : REPEAT) { allowed_double_values.put(aREPEAT, CssIdent.getIdent(aREPEAT)); } repeat = CssIdent.getIdent("repeat"); } public Object value; /** * Create a new CssBackgroundRepeat */ public CssBackgroundRepeat() { value = repeat; } /** * Set the value of the property * * @param ac the context * @param expression The expression for this property * @param check is length checking needed * @throws InvalidParamException The expression is incorrect */ public CssBackgroundRepeat(ApplContext ac, CssExpression expression, boolean check) throws InvalidParamException { ArrayList<CssValue> values = new ArrayList<CssValue>(); boolean is_complete = true; CssValue val; CssValueList vl = null; char op; setByUser(); while (!expression.end()) { val = expression.getValue(); op = expression.getOperator(); // not an ident? fail if (val.getType() != CssTypes.CSS_IDENT) { throw new InvalidParamException("value", expression.getValue(), getPropertyName(), ac); } CssIdent id_val = (CssIdent) val; if (inherit.equals(id_val)) { // if we got inherit after other values, fail // if we got more than one value... fail if ((values.size() > 0) || (expression.getCount() > 1)) { throw new InvalidParamException("value", val, getPropertyName(), ac); } values.add(inherit); } else { String id_value = id_val.toString(); CssIdent new_val; // check values that must be alone new_val = allowed_simple_values.get(id_value); if (new_val != null) { // if we already have a double value... it's an error if (!is_complete) { throw new InvalidParamException("value", val, getPropertyName(), ac); } values.add(new_val); is_complete = true; } else { // the the one that may come in pairs new_val = allowed_double_values.get(id_value); // not an allowed value ! if (new_val == null) { throw new InvalidParamException("value", val, getPropertyName(), ac); } if (is_complete) { vl = new CssValueList(); vl.add(new_val); } else { vl.add(new_val); values.add(vl); } is_complete = !is_complete; } } expression.next(); if (!expression.end()) { // incomplete value followed by a comma... it's complete! if (!is_complete && (op == COMMA)) { values.add(vl); is_complete = true; } // complete values are separated by a comma, otherwise space if ((is_complete && (op != COMMA)) || (!is_complete && (op != SPACE))) { throw new InvalidParamException("operator", ((new Character(op)).toString()), ac); } } } // if we reach the end in a value that can come in pair if (!is_complete) { values.add(vl); } if (values.size() == 1) { value = values.get(0); } else { value = values; } } public CssBackgroundRepeat(ApplContext ac, CssExpression expression) throws InvalidParamException { this(ac, expression, false); } /** * Returns the value of this property */ public Object get() { return value; } /** * Returns true if this property is "softly" inherited * e.g. his value equals inherit */ public boolean isSoftlyInherited() { return (inherit == value); } /** * Returns a string representation of the object. */ public String toString() { if (value instanceof ArrayList) { ArrayList values = (ArrayList) value; StringBuilder sb = new StringBuilder(); for (Object aValue : values) { sb.append(aValue.toString()).append(", "); } sb.setLength(sb.length() - 2); return sb.toString(); } return value.toString(); } /** * Returns the name of this property */ public final String getPropertyName() { return propertyName; } /** * Add this property to the CssStyle. * * @param style The CssStyle */ public void addToStyle(ApplContext ac, CssStyle style) { CssBackground cssBackground = ((Css1Style) style).cssBackground; if (cssBackground.repeat != null) style.addRedefinitionWarning(ac, this); cssBackground.repeat = this; } /** * Get this property in the style. * * @param style The style where the property is * @param resolve if true, resolve the style to find this property */ public CssProperty getPropertyInStyle(CssStyle style, boolean resolve) { if (resolve) { return ((Css1Style) style).getBackgroundRepeat(); } else { return ((Css1Style) style).cssBackground.repeat; } } /** * Compares two properties for equality. * * @param property The other property. */ public boolean equals(CssProperty property) { return (property instanceof CssBackgroundRepeat && value == ((CssBackgroundRepeat) property).value); } /** * Is the value of this property is a default value. * It is used by all macro for the function <code>print</code> */ public boolean isDefault() { return (repeat == value); } } --- NEW FILE: CssColumnRuleColor.java --- // $Id: CssColumnRuleColor.java,v 1.1 2010/01/05 13:49:38 ylafon Exp $ // From Sijtsche de Jong (http://www.w3.org/Consortium/Legal/copyright-software-19980720 package org.w3c.css.properties.css; import org.w3c.css.parser.CssStyle; import org.w3c.css.properties.css1.CssColor; import org.w3c.css.properties.css3.Css3Style; import org.w3c.css.util.ApplContext; import org.w3c.css.util.InvalidParamException; import org.w3c.css.values.CssExpression; import org.w3c.css.values.CssValue; /** * http://www.w3.org/TR/2009/CR-css3-multicol-20091217/#column-rule-color * * Name: column-rule-color * Value: <color> * Initial: same as for ÔcolorÕ property [CSS21] * Applies to: multicol elements * Inherited: no * Percentages: N/A * Media: visual * Computed value: the same as the computed value for the ÔcolorÕ * property [CSS21] * * This property sets the color of the column rule. The <color> values are * defined in [CSS21]. */ public class CssColumnRuleColor extends CssProperty { private static final String propertyName = "column-rule-color"; CssColor color; /** * Create a new CssColumnRuleColor */ public CssColumnRuleColor() { // nothing to do } /** * Create a new CssColumnRuleColor * * @param expression The expression for this property * @throws InvalidParamException Incorrect value */ public CssColumnRuleColor(ApplContext ac, CssExpression expression, boolean check) throws InvalidParamException { setByUser(); CssValue val = expression.getValue(); if (check && expression.getCount() > 1) { throw new InvalidParamException("unrecognize", ac); } try { // we use the latest version of CssColor, aka CSS3 // instead of using CSS21 colors + transparent per spec. color = new CssColor(ac, expression); } catch (InvalidParamException e) { throw new InvalidParamException("value", expression.getValue(), getPropertyName(), ac); } } public CssColumnRuleColor(ApplContext ac, CssExpression expression) throws InvalidParamException { this(ac, expression, false); } /** * Add this property to the CssStyle * * @param style The CssStyle */ public void addToStyle(ApplContext ac, CssStyle style) { if (((Css3Style) style).cssColumnRuleColor != null) style.addRedefinitionWarning(ac, this); ((Css3Style) style).cssColumnRuleColor = this; } /** * Get this property in the style. * * @param style The style where the property is * @param resolve if true, resolve the style to find this property */ public CssProperty getPropertyInStyle(CssStyle style, boolean resolve) { if (resolve) { return ((Css3Style) style).getColumnRuleColor(); } else { return ((Css3Style) style).cssColumnRuleColor; } } /** * Compares two properties for equality. * * @param property The other property. */ public boolean equals(CssProperty property) { return (property instanceof CssColumnRuleColor && color.equals(((CssColumnRuleColor) property).color)); } /** * Returns the name of this property */ public final String getPropertyName() { return propertyName; } /** * Returns the value of this property */ public Object get() { return color; } /** * Returns true if this property is "softly" inherited */ public boolean isSoftlyInherited() { return inherit.equals(color); } /** * Returns a string representation of the object */ public String toString() { return color.toString(); } /** * Is the value of this property a default value * It is used by all macro for the function <code>print</code> */ public boolean isDefault() { return false; } } --- NEW FILE: CssProperty.java --- // $Id: CssProperty.java,v 1.1 2010/01/05 13:49:38 ylafon Exp $ // From Philippe Le Hegaret (http://www.w3.org/Consortium/Legal/copyright-software-19980720 package org.w3c.css.properties.css; import org.w3c.css.parser.CssStyle; import org.w3c.css.properties.css3.Css3Style; import org.w3c.css.util.ApplContext; import org.w3c.css.util.InvalidParamException; import org.w3c.css.values.CssExpression; import org.w3c.css.values.CssIdent; import org.w3c.css.values.CssLength; import org.w3c.css.values.CssNumber; import org.w3c.css.values.CssTypes; import org.w3c.css.values.CssValue; /** * http://www.w3.org/TR/2009/CR-css3-multicol-20091217/#column-width * <p/> * Name: column-width * Value: <length> | auto * Initial: auto * Applies to: non-replaced block-level elements (except table elements), * table cells, and inline-block elements * Inherited: no * Percentages: N/A * Media: visual * Computed value: the absolute length * <p/> * This property describes the width of columns in multicol elements. */ public class CssColumnWidth extends CssProperty { private static final String propertyName = "column-width"; CssValue width; static CssIdent auto; static { auto = CssIdent.getIdent("auto"); } /** * Create a new CssColumnWidth */ public CssColumnWidth() { width = auto; } /** * Create a new CssColumnWidth * * @param expression The expression for this property * @throws InvalidParamException Incorrect value */ public CssColumnWidth(ApplContext ac, CssExpression expression, boolean check) throws InvalidParamException { setByUser(); CssValue val = expression.getValue(); Float value; switch (val.getType()) { case CssTypes.CSS_NUMBER: val = ((CssNumber) val).getLength(); // if we didn't fall in the first trap, there is another one :) throw new InvalidParamException("strictly-positive", expression.getValue(), getPropertyName(), ac); case CssTypes.CSS_LENGTH: value = (Float) ((CssLength) val).get(); if (value == null || value.floatValue() <= 0.0) { throw new InvalidParamException("strictly-positive", expression.getValue(), getPropertyName(), ac); } width = val; break; case CssTypes.CSS_IDENT: if (inherit.equals(val)) { width = inherit; break; } else if (auto.equals(val)) { width = auto; break; } default: throw new InvalidParamException("value", expression.getValue(), getPropertyName(), ac); } expression.next(); } public CssColumnWidth(ApplContext ac, CssExpression expression) throws InvalidParamException { this(ac, expression, false); } /** * Add this property to the CssStyle * * @param style The CssStyle */ public void addToStyle(ApplContext ac, CssStyle style) { if (((Css3Style) style).cssColumnWidth != null) style.addRedefinitionWarning(ac, this); ((Css3Style) style).cssColumnWidth = this; } /** * Get this property in the style. * * @param style The style where the property is * @param resolve if true, resolve the style to find this property */ public CssProperty getPropertyInStyle(CssStyle style, boolean resolve) { if (resolve) { return ((Css3Style) style).getColumnWidth(); } else { return ((Css3Style) style).cssColumnWidth; } } /** * Compares two properties for equality. * * @param property The other property. */ public boolean equals(CssProperty property) { return (property instanceof CssColumnWidth && width.equals(((CssColumnWidth) property).width)); } /** * Returns the name of this property */ public final String getPropertyName() { return propertyName; } /** * Returns the value of this property */ public Object get() { return width; } /** * Returns true if this property is "softly" inherited */ public boolean isSoftlyInherited() { return (inherit == width); } /** * Returns a string representation of the object */ public String toString() { return width.toString(); } /** * Is the value of this property a default value * It is used by all macro for the function <code>print</code> */ public boolean isDefault() { return (auto == width); } } --- NEW FILE: CssColumnSpan.java --- // // $Id: CssColumnSpan.java,v 1.1 2010/01/05 13:49:38 ylafon Exp $ // From Sijtsche de Jong (http://www.w3.org/Consortium/Legal/copyright-software-19980720 package org.w3c.css.properties.css; import org.w3c.css.parser.CssStyle; import org.w3c.css.properties.css.CssProperty; import org.w3c.css.properties.css3.Css3Style; import org.w3c.css.util.ApplContext; import org.w3c.css.util.InvalidParamException; import org.w3c.css.values.CssExpression; import org.w3c.css.values.CssIdent; import org.w3c.css.values.CssNumber; import org.w3c.css.values.CssTypes; import org.w3c.css.values.CssValue; /** * From http://www.w3.org/TR/css3-multicol * <P> * <EM>Value:</EM> 1 || all <BR> * <EM>Initial:</EM>1<BR> * <EM>Applies to:</EM>static, non-floating elements<BR> * <EM>Inherited:</EM>no<BR> * <EM>Percentages:</EM>N/A<BR> * <EM>Media:</EM>:visual */ public class CssColumnSpan extends CssProperty { CssValue value; ApplContext ac; static CssIdent all; static { all = new CssIdent("all"); } /** * Create a new CssColumnSpan */ public CssColumnSpan() { //nothing to do } /** * Create a new CssColumnSpan * * @param expression The expression for this property * @exception InvalidParamException Values are incorrect */ public CssColumnSpan(ApplContext ac, CssExpression expression, boolean check) throws InvalidParamException { this.ac = ac; setByUser(); // tell this property is set by the user CssValue val = expression.getValue(); switch (val.getType()) { case CssTypes.CSS_NUMBER: int ival = ((CssNumber) val).getInt(); if (ival != 1) { throw new InvalidParamException("value", val.toString(), getPropertyName(), ac); } value = val; break; case CssTypes.CSS_IDENT: if (all.equals(val)) { value = all; break; } if (inherit.equals(val)) { value = inherit; break; } default: throw new InvalidParamException("value", val.toString(), getPropertyName(), ac); } } public CssColumnSpan(ApplContext ac, CssExpression expression) throws InvalidParamException { this(ac, expression, false); } /** * Add this property to the CssStyle. * * @param style The CssStyle */ public void addToStyle(ApplContext ac, CssStyle style) { if (((Css3Style) style).cssColumnSpan != null) style.addRedefinitionWarning(ac, this); ((Css3Style) style).cssColumnSpan = this; } /** * Get this property in the style. * * @param style The style where the property is * @param resolve if true, resolve the style to find this property */ public CssProperty getPropertyInStyle(CssStyle style, boolean resolve) { if (resolve) { return ((Css3Style) style).getColumnSpan(); } else { return ((Css3Style) style).cssColumnSpan; } } /** * Compares two properties for equality. * * @param property The other property. */ public boolean equals(CssProperty property) { return (property instanceof CssColumnSpan && value.equals( ((CssColumnSpan) property).value)); } /** * Returns the name of this property */ public String getPropertyName() { return "column-span"; } /** * Returns the value of this property */ public Object get() { return value; } /** * Returns true if this property is "softly" inherited */ public boolean isSoftlyInherited() { return (value == inherit); } /** * Returns a string representation of the object */ public String toString() { return value.toString(); } /** * Is the value of this property a default value * It is used by all macro for the function <code>print</code> */ public boolean isDefault() { // we only have 3 values return ((value != all) && (value != inherit)); } } --- NEW FILE: CssColumnRuleWidth.java --- // // $Id: CssColumnRuleWidth.java,v 1.1 2010/01/05 13:49:38 ylafon Exp $ // From Sijtsche de Jong (http://www.w3.org/Consortium/Legal/copyright-software-19980720 package org.w3c.css.properties.css; import org.w3c.css.parser.CssStyle; import org.w3c.css.properties.css.CssProperty; import org.w3c.css.properties.css1.CssBorderFaceWidthCSS2; import org.w3c.css.properties.css3.Css3Style; import org.w3c.css.util.ApplContext; import org.w3c.css.util.InvalidParamException; import org.w3c.css.values.CssExpression; import org.w3c.css.values.CssValue; /** * http://www.w3.org/TR/css3-multicol/ * <P> * <EM>Value:</EM> <border-width><BR> * <EM>Initial:</EM>medium<BR> * <EM>Applies to:</EM>multicol elements<BR> * <EM>Inherited:</EM>no<BR> * <EM>Percentages:</EM>N/A<BR> * <EM>Media:</EM>:visual */ public class CssColumnRuleWidth extends CssProperty { CssBorderFaceWidthCSS2 value; /** * Create a new CssColumnRuleWidth */ public CssColumnRuleWidth() { // nothing to do } /** * Create a new CssColumnRuleWidth * * @param expression The expression for this property * @exception InvalidParamException Incorrect value */ public CssColumnRuleWidth(ApplContext ac, CssExpression expression, boolean check) throws InvalidParamException { setByUser(); CssValue val = expression.getValue(); if (check && expression.getCount() > 1) { throw new InvalidParamException("unrecognize", ac); } try { value = new CssBorderFaceWidthCSS2(ac, expression); } catch (InvalidParamException e) { throw new InvalidParamException("value", expression.getValue(), getPropertyName(), ac); } } public CssColumnRuleWidth(ApplContext ac, CssExpression expression) throws InvalidParamException { this(ac, expression, false); } /** * Add this property to the CssStyle * * @param style The CssStyle */ public void addToStyle(ApplContext ac, CssStyle style) { if (((Css3Style) style).cssColumnRuleWidth != null) style.addRedefinitionWarning(ac, this); ((Css3Style) style).cssColumnRuleWidth = this; } /** * Get this property in the style. * * @param style The style where the property is * @param resolve if true, resolve the style to find this property */ public CssProperty getPropertyInStyle(CssStyle style, boolean resolve) { if (resolve) { return ((Css3Style) style).getColumnRuleWidth(); } else { return ((Css3Style) style).cssColumnRuleWidth; } } /** * Compares two properties for equality. * * @param value The other property. */ public boolean equals(CssProperty property) { return (property instanceof CssColumnRuleWidth && value.equals(((CssColumnRuleWidth) property).value)); } /** * Returns the name of this property */ public String getPropertyName() { return "column-rule-width"; } /** * Returns the value of this property */ public Object get() { return value.getValue(); } /** * Returns true if this property is "softly" inherited */ public boolean isSoftlyInherited() { return inherit.equals(value.getValue()); } /** * Returns a string representation of the object */ public String toString() { return value.toString(); } /** * Is the value of this property a default value * It is used by alle macro for the function <code>print</code> */ public boolean isDefault() { return false; } } --- NEW FILE: CssBreakAfter.java --- // $Id: CssBreakAfter.java,v 1.1 2010/01/05 13:49:37 ylafon Exp $ // From Sijtsche de Jong (http://www.w3.org/Consortium/Legal/copyright-software-19980720 package org.w3c.css.properties.css; import org.w3c.css.parser.CssStyle; import org.w3c.css.properties.css3.Css3Style; import org.w3c.css.util.ApplContext; import org.w3c.css.util.InvalidParamException; import org.w3c.css.values.CssExpression; import org.w3c.css.values.CssIdent; import org.w3c.css.values.CssTypes; import org.w3c.css.values.CssValue; import java.util.HashMap; /** * http://www.w3.org/TR/2009/CR-css3-multicol-20091217/#column-breaks * <p/> * When content is laid out in multiple columns, the user agent must determine * where column breaks are placed. The problem of breaking content into columns * is similar to breaking content into pages. * <p/> * Three new properties are introduced to allow column breaks to be described * in the same properties as page breaks: ‘break-before’, ‘break-after’, and * ‘break-inside’. These properties take the same values as * ‘page-break-before’, ‘page-break-after’, and ‘page-break-inside’ [CSS21]. * In addition, some new keyword values are added. * <p/> * Name: break-after * Value: auto | always | avoid | left | right | page | column | * avoid-page | avoid-column * Initial: auto * Applies to: block-level elements * Inherited: no * Percentages: N/A * Media: paged * Computed value: specified value */ public class CssBreakAfter extends CssProperty { private static final String propertyName = "break-after"; static CssIdent auto; static HashMap<String, CssIdent> allowed_values; CssIdent value; static { allowed_values = new HashMap<String, CssIdent>(); auto = CssIdent.getIdent("auto"); String id_values[] = {"auto", "always", "avoid", "left", "right", "page", "column", "avoid-page", "avoid-column"}; for (String s : id_values) { allowed_values.put(s, CssIdent.getIdent(s)); } } /** * Create a new CssColumnWidth */ public CssBreakAfter() { value = auto; } /** * Create a new CssBreakAfter * * @param expression The expression for this property * @throws InvalidParamException Incorrect value */ public CssBreakAfter(ApplContext ac, CssExpression expression, boolean check) throws InvalidParamException { setByUser(); CssValue val = expression.getValue(); if (check && expression.getCount() > 1) { throw new InvalidParamException("unrecognize", ac); } if (val.getType() != CssTypes.CSS_IDENT) { throw new InvalidParamException("value", expression.getValue(), getPropertyName(), ac); } // ident, so inherit, or allowed value if (inherit.equals(val)) { value = inherit; } else { val = allowed_values.get(val.toString()); if (val == null) { throw new InvalidParamException("value", expression.getValue(), getPropertyName(), ac); } value = (CssIdent) val; } expression.next(); } public CssBreakAfter(ApplContext ac, CssExpression expression) throws InvalidParamException { this(ac, expression, false); } /** * Add this property to the CssStyle * * @param style The CssStyle */ public void addToStyle(ApplContext ac, CssStyle style) { if (((Css3Style) style).cssBreakAfter != null) style.addRedefinitionWarning(ac, this); ((Css3Style) style).cssBreakAfter = this; } /** * Get this property in the style. * * @param style The style where the property is * @param resolve if true, resolve the style to find this property */ public CssProperty getPropertyInStyle(CssStyle style, boolean resolve) { if (resolve) { return ((Css3Style) style).getBreakAfter(); } else { return ((Css3Style) style).cssBreakAfter; } } /** * Compares two properties for equality. * * @param property The other property. */ public boolean equals(CssProperty property) { return (property instanceof CssBreakAfter && value.equals(((CssBreakAfter) property).value)); } /** * Returns the name of this property */ public final String getPropertyName() { return propertyName; } /** * Returns the value of this property */ public Object get() { return value; } /** * Returns true if this property is "softly" inherited */ public boolean isSoftlyInherited() { return (inherit == value); } /** * Returns a string representation of the object */ public String toString() { return value.toString(); } /** * Is the value of this property a default value * It is used by all macro for the function <code>print</code> */ public boolean isDefault() { return (auto == value); } } --- NEW FILE: CssBreakInside.java --- // $Id: CssBreakInside.java,v 1.1 2010/01/05 13:49:37 ylafon Exp $ // From Sijtsche de Jong (http://www.w3.org/Consortium/Legal/copyright-software-19980720 package org.w3c.css.properties.css; import org.w3c.css.parser.CssStyle; import org.w3c.css.properties.css3.Css3Style; import org.w3c.css.util.ApplContext; import org.w3c.css.util.InvalidParamException; import org.w3c.css.values.CssExpression; import org.w3c.css.values.CssIdent; import org.w3c.css.values.CssTypes; import org.w3c.css.values.CssValue; import java.util.HashMap; /** * http://www.w3.org/TR/2009/CR-css3-multicol-20091217/#column-breaks * <p/> * When content is laid out in multiple columns, the user agent must determine * where column breaks are placed. The problem of breaking content into columns * is similar to breaking content into pages. * <p/> * Three new properties are introduced to allow column breaks to be described * in the same properties as page breaks: ‘break-before’, ‘break-after’, and * ‘break-inside’. These properties take the same values as * ‘page-break-before’, ‘page-break-after’, and ‘page-break-inside’ [CSS21]. * In addition, some new keyword values are added. * <p/> * Name: break-inside * Value: auto | avoid | avoid-page | avoid-column * Initial: auto * Applies to: block-level elements * Inherited: no * Percentages: N/A * Media: paged * Computed value: specified value */ public class CssBreakInside extends CssProperty { private static final String propertyName = "break-inside"; static CssIdent auto; static HashMap<String, CssIdent> allowed_values; CssIdent value; static { allowed_values = new HashMap<String, CssIdent>(); auto = CssIdent.getIdent("auto"); String id_values[] = {"auto", "always", "avoid", "left", "right", "page", "column", "avoid-page", "avoid-column"}; for (String s : id_values) { allowed_values.put(s, CssIdent.getIdent(s)); } } /** * Create a new CssColumnWidth */ public CssBreakInside() { value = auto; } /** * Create a new CssBreakInside * * @param expression The expression for this property * @throws InvalidParamException Incorrect value */ public CssBreakInside(ApplContext ac, CssExpression expression, boolean check) throws InvalidParamException { setByUser(); CssValue val = expression.getValue(); if (check && expression.getCount() > 1) { throw new InvalidParamException("unrecognize", ac); } if (val.getType() != CssTypes.CSS_IDENT) { throw new InvalidParamException("value", expression.getValue(), getPropertyName(), ac); } // ident, so inherit, or allowed value if (inherit.equals(val)) { value = inherit; } else { val = allowed_values.get(val.toString()); if (val == null) { throw new InvalidParamException("value", expression.getValue(), getPropertyName(), ac); } value = (CssIdent)val; } expression.next(); } public CssBreakInside(ApplContext ac, CssExpression expression) throws InvalidParamException { this(ac, expression, false); } /** * Add this property to the CssStyle * * @param style The CssStyle */ public void addToStyle(ApplContext ac, CssStyle style) { if (((Css3Style) style).cssBreakInside != null) style.addRedefinitionWarning(ac, this); ((Css3Style) style).cssBreakInside = this; } /** * Get this property in the style. * * @param style The style where the property is * @param resolve if true, resolve the style to find this property */ public CssProperty getPropertyInStyle(CssStyle style, boolean resolve) { if (resolve) { return ((Css3Style) style).getBreakInside(); } else { return ((Css3Style) style).cssBreakInside; } } /** * Compares two properties for equality. * * @param property The other property. */ public boolean equals(CssProperty property) { return (property instanceof CssBreakInside && value.equals(((CssBreakInside) property).value)); } /** * Returns the name of this property */ public final String getPropertyName() { return propertyName; } /** * Returns the value of this property */ public Object get() { return value; } /** * Returns true if this property is "softly" inherited */ public boolean isSoftlyInherited() { return (inherit == value); } /** * Returns a string representation of the object */ public String toString() { return value.toString(); } /** * Is the value of this property a default value * It is used by all macro for the function <code>print</code> */ public boolean isDefault() { return (auto == value); } } --- NEW FILE: CssDisplay.java --- // $Id: CssDisplay.java,v 1.1 2010/01/05 13:49:38 ylafon Exp $ // From Philippe Le Hegaret (http://www.w3.org/Consortium/Legal/copyright-software-19980720 package org.w3c.css.properties.css; import org.w3c.css.parser.CssStyle; import org.w3c.css.properties.css3.Css3Style; import org.w3c.css.util.ApplContext; import org.w3c.css.util.InvalidParamException; import org.w3c.css.values.CssExpression; import org.w3c.css.values.CssIdent; import org.w3c.css.values.CssLength; import org.w3c.css.values.CssNumber; import org.w3c.css.values.CssTypes; import org.w3c.css.values.CssValue; /** * http://www.w3.org/TR/2009/CR-css3-multicol-20091217/#column-gap * <p/> * Name: column-gap * Value: <length> | normal * Initial: normal * Applies to: multicol elements * Inherited: no * Percentages: N/A * Media: visual * Computed value: absolute length or ‘normal’ * <p/> * The ‘column-gap’ property sets the gap between columns. If there is a * column rule between columns, it will appear in the middle of the gap. * <p/> * The ‘normal’ value is UA-specific. A value of ‘1em’ is suggested. * <p/> * Column gaps cannot be negative. */ public class CssColumnGap extends CssProperty { private static final String propertyName = "column-gap"; CssValue columngap; static CssIdent normal; static { normal = CssIdent.getIdent("normal"); } /** * Create a new CssColumnGap */ public CssColumnGap() { columngap = normal; } /** * Create a new CssColumnGap */ public CssColumnGap(ApplContext ac, CssExpression expression, boolean check) throws InvalidParamException { setByUser(); CssValue val = expression.getValue(); Float value; switch (val.getType()) { case CssTypes.CSS_NUMBER: val = ((CssNumber) val).getLength(); case CssTypes.CSS_LENGTH: value = (Float) ((CssLength) val).get(); if (value == null || value.floatValue() < 0.0) { throw new InvalidParamException("negative-value", expression.getValue(), getPropertyName(), ac); } columngap = val; break; case CssTypes.CSS_IDENT: if (normal.equals(val)) { columngap = normal; break; } if (inherit.equals(val)) { columngap = inherit; break; } default: throw new InvalidParamException("value", expression.getValue(), getPropertyName(), ac); } expression.next(); } public CssColumnGap(ApplContext ac, CssExpression expression) throws InvalidParamException { this(ac, expression, false); } /** * Add this property to the CssStyle. * * @param style The CssStyle */ public void addToStyle(ApplContext ac, CssStyle style) { if (((Css3Style) style).cssColumnGap != null) style.addRedefinitionWarning(ac, this); ((Css3Style) style).cssColumnGap = this; } /** * Get this property in the style. * * @param style The style where the property is * @param resolve if true, resolve the style to find this property */ public CssProperty getPropertyInStyle(CssStyle style, boolean resolve) { if (resolve) { return ((Css3Style) style).getColumnGap(); } else { return ((Css3Style) style).cssColumnGap; } } /** * Compares two properties for equality. * * @param property The other property. */ public boolean equals(CssProperty property) { return (property instanceof CssColumnGap && columngap.equals(((CssColumnGap) property).columngap)); } /** * Returns the name of this property */ public final String getPropertyName() { return propertyName; } /** * Returns the value of this property */ public Object get() { return columngap; } /** * Returns true if this property is "softly" inherited */ public boolean isSoftlyInherited() { return (inherit == columngap); } /** * Returns a string representation of the object */ public String toString() { return columngap.toString(); } /** * Is the value of this property a default value * It is used by all macro for the function <code>print</code> */ public boolean isDefault() { return (columngap == normal); } } --- NEW FILE: CssBackgroundOrigin.java --- // // $Id: CssBackgroundOrigin.java,v 1.1 2010/01/05 13:49:37 ylafon Exp $ // @author Yves Lafon <http://www.w3.org/Consortium/Legal/copyright-software-19980720 package org.w3c.css.properties.css; import org.w3c.css.parser.CssStyle; import org.w3c.css.properties.css3.Css3Style; import org.w3c.css.util.ApplContext; import org.w3c.css.util.InvalidParamException; import org.w3c.css.values.CssExpression; import org.w3c.css.values.CssIdent; import org.w3c.css.values.CssTypes; import org.w3c.css.values.CssValue; import java.util.ArrayList; import static org.w3c.css.values.CssOperator.COMMA; /** * http://www.w3.org/TR/2009/CR-css3-background-20091217/#the-background-origin * * Name: background-origin * Value: <bg-origin> [ , <bg-origin> ]* * Initial: padding-box * Applies to: all elements * Inherited: no * Percentages: N/A * Media: visual * Computed value: same as specified value * * For elements rendered as a single box, specifies the background positioning * area. For elements rendered as multiple boxes (e.g., inline boxes on several * lines, boxes on several pages) specifies which boxes Ôbox-decoration-breakÕ * operates on to determine the background positioning area(s). * * <bg-origin> = border-box | padding-box | content-box */ public class CssBackgroundOrigin extends CssProperty { private static final String propertyName = "background-origin"; public static CssIdent border_box; public static CssIdent padding_box; public static CssIdent content_box; Object value; static { border_box = CssIdent.getIdent("border-box"); padding_box = CssIdent.getIdent("padding-box"); content_box = CssIdent.getIdent("content-box"); } /** * Create a new CssBackgroundClip */ public CssBackgroundOrigin() { value = padding_box; } /** * Create a new CssBackgroundClip * * @param expression The expression for this property * @throws org.w3c.css.util.InvalidParamException Incorrect value */ public CssBackgroundOrigin(ApplContext ac, CssExpression expression, boolean check) throws InvalidParamException { ArrayList<CssValue> values = new ArrayList<CssValue>(); CssValue val = expression.getValue(); char op; while (!expression.end()) { val = expression.getValue(); op = expression.getOperator(); switch (val.getType()) { case CssTypes.CSS_IDENT: if (inherit.equals(val)) { // if we got inherit after other values, fail // if we got more than one value... fail if ((values.size() > 0)||(expression.getCount() > 1)) { throw new InvalidParamException("value", val, getPropertyName(), ac); } values.add(inherit); break; } else if (border_box.equals(val)) { values.add(border_box); break; } else if (content_box.equals(val)) { values.add(content_box); break; } else if (padding_box.equals(val)) { values.add(padding_box); break; } default: throw new InvalidParamException("value", val, getPropertyName(), ac); } expression.next(); if (!expression.end() && (op != COMMA)) { throw new InvalidParamException("operator", ((new Character(op)).toString()), ac); } } if (values.size() == 1) { value = values.get(0); } else { value = values; } } public CssBackgroundOrigin(ApplContext ac, CssExpression expression) throws InvalidParamException { this(ac, expression, false); } /** * Add this property to the CssStyle * * @param style The CssStyle */ public void addToStyle(ApplContext ac, CssStyle style) { // TODO FIXME -> in CssStyle if (((Css3Style) style).cssBackgroundOrigin != null) style.addRedefinitionWarning(ac, this); ((Css3Style) style).cssBackgroundOrigin = this; } /** * Get this property in the style. * * @param style The style where the property is * @param resolve if true, resolve the style to find this property */ public CssProperty getPropertyInStyle(CssStyle style, boolean resolve) { if (resolve) { return ((Css3Style) style).getCssBackgroundOrigin(); } else { return ((Css3Style) style).cssBackgroundOrigin; } } /** * Compares two properties for equality. * * @param property The other property. */ public boolean equals(CssProperty property) { return (property instanceof CssBackgroundOrigin && value.equals(((CssBackgroundOrigin) property).value)); } /** * Returns the name of this property */ public final String getPropertyName() { return propertyName; } /** * Returns the value of this property */ public Object get() { return value; } /** * Returns true if this property is "softly" inherited */ public boolean isSoftlyInherited() { return inherit.equals(value); } /** * Returns a string representation of the object */ public String toString() { if (value instanceof ArrayList) { ArrayList values = (ArrayList) value; StringBuilder sb = new StringBuilder(); for (Object aValue : values) { sb.append(aValue.toString()).append(", "); } sb.setLength(sb.length() - 2); return sb.toString(); } return value.toString(); } /** * Is the value of this property a default value * It is used by all macro for the function <code>print</code> */ public boolean isDefault() { return (padding_box == value); } } --- NEW FILE: CssBackgroundClip.java --- // $Id: CssBackgroundClip.java,v 1.1 2010/01/05 13:49:37 ylafon Exp $ // @author Yves Lafon <http://www.w3.org/Consortium/Legal/copyright-software-19980720 package org.w3c.css.properties.css; import org.w3c.css.parser.CssStyle; import org.w3c.css.properties.css3.Css3Style; import org.w3c.css.util.ApplContext; import org.w3c.css.util.InvalidParamException; import org.w3c.css.values.CssExpression; import org.w3c.css.values.CssIdent; import org.w3c.css.values.CssTypes; import org.w3c.css.values.CssValue; import java.util.ArrayList; import static org.w3c.css.values.CssOperator.COMMA; /** * http://www.w3.org/TR/2009/CR-css3-background-20091217/#the-background-clip * Name: background-clip * Value: [border-box | padding-box ] [ , [border-box | padding-box ] ]* * Initial: border-box * Applies to: all elements * Inherited: no * Percentages: N/A * Media: visual * Computed value: same as specified value * <p/> * Determines the background painting area. */ public class CssBackgroundClip extends CssProperty { private static final String propertyName = "background-clip"; public static CssIdent border_box; public static CssIdent padding_box; Object value; static { border_box = CssIdent.getIdent("border-box"); padding_box = CssIdent.getIdent("padding-box"); } /** * Create a new CssBackgroundClip */ public CssBackgroundClip() { value = border_box; } /** * Create a new CssBackgroundClip * * @param expression The expression for this property * @throws InvalidParamException Incorrect value */ public CssBackgroundClip(ApplContext ac, CssExpression expression, boolean check) throws InvalidParamException { ArrayList<CssValue> values = new ArrayList<CssValue>(); CssValue val = expression.getValue(); char op; while (!expression.end()) { val = expression.getValue(); op = expression.getOperator(); switch (val.getType()) { case CssTypes.CSS_IDENT: if (inherit.equals(val)) { // if we got inherit after other values, fail // if we got more than one value... fail if ((values.size() > 0)||(expression.getCount() > 1)) { throw new InvalidParamException("value", val, getPropertyName(), ac); } values.add(inherit); break; } else if (border_box.equals(val)) { values.add(border_box); break; } else if (padding_box.equals(val)) { values.add(padding_box); break; } default: throw new InvalidParamException("value", val, getPropertyName(), ac); } expression.next(); if (!expression.end() && (op != COMMA)) { throw new InvalidParamException("operator", ((new Character(op)).toString()), ac); } } if (values.size() == 1) { value = values.get(0); } else { value = values; } } public CssBackgroundClip(ApplContext ac, CssExpression expression) throws InvalidParamException { this(ac, expression, false); } /** * Add this property to the CssStyle * * @param style The CssStyle */ public void addToStyle(ApplContext ac, CssStyle style) { // TODO FIXME -> in CssStyle if (((Css3Style) style).cssBackgroundClip != null) style.addRedefinitionWarning(ac, this); ((Css3Style) style).cssBackgroundClip = this; } /** * Get this property in the style. * * @param style The style where the property is * @param resolve if true, resolve the style to find this property */ public CssProperty getPropertyInStyle(CssStyle style, boolean resolve) { if (resolve) { return ((Css3Style) style).getCssBackgroundClip(); } else { return ((Css3Style) style).cssBackgroundClip; } } /** * Compares two properties for equality. * * @param property The other property. */ public boolean equals(CssProperty property) { return (property instanceof CssBackgroundClip && value.equals(((CssBackgroundClip) property).value)); } /** * Returns the name of this property */ public final String getPropertyName() { return propertyName; } /** * Returns the value of this property */ public Object get() { return value; } /** * Returns true if this property is "softly" inherited */ public boolean isSoftlyInherited() { return inherit.equals(value); } /** * Returns a string representation of the object */ public String toString() { if (value instanceof ArrayList) { ArrayList values = (ArrayList) value; StringBuilder sb = new StringBuilder(); for (Object aValue : values) { sb.append(aValue.toString()).append(", "); } sb.setLength(sb.length() - 2); return sb.toString(); } return value.toString(); } /** * Is the value of this property a default value * It is used by all macro for the function <code>print</code> */ public boolean isDefault() { return (border_box == value); } } --- NEW FILE: CssBackgroundAttachment.java --- // $Id: CssBackgroundAttachment.java,v 1.1 2010/01/05 13:49:37 ylafon Exp $ // @author Yves Lafon <http://www.w3.org/TR/2009/CR-css3-background-20091217/#the-background-attachment * Name: background-attachment * Value: <attachment> [ , <attachment> ]* * Initial: scroll * Applies to: all elements * Inherited: no * Percentages: N/A * Media: visual * Computed value: as specified * * If background images are specified, this property specifies whether they * are fixed with regard to the viewport (ÔfixedÕ) or scroll along with the * element (ÔscrollÕ) or its contents (ÔlocalÕ). The property's value is given * as a comma-separated list of <attachment> keywords where * * <attachment> = scroll | fixed | local */ public class CssBackgroundAttachment extends CssProperty { private static final String propertyName = "background-attachment"; public static HashMap<String, CssIdent> allowed_values; public static CssIdent scroll; static { allowed_values = new HashMap<String, CssIdent>(); scroll = CssIdent.getIdent("scroll"); allowed_values.put("scroll", scroll); allowed_values.put("fixed", CssIdent.getIdent("fixed")); allowed_values.put("local", CssIdent.getIdent("local")); } Object value; /** * Create a new CssBackgroundAttachment */ public CssBackgroundAttachment() { value = scroll; } /** * Creates a new CssBackgroundAttachment * * @param ac the context * @param expression The expression for this property * @param check if some length checking is required * @throws InvalidParamException Values are incorrect */ public CssBackgroundAttachment(ApplContext ac, CssExpression expression, boolean check) throws InvalidParamException { ArrayList<CssValue> values = new ArrayList<CssValue>(); char op; CssValue val; setByUser(); while (!expression.end()) { val = expression.getValue(); op = expression.getOperator(); if (val.getType() != CssTypes.CSS_IDENT) { throw new InvalidParamException("value", val, getPropertyName(), ac); } if (inherit.equals(val)) { // if we got inherit after other values, fail // if we got more than one value... fail if ((values.size() > 0) || (expression.getCount() > 1)) { throw new InvalidParamException("value", val, getPropertyName(), ac); } values.add(inherit); } else { // check that it's in the allowed values CssValue new_val = allowed_values.get(val.toString()); if (new_val == null) { throw new InvalidParamException("value", val, getPropertyName(), ac); } values.add(new_val); } expression.next(); // and check that values are separated by commas if (!expression.end() && (op != COMMA)) { throw new InvalidParamException("operator", ((new Character(op)).toString()), ac); } } if (values.size() == 1) { value = values.get(0); } else { value = values; } } public CssBackgroundAttachment(ApplContext ac, CssExpression expression) throws InvalidParamException { this(ac, expression, false); } /** * Returns the value of this property */ public Object get() { return value; } /** * Returns true if this property is "softly" inherited * e.g. his value equals inherit */ public boolean isSoftlyInherited() { return (inherit == value); } /** * Returns a string representation of the object. */ public String toString() { if (value instanceof ArrayList) { ArrayList values = (ArrayList) value; StringBuilder sb = new StringBuilder(); for (Object aValue : values) { sb.append(aValue.toString()).append(", "); } sb.setLength(sb.length() - 2); return sb.toString(); } return value.toString(); } /** * Returns the name of this property */ public final String getPropertyName() { return propertyName; } /** * Add this property to the CssStyle. * * @param style The CssStyle */ public void addToStyle(ApplContext ac, CssStyle style) { CssBackground cssBackground = ((Css1Style) style).cssBackground; if (cssBackground.attachment != null) style.addRedefinitionWarning(ac, this); cssBackground.attachment = this; } /** * Get this property in the style. * * @param style The style where the property is * @param resolve if true, resolve the style to find this property */ public CssProperty getPropertyInStyle(CssStyle style, boolean resolve) { if (resolve) { return ((Css1Style) style).getBackgroundAttachment(); } else { return ((Css1Style) style).cssBackground.attachment; } } /** * Compares two properties for equality. * * @param property The other property. */ public boolean equals(CssProperty property) { return (property instanceof CssBackgroundAttachment && value.equals(((CssBackgroundAttachment) property).value)); } /** * Is the value of this property is a default value. * It is used by all macro for the function <code>print</code> */ public boolean isDefault() { return (scroll == value); } } --- NEW FILE: CssZIndex.java --- // $Id: CssZIndex.java,v 1.1 2010/01/05 13:49:38 ylafon Exp $ // From Philippe Le Hegaret (http://www.w3.org/TR/2009/CR-css3-background-20091217/#the-background-image * * Name: background-image * Value: <bg-image> [ , <bg-image> ]* * Initial: none * Applies to: all elements * Inherited: no * Percentages: N/A * Media: visual * Computed value: as specified, but with URIs made absolute * * This property sets the background image(s) of an element. Images are drawn * with the first specified one on top (closest to the user) and each * subsequent image behind the previous one. Where * * <bg-image> = <image> | none */ public class CssBackgroundImage extends CssProperty { private static final String propertyName = "background-image"; Object url = null; /** * Create a new CssBackgroundImage */ public CssBackgroundImage() { url = none; } /** * Creates a new CssBackgroundImage * * @param ac the context * @param expression The expression for this property * @param check boolean * @throws InvalidParamException Values are incorrect */ public CssBackgroundImage(ApplContext ac, CssExpression expression, boolean check) throws InvalidParamException { ArrayList<CssValue> values = new ArrayList <CssValue>(); setByUser(); CssValue val; char op; while (!expression.end()) { val = expression.getValue(); op = expression.getOperator(); switch (val.getType()) { case CssTypes.CSS_URL: values.add(val); break; case CssTypes.CSS_IDENT: if (inherit.equals(val)) { // if we got inherit after other values, fail // if we got more than one value... fail if ((values.size()>0) || (expression.getCount()>1 )) { throw new InvalidParamException("value", val, getPropertyName(), ac); } values.add(inherit); break; } else if (none.equals(val)) { values.add(none); break; } default: throw new InvalidParamException("value", val, getPropertyName(), ac); } expression.next(); if (!expression.end() && (op != COMMA)) { throw new InvalidParamException("operator", ((new Character(op)).toString()), ac); } } if (values.size() == 1) { url = values.get(0); } else { url = values; } } public CssBackgroundImage(ApplContext ac, CssExpression expression) throws InvalidParamException { this(ac, expression, false); } /** * Returns the value of this property */ public Object get() { return url; } /** * Returns true if this property is "softly" inherited * e.g. his value equals inherit */ public boolean isSoftlyInherited() { return (inherit == url); } /** * Returns a string representation of the object. */ public String toString() { if (url instanceof ArrayList) { ArrayList values = (ArrayList) url; StringBuilder sb = new StringBuilder(); for (Object aValue : values) { sb.append(aValue.toString()).append(", "); } sb.setLength(sb.length() - 2); return sb.toString(); } return url.toString(); } /** * Returns the name of this property */ public final String getPropertyName() { return propertyName; } /** * Add this property to the CssStyle. * * @param style The CssStyle */ public void addToStyle(ApplContext ac, CssStyle style) { CssBackground cssBackground = ((Css1Style) style).cssBackground; if (cssBackground.image != null) style.addRedefinitionWarning(ac, this); cssBackground.image = this; } /** * Get this property in the style. * * @param style The style where the property is * @param resolve if true, resolve the style to find this property */ public CssProperty getPropertyInStyle(CssStyle style, boolean resolve) { if (resolve) { return ((Css1Style) style).getBackgroundImage(); } else { return ((Css1Style) style).cssBackground.image; } } /** * Compares two properties for equality. * * @param property The other property. */ public boolean equals(CssProperty property) { return (property instanceof CssBackgroundImage && url != null && url.equals(((CssBackgroundImage) property).url)); } /** * Is the value of this property is a default value. * It is used by all macro for the function <code>print</code> */ public boolean isDefault() { return (url == none); } } --- NEW FILE: CssBackgroundSize.java --- // $Id: CssBackgroundSize.java,v 1.1 2010/01/05 13:49:37 ylafon Exp $ // @author Yves Lafon <http://www.w3.org/TR/2009/CR-css3-background-20091217/#the-background-size * * <p/> * Name: background-size * Value: <bg-size> [ , <bg-size> ]* * Initial: auto * Applies to: all elements * Inherited: no * Percentages: see text * Media: visual * Computed value: for <length> the absolute value, otherwise as * specified * <p/> * Specifies the size of the background images. Where * <p/> * <bg-size> = [ <length> | <percentage> | auto ]{1,2} | * cover | contain */ public class CssBackgroundSize extends CssProperty { private static final String propertyName = "background-size"; public static CssIdent auto; public static HashMap<String, CssIdent> allowed_values; static { auto = CssIdent.getIdent("auto"); allowed_values = new HashMap<String, CssIdent>(); allowed_values.put("auto", auto); allowed_values.put("cover", CssIdent.getIdent("cover")); allowed_values.put("contain", CssIdent.getIdent("contain")); } Object value; /** * Create a new CssBackgroundSize */ public CssBackgroundSize() { value = auto; } /** * Create a new CssBackgroundSize * * @param ac The context * @param expression The expression for this property * @param check if arguments count must be checked. * @throws InvalidParamException Values are incorrect */ public CssBackgroundSize(ApplContext ac, CssExpression expression, boolean check) throws InvalidParamException { ArrayList<CssValue> values = new ArrayList<CssValue>(); char op; CssValue val; CssValueList vl = null; boolean is_complete = true; setByUser(); while (!expression.end()) { val = expression.getValue(); op = expression.getOperator(); switch (val.getType()) { case CssTypes.CSS_NUMBER: val = ((CssNumber) val).getLength(); case CssTypes.CSS_LENGTH: case CssTypes.CSS_PERCENTAGE: // per spec only non-negative values are allowed float f = ((Float) val.get()).floatValue(); if (f < 0) { throw new InvalidParamException("negative-value", val.toString(), ac); } if (is_complete) { vl = new CssValueList(); vl.add(val); } else { vl.add(val); values.add(vl); } is_complete = !is_complete; break; case CssTypes.CSS_IDENT: if (inherit.equals(val)) { // if we got inherit after other values, fail // if we got more than one value... fail if ((values.size() > 0) || (expression.getCount() > 1)) { throw new InvalidParamException("value", val, getPropertyName(), ac); } values.add(inherit); break; } else if (auto.equals(val)) { if (is_complete) { vl = new CssValueList(); vl.add(auto); } else { vl.add(auto); values.add(vl); } is_complete = !is_complete; break; } else { CssValue v = allowed_values.get(val.toString()); // if ok, and if we are not in a middle of a compound // value... if (v != null && is_complete) { values.add(v); break; } } default: throw new InvalidParamException("value", val, getPropertyName(), ac); } expression.next(); if (!expression.end()) { // incomplete value followed by a comma... it's complete! if (!is_complete && (op == COMMA)) { values.add(vl); is_complete = true; } // complete values are separated by a comma, otherwise space if ((is_complete && (op != COMMA)) || (!is_complete && (op != SPACE))) { throw new InvalidParamException("operator", ((new Character(op)).toString()), ac); } } } // if we reach the end in a value that can come in pair if (!is_complete) { values.add(vl); } if (values.size() == 1) { value = values.get(0); } else { value = values; } } public CssBackgroundSize(ApplContext ac, CssExpression expression) throws InvalidParamException { this(ac, expression, false); } /** * Add this property to the CssStyle * * @param style The CssStyle */ public void addToStyle(ApplContext ac, CssStyle style) { if (((Css3Style) style).cssBackgroundSize != null) style.addRedefinitionWarning(ac, this); ((Css3Style) style).cssBackgroundSize = this; } /** * Get this property in the style. * * @param style The style where the property is * @param resolve if true, resolve the style to find this property */ public CssProperty getPropertyInStyle(CssStyle style, boolean resolve) { if (resolve) { return ((Css3Style) style).getCssBackgroundSize(); } else { return ((Css3Style) style).cssBackgroundSize; } } /** * Compares two properties for equality. * * @param property The other property. */ public boolean equals(CssProperty property) { return (property instanceof CssBackgroundSize && value.equals(((CssBackgroundSize) property).value)); } /** * Returns the name of this property */ public final String getPropertyName() { return propertyName; } /** * Returns the value of this property */ public Object get() { return value; } /** * Returns true if this property is "softly" inherited */ public boolean isSoftlyInherited() { return (inherit == value); } /** * Returns a string representation of the object */ public String toString() { if (value instanceof ArrayList) { ArrayList values = (ArrayList) value; StringBuilder sb = new StringBuilder(); for (Object aValue : values) { sb.append(aValue.toString()).append(", "); } sb.setLength(sb.length() - 2); return sb.toString(); } return value.toString(); } /** * Is the value of this property a default value * It is used by all macro for the function <code>print</code> */ public boolean isDefault() { return (auto == value); } } --- NEW FILE: CssBackgroundColor.java --- // // $Id: CssBackgroundColor.java,v 1.1 2010/01/05 13:49:37 ylafon Exp $ // From Philippe Le Hegaret (Received on Tuesday, 5 January 2010 13:49:44 GMT
This archive was generated by hypermail 2.2.0+W3C-0.50 : Thursday, 26 April 2012 12:55:18 GMT