Files
mono/mcs/class/referencesource/System.Web/UI/DesignTimeTemplateParser.cs
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

194 lines
7.6 KiB
C#

//------------------------------------------------------------------------------
// <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;
}
}
}
}