Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web/UI/DesignTimeTemplateParser.cs

@@ -0,0 +1,193 @@
+//------------------------------------------------------------------------------
+// <copyright file="DesignTimeTemplateParser.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+namespace System.Web.UI {
+    using System;
+    using System.Collections;
+    using System.ComponentModel;
+    using System.ComponentModel.Design;
+    using System.Configuration;
+    using System.IO;
+    using System.Globalization;
+    using System.Security.Permissions;
+    using System.Text;
+    using System.Web;
+    using System.Web.Util;
+    using System.Web.Configuration;
+
+
+    /// <internalonly/>
+    public static class DesignTimeTemplateParser {
+
+        public static Control ParseControl(DesignTimeParseData data) {
+            Control[] parsedControls = ParseControlsInternal(data, true);
+
+            if (parsedControls.Length > 0) {
+                return parsedControls[0];
+            }
+
+            return null;
+        }
+
+
+        public static Control[] ParseControls(DesignTimeParseData data) {
+            return ParseControlsInternal(data, false);
+        }
+
+        /// <devdoc>
+        /// Convenience method for parsing one or more controls
+        /// </devdoc>
+        // DesignTimeTemplateParser is only meant for use within the designer
+        [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
+        internal static Control[] ParseControlsInternal(DesignTimeParseData data, bool returnFirst) {
+            try {
+                // Make the DesignerHost available only for the duration for this call
+                if (data.DesignerHost != null) {
+                    TargetFrameworkUtil.DesignerHost = data.DesignerHost;
+                }
+                return ParseControlsInternalHelper(data, returnFirst);
+            } finally {
+                // Remove reference to the DesignerHost so that it cannot be used outside
+                // of this call.
+                TargetFrameworkUtil.DesignerHost = null;
+            }
+        }
+
+        private static Control[] ParseControlsInternalHelper(DesignTimeParseData data, bool returnFirst) {
+            TemplateParser parser = new PageParser();
+            parser.FInDesigner = true;
+            parser.DesignerHost = data.DesignerHost;
+            parser.DesignTimeDataBindHandler = data.DataBindingHandler;
+            parser.Text = data.ParseText;
+            parser.Parse();
+
+            ArrayList parsedControls = new ArrayList();
+            ArrayList subBuilders = parser.RootBuilder.SubBuilders;
+
+            if (subBuilders != null) {
+                // Look for the first control builder
+                IEnumerator en = subBuilders.GetEnumerator();
+
+                for (int i = 0; en.MoveNext(); i++) {
+                    object cur = en.Current;
+
+                    if ((cur is ControlBuilder) && !(cur is CodeBlockBuilder)) {
+                        // Instantiate the control
+                        ControlBuilder controlBuilder = (ControlBuilder)cur;
+
+                        System.Diagnostics.Debug.Assert(controlBuilder.CurrentFilterResolutionService == null);
+
+                        IServiceProvider builderServiceProvider = null;
+
+                        // If there's a designer host, use it as the service provider
+                        if (data.DesignerHost != null) {
+                            builderServiceProvider = data.DesignerHost;
+                        }
+                        // If it doesn't exist, use a default ---- filter resolution service
+                        else {
+                            ServiceContainer serviceContainer = new ServiceContainer();
+                            serviceContainer.AddService(typeof(IFilterResolutionService), new SimpleDesignTimeFilterResolutionService(data.Filter));
+                            builderServiceProvider = serviceContainer;
+                        }
+
+                        controlBuilder.SetServiceProvider(builderServiceProvider);
+                        try {
+                            Control control = (Control)controlBuilder.BuildObject(data.ShouldApplyTheme);
+                            parsedControls.Add(control);
+                        }
+                        finally {
+                            controlBuilder.SetServiceProvider(null);
+                        }
+                        if (returnFirst) {
+                            break;
+                        }
+                    }
+                        // To preserve backwards compatibility, we don't add LiteralControls
+                        // to the control collection when parsing for a single control
+                    else if (!returnFirst && (cur is string)) {
+                        LiteralControl literalControl = new LiteralControl(cur.ToString());
+                        parsedControls.Add(literalControl);
+                    }
+                }
+            }
+
+            data.SetUserControlRegisterEntries(parser.UserControlRegisterEntries, parser.TagRegisterEntries);
+
+            return (Control[])parsedControls.ToArray(typeof(Control));
+        }
+
+
+        // DesignTimeTemplateParser is only meant for use within the designer
+        [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
+        public static ITemplate ParseTemplate(DesignTimeParseData data) {
+            TemplateParser parser = new PageParser();
+
+            parser.FInDesigner = true;
+            parser.DesignerHost = data.DesignerHost;
+            parser.DesignTimeDataBindHandler = data.DataBindingHandler;
+            parser.Text = data.ParseText;
+            parser.Parse();
+
+            // Set the Text property of the TemplateBuilder to the input text
+            parser.RootBuilder.Text = data.ParseText;
+            parser.RootBuilder.SetDesignerHost(data.DesignerHost);
+            return parser.RootBuilder;
+        }
+
+        public static ControlBuilder ParseTheme(IDesignerHost host, string theme, string themePath) {
+            try {
+                TemplateParser parser = new DesignTimePageThemeParser(themePath);
+                parser.FInDesigner = true;
+                parser.DesignerHost = host;
+                parser.ThrowOnFirstParseError = true;
+                
+                parser.Text = theme;
+                parser.Parse();
+
+                return parser.RootBuilder;
+            } catch (Exception e) {
+                throw new Exception(SR.GetString(SR.DesignTimeTemplateParser_ErrorParsingTheme) + " " + e.Message);
+            }
+        }
+
+        // Implementation of IDeviceFilterTester used at design time
+        private class SimpleDesignTimeFilterResolutionService : IFilterResolutionService {
+            private string _currentFilter;
+
+            public SimpleDesignTimeFilterResolutionService(string filter) {
+                _currentFilter = filter;
+            }
+
+            bool IFilterResolutionService.EvaluateFilter(string filterName) {
+                if (String.IsNullOrEmpty(filterName)) {
+                    return true;
+                }
+
+                if (StringUtil.EqualsIgnoreCase(((_currentFilter == null) ? String.Empty : _currentFilter), filterName)) {
+                    return true;
+                }
+
+                return false;
+            }
+
+            int IFilterResolutionService.CompareFilters(string filter1, string filter2) {
+                if (String.IsNullOrEmpty(filter1)) {
+                    if (!String.IsNullOrEmpty(filter2)) {
+                        return 1;
+                    }
+
+                    return 0;
+                }
+
+                if (String.IsNullOrEmpty(filter2)) {
+                    return -1;
+                }
+
+                return 0;
+            }
+        }
+    }
+}
+