Ejemplo n.º 1
0
        private void ParseAnimationOptions(AnimationRootNode rootNode)
        {
            while (tokenStream.HasMoreTokens && !AdvanceIfTokenType(StyleTokenType.BracesClose))
            {
                StyleToken typeToken  = tokenStream.Current;
                string     optionName = AssertTokenTypeAndAdvance(StyleTokenType.Identifier).ToLower();
                bool       typeFound  = false;
                for (int index = 0; index < s_AnimationOptionNames.Length; index++)
                {
                    string name = s_AnimationOptionNames[index].Item1;
                    if (name == optionName)
                    {
                        AssertTokenTypeAndAdvance(StyleTokenType.EqualSign);
                        StyleToken variableToken = tokenStream.Current;

                        AnimationOptionNode optionNode = StyleASTNodeFactory.AnimationOptionNode(s_AnimationOptionNames[index].Item2, ParsePropertyValue());
                        optionNode.WithLocation(variableToken);

                        rootNode.AddOptionNode(optionNode);

                        typeFound = true;

                        break;
                    }
                }

                if (!typeFound)
                {
                    throw new ParseException(typeToken, $"{optionName} is not a supported animation option. Valid values are: {FormatOptionList(s_AnimationOptionNames)}\n");
                }

                AssertTokenTypeAndAdvance(StyleTokenType.EndStatement);
            }
        }
Ejemplo n.º 2
0
    public void ParseAnimationOptionsHeader()
    {
        LightList <StyleASTNode> nodes = StyleParser.Parse(@"
            animation anim1 {
                [options] {
                    delay = 127;
                    loopType = constant;
                    loopTime = 100;
                    iterations = 99;
                    duration = 34;
                    forwardStartDelay = 1;
                    reverseStartDelay = 1;
                    direction = forward;
                    timingFunction = linear;
                }
            }
        ");

        Assert.AreEqual(1, nodes.Count);
        AnimationRootNode rootNode = nodes[0] as AnimationRootNode;

        AnimationOptionNode opt0 = rootNode.optionNodes[0];

        Assert.AreEqual("delay", opt0.optionName);
        Assert.AreEqual(StyleASTNodeType.NumericLiteral, opt0.value.type);

        AnimationOptionNode opt1 = rootNode.optionNodes[1];

        Assert.AreEqual("loopType", opt1.optionName);
        Assert.AreEqual(StyleASTNodeType.Identifier, opt1.value.type);

        AnimationOptionNode opt2 = rootNode.optionNodes[2];

        Assert.AreEqual("loopTime", opt2.optionName);
        Assert.AreEqual(StyleASTNodeType.NumericLiteral, opt2.value.type);

        AnimationOptionNode opt3 = rootNode.optionNodes[3];

        Assert.AreEqual("iterations", opt3.optionName);
        Assert.AreEqual(StyleASTNodeType.NumericLiteral, opt3.value.type);

        AnimationOptionNode opt4 = rootNode.optionNodes[4];

        Assert.AreEqual("duration", opt4.optionName);
        Assert.AreEqual(StyleASTNodeType.NumericLiteral, opt4.value.type);

        AnimationOptionNode opt5 = rootNode.optionNodes[5];

        Assert.AreEqual("forwardStartDelay", opt5.optionName);
        Assert.AreEqual(StyleASTNodeType.NumericLiteral, opt5.value.type);

        AnimationOptionNode opt6 = rootNode.optionNodes[6];

        Assert.AreEqual("reverseStartDelay", opt6.optionName);
        Assert.AreEqual(StyleASTNodeType.NumericLiteral, opt6.value.type);

        AnimationOptionNode opt7 = rootNode.optionNodes[7];

        Assert.AreEqual("direction", opt7.optionName);
        Assert.AreEqual(StyleASTNodeType.Identifier, opt7.value.type);

        AnimationOptionNode opt8 = rootNode.optionNodes[8];

        Assert.AreEqual("timingFunction", opt8.optionName);
        Assert.AreEqual(StyleASTNodeType.Identifier, opt8.value.type);
    }