W3C home > Mailing lists > Public > www-validator-cvs@w3.org > March 2012

2002/css-validator/org/w3c/css/properties/css1 CssFontWeight.java,1.4,1.5

From: Yves Lafon via cvs-syncmail <cvsmail@w3.org>
Date: Mon, 26 Mar 2012 09:20:14 +0000
To: www-validator-cvs@w3.org
Message-Id: <E1SC662-0008PT-Cb@lionel-hutz.w3.org>
Update of /sources/public/2002/css-validator/org/w3c/css/properties/css1
In directory hutz:/tmp/cvs-serv32313

Modified Files:
	CssFontWeight.java 
Log Message:
number checking uses the right tests crom CssNumber instead of checking instanceof of the underlying object (related to <http://www.w3.org/mid/4F642782.70501@kolumbus.fi>

Index: CssFontWeight.java
===================================================================
RCS file: /sources/public/2002/css-validator/org/w3c/css/properties/css1/CssFontWeight.java,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- CssFontWeight.java	5 Jan 2010 13:49:43 -0000	1.4
+++ CssFontWeight.java	26 Mar 2012 09:20:12 -0000	1.5
@@ -10,124 +10,121 @@
 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.CssValue;
+import org.w3c.css.values.*;
 
 /**
- *   <H4>
- *     &nbsp;&nbsp; 'font-weight'
- *   </H4>
- *   <P>
- *   <EM>Value:</EM> normal | bold | bolder | lighter | 100 | 200 | 300 | 400
- *   | 500 | 600 | 700 | 800 | 900<BR>
- *   <EM>Initial:</EM> normal<BR>
- *   <EM>Applies to:</EM> all elements<BR>
- *   <EM>Inherited:</EM> yes<BR>
- *   <EM>Percentage values:</EM> N/A<BR>
- *   <P> The 'font-weight' property selects the weight of the font. The values
- *   '100' to '900' form an ordered sequence, where each number indicates a
- *   weight that is at least as dark as its predecessor. The keyword 'normal' is
- *   synonymous with '400', and 'bold' is synonymous with '700'. Keywords other
- *   than 'normal' and 'bold' have been shown to be often confused with font
- *   names and a numerical scale was therefore chosen for the 9-value list.
- *   <PRE>
- *   P { font-weight: normal }    400
- *   H1 { font-weight: 700 }      bold
+ * <H4>
+ * &nbsp;&nbsp; 'font-weight'
+ * </H4>
+ * <p/>
+ * <EM>Value:</EM> normal | bold | bolder | lighter | 100 | 200 | 300 | 400
+ * | 500 | 600 | 700 | 800 | 900<BR>
+ * <EM>Initial:</EM> normal<BR>
+ * <EM>Applies to:</EM> all elements<BR>
+ * <EM>Inherited:</EM> yes<BR>
+ * <EM>Percentage values:</EM> N/A<BR>
+ * <P> The 'font-weight' property selects the weight of the font. The values
+ * '100' to '900' form an ordered sequence, where each number indicates a
+ * weight that is at least as dark as its predecessor. The keyword 'normal' is
+ * synonymous with '400', and 'bold' is synonymous with '700'. Keywords other
+ * than 'normal' and 'bold' have been shown to be often confused with font
+ * names and a numerical scale was therefore chosen for the 9-value list.
+ * <PRE>
+ * P { font-weight: normal }    400
+ * H1 { font-weight: 700 }      bold
  * </PRE>
- *   <P>
- *   The 'bolder' and 'lighter' values select font weights that are relative to
- *   the weight inherited from the parent:
- *   <PRE>
- *   STRONG { font-weight: bolder }
+ * <p/>
+ * The 'bolder' and 'lighter' values select font weights that are relative to
+ * the weight inherited from the parent:
+ * <PRE>
+ * STRONG { font-weight: bolder }
  * </PRE>
- *   <P>
- *   Child elements inherit the resultant weight, not the keyword value.
- *   <P> Fonts (the font data) typically have one or more properties whose
- *   values are names that are descriptive of the "weight" of a font. There is
- *   no accepted, universal meaning to these weight names. Their primary role is
- *   to distinguish faces of differing darkness within a single font
- *   family. Usage across font families is quite variant; for example a font
- *   that you might think of as being bold might be described as being
- *   <EM>Regular, Roman, Book, Medium, Semi-</EM> or <EM>DemiBold, Bold,</EM> or
- *   <EM>Black,</EM> depending on how black the "normal" face of the font is
- *   within the design. Because there is no standard usage of names, the weight
- *   property values in CSS1 are given on a numerical scale in which the value
- *   '400' (or 'normal') corresponds to the "normal" text face for that
- *   family. The weight name associated with that face will typically be
- *   <EM>Book, Regular, Roman, Normal</EM> or sometimes <EM>Medium</EM>.
- *   <P>
- *   The association of other weights within a family to the numerical weight
- *   values is intended only to preserve the ordering of darkness within that
- *   family. However, the following heuristics tell how the assignment is done
- *   in typical cases:
- *   <UL>
- *     <LI> If the font family already uses a numerical scale with nine values
- *     (like e.g. <EM>OpenType</EM> does), the font weights should be mapped
- *     directly.
- *     <LI> If there is both a face labeled <EM>Medium</EM> and one labeled
- *     <EM>Book, Regular, Roman</EM> or <EM>Normal,</EM> then the
- *     <EM>Medium</EM> is normally assigned to the '500'.
- *     <LI> The font labeled "Bold" will often correspond to the weight value
- *     '700'.
- *     <LI> If there are fewer then 9 weights in the family, the default
- *     algorithm for filling the "holes" is as follows. If '500' is unassigned,
- *     it will be assigned the same font as '400'. If any of the values '600',
- *     '700', '800' or '900' remains unassigned, they are assigned to the same
- *     face as the next darker assigned keyword, if any, or the next lighter one
- *     otherwise. If any of '300', '200' or '100' remains unassigned, it is
- *     assigned to the next lighter assigned keyword, if any, or the next darker
- *     otherwise.
- *   </UL>
- *   <P> The following two examples illustrate the process. Assume four weights
- *   in the "Example1" family, from lightest to darkest: <EM>Regular, Medium,
- *   Bold, Heavy.</EM> And assume six weights in the "Example2" family:
- *   <EM>Book, Medium, Bold, Heavy, Black, ExtraBlack.</EM> Note how in the
- *   second example it has been decided <EM>not</EM> to assign "Example2
- *   ExtraBlack" to anything.
- *   <PRE>
- *     Available faces       |  Assignments  |  Filling the holes
- *     ----------------------+---------------+-------------------
- *     "Example1 Regular"    |  400          |  100, 200, 300
- *     "Example1 Medium"     |  500          |
- *     "Example1 Bold"       |  700          |  600
- *     "Example1 Heavy"      |  800          |  900
+ * <p/>
+ * Child elements inherit the resultant weight, not the keyword value.
+ * <P> Fonts (the font data) typically have one or more properties whose
+ * values are names that are descriptive of the "weight" of a font. There is
+ * no accepted, universal meaning to these weight names. Their primary role is
+ * to distinguish faces of differing darkness within a single font
+ * family. Usage across font families is quite variant; for example a font
+ * that you might think of as being bold might be described as being
+ * <EM>Regular, Roman, Book, Medium, Semi-</EM> or <EM>DemiBold, Bold,</EM> or
+ * <EM>Black,</EM> depending on how black the "normal" face of the font is
+ * within the design. Because there is no standard usage of names, the weight
+ * property values in CSS1 are given on a numerical scale in which the value
+ * '400' (or 'normal') corresponds to the "normal" text face for that
+ * family. The weight name associated with that face will typically be
+ * <EM>Book, Regular, Roman, Normal</EM> or sometimes <EM>Medium</EM>.
+ * <p/>
+ * The association of other weights within a family to the numerical weight
+ * values is intended only to preserve the ordering of darkness within that
+ * family. However, the following heuristics tell how the assignment is done
+ * in typical cases:
+ * <UL>
+ * <LI> If the font family already uses a numerical scale with nine values
+ * (like e.g. <EM>OpenType</EM> does), the font weights should be mapped
+ * directly.
+ * <LI> If there is both a face labeled <EM>Medium</EM> and one labeled
+ * <EM>Book, Regular, Roman</EM> or <EM>Normal,</EM> then the
+ * <EM>Medium</EM> is normally assigned to the '500'.
+ * <LI> The font labeled "Bold" will often correspond to the weight value
+ * '700'.
+ * <LI> If there are fewer then 9 weights in the family, the default
+ * algorithm for filling the "holes" is as follows. If '500' is unassigned,
+ * it will be assigned the same font as '400'. If any of the values '600',
+ * '700', '800' or '900' remains unassigned, they are assigned to the same
+ * face as the next darker assigned keyword, if any, or the next lighter one
+ * otherwise. If any of '300', '200' or '100' remains unassigned, it is
+ * assigned to the next lighter assigned keyword, if any, or the next darker
+ * otherwise.
+ * </UL>
+ * <P> The following two examples illustrate the process. Assume four weights
+ * in the "Example1" family, from lightest to darkest: <EM>Regular, Medium,
+ * Bold, Heavy.</EM> And assume six weights in the "Example2" family:
+ * <EM>Book, Medium, Bold, Heavy, Black, ExtraBlack.</EM> Note how in the
+ * second example it has been decided <EM>not</EM> to assign "Example2
+ * ExtraBlack" to anything.
+ * <PRE>
+ * Available faces       |  Assignments  |  Filling the holes
+ * ----------------------+---------------+-------------------
+ * "Example1 Regular"    |  400          |  100, 200, 300
+ * "Example1 Medium"     |  500          |
+ * "Example1 Bold"       |  700          |  600
+ * "Example1 Heavy"      |  800          |  900
  * </PRE>
- *   <PRE>
- *     Available faces       |  Assignments  |  Filling the holes
- *     ----------------------+---------------+-------------------
- *     "Example2 Book"       |  400          |  100, 200, 300
- *     "Example2 Medium"     |  500          |
- *     "Example2 Bold"       |  700          |  600
- *     "Example2 Heavy"      |  800          |
- *     "Example2 Black"      |  900          |
- *     "Example2 ExtraBlack" |  (none)       |
+ * <PRE>
+ * Available faces       |  Assignments  |  Filling the holes
+ * ----------------------+---------------+-------------------
+ * "Example2 Book"       |  400          |  100, 200, 300
+ * "Example2 Medium"     |  500          |
+ * "Example2 Bold"       |  700          |  600
+ * "Example2 Heavy"      |  800          |
+ * "Example2 Black"      |  900          |
+ * "Example2 ExtraBlack" |  (none)       |
  * </PRE>
- *   <P> Since the intent of the relative keywords 'bolder' and 'lighter' is to
- *   darken or lighten the face <EM>within the family</EM> and because a family
- *   may not have faces aligned with all the symbolic weight values, the
- *   matching of 'bolder' is to the next darker face available on the client
- *   within the family and the matching of 'lighter' is to the next lighter face
- *   within the family.  To be precise, the meaning of the relative keywords
- *   'bolder' and 'lighter' is as follows:
- *   <UL>
- *     <LI> 'bolder' selects the next weight that is assigned to a font that is
- *     darker than the inherited one. If there is no such weight, it simply
- *     results in the next darker numerical value (and the font remains
- *     unchanged), unless the inherited value was '900' in which case the
- *     resulting weight is also '900'.
- *     <LI> 'lighter' is similar, but works in the opposite direction: it
- *     selects the next lighter keyword with a different font from the inherited
- *     one, unless there is no such font, in which case it selects the next
- *     lighter numerical value (and keeps the font unchanged).
- *   </UL>
- *   <P> There is no guarantee that there will be a darker face for each of the
- *   'font-weight' values; for example, some fonts may have only a normal and a
- *   bold face, others may have eight different face weights. There is no
- *   guarantee on how a UA will map font faces within a family to weight
- *   values. The only guarantee is that a face of a given value will be no less
- *   dark than the faces of lighter values.
+ * <P> Since the intent of the relative keywords 'bolder' and 'lighter' is to
+ * darken or lighten the face <EM>within the family</EM> and because a family
+ * may not have faces aligned with all the symbolic weight values, the
+ * matching of 'bolder' is to the next darker face available on the client
+ * within the family and the matching of 'lighter' is to the next lighter face
+ * within the family.  To be precise, the meaning of the relative keywords
+ * 'bolder' and 'lighter' is as follows:
+ * <UL>
+ * <LI> 'bolder' selects the next weight that is assigned to a font that is
+ * darker than the inherited one. If there is no such weight, it simply
+ * results in the next darker numerical value (and the font remains
+ * unchanged), unless the inherited value was '900' in which case the
+ * resulting weight is also '900'.
+ * <LI> 'lighter' is similar, but works in the opposite direction: it
+ * selects the next lighter keyword with a different font from the inherited
+ * one, unless there is no such font, in which case it selects the next
+ * lighter numerical value (and keeps the font unchanged).
+ * </UL>
+ * <P> There is no guarantee that there will be a darker face for each of the
+ * 'font-weight' values; for example, some fonts may have only a normal and a
+ * bold face, others may have eight different face weights. There is no
+ * guarantee on how a UA will map font faces within a family to weight
+ * values. The only guarantee is that a face of a given value will be no less
+ * dark than the faces of lighter values.
  *
  * @version $Revision$
  */
@@ -148,66 +145,69 @@
      * Create a new FontWeight with the default value.
      */
     public CssFontWeight() {
-	// nothing to do
+        // nothing to do
     }
 
     /**
      * Creates a new CssFontWeight with an expression.
      *
      * @param expr the expression
-     * @exception InvalidParamException values are incorrect
+     * @throws InvalidParamException values are incorrect
      */
     public CssFontWeight(ApplContext ac, CssExpression expr, boolean check)
-    	throws InvalidParamException {
-
-	if(check && expr.getCount() > 1) {
-	    throw new InvalidParamException("unrecognize", ac);
-	}
-
-	CssValue val = expr.getValue();
-
-	setByUser();
+            throws InvalidParamException {
 
-	if (val instanceof CssIdent) {
-	    int hash = expr.getValue().hashCode();
+        if (check && expr.getCount() > 1) {
+            throw new InvalidParamException("unrecognize", ac);
+        }
 
-	    // try to find the hashCode in my internal hack array
-	    for (int i=0; i<hash_values.length; i++)
-		if (hash_values[i] == hash) {
-		    this.value = i;
-		    expr.next();
-		    return;
-		}
-	} else if (val instanceof CssNumber) {
-	    Object valf = val.get();
-	    if(valf instanceof Integer) {
-		int vali = ((Integer) valf).intValue();
-		if(isCorrectWeight(vali)) { // verify the entire part number
-		    this.value = vali;
-		    expr.next();
-		    return;
-		}
-	    }
+        CssValue val = expr.getValue();
 
-	}
+        setByUser();
 
-	throw new InvalidParamException("value", expr.getValue().toString(),
-					getPropertyName(), ac);
+        switch (val.getType()) {
+            case CssTypes.CSS_IDENT:
+                int hash = expr.getValue().hashCode();
+                // try to find the hashCode in my internal hack array
+                for (int i = 0; i < hash_values.length; i++) {
+                    if (hash_values[i] == hash) {
+                        this.value = i;
+                        expr.next();
+                        return;
+                    }
+                }
+                throw new InvalidParamException("value", expr.getValue().toString(),
+                        getPropertyName(), ac);
+            case CssTypes.CSS_NUMBER:
+                CssNumber num = (CssNumber) val;
+                if (num.isInteger()) {
+                    int vali = num.getInt();
+                    if (isCorrectWeight(vali)) { // verify the entire part number
+                        this.value = vali;
+                        expr.next();
+                        break;
+                    }
+                }
+            default:
+                throw new InvalidParamException("value", expr.getValue().toString(),
+                        getPropertyName(), ac);
+        }
+        expr.next();
     }
 
     public CssFontWeight(ApplContext ac, CssExpression expression)
-	throws InvalidParamException {
-	this(ac, expression, false);
+            throws InvalidParamException {
+        this(ac, expression, false);
     }
 
     /**
      * Returns the current value.
      */
     public Object get() {
-	if (value >= 100)
-	    return new Integer(value);
-	else
-	    return FONTWEIGHT[value];
+        if (value >= 100)
+            return new Integer(value);
+        else
+            return FONTWEIGHT[value];
     }
 
 
@@ -216,24 +216,24 @@
      * e.g. his value equals inherit
      */
     public boolean isSoftlyInherited() {
-	return value == FONTWEIGHT.length - 1;
+        return value == FONTWEIGHT.length - 1;
     }
 
     /**
      * Returns a string representation of the object.
      */
     public String toString() {
-	if (value >= 100)
-	    return Integer.toString(value);
-	else
-	    return FONTWEIGHT[value];
+        if (value >= 100)
+            return Integer.toString(value);
+        else
+            return FONTWEIGHT[value];
     }
 
     /**
      * Returns the name of this property.
      */
     public String getPropertyName() {
-	return "font-weight";
+        return "font-weight";
     }
 
     /**
@@ -242,24 +242,24 @@
      * @param style The CssStyle
      */
     public void addToStyle(ApplContext ac, CssStyle style) {
-	CssFont cssFont = ((Css1Style) style).cssFont;
-	if (cssFont.fontWeight != null)
-	    style.addRedefinitionWarning(ac, this);
-	cssFont.fontWeight = this;
+        CssFont cssFont = ((Css1Style) style).cssFont;
+        if (cssFont.fontWeight != null)
+            style.addRedefinitionWarning(ac, this);
+        cssFont.fontWeight = this;
     }
 
     /**
      * Get this property in the style.
      *
-     * @param style The style where the property is
+     * @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).getFontWeight();
-	} else {
-	    return ((Css1Style) style).cssFont.fontWeight;
-	}
+        if (resolve) {
+            return ((Css1Style) style).getFontWeight();
+        } else {
+            return ((Css1Style) style).cssFont.fontWeight;
+        }
     }
 
     /**
@@ -268,8 +268,8 @@
      * @param value The other property.
      */
     public boolean equals(CssProperty property) {
-	return (property instanceof CssFontWeight &&
-		((CssFontWeight) property).value == value);
+        return (property instanceof CssFontWeight &&
+                ((CssFontWeight) property).value == value);
     }
 
     /**
@@ -277,18 +277,18 @@
      * It is used by all macro for the function <code>print</code>
      */
     public boolean isDefault() {
-	return value == 0;
+        return value == 0;
     }
 
     private boolean isCorrectWeight(int val) {
-	val = val / 100;
-	return val > 0 && val < 10;
+        val = val / 100;
+        return val > 0 && val < 10;
     }
 
     static {
-	hash_values = new int[FONTWEIGHT.length];
-	for (int i=0; i<FONTWEIGHT.length; i++)
-	    hash_values[i] = FONTWEIGHT[i].hashCode();
+        hash_values = new int[FONTWEIGHT.length];
+        for (int i = 0; i < FONTWEIGHT.length; i++)
+            hash_values[i] = FONTWEIGHT[i].hashCode();
     }
 }
 
Received on Monday, 26 March 2012 09:20:21 UTC

This archive was generated by hypermail 2.3.1 : Wednesday, 7 January 2015 15:17:49 UTC