TemplateBuilder.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Web / UI / TemplateBuilder.cs / 1305376 / 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)]
    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.]
    ///  
    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.]
    ///  
    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); 
        }
    } 
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

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