示例#1
0
        bool ProcessTemplateStyle(Style style, string attrKey, string attrValue)
        {
            switch (attrKey)
            {
            case "direction":
                if (Flex.StringToDirection(attrValue, out Direction direction))
                {
                    style.Direction = direction;
                }
                break;

            case "flex-direction":
                if (Flex.StringToFlexDirection(attrValue, out FlexDirection flexDirection))
                {
                    style.FlexDirection = flexDirection;
                }
                break;

            case "justify-content":
                if (Flex.StringToJustify(attrValue, out Justify justifyContent))
                {
                    style.JustifyContent = justifyContent;
                }
                break;

            case "align-content":
                if (Flex.StringToAlign(attrValue, out Align alignContent))
                {
                    style.AlignContent = alignContent;
                }
                break;

            case "align-items":
                if (Flex.StringToAlign(attrValue, out Align alignItem))
                {
                    style.AlignItems = alignItem;
                }
                break;

            case "align-self":
                if (Flex.StringToAlign(attrValue, out Align alignSelf))
                {
                    style.AlignSelf = alignSelf;
                }
                break;

            case "flex-wrap":
                if (Flex.StringToWrap(attrValue, out Wrap flexWrap))
                {
                    style.FlexWrap = flexWrap;
                }
                break;

            case "overflow":
                if (Flex.StringToOverflow(attrValue, out Overflow overflow))
                {
                    style.Overflow = overflow;
                }
                break;

            case "display":
                if (Flex.StringToDisplay(attrValue, out Display display))
                {
                    style.Display = display;
                }
                break;

            case "flex":
                if (float.TryParse(attrValue, out float flex))
                {
                    style.Flex = flex;
                }
                break;

            case "flex-grow":
                if (float.TryParse(attrValue, out float flexGrow))
                {
                    style.FlexGrow = flexGrow;
                }
                break;

            case "flex-shrink":
                if (float.TryParse(attrValue, out float flexShrink))
                {
                    style.FlexShrink = flexShrink;
                }
                break;

            case "flex-basis":
                style.FlexBasis = ParseValueFromString(attrValue);
                break;

            case "position":
                if (Flex.StringToPositionType(attrValue, out PositionType position))
                {
                    style.PositionType = position;
                }
                break;

            case "width":
                style.Dimensions[(int)Dimension.Width] = ParseValueFromString(attrValue);
                break;

            case "height":
                style.Dimensions[(int)Dimension.Height] = ParseValueFromString(attrValue);
                break;

            case "min-width":
                style.MinDimensions[(int)Dimension.Width] = ParseValueFromString(attrValue);
                break;

            case "min-height":
                style.MinDimensions[(int)Dimension.Height] = ParseValueFromString(attrValue);
                break;

            case "max-width":
                style.MaxDimensions[(int)Dimension.Width] = ParseValueFromString(attrValue);
                break;

            case "max-height":
                style.MaxDimensions[(int)Dimension.Height] = ParseValueFromString(attrValue);
                break;

            default:
                // parse [margin|padding|border|pos]-[Edgexxxx]
                if (ParseBreakWork(attrKey, out string head, out string tail))
                {
                    Value[] valuesToSet = null;
                    switch (head)
                    {
                    case "margin": valuesToSet = style.Margin; break;

                    case "padding": valuesToSet = style.Padding; break;

                    case "border": valuesToSet = style.Border; break;

                    case "pos": valuesToSet = style.Position; break;

                    default: return(false);
                    }
                    if (valuesToSet == null)
                    {
                        break;
                    }

                    if (tail == "")
                    {
                        var valueArray = ParseFourValueFromString(attrValue);
                        if (valueArray != null)
                        {
                            for (int i = 0; i < valueArray.Length; i++)
                            {
                                valuesToSet[i] = valueArray[i];
                            }
                        }
                    }
                    else if (Flex.StringToEdge(tail, out Edge edge))
                    {
                        valuesToSet[(int)edge] = ParseValueFromString(attrValue);
                    }
                }
                else
                {
                    return(false);
                }
                break;
            }