- From: Yves Lafon via cvs-syncmail <cvsmail@w3.org>
- Date: Thu, 09 Feb 2012 17:36:33 +0000
- To: www-validator-cvs@w3.org
Update of /sources/public/2002/css-validator/org/w3c/css/properties/css2
In directory hutz:/tmp/cvs-serv25830/w3c/css/properties/css2
Modified Files:
CssHeight.java CssWidth.java
Added Files:
CssBackground.java CssBackgroundAttachment.java
CssBackgroundColor.java CssBackgroundImage.java
CssBackgroundPosition.java CssBackgroundRepeat.java
CssLetterSpacing.java CssWhiteSpace.java CssWordSpacing.java
Removed Files:
CssBackgroundAttachmentCSS2.java CssBackgroundCSS2.java
CssBackgroundColorCSS2.java CssBackgroundImageCSS2.java
CssBackgroundPositionCSS2.java CssBackgroundRepeatCSS2.java
Log Message:
various things: Use of BigIntegers to avoid limits, background-* are now avoiding multiplication of checks and properties in CssXStyles impls, various updates for other properties, use of a string reader for string input, added the possibility of not following links, prepared for aggregation of all uris parsed
--- NEW FILE: CssBackgroundRepeat.java ---
//
// $Id: CssBackgroundRepeat.java,v 1.1 2012/02/09 17:36:30 ylafon Exp $
// From Philippe Le Hegaret (Philippe.Le_Hegaret@sophia.inria.fr)
//
// (c) COPYRIGHT MIT and INRIA, 1997.
// Please first read the full copyright statement in file COPYRIGHT.html
package org.w3c.css.properties.css2;
import org.w3c.css.parser.CssStyle;
import org.w3c.css.properties.css.CssProperty;
import org.w3c.css.properties.css1.Css1Style;
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;
/**
* <H4>
* <A NAME="background-repeat">5.3.4 'background-repeat'</A>
* </H4>
* <p/>
* <EM>Value:</EM> repeat | repeat-x | repeat-y | no-repeat<BR>
* <EM>Initial:</EM> repeat<BR>
* <EM>Applies to:</EM> all elements<BR>
* <EM>Inherited:</EM> no<BR>
* <EM>Percentage values:</EM> N/A<BR>
* <p/>
* If a background image is specified, the value of 'background-repeat' determines
* how/if the image is repeated.
* <p/>
* A value of 'repeat' means that the image is repeated both horizontally and
* vertically. The 'repeat-x' ('repeat-y') value makes the image repeat horizontally
* (vertically), to create a single band of images from one side to the other.
* With a value of 'no-repeat', the image is not repeated.
* <PRE>
* BODY {
* background: red url(pendant.gif);
* background-repeat: repeat-y;
* }
* </PRE>
* <p/>
* In the example above, the image will only be repeated vertically.
*
* @version $Revision: 1.1 $
*/
public class CssBackgroundRepeat extends org.w3c.css.properties.css.CssBackgroundRepeat {
// FIXME TODO is that the best way ?
public static boolean checkMatchingIdent(CssIdent ident) {
return allowed_values.containsValue(ident);
}
private static HashMap<String, CssIdent> allowed_values;
static {
allowed_values = new HashMap<String, CssIdent>();
String[] REPEAT = {"repeat", "repeat-x", "repeat-y", "no-repeat"};
for (String aREPEAT : REPEAT) {
allowed_values.put(aREPEAT, CssIdent.getIdent(aREPEAT));
}
}
public CssValue value;
/**
* Create a new CssBackgroundRepeat
*/
public CssBackgroundRepeat() {
value = repeat;
}
/**
* Set the value of the property
*
* @param expression The expression for this property
* @throws InvalidParamException The expression is incorrect
*/
public CssBackgroundRepeat(ApplContext ac, CssExpression expression,
boolean check) throws InvalidParamException {
if (check && expression.getCount() > 1) {
throw new InvalidParamException("unrecognize", ac);
}
CssValue val = expression.getValue();
setByUser();
if (val.getType() != CssTypes.CSS_IDENT) {
throw new InvalidParamException("value", expression.getValue(),
getPropertyName(), ac);
}
if (inherit.equals(val)) {
value = inherit;
} else {
value = allowed_values.get(val.toString());
if (value == null) {
throw new InvalidParamException("value", expression.getValue(),
getPropertyName(), ac);
}
}
expression.next();
}
public CssBackgroundRepeat(ApplContext ac, CssExpression expression)
throws InvalidParamException {
this(ac, expression, false);
}
/**
* Returns the value of this property
*/
public Object get() {
return value;
}
/**
* Returns a string representation of the object.
*/
public String toString() {
return value.toString();
}
// TODO FIXME get rid of this when Css1Style gets only one background
/**
* Add this property to the CssStyle.
*
* @param style The CssStyle
*/
public void addToStyle(ApplContext ac, CssStyle style) {
org.w3c.css.properties.css.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: CssLetterSpacing.java ---
//
// $Id: CssLetterSpacing.java,v 1.1 2012/02/09 17:36:30 ylafon Exp $
// From Philippe Le Hegaret (Philippe.Le_Hegaret@sophia.inria.fr)
//
// (c) COPYRIGHT MIT and INRIA, 1997.
// Please first read the full copyright statement in file COPYRIGHT.html
package org.w3c.css.properties.css2;
import org.w3c.css.properties.css.CssProperty;
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;
/**
* @spec http://www.w3.org/TR/2008/REC-CSS2-20080411/text.html#propdef-letter-spacing
* @version $Revision: 1.1 $
*/
public class CssLetterSpacing extends org.w3c.css.properties.css.CssLetterSpacing {
private CssValue value;
private static CssIdent normal = CssIdent.getIdent("normal");
/**
* Create a new CssLetterSpacing.
*/
public CssLetterSpacing() {
value = normal;
}
/**
* Create a new CssLetterSpacing with an expression
*
* @param expression The expression
* @throws org.w3c.css.util.InvalidParamException The expression is incorrect
*/
public CssLetterSpacing(ApplContext ac, CssExpression expression,
boolean check) throws InvalidParamException {
if (check && expression.getCount() > 1) {
throw new InvalidParamException("unrecognize", ac);
}
CssValue val = expression.getValue();
setByUser();
switch (val.getType()) {
case CssTypes.CSS_NUMBER:
val = ((CssNumber) val).getLength();
case CssTypes.CSS_LENGTH:
value = val;
break;
case CssTypes.CSS_IDENT:
if (inherit.equals(val) || normal.equals(val)) {
value = val;
break;
}
default:
throw new InvalidParamException("value", expression.getValue(),
getPropertyName(), ac);
}
expression.next();
}
public CssLetterSpacing(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 value == inherit;
}
/**
* Returns a string representation of the object.
*/
public String toString() {
return value.toString();
}
/**
* Compares two properties for equality.
*
* @param property The other property.
*/
public boolean equals(CssProperty property) {
return (property instanceof CssLetterSpacing &&
value.equals(((CssLetterSpacing) property).value));
}
}
--- NEW FILE: CssBackgroundAttachment.java ---
//
// $Id: CssBackgroundAttachment.java,v 1.1 2012/02/09 17:36:30 ylafon Exp $
// From Philippe Le Hegaret (Philippe.Le_Hegaret@sophia.inria.fr)
//
// (c) COPYRIGHT MIT and INRIA, 1997.
// Please first read the full copyright statement in file COPYRIGHT.html
package org.w3c.css.properties.css2;
import org.w3c.css.parser.CssStyle;
import org.w3c.css.properties.css.CssProperty;
import org.w3c.css.properties.css1.Css1Style;
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;
/**
* <H4>
* 'background-attachment'
* </H4>
* <p/>
* <EM>Value:</EM> scroll | fixed<BR>
* <EM>Initial:</EM> scroll<BR>
* <EM>Applies to:</EM> all elements<BR>
* <EM>Inherited:</EM> no<BR>
* <EM>Percentage values:</EM> N/A<BR>
* <p/>
* If a background image is specified, the value of 'background-attachment'
* determines if it is fixed with regard to the canvas or if it scrolls along
* with the content.
* <PRE>
* BODY {
* background: red url(pendant.gif);
* background-repeat: repeat-y;
* background-attachment: fixed;
* }
* </PRE>
*
* @version $Revision: 1.1 $
*/
public class CssBackgroundAttachment extends org.w3c.css.properties.css.CssBackgroundAttachment {
public static boolean checkMatchingIdent(CssIdent ident) {
return allowed_values.containsValue(ident);
}
private static HashMap<String,CssIdent> allowed_values;
private 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"));
}
CssIdent value;
/**
* Create a new CssBackgroundAttachment
*/
public CssBackgroundAttachment() {
value = scroll;
}
/**
* Creates a new CssBackgroundAttachment
*
* @param expression The expression for this property
* @throws InvalidParamException Values are incorrect
*/
public CssBackgroundAttachment(ApplContext ac, CssExpression expression,
boolean check) throws InvalidParamException {
if (check && expression.getCount() > 1) {
throw new InvalidParamException("unrecognize", ac);
}
setByUser();
CssValue val = expression.getValue();
if (val.getType() == CssTypes.CSS_IDENT) {
if (inherit.equals(val)) {
value = inherit;
expression.next();
return;
}
CssIdent new_val = allowed_values.get(val.toString());
if (new_val != null) {
value = new_val;
expression.next();
return;
}
}
throw new InvalidParamException("value", expression.getValue(),
getPropertyName(), ac);
}
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() {
return value.toString();
}
/**
* Add this property to the CssStyle.
*
* @param style The CssStyle
*/
public void addToStyle(ApplContext ac, CssStyle style) {
org.w3c.css.properties.css.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 == ((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);
}
}
--- CssBackgroundImageCSS2.java DELETED ---
--- NEW FILE: CssBackground.java ---
//
// $Id: CssBackground.java,v 1.1 2012/02/09 17:36:29 ylafon Exp $
// From Philippe Le Hegaret (Philippe.Le_Hegaret@sophia.inria.fr)
//
// (c) COPYRIGHT MIT and INRIA, 1997.
// Please first read the full copyright statement in file COPYRIGHT.html
package org.w3c.css.properties.css2;
import org.w3c.css.parser.CssSelectors;
import org.w3c.css.parser.CssStyle;
import org.w3c.css.properties.css.CssProperty;
import org.w3c.css.properties.css1.Css1Style;
import org.w3c.css.util.ApplContext;
import org.w3c.css.util.InvalidParamException;
import org.w3c.css.values.CssExpression;
import org.w3c.css.values.CssString;
import org.w3c.css.values.CssValue;
import static org.w3c.css.values.CssOperator.SPACE;
/**
* <H4>
* <A NAME="background">5.3.7 'background'</A>
* </H4>
* <p/>
* <EM>Value:</EM> <background-color> || <background-image> ||
* <background-repeat> || <background-attachment> ||
* <background-position><BR>
* <EM>Initial:</EM> not defined for shorthand properties<BR>
* <EM>Applies to:</EM> all elements<BR>
* <EM>Inherited:</EM> no<BR>
* <EM>Percentage values:</EM> allowed on <background-position><BR>
* <p/>
* The 'background' property is a shorthand property for setting the individual
* background properties (i.e., 'background-color', 'background-image',
* 'background-repeat', 'background-attachment' and 'background-position') at
* the same place in the style sheet.
* <p/>
* Possible values on the 'background' properties are the set of all possible
* values on the individual properties.
* <PRE>
* BODY { background: red }
* P { background: url(chess.png) gray 50% repeat fixed }
* </PRE>
* <P> The 'background' property always sets all the individual background
* properties. In the first rule of the above example, only a value for
* 'background-color' has been given and the other individual properties are
* set to their initial value. In the second rule, all individual properties
* have been specified.
*
* @version $Revision: 1.1 $
* @see org.w3c.css.properties.css.CssBackgroundColor
* @see org.w3c.css.properties.css.CssBackgroundImage
* @see org.w3c.css.properties.css.CssBackgroundRepeat
* @see org.w3c.css.properties.css.CssBackgroundAttachment
* @see org.w3c.css.properties.css.CssBackgroundPosition
*/
public class CssBackground extends org.w3c.css.properties.css.CssBackground {
public CssBackgroundColor color;
public CssBackgroundImage image;
public CssBackgroundRepeat repeat;
public CssBackgroundAttachment attachment;
public CssBackgroundPosition position;
public boolean same;
/**
* Duplicate this property.
*
* @see org.w3c.css.css.CssCascadingOrder#order
*/
public CssProperty duplicate() {
CssBackground cloned = (CssBackground) super.duplicate();
if (cloned != null) {
if (color != null) {
cloned.color = (CssBackgroundColor) color.duplicate();
}
if (image != null) {
cloned.image = (CssBackgroundImage) image.duplicate();
}
if (repeat != null) {
cloned.repeat = (CssBackgroundRepeat) repeat.duplicate();
}
if (attachment != null) {
cloned.attachment = (CssBackgroundAttachment) attachment.duplicate();
}
if (position != null) {
cloned.position = (CssBackgroundPosition) position.duplicate();
}
}
return cloned;
}
/**
* Create a new CssBackground
*/
public CssBackground() {
}
/**
* Set the value of the property
*
* @param expression The expression for this property
* @throws InvalidParamException The expression is incorrect
*/
public CssBackground(ApplContext ac, CssExpression expression,
boolean check) throws InvalidParamException {
CssValue val;
char op;
boolean find = true;
// too many values
if (check && expression.getCount() > 6) {
throw new InvalidParamException("unrecognize", ac);
}
setByUser();
boolean manyValues = (expression.getCount() > 1);
while (find) {
find = false;
val = expression.getValue();
op = expression.getOperator();
if (val == null) {
break;
}
if (inherit.equals(val)) {
if (manyValues) {
// if there are many values, we can't have inherit as one of them
throw new InvalidParamException("unrecognize", null, null, ac);
}
same = true;
expression.next();
// we exit as find is false
continue;
}
// quoted strings are not allowed (CssString)
if (check && (val instanceof CssString)) {
throw new InvalidParamException("unrecognize", ac);
}
if (color == null) {
try {
color = new CssBackgroundColor(ac, expression);
find = true;
} catch (InvalidParamException e) {
// nothing to do, image will test this value
}
}
if (!find && image == null) {
try {
image = new CssBackgroundImage(ac, expression);
find = true;
} catch (InvalidParamException e) {
// nothing to do, repeat will test this value
}
}
if (!find && repeat == null) {
try {
repeat = new CssBackgroundRepeat(ac, expression);
find = true;
} catch (InvalidParamException e) {
// nothing to do, attachment will test this value
}
}
if (!find && attachment == null) {
try {
attachment = new CssBackgroundAttachment(ac, expression);
find = true;
} catch (InvalidParamException e) {
// nothing to do, position will test this value
}
}
if (!find && position == null) {
try {
position = new CssBackgroundPosition(ac, expression);
find = true;
} catch (InvalidParamException e) {
// nothing to do
}
}
if (op != SPACE) {
throw new InvalidParamException("operator",
((new Character(op)).toString()),
ac);
}
if (!find && val != null) {
throw new InvalidParamException("unrecognize", ac);
}
}
}
public CssBackground(ApplContext ac, CssExpression expression)
throws InvalidParamException {
this(ac, expression, false);
}
/**
* @return Returns the attachment.
*/
public CssBackgroundAttachment getAttachment() {
return attachment;
}
/**
* @param attachment The attachment to set.
*/
public void setAttachment(CssBackgroundAttachment attachment) {
this.attachment = attachment;
}
/**
* @return Returns the image.
*/
public CssBackgroundImage getImage() {
return image;
}
/**
* @param image The image to set.
*/
public void setImage(CssBackgroundImage image) {
this.image = image;
}
/**
* @return Returns the repeat.
*/
public CssBackgroundRepeat getRepeat() {
return repeat;
}
/**
* @param repeat The repeat to set.
*/
public void setRepeat(CssBackgroundRepeat repeat) {
this.repeat = repeat;
}
/**
* @return Returns the same.
*/
public boolean isSame() {
return same;
}
/**
* @param same The same to set.
*/
public void setSame(boolean same) {
this.same = same;
}
/**
* Returns the color
*/
public final CssBackgroundColor getColor2() {
return color;
}
/**
* @param color The color to set.
*/
public void setColor(CssBackgroundColor color) {
this.color = color;
}
/**
* @return Returns the position.
*/
public CssBackgroundPosition getPosition() {
return position;
}
/**
* @param position The position to set.
*/
public void setPosition(CssBackgroundPosition position) {
this.position = position;
}
/**
* Returns the value of this property
*/
public Object get() {
return color;
}
/**
* Returns the color
*/
public final CssValue getColor() {
if (color == null) {
return null;
} else {
return color.getColor();
}
}
/**
* Returns a string representation of the object.
*/
public String toString() {
if (same) {
return inherit.toString();
} else {
StringBuilder sb = new StringBuilder();
boolean addspace = false;
if (color != null) {
sb.append(color);
addspace = true;
}
if (image != null) {
if (addspace) {
sb.append(' ');
}
sb.append(image);
addspace = true;
}
if (repeat != null) {
if (addspace) {
sb.append(' ');
}
sb.append(repeat);
addspace = true;
}
if (attachment != null) {
if (addspace) {
sb.append(' ');
}
sb.append(attachment);
addspace = true;
}
if (position != null) {
if (addspace) {
sb.append(' ');
}
sb.append(position);
}
return sb.toString();
}
}
/**
* Set this property to be important.
* Overrides this method for a macro
*/
public void setImportant() {
important = true;
if (color != null) {
color.important = true;
}
if (image != null) {
image.important = true;
}
if (repeat != null) {
repeat.important = true;
}
if (attachment != null) {
attachment.important = true;
}
if (position != null) {
position.important = true;
}
}
/**
* Returns true if this property is important.
* Overrides this method for a macro
*/
public boolean getImportant() {
if (same) {
return important;
}
return ((color == null || color.important) &&
(image == null || image.important) &&
(repeat == null || repeat.important) &&
(attachment == null || attachment.important) &&
(position == null || position.important));
}
/**
* Set the context.
* Overrides this method for a macro
*
* @see org.w3c.css.css.CssCascadingOrder#order
* @see org.w3c.css.css.StyleSheetParser#handleRule
*/
public void setSelectors(CssSelectors selector) {
super.setSelectors(selector);
if (color != null) {
color.setSelectors(selector);
}
if (image != null) {
image.setSelectors(selector);
}
if (repeat != null) {
repeat.setSelectors(selector);
}
if (attachment != null) {
attachment.setSelectors(selector);
}
if (position != null) {
position.setSelectors(selector);
}
}
/**
* Add this property to the CssStyle
*
* @param style The CssStyle
*/
public void addToStyle(ApplContext ac, CssStyle style) {
((Css1Style) style).cssBackground.same = same;
((Css1Style) style).cssBackground.byUser = byUser;
if (color != null) {
color.addToStyle(ac, style);
}
if (image != null) {
image.addToStyle(ac, style);
}
if (repeat != null) {
repeat.addToStyle(ac, style);
}
if (attachment != null) {
attachment.addToStyle(ac, style);
}
if (position != null) {
position.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 ((Css1Style) style).getBackground();
} else {
return ((Css1Style) style).cssBackground;
}
}
/**
* Compares two properties for equality.
*
* @param property The other property.
*/
public boolean equals(CssProperty property) {
return false; // FIXME
}
/**
* Update the source file and the line.
* Overrides this method for a macro
*
* @param line The line number where this property is defined
* @param source The source file where this property is defined
*/
public void setInfo(int line, String source) {
super.setInfo(line, source);
if (color != null) {
color.setInfo(line, source);
}
if (image != null) {
image.setInfo(line, source);
}
if (repeat != null) {
repeat.setInfo(line, source);
}
if (attachment != null) {
attachment.setInfo(line, source);
}
if (position != null) {
position.setInfo(line, source);
}
}
}
Index: CssHeight.java
===================================================================
RCS file: /sources/public/2002/css-validator/org/w3c/css/properties/css2/CssHeight.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- CssHeight.java 27 Sep 2011 08:15:45 -0000 1.1
+++ CssHeight.java 9 Feb 2012 17:36:30 -0000 1.2
@@ -63,7 +63,7 @@
val = ((CssNumber) val).getLength();
case CssTypes.CSS_LENGTH:
lenVal = (CssLength) val;
- if (lenVal.floatValue() < 0.) {
+ if (!lenVal.isPositive()) {
throw new InvalidParamException("negative-value",
val.toString(), ac);
}
--- CssBackgroundRepeatCSS2.java DELETED ---
--- NEW FILE: CssBackgroundPosition.java ---
//
// $Id: CssBackgroundPosition.java,v 1.1 2012/02/09 17:36:30 ylafon Exp $
// From Philippe Le Hegaret (Philippe.Le_Hegaret@sophia.inria.fr)
//
// (c) COPYRIGHT MIT and INRIA, 1997.
// Please first read the full copyright statement in file COPYRIGHT.html
package org.w3c.css.properties.css2;
import org.w3c.css.parser.CssStyle;
import org.w3c.css.properties.css.CssProperty;
import org.w3c.css.properties.css1.Css1Style;
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.CssPercentage;
import org.w3c.css.values.CssTypes;
import org.w3c.css.values.CssValue;
import java.util.HashMap;
import static org.w3c.css.values.CssOperator.SPACE;
/**
* <H4>
* 'background-position'
* </H4>
* <p/>
* <EM>Value:</EM> [<percentage> | <length>]{1,2} | [top | center
* | bottom] || [left | center | right]<BR>
* <EM>Initial:</EM> 0% 0%<BR>
* <EM>Applies to:</EM> block-level and replaced elements<BR>
* <EM>Inherited:</EM> no<BR>
* <EM>Percentage values:</EM> refer to the size of the element itself<BR>
* <P> If a background image has been specified, the value of
* 'background-position' specifies its initial position.
* <P> With a value pair of '0% 0%', the upper left corner of the image is
* placed in the upper left corner of the box that surrounds the content of
* the element (i.e., not the box that surrounds the padding, border or
* margin). A value pair of '100% 100%' places the lower right corner of the
* image in the lower right corner of the element. With a value pair of '14%
* 84%', the point 14% across and 84% down the image is to be placed at the
* point 14% across and 84% down the element.
* <P> With a value pair of '2cm 2cm', the upper left corner of the image is
* placed 2cm to the right and 2cm below the upper left corner of the element.
* <P> If only one percentage or length value is given, it sets the horizontal
* position only, the vertical position will be 50%. If two values are given,
* the horizontal position comes first. Combinations of length and percentage
* values are allowed, e.g. '50% 2cm'. Negative positions are allowed.
* <P> One can also use keyword values to indicate the position of the
* background image. Keywords cannot be combined with percentage values, or
* length values. The possible combinations of keywords and their
* interpretations are as follows:
* <p/>
* <UL>
* <LI>
* 'top left' and 'left top' both mean the same as '0% 0%'.
* <LI>
* 'top', 'top center' and 'center top' mean the same as '50% 0%'.
* <LI>
* 'right top' and 'top right' mean the same as '100% 0%'.
* <LI>
* 'left', 'left center' and 'center left' mean the same as '0% 50%'.
* <LI>
* 'center' and 'center center' mean the same as '50% 50%'.
* <LI>
* 'right', 'right center' and 'center right' mean the same as '100% 50%'.
* <LI>
* 'bottom left' and 'left bottom' mean the same as '0% 100%'.
* <LI>
* 'bottom', 'bottom center' and 'center bottom' mean the same as
* '50% 100%'.
* <LI>
* 'bottom right' and 'right bottom' mean the same as '100% 100%'.
* </UL>
* <p/>
* examples:
* <PRE>
* BODY { background: url(banner.jpeg) right top } / * 100% 0% * /
* BODY { background: url(banner.jpeg) top center } / * 50% 0% * /
* BODY { background: url(banner.jpeg) center } / * 50% 50% * /
* BODY { background: url(banner.jpeg) bottom } / * 50% 100% * /
* </PRE>
* <p/>
* If the background image is fixed with regard to the canvas (see the
* 'background-attachment' property above), the image is placed relative to
* the canvas instead of the element. E.g.:
* <PRE>
* BODY {
* background-image: url(logo.png);
* background-attachment: fixed;
* background-position: 100% 100%;
* }
* </PRE>
* <p/>
* In the example above, the image is placed in the lower right corner of the
* canvas.
*
* @version $Revision: 1.1 $
* @see org.w3c.css.properties.css.CssBackgroundAttachment
*/
public class CssBackgroundPosition extends org.w3c.css.properties.css.CssBackgroundPosition {
public static boolean checkMatchingIdent(CssIdent ident) {
return allowed_values.containsValue(ident);
}
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);
}
public CssValue value;
/**
* Create a new CssBackgroundPosition
*/
public CssBackgroundPosition() {
super();
}
/**
* 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 {
int nb_val = expression.getCount();
if (check && nb_val > 2) {
throw new InvalidParamException("unrecognize", ac);
}
setByUser();
setByUser();
CssValue val;
CssBackgroundPositionValue b_val = null;
char op;
// 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 (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);
value = b_val;
}
}
// check the value
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 > 2) {
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);
}
}
// 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:
// should never happen
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:
// we got two keywords for two values, yeah!
CssIdent id1 = (CssIdent) v.value.get(0);
CssIdent id2 = (CssIdent) v.value.get(1);
if (((isVertical(id1) && isVertical(id2))) ||
(isHorizontal(id1) && isHorizontal(id2))) {
throw new InvalidParamException("incompatible",
id1, id2, ac);
}
if (isVertical(id1) || isHorizontal(id2)) {
v.horizontal = id2;
v.val_horizontal = identToPercent(id2);
v.vertical = id1;
v.val_vertical = identToPercent(id1);
} else {
v.horizontal = id1;
v.val_horizontal = identToPercent(id1);
v.vertical = id2;
v.val_vertical = identToPercent(id2);
}
}
}
public CssBackgroundPosition(ApplContext ac, CssExpression expression)
throws InvalidParamException {
this(ac, expression, false);
}
public String toString() {
return value.toString();
}
/**
* Add this property to the CssStyle.
*
* @param style The CssStyle
*/
public void addToStyle(ApplContext ac, CssStyle style) {
org.w3c.css.properties.css.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;
}
}
}
--- NEW FILE: CssWordSpacing.java ---
//
// $Id: CssWordSpacing.java,v 1.1 2012/02/09 17:36:31 ylafon Exp $
// From Philippe Le Hegaret (Philippe.Le_Hegaret@sophia.inria.fr)
//
// (c) COPYRIGHT MIT and INRIA, 1997.
// Please first read the full copyright statement in file COPYRIGHT.html
package org.w3c.css.properties.css2;
import org.w3c.css.properties.css.CssProperty;
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;
/**
* @spec http://www.w3.org/TR/2008/REC-CSS2-20080411/text.html#propdef-word-spacing
* @version $Revision: 1.1 $
*/
public class CssWordSpacing extends org.w3c.css.properties.css.CssWordSpacing {
private CssValue value;
private static CssIdent normal = CssIdent.getIdent("normal");
/**
* Create a new CssWordSpacing.
*/
public CssWordSpacing() {
value = normal;
}
/**
* Create a new CssWordSpacing with an expression
*
* @param expression The expression
* @throws org.w3c.css.util.InvalidParamException The expression is incorrect
*/
public CssWordSpacing(ApplContext ac, CssExpression expression,
boolean check) throws InvalidParamException {
if (check && expression.getCount() > 1) {
throw new InvalidParamException("unrecognize", ac);
}
CssValue val = expression.getValue();
setByUser();
switch (val.getType()) {
case CssTypes.CSS_NUMBER:
val = ((CssNumber) val).getLength();
case CssTypes.CSS_LENGTH:
value = val;
break;
case CssTypes.CSS_IDENT:
if (inherit.equals(val) || normal.equals(val)) {
value = val;
break;
}
default:
throw new InvalidParamException("value", expression.getValue(),
getPropertyName(), ac);
}
expression.next();
}
public CssWordSpacing(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 value == inherit;
}
/**
* Returns a string representation of the object.
*/
public String toString() {
return value.toString();
}
/**
* Compares two properties for equality.
*
* @param property The other property.
*/
public boolean equals(CssProperty property) {
return (property instanceof CssWordSpacing &&
value.equals(((CssWordSpacing) property).value));
}
}
--- CssBackgroundColorCSS2.java DELETED ---
--- CssBackgroundAttachmentCSS2.java DELETED ---
--- NEW FILE: CssBackgroundImage.java ---
//
// $Id: CssBackgroundImage.java,v 1.1 2012/02/09 17:36:30 ylafon Exp $
// From Philippe Le Hegaret (Philippe.Le_Hegaret@sophia.inria.fr)
//
// (c) COPYRIGHT MIT and INRIA, 1997.
// Please first read the full copyright statement in file COPYRIGHT.html
package org.w3c.css.properties.css2;
import org.w3c.css.parser.CssStyle;
import org.w3c.css.properties.css.CssProperty;
import org.w3c.css.properties.css1.Css1Style;
import org.w3c.css.util.ApplContext;
import org.w3c.css.util.InvalidParamException;
import org.w3c.css.values.CssExpression;
import org.w3c.css.values.CssTypes;
import org.w3c.css.values.CssValue;
/**
* <H4>
* 'background-image'
* </H4>
* <p/>
* <EM>Value:</EM> <url> | none<BR>
* <EM>Initial:</EM> none<BR>
* <EM>Applies to:</EM> all elements<BR>
* <EM>Inherited:</EM> no<BR>
* <EM>Percentage values:</EM> N/A<BR>
* <P> This property sets the background image of an element. When setting a
* background image, one should also set a background color that will be used
* when the image is unavailable. When the image is available, it is overlaid
* on top of the background color.
* <PRE>
* BODY { background-image: url(marble.gif) }
* P { background-image: none }
* </PRE>
*
* @version $Revision: 1.1 $
*/
public class CssBackgroundImage extends org.w3c.css.properties.css.CssBackgroundImage {
public CssValue 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 if count check must be performed
* @throws InvalidParamException Values are incorrect
*/
public CssBackgroundImage(ApplContext ac, CssExpression expression,
boolean check) throws InvalidParamException {
if (check && expression.getCount() > 1) {
throw new InvalidParamException("unrecognize", ac);
}
setByUser();
CssValue val = expression.getValue();
switch (val.getType()) {
case CssTypes.CSS_URL:
url = val;
break;
case CssTypes.CSS_IDENT:
if (inherit.equals(val)) {
url = inherit;
break;
}
if (none.equals(val)) {
url = none;
break;
}
default:
throw new InvalidParamException("value", val,
getPropertyName(), ac);
}
expression.next();
}
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 (url == inherit);
}
/**
* Returns a string representation of the object.
*/
public String toString() {
return url.toString();
}
/**
* Add this property to the CssStyle.
*
* @param style The CssStyle
*/
public void addToStyle(ApplContext ac, CssStyle style) {
org.w3c.css.properties.css.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 == null && url == null)
|| (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: CssWhiteSpace.java ---
// $Id: CssWhiteSpace.java,v 1.1 2012/02/09 17:36:31 ylafon Exp $
//
// (c) COPYRIGHT MIT, ERCIM and Keio University, 2012.
// Please first read the full copyright statement in file COPYRIGHT.html
package org.w3c.css.properties.css2;
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;
/**
* @version $Revision: 1.1 $
* @spec http://www.w3.org/TR/2008/REC-CSS2-20080411/text.html#white-space-prop
*/
public class CssWhiteSpace extends org.w3c.css.properties.css.CssWhiteSpace {
CssValue value;
public static HashMap<String, CssIdent> allowed_values;
static {
allowed_values = new HashMap<String, CssIdent>();
String[] WHITESPACE = {
"normal", "pre", "nowrap"
};
for (String aWS : WHITESPACE) {
allowed_values.put(aWS, CssIdent.getIdent(aWS));
}
}
/**
* Create a new CssWhiteSpace
*
* @param expression The expression for this property
* @throws org.w3c.css.util.InvalidParamException
* values are incorrect
*/
public CssWhiteSpace(ApplContext ac, CssExpression expression, boolean check)
throws InvalidParamException {
if (check && expression.getCount() > 1) {
throw new InvalidParamException("unrecognize", ac);
}
CssValue val = expression.getValue();
setByUser();
if (val.getType() == CssTypes.CSS_IDENT) {
if (inherit.equals(val)) {
value = inherit;
} else {
value = allowed_values.get(val.toString());
}
if (value != null) {
expression.next();
return;
}
}
throw new InvalidParamException("value", expression.getValue(),
getPropertyName(), ac);
}
/**
* 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() {
return value.toString();
}
public CssWhiteSpace(ApplContext ac, CssExpression expression)
throws InvalidParamException {
this(ac, expression, false);
}
}
--- NEW FILE: CssBackgroundColor.java ---
//
// $Id: CssBackgroundColor.java,v 1.1 2012/02/09 17:36:30 ylafon Exp $
// From Philippe Le Hegaret (Philippe.Le_Hegaret@sophia.inria.fr)
//
// (c) COPYRIGHT MIT and INRIA, 1997.
// Please first read the full copyright statement in file COPYRIGHT.html
package org.w3c.css.properties.css2;
import org.w3c.css.parser.CssStyle;
import org.w3c.css.properties.css.CssProperty;
import org.w3c.css.properties.css1.Css1Style;
import org.w3c.css.util.ApplContext;
import org.w3c.css.util.InvalidParamException;
import org.w3c.css.values.CssExpression;
import org.w3c.css.values.CssTypes;
import org.w3c.css.values.CssValue;
/**
* @spec http://www.w3.org/TR/2008/REC-CSS2-20080411/colors.html#propdef-background-color
*/
public class CssBackgroundColor extends org.w3c.css.properties.css.CssBackgroundColor {
public CssValue color;
/**
* Create a new CssBackgroundColor
*/
public CssBackgroundColor() {
color = transparent;
}
/**
* Create a new CssBackgroundColor
*
* @param expression The expression for this property
* @throws InvalidParamException Values are incorrect
*/
public CssBackgroundColor(ApplContext ac, CssExpression expression,
boolean check) throws InvalidParamException {
if (check && expression.getCount() > 1) {
throw new InvalidParamException("unrecognize", ac);
}
setByUser();
CssValue val = expression.getValue();
switch (val.getType()) {
case CssTypes.CSS_COLOR:
setColor(val);
break;
case CssTypes.CSS_IDENT:
if (transparent.equals(val)) {
setColor(transparent);
break;
}
if (inherit.equals(val)) {
setColor(inherit);
break;
}
setColor(new org.w3c.css.values.CssColor(ac,
(String) val.get()));
break;
default:
throw new InvalidParamException("value", val.toString(),
getPropertyName(), ac);
}
expression.next();
}
public CssBackgroundColor(ApplContext ac, CssExpression expression)
throws InvalidParamException {
this(ac, expression, false);
}
/**
* @param color The color to set.
*/
public void setColor(CssValue color) {
this.color = color;
}
/**
* Returns the value of this property
*/
public Object get() {
return color;
}
/**
* Returns the color
*/
public final CssValue getColor() {
return color;
}
/**
* Returns true if this property is "softly" inherited
* e.g. his value equals inherit
*/
public boolean isSoftlyInherited() {
return color.equals(inherit);
}
/**
* Returns a string representation of the object.
*/
public String toString() {
if (color != null) {
return color.toString();
}
return "";
}
/**
* Add this property to the CssStyle.
*
* @param style The CssStyle
*/
public void addToStyle(ApplContext ac, CssStyle style) {
org.w3c.css.properties.css.CssBackground cssBackground = ((Css1Style) style).cssBackground;
if (cssBackground.color != null)
style.addRedefinitionWarning(ac, this);
cssBackground.color = 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).getBackgroundColor();
} else {
return ((Css1Style) style).cssBackground.color;
}
}
/**
* Compares two properties for equality.
*
* @param property The other property.
*/
public boolean equals(CssProperty property) {
return (property instanceof CssBackgroundColor &&
color.equals(((CssBackgroundColor) property).color));
}
/**
* 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 color == transparent;
}
}
--- CssBackgroundCSS2.java DELETED ---
Index: CssWidth.java
===================================================================
RCS file: /sources/public/2002/css-validator/org/w3c/css/properties/css2/CssWidth.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- CssWidth.java 27 Sep 2011 08:15:46 -0000 1.1
+++ CssWidth.java 9 Feb 2012 17:36:31 -0000 1.2
@@ -63,7 +63,7 @@
val = ((CssNumber) val).getLength();
case CssTypes.CSS_LENGTH:
lenVal = (CssLength) val;
- if (lenVal.floatValue() < 0.) {
+ if (!lenVal.isPositive()) {
throw new InvalidParamException("negative-value",
val.toString(), ac);
}
--- CssBackgroundPositionCSS2.java DELETED ---
Received on Thursday, 9 February 2012 17:37:12 UTC