public override void Apply(ComputedStyle style,Value value){ // Is it lit? bool lit=(value!=null && value.Boolean); if(!lit && style.Shading==null){ // Essentially ignore it anyway. return; } if(style.Shading==null){ // It's lit: style.RequireShading().Lit=true; }else{ // It's not lit: style.Shading.Lit=false; // Optimise - might no longer need the shading info: style.Shading.Optimise(); } // Request a layout now: style.RequestLayout(); }
public override void Apply(ComputedStyle style,Value value){ // Got text at all?: if(GetText(style)==null){ return; } // Apply the property: if(value==null || value.Text=="none"){ // Clear the shadow: style.TextShadow=null; }else{ // The glow properties: int blur=0; Color colour=Color.black; ShadowData data=style.TextShadow; if(data==null){ data=new ShadowData(); style.TextShadow=data; } data.HOffset=value[0].PX; data.VOffset=value[1].PX; // Grab the blur: Value innerValue=value[2]; if(innerValue.Type==ValueType.Color){ colour=innerValue.ToColor(); }else{ blur=innerValue.PX; // Grab the colour: innerValue=value[3]; if(innerValue.Type==ValueType.Color){ colour=innerValue.ToColor(); } } if(colour.a==1f){ // Default transparency: colour.a=0.8f; } data.Colour=colour; data.Blur=blur; } // Apply the changes - doesn't change anything about the actual text, so we just want a layout: style.RequestLayout(); }
/// <summary>Animates this property now.</summary> /// <param name="animation">The animation that this property is a part of.</param> /// <param name="targetValue">The value that this property will be when the animation is over.</param> /// <param name="constantSpeedTime">How long the animation will change the value at a constant speed for.</param> /// <param name="timeToAccelerateFor">How long the animation will accelerate for. This produces a smoother animation.</param> /// <param name="timeToDecelerateFor">How long the animation will decelerate for. This produces a smoother animation.</param> /// <param name="updateCss">True if this particular property should flush its changes to css/the screen.</param> public void Animate(UIAnimation animation, string targetValue, float constantSpeedTime, float timeToAccelerateFor, float timeToDecelerateFor, bool updateCss) { // Get the target float value for calculating our transition speeds as an object: Css.Value targetValueObject = new Css.Value(); targetValueObject.Set(targetValue); Animate(animation, targetValueObject, constantSpeedTime, timeToAccelerateFor, timeToDecelerateFor, updateCss); }
/// <summary>Creates a new animated property.</summary> /// <param name="animation">The animation that this property is a part of.</param> /// <param name="property">The property being animated.</param> /// <param name="targetValue">The value that this property will be when the animation is over.</param> /// <param name="constantSpeedTime">How long the animation will change the value at a constant speed for.</param> /// <param name="timeToAccelerateFor">How long the animation will accelerate for. This produces a smoother animation.</param> /// <param name="timeToDecelerateFor">How long the animation will decelerate for. This produces a smoother animation.</param> /// <param name="updateCss">True if this particular property should flush its changes to css/the screen.</param> public AnimatedProperty(UIAnimation animation, CssProperty property, int innerIndex, Css.Value targetValue, float constantSpeedTime, float timeToAccelerateFor, float timeToDecelerateFor, bool updateCss) { Animation = animation; PropertyInfo = property; InnerIndex = innerIndex; Css.ValueType type = targetValue.Type; if (!Animation.ElementStyle.Properties.TryGetValue(property, out ValueObject)) { ComputedStyle computed = Animation.ElementStyle.Computed; if (computed != null && computed.Properties.TryGetValue(property, out ValueObject)) { // Let's derive from the computed form. ValueObject = ValueObject.Copy(); } else { ValueObject = new Css.Value(); if (innerIndex != -1 || type == Css.ValueType.Null) { type = Css.ValueType.Rectangle; } property.SetDefault(ValueObject, type); } Animation.ElementStyle.Properties[property] = ValueObject; } if (ValueObject.Type == Css.ValueType.Inherit) { // Special case - we need to duplicate it. Animation.ElementStyle.Properties[property] = ValueObject = ValueObject.Copy(); ValueObject.Type = type; } PropertyValueObject = ValueObject; if (innerIndex != -1) { Css.Value innerValue = ValueObject[innerIndex]; if (innerValue == null) { ValueObject[innerIndex] = innerValue = new Css.Value(); } ValueObject = innerValue; } // Set our starting value: ActiveValue = ValueObject.ToFloat(); Animate(Animation, targetValue, constantSpeedTime, timeToAccelerateFor, timeToDecelerateFor, updateCss); }
private void AnimateComposite(CssProperty property, Css.Value value) { bool isPoint = (value.Type == Css.ValueType.Point); Animate(property, 0, value[0], false); Animate(property, 1, value[1], isPoint); if (!isPoint) { Animate(property, 2, value[2], false); Animate(property, 3, value[3], true); } }
/// <summary>Creates a new animated property.</summary> /// <param name="animation">The animation that this property is a part of.</param> /// <param name="property">The property being animated.</param> /// <param name="targetValue">The value that this property will be when the animation is over.</param> /// <param name="constantSpeedTime">How long the animation will change the value at a constant speed for.</param> /// <param name="timeToAccelerateFor">How long the animation will accelerate for. This produces a smoother animation.</param> /// <param name="timeToDecelerateFor">How long the animation will decelerate for. This produces a smoother animation.</param> /// <param name="updateCss">True if this particular property should flush its changes to css/the screen.</param> public AnimatedProperty(UIAnimation animation,CssProperty property,int innerIndex,Css.Value targetValue,float constantSpeedTime,float timeToAccelerateFor,float timeToDecelerateFor,bool updateCss){ Animation=animation; PropertyInfo=property; InnerIndex=innerIndex; Css.ValueType type=targetValue.Type; if(!Animation.ElementStyle.Properties.TryGetValue(property,out ValueObject)){ ComputedStyle computed=Animation.ElementStyle.Computed; if(computed!=null && computed.Properties.TryGetValue(property,out ValueObject)){ // Let's derive from the computed form. ValueObject=ValueObject.Copy(); }else{ ValueObject=new Css.Value(); if(innerIndex!=-1 || type==Css.ValueType.Null){ type=Css.ValueType.Rectangle; } property.SetDefault(ValueObject,type); } Animation.ElementStyle.Properties[property]=ValueObject; } if(ValueObject.Type==Css.ValueType.Inherit){ // Special case - we need to duplicate it. Animation.ElementStyle.Properties[property]=ValueObject=ValueObject.Copy(); ValueObject.Type=type; } PropertyValueObject=ValueObject; if(innerIndex!=-1){ Css.Value innerValue=ValueObject[innerIndex]; if(innerValue==null){ ValueObject[innerIndex]=innerValue=new Css.Value(); } ValueObject=innerValue; } // Set our starting value: ActiveValue=ValueObject.ToFloat(); Animate(Animation,targetValue,constantSpeedTime,timeToAccelerateFor,timeToDecelerateFor,updateCss); }
/// <summary>Starts animating the named property and target value. Must not be composite properties. /// (e.g. color-overlay-r instead of color-overlay)</summary> /// <param name="property">The property to update.</param> /// <param name="innerIndex">The inner index of the property to update.</param> /// <param name="value">The target value of the property.</param> /// <param name="updateCss">True if this property should update CSS/ the screen when it's progressed.</param> private void Animate(CssProperty property, int innerIndex, Css.Value value, bool updateCss) { // Check if this property is already animated - if so, interrupt it and override with our new values. // There won't be many actively animated properties, so looping through the update queue is fast anyway. AnimatedProperty animProperty = GetAnimatedProperty(Animating, property, innerIndex); if (animProperty != null) { animProperty.Animate(this, value, ConstantSpeedTime, TimeToAccelerateFor, TimeToDecelerateFor, updateCss); } else { // Otherwise we want to create a new AnimatedProperty and stick it into the queue: animProperty = new AnimatedProperty(this, property, innerIndex, value, ConstantSpeedTime, TimeToAccelerateFor, TimeToDecelerateFor, updateCss); animProperty.AddToQueue(); } }
public override void OnLoaded(string type) { ComputedStyle computed = Element.Style.Computed; if (computed.BGImage == null) { return; } Image = computed.BGImage.Image; if (Image == null) { return; } float width = (float)Image.Width(); float height = (float)Image.Height(); // Figure out the aspect ratios: AspectRatio = width / height; InverseAspectRatio = height / width; if (Image.PixelPerfect) { width *= ScreenInfo.ResolutionScale; height *= ScreenInfo.ResolutionScale; } // Compute the tag width: TagWidth = new Css.Value((int)width + "fpx", Css.ValueType.Pixels); // Compute the tag height: TagHeight = new Css.Value((int)height + "fpx", Css.ValueType.Pixels); // Act like we're setting tag properties: // This is so that class/ID/Style can override any of them. computed.ChangeTagProperty("height", TagHeight); computed.ChangeTagProperty("width", TagWidth); computed.ChangeTagProperty("background-repeat", new Css.Value("no-repeat", Css.ValueType.Text)); computed.ChangeTagProperty("background-size", new Css.Value("100% 100%", Css.ValueType.Point)); }
public override void Apply(ComputedStyle style,Value value){ ShaderSet family=null; // Apply: if(value!=null){ // Lowercase so we can have the best chance at spotting the standard set (which is optimised for). string familyLC=value.Text.ToLower(); if(familyLC!="standardui" && familyLC!="standard" && familyLC!="" && familyLC!="none"){ // Get the family: family=ShaderSet.Get(value.Text); } } // Apply it here: if(style.Shading!=null){ // Update it: style.Shading.Shaders=family; if(family==null){ // Check if the shading data is no longer in use: style.Shading.Optimise(); } }else if(family!=null){ style.RequireShading().Shaders=family; } // Request a layout now: style.RequestLayout(); }
/// <summary>Animates this property now.</summary> /// <param name="animation">The animation that this property is a part of.</param> /// <param name="targetValue">The parsed value that this property will be when the animation is over.</param> /// <param name="constantSpeedTime">How long the animation will change the value at a constant speed for.</param> /// <param name="timeToAccelerateFor">How long the animation will accelerate for. This produces a smoother animation.</param> /// <param name="timeToDecelerateFor">How long the animation will decelerate for. This produces a smoother animation.</param> /// <param name="updateCss">True if this particular property should flush its changes to css/the screen.</param> public void Animate(UIAnimation animation, Css.Value targetValue, float constantSpeedTime, float timeToAccelerateFor, float timeToDecelerateFor, bool updateCss) { Animation = animation; ValueObject.Type = targetValue.Type; Stage = 0; Speed = 0f; CurrentTime = 0f; UpdateCss = updateCss; PropertyAfter = PropertyBefore = null; // Find the max speed. This is what we accelerate to. // Speed (y) / time (x) graph: // /| |-| |\ // A B C. A = accelerate, b=constant, c=decelerate. // Max speed = top y value. // Distance travelled = area of the graph. This should match target - current value. TargetValue = targetValue.ToFloat(); float unitsDelta = TargetValue - ActiveValue; MaxSpeed = (unitsDelta * UI.RedrawRate) / ((0.5f * timeToAccelerateFor) + constantSpeedTime + (0.5f * timeToDecelerateFor)); if (timeToAccelerateFor == 0f) { // Skip acceleration stage. Stage = 1; Speed = MaxSpeed; } else { Acceleration = MaxSpeed * UI.RedrawRate / timeToAccelerateFor; } if (timeToDecelerateFor != 0f) { Deceleration = MaxSpeed * UI.RedrawRate / timeToDecelerateFor; } }
//--------------------------------------
/// <summary>Sets the named property on this style to the given value. An inner value may be set; For example, /// setting the red component of color-overlay (color-overlay-r) becomes color-overlay and an innerIndex of 0.</summary> /// <param name="property">The property to set or overwrite. e.g. "display".</param> /// <param name="value">The value to set the property to, e.g. "none".</param> /// <param name="innerIndex">The index of the inner value to set, if any. -1 to set the whole property.</param> private void Set(string cssProperty,string value,int innerIndex,bool important){ if(Element!=null && Element.Document.AotDocument){ return; } // Get the property: CssProperty property=CssProperties.Get(cssProperty); if(property==null){ // It doesn't exist! return; } if(value==""){ value=null; } if(value==null){ Properties.Remove(property); // Was in there (and not blank) - change it. OnChanged(property,null); return; } // Get the type of the property: ValueType type=Css.Value.TypeOf(property,ref value); // Read or create the raw property value: Value propertyValue=GetRawValue(property,type); if(innerIndex!=-1){ // Writing to an inner value, e.g. border-left. Grab it: Value innerValue=propertyValue[innerIndex]; if(innerValue==null){ innerValue=propertyValue[innerIndex]=new Value(); } innerValue.Set(value); // Apply its importance: innerValue.Important=important; }else{ if(type==ValueType.Null){ propertyValue.Set(value); }else{ propertyValue.Set(value,type); } // Apply its importance: propertyValue.Important=important; } // Let the sheet know the value changed: if(type==ValueType.Null){ OnChanged(property,null); }else{ OnChanged(property,propertyValue); } }
public override void OnChanged(CssProperty property,Value newValue){ // Update the computed object: Computed.ChangeProperty(property,newValue); }
public override void OnLoaded(string type){ ComputedStyle computed=Element.Style.Computed; if(computed.BGImage==null){ return; } Image=computed.BGImage.Image; if(Image==null){ return; } float width=(float)Image.Width(); float height=(float)Image.Height(); // Figure out the aspect ratios: AspectRatio=width/height; InverseAspectRatio=height/width; if(Image.PixelPerfect){ width*=ScreenInfo.ResolutionScale; height*=ScreenInfo.ResolutionScale; } // Compute the tag width: TagWidth=new Css.Value((int)width+"fpx",Css.ValueType.Pixels); // Compute the tag height: TagHeight=new Css.Value((int)height+"fpx",Css.ValueType.Pixels); // Act like we're setting tag properties: // This is so that class/ID/Style can override any of them. computed.ChangeTagProperty("height",TagHeight); computed.ChangeTagProperty("width",TagWidth); computed.ChangeTagProperty("background-repeat",new Css.Value("no-repeat",Css.ValueType.Text)); computed.ChangeTagProperty("background-size",new Css.Value("100% 100%",Css.ValueType.Point)); }
/// <summary>Inherits from the given parent value by copying them.</summary> /// <param name="parent">The value to inherit from.</param> public void InheritFrom(Value parent){ // e.g. font-size:inherit; // Simply copies the parent objects properties exactly. if(parent==null){ PX=0; Text=null; Boolean=false; InnerValues=null; Single=0f; }else{ PX=parent.PX; Text=parent.Text; Single=parent.Single; Boolean=parent.Boolean; InnerValues=parent.InnerValues; } }
/// <summary>Animates this property now.</summary> /// <param name="animation">The animation that this property is a part of.</param> /// <param name="targetValue">The value that this property will be when the animation is over.</param> /// <param name="constantSpeedTime">How long the animation will change the value at a constant speed for.</param> /// <param name="timeToAccelerateFor">How long the animation will accelerate for. This produces a smoother animation.</param> /// <param name="timeToDecelerateFor">How long the animation will decelerate for. This produces a smoother animation.</param> /// <param name="updateCss">True if this particular property should flush its changes to css/the screen.</param> public void Animate(UIAnimation animation,string targetValue,float constantSpeedTime,float timeToAccelerateFor,float timeToDecelerateFor,bool updateCss){ // Get the target float value for calculating our transition speeds as an object: Css.Value targetValueObject=new Css.Value(); targetValueObject.Set(targetValue); Animate(animation,targetValueObject,constantSpeedTime,timeToAccelerateFor,timeToDecelerateFor,updateCss); }
/// <summary>Creates a new UIAnimation for animating CSS and immediately animates it. /// See <see cref="PowerUI.Element.animate"/>.</summary> /// <param name="animating">The element being animated.</param> /// <param name="properties">The CSS property string. Each property should define the value it will be when the animation is done.</param> /// <param name="constantSpeedTime">How long this animation lasts for at a constant speed.</param> /// <param name="timeToAccelerateFor">How long this animation accelerates for. Creates smooth animations when used.</param> /// <param name="timeToDecelerateFor">How long this animation decelerates for. Creates smooth animations when used.</param> public UIAnimation(Element animating, string properties, float constantSpeedTime, float timeToAccelerateFor, float timeToDecelerateFor) { Animating = animating; ElementStyle = Animating.Style; if (string.IsNullOrEmpty(properties)) { Wrench.Log.Add("No properties given to animate!"); return; } if (constantSpeedTime < 0f) { constantSpeedTime = 0f; } if (timeToAccelerateFor < 0f) { timeToAccelerateFor = 0f; } if (timeToDecelerateFor < 0f) { timeToDecelerateFor = 0f; } TotalTime = (timeToDecelerateFor + timeToAccelerateFor + constantSpeedTime); ConstantSpeedTime = constantSpeedTime; TimeToAccelerateFor = timeToAccelerateFor; TimeToDecelerateFor = timeToDecelerateFor; if (TotalTime == 0f) { // Instant - probably a fault somewhere in the users request, so we won't do anything. Wrench.Log.Add("Instant css animation request ignored. Told to take no time to transition."); return; } if (timeToDecelerateFor == 0f) { Decelerate = false; } else { Decelerate = true; DecelerateAt = timeToAccelerateFor + constantSpeedTime; } if (properties.StartsWith(".") || properties.StartsWith("#")) { // Targeting a selector, e.g. #fadedBox // First, get the selector style: Css.SelectorStyle selector = animating.Document.getStyleBySelector(properties); if (selector == null) { return; } // Animate each property: foreach (KeyValuePair <CssProperty, Css.Value> kvp in selector.Properties) { // Is it a composite property? Css.Value value = kvp.Value; // Grab the type: Css.ValueType type = value.Type; if (type == Css.ValueType.Null || type == Css.ValueType.Text) { // Can't deal with either of these. continue; } if (type == Css.ValueType.Rectangle || type == Css.ValueType.Point || type == Css.ValueType.Color) { // Animate it (note that we don't need to copy it): AnimateComposite(kvp.Key, value); } else { // Animate it (note that we don't need to copy it): Animate(kvp.Key, -1, value, true); } } return; } string[] propertySet = properties.Split(';'); foreach (string currentProperty in propertySet) { if (currentProperty == "") { continue; } string[] keyValue = currentProperty.Split(Css.Style.Delimiter, 2); if (keyValue.Length != 2) { continue; } string key = keyValue[0].Trim(); if (key == "opacity") { key = "color-overlay-a"; } // Grab the inner index: int innerIndex = Css.Value.GetInnerIndex(ref key); // Get the property: CssProperty property = CssProperties.Get(key); if (property == null) { Wrench.Log.Add("Warning: CSS property '" + keyValue[0] + "' not found during animate."); continue; } // Trim shouldn't be applied to inner-text's value, but we can't animate that anyway! This is all we need to do: string value = keyValue[1].Trim(); // Key could be a composite property - for example padding, which needs to be broken down into it's individual inner elements (e.g. padding-left) Css.ValueType type; if (innerIndex == -1) { type = Css.Value.TypeOf(property, ref value); } else { type = Css.Value.TypeOf(value); } if (type == Css.ValueType.Null || type == Css.ValueType.Text) { // Can't deal with either of these. continue; } else if (type == Css.ValueType.Rectangle || type == Css.ValueType.Point || type == Css.ValueType.Color) { // We have a composite property (and we're animating the whole thing). Css.Value tempValue = new Css.Value(); tempValue.Set(value, type); // Animate it: AnimateComposite(property, tempValue); } else { Animate(property, innerIndex, new Css.Value(value, type), true); } } }
/// <summary>Creates a new UIAnimation for animating CSS and immediately animates it. /// See <see cref="PowerUI.Element.animate"/>.</summary> /// <param name="animating">The element being animated.</param> /// <param name="properties">The CSS property string. Each property should define the value it will be when the animation is done.</param> /// <param name="constantSpeedTime">How long this animation lasts for at a constant speed.</param> /// <param name="timeToAccelerateFor">How long this animation accelerates for. Creates smooth animations when used.</param> /// <param name="timeToDecelerateFor">How long this animation decelerates for. Creates smooth animations when used.</param> public UIAnimation(Element animating,string properties,float constantSpeedTime,float timeToAccelerateFor,float timeToDecelerateFor){ Animating=animating; ElementStyle=Animating.Style; if(string.IsNullOrEmpty(properties)){ Wrench.Log.Add("No properties given to animate!"); return; } if(constantSpeedTime<0f){ constantSpeedTime=0f; } if(timeToAccelerateFor<0f){ timeToAccelerateFor=0f; } if(timeToDecelerateFor<0f){ timeToDecelerateFor=0f; } TotalTime=(timeToDecelerateFor + timeToAccelerateFor + constantSpeedTime); ConstantSpeedTime=constantSpeedTime; TimeToAccelerateFor=timeToAccelerateFor; TimeToDecelerateFor=timeToDecelerateFor; if(TotalTime==0f){ // Instant - probably a fault somewhere in the users request, so we won't do anything. Wrench.Log.Add("Instant css animation request ignored. Told to take no time to transition."); return; } if(timeToDecelerateFor==0f){ Decelerate=false; }else{ Decelerate=true; DecelerateAt=timeToAccelerateFor + constantSpeedTime; } if( properties.StartsWith(".") || properties.StartsWith("#") ){ // Targeting a selector, e.g. #fadedBox // First, get the selector style: Css.SelectorStyle selector=animating.Document.getStyleBySelector(properties); if(selector==null){ return; } // Animate each property: foreach(KeyValuePair<CssProperty,Css.Value> kvp in selector.Properties){ // Is it a composite property? Css.Value value=kvp.Value; // Grab the type: Css.ValueType type=value.Type; if(type==Css.ValueType.Null || type==Css.ValueType.Text){ // Can't deal with either of these. continue; } if(type==Css.ValueType.Rectangle || type==Css.ValueType.Point || type==Css.ValueType.Color){ // Animate it (note that we don't need to copy it): AnimateComposite(kvp.Key,value); }else{ // Animate it (note that we don't need to copy it): Animate(kvp.Key,-1,value,true); } } return; } string[] propertySet=properties.Split(';'); foreach(string currentProperty in propertySet){ if(currentProperty==""){ continue; } string[] keyValue=currentProperty.Split(Css.Style.Delimiter,2); if(keyValue.Length!=2){ continue; } string key=keyValue[0].Trim(); if(key=="opacity"){ key="color-overlay-a"; } // Grab the inner index: int innerIndex=Css.Value.GetInnerIndex(ref key); // Get the property: CssProperty property=CssProperties.Get(key); if(property==null){ Wrench.Log.Add("Warning: CSS property '"+keyValue[0]+"' not found during animate."); continue; } // Trim shouldn't be applied to inner-text's value, but we can't animate that anyway! This is all we need to do: string value=keyValue[1].Trim(); // Key could be a composite property - for example padding, which needs to be broken down into it's individual inner elements (e.g. padding-left) Css.ValueType type; if(innerIndex==-1){ type=Css.Value.TypeOf(property,ref value); }else{ type=Css.Value.TypeOf(value); } if(type==Css.ValueType.Null || type==Css.ValueType.Text){ // Can't deal with either of these. continue; }else if(type==Css.ValueType.Rectangle || type==Css.ValueType.Point || type==Css.ValueType.Color){ // We have a composite property (and we're animating the whole thing). Css.Value tempValue=new Css.Value(); tempValue.Set(value,type); // Animate it: AnimateComposite(property,tempValue); }else{ Animate(property,innerIndex,new Css.Value(value,type),true); } } }
/// <summary>Gets or creates the base value for the given property. /// The base value is essentially the value held directly in this style sheet. /// E.g. if the value you're setting is the R channel of color-overlay, this sets up the color-overlay value for you.</summary> /// <returns>The raw value (which may have just been created).</returns> public Css.Value GetRawValue(CssProperty property,ValueType type){ Css.Value propertyValue; // Does it exist already? if(!Properties.TryGetValue(property,out propertyValue)){ // Nope! Create it now. Does the computed style hold a value instead? ComputedStyle computed=GetComputed(); if(computed!=null && computed.Properties.TryGetValue(property,out propertyValue) && propertyValue!=null){ // Let's derive from the computed form. propertyValue=propertyValue.Copy(); Properties[property]=propertyValue; }else{ // Needs to be created. Properties[property]=propertyValue=new Value(); if(type==ValueType.Null){ type=ValueType.Rectangle; } // Set the default value: property.SetDefault(propertyValue,type); if(type==ValueType.Inherit){ // Set inherit: propertyValue.Type=ValueType.Inherit; } } } if(propertyValue.Type==ValueType.Inherit && type!=ValueType.Inherit){ // Special case - we need to duplicate it. Properties[property]=propertyValue=propertyValue.Copy(); propertyValue.Type=type; } return propertyValue; }
/// <summary>Duplicates this value.</summary> /// <returns>A duplicated copy of this value. Note that if this value has inner values, they are copied too.</returns> public Value Copy(){ Value result=new Value(); result.Type=Type; result.PX=PX; result.Text=Text; result.Single=Single; result.Boolean=Boolean; if(InnerValues!=null){ result.InnerValues=new Value[InnerValues.Length]; for(int i=0;i<InnerValues.Length;i++){ Value value=InnerValues[i]; if(value==null){ continue; } result[i]=value.Copy(); } } return result; }
/// <summary>called when the named property changes.</summary> /// <param name="property">The property that changed.</param> /// <param name="newValue">It's new fully parsed value. May be null.</param> public virtual void OnChanged(CssProperty property,Value newValue){ }
/// <summary>Checks if two values are equal.</summary> /// <param name="value">The value to check for equality with this. Always returns false if null.</param> /// <returns>True if this and the given value are equal; false otherwise.</returns> public bool Equals(Value value){ if(value==null || value.Type!=Type){ return false; } switch(Type){ case ValueType.Null: return true; case ValueType.Boolean: return (value.Boolean==Boolean); case ValueType.Pixels: return (value.PX==PX); case ValueType.Percentage: return (value.Single==Single); case ValueType.Em: return (value.Single==Single); case ValueType.Radians: return (value.Single==Single); case ValueType.Degrees: return (value.Single==Single); case ValueType.Single: return (value.Single==Single); case ValueType.Text: return (value.Text==Text); case ValueType.Calc: return (value.Single==Single); default: if(InnerValues==null){ return (value.InnerValues==null); }else if(value.InnerValues==null){ return (InnerValues==null); } for(int i=InnerValues.Length-1;i>=0;i--){ if(InnerValues[i]==null){ if(value.InnerValues[i]!=null){ return false; } }else if(!InnerValues[i].Equals(value.InnerValues[i])){ return false; } } return true; } }
/// <summary>Apply this CSS style to the given computed style. /// Note that you can grab the element from the computed style if you need that.</summary> /// <param name="style">The computed style to apply the property to.</param> /// <param name="value">The new value being applied.</param> public virtual void Apply(ComputedStyle style,Value value){}
/// <summary>Offsets this percentage value by a given percentage or pixel value.</summary> public void Offset(Value by){ if(Single==1f){ // Take from it. if(by.PX!=0){ // Set: PX=-by.PX; }else{ // Decrease: Single-=by.Single; } }else{ // Add to it. if(by.PX!=0){ // Set: PX=by.PX; }else{ // Increase: Single+=by.Single; } } // It's a mixed unit type: Type=ValueType.Mixed; }
public override void Apply(ComputedStyle style,Value value){ // Got any text at all?: if(GetText(style)==null){ return; } // Apply the property: if(value==null || value.Text=="none"){ // Clear the stroke: style.TextStroke=null; }else{ // The stroke properties: int blur=0; Color colour=Color.black; int thickness=value[0].PX; if(thickness==0){ style.TextStroke=null; }else{ StrokeData data=style.TextStroke; if(data==null){ data=new StrokeData(); style.TextStroke=data; } data.Thickness=thickness; // Grab the blur: Value innerValue=value[1]; if(innerValue.Type==ValueType.Color){ colour=innerValue.ToColor(); }else{ blur=innerValue.PX; // Grab the colour: innerValue=value[2]; if(innerValue.Type==ValueType.Color){ colour=innerValue.ToColor(); } } data.Colour=colour; data.Blur=blur; } } // Apply the changes - doesn't change anything about the actual text, so we just want a layout: style.RequestLayout(); }
/// <summary>Sets defaults for the given number of inner values.</summary> /// <param name="count">The number of inner values to setup.</param> public void SetInnerValues(int count){ if(InnerValues==null||InnerValues.Length!=count){ InnerValues=new Value[count]; for(int i=0;i<count;i++){ InnerValues[i]=new Value(); } } }