// 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; }