// transform 0.04s linear, opacity 0.04s linear, visibility 0.04s linear;
// -webkit-transform 0.04s linear, opacity 0.04s linear, visibility 0.04s linear;
public static CssValue PatchValue(CssValue value, Browser browser)
{
if (value.Kind != NodeKind.ValueList) return value;
var a = (CssValueList)value;
var list = new CssValueList(a.Seperator);
foreach (var node in a)
{
if (node.Kind == NodeKind.ValueList) // For comma seperated componented lists
{
list.Add(PatchValue(node, browser));
}
else if (node.Kind == NodeKind.String && node.ToString() == "transform")
{
list.Add(new CssString(browser.Prefix.Text + "transform"));
}
else
{
list.Add(node);
}
}
return list;
}
// ||, &&, ==, !=
// +, -, *, /, %
public BinaryExpression(CssValue left, BinaryOperator op, CssValue right)
: base(NodeKind.Expression)
{
Left = left;
Operator = op;
Right = right;
}
protected static bool MoveValue(ref CssValue aSource, ref CssValue aDest)
{
bool changed = aSource != aDest;
aDest = aSource;
aSource.Reset();
return changed;
}
public virtual void TestCssReadOnly()
{
CssValue cssValue = _getCssValue(aCssText, false);
Assert.AreEqual(false, cssValue.ReadOnly);
cssValue = _getCssValue(aCssText, true);
Assert.AreEqual(true, cssValue.ReadOnly);
}
public PeriodicValue(IPropertyValue[] options, IEnumerable<CssToken> tokens, String[] labels)
{
_top = options[0];
_right = options[1] ?? _top;
_bottom = options[2] ?? _top;
_left = options[3] ?? _right;
_original = new CssValue(tokens);
_labels = labels;
}
public void PresAttUpdating()
{
SvgStyleableElement elm = Util.GetXmlElement("<title fill='black' />", "", "title") as SvgStyleableElement;
Assert.AreEqual(CssValue.GetCssValue("black", false).CssText, elm.GetPresentationAttribute("fill").CssText);
elm.SetAttribute("fill", "red");
Assert.AreEqual(CssValue.GetCssValue("red", false).CssText, elm.GetPresentationAttribute("fill").CssText);
}
public void PresAttSettingNew()
{
SvgStyleableElement elm = Util.GetXmlElement("<title />", "", "title") as SvgStyleableElement;
Assert.IsNull(elm.GetPresentationAttribute("stroke"));
elm.SetAttribute("stroke", "red");
Assert.AreEqual(CssValue.GetCssValue("red", false).CssText, elm.GetPresentationAttribute("stroke").CssText);
}
public PeriodicValue(IPropertyValue[] options, IEnumerable <CssToken> tokens, String[] labels)
{
_top = options[0];
_right = options[1] ?? _top;
_bottom = options[2] ?? _top;
_left = options[3] ?? _right;
_original = new CssValue(tokens);
_labels = labels;
}
public void ComponentValues()
{
Assert.Equal("red", CssValue.Parse("red").ToString());
var value = CssValue.Parse("3px 3px rgba(50%, 50%, 50%, 50%), lemonchiffon 0 0 4px inset");
var value2 = CssValue.Parse(@"""Gill Sans"", Futura, sans-serif");
Assert.Equal("3px 3px rgba(50%, 50%, 50%, 50%), lemonchiffon 0 0 4px inset", value.ToString());
Assert.Equal(@"""Gill Sans"", Futura, sans-serif", value2.ToString());
}
public void TestExsFontSize()
{
CssCollectedStyleDeclaration csd = new CssCollectedStyleDeclaration(getElm());
csd.CollectProperty("font-size", 1, CssValue.GetCssValue("2ex", false), CssStyleSheetType.Author, "");
CssPrimitiveValue cssPrimValue = csd.GetPropertyCssValue("font-size") as CssPrimitiveValue;
Assert.AreEqual(10, cssPrimValue.GetFloatValue(CssPrimitiveType.Px));
}
public string Serialize()
{
if (!IsValid)
{
return(string.Empty);
}
if (!Lookup.TryKeyword(Values[0].AsEnum <EMediaFeatureName>(), out string Name))
{
throw new CssSyntaxErrorException("Could not find media-feature name");
}
StringBuilder sb = new StringBuilder();
/* 1) Append a "(" (U+0028), followed by the media feature name, converted to ASCII lowercase, to s. */
sb.Append(UnicodeCommon.CHAR_LEFT_PARENTHESES);
if (Context == EMediaFeatureContext.Boolean)
{
sb.Append(Name);
}
else if (Context == EMediaFeatureContext.Range)
{
sb.Append(Name);
if (Operators.Length == 0 && Values.Length == 2)
{
/* If a value is given append a ":" (U+003A), followed by a single SPACE (U+0020), followed by the serialized media feature value. */
sb.Append(UnicodeCommon.CHAR_COLON);
sb.Append(UnicodeCommon.CHAR_SPACE);
sb.Append(Values[1].Serialize());
}
else
{
/* Serialize all value/operator pairs */
for (int i = 1; i < Operators.Length; i++)
{
CssValue B = Values[i];
EMediaOperator op = Operators[i - 1];
if (!Lookup.TryKeyword(op, out string outComparator))
{
throw new CssSyntaxErrorException("Unable to find the specified comparator within the CSS enum LUT");
}
sb.Append(B.Serialize());
sb.Append(outComparator);
}
}
}
/* 3) Append a ")" (U+0029) to s. */
sb.Append(UnicodeCommon.CHAR_RIGHT_PARENTHESES);
return(sb.ToString());
}
public void TestEmsNotFontSize()
{
CssCollectedStyleDeclaration csd = new CssCollectedStyleDeclaration(getElm());
csd.CollectProperty("notFontSize", 1, CssValue.GetCssValue("2em", false), CssStyleSheetType.Author, "");
CssPrimitiveValue cssPrimValue = csd.GetPropertyCssValue("notFontSize") as CssPrimitiveValue;
Assert.AreEqual(typeof(CssAbsPrimitiveLengthValue), cssPrimValue.GetType());
Assert.AreEqual(20, cssPrimValue.GetFloatValue(CssPrimitiveType.Px));
}
public void CssValueElement_ShouldReturnCorrectValue(string id, string cssProperty, string expected)
{
//arrange
var target = Target.The("css value element").LocatedBy(By.Id(id));
var question = CssValue.Of(target).AndTheProperty(cssProperty).Value;
//act
var actual = Answer(question);
//assert
Assert.Equal(expected, actual);
}
public void Update(CssValue _newValue)
{
if (!ShouldRerender(_newValue))
{
return;
}
ResolvedValue = _newValue;
RerenderSceneElement();
}
public void TestCssPropertyValue()
{
CssStyleDeclaration csd = getCSD();
CssValue cssValue = (CssValue)csd.GetPropertyCssValue("foo");
Assert.AreEqual("bar", cssValue.CssText);
Assert.AreEqual(CssValueType.PrimitiveValue, cssValue.CssValueType, "1");
cssValue = (CssValue)csd.GetPropertyCssValue("length");
Assert.AreEqual("23cm", cssValue.CssText);
Assert.AreEqual(CssValueType.PrimitiveValue, cssValue.CssValueType, "2");
}
public CssValue ReadExpressionFrom(CssValue left)
{
var operatorToken = Consume(); // Read operator
ReadTrivia();
// This may be another expression...
// TODO: Make recurssive
var right = ReadComponent();
return(new BinaryExpression(left, operatorToken, right));
}
public CssSecondProperty(
CssValue _value,
CssContainer _container,
Element _sceneElement
)
{
ResolvedValue = _value;
a_Container = _container;
a_SceneElement = _sceneElement;
RerenderSceneElement();
}
public static CssValue Containing_Block_Logical_Height(ICssProperty Property, double Percent)
{
if (!Property.Owner.Box.Containing_Box_Explicit_Height)
{
return(CssValue.Zero);
}
else
{
var resolved = Percent * CssCommon.Get_Logical_Height(Property.Owner.Style.WritingMode, Property.Owner.Box.Containing_Box);
return(CssValue.From(resolved, ECssUnit.PX));
}
}
public void CanProvideUnits()
{
var properties = new List <CssValue> {
"left", "right", "top", "bottom", "borderWidth"
}.ToArray();
foreach (var property in properties)
{
var rules = new CssValue[] { property, 1 };
TransformationsRules.ProvideUnits(rules, 0);
CollectionAssert.That.AreEqualRules(rules, property, "1px");
}
}
protected override void OnMouseClick(MouseEventArgs e)
{
base.OnMouseClick(e);
foreach (CssBox box in _htmlContainer.LinkRegions.Keys)
{
RectangleF rect = _htmlContainer.LinkRegions[box];
if (Rectangle.Round(rect).Contains(e.X, e.Y))
{
CssValue.GoLink(box.GetAttribute("href", string.Empty));
return;
}
}
}
public void TestFuncAttr()
{
XmlElement elm = getElm();
elm.SetAttribute("kalle", "", "roffe");
CssCollectedStyleDeclaration csd = new CssCollectedStyleDeclaration(elm);
csd.CollectProperty("foo", 1, CssValue.GetCssValue("attr(kalle)", false), CssStyleSheetType.Author, "");
CssPrimitiveValue cssPrimValue = csd.GetPropertyCssValue("foo") as CssPrimitiveValue;
Assert.IsNotNull(cssPrimValue);
Assert.AreEqual("roffe", cssPrimValue.GetStringValue());
}
public CssValue ReadExpressionFrom(CssValue left)
{
var opToken = Read(); // Read operator
ReadTrivia();
var op = (BinaryOperator)((int)opToken.Kind);
// This may be another expression...
// TODO: Make recurssive
var right = ReadComponent();
return new BinaryExpression(left, op, right);
}
/// <summary>
/// Given a string quad, flips the left and right values.
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
static CssValue flipQuad(CssValue value)
{
if (!value.IsNumber)
{
var parts = value.ToString().Split(' ');
if (parts.Length == 4)
{
return($"{parts[0]} {parts[3]} { parts[2]} { parts[1]}");
}
}
return(value);
}
public static CssValue Max_Height_Used(ICssProperty Property)
{// Docs: https://www.w3.org/TR/css-sizing-3/#min-size-properties
if (Property == null)
{
throw new ArgumentNullException(nameof(Property));
}
Contract.EndContractBlock();
var prop = (Property as CssProperty);
CssValue Value = prop.Computed;
if (Value.Type == ECssValueTypes.KEYWORD)
{
var keyword = Value.AsEnum <EBoxSize>();
switch (keyword)
{
case EBoxSize.Min_Content:
{
if (prop.Owner.Style.WritingMode != EWritingMode.Horizontal_TB)
{
return(prop.Definition.Initial);
}
return(CssValue.From(prop.Owner.Box.Min_Content.Height));
}
case EBoxSize.Max_Content:
{
if (prop.Owner.Style.WritingMode != EWritingMode.Horizontal_TB)
{
return(prop.Definition.Initial);
}
return(CssValue.From(prop.Owner.Box.Max_Content.Height));
}
case EBoxSize.Fit_Content:
{ // XXX: Implement this!
throw new NotImplementedException();
}
default:
throw new NotImplementedException($"Keyword '{keyword}' is not implemented!");
}
}
return(Value);
}
public virtual void TestReadWrite()
{
CssStyleDeclaration csd = getCSD(false);
csd.SetProperty("foo", "newvalue", "");
CssValue cssValue = (CssValue)csd.GetPropertyCssValue("foo");
Assert.AreEqual("newvalue", cssValue.CssText);
Assert.AreEqual("", csd.GetPropertyPriority("foo"));
csd.SetProperty("foo", "value2", "important");
cssValue = (CssValue)csd.GetPropertyCssValue("foo");
Assert.AreEqual("value2", cssValue.CssText);
Assert.AreEqual("important", csd.GetPropertyPriority("foo"));
}
public static CssValue Position_Used(ICssProperty Property)
{
if (Property == null)
{
throw new ArgumentNullException(nameof(Property));
}
Contract.EndContractBlock();
var prop = (Property as CssProperty);
CssValue Value = prop.Computed;
if (!Value.IsDefinite)
{
return(CssValue.From(0));
}
return(Value);
}
public void C()
{
var dic = new Dictionary <string, CssValue>
{
["columnCount"] = CssValue.Parse("5"),
["columnWidth"] = CssUnitValue.Number(100 / 5d),
["gap"] = CssValue.Parse("10px")
};
var sheet = StyleSheet.Parse(@"
@for $i from 1 through $columnCount {
.col-#{$i} {
left: #{$columnWidth * $i}%;
margin: $gap * 0.5;
}
}
");
Assert.Equal(@"
.col-1 {
left: 20%;
margin: 5px;
}
.col-2 {
left: 40%;
margin: 5px;
}
.col-3 {
left: 60%;
margin: 5px;
}
.col-4 {
left: 80%;
margin: 5px;
}
.col-5 {
left: 100%;
margin: 5px;
}
".Trim(), sheet.ToString(dic));
}
public void SetSide(Side side, CssValue aValue)
{
switch (side) {
case Side.Top:
mTop = aValue;
break;
case Side.Right:
mRight = aValue;
break;
case Side.Bottom:
mBottom = aValue;
break;
case Side.Left:
mLeft = aValue;
break;
default:
throw new ArgumentOutOfRangeException("side");
}
}
public static CssValue Position_Computed(ICssProperty Property)
{/* Docs: https://www.w3.org/TR/css-backgrounds-3/#propdef-background-position */
if (Property == null)
{
throw new ArgumentNullException(nameof(Property));
}
Contract.EndContractBlock();
var prop = (Property as CssProperty);
CssValue Value = prop.Specified;
if (!Value.IsCollection)
{
throw new CssPropertyException($"Cannot resolve computed value for '{Property.CssName}' because it is not a collection");
}
//switch
return(Value);
}
public static void Setup_Cheroke_Script_FontFamilys()
{
GenericFamilyMap.TryAdd(EGenericFontFamily.Serif, new List <CssValue>()
{
CssValue.From_String("Lo Cicero Cherokee")
});
GenericFamilyMap.TryAdd(EGenericFontFamily.SansSerif, new List <CssValue>()
{
});
GenericFamilyMap.TryAdd(EGenericFontFamily.Monospace, new List <CssValue>()
{
CssValue.From_String("Everson Mono")
});
GenericFamilyMap.TryAdd(EGenericFontFamily.Cursive, new List <CssValue>()
{
});
GenericFamilyMap.TryAdd(EGenericFontFamily.Fantasy, new List <CssValue>()
{
});
}
/// <summary>
/// Tries to set the given value.
/// </summary>
/// <param name="value">The value that should be used.</param>
/// <returns>True if the given value is accepted, otherwise false.</returns>
internal Boolean TrySetValue(CssValue value)
{
var result = false;
if (value == null)
{
result = !IsMinimum && !IsMaximum && Converter.HasDefault();
}
else
{
result = Converter.Convert(value) != null;
}
if (result)
{
_value = value;
}
return(result);
}
internal Boolean TrySetValue(CssValue value)
{
var result = false;
if (value == null)
{
result = !IsMinimum && !IsMaximum && Converter.HasDefault();
}
else
{
result = Converter.Convert(value) != null;
}
if (result)
{
_value = value;
}
return result;
}
public static void Setup_Japanese_Script_FontFamilys()
{
GenericFamilyMap.TryAdd(EGenericFontFamily.Serif, new List <CssValue>()
{
CssValue.From_String("Ryumin Light-KL"), CssValue.From_String("Kyokasho ICA"), CssValue.From_String("Futo Min A101")
});
GenericFamilyMap.TryAdd(EGenericFontFamily.SansSerif, new List <CssValue>()
{
CssValue.From_String("Shin Go"), CssValue.From_String("Heisei Kaku Gothic W5")
});
GenericFamilyMap.TryAdd(EGenericFontFamily.Monospace, new List <CssValue>()
{
CssValue.From_String("Osaka Monospaced")
});
GenericFamilyMap.TryAdd(EGenericFontFamily.Cursive, new List <CssValue>()
{
});
GenericFamilyMap.TryAdd(EGenericFontFamily.Fantasy, new List <CssValue>()
{
});
}
public static void Setup_Arabic_Script_FontFamilys()
{
GenericFamilyMap.TryAdd(EGenericFontFamily.Serif, new List <CssValue>()
{
CssValue.From_String("Bitstream Cyberbit")
});
GenericFamilyMap.TryAdd(EGenericFontFamily.SansSerif, new List <CssValue>()
{
CssValue.From_String("MS Tahoma")
});
GenericFamilyMap.TryAdd(EGenericFontFamily.Monospace, new List <CssValue>()
{
});
GenericFamilyMap.TryAdd(EGenericFontFamily.Cursive, new List <CssValue>()
{
CssValue.From_String("DecoType Naskh"), CssValue.From_String("Monotype Urdu 507")
});
GenericFamilyMap.TryAdd(EGenericFontFamily.Fantasy, new List <CssValue>()
{
});
}
public static void Setup_Hebrew_Script_FontFamilys()
{
GenericFamilyMap.TryAdd(EGenericFontFamily.Serif, new List <CssValue>()
{
CssValue.From_String("New Peninim"), CssValue.From_String("Raanana"), CssValue.From_String("Bitstream Cyberbit")
});
GenericFamilyMap.TryAdd(EGenericFontFamily.SansSerif, new List <CssValue>()
{
CssValue.From_String("Arial Hebrew"), CssValue.From_String("MS Tahoma")
});
GenericFamilyMap.TryAdd(EGenericFontFamily.Monospace, new List <CssValue>()
{
});
GenericFamilyMap.TryAdd(EGenericFontFamily.Cursive, new List <CssValue>()
{
CssValue.From_String("Corsiva")
});
GenericFamilyMap.TryAdd(EGenericFontFamily.Fantasy, new List <CssValue>()
{
});
}
public override ICssStyleDeclaration GetComputedStyle(string pseudoElt)
{
if (cachedCSD == null)
{
CssCollectedStyleDeclaration csd = (CssCollectedStyleDeclaration)base.GetComputedStyle(pseudoElt);
IEnumerator cssPropNames = OwnerDocument.CssPropertyProfile.GetAllPropertyNames().GetEnumerator();
while (cssPropNames.MoveNext())
{
string cssPropName = (string)cssPropNames.Current;
CssValue cssValue = (CssValue)GetPresentationAttribute(cssPropName);
if (cssValue != null)
{
csd.CollectProperty(cssPropName, 0, cssValue, CssStyleSheetType.NonCssPresentationalHints, String.Empty);
}
}
cachedCSD = csd;
}
return(cachedCSD);
}
public static void Setup_Greek_Script_FontFamilys()
{
GenericFamilyMap.TryAdd(EGenericFontFamily.Serif, new List <CssValue>()
{
CssValue.From_String("Bitstream Cyberbit")
});
GenericFamilyMap.TryAdd(EGenericFontFamily.SansSerif, new List <CssValue>()
{
CssValue.From_String("Attika"), CssValue.From_String("Typiko New Era"), CssValue.From_String("MS Tahoma"), CssValue.From_String("Monotype Gill Sans 571"), CssValue.From_String("Helvetica Greek")
});
GenericFamilyMap.TryAdd(EGenericFontFamily.Monospace, new List <CssValue>()
{
CssValue.From_String("MS Courier New"), CssValue.From_String("Everson Mono")
});
GenericFamilyMap.TryAdd(EGenericFontFamily.Cursive, new List <CssValue>()
{
});
GenericFamilyMap.TryAdd(EGenericFontFamily.Fantasy, new List <CssValue>()
{
});
}
internal void SetAllSidesTo(CssValue aValue)
{
mTop = mRight = mBottom = mLeft = aValue;
}
public MultipleValue(IPropertyValue[] values, IEnumerable<CssToken> tokens)
{
_values = values;
_value = new CssValue(tokens);
}
// flex: none | [ <'flex-grow'> <'flex-shrink'>? || <'flex-basis'> ]
internal bool ParseFlex()
{
// First check for inherit / initial
var tmpVal = new nsCSSValue();
if (ParseVariant(ref tmpVal, VARIANT_INHERIT, null)) {
AppendValue(nsCSSProperty.FlexGrow, tmpVal);
AppendValue(nsCSSProperty.FlexShrink, tmpVal);
AppendValue(nsCSSProperty.FlexBasis, tmpVal);
return true;
}
// Next, check for 'none' == '0 0 auto'
if (ParseVariant(ref tmpVal, VARIANT_NONE, null)) {
AppendValue(nsCSSProperty.FlexGrow, new nsCSSValue(0.0f, nsCSSUnit.Number));
AppendValue(nsCSSProperty.FlexShrink, new nsCSSValue(0.0f, nsCSSUnit.Number));
AppendValue(nsCSSProperty.FlexBasis, new nsCSSValue(nsCSSUnit.Auto));
return true;
}
// OK, try parsing our value as individual per-subproperty components:
// [ <'flex-grow'> <'flex-shrink'>? || <'flex-basis'> ]
// Each subproperty has a default value that it takes when it's omitted in a
// "flex" shorthand value. These default values are *only* for the shorthand
// syntax -- they're distinct from the subproperties' own initial values. We
// start with each subproperty at its default, as if we had "flex: 1 1 0%".
var flexGrow = new nsCSSValue(1.0f, nsCSSUnit.Number);
var flexShrink = new nsCSSValue(1.0f, nsCSSUnit.Number);
var flexBasis = new nsCSSValue(0.0f, nsCSSUnit.Percent);
// OVERVIEW OF PARSING STRATEGY:
// =============================
// a) Parse the first component as either flex-basis or flex-grow.
// b) If it wasn't flex-grow, parse the _next_ component as flex-grow.
// c) Now we've just parsed flex-grow -- so try parsing the next thing as
// flex-shrink.
// d) Finally: If we didn't get flex-basis at the beginning, try to parse
// it now, at the end.
//
// More details in each section below.
uint32_t flexBasisVariantMask =
(nsCSSProps.ParserVariant(nsCSSProperty.FlexBasis) & ~(VARIANT_INHERIT));
// (a) Parse first component. It can be either be a 'flex-basis' value or a
// 'flex-grow' value, so we use the flex-basis-specific variant mask, along
// with VARIANT_NUMBER to accept 'flex-grow' values.
//
// NOTE: if we encounter unitless 0 here, we *must* interpret it as a
// 'flex-grow' value (a number), *not* as a 'flex-basis' value (a length).
// Conveniently, that's the behavior this combined variant-mask gives us --
// it'll treat unitless 0 as a number. The flexbox spec requires this:
// "a unitless zero that is not already preceded by two flex factors must be
// interpreted as a flex factor.
if (!ParseNonNegativeVariant(ref tmpVal, flexBasisVariantMask | VARIANT_NUMBER,
nsCSSProps.kWidthKTable)) {
// First component was not a valid flex-basis or flex-grow value. Fail.
return false;
}
// Record what we just parsed as either flex-basis or flex-grow:
bool wasFirstComponentFlexBasis = (tmpVal.GetUnit() != nsCSSUnit.Number);
if (wasFirstComponentFlexBasis) flexBasis = tmpVal; else flexGrow = tmpVal;
// (b) If we didn't get flex-grow yet, parse _next_ component as flex-grow.
bool doneParsing = false;
if (wasFirstComponentFlexBasis) {
if (ParseNonNegativeVariant(ref tmpVal, VARIANT_NUMBER, null)) {
flexGrow = tmpVal;
} else {
// Failed to parse anything after our flex-basis -- that's fine. We can
// skip the remaining parsing.
doneParsing = true;
}
}
if (!doneParsing) {
// (c) OK -- the last thing we parsed was flex-grow, so look for a
// flex-shrink in the next position.
if (ParseNonNegativeVariant(ref tmpVal, VARIANT_NUMBER, null)) {
flexShrink = tmpVal;
}
// d) Finally: If we didn't get flex-basis at the beginning, try to parse
// it now, at the end.
//
// NOTE: If we encounter unitless 0 in this final position, we'll parse it
// as a 'flex-basis' value. That's OK, because we know it must have
// been "preceded by 2 flex factors" (justification below), which gets us
// out of the spec's requirement of otherwise having to treat unitless 0
// as a flex factor.
//
// JUSTIFICATION: How do we know that a unitless 0 here must have been
// preceded by 2 flex factors? Well, suppose we had a unitless 0 that
// was preceded by only 1 flex factor. Then, we would have already
// accepted this unitless 0 as the 'flex-shrink' value, up above (since
// it's a valid flex-shrink value), and we'd have moved on to the next
// token (if any). And of course, if we instead had a unitless 0 preceded
// by *no* flex factors (if it were the first token), we would've already
// parsed it in our very first call to ParseNonNegativeVariant(). So, any
// unitless 0 encountered here *must* have been preceded by 2 flex factors.
if (!wasFirstComponentFlexBasis &&
ParseNonNegativeVariant(ref tmpVal, flexBasisVariantMask,
nsCSSProps.kWidthKTable)) {
flexBasis = tmpVal;
}
}
AppendValue(nsCSSProperty.FlexGrow, flexGrow);
AppendValue(nsCSSProperty.FlexShrink, flexShrink);
AppendValue(nsCSSProperty.FlexBasis, flexBasis);
return true;
}
internal bool ParseTextOverflow(ref nsCSSValue aValue)
{
if (ParseVariant(ref aValue, VARIANT_INHERIT, null)) {
// 'inherit' and 'initial' must be alone
return true;
}
var left = new nsCSSValue();
if (!ParseVariant(ref left, VARIANT_KEYWORD | VARIANT_STRING,
nsCSSProps.kTextOverflowKTable))
return false;
var right = new nsCSSValue();
if (ParseVariant(ref right, VARIANT_KEYWORD | VARIANT_STRING,
nsCSSProps.kTextOverflowKTable))
aValue.SetPairValue(left, right);
else {
aValue = left;
}
return true;
}
internal bool ParseTransitionStepTimingFunctionValues(ref nsCSSValue aValue)
{
Debug.Assert(!mHavePushBack &&
mToken.mType == nsCSSTokenType.Function &&
mToken.mIdentStr.LowerCaseEqualsLiteral("steps"),
"unexpected initial state");
nsCSSValue[] val = new nsCSSValue[2];
if (!ParseOneOrLargerVariant(ref val[0], VARIANT_INTEGER, null)) {
return false;
}
int32_t type = nsStyle.TRANSITION_TIMING_FUNCTION_STEP_END;
if (ExpectSymbol(',', true)) {
if (!GetToken(true)) {
return false;
}
type = -1;
if (mToken.mType == nsCSSTokenType.Ident) {
if (mToken.mIdentStr.LowerCaseEqualsLiteral("start")) {
type = nsStyle.TRANSITION_TIMING_FUNCTION_STEP_START;
} else if (mToken.mIdentStr.LowerCaseEqualsLiteral("end")) {
type = nsStyle.TRANSITION_TIMING_FUNCTION_STEP_END;
}
}
if (type == -1) {
UngetToken();
return false;
}
}
val[1].SetIntValue(type, nsCSSUnit.Enumerated);
if (!ExpectSymbol(')', true)) {
return false;
}
aValue.SetArrayValue(val, nsCSSUnit.Steps);
return true;
}
bool ParseTransformOrigin(bool aPerspective)
{
var position = new nsCSSValuePair();
if (!ParseBoxPositionValues(ref position, true))
return false;
nsCSSProperty prop = nsCSSProperty.TransformOrigin;
if (aPerspective) {
if (!ExpectEndProperty()) {
return false;
}
prop = nsCSSProperty.PerspectiveOrigin;
}
// Unlike many other uses of pairs, this position should always be stored
// as a pair, even if the values are the same, so it always serializes as
// a pair, and to keep the computation code simple.
if (position.mXValue.GetUnit() == nsCSSUnit.Inherit ||
position.mXValue.GetUnit() == nsCSSUnit.Initial) {
Debug.Assert(position.mXValue == position.mYValue,
"inherit/initial only half?");
AppendValue(prop, position.mXValue);
} else {
var value = new nsCSSValue();
if (aPerspective) {
value.SetPairValue(position.mXValue, position.mYValue);
} else {
var depth = new nsCSSValue();
if (!nsLayoutUtils.Are3DTransformsEnabled() ||
// only try parsing if 3-D transforms are enabled
!ParseVariant(ref depth, VARIANT_LENGTH | VARIANT_CALC, null)) {
depth.SetFloatValue(0.0f, nsCSSUnit.Pixel);
}
value.SetTripletValue(position.mXValue, position.mYValue, depth);
}
AppendValue(prop, value);
}
return true;
}
static nsCSSValueList AppendValueToList(ref nsCSSValue aContainer,
nsCSSValueList aTail,
nsCSSValue aValue)
{
nsCSSValueList entry;
if (aContainer.GetUnit() == nsCSSUnit.Null) {
Debug.Assert(aTail == null, "should not have an entry");
entry = aContainer.SetListValue();
} else {
Debug.Assert(aTail.mNext == null, "should not have a next entry");
Debug.Assert(aContainer.GetUnit() == nsCSSUnit.List, "not a list");
entry = new nsCSSValueList();
aTail.mNext = entry;
}
entry.mValue = aValue;
return entry;
}
public Patch(string name, CssValue value)
{
Name = name;
Value = value;
}
internal bool ParseAttr(ref nsCSSValue aValue)
{
if (!GetToken(true)) {
return false;
}
var attr = new StringBuilder();
if (nsCSSTokenType.Ident == mToken.mType) { // attr name or namespace
string holdIdent = mToken.mIdentStr;
if (ExpectSymbol('|', false)) { // namespace
int32_t nameSpaceID = GetNamespaceIdForPrefix(holdIdent);
if (nameSpaceID == nsNameSpace.Unknown) {
return false;
}
attr.AppendInt(nameSpaceID, 10);
attr.Append('|');
if (! GetToken(false)) {
{ if (!mSuppressErrors) mReporter.ReportUnexpected("PEAttributeNameEOF"); };
return false;
}
if (nsCSSTokenType.Ident == mToken.mType) {
attr.Append(mToken.mIdentStr);
}
else {
{ if (!mSuppressErrors) mReporter.ReportUnexpected("PEAttributeNameExpected", mToken); };
UngetToken();
return false;
}
}
else { // no namespace
attr.AssignLiteral(holdIdent);
}
}
else if (mToken.IsSymbol('*')) { // namespace wildcard
// Wildcard namespace makes no sense here and is not allowed
{ if (!mSuppressErrors) mReporter.ReportUnexpected("PEAttributeNameExpected", mToken); };
UngetToken();
return false;
}
else if (mToken.IsSymbol('|')) { // explicit NO namespace
if (! GetToken(false)) {
{ if (!mSuppressErrors) mReporter.ReportUnexpected("PEAttributeNameEOF"); };
return false;
}
if (nsCSSTokenType.Ident == mToken.mType) {
attr.Append(mToken.mIdentStr);
}
else {
{ if (!mSuppressErrors) mReporter.ReportUnexpected("PEAttributeNameExpected", mToken); };
UngetToken();
return false;
}
}
else {
{ if (!mSuppressErrors) mReporter.ReportUnexpected("PEAttributeNameOrNamespaceExpected", mToken); };
UngetToken();
return false;
}
if (!ExpectSymbol(')', true)) {
return false;
}
aValue.SetStringValue(attr, nsCSSUnit.Attr);
return true;
}
internal bool TranslateDimension(ref nsCSSValue aValue,
int32_t aVariantMask,
float aNumber,
string aUnit)
{
nsCSSUnit units = 0;
int32_t type = 0;
if (!aUnit.IsEmpty()) {
uint32_t i = 0;
for (i = 0; i < UnitData.Length; ++i) {
if (aUnit.LowerCaseEqualsASCII(UnitData[i].name,
UnitData[i].length)) {
units = UnitData[i].unit;
type = UnitData[i].type;
break;
}
}
if (!mViewportUnitsEnabled &&
(nsCSSUnit.ViewportWidth == units ||
nsCSSUnit.ViewportHeight == units ||
nsCSSUnit.ViewportMin == units ||
nsCSSUnit.ViewportMax == units)) {
// Viewport units aren't allowed right now, probably because we're
// inside an @page declaration. Fail.
return false;
}
if (i == UnitData.Length) {
// Unknown unit
return false;
}
} else {
// Must be a zero number...
Debug.Assert(0 == aNumber, "numbers without units must be 0");
if ((VARIANT_LENGTH & aVariantMask) != 0) {
units = nsCSSUnit.Pixel;
type = VARIANT_LENGTH;
}
else if ((VARIANT_ANGLE & aVariantMask) != 0) {
Debug.Assert(((aVariantMask & VARIANT_ZERO_ANGLE) != 0),
"must have allowed zero angle");
units = nsCSSUnit.Degree;
type = VARIANT_ANGLE;
}
else {
throw new Exception("Variant mask does not include dimension; why were we called?");
return false;
}
}
if ((type & aVariantMask) != 0) {
aValue.SetFloatValue(aNumber, units);
return true;
}
return false;
}
internal bool ParseTransition()
{
/*TODO: static*/ nsCSSProperty[] kTransitionProperties = {
nsCSSProperty.TransitionDuration,
nsCSSProperty.TransitionTimingFunction,
// Must check 'transition-delay' after 'transition-duration', since
// that's our assumption about what the spec means for the shorthand
// syntax (the first time given is the duration, and the second
// given is the delay).
nsCSSProperty.TransitionDelay,
// Must check 'transition-property' after
// 'transition-timing-function' since 'transition-property' accepts
// any keyword.
nsCSSProperty.TransitionProperty
};
uint32_t numProps = kTransitionProperties.Length;
// this is a shorthand property that accepts -property, -delay,
// -duration, and -timing-function with some components missing.
// there can be multiple transitions, separated with commas
var initialValues = new nsCSSValue[numProps];
initialValues[0].SetFloatValue(0.0, nsCSSUnit.Seconds);
initialValues[1].SetIntValue(nsStyle.TRANSITION_TIMING_FUNCTION_EASE,
nsCSSUnit.Enumerated);
initialValues[2].SetFloatValue(0.0, nsCSSUnit.Seconds);
initialValues[3].SetAllValue();
var values = new nsCSSValue[numProps];
ParseAnimationOrTransitionShorthandResult spres =
ParseAnimationOrTransitionShorthand(kTransitionProperties, initialValues, ref values, numProps);
if (spres != ParseAnimationOrTransitionShorthandResult.Values) {
return spres != ParseAnimationOrTransitionShorthandResult.Error;
}
// Make two checks on the list for 'transition-property':
// + If there is more than one item, then none of the items can be
// 'none' or 'all'.
// + None of the items can be 'inherit' or 'initial' (this is the case,
// like with counter-reset &c., where CSS 2.1 specifies 'initial', so
// we should check it without the -moz- prefix).
{
Debug.Assert(kTransitionProperties[3] ==
nsCSSProperty.TransitionProperty,
"array index mismatch");
nsCSSValueList l = values[3].GetListValue();
bool multipleItems = l.mNext != null;
do {
nsCSSValue val = l.mValue;
if (val.GetUnit() == nsCSSUnit.None) {
if (multipleItems) {
// This is a syntax error.
return false;
}
// Unbox a solitary 'none'.
values[3].SetNoneValue();
break;
}
if (val.GetUnit() == nsCSSUnit.Ident) {
string str = val.GetStringBufferValue();
if (str.EqualsLiteral("inherit") || str.EqualsLiteral("initial")) {
return false;
}
}
} while ((l = l.mNext) != null);
}
// Save all parsed transition sub-properties in mTempData
for (uint32_t i = 0; i < numProps; ++i) {
AppendValue(kTransitionProperties[i], values[i]);
}
return true;
}
internal void SetBorderImageInitialValues()
{
// border-image-source: none
var source = new nsCSSValue();
source.SetNoneValue();
AppendValue(nsCSSProperty.BorderImageSource, source);
// border-image-slice: 100%
var sliceBoxValue = new nsCSSValue();
nsCSSRect sliceBox = sliceBoxValue.SetRectValue();
sliceBox.SetAllSidesTo(new nsCSSValue(1.0f, nsCSSUnit.Percent));
var slice = new nsCSSValue();
nsCSSValueList sliceList = slice.SetListValue();
sliceList.mValue = sliceBoxValue;
AppendValue(nsCSSProperty.BorderImageSlice, slice);
// border-image-width: 1
var width = new nsCSSValue();
nsCSSRect widthBox = width.SetRectValue();
widthBox.SetAllSidesTo(new nsCSSValue(1.0f, nsCSSUnit.Number));
AppendValue(nsCSSProperty.BorderImageWidth, width);
// border-image-outset: 0
var outset = new nsCSSValue();
nsCSSRect outsetBox = outset.SetRectValue();
outsetBox.SetAllSidesTo(new nsCSSValue(0.0f, nsCSSUnit.Number));
AppendValue(nsCSSProperty.BorderImageOutset, outset);
// border-image-repeat: repeat
var repeat = new nsCSSValue();
var repeatPair = new nsCSSValuePair();
repeatPair.SetBothValuesTo(new nsCSSValue(nsStyle.BORDER_IMAGE_REPEAT_STRETCH,
nsCSSUnit.Enumerated));
repeat.SetPairValue(repeatPair);
AppendValue(nsCSSProperty.BorderImageRepeat, repeat);
}
internal bool ParseTransitionProperty()
{
var value = new nsCSSValue();
if (ParseVariant(ref value, VARIANT_INHERIT | VARIANT_NONE, null)) {
// 'inherit', 'initial', and 'none' must be alone
if (!ExpectEndProperty()) {
return false;
}
} else {
// Accept a list of arbitrary identifiers. They should be
// CSS properties, but we want to accept any so that we
// accept properties that we don't know about yet, e.g.
// transition-property: invalid-property, left, opacity;
nsCSSValueList cur = value.SetListValue();
for (;;) {
if (!ParseVariant(ref cur.mValue, VARIANT_IDENTIFIER | VARIANT_ALL, null)) {
return false;
}
if (cur.mValue.GetUnit() == nsCSSUnit.Ident) {
string str = cur.mValue.GetStringBufferValue();
// Exclude 'none' and 'inherit' and 'initial' according to the
// same rules as for 'counter-reset' in CSS 2.1.
if (str.LowerCaseEqualsLiteral("none") ||
str.LowerCaseEqualsLiteral("inherit") ||
str.LowerCaseEqualsLiteral("initial")) {
return false;
}
}
if (CheckEndProperty()) {
break;
}
if (!ExpectSymbol(',', true)) {
{ if (!mSuppressErrors) mReporter.ReportUnexpected("PEExpectedComma", mToken); };
return false;
}
cur.mNext = new nsCSSValueList();
cur = cur.mNext;
}
}
AppendValue(nsCSSProperty.TransitionProperty, value);
return true;
}
//typedef nsCSSValue input_type;
//typedef nsCSSValue::Array input_array_type;
public static CssUnit GetUnit(CssValue aValue)
{
return aValue.GetUnit();
}
bool ParseBackgroundPositionValues(ref nsCSSValue aOut,
bool aAcceptsInherit)
{
// css3-background allows positions to be defined as offsets
// from an edge. There can be 2 keywords and 2 offsets given. These
// four 'values' are stored in an array in the following order:
// [keyword offset keyword offset]. If a keyword or offset isn't
// parsed the value of the corresponding array element is set
// to nsCSSUnit.Null by a call to nsCSSValue.Reset().
if (aAcceptsInherit && ParseVariant(ref aOut, VARIANT_INHERIT, null)) {
return true;
}
nsCSSValue[] value = new nsCSSValue[4];
aOut.SetArrayValue(value, nsCSSUnit.Array);
// The following clarifies organisation of the array.
nsCSSValue xEdge = value[0],
xOffset = value[1],
yEdge = value[2],
yOffset = value[3];
// Parse all the values into the array.
uint32_t valueCount = 0;
for (int32_t i = 0; i < 4; i++) {
if (!ParseVariant(ref value[i], VARIANT_LPCALC | VARIANT_KEYWORD,
nsCSSProps.kBackgroundPositionKTable)) {
break;
}
++valueCount;
}
switch (valueCount) {
case 4:
// "If three or four values are given, then each <percentage> or <length>
// represents an offset and must be preceded by a keyword, which specifies
// from which edge the offset is given."
if (nsCSSUnit.Enumerated != xEdge.GetUnit() ||
BG_CENTER == xEdge.GetIntValue() ||
nsCSSUnit.Enumerated == xOffset.GetUnit() ||
nsCSSUnit.Enumerated != yEdge.GetUnit() ||
BG_CENTER == yEdge.GetIntValue() ||
nsCSSUnit.Enumerated == yOffset.GetUnit()) {
return false;
}
break;
case 3:
// "If three or four values are given, then each <percentage> or<length>
// represents an offset and must be preceded by a keyword, which specifies
// from which edge the offset is given." ... "If three values are given,
// the missing offset is assumed to be zero."
if (nsCSSUnit.Enumerated != value[1].GetUnit()) {
// keyword offset keyword
// Second value is non-keyword, thus first value must be a non-center
// keyword.
if (nsCSSUnit.Enumerated != value[0].GetUnit() ||
BG_CENTER == value[0].GetIntValue()) {
return false;
}
// Remaining value must be a keyword.
if (nsCSSUnit.Enumerated != value[2].GetUnit()) {
return false;
}
yOffset.Reset(); // Everything else is in the correct position.
} else if (nsCSSUnit.Enumerated != value[2].GetUnit()) {
// keyword keyword offset
// Third value is non-keyword, thus second value must be non-center
// keyword.
if (BG_CENTER == value[1].GetIntValue()) {
return false;
}
// Remaining value must be a keyword.
if (nsCSSUnit.Enumerated != value[0].GetUnit()) {
return false;
}
// Move the values to the correct position in the array.
value[3] = value[2]; // yOffset
value[2] = value[1]; // yEdge
value[1].Reset(); // xOffset
} else {
return false;
}
break;
case 2:
// "If two values are given and at least one value is not a keyword, then
// the first value represents the horizontal position (or offset) and the
// second represents the vertical position (or offset)"
if (nsCSSUnit.Enumerated == value[0].GetUnit()) {
if (nsCSSUnit.Enumerated == value[1].GetUnit()) {
// keyword keyword
value[2] = value[1]; // move yEdge to correct position
xOffset.Reset();
yOffset.Reset();
} else {
// keyword offset
// First value must represent horizontal position.
if (((BG_TOP | BG_BOTTOM) & value[0].GetIntValue()) != 0) {
return false;
}
value[3] = value[1]; // move yOffset to correct position
xOffset.Reset();
yEdge.Reset();
}
} else {
if (nsCSSUnit.Enumerated == value[1].GetUnit()) {
// offset keyword
// Second value must represent vertical position.
if (((BG_LEFT | BG_RIGHT) & value[1].GetIntValue()) != 0) {
return false;
}
value[2] = value[1]; // move yEdge to correct position
value[1] = value[0]; // move xOffset to correct position
xEdge.Reset();
yOffset.Reset();
} else {
// offset offset
value[3] = value[1]; // move yOffset to correct position
value[1] = value[0]; // move xOffset to correct position
xEdge.Reset();
yEdge.Reset();
}
}
break;
case 1:
// "If only one value is specified, the second value is assumed to be
// center."
if (nsCSSUnit.Enumerated == value[0].GetUnit()) {
xOffset.Reset();
} else {
value[1] = value[0]; // move xOffset to correct position
xEdge.Reset();
}
yEdge.SetIntValue(nsStyle.BG_POSITION_CENTER, nsCSSUnit.Enumerated);
yOffset.Reset();
break;
default:
return false;
}
// For compatibility with CSS2.1 code the edges can be unspecified.
// Unspecified edges are recorded as NULL.
Debug.Assert((nsCSSUnit.Enumerated == xEdge.GetUnit() ||
nsCSSUnit.Null == xEdge.GetUnit()) &&
(nsCSSUnit.Enumerated == yEdge.GetUnit() ||
nsCSSUnit.Null == yEdge.GetUnit()) &&
nsCSSUnit.Enumerated != xOffset.GetUnit() &&
nsCSSUnit.Enumerated != yOffset.GetUnit(),
"Unexpected units");
// Keywords in first and second pairs can not both be vertical or
// horizontal keywords. (eg. left right, bottom top). Additionally,
// non-center keyword can not be duplicated (eg. left left).
int32_t xEdgeEnum =
xEdge.GetUnit() == nsCSSUnit.Enumerated ? xEdge.GetIntValue() : 0;
int32_t yEdgeEnum =
yEdge.GetUnit() == nsCSSUnit.Enumerated ? yEdge.GetIntValue() : 0;
if ((xEdgeEnum | yEdgeEnum) == (BG_LEFT | BG_RIGHT) ||
(xEdgeEnum | yEdgeEnum) == (BG_TOP | BG_BOTTOM) ||
((xEdgeEnum & yEdgeEnum & ~BG_CENTER) != 0)) {
return false;
}
// The values could be in an order that is different than expected.
// eg. x contains vertical information, y contains horizontal information.
// Swap if incorrect order.
if (((xEdgeEnum & (BG_TOP | BG_BOTTOM)) != 0) ||
((yEdgeEnum & (BG_LEFT | BG_RIGHT)) != 0)) {
nsCSSValue swapEdge = xEdge;
nsCSSValue swapOffset = xOffset;
xEdge = yEdge;
xOffset = yOffset;
yEdge = swapEdge;
yOffset = swapOffset;
}
return true;
}
public StringsValue(String[] values, IEnumerable<CssToken> tokens)
{
_values = values;
_original = new CssValue(tokens);
}
/* Parses a transform property list by continuously reading in properties
* and constructing a matrix from it.
*/
bool ParseTransform(bool aIsPrefixed)
{
var value = new nsCSSValue();
if (ParseVariant(ref value, VARIANT_INHERIT | VARIANT_NONE, null)) {
// 'inherit', 'initial', and 'none' must be alone
if (!ExpectEndProperty()) {
return false;
}
} else {
nsCSSValueList cur = value.SetListValue();
for (;;) {
bool is3D = false;
if (!ParseSingleTransform(aIsPrefixed, ref cur.mValue, ref is3D)) {
return false;
}
if (is3D && !nsLayoutUtils.Are3DTransformsEnabled()) {
return false;
}
if (CheckEndProperty()) {
break;
}
cur.mNext = new nsCSSValueList();
cur = cur.mNext;
}
}
AppendValue(nsCSSProperty.Transform, value);
return true;
}
internal bool SetValueToURL(ref nsCSSValue aValue, string aURL)
{
if (mSheetPrincipal == null) {
Debug.Fail("Codepaths that expect to parse URLs MUST pass in an origin principal");
return false;
}
string buffer = nsCSSValue.BufferFromString(aURL);
// Note: urlVal retains its own reference to |buffer|.
URLValue urlVal =
new URLValue(buffer, mBaseURI, mSheetURI, mSheetPrincipal);
aValue.SetURLValue(urlVal);
return true;
}
public GradientValue(Boolean repeating, IPropertyValue initial, IPropertyValue[] stops, IEnumerable<CssToken> tokens)
{
_repeating = repeating;
_initial = initial;
_stops = stops;
_original = new CssValue(tokens);
}
public StopValue(IPropertyValue color, IPropertyValue position, IEnumerable<CssToken> tokens)
{
_color = color;
_position = position;
_original = new CssValue(tokens);
}
// This function is very similar to ParseBackgroundPosition and
// ParseBackgroundSize.
internal bool ParseValueList(nsCSSProperty aPropID)
{
// aPropID is a single value prop-id
var value = new nsCSSValue();
if (ParseVariant(ref value, VARIANT_INHERIT, null)) {
// 'initial' and 'inherit' stand alone, no list permitted.
if (!ExpectEndProperty()) {
return false;
}
} else {
nsCSSValueList item = value.SetListValue();
for (;;) {
if (!ParseSingleValueProperty(ref item.mValue, aPropID)) {
return false;
}
if (CheckEndProperty()) {
break;
}
if (!ExpectSymbol(',', true)) {
return false;
}
item.mNext = new nsCSSValueList();
item = item.mNext;
}
}
AppendValue(aPropID, value);
return true;
}
internal bool ParseTransitionTimingFunctionValues(ref nsCSSValue aValue)
{
Debug.Assert(!mHavePushBack &&
mToken.mType == nsCSSTokenType.Function &&
mToken.mIdentStr.LowerCaseEqualsLiteral("cubic-bezier"),
"unexpected initial state");
nsCSSValue[] val = new nsCSSValue[4];
float x1 = 0, x2 = 0, y1 = 0, y2 = 0;
if (!ParseTransitionTimingFunctionValueComponent(ref x1, ',', true) ||
!ParseTransitionTimingFunctionValueComponent(ref y1, ',', false) ||
!ParseTransitionTimingFunctionValueComponent(ref x2, ',', true) ||
!ParseTransitionTimingFunctionValueComponent(ref y2, ')', false)) {
return false;
}
val[0].SetFloatValue(x1, nsCSSUnit.Number);
val[1].SetFloatValue(y1, nsCSSUnit.Number);
val[2].SetFloatValue(x2, nsCSSUnit.Number);
val[3].SetFloatValue(y2, nsCSSUnit.Number);
aValue.SetArrayValue(val, nsCSSUnit.CubicBezier);
return true;
}
// Assigns to aValue iff it returns true.
internal bool ParseVariant(ref nsCSSValue aValue,
int32_t aVariantMask,
int32_t[] aKeywordTable)
{
Debug.Assert(!(mHashlessColorQuirk && ((aVariantMask & VARIANT_COLOR) != 0)) ||
!((aVariantMask & VARIANT_NUMBER) != 0),
"can't distinguish colors from numbers");
Debug.Assert(!(mHashlessColorQuirk && ((aVariantMask & VARIANT_COLOR) != 0)) ||
!(mUnitlessLengthQuirk && ((aVariantMask & VARIANT_LENGTH) != 0)),
"can't distinguish colors from lengths");
Debug.Assert(!(mUnitlessLengthQuirk && ((aVariantMask & VARIANT_LENGTH) != 0)) ||
!((aVariantMask & VARIANT_NUMBER) != 0),
"can't distinguish lengths from numbers");
Debug.Assert(!((aVariantMask & VARIANT_IDENTIFIER) != 0) ||
!((aVariantMask & VARIANT_IDENTIFIER_NO_INHERIT) != 0),
"must not set both VARIANT_IDENTIFIER and VARIANT_IDENTIFIER_NO_INHERIT");
if (!GetToken(true)) {
return false;
}
nsCSSToken tk = mToken;
if (((aVariantMask & (VARIANT_AHK | VARIANT_NORMAL | VARIANT_NONE | VARIANT_ALL)) != 0) &&
(nsCSSTokenType.Ident == tk.mType)) {
nsCSSKeyword keyword = nsCSSKeywords.LookupKeyword(tk.mIdentStr);
if (nsCSSKeyword.UNKNOWN < keyword) { // known keyword
if ((aVariantMask & VARIANT_AUTO) != 0) {
if (nsCSSKeyword.auto == keyword) {
aValue.SetAutoValue();
return true;
}
}
if ((aVariantMask & VARIANT_INHERIT) != 0) {
// XXX Should we check IsParsingCompoundProperty, or do all
// callers handle it? (Not all callers set it, though, since
// they want the quirks that are disabled by setting it.)
if (nsCSSKeyword.inherit == keyword) {
aValue.SetInheritValue();
return true;
}
else if (nsCSSKeyword._moz_initial == keyword ||
nsCSSKeyword.initial == keyword) { // anything that can inherit can also take an initial val.
aValue.SetInitialValue();
return true;
}
}
if ((aVariantMask & VARIANT_NONE) != 0) {
if (nsCSSKeyword.none == keyword) {
aValue.SetNoneValue();
return true;
}
}
if ((aVariantMask & VARIANT_ALL) != 0) {
if (nsCSSKeyword.all == keyword) {
aValue.SetAllValue();
return true;
}
}
if ((aVariantMask & VARIANT_NORMAL) != 0) {
if (nsCSSKeyword.normal == keyword) {
aValue.SetNormalValue();
return true;
}
}
if ((aVariantMask & VARIANT_SYSFONT) != 0) {
if (nsCSSKeyword._moz_use_system_font == keyword &&
!IsParsingCompoundProperty()) {
aValue.SetSystemFontValue();
return true;
}
}
if ((aVariantMask & VARIANT_KEYWORD) != 0) {
int32_t value = 0;
if (nsCSSProps.FindKeyword(keyword, aKeywordTable, ref value)) {
aValue.SetIntValue(value, nsCSSUnit.Enumerated);
return true;
}
}
}
}
// Check VARIANT_NUMBER and VARIANT_INTEGER before VARIANT_LENGTH or
// VARIANT_ZERO_ANGLE.
if (((aVariantMask & VARIANT_NUMBER) != 0) &&
(nsCSSTokenType.Number == tk.mType)) {
aValue.SetFloatValue(tk.mNumber, nsCSSUnit.Number);
return true;
}
if (((aVariantMask & VARIANT_INTEGER) != 0) &&
(nsCSSTokenType.Number == tk.mType) && tk.mIntegerValid) {
aValue.SetIntValue(tk.mInteger, nsCSSUnit.Integer);
return true;
}
if (((aVariantMask & (VARIANT_LENGTH | VARIANT_ANGLE |
VARIANT_FREQUENCY | VARIANT_TIME)) != 0 &&
nsCSSTokenType.Dimension == tk.mType) ||
((aVariantMask & (VARIANT_LENGTH | VARIANT_ZERO_ANGLE)) != 0 &&
nsCSSTokenType.Number == tk.mType &&
tk.mNumber == 0.0f)) {
if (((aVariantMask & VARIANT_POSITIVE_DIMENSION) != 0 &&
tk.mNumber <= 0.0) ||
((aVariantMask & VARIANT_NONNEGATIVE_DIMENSION) != 0 &&
tk.mNumber < 0.0)) {
UngetToken();
return false;
}
if (TranslateDimension(ref aValue, aVariantMask, tk.mNumber, tk.mIdentStr)) {
return true;
}
// Put the token back; we didn't parse it, so we shouldn't consume it
UngetToken();
return false;
}
if (((aVariantMask & VARIANT_PERCENT) != 0) &&
(nsCSSTokenType.Percentage == tk.mType)) {
aValue.SetPercentValue(tk.mNumber);
return true;
}
if (mUnitlessLengthQuirk) { // NONSTANDARD: Nav interprets unitless numbers as px
if (((aVariantMask & VARIANT_LENGTH) != 0) &&
(nsCSSTokenType.Number == tk.mType)) {
aValue.SetFloatValue(tk.mNumber, nsCSSUnit.Pixel);
return true;
}
}
if (IsSVGMode() && !IsParsingCompoundProperty()) {
// STANDARD: SVG Spec states that lengths and coordinates can be unitless
// in which case they default to user-units (1 px = 1 user unit)
if (((aVariantMask & VARIANT_LENGTH) != 0) &&
(nsCSSTokenType.Number == tk.mType)) {
aValue.SetFloatValue(tk.mNumber, nsCSSUnit.Pixel);
return true;
}
}
if (((aVariantMask & VARIANT_URL) != 0) &&
nsCSSTokenType.URL == tk.mType) {
SetValueToURL(ref aValue, tk.mIdentStr);
return true;
}
if ((aVariantMask & VARIANT_GRADIENT) != 0 &&
nsCSSTokenType.Function == tk.mType) {
// a generated gradient
string tmp = tk.mIdentStr;
bool isLegacy = false;
if (StringBeginsWith(tmp, "-moz-")) {
tmp = tmp.Substring(5);
isLegacy = true;
}
bool isRepeating = false;
if (StringBeginsWith(tmp, "repeating-")) {
tmp = tmp.Substring(10);
isRepeating = true;
}
if (tmp.LowerCaseEqualsLiteral("linear-gradient")) {
return ParseLinearGradient(ref aValue, isRepeating, isLegacy);
}
if (tmp.LowerCaseEqualsLiteral("radial-gradient")) {
return ParseRadialGradient(ref aValue, isRepeating, isLegacy);
}
}
if ((aVariantMask & VARIANT_IMAGE_RECT) != 0 &&
nsCSSTokenType.Function == tk.mType &&
tk.mIdentStr.LowerCaseEqualsLiteral("-moz-image-rect")) {
return ParseImageRect(ref aValue);
}
if ((aVariantMask & VARIANT_ELEMENT) != 0 &&
nsCSSTokenType.Function == tk.mType &&
tk.mIdentStr.LowerCaseEqualsLiteral("-moz-element")) {
return ParseElement(ref aValue);
}
if ((aVariantMask & VARIANT_COLOR) != 0) {
if (mHashlessColorQuirk || // NONSTANDARD: Nav interprets 'xxyyzz' values even without '#' prefix
(nsCSSTokenType.ID == tk.mType) ||
(nsCSSTokenType.Hash == tk.mType) ||
(nsCSSTokenType.Ident == tk.mType) ||
((nsCSSTokenType.Function == tk.mType) &&
(tk.mIdentStr.LowerCaseEqualsLiteral("rgb") ||
tk.mIdentStr.LowerCaseEqualsLiteral("hsl") ||
tk.mIdentStr.LowerCaseEqualsLiteral("-moz-rgba") ||
tk.mIdentStr.LowerCaseEqualsLiteral("-moz-hsla") ||
tk.mIdentStr.LowerCaseEqualsLiteral("rgba") ||
tk.mIdentStr.LowerCaseEqualsLiteral("hsla"))))
{
// Put token back so that parse color can get it
UngetToken();
if (ParseColor(ref aValue)) {
return true;
}
return false;
}
}
if (((aVariantMask & VARIANT_STRING) != 0) &&
(nsCSSTokenType.String == tk.mType)) {
string buffer;
buffer = tk.mIdentStr;
aValue.SetStringValue(buffer, nsCSSUnit.String);
return true;
}
if (((aVariantMask &
(VARIANT_IDENTIFIER | VARIANT_IDENTIFIER_NO_INHERIT)) != 0) &&
(nsCSSTokenType.Ident == tk.mType) &&
((aVariantMask & VARIANT_IDENTIFIER) != 0 ||
!(tk.mIdentStr.LowerCaseEqualsLiteral("inherit") ||
tk.mIdentStr.LowerCaseEqualsLiteral("initial")))) {
aValue.SetStringValue(tk.mIdentStr, nsCSSUnit.Ident);
return true;
}
if (((aVariantMask & VARIANT_COUNTER) != 0) &&
(nsCSSTokenType.Function == tk.mType) &&
(tk.mIdentStr.LowerCaseEqualsLiteral("counter") ||
tk.mIdentStr.LowerCaseEqualsLiteral("counters"))) {
return ParseCounter(ref aValue);
}
if (((aVariantMask & VARIANT_ATTR) != 0) &&
(nsCSSTokenType.Function == tk.mType) &&
tk.mIdentStr.LowerCaseEqualsLiteral("attr")) {
if (!ParseAttr(ref aValue)) {
SkipUntil(')');
return false;
}
return true;
}
if (((aVariantMask & VARIANT_TIMING_FUNCTION) != 0) &&
(nsCSSTokenType.Function == tk.mType)) {
if (tk.mIdentStr.LowerCaseEqualsLiteral("cubic-bezier")) {
if (!ParseTransitionTimingFunctionValues(ref aValue)) {
SkipUntil(')');
return false;
}
return true;
}
if (tk.mIdentStr.LowerCaseEqualsLiteral("steps")) {
if (!ParseTransitionStepTimingFunctionValues(ref aValue)) {
SkipUntil(')');
return false;
}
return true;
}
}
if (((aVariantMask & VARIANT_CALC) != 0) &&
(nsCSSTokenType.Function == tk.mType) &&
(tk.mIdentStr.LowerCaseEqualsLiteral("calc") ||
tk.mIdentStr.LowerCaseEqualsLiteral("-moz-calc"))) {
// calc() currently allows only lengths and percents inside it.
return ParseCalc(ref aValue, aVariantMask & VARIANT_LP);
}
UngetToken();
return false;
}
