TemplateBuilder.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / DotNET / DotNET / 8.0 / untmp / whidbey / REDBITS / ndp / fx / src / xsp / System / Web / UI / TemplateBuilder.cs / 1 / TemplateBuilder.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 
/*
 * 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
     */
 
    /// 
    ///    [To be supplied.] 
    ///  
    [AttributeUsage(AttributeTargets.Property)]
    [AspNetHostingPermission(SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)] 
    public sealed class TemplateContainerAttribute : Attribute {
        private Type _containerType;

        private BindingDirection _bindingDirection; 

 
        ///  
        /// Whether the template supports two-way binding.
        ///  
        public BindingDirection BindingDirection {
            get {
                return _bindingDirection;
            } 
        }
 
 
        /// 
        ///     
        /// 
        public Type ContainerType {
            get {
                return _containerType; 
            }
        } 
 

        ///  
        ///    [To be supplied.]
        /// 
        public TemplateContainerAttribute(Type containerType) : this(containerType, BindingDirection.OneWay) {
        } 

 
        ///  
        ///    [To be supplied.]
        ///  
        public TemplateContainerAttribute(Type containerType, BindingDirection bindingDirection) {
            _containerType = containerType;
            _bindingDirection = bindingDirection;
        } 
    }
 
 
    /// 
    ///    [To be supplied.] 
    /// 
    [AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
    [AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
    public class TemplateBuilder : ControlBuilder, ITemplate { 
        internal string _tagInnerText;
 
        private bool _allowMultipleInstances; 

        private IDesignerHost _designerHost; 


        public TemplateBuilder() {
            _allowMultipleInstances = true; 
        }
 
        ///  
        ///    [To be supplied.]
        ///  
        //  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
 
        ///  
        ///    [To be supplied.]
        ///  
        public override object BuildObject() {
            return this;
        }
 

        ///  
        ///    [To be supplied.] 
        /// 
        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; 
        }
 

        /// 
        ///    [To be supplied.]
        ///  
        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
         */ 

        ///  
        ///    [To be supplied.] 
        /// 
        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;
            } 
        }
 
 
        /// 
        ///    [To be supplied.] 
        /// 
        public virtual string Text {
            get { return _tagInnerText; }
            set { _tagInnerText = value; } 
        }
    } 
 
    // Delegates used for the compiled template
 
    /// 
    /// 
    ///    [To be supplied.]
    ///  
    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.
     */

    ///  
    /// 
    ///    [To be supplied.] 
    ///  
    [AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
    public sealed class CompiledTemplateBuilder : ITemplate { 
        private BuildTemplateMethod _buildTemplateMethod;


        ///  
        ///    [To be supplied.]
        ///  
        public CompiledTemplateBuilder(BuildTemplateMethod buildTemplateMethod) { 
            _buildTemplateMethod = buildTemplateMethod;
        } 

        // ITemplate::InstantiateIn

        ///  
        ///    [To be supplied.]
        ///  
        public void InstantiateIn(Control container) { 
            _buildTemplateMethod(container);
        } 
    }
}

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK