public static CssValue Color_Specified(ICssProperty Property) { if (Property == null) { throw new ArgumentNullException(nameof(Property)); } Contract.EndContractBlock(); var prop = (Property as CssProperty); if (prop.Specified.Type != ECssValueTypes.KEYWORD) { return(prop.Specified); } CssValue Value = prop.Specified; var keyword = Value.AsEnum <EColor>(); switch (keyword) { case EColor.CurrentColor: { /* If the ‘currentColor’ keyword is set on the ‘color’ property itself, it is treated as ‘color: inherit’. */ if (Property.CssName == ECssPropertyID.Color) { return(Property.Find_Inherited_Value()); } } break; } return(Value); }
internal CssValue Derive_ComputedValue(ICssProperty Property) {/* Docs: https://www.w3.org/TR/css-cascade-3/#computed */ StyleDefinition Def = Property.Definition; // Resolve any relative values switch (Type) { case ECssValueTypes.INHERIT: // Docs: https://www.w3.org/TR/CSS2/cascade.html#value-def-inherit { return(Property.Find_Inherited_Value()); } case ECssValueTypes.PERCENT: { if (Def.Percentage_Resolver != null) { return(Def.Percentage_Resolver(Property, (double)value)); } } break; case ECssValueTypes.DIMENSION: { double nv = Resolve(Property.Owner.ownerDocument.cssUnitResolver); return(CssValue.From(nv)); } } // If we havent resolved a value yet that means this was meant to be handled by a custom handler var ResolutionDelegate = Def.PropertyStageResolver[(int)EPropertyStage.Computed]; if (ResolutionDelegate is object) { return((CssValue)ResolutionDelegate.Invoke(Property)); } return(this); }
public static CssValue Font_Weight_Computed(ICssProperty Property) {/* Docs: https://drafts.csswg.org/css-fonts-4/#valdef-font-weight-bolder */ if (Property == null) { throw new ArgumentNullException(nameof(Property)); } Contract.EndContractBlock(); // handle font-weight related keywords // This function wouldnt even be called if the value werent a keyword var keyword = (Property as CssProperty).Specified.AsEnum <EFontWeight>(); int Weight = 400; switch (keyword) { case EFontWeight.Normal: Weight = 400; break; case EFontWeight.Bold: Weight = 700; break; case EFontWeight.Bolder: { /* Docs: https://drafts.csswg.org/css-fonts-4/#relative-weights */ CssValue inherited = Property.Find_Inherited_Value(); int w = inherited.AsInteger(); if (w < 100) { Weight = 400; } else if (w >= 100 && w < 350) { Weight = 400; } else if (w >= 350 && w < 550) { Weight = 700; } else if (w >= 550 && w < 750) { Weight = 900; } else if (w >= 750 && w < 900) { Weight = 900; } else { Weight = 900; } } break; case EFontWeight.Lighter: { /* Docs: https://drafts.csswg.org/css-fonts-4/#relative-weights */ CssValue inherited = Property.Find_Inherited_Value(); int w = inherited.AsInteger(); if (w < 100) { Weight = 100; } else if (w >= 100 && w < 350) { Weight = 100; } else if (w >= 350 && w < 550) { Weight = 100; } else if (w >= 550 && w < 750) { Weight = 400; } else if (w >= 750 && w < 900) { Weight = 700; } else { Weight = 700; } } break; } return(CssValue.From(Weight)); }
internal CssValue Derive_SpecifiedValue(ICssProperty Property) {/* Docs: https://www.w3.org/TR/css-cascade-3/#specified */ StyleDefinition Def = Property.Definition; // CSS specs say if the cascade (assigned) resulted in a value, use it. if (!IsNull) { switch (Type) { case ECssValueTypes.UNSET: /* Docs: https://www.w3.org/TR/css-cascade-4/#valdef-all-unset */ { // This property wants to act as though there is no decleration //is this property inherited if (Def != null && Def.Inherited) { return(Property.Find_Inherited_Value()); } // Not inherited, treat this situation like INITIAL return(new CssValue(Def.Initial)); } case ECssValueTypes.INHERIT: { return(Property.Find_Inherited_Value()); } case ECssValueTypes.INITIAL: { // If the Assigned value is the CssValue.Initial literal, then we use our definitions default return(Def.Initial); } default: { // Try and use a resolver if one is specified var ResolutionDelegate = Def.PropertyStageResolver[(int)EPropertyStage.Specified]; if (ResolutionDelegate is object) { return((CssValue)ResolutionDelegate.Invoke(Property)); } // Looks like this value doesn't need to change return(this); } } } // Assigned value is NULL // Try to inherit from our parent, if that fails use the Initial value. /* * CSS Specs: * 2. if the property is inherited and the element is not the root of the document tree, use the computed value of the parent element. */ if (Def != null && Def.Inherited) { if (!Property.Owner.isRoot) {// Root elements cannot inherit, they use the INITIAL value return(Def.Initial); } return(Property.Find_Inherited_Value()); } /* * CSS Specs: * 3. Otherwise use the property's initial value. The initial value of each property is indicated in the property's definition. */ return(Def.Initial); }