Files
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

252 lines
7.7 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="TemplateBuilder.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
/*
* Classes related to templated control support
*
* Copyright (c) 1999 Microsoft Corporation
*/
namespace System.Web.UI {
using System;
using System.Collections;
using System.Reflection;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Security.Permissions;
/*
* This class defines the TemplateAttribute attribute that can be placed on
* properties of type ITemplate. It allows the parser to strongly type the
* container, which makes it easier to write render code in a template
*/
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
[AttributeUsage(AttributeTargets.Property)]
public sealed class TemplateContainerAttribute : Attribute {
private Type _containerType;
private BindingDirection _bindingDirection;
/// <devdoc>
/// <para>Whether the template supports two-way binding.</para>
/// </devdoc>
public BindingDirection BindingDirection {
get {
return _bindingDirection;
}
}
/// <devdoc>
/// <para></para>
/// </devdoc>
public Type ContainerType {
get {
return _containerType;
}
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public TemplateContainerAttribute(Type containerType) : this(containerType, BindingDirection.OneWay) {
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public TemplateContainerAttribute(Type containerType, BindingDirection bindingDirection) {
_containerType = containerType;
_bindingDirection = bindingDirection;
}
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public class TemplateBuilder : ControlBuilder, ITemplate {
internal string _tagInnerText;
private bool _allowMultipleInstances;
private IDesignerHost _designerHost;
public TemplateBuilder() {
_allowMultipleInstances = true;
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
// ID parameter name changed from ControlBuilder, so leave this to avoid a "breaking change"
public override void Init(TemplateParser parser, ControlBuilder parentBuilder, Type type, string tagName, string ID, IDictionary attribs) {
base.Init(parser, parentBuilder, type, tagName, ID, attribs);
if (InPageTheme && ParentBuilder != null && ParentBuilder.IsControlSkin) {
((PageThemeParser)Parser).CurrentSkinBuilder = parentBuilder;
}
}
public override void CloseControl() {
base.CloseControl();
if (InPageTheme && ParentBuilder != null && ParentBuilder.IsControlSkin) {
((PageThemeParser)Parser).CurrentSkinBuilder = null;
}
}
internal bool AllowMultipleInstances {
get { return _allowMultipleInstances; }
set { _allowMultipleInstances = value; }
}
// This code is only executed when used from the designer
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public override object BuildObject() {
return this;
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public override bool NeedsTagInnerText() {
// We want SetTagInnerText() to be called if we're running in the
// designer.
return InDesigner;
}
internal void SetDesignerHost(IDesignerHost designerHost) {
_designerHost = designerHost;
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public override void SetTagInnerText(string text) {
// Save the inner text of the template tag
_tagInnerText = text;
}
/*
* ITemplate implementation
* This implementation of ITemplate is only used in the designer
*/
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public virtual void InstantiateIn(Control container) {
IServiceProvider builderServiceProvider = null;
// Use the designer host to get one at designtime as the service provider
if (_designerHost != null) {
builderServiceProvider = _designerHost;
}
else if (!IsNoCompile) {
// Otherwise, create a ServiceContainer and try using the container as the service provider
ServiceContainer serviceContainer = new ServiceContainer();
if (container is IThemeResolutionService) {
serviceContainer.AddService(typeof(IThemeResolutionService), (IThemeResolutionService)container);
}
if (container is IFilterResolutionService) {
serviceContainer.AddService(typeof(IFilterResolutionService), (IFilterResolutionService)container);
}
builderServiceProvider = serviceContainer;
}
HttpContext context = null;
TemplateControl savedTemplateControl = null;
TemplateControl templateControl = container as TemplateControl;
if (templateControl != null) {
context = HttpContext.Current;
if (context != null)
savedTemplateControl = context.TemplateControl;
}
try {
if (!IsNoCompile)
SetServiceProvider(builderServiceProvider);
if (context != null) {
context.TemplateControl = templateControl;
}
BuildChildren(container);
}
finally {
if (!IsNoCompile)
SetServiceProvider(null);
// Restore the previous template control
if (context != null)
context.TemplateControl = savedTemplateControl;
}
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public virtual string Text {
get { return _tagInnerText; }
set { _tagInnerText = value; }
}
}
// Delegates used for the compiled template
/// <internalonly/>
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public delegate void BuildTemplateMethod(Control control);
/*
* This class is the ITemplate implementation that is called from the
* generated page class code. It just passes the Initialize call on to a
* delegate.
*/
/// <internalonly/>
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public sealed class CompiledTemplateBuilder : ITemplate {
private BuildTemplateMethod _buildTemplateMethod;
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public CompiledTemplateBuilder(BuildTemplateMethod buildTemplateMethod) {
_buildTemplateMethod = buildTemplateMethod;
}
// ITemplate::InstantiateIn
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public void InstantiateIn(Control container) {
_buildTemplateMethod(container);
}
}
}