xref: /dports/lang/mono/mono-5.10.1.57/mcs/class/referencesource/System.Web/UI/Control.cs

//------------------------------------------------------------------------------
// <copyright file="Control.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------

namespace System.Web.UI {
    using System;
    using System.Collections;
    using System.Collections.Specialized;
    using System.ComponentModel;
    using System.ComponentModel.Design;
    using System.ComponentModel.Design.Serialization;
    using System.Diagnostics.CodeAnalysis;
    using System.Globalization;
    using System.IO;
    using System.Reflection;
    using System.Runtime.CompilerServices;
    using System.Security.Permissions;
    using System.Text;
    using System.Threading.Tasks;
    using System.Web.Caching;
    using System.Web.Configuration;
    using System.Web.Hosting;
    using System.Web.Routing;
    using System.Web.UI.Adapters;
    using System.Web.UI.HtmlControls;
    using System.Web.UI.WebControls;
    using System.Web.Util;
    using HttpException = System.Web.HttpException;

    // Delegate used for the compiled template
    public delegate void RenderMethod(HtmlTextWriter output, Control container);

    public delegate Control BuildMethod();

    // Defines the properties, methods, and events that are shared by all server
    // controls in the Web Forms page framework.</para>
    [
    Bindable(true),
    DefaultProperty("ID"),
    DesignerCategory("Code"),
    Designer("System.Web.UI.Design.ControlDesigner, " + AssemblyRef.SystemDesign),
    DesignerSerializer("Microsoft.VisualStudio.Web.WebForms.ControlCodeDomSerializer, " + AssemblyRef.MicrosoftVisualStudioWeb,  "System.ComponentModel.Design.Serialization.CodeDomSerializer, " + AssemblyRef.SystemDesign),
    Themeable(false),
    ToolboxItemFilter("System.Web.UI", ToolboxItemFilterType.Require),
    ToolboxItemAttribute("System.Web.UI.Design.WebControlToolboxItem, " + AssemblyRef.SystemDesign)
    ]
    public class Control : IComponent, IParserAccessor, IUrlResolutionService, IDataBindingsAccessor, IControlBuilderAccessor, IControlDesignerAccessor, IExpressionsAccessor {

        internal static readonly object EventDataBinding = new object();
        internal static readonly object EventInit = new object();
        internal static readonly object EventLoad = new object();
        internal static readonly object EventUnload = new object();
        internal static readonly object EventPreRender = new object();
        private static readonly object EventDisposed = new object();

        internal const bool EnableViewStateDefault = true;
        internal const char ID_SEPARATOR = '$';
        private const char ID_RENDER_SEPARATOR = '_';
        internal const char LEGACY_ID_SEPARATOR = ':';

        private string _id;
        // allows us to reuse the id variable to store a calculated id w/o polluting the public getter
        private string _cachedUniqueID;
        private string _cachedPredictableID;
        private Control _parent;

        // fields related to being a container
        private ControlState _controlState;
        private StateBag _viewState;

        private EventHandlerList _events;
        private ControlCollection _controls;

        // The naming container that this control leaves in.  Note that even if
        // this ctrl is a naming container, it will not point to itself, but to
        // the naming container that contains it.
        private Control _namingContainer;
        internal Page _page;
        private OccasionalFields _occasionalFields;
        // The virtual directory of the Page or UserControl that hosts this control.

        // const masks into the BitVector32
        private const int idNotCalculated           = 0x00000001;
        private const int marked                    = 0x00000002;
        private const int disableViewState          = 0x00000004;
        private const int controlsCreated           = 0x00000008;
        private const int invisible                 = 0x00000010;
        private const int visibleDirty              = 0x00000020;
        private const int idNotRequired             = 0x00000040;
        private const int isNamingContainer         = 0x00000080;
        private const int creatingControls          = 0x00000100;
        private const int notVisibleOnPage          = 0x00000200;
        private const int themeApplied              = 0x00000400;
        private const int mustRenderID              = 0x00000800;
        private const int disableTheming            = 0x00001000;
        private const int enableThemingSet          = 0x00002000;
        private const int styleSheetApplied         = 0x00004000;
        private const int controlAdapterResolved    = 0x00008000;
        private const int designMode                = 0x00010000;
        private const int designModeChecked         = 0x00020000;
        private const int disableChildControlState  = 0x00040000;
        internal const int isWebControlDisabled     = 0x00080000;
        private const int controlStateApplied       = 0x00100000;
        private const int useGeneratedID            = 0x00200000;
        private const int validateRequestModeDirty  = 0x00400000;
        private const int viewStateNotInherited     = 0x00800000;
        private const int viewStateMode             = 0x01000000;
        private const int clientIDMode              = 0x06000000;
        private const int clientIDModeOffset        = 25;
        private const int effectiveClientIDMode     = 0x18000000;
        private const int effectiveClientIDModeOffset = 27;
        private const int validateRequestMode       = 0x60000000;
        private const int validateRequestModeOffset = 29;
        #pragma warning disable 0649
        internal SimpleBitVector32 flags;
        #pragma warning restore 0649

        private const string automaticIDPrefix = "ctl";
        private const string automaticLegacyIDPrefix = "_ctl";
        private const int automaticIDCount = 128;
        private static readonly string[] automaticIDs = new string [automaticIDCount] {
            "ctl00", "ctl01", "ctl02", "ctl03", "ctl04", "ctl05", "ctl06",
            "ctl07", "ctl08", "ctl09", "ctl10", "ctl11", "ctl12", "ctl13",
            "ctl14", "ctl15", "ctl16", "ctl17", "ctl18", "ctl19", "ctl20",
            "ctl21", "ctl22", "ctl23", "ctl24", "ctl25", "ctl26", "ctl27",
            "ctl28", "ctl29", "ctl30", "ctl31", "ctl32", "ctl33", "ctl34",
            "ctl35", "ctl36", "ctl37", "ctl38", "ctl39", "ctl40", "ctl41",
            "ctl42", "ctl43", "ctl44", "ctl45", "ctl46", "ctl47", "ctl48",
            "ctl49", "ctl50", "ctl51", "ctl52", "ctl53", "ctl54", "ctl55",
            "ctl56", "ctl57", "ctl58", "ctl59", "ctl60", "ctl61", "ctl62",
            "ctl63", "ctl64", "ctl65", "ctl66", "ctl67", "ctl68", "ctl69",
            "ctl70", "ctl71", "ctl72", "ctl73", "ctl74", "ctl75", "ctl76",
            "ctl77", "ctl78", "ctl79", "ctl80", "ctl81", "ctl82", "ctl83",
            "ctl84", "ctl85", "ctl86", "ctl87", "ctl88", "ctl89", "ctl90",
            "ctl91", "ctl92", "ctl93", "ctl94", "ctl95", "ctl96", "ctl97",
            "ctl98", "ctl99",
            "ctl100", "ctl101", "ctl102", "ctl103", "ctl104", "ctl105", "ctl106",
            "ctl107", "ctl108", "ctl109", "ctl110", "ctl111", "ctl112", "ctl113",
            "ctl114", "ctl115", "ctl116", "ctl117", "ctl118", "ctl119", "ctl120",
            "ctl121", "ctl122", "ctl123", "ctl124", "ctl125", "ctl126", "ctl127"

        };

        /// <devdoc>
        /// <para>Initializes a new instance of the <see cref='System.Web.UI.Control'/> class.</para>
        /// </devdoc>
        public Control() {
            if (this is INamingContainer)
                flags.Set(isNamingContainer);
        }

        private ClientIDMode ClientIDModeValue {
            get {
                return (ClientIDMode)flags[clientIDMode, clientIDModeOffset];
            }
            set {
                flags[clientIDMode, clientIDModeOffset] = (int)value;
            }
        }

        [SuppressMessage("Microsoft.Naming", "CA1706:ShortAcronymsShouldBeUppercase", MessageId="Member")]
        [
        DefaultValue(ClientIDMode.Inherit),
        Themeable(false),
        WebCategory("Behavior"),
        WebSysDescription(SR.Control_ClientIDMode)
        ]
        public virtual ClientIDMode ClientIDMode {
            get {
                return ClientIDModeValue;
            }
            set {
                if (ClientIDModeValue != value) {
                    if (value != EffectiveClientIDModeValue) {
                        ClearEffectiveClientIDMode();
                        ClearCachedClientID();
                    }
                    ClientIDModeValue = value;
                }
            }
        }

        private ClientIDMode EffectiveClientIDModeValue {
            get {
                return (ClientIDMode)flags[effectiveClientIDMode, effectiveClientIDModeOffset];
            }
            set {
                flags[effectiveClientIDMode, effectiveClientIDModeOffset] = (int)value;
            }
        }

        internal virtual ClientIDMode EffectiveClientIDMode {
            get {
                if (EffectiveClientIDModeValue == ClientIDMode.Inherit) {
                    EffectiveClientIDModeValue = ClientIDMode;
                    if (EffectiveClientIDModeValue == ClientIDMode.Inherit) {
                        if (NamingContainer != null) {
                            EffectiveClientIDModeValue = NamingContainer.EffectiveClientIDMode;
                        }
                        else {
                            HttpContext context = Context;
                            if (context != null) {
                                EffectiveClientIDModeValue = RuntimeConfig.GetConfig(context).Pages.ClientIDMode;
                            }
                            else {
                                EffectiveClientIDModeValue = RuntimeConfig.GetConfig().Pages.ClientIDMode;
                            }
                        }
                    }
                }
                return EffectiveClientIDModeValue;
            }
        }

        internal string UniqueClientID {
            get {
                string uniqueID = UniqueID;
                if(uniqueID != null && uniqueID.IndexOf(IdSeparator) >= 0) {
                    return uniqueID.Replace(IdSeparator, ID_RENDER_SEPARATOR);
                }
                return uniqueID;
            }
        }

        internal string StaticClientID {
            get {
                return flags[useGeneratedID] ? String.Empty : ID ?? String.Empty;
            }
        }

        internal ControlAdapter AdapterInternal {
            get {
                if (_occasionalFields == null ||
                    _occasionalFields.RareFields == null ||
                    _occasionalFields.RareFields.Adapter == null) {
                        return null;
                }
                return _occasionalFields.RareFields.Adapter;
            }
            set {
                if (value != null) {
                    RareFieldsEnsured.Adapter = value;
                }
                else {
                    if (_occasionalFields != null &&
                        _occasionalFields.RareFields != null &&
                        _occasionalFields.RareFields.Adapter != null) {
                            _occasionalFields.RareFields.Adapter = null;
                    }
                }
            }
        }

        private string GetClientID() {
            switch (EffectiveClientIDMode) {
                case ClientIDMode.Predictable:
                    return PredictableClientID;
                case ClientIDMode.Static:
                    return StaticClientID;
                default:
                    return UniqueClientID;
            }
        }

        private string GetPredictableClientIDPrefix() {
            string predictableIDPrefix;

            Control namingContainer = NamingContainer;
            if (namingContainer != null) {
                if (_id == null) {
                    GenerateAutomaticID();
                }
                if (namingContainer is Page || namingContainer is MasterPage) {
                    predictableIDPrefix = _id;
                }
                else {
                    predictableIDPrefix = namingContainer.GetClientID();
                    if (String.IsNullOrEmpty(predictableIDPrefix)) {
                        predictableIDPrefix = _id;
                    }
                    else {
                        if (!String.IsNullOrEmpty(_id) && (!(this is IDataItemContainer) || (this is IDataBoundItemControl))) {
                            predictableIDPrefix = predictableIDPrefix + ID_RENDER_SEPARATOR + _id;
                        }
                    }
                }
            }
            else {
                predictableIDPrefix = _id;
            }
            return predictableIDPrefix;
        }

        private string GetPredictableClientIDSuffix() {
            string predictableIDSuffix = null;

            Control dataItemContainer = DataItemContainer;
            if (dataItemContainer != null &&
                !(dataItemContainer is IDataBoundItemControl) &&
                (!(this is IDataItemContainer) || (this is IDataBoundItemControl))) {
                Control dataKeysContainer = dataItemContainer.DataKeysContainer;
                if (dataKeysContainer != null && (((IDataKeysControl)dataKeysContainer).ClientIDRowSuffix != null) && (((IDataKeysControl)dataKeysContainer).ClientIDRowSuffix.Length > 0)) {
                    predictableIDSuffix = String.Empty;
                    IOrderedDictionary dataKey = ((IDataKeysControl)dataKeysContainer).ClientIDRowSuffixDataKeys[((IDataItemContainer)dataItemContainer).DisplayIndex].Values;
                    foreach (string suffixName in ((IDataKeysControl)dataKeysContainer).ClientIDRowSuffix) {
                        predictableIDSuffix = predictableIDSuffix + ID_RENDER_SEPARATOR + dataKey[suffixName].ToString();
                    }
                }
                else {
                    int index = ((IDataItemContainer)dataItemContainer).DisplayIndex;
                    if (index >= 0) {
                        predictableIDSuffix = ID_RENDER_SEPARATOR + index.ToString(CultureInfo.InvariantCulture);
                    }
                }
            }
            return predictableIDSuffix;
        }

        internal string PredictableClientID {
            get {
                if (_cachedPredictableID != null) {
                    return _cachedPredictableID;
                }

                _cachedPredictableID = GetPredictableClientIDPrefix();
                string suffixID = GetPredictableClientIDSuffix();

                // Concatenates Predictable clientID and ClientIDRowSuffix if available
                if (!String.IsNullOrEmpty(suffixID)) {
                    if (!String.IsNullOrEmpty(_cachedPredictableID)) {
                        _cachedPredictableID = _cachedPredictableID + suffixID;
                    }
                    else {
                        _cachedPredictableID = suffixID.Substring(1);
                    }
                }
                return String.IsNullOrEmpty(_cachedPredictableID) ? String.Empty : _cachedPredictableID;
            }
        }

        /// <devdoc>
        ///    <para>Indicates the control identifier generated by the ASP.NET framework. </para>
        /// </devdoc>
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        WebSysDescription(SR.Control_ClientID)
        ]
        public virtual string ClientID {
            // This property is required to render a unique client-friendly id.
            get {
                if (EffectiveClientIDMode != ClientIDMode.Static) {
                    // Ensure that ID is set. The assumption being made is that the caller
                    // is likely to use the client ID in script, and to support that the
                    // control should render out an ID attribute
                    EnsureID();
                }
                return GetClientID();
            }
        }

        protected char ClientIDSeparator {
            get {
                return ID_RENDER_SEPARATOR;
            }
        }

        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [
        WebSysDescription(SR.Control_OnDisposed)
        ]
        public event EventHandler Disposed {
            add {
                Events.AddHandler(EventDisposed, value);
            }
            remove {
                Events.RemoveHandler(EventDisposed, value);
            }
        }

        /// <devdoc>
        /// <para>Gets the <see langword='HttpContext'/> object of the current Web request. If
        ///    the control's context is <see langword='null'/>, this will be the context of the
        ///    control's parent, unless the parent control's context is <see langword='null'/>.
        ///    If this is the case, this will be equal to the HttpContext property.</para>
        /// </devdoc>
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        protected internal virtual HttpContext Context {
            //  Request context containing the intrinsics
            get {
                Page page = Page;
                if(page != null) {
                    return page.Context;
                }
                return HttpContext.Current;
            }
        }

        protected virtual ControlAdapter ResolveAdapter() {
            if(flags[controlAdapterResolved]) {
                return AdapterInternal;
            }
            if (DesignMode) {
                flags.Set(controlAdapterResolved);
                return null;
            }

            HttpContext context = Context;
            if (context != null && context.Request.Browser != null) {
                AdapterInternal = context.Request.Browser.GetAdapter(this);
            }
            flags.Set(controlAdapterResolved);
            return AdapterInternal;
        }

        /// <devdoc>
        ///    <para>Indicates the list of event handler delegates for the control. This property
        ///       is read-only.</para>
        /// </devdoc>
        protected ControlAdapter Adapter {
            get {
                if(flags[controlAdapterResolved]) {
                    return AdapterInternal;
                }
                AdapterInternal = ResolveAdapter();
                flags.Set(controlAdapterResolved);
                return AdapterInternal;
            }
        }

        /// <devdoc>
        /// Indicates whether a control is being used in the context of a design surface.
        /// </devdoc>
        protected internal bool DesignMode {
            get {
                if(!flags[designModeChecked]) {
                    Page page = Page;
                    if(page != null )  {
                        if(page.GetDesignModeInternal()) {
                            flags.Set(designMode);
                        }
                        else {
                            flags.Clear(designMode);
                        }
                    }
                    else {
                        if(Site != null) {
                            if(Site.DesignMode) {
                                flags.Set(designMode);
                            }
                            else {
                                flags.Clear(designMode);
                            }
                        }
                        else if (Parent != null) {
                            if(Parent.DesignMode) {
                                flags.Set(designMode);
                            }

                            // VSWhidbey 535747: If Page, Site and Parent are all null, do not change the
                            // designMode flag since it might had been previously set by the controlBuilder.
                            // This does not affect runtime since designMode is by-default false.
                            /*
                            else {
                                flags.Clear(designMode);
                            }
                            */
                        }
                    }
                    flags.Set(designModeChecked);
                }
                return flags[designMode];

            }
        }

        // Helper function to call validateEvent.
        internal void ValidateEvent(string uniqueID) {
            ValidateEvent(uniqueID, String.Empty);
        }

        // Helper function to call validateEvent.
        internal void ValidateEvent(string uniqueID, string eventArgument) {
            if (Page != null && SupportsEventValidation) {
                Page.ClientScript.ValidateEvent(uniqueID, eventArgument);
            }
        }

        // Indicates whether the control supports event validation
        // By default, all web controls in System.Web assembly supports it but not custom controls.
        private bool SupportsEventValidation {
            get {
                return SupportsEventValidationAttribute.SupportsEventValidation(this.GetType());
            }
        }

        /// <devdoc>
        ///    <para>Indicates the list of event handler delegates for the control. This property
        ///       is read-only.</para>
        /// </devdoc>
        protected EventHandlerList Events {
            get {
                if (_events == null) {
                    _events = new EventHandlerList();
                }
                return _events;
            }
        }

        protected bool HasEvents() {
            return (_events != null);
        }

        /// <devdoc>
        ///    <para> Gets or sets the identifier for the control. Setting the
        ///       property on a control allows programmatic access to the control's properties. If
        ///       this property is not specified on a control, either declaratively or
        ///       programmatically, then you cannot write event handlers and the like for the control.</para>
        /// </devdoc>
        [
        ParenthesizePropertyName(true),
        MergableProperty(false),
        Filterable(false),
        Themeable(false),
        WebSysDescription(SR.Control_ID)
        ]
        public virtual string ID {
            get {
                if (!flags[idNotCalculated] && !flags[mustRenderID]) {
                    return null;
                }
                return _id;
            }
            set {
                // allow the id to be unset
                if (value != null && value.Length == 0)
                    value = null;

                string oldID = _id;

                _id = value;
                ClearCachedUniqueIDRecursive();
                flags.Set(idNotCalculated);
                flags.Clear(useGeneratedID);

                // Update the ID in the naming container
                if ((_namingContainer != null) && (oldID != null)) {
                    _namingContainer.DirtyNameTable();
                }

                if (oldID != null && oldID != _id) {
                    ClearCachedClientID();
                }
            }
        }


        /// <devdoc>
        ///    <para>Gets and sets a value indicating whether theme is enabled.</para>
        /// </devdoc>
        [
        Browsable(false),
        DefaultValue(true),
        Themeable(false),
        WebCategory("Behavior"),
        WebSysDescription(SR.Control_EnableTheming)
        ]
        public virtual bool EnableTheming {
            get {
                if (flags[enableThemingSet]) {
                    return !flags[disableTheming];
                }

                if (Parent != null) {
                    return Parent.EnableTheming;
                }

                return !flags[disableTheming];
            }
            set {
                if ((_controlState >= ControlState.FrameworkInitialized) && !DesignMode) {
                    throw new InvalidOperationException(SR.GetString(SR.PropertySetBeforePreInitOrAddToControls, "EnableTheming"));
                }

                if(!value) {
                    flags.Set(disableTheming);
                }
                else {
                    flags.Clear(disableTheming);
                }

                flags.Set(enableThemingSet);
            }
        }

        // Serialzie the value if it's set explicitely.
        internal bool ShouldSerializeEnableTheming() {
            return flags[enableThemingSet];;
        }

        internal bool IsBindingContainer {
            get {
                return this is INamingContainer && !(this is INonBindingContainer);
            }
        }

        protected internal bool IsChildControlStateCleared {
            get {
                return flags[disableChildControlState];
            }
        }


        /// <devdoc>
        ///    <para>Gets and sets the skinID of the control.</para>
        /// </devdoc>
        [
        Browsable(false),
        DefaultValue(""),
        Filterable(false),
        WebCategory("Behavior"),
        WebSysDescription(SR.Control_SkinId),
        ]
        public virtual string SkinID {
            get {
                if(_occasionalFields != null) {
                    return _occasionalFields.SkinId == null ? String.Empty : _occasionalFields.SkinId;
                }
                return String.Empty;
            }
            set {
                if (!DesignMode) {
                    if (flags[styleSheetApplied]) {
                        throw new InvalidOperationException(SR.GetString(SR.PropertySetBeforeStyleSheetApplied, "SkinId"));
                    }

                    if (_controlState >= ControlState.FrameworkInitialized) {
                        throw new InvalidOperationException(SR.GetString(SR.PropertySetBeforePreInitOrAddToControls, "SkinId"));
                    }
                }

                EnsureOccasionalFields();
                _occasionalFields.SkinId = value;
            }
        }

        private ControlRareFields RareFieldsEnsured {
            get {
                EnsureOccasionalFields();
                ControlRareFields rareFields = _occasionalFields.RareFields;
                if(rareFields == null) {
                    rareFields = new ControlRareFields();
                    _occasionalFields.RareFields = rareFields;
                }

                return rareFields;
            }
        }

        private ControlRareFields RareFields {
            get {
                if(_occasionalFields != null) {
                    return _occasionalFields.RareFields;
                }
                return null;
            }
        }

        private void EnsureOccasionalFields() {
            if(_occasionalFields == null) {
                _occasionalFields = new OccasionalFields();
            }
        }


        /// <devdoc>
        ///    <para>
        ///       Gets or sets a value indicating whether the control should maintain its view
        ///       state, and the view state of any child control in contains, when the current
        ///       page request ends.
        ///    </para>
        /// </devdoc>
        [
        DefaultValue(EnableViewStateDefault),
        Themeable(false),
        WebCategory("Behavior"),
        WebSysDescription(SR.Control_MaintainState)
        ]
        public virtual bool EnableViewState {
            get {
                return !flags[disableViewState];
            }
            set {
                SetEnableViewStateInternal(value);
            }
        }

        [
        DefaultValue(ViewStateMode.Inherit),
        Themeable(false),
        WebCategory("Behavior"),
        WebSysDescription(SR.Control_ViewStateMode)
        ]
        public virtual ViewStateMode ViewStateMode {
            get {
                return flags[viewStateNotInherited] ?
                    (flags[viewStateMode] ? ViewStateMode.Enabled : ViewStateMode.Disabled) :
                    ViewStateMode.Inherit;
            }
            set {
                if ((value < ViewStateMode.Inherit) || (value > ViewStateMode.Disabled)) {
                    throw new ArgumentOutOfRangeException("value");
                }
                if (value == ViewStateMode.Inherit) {
                    flags.Clear(viewStateNotInherited);
                }
                else {
                    flags.Set(viewStateNotInherited);
                    if (value == ViewStateMode.Enabled) {
                        flags.Set(viewStateMode);
                    }
                    else {
                        flags.Clear(viewStateMode);
                    }
                }
            }
        }


        internal void SetEnableViewStateInternal(bool value) {
            if (!value)
                flags.Set(disableViewState);
            else
                flags.Clear(disableViewState);
        }


        /// <devdoc>
        /// Gets a value indicating whether the control is maintaining its view
        /// state, when the current page request ends by looking at its own EnableViewState
        /// value, and the value for all its parents.
        /// </devdoc>
        protected internal bool IsViewStateEnabled {
            get {
                Control current = this;
                while (current != null) {
                    if (current.EnableViewState == false) {
                        return false;
                    }
                    ViewStateMode mode = current.ViewStateMode;
                    if (mode != ViewStateMode.Inherit) {
                        return (mode == ViewStateMode.Enabled);
                    }
                    current = current.Parent;
                }
                return true;
            }
        }


        /// <devdoc>
        ///    <para>Gets the reference to the current control's naming container.</para>
        /// </devdoc>
        [
        Bindable(false),
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        WebSysDescription(SR.Control_NamingContainer)
        ]
        public virtual Control NamingContainer {
            get {
                if (_namingContainer == null) {
                    if (Parent != null) {
                        // Search for the closest naming container in the tree
                        if (Parent.flags[isNamingContainer])
                            _namingContainer = Parent;
                        else
                            _namingContainer = Parent.NamingContainer;
                    }
                }

                return _namingContainer;
            }
        }

        /// <internalonly/>
        /// <devdoc>
        ///    <para>Returns the databinding container of this control.  In most cases,
        ///     this is the same as the NamingContainer. But when using LoadTemplate(),
        ///     we get into a situation where that is not the case (ASURT 94138)</para>
        ///     The behavior is different than V1 that Usercontrol.BindingContainer is no
        ///     longer the UserControl but the control contains it. The behavior is consistent
        ///     with LoadTemplate() case.
        /// </devdoc>
        [
        Bindable(false),
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        EditorBrowsable(EditorBrowsableState.Never)
        ]
        public Control BindingContainer {
            get {
                Control bindingContainer = NamingContainer;
                while (bindingContainer is INonBindingContainer) {
                    bindingContainer = bindingContainer.BindingContainer;
                }

                return bindingContainer;
            }
        }

        [
        Bindable(false),
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        EditorBrowsable(EditorBrowsableState.Never)
        ]
        public Control DataItemContainer {
            get {
                Control dataItemContainer = NamingContainer;
                while (dataItemContainer != null && !(dataItemContainer is IDataItemContainer)) {
                    dataItemContainer = dataItemContainer.DataItemContainer;
                }

                return dataItemContainer;
            }
        }

        [
        Bindable(false),
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        EditorBrowsable(EditorBrowsableState.Never)
        ]
        public Control DataKeysContainer {
            get {
                Control dataKeysContainer = NamingContainer;
                while (dataKeysContainer != null && !(dataKeysContainer is IDataKeysControl)) {
                    dataKeysContainer = dataKeysContainer.DataKeysContainer;
                }

                return dataKeysContainer;
            }
        }



        /// <internalonly/>
        /// <devdoc>
        /// VSWhidbey 80467: Need to adapt id separator.
        /// </devdoc>
        protected char IdSeparator {
            get {
                if (Page != null) {
                    return Page.IdSeparator;
                }
                return IdSeparatorFromConfig;
            }
        }

        // VSWhidbey 475945: Use the old id separator if configured
        internal char IdSeparatorFromConfig {
            get {
                return ((EnableLegacyRendering) ? LEGACY_ID_SEPARATOR : ID_SEPARATOR);
            }
        }

        // VSWhidbey 244374: Allow controls to opt into loading view state by ID instead of index (perf hit)
        protected bool LoadViewStateByID {
            get {
                return ViewStateModeByIdAttribute.IsEnabled(GetType());
            }
        }

        /// <devdoc>
        /// <para> Gets the <see cref='System.Web.UI.Page'/> object that contains the
        ///    current control.</para>
        /// </devdoc>
        [
        Bindable(false),
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        WebSysDescription(SR.Control_Page)
        ]
        public virtual Page Page {
            get {
                if (_page == null) {
                    if (Parent != null) {
                        _page = Parent.Page;
                    }
                }
                return _page;
            }

            set {
                if (OwnerControl != null) {
                    throw new InvalidOperationException();
                }
                // This is necessary because we need to set the page in generated
                // code before controls are added to the tree (ASURT 75330)
                Debug.Assert(_page == null);
                Debug.Assert(Parent == null || Parent.Page == null);
                _page = value;
            }
        }

        internal RouteCollection RouteCollection {
            get {
                if (_occasionalFields == null ||
                    _occasionalFields.RareFields == null ||
                    _occasionalFields.RareFields.RouteCollection == null) {
                        return RouteTable.Routes;
                }
                return _occasionalFields.RareFields.RouteCollection;
            }
            set {
                if (value != null) {
                    RareFieldsEnsured.RouteCollection = value;
                }
                else {
                    if (_occasionalFields != null &&
                        _occasionalFields.RareFields != null &&
                        _occasionalFields.RareFields.RouteCollection != null) {
                            _occasionalFields.RareFields.RouteCollection = null;
                    }
                }
            }
        }

        // VSWhidbey 244999
        internal virtual bool IsReloadable {
            get {
                return false;
            }
        }

        // DevDiv 33149, 43258: A backward compat. switch for Everett rendering
        internal bool EnableLegacyRendering {
            get {
                Page page = Page;
                if (page != null) {
                    return (page.XhtmlConformanceMode == XhtmlConformanceMode.Legacy);
                }
                else if (DesignMode || Adapter != null) {
                    return false;
                }
                else {
                    return (GetXhtmlConformanceSection().Mode == XhtmlConformanceMode.Legacy);
                }
            }
        }

        internal XhtmlConformanceSection GetXhtmlConformanceSection() {
            HttpContext context = Context;
            XhtmlConformanceSection xhtmlConformanceSection;
            if (context != null) {
                // if context is available, use the most efficient way to get the section
                xhtmlConformanceSection = RuntimeConfig.GetConfig(context).XhtmlConformance;
            }
            else {
                xhtmlConformanceSection = RuntimeConfig.GetConfig().XhtmlConformance;
            }
            Debug.Assert(xhtmlConformanceSection != null);
            return xhtmlConformanceSection;
        }

        [
        Bindable(false),
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ]
        public virtual Version RenderingCompatibility {
            get {
                if (_occasionalFields == null ||
                    _occasionalFields.RareFields == null ||
                    _occasionalFields.RareFields.RenderingCompatibility == null) {
                        return RuntimeConfig.Pages.ControlRenderingCompatibilityVersion;
                }
                return _occasionalFields.RareFields.RenderingCompatibility;
            }
            set {
                if (value != null) {
                    RareFieldsEnsured.RenderingCompatibility = value;
                }
                else {
                    if (_occasionalFields != null &&
                        _occasionalFields.RareFields != null &&
                        _occasionalFields.RareFields.RenderingCompatibility != null) {
                            _occasionalFields.RareFields.RenderingCompatibility = null;
                    }
                }
            }
        }

        private RuntimeConfig RuntimeConfig {
            get {
                HttpContext context = Context;
                if (context != null) {
                    // if context is available, use the most efficient way to get the config
                    return RuntimeConfig.GetConfig(context);
                } else {
                    return RuntimeConfig.GetConfig();
                }
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings",
            Justification = "Consistent with other URL properties in ASP.NET.")]
        public string GetRouteUrl(object routeParameters) {
            return GetRouteUrl(new RouteValueDictionary(routeParameters));
        }

        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings",
            Justification = "Consistent with other URL properties in ASP.NET.")]
        public string GetRouteUrl(string routeName, object routeParameters) {
            return GetRouteUrl(routeName, new RouteValueDictionary(routeParameters));
        }

        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings",
            Justification = "Consistent with other URL properties in ASP.NET.")]
        public string GetRouteUrl(RouteValueDictionary routeParameters) {
            return GetRouteUrl(null, routeParameters);
        }

        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings",
            Justification = "Consistent with other URL properties in ASP.NET.")]
        public string GetRouteUrl(string routeName, RouteValueDictionary routeParameters) {
            VirtualPathData data = RouteCollection.GetVirtualPath(Context.Request.RequestContext, routeName, routeParameters);
            if (data != null) {
                return data.VirtualPath;
            }
            return null;
        }

        /// <devdoc>
        ///    <para>Gets the reference to the <see cref='System.Web.UI.TemplateControl'/>
        ///    that hosts the control.</para>
        /// </devdoc>
        internal virtual TemplateControl GetTemplateControl() {
            if (_occasionalFields == null || _occasionalFields.TemplateControl == null) {
                if (Parent != null) {
                    TemplateControl templateControl = Parent.GetTemplateControl();
                    if (templateControl != null) {
                        EnsureOccasionalFields();
                        _occasionalFields.TemplateControl = templateControl;
                    }
                }
            }
            return (_occasionalFields != null) ? _occasionalFields.TemplateControl : null;
        }


        /// <devdoc>
        ///    <para>Gets the reference to the <see cref='System.Web.UI.TemplateControl'/>
        ///    that hosts the control.</para>
        /// </devdoc>
        [
        Bindable(false),
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        WebSysDescription(SR.Control_TemplateControl)
        ]
        public TemplateControl TemplateControl {
            get {
                return GetTemplateControl();
            }

            [EditorBrowsable(EditorBrowsableState.Never)]
            set {
                // This setter is necessary so that controls inside templates are based on
                // hosting pages not where the templates are used.
                if (value != null) {
                    EnsureOccasionalFields();
                    _occasionalFields.TemplateControl = value;
                }
                else {
                    if (_occasionalFields != null &&
                        _occasionalFields.TemplateControl != null) {
                            _occasionalFields.TemplateControl = null;
                    }
                }
            }
        }

        /*
         * Determine whether this control is a descendent of the passed in control
         */
        internal bool IsDescendentOf(Control ancestor) {
            Control current = this;
            while (current != ancestor && current.Parent != null) {
                current = current.Parent;
            }
            return (current == ancestor);
        }


        /// <devdoc>
        ///    <para> Gets the current control's parent control in the UI hierarchy.</para>
        /// </devdoc>
        [
        Bindable(false),
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        WebSysDescription(SR.Control_Parent)
        ]
        public virtual Control Parent {
            get {
                return _parent;
            }
        }

        internal bool IsParentedToUpdatePanel {
            get {
                Control parent = Parent;
                while (parent != null) {
                    if (parent is IUpdatePanel) {
                        return true;
                    }
                    parent = parent.Parent;
                }
                return false;
            }
        }

        /// <devdoc>
        ///    <para> Gets the virtual directory of the Page or UserControl that contains this control.</para>
        /// </devdoc>
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        WebSysDescription(SR.Control_TemplateSourceDirectory)
        ]
        public virtual string TemplateSourceDirectory {
            get {
                if (TemplateControlVirtualDirectory == null)
                    return String.Empty;

                return TemplateControlVirtualDirectory.VirtualPathStringNoTrailingSlash;
            }
        }


        /// <devdoc>
        ///    <para> Gets the virtual directory of the Page or UserControl that contains this control.
        ///         Unlike TemplateSourceDirectory, this returns an app relative path (e.g. "~/sub")</para>
        /// </devdoc>
        [
        Browsable(false),
        EditorBrowsable(EditorBrowsableState.Advanced),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        WebSysDescription(SR.Control_TemplateSourceDirectory)
        ]
        public string AppRelativeTemplateSourceDirectory {
            get {
                return VirtualPath.GetAppRelativeVirtualPathStringOrEmpty(TemplateControlVirtualDirectory);
            }

            [EditorBrowsable(EditorBrowsableState.Never)]
            set {
                // This setter is necessary so that skins are based on hosting skin file.
                this.TemplateControlVirtualDirectory = VirtualPath.CreateNonRelativeAllowNull(value);
            }
        }

        internal VirtualPath TemplateControlVirtualDirectory {
            get {
                if (_occasionalFields != null && _occasionalFields.TemplateSourceVirtualDirectory != null)
                    return _occasionalFields.TemplateSourceVirtualDirectory;

                TemplateControl control = TemplateControl;
                if (control == null) {
                    HttpContext context = Context;
                    if (context != null) {
                        VirtualPath templateSourceVirtualDirectory = context.Request.CurrentExecutionFilePathObject.Parent;
                        if (templateSourceVirtualDirectory != null) {
                            EnsureOccasionalFields();
                            _occasionalFields.TemplateSourceVirtualDirectory = templateSourceVirtualDirectory;
                        }
                    }
                    return (_occasionalFields != null) ? _occasionalFields.TemplateSourceVirtualDirectory : null;
                }
                // Prevent recursion if this is the TemplateControl
                if (control != this) {
                    VirtualPath templateSourceVirtualDirectory = control.TemplateControlVirtualDirectory;
                    if (templateSourceVirtualDirectory != null) {
                        EnsureOccasionalFields();
                        _occasionalFields.TemplateSourceVirtualDirectory = templateSourceVirtualDirectory;
                    }
                }
                return (_occasionalFields != null) ? _occasionalFields.TemplateSourceVirtualDirectory : null;
            }

            set {
                // This setter is necessary so that skins are based on hosting skin file.
                if (value != null) {
                    EnsureOccasionalFields();
                    _occasionalFields.TemplateSourceVirtualDirectory = value;
                }
                else {
                    if (_occasionalFields != null &&
                        _occasionalFields.TemplateSourceVirtualDirectory != null) {
                            _occasionalFields.TemplateSourceVirtualDirectory = null;
                    }
                }
            }
        }

        internal ControlState ControlState {
            get { return _controlState; }
            set { _controlState = value; }
        }


        /// <devdoc>
        ///    <para>Indicates the site information for the control.</para>
        /// </devdoc>
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        EditorBrowsable(EditorBrowsableState.Advanced),
        WebSysDescription(SR.Control_Site)
        ]
        public ISite Site {
            get {
                if (OwnerControl != null) {
                    return OwnerControl.Site;
                }

                if (RareFields != null) {
                    return RareFields.Site;
                }
                return null;
            }
            set {
                if (OwnerControl != null) {
                    throw new InvalidOperationException(SR.GetString(SR.Substitution_SiteNotAllowed));
                }

                RareFieldsEnsured.Site = value;
                flags.Clear(designModeChecked);
            }
        }


        /// <devdoc>
        ///    <para>
        ///       Gets or sets a value that indicates whether a control should be rendered on
        ///       the page.
        ///    </para>
        /// </devdoc>
        [
        Bindable(true),
        DefaultValue(true),
        WebCategory("Behavior"),
        WebSysDescription(SR.Control_Visible)
        ]
        public virtual bool Visible {
            get {
                if (flags[invisible])
                    return false;
                else if ((_parent != null) && !DesignMode)
                    return _parent.Visible;
                else
                    return true;
            }
            set {
                if (flags[marked]) {
                    bool visible = !flags[invisible];
                    if (visible != value) {
                        flags.Set(visibleDirty);
                    }
                }

                if(!value) {
                    flags.Set(invisible);
                }
                else {
                    flags.Clear(invisible);
                }
            }
        }


        /// <devdoc>
        /// Do not remove or change the signature. It is called via reflection.
        /// This allows for correct serialization, since Visible is implemented as a
        /// recursive property.
        /// </devdoc>
        private void ResetVisible() {
            Visible = true;
        }


        /// <devdoc>
        /// Do not remove or change the signature. It is called via reflection.
        /// This allows for correct serialization, since Visible is implemented as a
        /// recursive property.
        /// </devdoc>
        private bool ShouldSerializeVisible() {
            return flags[invisible];
        }


        /// <devdoc>
        ///    <para> Gets the unique, hierarchically-qualified identifier for
        ///       a control. This is different from the ID property, in that the fully-qualified
        ///       identifier includes the identifier for the control's naming container.</para>
        /// </devdoc>
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        WebSysDescription(SR.Control_UniqueID)
        ]
        public virtual string UniqueID {
            get {
                if (_cachedUniqueID != null) {
                    return _cachedUniqueID;
                }

                Control namingContainer = NamingContainer;
                if (namingContainer != null) {
                    // if the ID is null at this point, we need to have one created and the control added to the
                    // naming container.
                    if (_id == null) {
                        GenerateAutomaticID();
                    }

                    if (Page == namingContainer) {
                        _cachedUniqueID = _id;
                    }
                    else {
                        string uniqueIDPrefix = namingContainer.GetUniqueIDPrefix();
                        if (uniqueIDPrefix.Length == 0) {
                            // In this case, it is probably a naming container that is not sited, so we don't want to cache it
                            return _id;
                        }
                        else {
                            _cachedUniqueID = uniqueIDPrefix + _id;
                        }
                    }

                    return _cachedUniqueID;
                }
                else {
                    // no naming container
                    return _id;
                }
            }
        }

        [SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "ID", Justification="This is consistent with UniqueID")]
        [SuppressMessage("Microsoft.Naming", "CA1706:ShortAcronymsShouldBeUppercase", MessageId = "Member", Justification="This is consistent with UniqueID")]
        public string GetUniqueIDRelativeTo(Control control) {
            if (control == null) {
                throw new ArgumentNullException("control");
            }

            if (!IsDescendentOf(control.NamingContainer)) {
                throw new InvalidOperationException(SR.GetString(SR.Control_NotADescendentOfNamingContainer, control.ID));
            }

            if (control.NamingContainer == Page) {
                return UniqueID;
            } else {
                return UniqueID.Substring(control.NamingContainer.UniqueID.Length + 1); // add 1 for the ID seperator (which is a char)
            }
        }

        /// <devdoc>
        ///    <para>Occurs when the control binds to a data source. Notifies the control to perform any data binding during this event.</para>
        /// </devdoc>
        [
        WebCategory("Data"),
        WebSysDescription(SR.Control_OnDataBind)
        ]
        public event EventHandler DataBinding {
            add {
                Events.AddHandler(EventDataBinding, value);
            }
            remove {
                Events.RemoveHandler(EventDataBinding, value);
            }
        }


        /// <devdoc>
        ///    <para>Occurs when the control is initialized, the first step in the page lifecycle. Controls should
        ///       perform any initialization steps that are required to create and set up an
        ///       instantiation.</para>
        /// </devdoc>
        [
        WebSysDescription(SR.Control_OnInit)
        ]
        public event EventHandler Init {
            add {
                Events.AddHandler(EventInit, value);
            }
            remove {
                Events.RemoveHandler(EventInit, value);
            }
        }


        /// <devdoc>
        /// <para>Occurs when the control is loaded to the <see cref='System.Web.UI.Page'/> object. Notifies the control to perform any steps that
        ///    need to occur on each page request.</para>
        /// </devdoc>
        [
        WebSysDescription(SR.Control_OnLoad)
        ]
        public event EventHandler Load {
            add {
                Events.AddHandler(EventLoad, value);
            }
            remove {
                Events.RemoveHandler(EventLoad, value);
            }
        }


        /// <devdoc>
        ///    <para>Occurs when the control is about to render. Controls
        ///       should perform any pre-rendering steps necessary before saving view state and
        ///       rendering content to the <see cref='System.Web.UI.Page'/> object.</para>
        /// </devdoc>
        [
        WebSysDescription(SR.Control_OnPreRender)
        ]
        public event EventHandler PreRender {
            add {
                Events.AddHandler(EventPreRender, value);
            }
            remove {
                Events.RemoveHandler(EventPreRender, value);
            }
        }


        /// <devdoc>
        ///    <para>Occurs when the control is unloaded from memory. Controls should perform any
        ///       final cleanup before this instance of it is </para>
        /// </devdoc>
        [
        WebSysDescription(SR.Control_OnUnload)
        ]
        public event EventHandler Unload {
            add {
                Events.AddHandler(EventUnload, value);
            }
            remove {
                Events.RemoveHandler(EventUnload, value);
            }
        }

        /// <devdoc>
        /// <para>Apply stylesheet skin on the control.</para>
        /// </devdoc>
        [
        EditorBrowsable(EditorBrowsableState.Advanced),
        ]
        public virtual void ApplyStyleSheetSkin(Page page) {
            // Nothing to do if the control is not in a Page.
            if (page == null) {
                return;
            }

            // Only apply stylesheet if not already applied.
            if (flags[styleSheetApplied]) {
                throw new InvalidOperationException(SR.GetString(SR.StyleSheetAreadyAppliedOnControl));
            }

            if (page.ApplyControlStyleSheet(this)) {
                flags.Set(styleSheetApplied);
            }
        }

        /// <devdoc>
        /// <para>Apply theme on the control.</para>
        /// </devdoc>
        private void ApplySkin(Page page) {
            if (page == null) {
                throw new ArgumentNullException("page");
            }

            if (flags[themeApplied]) {
                return;
            }

            if (ThemeableAttribute.IsTypeThemeable(this.GetType())) {
                page.ApplyControlSkin(this);
                flags.Set(themeApplied);
            }
        }


        /// <devdoc>
        /// <para>Raises the <see langword='DataBinding'/> event. This
        ///    notifies a control to perform any data binding logic that is associated with it.</para>
        /// </devdoc>
        protected virtual void OnDataBinding(EventArgs e) {
            if(HasEvents()) {
                EventHandler handler = _events[EventDataBinding] as EventHandler;
                if(handler != null) {
                    handler(this, e);
                }
            }
        }


        /// <devdoc>
        ///    <para> Causes data binding to occur on the invoked control and all of its child
        ///       controls.</para>
        /// </devdoc>
        public virtual void DataBind() {
            DataBind(true);
        }

        /// <devdoc>
        ///    <para> Causes the invoked controls' context to be pushed on the stack,
        ///       then conditionally call OnDataBinging on the invoked control, and databind all of its child
        ///       controls.  A control would call this with false if it overrides DataBind without calling
        ///       Control.DataBind, but still wants to be an IDataItemContainer.  FormView and DetailsView
        ///       are good examples of this.</para>
        /// </devdoc>
        protected virtual void DataBind(bool raiseOnDataBinding) {
            bool inDataBind = false;

            if (IsBindingContainer) {
                bool foundDataItem;

                object dataItem = DataBinder.GetDataItem(this, out foundDataItem);

                if (foundDataItem && (Page != null)) {
                    Page.PushDataBindingContext(dataItem);
                    inDataBind = true;
                }
            }
            try {
                if (raiseOnDataBinding) {
                    // Do our own databinding
                    OnDataBinding(EventArgs.Empty);
                }

                // Do all of our children's databinding
                DataBindChildren();
            }
            finally {
                if (inDataBind) {
                    Page.PopDataBindingContext();
                }
            }
        }


        /// <devdoc>
        /// <para> Causes data binding to occur on all of the child controls.</para>
        /// </devdoc>
        protected virtual void DataBindChildren() {
            if (HasControls()) {
                string oldmsg = _controls.SetCollectionReadOnly(SR.Parent_collections_readonly);

                try {
                    try {
                        int controlCount = _controls.Count;
                        for (int i=0; i < controlCount; i++)
                            _controls[i].DataBind();
                    }
                    finally {
                        _controls.SetCollectionReadOnly(oldmsg);
                    }
                }
                catch {
                    throw;
                }
            }
        }

        internal void PreventAutoID() {
            // controls that are also naming containers must always get an id
            if (flags[isNamingContainer] == false) {
                flags.Set(idNotRequired);
            }
        }


        /// <devdoc>
        ///    <para>Notifies the control that an element, XML or HTML, was parsed, and adds it to
        ///       the control.</para>
        /// </devdoc>
        protected virtual void AddParsedSubObject(object obj) {
            Control control = obj as Control;
            if (control != null) {
                Controls.Add(control);
            }
        }

        private void UpdateNamingContainer(Control namingContainer) {
            // Remove the cached uniqueID if the control already had a namingcontainer
            // and the namingcontainer is changed.
            if (_namingContainer == null || (_namingContainer != null && _namingContainer != namingContainer)) {
                ClearCachedUniqueIDRecursive();
            }

            // No need to clear the cache if never been initialized
            if (EffectiveClientIDModeValue != ClientIDMode.Inherit) {
                ClearCachedClientID();
                ClearEffectiveClientIDMode();
            }

            _namingContainer = namingContainer;
        }

        private void ClearCachedUniqueIDRecursive() {
            _cachedUniqueID = null;

            if (_occasionalFields != null) {
                _occasionalFields.UniqueIDPrefix = null;
            }

            if (_controls != null) {
                int controlCount = _controls.Count;
                for (int i = 0; i < controlCount; i++) {
                    _controls[i].ClearCachedUniqueIDRecursive();
                }
            }
        }

        protected void EnsureID() {
            if (_namingContainer != null) {
                if (_id == null) {
                    GenerateAutomaticID();
                }
                flags.Set(mustRenderID);
            }
        }

        private void GenerateAutomaticID() {
            Debug.Assert(_namingContainer != null);
            Debug.Assert(_id == null);

            // Remember that a generated ID is used for this control.
            flags.Set(useGeneratedID);

            // Calculate the automatic ID. For performance and memory reasons
            // we look up a static table entry if possible
            _namingContainer.EnsureOccasionalFields();
            int idNo = _namingContainer._occasionalFields.NamedControlsID++;
            if (EnableLegacyRendering) {
                // VSWhidbey 517118
                _id = automaticLegacyIDPrefix + idNo.ToString(NumberFormatInfo.InvariantInfo);
            }
            else {
                if (idNo < automaticIDCount) {
                    _id = automaticIDs[idNo];
                }
                else {
                    _id = automaticIDPrefix + idNo.ToString(NumberFormatInfo.InvariantInfo);
                }
            }

            _namingContainer.DirtyNameTable();
        }

        internal virtual string GetUniqueIDPrefix() {
            EnsureOccasionalFields();

            if (_occasionalFields.UniqueIDPrefix == null) {
                string uniqueID = UniqueID;
                if (!String.IsNullOrEmpty(uniqueID)) {
                    _occasionalFields.UniqueIDPrefix = uniqueID + IdSeparator;
                }
                else {
                    _occasionalFields.UniqueIDPrefix = String.Empty;
                }
            }

            return _occasionalFields.UniqueIDPrefix;
        }

        /// <devdoc>
        /// <para>Raises the <see langword='Init'/> event. This notifies the control to perform
        ///    any steps necessary for its creation on a page request.</para>
        /// </devdoc>
        protected internal virtual void OnInit(EventArgs e) {
            if(HasEvents()) {
                EventHandler handler = _events[EventInit] as EventHandler;
                if(handler != null) {
                    handler(this, e);
                }
            }
        }

        // !! IMPORTANT !!
        // If you make changes to this method, also change InitRecursiveAsync.
        internal virtual void InitRecursive(Control namingContainer) {
            ResolveAdapter();
            if (_controls != null) {
                if (flags[isNamingContainer]) {
                    namingContainer = this;
                }
                string oldmsg = _controls.SetCollectionReadOnly(SR.Parent_collections_readonly);

                int controlCount = _controls.Count;
                for (int i = 0; i < controlCount; i++) {
                    Control control = _controls[i];

                    // Propagate the page and namingContainer
                    control.UpdateNamingContainer(namingContainer);

                    if ((control._id == null) && (namingContainer != null) && !control.flags[idNotRequired]) {
                        control.GenerateAutomaticID();
                    }
                    control._page = Page;

                    control.InitRecursive(namingContainer);
                }
                _controls.SetCollectionReadOnly(oldmsg);

            }

            // Only make the actual call if it hasn't already happened (ASURT 111303)
            if (_controlState < ControlState.Initialized) {
                _controlState = ControlState.ChildrenInitialized; // framework also initialized

                if ((Page != null) && !DesignMode) {
                    if (Page.ContainsTheme && EnableTheming) {
                        ApplySkin(Page);
                    }
                }

                if (AdapterInternal != null) {
                    AdapterInternal.OnInit(EventArgs.Empty);
                }
                else {
                    OnInit(EventArgs.Empty);
                }

                _controlState = ControlState.Initialized;
            }

            // track all subsequent state changes
            TrackViewState();

#if DEBUG
            ControlInvariant();
#endif
        }

        // TAP version of InitRecursive
        // !! IMPORTANT !!
        // If you make changes to this method, also change InitRecursive.
        internal async Task InitRecursiveAsync(Control namingContainer, Page page) {
            ResolveAdapter();
            if (_controls != null) {
                if (flags[isNamingContainer]) {
                    namingContainer = this;
                }
                string oldmsg = _controls.SetCollectionReadOnly(SR.Parent_collections_readonly);

                int controlCount = _controls.Count;
                for (int i = 0; i < controlCount; i++) {
                    Control control = _controls[i];

                    // Propagate the page and namingContainer
                    control.UpdateNamingContainer(namingContainer);

                    if ((control._id == null) && (namingContainer != null) && !control.flags[idNotRequired]) {
                        control.GenerateAutomaticID();
                    }
                    control._page = Page;

                    control.InitRecursive(namingContainer);
                }
                _controls.SetCollectionReadOnly(oldmsg);

            }

            // Only make the actual call if it hasn't already happened (ASURT 111303)
            if (_controlState < ControlState.Initialized) {
                _controlState = ControlState.ChildrenInitialized; // framework also initialized

                if ((Page != null) && !DesignMode) {
                    if (Page.ContainsTheme && EnableTheming) {
                        ApplySkin(Page);
                    }
                }

                using (page.Context.SyncContext.AllowVoidAsyncOperationsBlock()) {
                    if (AdapterInternal != null) {
                        AdapterInternal.OnInit(EventArgs.Empty);
                    }
                    else {
                        OnInit(EventArgs.Empty);
                    }
                    await page.GetWaitForPreviousStepCompletionAwaitable();
                }

                _controlState = ControlState.Initialized;
            }

            // track all subsequent state changes
            TrackViewState();

#if DEBUG
            ControlInvariant();
#endif
        }

#if DEBUG

        /// <devdoc>
        ///    <para>This should be used to assert internal state about the control</para>
        /// </devdoc>
        internal void ControlInvariant() {

            // If the control is initialized, the naming container and page should have been pushed in
            if (_controlState >= ControlState.Initialized) {
                if (DesignMode) {
                    // Top-level UserControls do not have a page or a naming container in the designer
                    // hence the special casing.

                    Debug.Assert((_namingContainer != null) || (this is Page) || (this is UserControl));

                    //



                }
                else {
                    if (!(this is Page)) {
                        Debug.Assert(_namingContainer != null);
                    }
                    Debug.Assert(Page != null);
                }
            }
            // If naming container is set and the name table exists, the ID should exist in it.

            if(_namingContainer != null &&
               _namingContainer._occasionalFields != null &&
               _namingContainer._occasionalFields.NamedControls != null &&
               _id != null) {
                Debug.Assert(_namingContainer._occasionalFields.NamedControls.Contains(_id));
            }
        }

        // Collect some statistic about the number of controls with occasional and
        // rare fields.
        internal void GetRareFieldStatistics(ref int totalControls,
            ref int withOccasionalFields, ref int withRareFields) {
            totalControls++;
            if (_occasionalFields != null) {
                withOccasionalFields++;
                if (_occasionalFields.RareFields != null)
                    withRareFields++;

                // No children: we're done
                if (_controls == null)
                    return;

                int controlCount = _controls.Count;
                for (int i = 0; i < controlCount; i++) {
                    Control control = _controls[i];

                    control.GetRareFieldStatistics(ref totalControls, ref withOccasionalFields,
                        ref withRareFields);
                }
            }
        }
#endif

        protected void ClearChildState() {
            ClearChildControlState();
            ClearChildViewState();
        }

        protected void ClearChildControlState() {
            //VSWhidbey 242621 to be consistent with ClearChildViewState, ignore calls before and during Init
            if (ControlState < ControlState.Initialized) {
                return;
            }
            flags.Set(disableChildControlState);
            if (Page != null) {
                Page.RegisterRequiresClearChildControlState(this);
            }
        }


        /// <devdoc>
        ///    <para>Deletes the view state information for all of the current control's child
        ///       controls.</para>
        /// </devdoc>
        protected void ClearChildViewState() {
            if(_occasionalFields != null) {
                _occasionalFields.ControlsViewState = null;
            }
        }

        [SuppressMessage("Microsoft.Naming", "CA1706:ShortAcronymsShouldBeUppercase", MessageId="Member")]
        protected void ClearEffectiveClientIDMode() {
            EffectiveClientIDModeValue = ClientIDMode.Inherit;
            if (HasControls()) {
                foreach (Control control in Controls) {
                    control.ClearEffectiveClientIDMode();
                }
            }
        }

        [SuppressMessage("Microsoft.Naming", "CA1706:ShortAcronymsShouldBeUppercase", MessageId="Member")]
        protected void ClearCachedClientID() {
            _cachedPredictableID = null;
            if (HasControls()) {
                foreach (Control control in Controls) {
                    control.ClearCachedClientID();
                }
            }
        }

        /// <devdoc>
        ///    <para>Indicates whether the current control's children have any saved view state
        ///       information. This property is read-only.</para>
        /// </devdoc>
        protected bool HasChildViewState {
            get {
                return ((_occasionalFields != null) &&
                        (_occasionalFields.ControlsViewState != null) &&
                        (_occasionalFields.ControlsViewState.Count > 0));
            }
        }


        /// <devdoc>
        /// Sets initial focus on the control
        /// </devdoc>
        public virtual void Focus() {
            Page.SetFocus(this);
        }

        internal void LoadControlStateInternal(object savedStateObj) {
            // Do not load the control state if it has been applied.
            if (flags[controlStateApplied]) {
                return;
            }

            flags.Set(controlStateApplied);

            Pair savedState = (Pair)savedStateObj;
            if (savedState == null) {
                return;
            }
            Page page = Page;
            if (page != null && !page.ShouldLoadControlState(this)) {
                return;
            }
            // VSWhidbey160650: Only call LoadControlState with non null savedState
            if (savedState.First != null) {
                LoadControlState(savedState.First);
            }
            // VSWhidbey356804: Only call LoadAdapterControlState with non null savedState
            if (AdapterInternal == null || savedState.Second == null) {
                return;
            }
            AdapterInternal.LoadAdapterControlState(savedState.Second);
        }


        /// <devdoc>
        /// Load the control state, which is the essential state information needed even if view state is disabled.
        /// </devdoc>
        protected internal virtual void LoadControlState(object savedState) {
        }


        /// <devdoc>
        ///    <para>Restores the view state information from a previous page
        ///       request that was saved by the Control.SavedState method.</para>
        /// </devdoc>
        protected virtual void LoadViewState(object savedState) {
            if (savedState != null) {
                ViewState.LoadViewState(savedState);

                // Load values cached out of view state
                object visible = ViewState["Visible"];
                if (visible != null) {
                    if(!(bool)visible) {
                        flags.Set(invisible);
                    }
                    else {
                        flags.Clear(invisible);
                    }
                    flags.Set(visibleDirty);
                }

                object validateRequestModeValue = ViewState["ValidateRequestMode"];
                if (validateRequestModeValue != null) {
                    flags[validateRequestMode, validateRequestModeOffset] = (int)validateRequestModeValue;
                    flags.Set(validateRequestModeDirty);
                }
            }
        }

        internal void LoadViewStateRecursive(object savedState) {
            // nothing to do if we have no state
            if (savedState == null || flags[disableViewState])
                return;

            if (Page != null && Page.IsPostBack) {
                object controlState = null;
                object adapterState = null;
                ArrayList childState = null;

                Pair allSavedState = savedState as Pair;
                if (allSavedState != null) {
                    controlState = allSavedState.First;
                    childState = (ArrayList)allSavedState.Second;
                }
                else {
                    Debug.Assert(savedState is Triplet);
                    Triplet t = (Triplet)savedState;

                    controlState = t.First;
                    adapterState = t.Second;
                    childState = (ArrayList)t.Third;
                }

                try {
                    if ((adapterState != null) && (AdapterInternal != null)) {
                        AdapterInternal.LoadAdapterViewState(adapterState);
                    }

                    if (controlState != null) {
                        LoadViewState(controlState);
                    }

                    if (childState != null) {
                        if (LoadViewStateByID) {
                            LoadChildViewStateByID(childState);
                        }
                        else {
                            LoadChildViewStateByIndex(childState);
                        }
                    }
                }
                catch (InvalidCastException) {
                    // catch all viewstate loading problems with casts.  They are most likely changed control trees.
                    throw new HttpException(SR.GetString(SR.Controls_Cant_Change_Between_Posts));
                }
                catch (IndexOutOfRangeException) {
                    // catch all viewstate loading problems with indeces.  They are most likely changed control trees.
                    throw new HttpException(SR.GetString(SR.Controls_Cant_Change_Between_Posts));
                }
            }

            _controlState = ControlState.ViewStateLoaded;
        }

        internal void LoadChildViewStateByID(ArrayList childState) {
            int childStateCount = childState.Count;
            for (int i = 0; i < childStateCount; i += 2) {
                // first element is index or ID of control with state and the
                // next element is state of the control
                string controlId = (string)childState[i];
                object state = childState[i + 1];

                Control childControl = FindControl(controlId);
                if (childControl != null) {
                    childControl.LoadViewStateRecursive(state);
                }
                else {
                    // couldn't find a control for this state blob, save it for later
                    EnsureOccasionalFields();
                    if (_occasionalFields.ControlsViewState == null) {
                        _occasionalFields.ControlsViewState = new Hashtable();
                    }
                    _occasionalFields.ControlsViewState[controlId] = state;
                }
            }
        }

        internal void LoadChildViewStateByIndex(ArrayList childState) {
            ControlCollection ctrlColl = Controls;
            int ctrlCount = ctrlColl.Count;

            int childStateCount = childState.Count;
            for (int i = 0; i < childStateCount; i += 2) {
                // first element is index of control with state and the
                // next element is state of the control
                int controlIndex = (int)childState[i];
                object state = childState[i + 1];

                if (controlIndex < ctrlCount) {
                    // we have a control for this state blob
                    ctrlColl[controlIndex].LoadViewStateRecursive(state);
                }
                else {
                    // couldn't find a control for this state blob, save it for later
                    EnsureOccasionalFields();
                    if (_occasionalFields.ControlsViewState == null) {
                        _occasionalFields.ControlsViewState = new Hashtable();
                    }
                    _occasionalFields.ControlsViewState[controlIndex] = state;
                }
            }
        }

        ///
        /// Figure out if a path is physical or virtual.  This is useful because a number of our controls
        /// accept either type of path for the same attribute.
        ///
        internal void ResolvePhysicalOrVirtualPath(string path, out VirtualPath virtualPath, out string physicalPath) {
            if (System.Web.Util.UrlPath.IsAbsolutePhysicalPath(path)) {
                physicalPath = path;
                virtualPath = null;
            }
            else {
                physicalPath = null;

                // It could be relative, so resolve it
                virtualPath = TemplateControlVirtualDirectory.Combine(VirtualPath.Create(path));
            }
        }


        /// <devdoc>
        /// <para>
        ///   This function takes a virtual path, that is a relative or root relative URL without a protocol.
        ///   It returns the mapped physcial file name relative to the template source. It throws an exception if
        ///   there is insufficient security access to read or investigate the mapped result. This should be used
        ///   by controls that can read files and live in fully trusted DLLs such as System.Web.dll to prevent
        ///   security issues. The exception thrown does not give away information about the mapping.  For absolute
        ///   physical paths, this function checks permission
        /// </para>
        /// </devdoc>
        protected internal string MapPathSecure(string virtualPath) {
            if (String.IsNullOrEmpty(virtualPath)) {
                throw new ArgumentNullException("virtualPath", SR.GetString(SR.VirtualPath_Length_Zero));
            }

            string physicalPath;
            VirtualPath virtualPathObject;
            ResolvePhysicalOrVirtualPath(virtualPath, out virtualPathObject, out physicalPath);
            if (physicalPath == null) {
                physicalPath = virtualPathObject.MapPathInternal(TemplateControlVirtualDirectory,
                    true /*allowCrossAppMapping*/);
            }

            // Security check
            HttpRuntime.CheckFilePermission(physicalPath);

            return physicalPath;
        }


        /// <devdoc>
        /// <para>
        ///   This function takes a virtual path, that is a relative or root relative URL without a protocol.
        ///   It can also take a physical path, either local (c:\) or UNC.
        ///   It returns a stream used to read to contents of the file. It throws an exception if
        ///   there is insufficient security access to read or investigate the mapped result. This should be used
        ///   by controls that can read files and live in fully trusted DLLs such as System.Web.dll to prevent
        ///   security issues. The exception thrown does not give away information about the mapping.  For absolute
        ///   physical paths, this function checks permission
        /// </para>
        /// </devdoc>
        protected internal Stream OpenFile(string path) {

            string physicalPath = null;
            VirtualFile vfile = null;

            // Need to Trim it since MapPath no longer allows trailing space (VSWhidbey 441210)
            path = path.Trim();

            if (UrlPath.IsAbsolutePhysicalPath(path)) {
                // Absolute physical path
                physicalPath = path;
            }
            else {
                vfile = HostingEnvironment.VirtualPathProvider.GetFile(path);
                MapPathBasedVirtualFile mapPathVFile = vfile as MapPathBasedVirtualFile;
                if (mapPathVFile != null) {
                    physicalPath = mapPathVFile.PhysicalPath;
                }
            }

            // If we got a physical path, make sure the user has access to it
            if (physicalPath != null) {
                HttpRuntime.CheckFilePermission(physicalPath);
            }

            if (vfile != null) {
                return vfile.Open();
            }
            else {
                return new FileStream(physicalPath, FileMode.Open, FileAccess.Read, FileShare.Read);
            }
        }

        ///
        /// Open a stream from either a virtual or physical path, and if possible get a CacheDependency
        /// for the resulting Stream.
        ///
        internal Stream OpenFileAndGetDependency(VirtualPath virtualPath, string physicalPath, out CacheDependency dependency) {

            // Only one of the paths should be non-null
            Debug.Assert((virtualPath == null) != (physicalPath == null));

            // If we got a virtual path, and we're using the default VPP, call MapPath
            if (physicalPath == null && HostingEnvironment.UsingMapPathBasedVirtualPathProvider) {
                physicalPath = virtualPath.MapPathInternal(TemplateControlVirtualDirectory,
                    true /*allowCrossAppMapping*/);
            }

            Stream stream;
            if (physicalPath != null) {
                // Security check
                HttpRuntime.CheckFilePermission(physicalPath);

                // Work directly with the physical file, bypassing the VPP
                stream = new FileStream(physicalPath, FileMode.Open, FileAccess.Read, FileShare.Read);
                dependency = new CacheDependency(0, physicalPath);
            }
            else {
                // It's non file system based, so go though the VirtualPathProvider
                stream = virtualPath.OpenFile();
                dependency = VirtualPathProvider.GetCacheDependency(virtualPath);
            }

            return stream;
        }


        /// <devdoc>
        /// <para>Raises the <see langword='Load'/>
        /// event. This notifies the control that it should perform any work that needs to
        /// occur for each page request.</para>
        /// </devdoc>
        protected internal virtual void OnLoad(EventArgs e) {
            if(HasEvents()) {
                EventHandler handler = _events[EventLoad] as EventHandler;
                if(handler != null) {
                    handler(this, e);
                }
            }
        }

        internal virtual void LoadRecursive() {
            // Only make the actual call if it hasn't already happened (ASURT 111303)
            if (_controlState < ControlState.Loaded) {
                if (AdapterInternal != null) {
                    AdapterInternal.OnLoad(EventArgs.Empty);
                }
                else {
                    OnLoad(EventArgs.Empty);
                }
            }

            // Call Load on all our children
            if (_controls != null) {
                string oldmsg = _controls.SetCollectionReadOnly(SR.Parent_collections_readonly);

                int controlCount = _controls.Count;
                for (int i = 0; i < controlCount; i++) {
                    _controls[i].LoadRecursive();
                }

                _controls.SetCollectionReadOnly(oldmsg);
            }

            if (_controlState < ControlState.Loaded)
                _controlState = ControlState.Loaded;
        }

        // Same as LoadRecursive, but has an async point immediately after the call to this.OnLoad.
        internal async Task LoadRecursiveAsync(Page page) {
            // Only make the actual call if it hasn't already happened (ASURT 111303)
            if (_controlState < ControlState.Loaded) {
                using (page.Context.SyncContext.AllowVoidAsyncOperationsBlock()) {
                    if (AdapterInternal != null) {
                        AdapterInternal.OnLoad(EventArgs.Empty);
                    }
                    else {
                        OnLoad(EventArgs.Empty);
                    }
                    await page.GetWaitForPreviousStepCompletionAwaitable();
                }
            }

            // Call Load on all our children
            if (_controls != null) {
                string oldmsg = _controls.SetCollectionReadOnly(SR.Parent_collections_readonly);

                int controlCount = _controls.Count;
                for (int i = 0; i < controlCount; i++) {
                    _controls[i].LoadRecursive();
                }

                _controls.SetCollectionReadOnly(oldmsg);
            }

            if (_controlState < ControlState.Loaded)
                _controlState = ControlState.Loaded;
        }

        /// <devdoc>
        /// <para>Raises the <see langword='PreRender'/> event. This method uses event arguments
        ///    to pass the event data to the control.</para>
        /// </devdoc>
        protected internal virtual void OnPreRender(EventArgs e) {
            if(HasEvents()) {
                EventHandler handler = _events[EventPreRender] as EventHandler;
                if (handler != null) {
                    handler(this, e);
                }
            }
        }

        internal virtual void PreRenderRecursiveInternal() {
            // Call Visible property and cache value in !flags[invisible] to allow Visible to be overridden.
            // This avoids unnecessary virtual property calls in SaveViewState and Render.
            bool visible = Visible;
            if(!visible) {
                flags.Set(invisible);
            }
            else {
                flags.Clear(invisible);
                EnsureChildControls();

                if (AdapterInternal != null) {
                    AdapterInternal.OnPreRender(EventArgs.Empty);
                }
                else {
                    OnPreRender(EventArgs.Empty);
                }

                if (_controls != null) {
                    string oldmsg = _controls.SetCollectionReadOnly(SR.Parent_collections_readonly);

                    int controlCount = _controls.Count;
                    for (int i=0; i < controlCount; i++) {
                        _controls[i].PreRenderRecursiveInternal();
                    }
                    _controls.SetCollectionReadOnly(oldmsg);
                }
            }
            _controlState = ControlState.PreRendered;
        }

        // Same as PreRenderRecursive, but has an async point after the call to this.OnPreRender.
        internal async Task PreRenderRecursiveInternalAsync(Page page) {
            // Call Visible property and cache value in !flags[invisible] to allow Visible to be overridden.
            // This avoids unnecessary virtual property calls in SaveViewState and Render.
            bool visible = Visible;
            if (!visible) {
                flags.Set(invisible);
            }
            else {
                flags.Clear(invisible);
                if (AppSettings.EnableAsyncModelBinding) {
                    using (page.Context.SyncContext.AllowVoidAsyncOperationsBlock()) {
                        EnsureChildControls();
                        await page.GetWaitForPreviousStepCompletionAwaitable();
                    }
                }
                else {
                    EnsureChildControls();
                }

                using (page.Context.SyncContext.AllowVoidAsyncOperationsBlock()) {
                    if (AdapterInternal != null) {
                        AdapterInternal.OnPreRender(EventArgs.Empty);
                    }
                    else {
                        OnPreRender(EventArgs.Empty);
                    }
                    await page.GetWaitForPreviousStepCompletionAwaitable();
                }

                if (_controls != null) {
                    string oldmsg = _controls.SetCollectionReadOnly(SR.Parent_collections_readonly);

                    int controlCount = _controls.Count;
                    for (int i = 0; i < controlCount; i++) {
                        if (AppSettings.EnableAsyncModelBinding) {
                            // To make sure every OnPreRender is awaited so that _controlState
                            // would not be set to ControlState.PreRendered until the control is
                            // really PreRendered
                            await _controls[i].PreRenderRecursiveInternalAsync(page);
                        }
                        else {
                            _controls[i].PreRenderRecursiveInternal();
                        }
                    }

                    _controls.SetCollectionReadOnly(oldmsg);
                }
            }
            _controlState = ControlState.PreRendered;
        }

        internal int EstimateStateSize(object state) {
            if(state == null) {
                return 0;
            }
            return Util.SerializeWithAssert(new ObjectStateFormatter(), state).Length;
        }

        /*
         * Walk the tree and fill in profile information
         */

        /// <internalonly/>
        /// <devdoc>
        /// <para>Gathers information about the control and delivers it to the <see cref='System.Web.UI.Page.Trace'/>
        /// property to be displayed when tracing is enabled for the page.</para>
        /// </devdoc>
        protected void BuildProfileTree(string parentId, bool calcViewState) {
            // estimate the viewstate size.
            calcViewState = calcViewState && (!flags[disableViewState]);
            int viewstatesize;
            if (calcViewState)
                viewstatesize = EstimateStateSize(SaveViewState());
            else
                viewstatesize = 0;

            int controlstatesize = 0;
            if(Page != null && Page._registeredControlsRequiringControlState != null && Page._registeredControlsRequiringControlState.Contains(this)) {
                controlstatesize = EstimateStateSize(SaveControlStateInternal());
            }

            // give it all to the profiler
            Page.Trace.AddNewControl(UniqueID, parentId, this.GetType().FullName, viewstatesize, controlstatesize);

            if (_controls != null) {
                int controlCount = _controls.Count;
                for (int i = 0; i < controlCount; i++) {
                    _controls[i].BuildProfileTree(UniqueID, calcViewState);
                }
            }
        }


        internal object SaveControlStateInternal() {
            object controlState = SaveControlState();
            object adapterControlState = null;
            if (AdapterInternal != null) {
                adapterControlState = AdapterInternal.SaveAdapterControlState();
            }
            if (controlState != null || adapterControlState != null) {
                return new Pair(controlState, adapterControlState);
            }
            return null;
        }


        /// <devdoc>
        /// Save the control state, which is the essential state information needed even if view state is disabled.
        /// </devdoc>
        protected internal virtual object SaveControlState() {
            return null;
        }

        // Save modified state the control would like restored on the postback.
        // Return null if there is no state to save.

        /// <devdoc>
        ///    <para>
        ///       Saves view state for use with a later <see cref='System.Web.UI.Control.LoadViewState'/>
        ///       request.
        ///    </para>
        /// </devdoc>
        protected virtual object SaveViewState() {
            // Save values cached out of view state
            if (flags[visibleDirty]) {
                ViewState["Visible"] = !flags[invisible];
            }
            if (flags[validateRequestModeDirty]) {
                ViewState["ValidateRequestMode"] = (int)ValidateRequestMode;
            }
            if (_viewState != null)
                return _viewState.SaveViewState();

            return null;
        }

        // Answer any state this control or its descendants want to save on freeze.
        // The format for saving is Triplet(myState, ArrayList childIDs, ArrayList childStates),
        // where myState or childStates and childIDs may be null.
        internal object SaveViewStateRecursive(ViewStateMode inheritedMode) {
            if (flags[disableViewState])
                return null;

            bool saveThisState;
            if (flags[viewStateNotInherited]) {
                if (flags[viewStateMode]) {
                    saveThisState = true;
                    inheritedMode = ViewStateMode.Enabled;
                }
                else {
                    saveThisState = false;
                    inheritedMode = ViewStateMode.Disabled;
                }
            }
            else {
                saveThisState = (inheritedMode == ViewStateMode.Enabled);
            }

            object adapterState = null;
            object controlSavedState = null;

            if (saveThisState) {
                if (AdapterInternal != null) {
                    adapterState = AdapterInternal.SaveAdapterViewState();
                }
                controlSavedState = SaveViewState();
            }

            ArrayList childStates = null;
            if (HasControls()) {
                ControlCollection occasionalFieldControls = _controls;
                int occasionalFieldControlCount = occasionalFieldControls.Count;

                bool useId = LoadViewStateByID;
                for (int i = 0; i < occasionalFieldControlCount; i++) {
                    Control child = occasionalFieldControls[i];
                    object childState = child.SaveViewStateRecursive(inheritedMode);
                    if (childState != null) {
                        if (childStates == null) {
                            childStates = new ArrayList(occasionalFieldControlCount);
                        }

                        if (useId) {
                            child.EnsureID();
                            childStates.Add(child.ID);
                        }
                        else {
                            childStates.Add(i);
                        }
                        childStates.Add(childState);
                    }
                }
            }

            if (AdapterInternal != null) {
                if ((controlSavedState != null) || (adapterState != null) || (childStates != null)) {
                    return new Triplet(controlSavedState, adapterState, childStates);
                }
            }
            else {
                if ((controlSavedState != null) || (childStates != null)) {
                    return new Pair(controlSavedState, childStates);
                }
            }

            return null;
        }


        /// <devdoc>
        /// <para>Outputs control content to a provided HTMLTextWriter
        /// output stream.</para>
        /// </devdoc>
        protected internal virtual void Render(HtmlTextWriter writer) {
            RenderChildren(writer);
        }

        internal void RenderChildrenInternal(HtmlTextWriter writer, ICollection children) {
            // If we have a delegate, use it for the rendering.
            // This happens when there is some ASP code.  See also Whidbey 33012.
            if(RareFields != null && RareFields.RenderMethod != null ) {
                writer.BeginRender();
                RareFields.RenderMethod(writer, this);
                writer.EndRender();
                return;
            }
            if (children != null) {
                foreach (Control child in children) {
                    child.RenderControl(writer);
                }
            }
        }

        protected internal virtual void RenderChildren(HtmlTextWriter writer) {
            ICollection children = _controls;
            RenderChildrenInternal(writer, children);
        }

        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public virtual void RenderControl(HtmlTextWriter writer) {
            //use the Adapter property to ensure it is resolved
            RenderControl(writer, Adapter);
        }

        /// <devdoc>
        ///    <para>Used for MobilePage implementation.</para>
        /// </devdoc>
        protected void RenderControl(HtmlTextWriter writer, ControlAdapter adapter) {
            if (!flags[invisible] && !flags[notVisibleOnPage]) {
                HttpContext context = (Page == null) ? null : Page._context;
                if (context  != null && context.TraceIsEnabled) {
                    int presize = context.Response.GetBufferedLength();
                    RenderControlInternal(writer, adapter);
                    int postsize = context.Response.GetBufferedLength();
                    context.Trace.AddControlSize(UniqueID, postsize - presize);
                }
                else {
                    RenderControlInternal(writer, adapter);
                }
            }
            else {
                TraceNonRenderingControlInternal(writer);
            }
        }

        private void RenderControlInternal(HtmlTextWriter writer, ControlAdapter adapter) {
            try {
                BeginRenderTracing(writer, this);

                if (adapter != null) {
                    //
                    adapter.BeginRender(writer);
                    adapter.Render(writer);
                    adapter.EndRender(writer);
                }
                else {
                    Render(writer);
                }
            }
            finally {
                EndRenderTracing(writer, this);
            }
        }


        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        protected internal virtual void OnUnload(EventArgs e) {
            if(HasEvents()) {
                EventHandler handler = _events[EventUnload] as EventHandler;
                if (handler != null) {
                    handler(this, e);
                }
            }
        }


        /// <devdoc>
        ///    <para>Enables a control to perform final cleanup.</para>
        /// </devdoc>
        public virtual void Dispose() {
            IContainer container = null;

            if (Site != null) {
                container = (IContainer)Site.GetService(typeof(IContainer));
                if (container != null) {
                    container.Remove(this);
                    EventHandler disp = Events[EventDisposed] as EventHandler;
                    if (disp != null)
                        disp(this, EventArgs.Empty);
                }
            }

            if (_occasionalFields != null) {
                _occasionalFields.Dispose();
                //do not null out for backwards compat, VSWhidbey 475940
                //_occasionalFields = null;
            }

            if (_events != null) {
                _events.Dispose();
                _events = null;
            }
        }


        internal virtual void UnloadRecursive(bool dispose) {
            Page page = Page;
            if (page != null && page.RequiresControlState(this)) {
                page.UnregisterRequiresControlState(this);
                RareFieldsEnsured.RequiredControlState = true;
            }

            // Remove the generated ID so it will be assigned a different ID next time.
            if (flags[useGeneratedID]) {
                _id = null;
                flags.Clear(useGeneratedID);
            }

            if (_controls != null) {
                string oldmsg = _controls.SetCollectionReadOnly(SR.Parent_collections_readonly);

                int controlCount = _controls.Count;
                for (int i = 0; i < controlCount; i++)
                    _controls[i].UnloadRecursive(dispose);

                _controls.SetCollectionReadOnly(oldmsg);
            }

            if (AdapterInternal != null) {
                AdapterInternal.OnUnload(EventArgs.Empty);
            }
            else {
                OnUnload(EventArgs.Empty);
            }

            //
            if (dispose)
                Dispose();

            // VSWhidbey 244999: Everett behavior doesn't reset the control state.
            // But for control which requires its OnInit method to be called again
            // to properly initialize when the control is removed and added back
            // to Page's control tree, the control can override IsReloadable
            // to true so the control state is reset.  e.g. Validator, see bug
            if (IsReloadable) {
                _controlState = ControlState.Constructed;
            }
        }


        /// <devdoc>
        ///    <para>Assigns an sources of the event and its information up the page control
        ///       hierarchy until they reach the top of the control tree. </para>
        /// </devdoc>
        protected void RaiseBubbleEvent(object source, EventArgs args) {
            Control currentTarget = Parent;
            while (currentTarget != null) {
                if (currentTarget.OnBubbleEvent(source, args)) {
                    return;
                }
                currentTarget = currentTarget.Parent;
            }
        }


        /// <devdoc>
        ///    <para>Determines whether the event for the control should be passed up the page's
        ///       control hierarchy.</para>
        /// </devdoc>
        protected virtual bool OnBubbleEvent(object source, EventArgs args) {
            return false;
        }


        // Members related to being a container


        /// <devdoc>
        ///    <para> Gets a ControlCollection object that represents the child controls for a specified control in the
        ///       UI hierarchy.</para>
        /// </devdoc>
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        WebSysDescription(SR.Control_Controls)
        ]
        public virtual ControlCollection Controls {
            get {
                if (_controls == null) {
                    _controls = CreateControlCollection();
                }
                return _controls;
            }
        }

        [
        WebCategory("Behavior"),
        WebSysDescription(SR.Control_ValidateRequestMode),
        DefaultValue(ValidateRequestMode.Inherit)
        ]
        public virtual ValidateRequestMode ValidateRequestMode {
            get {
                return (ValidateRequestMode)flags[validateRequestMode, validateRequestModeOffset];
            }
            set {
                SetValidateRequestModeInternal(value, setDirty: true);
            }
        }

        internal void SetValidateRequestModeInternal(UI.ValidateRequestMode value, bool setDirty) {
            if (value < ValidateRequestMode.Inherit || value > ValidateRequestMode.Enabled) {
                throw new ArgumentOutOfRangeException("value");
            }

            int oldValue = flags[validateRequestMode, validateRequestModeOffset];
            if (setDirty && (oldValue != (int)value)) {
                flags.Set(validateRequestModeDirty);
            }

            flags[validateRequestMode, validateRequestModeOffset] = (int)value;
        }

        internal bool CalculateEffectiveValidateRequest() {
            RuntimeConfig config = RuntimeConfig.GetConfig();
            HttpRuntimeSection runtimeSection = config.HttpRuntime;
            if (runtimeSection.RequestValidationMode >= VersionUtil.Framework45) {
                Control c = this;
                while (c != null) {
                    ValidateRequestMode mode = c.ValidateRequestMode;
                    if (mode != ValidateRequestMode.Inherit) {
                        return mode == ValidateRequestMode.Enabled;
                    }
                    c = c.Parent;
                }
            }
            return true;
        }


        /// <devdoc>
        ///    <para>Indicates a dictionary of state information that allows you to save and restore
        ///       the state of a control across multiple requests for the same page.</para>
        /// </devdoc>
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        WebSysDescription(SR.Control_State)
        ]
        protected virtual StateBag ViewState {
            get {
                if (_viewState != null) {   // create a StateBag on demand; WebControl makes its case sensitive
                    return _viewState;
                }

                _viewState = new StateBag(ViewStateIgnoresCase);
                if (IsTrackingViewState)
                    _viewState.TrackViewState();
                return _viewState;
            }
        }

        // fast enough that we cam always use it.

        /// <devdoc>
        /// <para>Indicates whether the <see cref='System.Web.UI.StateBag'/> object is case-insensitive.</para>
        /// </devdoc>
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        protected virtual bool ViewStateIgnoresCase {
            get {
                return false;
            }
        }


        /// <devdoc>
        /// </devdoc>
        protected internal virtual void AddedControl(Control control, int index) {
            if (control.OwnerControl != null) {
                throw new InvalidOperationException(SR.GetString(SR.Substitution_NotAllowed));
            }

            if (control._parent != null) {
                control._parent.Controls.Remove(control);
            }

            control._parent = this;
            control._page = Page;
            control.flags.Clear(designModeChecked);

            // We only add to naming container if it is available. Otherwise, it will be pushed through
            // during InitRecursive
            Control namingContainer = flags[isNamingContainer] ? this : _namingContainer;
            if (namingContainer != null) {
                control.UpdateNamingContainer(namingContainer);
                if (control._id == null && !control.flags[idNotRequired]) {
                    // this will also dirty the name table in the naming container
                    control.GenerateAutomaticID();
                }
                else if (control._id != null || (control._controls != null)) {
                    // If the control has and ID, or has children (which *may* themselves
                    // have ID's), we need to dirty the name table (ASURT 100557)
                    namingContainer.DirtyNameTable();
                }
            }

            /*
             * The following is for times when AddChild is called after CreateChildControls. This
             * allows users to add children at any time in the creation process without having
             * to understand the underlying machinery.
             * Note that if page is null, it means we haven't been attached to a container ourselves.
             * If this is true, when we are, our children will be recursively set up.
             */
            if (_controlState >= ControlState.ChildrenInitialized) {

                Debug.Assert(namingContainer != null);
                control.InitRecursive(namingContainer);

                // VSWhidbey 396372: We need to reregister the control state if the control is reparented because the control
                // is unregistered during unload, but its already been inited once, so it will not get its Init called again
                // which is where most controls call RegisterRequiresControlState
                if (control._controlState >= ControlState.Initialized &&
                    control.RareFields != null &&
                    control.RareFields.RequiredControlState) {
                    Page.RegisterRequiresControlState(control);
                }

                if (_controlState >= ControlState.ViewStateLoaded) {
                    object viewState = null;
                    if(_occasionalFields != null && _occasionalFields.ControlsViewState != null) {
                        viewState = _occasionalFields.ControlsViewState[index];
                        // This solution takes the conservative approach that once viewstate has been
                        // applied to a child control, it is thrown away.  This eliminates inadvertently
                        // setting viewstate on the wrong control, which can occur in scenarios where
                        // the child control collection is being manipulated via code.  Probably need
                        // to provide a feature where programmer can control whether to reapply viewstate
                        // or not.
                        if (LoadViewStateByID) {
                            control.EnsureID();
                            viewState = _occasionalFields.ControlsViewState[control.ID];
                            _occasionalFields.ControlsViewState.Remove(control.ID);
                        }
                        else {
                            viewState = _occasionalFields.ControlsViewState[index];
                            _occasionalFields.ControlsViewState.Remove(index);
                        }
                    }

                    control.LoadViewStateRecursive(viewState);

                    if (_controlState >= ControlState.Loaded) {
                        control.LoadRecursive();

                        if (_controlState >= ControlState.PreRendered)
                            control.PreRenderRecursiveInternal();
                    }
                }
            }
        }


        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        protected virtual ControlCollection CreateControlCollection() {
            return new ControlCollection(this);
        }


        /// <devdoc>
        ///    <para>
        ///       Notifies any controls that use composition-based implementation to create any
        ///       child controls they contain in preperation for postback or rendering.
        ///    </para>
        /// </devdoc>
        protected internal virtual void CreateChildControls() {
        }



        /// <devdoc>
        ///    <para>Indicates whether the control's child controls have been created.</para>
        /// </devdoc>
        protected bool ChildControlsCreated {
            get {
                return flags[controlsCreated];
            }
            set {
                if (!value && flags[controlsCreated]) {
                    Controls.Clear();
                }
                if(value) {
                    flags.Set(controlsCreated);
                }
                else {
                    flags.Clear(controlsCreated);
                }
            }
        }


        /// <devdoc>
        ///    <para>Make a URL absolute using the AppRelativeTemplateSourceDirectory.  The returned URL is for
        ///        client use, and will contain the session cookie if appropriate.</para>
        /// </devdoc>
        public string ResolveUrl(string relativeUrl) {
            if (relativeUrl == null) {
                throw new ArgumentNullException("relativeUrl");
            }

            // check if its empty or already absolute
            if ((relativeUrl.Length == 0) || (UrlPath.IsRelativeUrl(relativeUrl) == false)) {
                return relativeUrl;
            }

            string baseUrl = AppRelativeTemplateSourceDirectory;
            if (String.IsNullOrEmpty(baseUrl)) {
                return relativeUrl;
            }

            // first make it absolute
            string url = UrlPath.Combine(baseUrl, relativeUrl);

            // include the session cookie if available (ASURT 47658)
            // As a side effect, this will change an app relative path (~/...) to app absolute
            return Context.Response.ApplyAppPathModifier(url);
        }


        /// <devdoc>
        ///    <para> Return a URL that is suitable for use on the client.
        ///     If the URL is absolute, return it unchanged.  If it is relative, turn it into a
        ///     relative URL that is correct from the point of view of the current request path
        ///     (which is what the browser uses for resolution).</para>
        /// </devdoc>
        public string ResolveClientUrl(string relativeUrl) {
            if (DesignMode && Page != null && Page.Site != null) {
                IUrlResolutionService resolutionService = (IUrlResolutionService)Page.Site.GetService(typeof(IUrlResolutionService));
                if (resolutionService != null) {
                    return resolutionService.ResolveClientUrl(relativeUrl);
                }
            }

            if (relativeUrl == null) {
                throw new ArgumentNullException("relativeUrl");
            }

            // Get the app absolute TemplateSourceDirectory (not app relative)
            string tplSourceDir = VirtualPath.GetVirtualPathString(TemplateControlVirtualDirectory);
            if (String.IsNullOrEmpty(tplSourceDir))
                return relativeUrl;

            string baseRequestDir = Context.Request.ClientBaseDir.VirtualPathString;

            // If the path is app relative (~/...), we cannot take shortcuts, since
            // the ~ is meaningless on the client, and must be resolved
            if (!UrlPath.IsAppRelativePath(relativeUrl)) {

                // If the template source directory is the same as the directory of the request,
                // we don't need to do any adjustments to the input path
                if (StringUtil.EqualsIgnoreCase(baseRequestDir, tplSourceDir))
                    return relativeUrl;

                // check if it's empty or absolute
                if ((relativeUrl.Length == 0) || (!UrlPath.IsRelativeUrl(relativeUrl))) {
                    return relativeUrl;
                }
            }

            // first make it absolute
            string url = UrlPath.Combine(tplSourceDir, relativeUrl);

            // Make sure the path ends with a slash before calling MakeRelative
            baseRequestDir = UrlPath.AppendSlashToPathIfNeeded(baseRequestDir);

            // Now, make it relative to the current request, so that the client will
            // compute the correct path
            url = HttpUtility.UrlPathEncode(UrlPath.MakeRelative(baseRequestDir, url));
            Debug.Trace("ClientUrl", "*** ResolveClientUrl (" + relativeUrl + ") --> " + url + " ***");
            return url;
        }

        internal void DirtyNameTable() {
            Debug.Assert(this is INamingContainer);
            if(_occasionalFields != null) {
                _occasionalFields.NamedControls = null;
            }
        }

        private void EnsureNamedControlsTable() {
            Debug.Assert(this is INamingContainer);
            Debug.Assert(HasControls());
            Debug.Assert(_occasionalFields != null);
            Debug.Assert(_occasionalFields.NamedControls == null);

            _occasionalFields.NamedControls = new HybridDictionary(/*initialSize*/ _occasionalFields.NamedControlsID, /*caseInsensitive*/ true);
            FillNamedControlsTable(this, _controls);
        }

        private void FillNamedControlsTable(Control namingContainer, ControlCollection controls) {
            Debug.Assert(namingContainer._occasionalFields != null);
            Debug.Assert(namingContainer._occasionalFields.NamedControls != null);
            Debug.Assert((controls != null) && (controls.Count != 0));

            int controlCount = controls.Count;
            for (int i=0; i < controlCount; i++) {
                Control control = controls[i];
                if (control._id != null) {
#if DEBUG
                    if (control._namingContainer != null) {
                        Debug.Assert(control._namingContainer == namingContainer);
                    }
#endif // DEBUG
                    try {
                        namingContainer.EnsureOccasionalFields();
                        namingContainer._occasionalFields.NamedControls.Add(control._id, control);
                    }
                    catch {
                        throw new HttpException(SR.GetString(SR.Duplicate_id_used, control._id, "FindControl"));
                    }
                }
                if (control.HasControls() && (control.flags[isNamingContainer] == false)) {
                    FillNamedControlsTable(namingContainer, control.Controls);
                }
            }
        }


        /// <devdoc>
        ///    <para>Searches the current naming container for a control with
        ///       the specified <paramref name="id"/> .</para>
        /// </devdoc>
        public virtual Control FindControl(String id) {
            return FindControl(id, 0);
        }


        /// <internalonly/>
        /// <devdoc>
        ///    <para>Searches the current naming container for a control with the specified
        ///    <paramref name="id"/> and an offset to aid in the
        ///       search.</para>
        /// </devdoc>
        protected virtual Control FindControl(String id, int pathOffset) {
            // DevDiv #338426 - Since this is a recursive function, malicious clients can send us an id
            // which causes a very deep stack dive, resulting in SO (which terminates the worker process).
            // We avoid this via the following call, which at the time of this writing ensures that at
            // least 50% of the available stack remains. The check is very quick: < 1 microsecond.
            RuntimeHelpers.EnsureSufficientExecutionStack();

            string childID;

            EnsureChildControls();

            // If we're not the naming container, let it do the job
            if (!(flags[isNamingContainer])) {
                Control namingContainer = NamingContainer;
                if (namingContainer != null) {
                    return namingContainer.FindControl(id, pathOffset);
                }
                return null;
            }

            // No registered control, demand create the named controls table
            //call HasControls doesn't ensures _occasionalFields != null
            if (HasControls()) {
                EnsureOccasionalFields();
                if (_occasionalFields.NamedControls == null) {
                    EnsureNamedControlsTable();
                }
            }
            if (_occasionalFields == null || _occasionalFields.NamedControls == null) {
                return null;
            }

            // Need to support ':' for V1 backward compatibility.
            char[] findControlSeparators = { ID_SEPARATOR, LEGACY_ID_SEPARATOR };

            // Is it a hierarchical name?
            int newPathOffset = id.IndexOfAny(findControlSeparators, pathOffset);

            // If not, handle it here
            if (newPathOffset == -1) {
                childID = id.Substring(pathOffset);
                return _occasionalFields.NamedControls[childID] as Control;
            }

            // Get the name of the child, and try to locate it
            childID = id.Substring(pathOffset, newPathOffset - pathOffset);
            Control child =  _occasionalFields.NamedControls[childID] as Control;

            // Child doesn't exist: fail
            if (child == null)
                return null;

            return child.FindControl(id, newPathOffset + 1);
        }

        internal Control FindControlFromPageIfNecessary(string id) {
            Control c = FindControl(id);
            // Find control from the page if it's a hierarchical ID.
            // Dev11 bug 19915
            if (c == null && Page != null) {
                char[] findControlSeparators = { ID_SEPARATOR, LEGACY_ID_SEPARATOR };
                if (id.IndexOfAny(findControlSeparators) != -1) {
                    c = Page.FindControl(id);
                }
            }
            return c;
        }

        /*
         * Called when the controls of a naming container are cleared.
         */
        internal void ClearNamingContainer() {
            Debug.Assert(this is INamingContainer);

            EnsureOccasionalFields();
            _occasionalFields.NamedControlsID = 0;
            DirtyNameTable();
        }


        /// <internalonly/>
        /// <devdoc>
        /// </devdoc>
        [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
        protected virtual IDictionary GetDesignModeState() {
            ControlRareFields rareFields = RareFieldsEnsured;
            if (rareFields.DesignModeState == null) {
                rareFields.DesignModeState = new HybridDictionary();
            }
            return rareFields.DesignModeState;
        }


        /// <devdoc>
        ///    <para>Determines if the current control contains any child
        ///       controls. Since this method simply deteremines if any child controls exist at
        ///       all, it can enhance performance by avoiding a call to the Count property,
        ///       inherited from the <see cref='System.Web.UI.ControlCollection'/> class, on the <see cref='System.Web.UI.Control.Controls'/>
        ///       property.</para>
        /// </devdoc>
        public virtual bool HasControls() {
            return _controls != null && _controls.Count > 0;
        }

        /*
         * Check if a Control either has children or has a compiled render method.
         * This is to address issues like ASURT 94127
         */
        internal bool HasRenderingData() {
            return HasControls() || HasRenderDelegate();
        }

        /*
         * Check if a Control either has children or has a compiled render method.
         * This is to address issues like ASURT 94127
         */
        internal bool HasRenderDelegate() {
            if(RareFields != null) {
                return (RareFields.RenderMethod != null );
            }
            return false;
        }

        /*
         * Returns true if the container contains just a static string, i.e.,
         * when the Controls collection has a single LiteralControl.
         */

        /// <devdoc>
        ///    <para>Determines if the container holds literal content only.
        ///       When this method returns <see langword='true'/>
        ///       , the container collection only holds a single literal control. The
        ///       content is then passed to the requesting browser as HTML.</para>
        /// </devdoc>
        protected bool IsLiteralContent() {
            return (_controls != null) && (_controls.Count == 1) &&
            ((_controls[0] is LiteralControl));
        }


        /// <devdoc>
        ///    <para>Determines if view state changes to the
        ///    <see langword='Control'/>
        ///    are being saved. </para>
        /// </devdoc>
        protected bool IsTrackingViewState {
            get {
                return flags[marked];
            }
        }


        /// <devdoc>
        ///    <para>Turns on tracking of view state changes to the control
        ///       so that they can be stored in the <see langword='StateBag'/>
        ///       object.</para>
        /// </devdoc>
        protected virtual void TrackViewState() {
            if (_viewState != null)
                _viewState.TrackViewState();

            flags.Set(marked);
        }


        /// <devdoc>
        ///    <para>Checks that the control contains child controls; if it does not, it creates
        ///       them. This includes any literal content being parsed as a <see cref='System.Web.UI.LiteralControl'/>
        ///       object. </para>
        /// </devdoc>
        protected virtual void EnsureChildControls() {
            if (!ChildControlsCreated && !flags[creatingControls]) {
                flags.Set(creatingControls);
                try {
                    ResolveAdapter();
                    if (AdapterInternal != null) {
                        AdapterInternal.CreateChildControls();
                    }
                    else {
                        CreateChildControls();
                    }

                    // Only set ChildControlsCreated = true if CreateChildControls() did not throw
                    // an exception (VSWhidbey 465798).
                    ChildControlsCreated = true;
                }
                finally {
                    flags.Clear(creatingControls);
                }
            }
        }

        /// <devdoc>
        /// Used internally to store a ControlBuilder reference for the control.
        /// The builder will be used at design-time to help persist all the filtered properties
        /// of the control.
        /// </devdoc>
        internal void SetControlBuilder(ControlBuilder controlBuilder) {
            RareFieldsEnsured.ControlBuilder = controlBuilder;
        }


        /// <devdoc>
        /// </devdoc>
        protected internal virtual void RemovedControl(Control control) {
            if (control.OwnerControl != null) {
                throw new InvalidOperationException(SR.GetString(SR.Substitution_NotAllowed));
            }

            if ((_namingContainer != null) && (control._id != null)) {
                _namingContainer.DirtyNameTable();
            }

            // Controls may need to do their own cleanup.
            control.UnloadRecursive(false);

            control._parent = null;
            control._page = null;
            control._namingContainer = null;

            // Don't reset template source virtual directory on TemplateControl's, because
            // the path is their own, not their parent. i.e. it doesn't change no matter
            // where in the tree they end up.
            if (!(control is TemplateControl)) {
                if (control._occasionalFields != null) {
                    control._occasionalFields.TemplateSourceVirtualDirectory = null;
                }
            }

            if (control._occasionalFields != null ) {
                control._occasionalFields.TemplateControl = null;
            }

            control.flags.Clear(mustRenderID);
            control.ClearCachedUniqueIDRecursive();
        }

        internal void SetDesignMode() {
            flags.Set(designMode);
            flags.Set(designModeChecked);
        }


        /// <internalonly/>
        /// <devdoc>
        /// </devdoc>
        protected virtual void SetDesignModeState(IDictionary data) {
        }

        // Set the delegate to the render method

        /// <internalonly/>
        /// <devdoc>
        ///    <para>Assigns any event handler delegates for the control to match the parameters
        ///       defined in the <see cref='System.Web.UI.RenderMethod'/>. </para>
        /// </devdoc>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void SetRenderMethodDelegate(RenderMethod renderMethod) {
            RareFieldsEnsured.RenderMethod = renderMethod;

            // Make the collection readonly if there are code blocks (ASURT 78810)
            Controls.SetCollectionReadOnly(SR.Collection_readonly_Codeblocks);
        }


        /// <internalonly/>
        /// <devdoc>
        ///    <para>Returns whether the control contains any data binding logic. This method is
        ///       only accessed by RAD designers.</para>
        /// </devdoc>
        bool IDataBindingsAccessor.HasDataBindings {
            get {
                return ((RareFields != null) && (RareFields.DataBindings != null) && (RareFields.DataBindings.Count != 0));
            }
        }


        /// <internalonly/>
        /// <devdoc>
        /// <para>Indicates a collection of all data bindings on the control. This property is
        /// read-only.</para>
        /// </devdoc>
        DataBindingCollection IDataBindingsAccessor.DataBindings {
            get {
                ControlRareFields rareFields = RareFieldsEnsured;
                if (rareFields.DataBindings == null) {
                    rareFields.DataBindings = new DataBindingCollection();
                }
                return rareFields.DataBindings;
            }
        }


        // IParserAccessor interface
        // A sub-object tag was parsed by the parser; add it to this control.

        /// <internalonly/>
        /// <devdoc>
        /// <para>Notifies the control that an element, XML or HTML, was parsed, and adds it to
        /// the control.</para>
        /// </devdoc>
        void IParserAccessor.AddParsedSubObject(object obj) {
            AddParsedSubObject(obj);
        }

        internal string SpacerImageUrl {
            get {
                EnsureOccasionalFields();
                if (_occasionalFields.SpacerImageUrl == null) {
                    _occasionalFields.SpacerImageUrl = Page.ClientScript.GetWebResourceUrl(typeof(WebControl), "Spacer.gif");
                }
                return _occasionalFields.SpacerImageUrl;
            }
        }

        private Control OwnerControl {
            get {
                if (RareFields == null) {
                    return null;
                }

                return RareFields.OwnerControl;
            }
            set {
                RareFieldsEnsured.OwnerControl = value;
            }
        }

        internal IPostBackDataHandler PostBackDataHandler {
            get {
                IPostBackDataHandler pbdh = AdapterInternal as IPostBackDataHandler;
                if(pbdh != null)
                    return pbdh;
                pbdh = this as IPostBackDataHandler;
                return pbdh;
            }
        }

        internal IPostBackEventHandler PostBackEventHandler {
            get {
                IPostBackEventHandler pbeh = AdapterInternal as IPostBackEventHandler;
                if(pbeh != null)
                    return pbeh;
                pbeh = this as IPostBackEventHandler;
                return pbeh;
            }
        }

        /// <summary>
        /// This method is used for design-time tracing of rendering data.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected void BeginRenderTracing(TextWriter writer, object traceObject) {
            RenderTraceListener.CurrentListeners.BeginRendering(writer, traceObject);
        }

        /// <summary>
        /// This method is used for design-time tracing of rendering data.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected void EndRenderTracing(TextWriter writer, object traceObject) {
            RenderTraceListener.CurrentListeners.EndRendering(writer, traceObject);
        }

        private void TraceNonRenderingControlInternal(TextWriter writer) {
            BeginRenderTracing(writer, this);
            EndRenderTracing(writer, this);
        }

        /// <summary>
        /// This method is used for design-time tracing of rendering data.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public void SetTraceData(object traceDataKey, object traceDataValue) {
            SetTraceData(this, traceDataKey, traceDataValue);
        }

        /// <summary>
        /// This method is used for design-time tracing of rendering data.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public void SetTraceData(object tracedObject, object traceDataKey, object traceDataValue) {
            RenderTraceListener.CurrentListeners.SetTraceData(tracedObject, traceDataKey, traceDataValue);
        }

        #region IControlDesignerAccessor implementation

        /// <internalonly/>
        IDictionary IControlDesignerAccessor.UserData {
            get {
                ControlRareFields rareFields = RareFieldsEnsured;
                if (rareFields.ControlDesignerAccessorUserData == null) {
                    rareFields.ControlDesignerAccessorUserData = new HybridDictionary();
                }
                return rareFields.ControlDesignerAccessorUserData;
            }
        }

        /// <internalonly/>
        /// <devdoc>
        /// </devdoc>
        IDictionary IControlDesignerAccessor.GetDesignModeState() {
            return GetDesignModeState();
        }


        /// <internalonly/>
        /// <devdoc>
        /// </devdoc>
        void IControlDesignerAccessor.SetDesignModeState(IDictionary data) {
            SetDesignModeState(data);
        }

        void IControlDesignerAccessor.SetOwnerControl(Control owner) {
            if (owner == this) {
                throw new ArgumentException(SR.GetString(SR.Control_CannotOwnSelf), "owner");
            }
            OwnerControl = owner;
            _parent = owner.Parent;
            _page = owner.Page;
        }
        #endregion

        #region IControlBuilderAccessor implementation

        /// <internalonly/>
        /// <devdoc>
        /// A reference to the ControlBuilder that was used to construct this control (if there was one)
        /// </devdoc>
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        ControlBuilder IControlBuilderAccessor.ControlBuilder {
            get {
                return RareFields != null ? RareFields.ControlBuilder : null;
            }
        }
        #endregion IControlBuilderAccessor implementation

        #region IExpressionsAccessor


        /// <internalonly/>
        bool IExpressionsAccessor.HasExpressions {
            get {
                if (RareFields == null) {
                    return false;
                }
                ExpressionBindingCollection expressions = RareFields.ExpressionBindings;
                return ((expressions != null) && (expressions.Count > 0));
            }
        }


        /// <internalonly/>
        ExpressionBindingCollection IExpressionsAccessor.Expressions {
            get {
                ExpressionBindingCollection expressions = RareFieldsEnsured.ExpressionBindings;
                if (expressions == null) {
                    expressions = new ExpressionBindingCollection();
                    RareFields.ExpressionBindings = expressions;
                }
                return expressions;
            }
        }
        #endregion

        private sealed class ControlRareFields : IDisposable {

            internal ControlRareFields() {
            }
            public ISite Site;
            public RenderMethod RenderMethod;
            // Reference to the ControlBuilder used to build this control
            public ControlBuilder ControlBuilder;
            public DataBindingCollection DataBindings;
            public Control OwnerControl;
            public ExpressionBindingCollection ExpressionBindings;
            public bool RequiredControlState = false;

            // These fields are only used in the designer so we
            // keep them here to prevent memory bloat at runtime
            public IDictionary ControlDesignerAccessorUserData;
            public IDictionary DesignModeState;

            public Version RenderingCompatibility;
            public RouteCollection RouteCollection;
            public ControlAdapter Adapter;

            public void Dispose() {
                //do not null out for backwards compat, VSWhidbey 475940
                //Site = null;
                //RenderMethod = null;
                //DataBindings = null;
                //OwnerControl = null;
                //ExpressionBindings = null;
                //Adapter = null;
                ControlBuilder = null;
                if (OwnerControl != null)
                {
                    OwnerControl.Dispose();
                }
                ControlDesignerAccessorUserData = null;
                DesignModeState = null;
                RenderingCompatibility = null;
                RouteCollection = null;
            }
        }

        private sealed class OccasionalFields : IDisposable {
            internal OccasionalFields() {
            }

            public string SkinId;
            public IDictionary ControlsViewState;
            public int NamedControlsID;
            // Only used if we are a naming container.  It contains all the controls
            // in the namespace.
            public IDictionary NamedControls;
            public ControlRareFields RareFields;
            public String UniqueIDPrefix;

            public string SpacerImageUrl;
            public TemplateControl TemplateControl;
            public VirtualPath TemplateSourceVirtualDirectory;

            public void Dispose() {
                if (RareFields != null) {
                    RareFields.Dispose();
                }

                ControlsViewState = null;
                //do not null out for backwards compat, VSWhidbey 475940
                //NamedControls = null;
                //UniqueIDPrefix = null;
                //TemplateControl = null;
                //TemplateSourceVirtualDirectory = null;
            }
        }
    }
}