// Sync text values to class properties. Used for animation.
protected virtual void Sync()
{
SetDefault(false);
foreach (var kv in layoutAttribute)
{
if (!Flex.ParseStyleAttr(this, kv.Key, kv.Value))
{
throw new Exception("Failed to parse attribute [" + kv.Key + ":" + kv.Value + "]");
}
}
foreach (var kv in layoutAttributeAnimated)
{
if (!Flex.ParseStyleAttr(this, kv.Key, kv.Value))
{
throw new Exception("Failed to parse attribute [" + kv.Key + ":" + kv.Value + "]");
}
}
}
// LayoutGetMargin gets margin
internal float LayoutGetMargin(Edge edge)
{
Flex.assertWithNode(this, edge < Edge.End, "Cannot get layout properties of multi-edge shorthands");
if (edge == Edge.Left)
{
if (this.nodeLayout.Direction == Direction.RTL)
{
return(this.nodeLayout.Margin[(int)Edge.End]);
}
return(this.nodeLayout.Margin[(int)Edge.Start]);
}
if (edge == Edge.Right)
{
if (this.nodeLayout.Direction == Direction.RTL)
{
return(this.nodeLayout.Margin[(int)Edge.Start]);
}
return(this.nodeLayout.Margin[(int)Edge.End]);
}
return(this.nodeLayout.Margin[(int)edge]);
}
public static bool ParseStyleAttr(Style style, string attrKey, string attrValue)
{
bool parsed = true;
switch (attrKey)
{
case "direction":
parsed = Flex.StringToDirection(attrValue, out style.Direction);
break;
case "flex-direction":
parsed = Flex.StringToFlexDirection(attrValue, out style.FlexDirection);
break;
case "justify-content":
parsed = Flex.StringToJustify(attrValue, out style.JustifyContent);
break;
case "align-content":
parsed = Flex.StringToAlign(attrValue, out style.AlignContent);
break;
case "align-items":
parsed = Flex.StringToAlign(attrValue, out style.AlignItems);
break;
case "align-self":
parsed = Flex.StringToAlign(attrValue, out style.AlignSelf);
break;
case "flex-wrap":
parsed = Flex.StringToWrap(attrValue, out style.FlexWrap);
break;
case "overflow":
parsed = Flex.StringToOverflow(attrValue, out style.Overflow);
break;
case "display":
parsed = Flex.StringToDisplay(attrValue, out style.Display);
break;
case "flex-grow":
parsed = float.TryParse(attrValue, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out style.FlexGrow);
break;
case "flex-shrink":
parsed = float.TryParse(attrValue, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out style.FlexShrink);
break;
case "flex-basis":
parsed = ParseValueFromString(attrValue, out style.FlexBasis);
break;
case "position":
parsed = Flex.StringToPositionType(attrValue, out style.PositionType);
break;
case "left":
parsed = ParseValueFromString(attrValue, out style.Position[(int)Edge.Left]);
break;
case "top":
parsed = ParseValueFromString(attrValue, out style.Position[(int)Edge.Top]);
break;
case "right":
parsed = ParseValueFromString(attrValue, out style.Position[(int)Edge.Right]);
break;
case "bottom":
parsed = ParseValueFromString(attrValue, out style.Position[(int)Edge.Bottom]);
break;
case "width":
parsed = ParseValueFromString(attrValue, out style.Dimensions[(int)Dimension.Width]);
break;
case "height":
parsed = ParseValueFromString(attrValue, out style.Dimensions[(int)Dimension.Height]);
break;
case "min-width":
parsed = ParseValueFromString(attrValue, out style.MinDimensions[(int)Dimension.Width]);
break;
case "min-height":
parsed = ParseValueFromString(attrValue, out style.MinDimensions[(int)Dimension.Height]);
break;
case "max-width":
parsed = ParseValueFromString(attrValue, out style.MaxDimensions[(int)Dimension.Width]);
break;
case "max-height":
parsed = ParseValueFromString(attrValue, out style.MaxDimensions[(int)Dimension.Height]);
break;
case "margin":
case "margin-left":
case "margin-right":
case "margin-top":
case "margin-bottom":
case "padding":
case "padding-left":
case "padding-right":
case "padding-top":
case "padding-bottom":
case "border-width":
case "border-left-width":
case "border-right-width":
case "border-top-width":
case "border-bottom-width":
// parse [margin|padding|border]-[Edgexxxx]
if (ParseBreakWork(attrKey, out string head, out string tail))
{
if (tail == "")
{
switch (head)
{
case "margin": parsed = ParseFourValueFromString(attrValue, out style.Margin); break;
case "padding": parsed = ParseFourValueFromString(attrValue, out style.Padding); break;
case "border": parsed = ParseFourValueFromString(attrValue, out style.Border); break;
default: parsed = false; break;
}
}
else if (Flex.StringToEdge(tail, out Edge edge))
{
switch (head)
{
case "margin": parsed = ParseValueFromString(attrValue, out style.Margin[(int)edge]); break;
case "padding": parsed = ParseValueFromString(attrValue, out style.Padding[(int)edge]); break;
case "border": parsed = ParseValueFromString(attrValue, out style.Border[(int)edge]); break;
default: parsed = false; break;
}
}
else
{
parsed = false;
}
}
else
{
parsed = false;
}
break;
// get/set attribute by text name used string value
public virtual string this[string attr]
{
get
{
if (layoutAttributeAnimated.ContainsKey(attr))
{
return(layoutAttributeAnimated[attr]);
}
if (!layoutAttributeDefault.ContainsKey(attr))
{
throw new Exception("Try to get unknown layout style attribute [" + attr + "]");
}
string value = layoutAttribute.ContainsKey(attr) ? layoutAttribute[attr] : layoutAttributeDefault[attr];
if (layoutAttributeInherit.ContainsKey(attr) && value == "inherit")
{
//! Dirty-dirty hack (for good solution need to knew style of parent node, placed in TODO)
value = layoutAttributeInherit[attr];
}
return(value);
}
set
{
value = value.Trim();
// if attr is margin, padding, border-width - ignore it in change tracking and expands it to edges(top, right, bottom, and left)
if (attr == "margin" || attr == "padding" || attr == "border-width")
{
var tail = attr == "border-width" ? "-width" : "";
var name = attr == "border-width" ? "border" : attr;
if (Flex.ParseFourValueFromString(value, out var vals))
{
foreach (var kv in edgeNameToId)
{
this[name + "-" + kv.Key + tail] = vals[kv.Value].value.ToString("F", System.Globalization.CultureInfo.InvariantCulture)
+ (vals[kv.Value].unit == Unit.Percent ? "%" : "");
}
}
else
{
throw new Exception("Failed to parse attribute [" + attr + ":" + value + "]");
}
return;
}
if (!layoutAttributeDefault.ContainsKey(attr))
{
throw new Exception("Try to set unknown layout style attribute [" + attr + "]");
}
if (setMode)
{
var old_value = layoutAttributeWas.ContainsKey(attr) ? layoutAttributeWas[attr] : layoutAttributeDefault[attr];
if (value != old_value)
{
layoutAttributeChanged[attr] = old_value;
}
else if (layoutAttributeChanged.ContainsKey(attr))
{
layoutAttributeChanged.Remove(attr);
}
}
else
{
layoutAttributeChanged[attr] = this[attr];
}
layoutAttribute[attr] = value;
if (!Flex.ParseStyleAttr(this, attr, value))
{
throw new Exception("Failed to parse attribute [" + attr + ":" + value + "]");
}
}
}
public void MarkAsDirty()
{
Flex.nodeMarkDirtyInternal(this);
}
public void CalculateLayout(float parentWidth, float parentHeight, Direction parentDirection)
{
_layout = null;
Flex.CalculateLayout(this, parentWidth, parentHeight, parentDirection);
}
public void RemoveChild(Node child)
{
Flex.RemoveChild(this, child);
}
public void InsertChild(Node child, int idx)
{
Flex.InsertChild(this, child, idx);
}
public void AddChild(Node child)
{
Flex.InsertChild(this, child, ChildrenCount);
}
public Node GetChild(int idx)
{
return(Flex.GetChild(this, idx));
}
public void SetMeasureFunc(MeasureFunc measureFunc)
{
Flex.SetMeasureFunc(this, measureFunc);
}
