@​font-face font-style descriptor per https://www.w3.org/TR/2021/WD-c…

…ss-fonts-4-20210729/#descdef-font-face-font-style

org/w3c/css/properties/CSS3Properties.properties

@@ -516,12 +516,12 @@ lighting-color:                         org.w3c.css.properties.css3.CssLightingC
 @font-face.definition-src:              org.w3c.css.properties.css2.font.DefinitionSrc
 @font-face.mathline:                    org.w3c.css.properties.css2.font.Mathline
 @font-face.topline:                     org.w3c.css.properties.css2.font.Topline
-@font-face.font-style:                  org.w3c.css.properties.css2.font.FontStyle
+@font-face.font-style:                  org.w3c.css.properties.css3.fontface.CssFontStyle
 @font-face.font-variant:                org.w3c.css.properties.css2.font.FontVariant
 @font-face.font-weight:                 org.w3c.css.properties.css3.fontface.CssFontWeight
 @font-face.font-size:                   org.w3c.css.properties.css2.font.FontSize
 @font-face.font-family:                 org.w3c.css.properties.css2.font.FontFamily
-@font-face.font-stretch:                org.w3c.css.properties.css3.fontface.CssFontStretch\
+@font-face.font-stretch:                org.w3c.css.properties.css3.fontface.CssFontStretch
 @font-face.font-display:                org.w3c.css.properties.css3.fontface.CssFontDisplay
 
 // mediafeatures

org/w3c/css/properties/css/fontface/CssFontStyle.java

@@ -0,0 +1,113 @@
+//
+// Author: Yves Lafon <ylafon@w3.org>
+//
+// (c) COPYRIGHT MIT, ERCIM, Keio, Beihang, 2021.
+// Please first read the full copyright statement in file COPYRIGHT.html
+package org.w3c.css.properties.css.fontface;
+
+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;
+
+/**
+ * @since CSS3
+ */
+public class CssFontStyle extends CssProperty {
+
+    /**
+     * Create a new CssFontStyle
+     */
+    public CssFontStyle() {
+    }
+
+    /**
+     * Creates a new CssFontStyle
+     *
+     * @param expression The expression for this property
+     * @throws InvalidParamException Expressions are incorrect
+     */
+    public CssFontStyle(ApplContext ac, CssExpression expression, boolean check)
+            throws InvalidParamException {
+        throw new InvalidParamException("value",
+                expression.getValue().toString(),
+                getPropertyName(), ac);
+    }
+
+    public CssFontStyle(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 "font-style";
+    }
+
+    /**
+     * Returns true if this property is "softly" inherited
+     * e.g. his value is equals to inherit
+     */
+    public boolean isSoftlyInherited() {
+        return value.equals(inherit);
+    }
+
+    /**
+     * 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) {
+        Css3Style s = (Css3Style) style;
+        if (s.fontFaceCssFontStyle != null) {
+            style.addRedefinitionWarning(ac, this);
+        }
+        s.fontFaceCssFontStyle = this;
+    }
+
+
+    /**
+     * Compares two properties for equality.
+     *
+     * @param property The other property.
+     */
+    public boolean equals(CssProperty property) {
+        return (property instanceof CssFontStyle &&
+                value.equals(property.value));
+    }
+
+
+    /**
+     * 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).getFontFaceCssFontStyle();
+        } else {
+            return ((Css3Style) style).fontFaceCssFontStyle;
+        }
+    }
+}
+

org/w3c/css/properties/css3/Css3Style.java

@@ -302,6 +302,7 @@
 import org.w3c.css.properties.css.counterstyle.CssSystem;
 import org.w3c.css.properties.css.fontface.CssFontDisplay;
 import org.w3c.css.properties.css.fontface.CssFontStretch;
+import org.w3c.css.properties.css.fontface.CssFontStyle;
 import org.w3c.css.properties.css.fontface.CssFontWeight;
 import org.w3c.css.properties.css.viewport.CssMaxZoom;
 import org.w3c.css.properties.css.viewport.CssMinZoom;
@@ -582,6 +583,7 @@ public class Css3Style extends ATSCStyle {
     public CssFontDisplay fontFaceCssFontDisplay;
     public CssFontWeight fontFaceCssFontWeight;
     public CssFontStretch fontFaceCssFontStretch;
+    public CssFontStyle fontFaceCssFontStyle;
 
     public CssColorAdjust cssColorAdjust;
     public CssForcedColorAdjust cssForcedColorAdjust;
@@ -1301,6 +1303,15 @@ public CssFontStretch getFontFaceCssFontStretch() {
         }
         return fontFaceCssFontStretch;
     }
+
+    public CssFontStyle getFontFaceCssFontStyle() {
+        if (fontFaceCssFontStyle == null) {
+            fontFaceCssFontStyle =
+                    (CssFontStyle) style.CascadingOrder(new CssFontStyle(),
+                            style, selector);
+        }
+        return fontFaceCssFontStyle;
+    }
 
     public CssFontWeight getFontFaceCssFontWeight() {
         if (fontFaceCssFontWeight == null) {

org/w3c/css/properties/css3/CssFontStyle.java

@@ -24,7 +24,7 @@ public class CssFontStyle extends org.w3c.css.properties.css.CssFontStyle {
 
     static final String[] _allowed_values = {"italic", "normal", "oblique"};
     static final ArrayList<CssIdent> allowed_values;
-    static final CssIdent oblique = CssIdent.getIdent("oblique");
+    static public final CssIdent oblique = CssIdent.getIdent("oblique");
 
     static {
         allowed_values = new ArrayList<CssIdent>(_allowed_values.length);

org/w3c/css/properties/css3/fontface/CssFontStyle.java

@@ -0,0 +1,121 @@
+//
+// Author: Yves Lafon <ylafon@w3.org>
+//
+// (c) COPYRIGHT MIT, ERCIM, Keio, Beihang, 2018.
+// Please first read the full copyright statement in file COPYRIGHT.html
+package org.w3c.css.properties.css3.fontface;
+
+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 org.w3c.css.values.CssValueList;
+
+import java.util.ArrayList;
+
+import static org.w3c.css.properties.css3.CssFontStyle.getMatchingIdent;
+import static org.w3c.css.properties.css3.CssFontStyle.oblique;
+import static org.w3c.css.values.CssOperator.SPACE;
+
+/**
+ * @spec https://www.w3.org/TR/2021/WD-css-fonts-4-20210729/#descdef-font-face-font-style
+ * @see org.w3c.css.properties.css3.CssFontStyle
+ */
+public class CssFontStyle extends org.w3c.css.properties.css.fontface.CssFontStyle {
+
+    public static final CssIdent auto = CssIdent.getIdent("auto");
+
+    /**
+     * Create a new CssFontStyle
+     */
+    public CssFontStyle() {
+        value = initial;
+    }
+
+    /**
+     * Creates a new CssFontStyle
+     *
+     * @param expression The expression for this property
+     * @throws InvalidParamException Expressions are incorrect
+     */
+    public CssFontStyle(ApplContext ac, CssExpression expression, boolean check)
+            throws InvalidParamException {
+        if (check && expression.getCount() > 3) {
+            throw new InvalidParamException("unrecognize", ac);
+        }
+
+        setByUser();
+
+        char op;
+        CssValue val;
+        ArrayList<CssValue> values = new ArrayList<>();
+
+        val = expression.getValue();
+        op = expression.getOperator();
+
+        switch (val.getType()) {
+            case CssTypes.CSS_IDENT:
+                CssIdent id = val.getIdent();
+                if (auto.equals(id)) {
+                    if (expression.getCount() > 1) {
+                        throw new InvalidParamException("unrecognize", ac);
+                    }
+                    value = val;
+                    expression.next();
+                    break;
+                }
+                if (getMatchingIdent(id) != null) {
+                    if (oblique.equals(id)) {
+                        values.add(val);
+                        // check for extra angle values
+                        expression.next();
+                        while (!expression.end()) {
+                            if (op != SPACE) {
+                                throw new InvalidParamException("operator",
+                                        Character.toString(op), ac);
+                            }
+                            val = expression.getValue();
+                            op = expression.getOperator();
+                            if (val.getType() != CssTypes.CSS_ANGLE) {
+                                throw new InvalidParamException("value",
+                                        val.toString(),
+                                        getPropertyName(), ac);
+                            }
+                            values.add(val);
+                            expression.next();
+                        }
+                        if (values.size() > 3) {
+                            throw new InvalidParamException("value",
+                                    values.get(values.size() - 1).toString(),
+                                    getPropertyName(), ac);
+                        }
+                        value = new CssValueList(values);
+                    } else {
+                        // single value
+                        if (expression.getCount() > 1) {
+                            throw new InvalidParamException("value",
+                                    val.toString(),
+                                    getPropertyName(), ac);
+                        }
+                        value = val;
+                        expression.next();
+                    }
+                    break;
+                }
+            default:
+                throw new InvalidParamException("value",
+                        val.toString(),
+                        getPropertyName(), ac);
+        }
+
+    }
+
+    public CssFontStyle(ApplContext ac, CssExpression expression)
+            throws InvalidParamException {
+        this(ac, expression, false);
+    }
+
+}
+