Example #1
0
        public new static void Parse(XNode node, DefinitionFile file)
        {
            UiContainer.Parse(node, file);

            DefinitionParser parser = new DefinitionParser(node);

            file["Mode"]    = parser.ParseEnum <Mode>("Mode");
            file["Spacing"] = parser.ParseLength("Spacing", false);
            file["Padding"] = parser.ParseLength("Padding", false);
            file["NotifyParentOnResize"] = parser.ParseBoolean("NotifyParentOnResize");

            file["ExpandTime"]   = parser.ParseInt("ExpandTime");
            file["CollapseTime"] = parser.ParseInt("CollapseTime");
            file["Expanded"]     = parser.ParseBoolean("Expanded");

            file["Wrap"] = parser.ParseBoolean("Wrap");

            file["HorizontalContentAlignment"] = parser.ParseEnum <HorizontalContentAlignment>("HorizontalContentAlignment");
            file["VerticalContentAlignment"]   = parser.ParseEnum <VerticalContentAlignment>("VerticalContentAlignment");

            file["CollapseFinished"] = parser.ParseDelegate("CollapseFinished");
            file["ExpandFinished"]   = parser.ParseDelegate("ExpandFinished");

            file["ExpandStarted"] = parser.ParseDelegate("ExpandStarted");
        }
Example #2
0
        public new static void Parse(XNode node, DefinitionFile file)
        {
            UiView.Parse(node, file);

            var parser = new DefinitionParser(node);

            file["Text"]     = parser.ParseString("Text");
            file["Icon"]     = parser.ParseResource <Texture2D>("Icon");
            file["Click"]    = parser.ParseDelegate("Click");
            file["Hold"]     = parser.ParseDelegate("Hold");
            file["Enabled"]  = parser.ParseBoolean("Enabled");
            file["Disabled"] = parser.ParseBoolean("Disabled");

            file["RepeatStart"]    = parser.ParseInt("RepeatStart");
            file["RepeatInterval"] = parser.ParseInt("RepeatInterval");

            file["PushSound"]    = parser.ParseResource <SoundEffect>("PushSound");
            file["ReleaseSound"] = parser.ParseResource <SoundEffect>("ReleaseSound");
            file["ActionSound"]  = parser.ParseResource <SoundEffect>("ActionSound");

            file["GestureMargin"] = parser.ParseLength("GestureMargin");

            file["Mode"] = parser.ParseEnum <UiButtonMode>("Mode");

            foreach (var cn in node.Nodes)
            {
                switch (cn.Tag)
                {
                case "UiButton.Drawables":
                    ParseDrawables(cn, file, typeof(ButtonDrawable));
                    break;
                }
            }
        }
Example #3
0
        public new static void Parse(XNode node, DefinitionFile file)
        {
            UiView.Parse(node, file);

            var parser = new DefinitionParser(node);

            file["Processor"] = Type.GetType(node.Attribute("Processor"));

            file["LinkResolver"] = parser.ParseDelegate("LinkResolver");

            file["ImageNotLoaded"] = parser.ParseResource <Texture2D>("ImageNotLoaded");

            file["EnableBaseLineCorrection"] = parser.ParseBoolean("EnableBaseLineCorrection");

            file["Text"]        = parser.ParseString("Text");
            file["Font"]        = parser.ValueOrNull("Font");
            file["FontSize"]    = parser.ParseInt("FontSize");
            file["FontSpacing"] = parser.ParseInt("FontSpacing");

            for (int idx = 0; idx < (int)FontType.Count; ++idx)
            {
                FontType type    = (FontType)idx;
                string   font    = string.Format("{0}.Font", type);
                string   spacing = string.Format("{0}.FontSpacing", type);
                string   resize  = string.Format("{0}.FontResize", type);

                file[font]    = parser.ValueOrNull(font);
                file[spacing] = parser.ParseInt(spacing);
                file[resize]  = parser.ParseInt(resize);
            }

            for (int idx = 0; idx < (int)SizeType.Count; ++idx)
            {
                SizeType type = (SizeType)idx;
                string   size = string.Format("{0}.FontSize", type);

                file[size] = parser.ParseInt(size);
            }

            file["LineHeight"]       = parser.ParseInt("LineHeight");
            file["Indent"]           = parser.ParseLength("Indent");
            file["ParagraphSpacing"] = parser.ParseLength("ParagraphSpacing");

            file["Justify"] = parser.ParseBoolean("Justify");

            file["TextColor"]            = parser.ParseColor("TextColor");
            file["LinkColor"]            = parser.ParseColor("LinkColor");
            file["ActiveLinkColor"]      = parser.ParseColor("ActiveLinkColor");
            file["HorizontalRulerColor"] = parser.ParseColor("HorizontalRulerColor");

            file["HorizontalContentAlignment"] = parser.ParseEnum <HorizontalContentAlignment>("HorizontalContentAlignment");
            file["VerticalContentAlignment"]   = parser.ParseEnum <VerticalContentAlignment>("VerticalContentAlignment");

            file["BulletText"]            = parser.ParseString("BulletText");
            file["HorizontalRulerHeight"] = parser.ParseLength("HorizontalRulerHeight");

            file["ClickMargin"] = parser.ParseLength("ClickMargin");
            file["UrlClick"]    = parser.ParseDelegate("UrlClick");
        }
Example #4
0
        public new static void Parse(XNode node, DefinitionFile file)
        {
            ButtonDrawable.Parse(node, file);

            var parser = new DefinitionParser(node);

            file["Reverse"] = parser.ParseBoolean("Reverse");

            foreach (var cn in node.Nodes)
            {
                if (cn.Tag == "TransformGroup.TransitionEffect")
                {
                    if (cn.Nodes.Count != 1)
                    {
                        string error = node.NodeError("TransformGroup.TransitionEffect must have exactly 1 child.");
                        if (DefinitionParser.EnableCheckMode)
                        {
                            ConsoleEx.WriteLine(error);
                        }
                        else
                        {
                            throw new Exception(error);
                        }
                    }

                    file["TransitionEffect"] = DefinitionFile.LoadFile(cn.Nodes[0]);
                }
                else if (cn.Tag == "TransformGroup.Drawables")
                {
                    UiView.ParseDrawables(cn, file, typeof(ButtonDrawable));
                }
            }
        }
Example #5
0
        public static void Parse(XNode node, DefinitionFile file)
        {
            var parser = new DefinitionParser(node);

            file["ChangeTime"] = parser.ParseDouble("ChangeTime");

            file["Opacity"] = parser.ParseDouble("Opacity");

            file["ColorPushed"]   = parser.ParseColor("ColorPushed");
            file["ColorReleased"] = parser.ParseColor("ColorReleased");
            file["ColorDisabled"] = parser.ParseColor("ColorDisabled");
            file["Margin"]        = parser.ParseMargin("Margin");

            file["Checked"] = parser.ParseBoolean("Checked");
            file["Special"] = parser.ParseBoolean("Special");
        }
Example #6
0
        public new static void Parse(XNode node, DefinitionFile file)
        {
            UiContainer.Parse(node, file);

            DefinitionParser parser = new DefinitionParser(node);

            file["SelectedIndex"]  = parser.ParseInt("SelectedIndex");
            file["TransitionTime"] = parser.ParseDouble("TransitionTime");
            file["Cycle"]          = parser.ParseBoolean("Cycle");

            foreach (var cn in node.Nodes)
            {
                switch (cn.Tag)
                {
                case "UiContentSlider.ShowTransitionEffect":
                case "UiContentSlider.HideTransitionEffect":
                case "UiContentSlider.ShowTransitionEffectNext":
                case "UiContentSlider.HideTransitionEffectNext":
                case "UiContentSlider.ShowTransitionEffectPrev":
                case "UiContentSlider.HideTransitionEffectPrev":
                    ParseTransitionEffect(cn, file);
                    break;
                }
            }
        }
Example #7
0
        public new static void Parse(XNode node, DefinitionFile file)
        {
            UiContainer.Parse(node, file);

            var parser = new DefinitionParser(node);

            file["FitChildren"] = parser.ParseBoolean("FitChildren");
        }
Example #8
0
        public new static void Parse(XNode node, DefinitionFile file)
        {
            UiButton.Parse(node, file);

            var parser = new DefinitionParser(node);

            file["Checked"] = parser.ParseBoolean("Checked");
        }
Example #9
0
        public new static void Parse(XNode node, DefinitionFile file)
        {
            UiBorder.Parse(node, file);

            DefinitionParser parser = new DefinitionParser(node);

            file["TouchOutsideToHide"] = parser.ParseBoolean("TouchOutsideToHide");
            file["ClickOutside"]       = parser.ParseDelegate("ClickOutside");
        }
Example #10
0
        public new static void Parse(XNode node, DefinitionFile file)
        {
            UiView.Parse(node, file);

            var parser = new DefinitionParser(node);

            file["Image"]       = parser.ParseResource <NinePatchImage>("Image");
            file["ScaleByUnit"] = parser.ParseBoolean("ScaleByUnit");
            file["Scale"]       = parser.ParseDouble("Scale");
            file["Color"]       = parser.ParseColor("Color");
        }
Example #11
0
        public new static void Parse(XNode node, DefinitionFile file)
        {
            UiContainer.Parse(node, file);

            var parser = new DefinitionParser(node);

            file["PageController"] = file["Controller"];
            file["Controller"]     = null;

            file["PageShown"] = parser.ParseBoolean("PageShown");
        }
Example #12
0
        public new static void Parse(XNode node, DefinitionFile file)
        {
            UiButton.Parse(node, file);

            var parser = new DefinitionParser(node);

            file["Hint"] = parser.ParseString("Hint");

            file["InputType"]         = parser.ParseEnum <TextInputType>("InputType");
            file["CancelOnLostFocus"] = parser.ParseBoolean("CancelOnLostFocus");

            file["TextApply"]   = parser.ParseDelegate("TextApply");
            file["TextCancel"]  = parser.ParseDelegate("TextCancel");
            file["TextChanged"] = parser.ParseDelegate("TextChanged");

            file["LostFocus"] = parser.ParseDelegate("LostFocus");
            file["Return"]    = parser.ParseDelegate("Return");
            file["MaxLength"] = parser.ParseInt("MaxLength");

            file["IsFocused"] = parser.ParseBoolean("IsFocused");
        }
        public new static void Parse(XNode node, DefinitionFile file)
        {
            ButtonDrawable.Parse(node, file);

            var parser = new DefinitionParser(node);

            file["ImagePushed"]   = parser.ParseResource <NinePatchImage>("ImagePushed");
            file["ImageReleased"] = parser.ParseResource <NinePatchImage>("Image");
            file["ImageDisabled"] = parser.ParseResource <NinePatchImage>("ImageDisabled");
            file["ScaleByUnit"]   = parser.ParseBoolean("ScaleByUnit");

            file["Scale"] = parser.ParseDouble("Scale");
        }
Example #14
0
        public new static void Parse(XNode node, DefinitionFile file)
        {
            UiView.Parse(node, file);

            var parser = new DefinitionParser(node);

            file["Image"]         = parser.ParseResource <Texture2D>("Image");
            file["Stretch"]       = parser.ParseEnum <Stretch>("Stretch");
            file["Color"]         = parser.ParseColor("Color");
            file["RotationSpeed"] = parser.ParseDouble("RotationSpeed");
            file["ScaleByUnit"]   = parser.ParseBoolean("ScaleByUnit");
            file["Scale"]         = parser.ParseDouble("Scale");
        }
Example #15
0
        public new static void Parse(XNode node, DefinitionFile file)
        {
            UiBorder.Parse(node, file);

            var parser = new DefinitionParser(node);

            file["ExpandedWidth"]  = parser.ParseLength("ExpandedWidth");
            file["ExpandedHeight"] = parser.ParseLength("ExpandedHeight");
            file["ExpandTime"]     = parser.ParseInt("ExpandTime");
            file["Expanded"]       = parser.ParseBoolean("Expanded");

            file["CollapseFinished"] = parser.ParseDelegate("CollapseFinished");
            file["ExpandFinished"]   = parser.ParseDelegate("ExpandFinished");
        }
Example #16
0
        public new static void Parse(XNode node, DefinitionFile file)
        {
            UiView.Parse(node, file);

            var parser = new DefinitionParser(node);

            file["ClipChildren"]       = parser.ParseBoolean("ClipChildren");
            file["AutoCreateChildren"] = parser.ParseBoolean("AutoCreateChildren");

            List <DefinitionFile> list = new List <DefinitionFile>();

            foreach (var cn in node.Nodes)
            {
                if (!cn.Tag.Contains("."))
                {
                    list.Add(DefinitionFile.LoadFile(cn));
                }
            }

            if (list.Count > 0)
            {
                file["Children"] = list;
            }
        }
Example #17
0
        public new static void Parse(XNode node, DefinitionFile file)
        {
            UiView.Parse(node, file);
            var parser = new DefinitionParser(node);

            file["Items"]     = parser.ParseDelegate("Items");
            file["Reversed"]  = parser.ParseBoolean("Reversed");
            file["RowHeight"] = parser.ParseLength("RowHeight");

            file["ExceedRule"]       = parser.ParseEnum <ScrollingService.ExceedRule>("ExceedRule");
            file["WheelScrollSpeed"] = parser.ParseDouble("WheelScrollSpeed");

            file["SeparatorHeight"] = parser.ParseLength("SeparatorHeight");

            file["MaxScrollExceed"] = parser.ParseLength("MaxScrollExceed");

            foreach (var cn in node.Nodes)
            {
                switch (cn.Tag)
                {
                case "UiQuickList.Columns":
                    ParseColumns(cn, file);
                    break;

                case "UiQuickList.Separator":
                {
                    if (cn.Nodes.Count != 1)
                    {
                        string error = node.NodeError("UiQuickList.Separator must have exactly 1 child.");

                        if (DefinitionParser.EnableCheckMode)
                        {
                            ConsoleEx.WriteLine(error);
                        }
                        else
                        {
                            throw new Exception(error);
                        }
                    }


                    DefinitionFile separatorDef = DefinitionFile.LoadFile(cn.Nodes[0]);
                    file["Separator"] = separatorDef;
                }
                break;
                }
            }
        }
        public static new void Parse(XNode node, DefinitionFile file)
        {
            UiView.Parse(node, file);

            var parser = new DefinitionParser(node);

            file["AutomataGrid"] = parser.ParseDelegate("AutomataGrid");
            file["EditEnabled"] = parser.ParseBoolean("EditEnabled");

            file["Zoom"] = parser.ParseDouble("Zoom");
            file["StateToPaint"] = parser.ParseInt("StateToPaint");

            file["Colors"] = parser.ParseDelegate("Colors");

            file["GridColor"] = parser.ParseColor("GridColor");
        }
Example #19
0
        public new static void Parse(XNode node, DefinitionFile file)
        {
            ButtonDrawable.Parse(node, file);

            var parser = new DefinitionParser(node);

            file["Font"]        = parser.Value("Font");
            file["FontSize"]    = parser.ParseInt("FontSize");
            file["FontSpacing"] = parser.ParseInt("FontSpacing");
            file["LineHeight"]  = parser.ParseInt("LineHeight");
            file["HorizontalContentAlignment"] = parser.ParseEnum <HorizontalContentAlignment>("HorizontalContentAlignment");
            file["VerticalContentAlignment"]   = parser.ParseEnum <VerticalContentAlignment>("VerticalContentAlignment");
            file["Text"]         = parser.ParseString("Text");
            file["TextRotation"] = parser.ParseEnum <TextRotation>("TextRotation");
            file["PathEllipsis"] = parser.ParseBoolean("PathEllipsis");
            file["Line"]         = parser.ParseInt("Line");
        }
Example #20
0
        public new static void Parse(XNode node, DefinitionFile file)
        {
            UiView.Parse(node, file);

            var parser = new DefinitionParser(node);

            file["Text"]        = parser.ParseString("Text");
            file["Font"]        = parser.ValueOrNull("Font");
            file["FontSize"]    = parser.ParseInt("FontSize");
            file["FontSpacing"] = parser.ParseInt("FontSpacing");
            file["LineHeight"]  = parser.ParseInt("LineHeight");

            file["TextColor"] = parser.ParseColor("TextColor");
            file["HorizontalContentAlignment"] = parser.ParseEnum <HorizontalContentAlignment>("HorizontalContentAlignment");
            file["VerticalContentAlignment"]   = parser.ParseEnum <VerticalContentAlignment>("VerticalContentAlignment");

            file["AutoSizeUpdate"] = parser.ParseBoolean("AutoSizeUpdate");
            file["TextRotation"]   = parser.ParseEnum <TextRotation>("TextRotation");

            file["TextMargin"] = parser.ParseMargin("TextMargin");
        }
Example #21
0
        public new static void Parse(XNode node, DefinitionFile file)
        {
            UiView.Parse(node, file);

            var parser = new DefinitionParser(node);

            file["Text"]        = parser.ParseString("Text");
            file["Font"]        = parser.ValueOrNull("Font");
            file["FontSize"]    = parser.ParseInt("FontSize");
            file["FontSpacing"] = parser.ParseInt("FontSpacing");
            file["LineHeight"]  = parser.ParseInt("LineHeight");
            file["Indent"]      = parser.ParseLength("Indent");

            file["LineWidth"] = parser.ParseLength("LineWidth");

            file["Justify"] = parser.ParseBoolean("Justify");

            file["TextColor"] = parser.ParseColor("TextColor");
            file["HorizontalContentAlignment"] = parser.ParseEnum <HorizontalContentAlignment>("HorizontalContentAlignment");
            file["VerticalContentAlignment"]   = parser.ParseEnum <VerticalContentAlignment>("VerticalContentAlignment");
        }
Example #22
0
        public new static void Parse(XNode node, DefinitionFile file)
        {
            UiView.Parse(node, file);

            var parser = new DefinitionParser(node);

            file["Context"]       = parser.ParseDelegate("Context");
            file["ElementHeight"] = parser.ParseLength("ElementHeight");
            file["Spacing"]       = parser.ParseLength("Spacing");

            file["AutoValidate"] = parser.ParseBoolean("AutoValidate");

            file["SelectedPositionOffset"] = parser.ParseLength("SelectedPositionOffset");

            foreach (var cn in node.Nodes)
            {
                switch (cn.Tag)
                {
                case "ScrollingSelector.ItemDrawables":
                    ParseDrawables(cn, file, typeof(ButtonDrawable));
                    break;
                }
            }
        }
Example #23
0
        public new static void Parse(XNode node, DefinitionFile file)
        {
            UiView.Parse(node, file);

            var parser = new DefinitionParser(node);

            file["Context"]       = parser.ParseString("Context");
            file["Mode"]          = parser.ParseEnum <Mode>("Mode");
            file["AlwaysVisible"] = parser.ParseBoolean("AlwaysVisible");

            foreach (var cn in node.Nodes)
            {
                switch (cn.Tag)
                {
                case "UiScrollBar.ThumbDrawables":
                    ParseDrawables(cn, file, typeof(ButtonDrawable), "ThumbDrawables");
                    break;

                case "UiScrollBar.TrackDrawables":
                    ParseDrawables(cn, file, typeof(ButtonDrawable), "TrackDrawables");
                    break;
                }
            }
        }
Example #24
0
        public new static void Parse(XNode node, DefinitionFile file)
        {
            UiContainer.Parse(node, file);

            DefinitionParser parser = new DefinitionParser(node);

            file["Items"]            = parser.ParseDelegate("Items");
            file["Mode"]             = parser.ParseEnum <Mode>("Mode");
            file["Reverse"]          = parser.ParseBoolean("Reverse");
            file["MaxAddFirstTime"]  = parser.ParseInt("MaxAddFirstTime");
            file["MaxAddOneTime"]    = parser.ParseInt("MaxAddOneTime");
            file["ExceedRule"]       = parser.ParseEnum <ScrollingService.ExceedRule>("ExceedRule");
            file["WheelScrollSpeed"] = parser.ParseDouble("WheelScrollSpeed");
            file["MaxScrollExceed"]  = parser.ParseLength("MaxScrollExceed");

            Dictionary <Type, DefinitionFile> additionalTemplates = new Dictionary <Type, DefinitionFile>();

            foreach (var cn in node.Nodes)
            {
                switch (cn.Tag)
                {
                case "UiListBox.ItemTemplate":
                {
                    if (cn.Nodes.Count != 1)
                    {
                        string error = node.NodeError("UiListBox.ItemTemplate must have exactly 1 child.");

                        if (DefinitionParser.EnableCheckMode)
                        {
                            ConsoleEx.WriteLine(error);
                        }
                        else
                        {
                            throw new Exception(error);
                        }
                    }

                    if (string.IsNullOrEmpty(cn.Attribute("DataType")))
                    {
                        if (file["Template"] != null)
                        {
                            string error = node.NodeError("UiListBox default template already defined.");

                            if (DefinitionParser.EnableCheckMode)
                            {
                                ConsoleEx.WriteLine(error);
                            }
                            else
                            {
                                throw new Exception(error);
                            }
                        }

                        file["Template"] = DefinitionFile.LoadFile(cn.Nodes[0]);
                    }
                    else
                    {
                        Type type = Type.GetType(cn.Attribute("DataType"));

                        if (type == null)
                        {
                            string error = node.NodeError("Cannot find type: {0}", cn.Attribute("DataType"));

                            if (DefinitionParser.EnableCheckMode)
                            {
                                ConsoleEx.WriteLine(error);
                            }
                            else
                            {
                                throw new Exception(error);
                            }
                        }

                        additionalTemplates.Add(type, DefinitionFile.LoadFile(cn.Nodes[0]));
                    }
                }
                break;
                }
            }

            if (additionalTemplates.Count > 0)
            {
                file["AdditionalTemplates"] = additionalTemplates;
            }
        }
Example #25
0
        public static void Parse(XNode node, DefinitionFile file)
        {
            var parser = new DefinitionParser(node);

            file["Id"] = parser.ParseString("Id");

            string controller     = node.Attribute("Controller");
            Type   controllerType = null;

            if (!string.IsNullOrEmpty(controller))
            {
                controllerType = Type.GetType(controller);
                if (controllerType == null)
                {
                    throw new Exception(string.Format("Cannot find controller type: {0}.", controller));
                }
            }

            file["Controller"] = controllerType;

            file["Binding"] = parser.ParseDelegate("Binding");

            file["Modal"] = parser.ParseBoolean("Modal");

            file["Visible"] = parser.ParseBoolean("Visible");
            file["Hidden"]  = parser.ParseBoolean("Hidden");

            file["BackgroundColor"] = parser.ParseColor("BackgroundColor");

            file["Opacity"] = parser.ParseDouble("Opacity");

            file["ViewRemoved"] = parser.ParseDelegate("ViewRemoved");
            file["ViewAdded"]   = parser.ParseDelegate("ViewAdded");

            file["ViewActivated"]   = parser.ParseDelegate("ViewActivated");
            file["ViewDeactivated"] = parser.ParseDelegate("ViewDeactivated");

            file["ViewResized"] = parser.ParseDelegate("ViewResized");

            file["MinWidth"]  = parser.ParseLength("MinWidth", false);
            file["MinHeight"] = parser.ParseLength("MinHeight", false);

            file["ShowHideTime"] = parser.ParseDouble("ShowHideTime");

            file["HideTime"] = parser.ParseDouble("HideTime");
            file["ShowTime"] = parser.ParseDouble("ShowTime");

            file["Tag"] = parser.ParseString("Tag");

            PositionParameters.Parse(node, file);

            foreach (var cn in node.Nodes)
            {
                if (cn.Tag == "UiView.BackgroundDrawable")
                {
                    if (cn.Nodes.Count != 1)
                    {
                        string error = node.NodeError("UiView.BackgroundDrawable must have exactly 1 child.");
                        if (DefinitionParser.EnableCheckMode)
                        {
                            ConsoleEx.WriteLine(error);
                        }
                        else
                        {
                            throw new Exception(error);
                        }
                    }

                    file["BackgroundDrawable"] = DefinitionFile.LoadFile(cn.Nodes[0]);
                }

                if (cn.Tag == "UiView.ShowTransitionEffect")
                {
                    if (cn.Nodes.Count != 1)
                    {
                        string error = node.NodeError("UiView.ShowTransitionEffect must have exactly 1 child.");
                        if (DefinitionParser.EnableCheckMode)
                        {
                            ConsoleEx.WriteLine(error);
                        }
                        else
                        {
                            throw new Exception(error);
                        }
                    }

                    file["ShowTransitionEffect"] = DefinitionFile.LoadFile(cn.Nodes[0]);
                }

                if (cn.Tag == "UiView.HideTransitionEffect")
                {
                    if (cn.Nodes.Count != 1)
                    {
                        string error = node.NodeError("UiView.HideTransitionEffect must have exactly 1 child.");
                        if (DefinitionParser.EnableCheckMode)
                        {
                            ConsoleEx.WriteLine(error);
                        }
                        else
                        {
                            throw new Exception(error);
                        }
                    }

                    file["HideTransitionEffect"] = DefinitionFile.LoadFile(cn.Nodes[0]);
                }

                if (cn.Tag == "UiView.ParentShowTransitionEffect")
                {
                    if (cn.Nodes.Count != 1)
                    {
                        string error = node.NodeError("UiView.NavigateToTransitionEffect must have exactly 1 child.");
                        if (DefinitionParser.EnableCheckMode)
                        {
                            ConsoleEx.WriteLine(error);
                        }
                        else
                        {
                            throw new Exception(error);
                        }
                    }

                    file["ParentShowTransitionEffect"] = DefinitionFile.LoadFile(cn.Nodes[0]);
                }

                if (cn.Tag == "UiView.ParentHideTransitionEffect")
                {
                    if (cn.Nodes.Count != 1)
                    {
                        string error = node.NodeError("UiView.NavigateFromTransitionEffect must have exactly 1 child.");
                        if (DefinitionParser.EnableCheckMode)
                        {
                            ConsoleEx.WriteLine(error);
                        }
                        else
                        {
                            throw new Exception(error);
                        }
                    }

                    file["ParentHideTransitionEffect"] = DefinitionFile.LoadFile(cn.Nodes[0]);
                }
            }
        }