File: WebPartManager.cs

package info (click to toggle)
mono 6.8.0.105%2Bdfsg-3.3
links: PTS, VCS
area: main
in suites: bookworm
size: 1,284,512 kB
sloc: cs: 11,172,132; xml: 2,850,069; ansic: 671,653; cpp: 122,091; perl: 59,366; javascript: 30,841; asm: 22,168; makefile: 20,093; sh: 15,020; python: 4,827; pascal: 925; sql: 859; sed: 16; php: 1
file content (4632 lines) | stat: -rw-r--r-- 206,910 bytes
parent folder | download | duplicates (6)
//------------------------------------------------------------------------------
// <copyright file="WebPartManager.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------

namespace System.Web.UI.WebControls.WebParts {

    using System;
    using System.Collections;
    using System.Collections.Specialized;
    using System.ComponentModel;
    using System.Diagnostics.CodeAnalysis;
    using System.Drawing;
    using System.Globalization;
    using System.IO;
    using System.Reflection;
    using System.Security;
    using System.Security.Permissions;
    using System.Text;
    using System.Web;
    using System.Web.Configuration;
    using System.Web.UI;
    using System.Web.UI.WebControls;
    using System.Web.Util;
    using System.Xml;

    [
    Bindable(false),
    Designer("System.Web.UI.Design.WebControls.WebParts.WebPartManagerDesigner, " + AssemblyRef.SystemDesign),
    NonVisualControl(),
    ParseChildren(true),
    PersistChildren(false),
    ViewStateModeById(),
    ]
    public class WebPartManager : Control, INamingContainer, IPersonalizable {

        public static readonly WebPartDisplayMode CatalogDisplayMode = new CatalogWebPartDisplayMode();
        public static readonly WebPartDisplayMode ConnectDisplayMode = new ConnectWebPartDisplayMode();
        public static readonly WebPartDisplayMode DesignDisplayMode = new DesignWebPartDisplayMode();
        public static readonly WebPartDisplayMode EditDisplayMode = new EditWebPartDisplayMode();
        public static readonly WebPartDisplayMode BrowseDisplayMode = new BrowseWebPartDisplayMode();

        // Cache collections of ConnectionPoints for each object Type.  We store an array of
        // 2 ConnectionPointCollections (consumer, provider) for each Type.  The Hashtable
        // is synchronized so it is threadsafe with multiple writers.
        private static Hashtable ConnectionPointsCache;

        private static readonly object AuthorizeWebPartEvent = new object();
        private static readonly object ConnectionsActivatedEvent = new object();
        private static readonly object ConnectionsActivatingEvent = new object();
        private static readonly object DisplayModeChangedEvent = new object();
        private static readonly object DisplayModeChangingEvent = new object();
        private static readonly object SelectedWebPartChangingEvent = new object();
        private static readonly object SelectedWebPartChangedEvent = new object();
        private static readonly object WebPartAddedEvent = new object();
        private static readonly object WebPartAddingEvent = new object();
        private static readonly object WebPartClosedEvent = new object();
        private static readonly object WebPartClosingEvent = new object();
        private static readonly object WebPartDeletedEvent = new object();
        private static readonly object WebPartDeletingEvent = new object();
        private static readonly object WebPartMovedEvent = new object();
        private static readonly object WebPartMovingEvent = new object();
        private static readonly object WebPartsConnectedEvent = new object();
        private static readonly object WebPartsConnectingEvent = new object();
        private static readonly object WebPartsDisconnectedEvent = new object();
        private static readonly object WebPartsDisconnectingEvent = new object();

        private PermissionSet _minimalPermissionSet;
        private PermissionSet _mediumPermissionSet;
        private bool? _usePermitOnly;

        private const string DynamicConnectionIDPrefix = "c";
        private const string DynamicWebPartIDPrefix = "wp";

        private const int baseIndex = 0;
        private const int selectedWebPartIndex = 1;
        private const int displayModeIndex = 2;
        private const int controlStateArrayLength = 3;

        private WebPartPersonalization _personalization;
        private WebPartDisplayMode _displayMode;
        private WebPartDisplayModeCollection _displayModes;
        private WebPartDisplayModeCollection _supportedDisplayModes;
        private WebPartManagerInternals _internals;

        private bool _allowCreateDisplayTitles;
        private bool _pageInitComplete;

        // When this flag is set to false, then cancelled events are ignored.  We will not actually
        // cancel the action even though e.Cancel is true.  (VSWhidbey 516012)
        private bool _allowEventCancellation;

        private PersonalizationDictionary _personalizationState;
        private bool _hasDataChanged;

        private WebPartConnectionCollection _staticConnections;
        private WebPartConnectionCollection _dynamicConnections;

        private WebPartZoneCollection _webPartZones;
        private TransformerTypeCollection _availableTransformers;

        // Dictionary mapping a WebPart to its DisplayTitle.  Created and filled on demand when
        // GetDisplayTitle() is called after PreRender.
        private IDictionary _displayTitles;

        // NOTE: We are no longer rendering the LRO or PDF characters (VSWhidbey 364897)
        // LRO is the Unicode left-to-right override marker.  Effectively creates a "run break"
        // so that contents in parentheses et. al. maintain correct reading order regardless
        // of text direction (LTR or RTL).  PDF "pops" the formatting and allows ensuing text
        // to lay out as it would w/o the markers.  The PDF is needed when constructing dialogs
        // that use the web part titles.  We must use the Unicode characters instead of
        // <span dir="ltr">, since the DisplayTitle is HTML Encoded before being rendered.
        // (VSWhidbey 190501)
        // private static string LRO = new String((char)0x202d, 1);  // left-to-right override
        // private static string PDF = new String((char)0x202c, 1);  // pop directional formatting

        // PERF: At compile-time, compute strings to append to DisplayTitle
        // We chose to compute suffixes up to 20, since it is unlikely there will be more than
        // 20 WebParts with the same title.
        // The 0 element is currently not used, but is a placeholder so the index into the array
        // matches the string.
        private static string[] displayTitleSuffix = new string[] {
            " [0]", " [1]", " [2]", " [3]", " [4]", " [5]", " [6]", " [7]", " [8]", " [9]", " [10]",
            " [11]", " [12]", " [13]", " [14]", " [15]", " [16]", " [17]", " [18]", " [19]", " [20]" };

        // Dictionary mapping a zone to the parts in the zone.  Used by GetAllWebPartsForZone
        // to improve performance.
        private IDictionary _partsForZone;

        // Contains the IDs of WebParts and Child Controls already added.  WebParts and the child
        // controls of GenericWebParts share the same namespace, meaning you cannot have a WebPart
        // and a Child Control with the same ID. An exception is thrown if a WebPart or Child Control
        // is added with a duplicate ID.
        private IDictionary _partAndChildControlIDs;

        // Contains the IDs of Zones already added.  An exception is thrown if a Zone is added with
        // a duplicate ID.
        private IDictionary _zoneIDs;

        private WebPart _selectedWebPart;

        private bool _renderClientScript;

        private const string DragOverlayElementHtmlTemplate = @"
<div id=""{0}___Drag"" style=""display:none; position:absolute; z-index: 32000; filter:alpha(opacity=75)""></div>";
        private const string ExportSensitiveDataWarningDeclaration = "ExportSensitiveDataWarningDeclaration";
        private const string CloseProviderWarningDeclaration = "CloseProviderWarningDeclaration";
        private const string DeleteWarningDeclaration = "DeleteWarningDeclaration";
        private const string StartupScript = @"
<script type=""text/javascript"">

__wpm = new WebPartManager();
__wpm.overlayContainerElement = {0};
__wpm.personalizationScopeShared = {1};

var zoneElement;
var zoneObject;
{2}
</script>
";
        private const string ZoneScript = @"
zoneElement = document.getElementById('{0}');
if (zoneElement != null) {{
    zoneObject = __wpm.AddZone(zoneElement, '{1}', {2}, {3}, '{4}');";

        private const string ZonePartScript = @"
    zoneObject.AddWebPart(document.getElementById('{0}'), {1}, {2});";

        private const string ZoneEndScript = @"
}";

        private const string AuthorizationFilterName = "AuthorizationFilter";
        private const string ImportErrorMessageName = "ImportErrorMessage";
        private const string ZoneIDName = "ZoneID";
        private const string ZoneIndexName = "ZoneIndex";

        internal const string ExportRootElement = "webParts";
        internal const string ExportPartElement = "webPart";
        internal const string ExportPartNamespaceAttribute = "xmlns";
        internal const string ExportPartNamespaceValue = "http://schemas.microsoft.com/WebPart/v3";
        internal const string ExportMetaDataElement = "metaData";
        internal const string ExportTypeElement = "type";
        internal const string ExportErrorMessageElement = "importErrorMessage";
        internal const string ExportDataElement = "data";
        internal const string ExportPropertiesElement = "properties";
        internal const string ExportPropertyElement = "property";
        internal const string ExportTypeNameAttribute = "name";
        internal const string ExportUserControlSrcAttribute = "src";
        internal const string ExportPropertyNameAttribute = "name";
        internal const string ExportGenericPartPropertiesElement = "genericWebPartProperties";
        internal const string ExportIPersonalizableElement = "ipersonalizable";
        internal const string ExportPropertyTypeAttribute = "type";
        internal const string ExportPropertyScopeAttribute = "scope";
        internal const string ExportPropertyNullAttribute = "null";

        private const string ExportTypeBool = "bool";
        private const string ExportTypeInt = "int";
        private const string ExportTypeChromeState = "chromestate";
        private const string ExportTypeChromeType = "chrometype";
        private const string ExportTypeColor = "color";
        private const string ExportTypeDateTime = "datetime";
        private const string ExportTypeDirection = "direction";
        private const string ExportTypeDouble = "double";
        private const string ExportTypeExportMode = "exportmode";
        private const string ExportTypeFontSize = "fontsize";
        private const string ExportTypeHelpMode = "helpmode";
        private const string ExportTypeObject = "object";
        private const string ExportTypeSingle = "single";
        private const string ExportTypeString = "string";
        private const string ExportTypeUnit = "unit";

        /// <devdoc>
        /// </devdoc>
        public WebPartManager() {
            _allowEventCancellation = true;
            _displayMode = BrowseDisplayMode;
            _webPartZones = new WebPartZoneCollection();
            _partAndChildControlIDs = new HybridDictionary(true /* caseInsensitive */);
            _zoneIDs = new HybridDictionary(true /* caseInsensitive */);
        }

        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public TransformerTypeCollection AvailableTransformers {
            get {
                if (_availableTransformers == null) {
                    _availableTransformers = CreateAvailableTransformers();
                }
                return _availableTransformers;
            }
        }

        [
        WebCategory("Behavior"),
        WebSysDefaultValue(SR.WebPartManager_DefaultCloseProviderWarning),
        WebSysDescription(SR.WebPartManager_CloseProviderWarning)
        ]
        public virtual string CloseProviderWarning {
            get {
                object o = ViewState["CloseProviderWarning"];
                return (o != null) ? (string)o : SR.GetString(SR.WebPartManager_DefaultCloseProviderWarning);
            }
            set {
                ViewState["CloseProviderWarning"] = value;
            }
        }

        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public WebPartConnectionCollection Connections {
            get {
                WebPartConnectionCollection connections = new WebPartConnectionCollection(this);
                if (_staticConnections != null) {
                    foreach (WebPartConnection connection in _staticConnections) {
                        if (!Internals.ConnectionDeleted(connection)) {
                            connections.Add(connection);
                        }
                    }
                }
                if (_dynamicConnections != null) {
                    foreach (WebPartConnection connection in _dynamicConnections) {
                        if (!Internals.ConnectionDeleted(connection)) {
                            connections.Add(connection);
                        }
                    }
                }
                connections.SetReadOnly(SR.WebPartManager_ConnectionsReadOnly);
                return connections;
            }
        }

        // Hide the Controls property from IntelliSense.  The developer should use the
        // WebParts property instead.
        [
        EditorBrowsable(EditorBrowsableState.Never),
        ]
        public override ControlCollection Controls {
            get {
                return base.Controls;
            }
        }

        [
        WebCategory("Behavior"),
        WebSysDefaultValue(SR.WebPartManager_DefaultDeleteWarning),
        WebSysDescription(SR.WebPartManager_DeleteWarning)
        ]
        public virtual string DeleteWarning {
            get {
                object o = ViewState["DeleteWarning"];
                return (o != null) ? (string)o : SR.GetString(SR.WebPartManager_DefaultDeleteWarning);
            }
            set {
                ViewState["DeleteWarning"] = value;
            }
        }

        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public virtual WebPartDisplayMode DisplayMode {
            get {
                return _displayMode;
            }
            set {
                if (value == null) {
                    throw new ArgumentNullException("value");
                }

                if (DisplayMode == value) {
                    return;
                }

                if (SupportedDisplayModes.Contains(value) == false) {
                    throw new ArgumentException(SR.GetString(SR.WebPartManager_InvalidDisplayMode), "value");
                }

                if (!value.IsEnabled(this)) {
                    throw new ArgumentException(SR.GetString(SR.WebPartManager_DisabledDisplayMode), "value");
                }

                WebPartDisplayModeCancelEventArgs dmce = new WebPartDisplayModeCancelEventArgs(value);
                OnDisplayModeChanging(dmce);

                if (_allowEventCancellation && dmce.Cancel) {
                    return;
                }

                // Custom display modes can take actions like this in the OnDisplayModeChanging method.
                // For example:
                // public override void OnDisplayModeChanging(WebPartDisplayModeCancelEventArgs e) {
                //     base.OnDisplayModeChanging(e);
                //     if (e.Cancel) return;
                //     if (DisplayMode == CustomDisplayMode) {
                //         // Take some actions and set e.Cancel=true if appropriate
                //     }
                // }

                // End web part connecting if necessary
                if ((DisplayMode == ConnectDisplayMode) && (SelectedWebPart != null)) {
                    EndWebPartConnecting();
                    if (SelectedWebPart != null) {
                        // WebPartConnectModeChanging event was cancelled
                        return;
                    }
                }

                // End web part editing if necessary
                if ((DisplayMode == EditDisplayMode) && (SelectedWebPart != null)) {
                    EndWebPartEditing();
                    if (SelectedWebPart != null) {
                        // WebPartEditModeChanging event was cancelled
                        return;
                    }
                }

                WebPartDisplayModeEventArgs dme = new WebPartDisplayModeEventArgs(DisplayMode);
                _displayMode = value;
                OnDisplayModeChanged(dme);
            }
        }

        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public WebPartDisplayModeCollection DisplayModes {
            get {
                if (_displayModes == null) {
                    _displayModes = CreateDisplayModes();
                    _displayModes.SetReadOnly(SR.WebPartManager_DisplayModesReadOnly);
                }

                return _displayModes;
            }
        }

        protected internal WebPartConnectionCollection DynamicConnections {
            get {
                if (_dynamicConnections == null) {
                    _dynamicConnections = new WebPartConnectionCollection(this);
                }
                return _dynamicConnections;
            }
        }

        [
        DefaultValue(true),
        WebCategory("Behavior"),
        WebSysDescription(SR.WebPartManager_EnableClientScript)
        ]
        public virtual bool EnableClientScript {
            get {
                object o = ViewState["EnableClientScript"];
                return (o != null) ? (bool)o : true;
            }
            set {
                ViewState["EnableClientScript"] = value;
            }
        }

        // Theming must be enabled, so the WebPart child controls have theming enabled
        [
        Browsable(false),
        DefaultValue(true),
        EditorBrowsable(EditorBrowsableState.Never),
        ]
        public override bool EnableTheming {
            get {
                return true;
            }
            set {
                throw new NotSupportedException(SR.GetString(SR.WebPartManager_CantSetEnableTheming));
            }
        }

        [
        WebCategory("Behavior"),
        WebSysDefaultValue(SR.WebPartChrome_ConfirmExportSensitive),
        WebSysDescription(SR.WebPartManager_ExportSensitiveDataWarning)
        ]
        public virtual string ExportSensitiveDataWarning {
            get {
                object o = ViewState["ExportSensitiveDataWarning"];
                return (o != null) ? (string)o : SR.GetString(SR.WebPartChrome_ConfirmExportSensitive);
            }
            set {
                ViewState["ExportSensitiveDataWarning"] = value;
            }
        }

        [
        EditorBrowsable(EditorBrowsableState.Never),
        ]
        protected WebPartManagerInternals Internals {
            get {
                if (_internals == null) {
                    _internals = new WebPartManagerInternals(this);
                }
                return _internals;
            }
        }

        /// <devdoc>
        /// </devdoc>
        protected virtual bool IsCustomPersonalizationStateDirty {
            get {
                return _hasDataChanged;
            }
        }

        // PermissionSet that allows only Execution and AspNetHostingPermissionLevel.Medium.
        // AspNetHostingPermissionLevel.Medium is needed to call BuildManager.GetType().
        // Used for during Import for type deserialization.
        protected virtual PermissionSet MediumPermissionSet {
            get {
                if (_mediumPermissionSet == null) {
                    _mediumPermissionSet = new PermissionSet(PermissionState.None);
                    _mediumPermissionSet.AddPermission(new SecurityPermission(SecurityPermissionFlag.Execution));
                    _mediumPermissionSet.AddPermission(new AspNetHostingPermission(AspNetHostingPermissionLevel.Medium));
                }
                return _mediumPermissionSet;
            }
        }

        // PermissionSet that allows only Execution and AspNetHostingPermissionLevel.Minimal.
        // Used for during Import for everything except type deserialization.
        protected virtual PermissionSet MinimalPermissionSet {
            get {
                if (_minimalPermissionSet == null) {
                    _minimalPermissionSet = new PermissionSet(PermissionState.None);
                    _minimalPermissionSet.AddPermission(new SecurityPermission(SecurityPermissionFlag.Execution));
                    _minimalPermissionSet.AddPermission(new AspNetHostingPermission(AspNetHostingPermissionLevel.Minimal));
                }
                return _minimalPermissionSet;
            }
        }

        /// <devdoc>
        /// </devdoc>
        [
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty),
        WebCategory("Behavior"),
        WebSysDescription(SR.WebPartManager_Personalization)
        ]
        public WebPartPersonalization Personalization {
            get {
                if (_personalization == null) {
                    _personalization = CreatePersonalization();
                }

                return _personalization;
            }
        }

        internal bool RenderClientScript {
            get {
                return _renderClientScript;
            }
        }

        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public WebPart SelectedWebPart {
            get {
                return _selectedWebPart;
            }
        }

        [
        Browsable(false),
        DefaultValue(""),
        EditorBrowsable(EditorBrowsableState.Never),
        ]
        public override string SkinID {
            get {
                return String.Empty;
            }
            set {
                throw new NotSupportedException(SR.GetString(SR.NoThemingSupport, this.GetType().Name));
            }
        }

        [
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        MergableProperty(false),
        PersistenceMode(PersistenceMode.InnerProperty),
        WebCategory("Behavior"),
        WebSysDescription(SR.WebPartManager_StaticConnections),
        ]
        public WebPartConnectionCollection StaticConnections {
            get {
                if (_staticConnections == null) {
                    _staticConnections = new WebPartConnectionCollection(this);
                }
                return _staticConnections;
            }
        }

        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public WebPartDisplayModeCollection SupportedDisplayModes {
            get {
                if (_supportedDisplayModes == null) {
                    _supportedDisplayModes = new WebPartDisplayModeCollection();

                    foreach (WebPartDisplayMode mode in DisplayModes) {
                        if (mode.AssociatedWithToolZone == false) {
                            _supportedDisplayModes.Add(mode);
                        }
                    }

                    _supportedDisplayModes.SetReadOnly(SR.WebPartManager_DisplayModesReadOnly);
                }
                return _supportedDisplayModes;
            }
        }

        // Only call PermitOnly() in legacy CAS mode.  In the v4 CAS model, calling PermitOnly() would prevent us from calling
        // Activator.CreateInstance() on types in App_Code (assuming it is non-APTCA). (Dev10 Bug 807117)
        private bool UsePermitOnly {
            get {
                if (!_usePermitOnly.HasValue) {
                    _usePermitOnly =  RuntimeConfig.GetAppConfig().Trust.LegacyCasModel;
                }
                return _usePermitOnly.Value;
            }
        }

        [
        Bindable(false),
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        EditorBrowsable(EditorBrowsableState.Never),
        ]
        public override bool Visible {
            get {
                // Even though we are a non-visual control, this returns true, because we want our
                // child controls (the WebParts) to be Visible.
                return true;
            }
            set {
                throw new NotSupportedException(SR.GetString(SR.ControlNonVisual, this.GetType().Name));
            }
        }

        /// <devdoc>
        /// All the WebParts on the page.
        /// </devdoc>
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public WebPartCollection WebParts {
            get {
                // PERF: Consider changing WebPartCollection so it just wraps the ControlCollection,
                // instead of copying the controls to a new collection.
                if (HasControls()) {
                    return new WebPartCollection(Controls);
                }
                else {
                    return new WebPartCollection();
                }
            }
        }

        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public WebPartZoneCollection Zones {
            get {
                return _webPartZones;
            }
        }

        [
        WebCategory("Action"),
        WebSysDescription(SR.WebPartManager_AuthorizeWebPart)
        ]
        public event WebPartAuthorizationEventHandler AuthorizeWebPart {
            add {
                Events.AddHandler(AuthorizeWebPartEvent, value);
            }
            remove {
                Events.RemoveHandler(AuthorizeWebPartEvent, value);
            }
        }

        [
        WebCategory("Action"),
        WebSysDescription(SR.WebPartManager_ConnectionsActivated)
        ]
        public event EventHandler ConnectionsActivated {
            add {
                Events.AddHandler(ConnectionsActivatedEvent, value);
            }
            remove {
                Events.RemoveHandler(ConnectionsActivatedEvent, value);
            }
        }

        [
        WebCategory("Action"),
        WebSysDescription(SR.WebPartManager_ConnectionsActivating)
        ]
        public event EventHandler ConnectionsActivating {
            add {
                Events.AddHandler(ConnectionsActivatingEvent, value);
            }
            remove {
                Events.RemoveHandler(ConnectionsActivatingEvent, value);
            }
        }

        [
        WebCategory("Action"),
        WebSysDescription(SR.WebPartManager_DisplayModeChanged)
        ]
        public event WebPartDisplayModeEventHandler DisplayModeChanged {
            add {
                Events.AddHandler(DisplayModeChangedEvent, value);
            }
            remove {
                Events.RemoveHandler(DisplayModeChangedEvent, value);
            }
        }

        [
        WebCategory("Action"),
        WebSysDescription(SR.WebPartManager_DisplayModeChanging)
        ]
        public event WebPartDisplayModeCancelEventHandler DisplayModeChanging {
            add {
                Events.AddHandler(DisplayModeChangingEvent, value);
            }
            remove {
                Events.RemoveHandler(DisplayModeChangingEvent, value);
            }
        }

        [
        WebCategory("Action"),
        WebSysDescription(SR.WebPartManager_SelectedWebPartChanged)
        ]
        public event WebPartEventHandler SelectedWebPartChanged {
            add {
                Events.AddHandler(SelectedWebPartChangedEvent, value);
            }
            remove {
                Events.RemoveHandler(SelectedWebPartChangedEvent, value);
            }
        }

        [
        WebCategory("Action"),
        WebSysDescription(SR.WebPartManager_SelectedWebPartChanging)
        ]
        public event WebPartCancelEventHandler SelectedWebPartChanging {
            add {
                Events.AddHandler(SelectedWebPartChangingEvent, value);
            }
            remove {
                Events.RemoveHandler(SelectedWebPartChangingEvent, value);
            }
        }

        [
        WebCategory("Action"),
        WebSysDescription(SR.WebPartManager_WebPartAdded)
        ]
        public event WebPartEventHandler WebPartAdded {
            add {
                Events.AddHandler(WebPartAddedEvent, value);
            }
            remove {
                Events.RemoveHandler(WebPartAddedEvent, value);
            }
        }

        [
        WebCategory("Action"),
        WebSysDescription(SR.WebPartManager_WebPartAdding)
        ]
        public event WebPartAddingEventHandler WebPartAdding {
            add {
                Events.AddHandler(WebPartAddingEvent, value);
            }
            remove {
                Events.RemoveHandler(WebPartAddingEvent, value);
            }
        }

        [
        WebCategory("Action"),
        WebSysDescription(SR.WebPartManager_WebPartClosed)
        ]
        public event WebPartEventHandler WebPartClosed {
            add {
                Events.AddHandler(WebPartClosedEvent, value);
            }
            remove {
                Events.RemoveHandler(WebPartClosedEvent, value);
            }
        }

        [
        WebCategory("Action"),
        WebSysDescription(SR.WebPartManager_WebPartClosing)
        ]
        public event WebPartCancelEventHandler WebPartClosing {
            add {
                Events.AddHandler(WebPartClosingEvent, value);
            }
            remove {
                Events.RemoveHandler(WebPartClosingEvent, value);
            }
        }

        [
        WebCategory("Action"),
        WebSysDescription(SR.WebPartManager_WebPartDeleted)
        ]
        public event WebPartEventHandler WebPartDeleted {
            add {
                Events.AddHandler(WebPartDeletedEvent, value);
            }
            remove {
                Events.RemoveHandler(WebPartDeletedEvent, value);
            }
        }

        [
        WebCategory("Action"),
        WebSysDescription(SR.WebPartManager_WebPartDeleting)
        ]
        public event WebPartCancelEventHandler WebPartDeleting {
            add {
                Events.AddHandler(WebPartDeletingEvent, value);
            }
            remove {
                Events.RemoveHandler(WebPartDeletingEvent, value);
            }
        }

        [
        WebCategory("Action"),
        WebSysDescription(SR.WebPartManager_WebPartMoved)
        ]
        public event WebPartEventHandler WebPartMoved {
            add {
                Events.AddHandler(WebPartMovedEvent, value);
            }
            remove {
                Events.RemoveHandler(WebPartMovedEvent, value);
            }
        }

        [
        WebCategory("Action"),
        WebSysDescription(SR.WebPartManager_WebPartMoving)
        ]
        public event WebPartMovingEventHandler WebPartMoving {
            add {
                Events.AddHandler(WebPartMovingEvent, value);
            }
            remove {
                Events.RemoveHandler(WebPartMovingEvent, value);
            }
        }

        [
        WebCategory("Action"),
        WebSysDescription(SR.WebPartManager_WebPartsConnected)
        ]
        public event WebPartConnectionsEventHandler WebPartsConnected {
            add {
                Events.AddHandler(WebPartsConnectedEvent, value);
            }
            remove {
                Events.RemoveHandler(WebPartsConnectedEvent, value);
            }
        }

        [
        WebCategory("Action"),
        WebSysDescription(SR.WebPartManager_WebPartsConnecting)
        ]
        public event WebPartConnectionsCancelEventHandler WebPartsConnecting {
            add {
                Events.AddHandler(WebPartsConnectingEvent, value);
            }
            remove {
                Events.RemoveHandler(WebPartsConnectingEvent, value);
            }
        }

        [
        WebCategory("Action"),
        WebSysDescription(SR.WebPartManager_WebPartsDisconnected)
        ]
        public event WebPartConnectionsEventHandler WebPartsDisconnected {
            add {
                Events.AddHandler(WebPartsDisconnectedEvent, value);
            }
            remove {
                Events.RemoveHandler(WebPartsDisconnectedEvent, value);
            }
        }

        [
        WebCategory("Action"),
        WebSysDescription(SR.WebPartManager_WebPartsDisconnecting)
        ]
        public event WebPartConnectionsCancelEventHandler WebPartsDisconnecting {
            add {
                Events.AddHandler(WebPartsDisconnectingEvent, value);
            }
            remove {
                Events.RemoveHandler(WebPartsDisconnectingEvent, value);
            }
        }

        protected virtual void ActivateConnections() {
            try {
                // ActivateConnections() is called as a result of no user action, so the events
                // should not be cancellable. (VSWhidbey 516012)
                _allowEventCancellation = false;
                foreach (WebPartConnection connection in ConnectionsToActivate()) {
                    connection.Activate();
                }
            }
            finally {
                _allowEventCancellation = true;
            }
        }

        // Called by WebPartManagerInternals
        internal void AddWebPart(WebPart webPart) {
            ((WebPartManagerControlCollection)Controls).AddWebPart(webPart);
        }

        private WebPart AddDynamicWebPartToZone(WebPart webPart, WebPartZoneBase zone, int zoneIndex) {
            Debug.Assert(Personalization.IsModifiable);

            // Zone should not be set on a dynamic web part being added to the page for the first time
            Debug.Assert(webPart.Zone == null);

            // Only add WebPart if IsAuthorized(webPart) == true
            if (!IsAuthorized(webPart)) {
                return null;
            }

            WebPart newWebPart = CopyWebPart(webPart);
            Internals.SetIsStatic(newWebPart, false);
            Internals.SetIsShared(newWebPart, Personalization.Scope == PersonalizationScope.Shared);

            AddWebPartToZone(newWebPart, zone, zoneIndex);
            Internals.AddWebPart(newWebPart);

            // We set the personalized properties on the added WebPart AFTER it has been added to the
            // control tree, since we want to exactly recreate the process the WebPart will go through
            // when it is added from Personalization.
            Personalization.CopyPersonalizationState(webPart, newWebPart);

            // Raise event at very end of Add method
            OnWebPartAdded(new WebPartEventArgs(newWebPart));

            return newWebPart;
        }

        // Returns the WebPart that was actually added.  For an existing Closed WebPart, this is a reference
        // to the webPart parameter.  For a new DynamicWebPart, this will be a copy of the webPart parameter.
        public WebPart AddWebPart(WebPart webPart, WebPartZoneBase zone, int zoneIndex) {
            Personalization.EnsureEnabled(/* ensureModifiable */ true);

            if (webPart == null) {
                throw new ArgumentNullException("webPart");
            }
            // Do not check that Controls.Contains(webPart), since this will be called on a WebPart
            // before it is added to the Controls collection.
            if (zone == null) {
                throw new ArgumentNullException("zone");
            }
            if (_webPartZones.Contains(zone) == false) {
                throw new ArgumentException(SR.GetString(SR.WebPartManager_MustRegister), "zone");
            }
            if (zoneIndex < 0) {
                throw new ArgumentOutOfRangeException("zoneIndex");
            }
            if (webPart.Zone != null && !webPart.IsClosed) {
                throw new ArgumentException(SR.GetString(SR.WebPartManager_AlreadyInZone), "webPart");
            }

            WebPartAddingEventArgs e = new WebPartAddingEventArgs(webPart, zone, zoneIndex);
            OnWebPartAdding(e);
            if (_allowEventCancellation && e.Cancel) {
                return null;
            }

            WebPart addedWebPart;

            // If a part is already in the controls collection, dynamic or static, just make it
            // not closed and add it to the specified zone
            if (Controls.Contains(webPart)) {
                addedWebPart = webPart;
                AddWebPartToZone(webPart, zone, zoneIndex);
                OnWebPartAdded(new WebPartEventArgs(addedWebPart));
            } else {
                addedWebPart = AddDynamicWebPartToZone(webPart, zone, zoneIndex);
                // OnWebPartAdded() is called by AddDynamicWebPartToZone
            }

#if DEBUG
            CheckPartZoneIndexes(zone);
#endif

            return addedWebPart;
        }

        /// <devdoc>
        /// Adds the part to the dictionary mapping zones to parts.
        /// </devdoc>
        private void AddWebPartToDictionary(WebPart webPart) {
            if (_partsForZone != null) {
                string zoneID = Internals.GetZoneID(webPart);
                if (!String.IsNullOrEmpty(zoneID)) {
                    SortedList partsForZone = (SortedList)(_partsForZone[zoneID]);
                    if (partsForZone == null) {
                        partsForZone = new SortedList(new WebPart.ZoneIndexComparer());
                        _partsForZone[zoneID] = partsForZone;
                    }
                    partsForZone.Add(webPart, null);
                }
            }
        }

        /// <devdoc>
        /// Adds a web part to a zone at the specified zoneIndex, and renumbers all the parts in the zone
        /// sequentially.
        /// </devdoc>
        private void AddWebPartToZone(WebPart webPart, WebPartZoneBase zone, int zoneIndex) {
            Debug.Assert(webPart.Zone == null || webPart.IsClosed);

            // All the parts for the zone
            IList allParts = GetAllWebPartsForZone(zone);

            // The parts for the zone that were actually rendered
            WebPartCollection renderedParts = GetWebPartsForZone(zone);

            // The zoneIndex parameter is the desired index in the renderedParts collection.
            // Calculate the destination index into the allParts collection. (VSWhidbey 77719)
            int allPartsDestinationIndex;
            if (zoneIndex < renderedParts.Count) {
                WebPart successor = renderedParts[zoneIndex];
                Debug.Assert(allParts.Contains(successor));
                allPartsDestinationIndex = allParts.IndexOf(successor);
            }
            else {
                allPartsDestinationIndex = allParts.Count;
            }

            // Renumber all parts in the zone, leaving room for the added part
            for (int i = 0; i < allPartsDestinationIndex; i++) {
                WebPart part = ((WebPart)allParts[i]);
                Internals.SetZoneIndex(part, i);
            }
            for (int i = allPartsDestinationIndex; i < allParts.Count; i++) {
                WebPart part = ((WebPart)allParts[i]);
                Internals.SetZoneIndex(part, i + 1);
            }

            // Set the part index and add to destination zone
            Internals.SetZoneIndex(webPart, allPartsDestinationIndex);
            Internals.SetZoneID(webPart, zone.ID);
            Internals.SetIsClosed(webPart, false);

            _hasDataChanged = true;

            AddWebPartToDictionary(webPart);
        }

        public virtual void BeginWebPartConnecting(WebPart webPart) {
            Personalization.EnsureEnabled(/* ensureModifiable */ true);

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

            if (webPart.IsClosed) {
                throw new ArgumentException(SR.GetString(SR.WebPartManager_CantBeginConnectingClosed), "webPart");
            }

            if (!Controls.Contains(webPart)) {
                throw new ArgumentException(SR.GetString(SR.UnknownWebPart), "webPart");
            }

            if (DisplayMode != ConnectDisplayMode) {
                throw new InvalidOperationException(SR.GetString(SR.WebPartManager_MustBeInConnect));
            }

            if (webPart == SelectedWebPart) {
                throw new ArgumentException(SR.GetString(SR.WebPartManager_AlreadyInConnect), "webPart");
            }

            WebPartCancelEventArgs ce = new WebPartCancelEventArgs(webPart);
            OnSelectedWebPartChanging(ce);
            if (_allowEventCancellation && ce.Cancel) {
                return;
            }

            if (SelectedWebPart != null) {
                EndWebPartConnecting();
                if (SelectedWebPart != null) {
                    // The ConnectModeChange was cancelled
                    return;
                }
            }

            SetSelectedWebPart(webPart);

            Internals.CallOnConnectModeChanged(webPart);

            OnSelectedWebPartChanged(new WebPartEventArgs(webPart));
        }

        public virtual void BeginWebPartEditing(WebPart webPart) {
            Personalization.EnsureEnabled(/* ensureModifiable */ true);

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

            if (webPart.IsClosed) {
                throw new ArgumentException(SR.GetString(SR.WebPartManager_CantBeginEditingClosed), "webPart");
            }

            if (!Controls.Contains(webPart)) {
                throw new ArgumentException(SR.GetString(SR.UnknownWebPart), "webPart");
            }

            if (DisplayMode != EditDisplayMode) {
                throw new InvalidOperationException(SR.GetString(SR.WebPartManager_MustBeInEdit));
            }

            if (webPart == SelectedWebPart) {
                throw new ArgumentException(SR.GetString(SR.WebPartManager_AlreadyInEdit), "webPart");
            }

            WebPartCancelEventArgs ce = new WebPartCancelEventArgs(webPart);
            OnSelectedWebPartChanging(ce);
            if (_allowEventCancellation && ce.Cancel) {
                return;
            }

            if (SelectedWebPart != null) {
                EndWebPartEditing();
                if (SelectedWebPart != null) {
                    // The EditModeChange was cancelled
                    return;
                }
            }

            SetSelectedWebPart(webPart);

            Internals.CallOnEditModeChanged(webPart);

            OnSelectedWebPartChanged(new WebPartEventArgs(webPart));
        }

#if DEBUG
        /// <devdoc>
        /// Checks that the web parts in a zone are numbered sequentially.  This invariant
        /// should hold at the exit of AddWebPart, CloseWebPart, DeleteWebPart, MoveWebPart, and RegisterZone.
        /// </devdoc>
        private void CheckPartZoneIndexes(WebPartZoneBase zone) {
            ICollection parts = GetAllWebPartsForZone(zone);
            int index = 0;
            foreach (WebPart part in parts) {
                if (part.ZoneIndex != index) {
                    System.Text.StringBuilder builder = new System.Text.StringBuilder();
                    builder.Append("Title\tZone\tZoneIndex");
                    foreach (WebPart part2 in Controls) {
                        string zoneTitle = (part2.Zone == null) ? "null" : part2.Zone.DisplayTitle;
                        builder.Append(part2.DisplayTitle + "\t" + zoneTitle + "\t" + part2.ZoneIndex);
                    }
                    Debug.Assert(false, builder.ToString());
                    return;
                }
                index++;
            }
        }
#endif // DEBUG

        protected virtual bool CheckRenderClientScript() {
            bool renderClientScript = false;

            if (EnableClientScript && Page != null) {
                HttpBrowserCapabilities browserCaps = Page.Request.Browser;

                // Win32 IE5.5+ and JScript 5.5+
                if (browserCaps.Win32 && (browserCaps.MSDomVersion.CompareTo(new Version(5, 5)) >= 0)) {
                    renderClientScript = true;
                }
            }

            return renderClientScript;
        }

        // When a Zone is deleted, any web parts in that zone should move to the page catalog.
        // VSWhidbey 77708
        private void CloseOrphanedParts() {
            // PERF: Use Controls instead of WebParts property, to avoid creating another collection
            if (HasControls()) {
                try {
                    // CloseOrphanedParts() is called as a result of no user action, so the events
                    // should not be cancellable. (VSWhidbey 516012)
                    _allowEventCancellation = false;
                    foreach (WebPart part in Controls) {
                        if (part.IsOrphaned) {
                            CloseWebPart(part);
                        }
                    }
                }
                finally {
                    _allowEventCancellation = true;
                }
            }
        }

        public bool CanConnectWebParts(WebPart provider, ProviderConnectionPoint providerConnectionPoint,
                                       WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint) {
            return CanConnectWebParts(provider, providerConnectionPoint, consumer, consumerConnectionPoint, null);
        }

        public virtual bool CanConnectWebParts(WebPart provider, ProviderConnectionPoint providerConnectionPoint,
                                               WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint,
                                               WebPartTransformer transformer) {
            return CanConnectWebPartsCore(provider, providerConnectionPoint, consumer, consumerConnectionPoint,
                                          transformer, false);
        }

        private bool CanConnectWebPartsCore(WebPart provider, ProviderConnectionPoint providerConnectionPoint,
                                            WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint,
                                            WebPartTransformer transformer, bool throwOnError) {
            if (!Personalization.IsModifiable) {
                if (throwOnError) {
                    // Will throw appropriate exception
                    Personalization.EnsureEnabled(/* ensureModifiable */ true);
                }
                else {
                    return false;
                }
            }

            if (provider == null) {
                throw new ArgumentNullException("provider");
            }
            if (!Controls.Contains(provider)) {
                throw new ArgumentException(SR.GetString(SR.UnknownWebPart), "provider");
            }

            if (consumer == null) {
                throw new ArgumentNullException("consumer");
            }
            if (!Controls.Contains(consumer)) {
                throw new ArgumentException(SR.GetString(SR.UnknownWebPart), "consumer");
            }

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

            Control providerControl = provider.ToControl();
            Control consumerControl = consumer.ToControl();

            if (providerConnectionPoint.ControlType != providerControl.GetType()) {
                throw new ArgumentException(SR.GetString(SR.WebPartManager_InvalidConnectionPoint), "providerConnectionPoint");
            }
            if (consumerConnectionPoint.ControlType != consumerControl.GetType()) {
                throw new ArgumentException(SR.GetString(SR.WebPartManager_InvalidConnectionPoint), "consumerConnectionPoint");
            }

            if (provider == consumer) {
                if (throwOnError) {
                    throw new InvalidOperationException(SR.GetString(SR.WebPartManager_CantConnectToSelf));
                }
                else {
                    return false;
                }
            }

            if (provider.IsClosed) {
                if (throwOnError) {
                    throw new InvalidOperationException(SR.GetString(SR.WebPartManager_CantConnectClosed, provider.ID));
                }
                else {
                    return false;
                }
            }

            if (consumer.IsClosed) {
                if (throwOnError) {
                    throw new InvalidOperationException(SR.GetString(SR.WebPartManager_CantConnectClosed, consumer.ID));
                }
                else {
                    return false;
                }
            }

            if (!providerConnectionPoint.GetEnabled(providerControl)) {
                if (throwOnError) {
                    throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_DisabledConnectionPoint, providerConnectionPoint.ID, provider.ID));
                }
                else {
                    return false;
                }
            }

            if (!consumerConnectionPoint.GetEnabled(consumerControl)) {
                if (throwOnError) {
                    throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_DisabledConnectionPoint, consumerConnectionPoint.ID, consumer.ID));
                }
                else {
                    return false;
                }
            }

            // Check AllowsMultipleConnections on each ConnectionPoint
            if (!providerConnectionPoint.AllowsMultipleConnections) {
                foreach (WebPartConnection c in Connections) {
                    if (c.Provider == provider && c.ProviderConnectionPoint == providerConnectionPoint) {
                        if (throwOnError) {
                            throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_Duplicate, providerConnectionPoint.ID, provider.ID));
                        }
                        else {
                            return false;
                        }
                    }
                }
            }

            if (!consumerConnectionPoint.AllowsMultipleConnections) {
                foreach (WebPartConnection c in Connections) {
                    if (c.Consumer == consumer && c.ConsumerConnectionPoint == consumerConnectionPoint) {
                        if (throwOnError) {
                            throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_Duplicate, consumerConnectionPoint.ID, consumer.ID));
                        }
                        else {
                            return false;
                        }
                    }
                }
            }

            if (transformer == null) {
                if (providerConnectionPoint.InterfaceType != consumerConnectionPoint.InterfaceType) {
                    if (throwOnError) {
                        throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_NoCommonInterface,
                            new string[] {providerConnectionPoint.DisplayName, provider.ID,
                                consumerConnectionPoint.DisplayName, consumer.ID}));
                    }
                    else {
                        return false;
                    }
                }

                ConnectionInterfaceCollection secondaryInterfaces = providerConnectionPoint.GetSecondaryInterfaces(providerControl);
                if (!consumerConnectionPoint.SupportsConnection(consumerControl, secondaryInterfaces)) {
                    if (throwOnError) {
                        throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_IncompatibleSecondaryInterfaces, new string[] {
                                consumerConnectionPoint.DisplayName, consumer.ID,
                                providerConnectionPoint.DisplayName, provider.ID}));
                    }
                    else {
                        return false;
                    }
                }
            }
            else {
                Type transformerType = transformer.GetType();

                if (!AvailableTransformers.Contains(transformerType)) {
                    throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_TransformerNotAvailable, transformerType.FullName));
                }

                // Check matching interfaces on connection points and transformer attribute.
                // Note that we require the connection interfaces to match exactly.  We do not match
                // a derived interface type.  This is because we want to simplify the interface matching
                // algorithm when transformers are involved.  If we allowed derived interfaces to match,
                // then we would to take into account the "closest" match if multiple transformers
                // have compatible interfaces.
                Type transformerConsumerType = WebPartTransformerAttribute.GetConsumerType(transformerType);
                Type transformerProviderType = WebPartTransformerAttribute.GetProviderType(transformerType);
                if (providerConnectionPoint.InterfaceType != transformerConsumerType) {
                    if (throwOnError) {
                        throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_IncompatibleProviderTransformer,
                            providerConnectionPoint.DisplayName, provider.ID, transformerType.FullName));
                    }
                    else {
                        return false;
                    }
                }
                if (transformerProviderType != consumerConnectionPoint.InterfaceType) {
                    if (throwOnError) {
                        throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_IncompatibleConsumerTransformer,
                            transformerType.FullName, consumerConnectionPoint.DisplayName, consumer.ID));
                    }
                    else {
                        return false;
                    }
                }

                // A transformer never provides any secondary interfaces
                if (!consumerConnectionPoint.SupportsConnection(consumerControl, ConnectionInterfaceCollection.Empty)) {
                    if (throwOnError) {
                        throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_ConsumerRequiresSecondaryInterfaces,
                            consumerConnectionPoint.DisplayName, consumer.ID));
                    }
                    else {
                        return false;
                    }
                }

            }

            return true;
        }

        public void CloseWebPart(WebPart webPart) {
            CloseOrDeleteWebPart(webPart, /* delete */ false);
        }

        private void CloseOrDeleteWebPart(WebPart webPart, bool delete) {
            Personalization.EnsureEnabled(/* ensureModifiable */ true);

            if (webPart == null) {
                throw new ArgumentNullException("webPart");
            }
            if (!Controls.Contains(webPart)) {
                throw new ArgumentException(SR.GetString(SR.UnknownWebPart), "webPart");
            }

            if (!delete && webPart.IsClosed) {
                // Throw an exception instead of just returning.  If the shared user and per user close
                // a WebPart at the same time, then the WebPartZoneBase should not call CloseWebPart
                // if the WebPart is now closed.
                throw new ArgumentException(SR.GetString(SR.WebPartManager_AlreadyClosed), "webPart");
            }

            if (delete) {
                if (webPart.IsStatic) {
                    // Can't delete static parts
                    throw new ArgumentException(SR.GetString(SR.WebPartManager_CantDeleteStatic), "webPart");
                }
                else if (webPart.IsShared && (Personalization.Scope == PersonalizationScope.User)) {
                    // Can't delete shared part in user scope
                    throw new ArgumentException(SR.GetString(SR.WebPartManager_CantDeleteSharedInUserScope), "webPart");
                }
            }

            WebPartCancelEventArgs ce = new WebPartCancelEventArgs(webPart);
            if (delete) {
                OnWebPartDeleting(ce);
            }
            else {
                OnWebPartClosing(ce);
            }
            if (_allowEventCancellation && ce.Cancel) {
                return;
            }

            if ((DisplayMode == ConnectDisplayMode) && (webPart == SelectedWebPart)) {
                EndWebPartConnecting();
                if (SelectedWebPart != null) {
                    // The ConnectModeChange was cancelled
                    return;
                }
            }

            // VSWhidbey 77768
            if ((DisplayMode == EditDisplayMode) && (webPart == SelectedWebPart)) {
                EndWebPartEditing();
                if (SelectedWebPart != null) {
                    // The EditModeChange was cancelled
                    return;
                }
            }

            if (delete) {
                Internals.CallOnDeleting(webPart);
            }
            else {
                Internals.CallOnClosing(webPart);
            }

#if DEBUG
            WebPartZoneBase zone = webPart.Zone;
#endif

            // If we are deleting a closed WebPart, it has already been removed from
            // its Zone, so there is no need to do it again.
            if (!webPart.IsClosed) {
                RemoveWebPartFromZone(webPart);
            }

            DisconnectWebPart(webPart);

            if (delete) {
                Internals.RemoveWebPart(webPart);

                // Raise the WebPartDeleted event after changing the WebPart properties
                // The WebPartDeleting event is raised before changing the WebPart properties
                OnWebPartDeleted(new WebPartEventArgs(webPart));
            }
            else {
                // Raise the WebPartClosed event after changing the WebPart properties
                // The WebPartClosing event is raised before changing the WebPart properties
                OnWebPartClosed(new WebPartEventArgs(webPart));
            }

#if DEBUG
            if (zone != null) {
                CheckPartZoneIndexes(zone);
            }
#endif
        }

        private WebPartConnection[] ConnectionsToActivate() {
            // PERF: We could implement this with a sorted list to simplify the code

            ArrayList connectionsToActivate = new ArrayList();

            // Contains the connection IDs we have already seen
            HybridDictionary connectionIDs = new HybridDictionary(true /* caseInsensitive */);

            WebPartConnection[] connections = new WebPartConnection[StaticConnections.Count + DynamicConnections.Count];
            StaticConnections.CopyTo(connections, 0);
            DynamicConnections.CopyTo(connections, StaticConnections.Count);
            foreach (WebPartConnection connection in connections) {
                ConnectionsToActivateHelper(connection, connectionIDs, connectionsToActivate);
            }

            // Check unshared connections for conflicts with shared connections
            // Maybe this should only be done in user scope
            WebPartConnection[] connectionsToActivateArray = (WebPartConnection[])connectionsToActivate.ToArray(typeof(WebPartConnection));
            foreach (WebPartConnection connection in connectionsToActivateArray) {
                if (connection.IsShared) {
                    continue;
                }

                ArrayList connectionsToDelete = new ArrayList();
                foreach (WebPartConnection otherConnection in connectionsToActivate) {
                    if (connection == otherConnection) {
                        continue;
                    }

                    if (otherConnection.IsShared && connection.ConflictsWith(otherConnection)) {
                        // Delete shared connection.
                        connectionsToDelete.Add(otherConnection);
                    }
                }

                foreach (WebPartConnection connectionToDelete in connectionsToDelete) {
                    DisconnectWebParts(connectionToDelete);
                    connectionsToActivate.Remove(connectionToDelete);
                }
            }

            // Check shared, nonstatic connections for conflicts with static connections
            connectionsToActivateArray = (WebPartConnection[])connectionsToActivate.ToArray(typeof(WebPartConnection));
            foreach (WebPartConnection connection in connectionsToActivateArray) {
                if (!connection.IsShared || connection.IsStatic) {
                    continue;
                }

                ArrayList connectionsToDelete = new ArrayList();
                foreach (WebPartConnection otherConnection in connectionsToActivate) {
                    if (connection == otherConnection) {
                        continue;
                    }

                    if (otherConnection.IsStatic && connection.ConflictsWith(otherConnection)) {
                        // Delete static connection.
                        connectionsToDelete.Add(otherConnection);
                    }
                }

                foreach (WebPartConnection connectionToDelete in connectionsToDelete) {
                    DisconnectWebParts(connectionToDelete);
                    connectionsToActivate.Remove(connectionToDelete);
                }
            }

            // Check all remaining connections for conflicts.  Any conflicts at this stage will
            // cause an error to be rendered in the consumer WebPart, and the conflicting connections
            // will not be activated.
            ArrayList finalConnectionsToActivate = new ArrayList();
            foreach (WebPartConnection connection in connectionsToActivate) {
                bool hasConflict = false;

                foreach (WebPartConnection otherConnection in connectionsToActivate) {
                    if (connection == otherConnection) {
                        continue;
                    }

                    if (connection.ConflictsWithConsumer(otherConnection)) {
                        connection.Consumer.SetConnectErrorMessage(SR.GetString(SR.WebPartConnection_Duplicate, connection.ConsumerConnectionPoint.DisplayName,
                                connection.Consumer.DisplayTitle));
                        hasConflict = true;
                    }

                    if (connection.ConflictsWithProvider(otherConnection)) {
                        connection.Consumer.SetConnectErrorMessage(SR.GetString(SR.WebPartConnection_Duplicate, connection.ProviderConnectionPoint.DisplayName,
                                connection.Provider.DisplayTitle));
                        hasConflict = true;
                    }
                }

                if (!hasConflict) {
                    finalConnectionsToActivate.Add(connection);
                }
            }

            // Don't allow the user to modify the StaticConnections collection after its connections have
            // been activated.  Use property instead of field to force creation of collection.
            StaticConnections.SetReadOnly(SR.WebPartManager_StaticConnectionsReadOnly);

            // The user can't directly change the DynamicConnections property since it is internal.
            // Make it read-only in case we have a bug and try to change it after activation.
            // We check the read-only status of this collection in ConnectWebParts() and DisconnectWebParts().
            DynamicConnections.SetReadOnly(SR.WebPartManager_DynamicConnectionsReadOnly);

            return (WebPartConnection[])finalConnectionsToActivate.ToArray(typeof(WebPartConnection));
        }

        // If we think we should activate the connection, adds it to the dictionary under the key
        // for its provider and consumer connection points.
        private void ConnectionsToActivateHelper(WebPartConnection connection, IDictionary connectionIDs,
                                                 ArrayList connectionsToActivate) {
            string connectionID = connection.ID;

            if (String.IsNullOrEmpty(connectionID)) {
                throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_NoID));
            }

            if (connectionIDs.Contains(connectionID)) {
                throw new InvalidOperationException(
                    SR.GetString(SR.WebPartManager_DuplicateConnectionID, connectionID));
            }
            connectionIDs.Add(connectionID, null);

            if (connection.Deleted) {
                return;
            }

            WebPart providerWebPart = connection.Provider;
            if (providerWebPart == null) {
                if (connection.IsStatic) {
                    // throw an exception, to alert the developer that his static connection is invalid
                    throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_NoProvider, connection.ProviderID));
                }
                else {
                    // Silently delete the connection, since this is a valid runtime scenario.
                    // A connected web part may have been deleted.
                    DisconnectWebParts(connection);
                    return;
                }
            }

            WebPart consumerWebPart = connection.Consumer;
            if (consumerWebPart == null) {
                if (connection.IsStatic) {
                    // throw an exception, to alert the developer that his static connection is invalid
                    throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_NoConsumer, connection.ConsumerID));
                }
                else {
                    // Silently delete the connection, since this is a valid runtime scenario.
                    // A connected web part may have been deleted.
                    DisconnectWebParts(connection);
                    return;
                }
            }

            // Do not activate connections involving ProxyWebParts
            if (providerWebPart is ProxyWebPart || consumerWebPart is ProxyWebPart) {
                return;
            }

            Control providerControl = providerWebPart.ToControl();
            Control consumerControl = consumerWebPart.ToControl();

            // Cannot connect a WebPart to itself
            if (providerControl == consumerControl) {
                throw new InvalidOperationException(SR.GetString(SR.WebPartManager_CantConnectToSelf));
            }

            ProviderConnectionPoint providerConnectionPoint = connection.ProviderConnectionPoint;
            if (providerConnectionPoint == null) {
                consumerWebPart.SetConnectErrorMessage(SR.GetString(SR.WebPartConnection_NoProviderConnectionPoint, connection.ProviderConnectionPointID,
                    providerWebPart.DisplayTitle));
                return;
            }
            // Don't need to check that providerConnectionPoint is enabled, since this will be checked
            // in WebPartConnection.Activate().

            ConsumerConnectionPoint consumerConnectionPoint = connection.ConsumerConnectionPoint;
            if (consumerConnectionPoint == null) {
                consumerWebPart.SetConnectErrorMessage(SR.GetString(SR.WebPartConnection_NoConsumerConnectionPoint, connection.ConsumerConnectionPointID,
                    consumerWebPart.DisplayTitle));
                return;
            }
            // Don't need to check that consumer ConnectionPoint is enabled, since this will be checked
            // in WebPartConnection.Activate().

            connectionsToActivate.Add(connection);
        }

        public WebPartConnection ConnectWebParts(WebPart provider, ProviderConnectionPoint providerConnectionPoint,
                                                 WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint) {
            return ConnectWebParts(provider, providerConnectionPoint, consumer, consumerConnectionPoint, null);
        }

        public virtual WebPartConnection ConnectWebParts(WebPart provider, ProviderConnectionPoint providerConnectionPoint,
                                                         WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint,
                                                         WebPartTransformer transformer) {
            CanConnectWebPartsCore(provider, providerConnectionPoint, consumer, consumerConnectionPoint,
                                   transformer, /*throwOnError*/ true);

            if (DynamicConnections.IsReadOnly) {
                throw new InvalidOperationException(SR.GetString(SR.WebPartManager_ConnectTooLate));
            }

            WebPartConnectionsCancelEventArgs ce = new WebPartConnectionsCancelEventArgs(
                provider, providerConnectionPoint, consumer, consumerConnectionPoint);
            OnWebPartsConnecting(ce);
            if (_allowEventCancellation && ce.Cancel) {
                return null;
            }

            Control providerControl = provider.ToControl();
            Control consumerControl = consumer.ToControl();

            WebPartConnection connection = new WebPartConnection();
            connection.ID = CreateDynamicConnectionID();
            connection.ProviderID = providerControl.ID;
            connection.ConsumerID = consumerControl.ID;
            connection.ProviderConnectionPointID = providerConnectionPoint.ID;
            connection.ConsumerConnectionPointID = consumerConnectionPoint.ID;

            if (transformer != null) {
                Internals.SetTransformer(connection, transformer);
            }

            Internals.SetIsShared(connection, Personalization.Scope == PersonalizationScope.Shared);
            Internals.SetIsStatic(connection, false);

            DynamicConnections.Add(connection);
            _hasDataChanged = true;

            OnWebPartsConnected(new WebPartConnectionsEventArgs(provider, providerConnectionPoint,
                                                                consumer, consumerConnectionPoint, connection));

            return connection;
        }

        // Returns a copy of the WebPart, with all the properties reset to their default value.
        // If the WebPart is a GenericWebPart, returns a copy of the GenericWebPart and a copy of the
        // ChildControl inside the GenericWebPart.  The ID of the new WebPart and ChildControl should
        // be set to a value obtained from CreateDynamicWebPartID.
        // Virtual because a derived WebPartManager will deserialize a WebPart from XML in this method.
        protected virtual WebPart CopyWebPart(WebPart webPart) {
            WebPart newWebPart;

            GenericWebPart genericWebPart = webPart as GenericWebPart;
            if (genericWebPart != null) {
                Control childControl = genericWebPart.ChildControl;
                VerifyType(childControl);
                Type childControlType = childControl.GetType();
                Control newChildControl = (Control)Internals.CreateObjectFromType(childControlType);
                newChildControl.ID = CreateDynamicWebPartID(childControlType);

                newWebPart = CreateWebPart(newChildControl);
            }
            else {
                VerifyType(webPart);
                newWebPart = (WebPart)Internals.CreateObjectFromType(webPart.GetType());
            }

            newWebPart.ID = CreateDynamicWebPartID(webPart.GetType());

            return newWebPart;
        }

        protected virtual TransformerTypeCollection CreateAvailableTransformers() {
            TransformerTypeCollection availableTransformers = new TransformerTypeCollection();

            WebPartsSection configSection = RuntimeConfig.GetConfig().WebParts;

            IDictionary transformers = configSection.Transformers.GetTransformerEntries();

            foreach (Type type in transformers.Values) {
                availableTransformers.Add(type);
            }

            return availableTransformers;
        }

        // Returns an array of ICollection objects.  The first is the ConsumerConnectionPoints, the
        // second is the ProviderConnectionPoints.
        private static ICollection[] CreateConnectionPoints(Type type) {
            ArrayList consumerConnectionPoints = new ArrayList();
            ArrayList providerConnectionPoints = new ArrayList();

            MethodInfo[] methods = type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
            foreach (MethodInfo method in methods) {

                // Create consumer connection points
                object[] consumerAttributes = method.GetCustomAttributes(typeof(ConnectionConsumerAttribute), true);
                // ConnectionConsumerAttribute.AllowMultiple is false
                Debug.Assert(consumerAttributes.Length == 0 || consumerAttributes.Length == 1);
                if (consumerAttributes.Length == 1) {
                    // Consumer signature: method is public, return type is void, takes one parameter
                    ParameterInfo[] parameters = method.GetParameters();
                    Type parameterType = null;
                    if (parameters.Length == 1) {
                        parameterType = parameters[0].ParameterType;
                    }

                    if (method.IsPublic && method.ReturnType == typeof(void) && parameterType != null) {
                        ConnectionConsumerAttribute attribute = consumerAttributes[0] as ConnectionConsumerAttribute;
                        String displayName = attribute.DisplayName;
                        String id = attribute.ID;
                        Type connectionPointType = attribute.ConnectionPointType;
                        bool allowsMultipleConnections = attribute.AllowsMultipleConnections;
                        ConsumerConnectionPoint connectionPoint;
                        if (connectionPointType == null) {
                            connectionPoint = new ConsumerConnectionPoint(method, parameterType, type,
                                                                          displayName, id, allowsMultipleConnections);
                        }
                        else {
                            // The ConnectionPointType is validated in the attribute property getter
                            Object[] args = new Object[] { method, parameterType, type, displayName, id, allowsMultipleConnections };
                            connectionPoint = (ConsumerConnectionPoint)Activator.CreateInstance(connectionPointType, args);
                        }
                        consumerConnectionPoints.Add(connectionPoint);
                    }
                    else {
                        throw new InvalidOperationException(SR.GetString(SR.WebPartManager_InvalidConsumerSignature, method.Name, type.FullName));
                    }
                }

                // Create provider connection points
                object[] providerAttributes = method.GetCustomAttributes(typeof(ConnectionProviderAttribute), true);
                // ConnectionProviderAttribute.AllowMultiple is false
                Debug.Assert(providerAttributes.Length == 0 || providerAttributes.Length == 1);
                if (providerAttributes.Length == 1) {
                    // Provider signature: method is public, return type is an object, and takes no parameters
                    Type returnType = method.ReturnType;
                    if (method.IsPublic && returnType != typeof(void) && method.GetParameters().Length == 0) {
                        ConnectionProviderAttribute attribute = providerAttributes[0] as ConnectionProviderAttribute;
                        String displayName = attribute.DisplayName;
                        String id = attribute.ID;
                        Type connectionPointType = attribute.ConnectionPointType;
                        bool allowsMultipleConnections = attribute.AllowsMultipleConnections;
                        ProviderConnectionPoint connectionPoint;
                        if (connectionPointType == null) {
                            connectionPoint = new ProviderConnectionPoint(method, returnType, type,
                                                                          displayName, id, allowsMultipleConnections);
                        }
                        else {
                            // The ConnectionPointType is validated in the attribute property getter
                            Object[] args = new Object[] { method, returnType, type, displayName, id, allowsMultipleConnections };
                            connectionPoint = (ProviderConnectionPoint)Activator.CreateInstance(connectionPointType, args);
                        }
                        providerConnectionPoints.Add(connectionPoint);
                    }
                    else {
                        throw new InvalidOperationException(SR.GetString(SR.WebPartManager_InvalidProviderSignature, method.Name, type.FullName));
                    }
                }
            }

            return new ICollection[] { new ConsumerConnectionPointCollection(consumerConnectionPoints),
                new ProviderConnectionPointCollection(providerConnectionPoints) };
        }

        protected sealed override ControlCollection CreateControlCollection() {
            return new WebPartManagerControlCollection(this);
        }

        /// <devdoc>
        /// Can be overridden by derived types, to add additional display modes.  Display modes
        /// should be added in the order they are to appear in the page menu.
        /// </devdoc>
        protected virtual WebPartDisplayModeCollection CreateDisplayModes() {
            WebPartDisplayModeCollection displayModes = new WebPartDisplayModeCollection();

            displayModes.Add(BrowseDisplayMode);
            displayModes.Add(CatalogDisplayMode);
            displayModes.Add(DesignDisplayMode);
            displayModes.Add(EditDisplayMode);
            displayModes.Add(ConnectDisplayMode);

            return displayModes;
        }

        private string CreateDisplayTitle(string title, WebPart webPart, int count) {
            string displayTitle = title;

            if (webPart.Hidden) {
                displayTitle = SR.GetString(SR.WebPart_HiddenFormatString, displayTitle);
            }

            if (webPart is ErrorWebPart) {
                displayTitle = SR.GetString(SR.WebPart_ErrorFormatString, displayTitle);
            }

            if (count != 0) {
                if (count < displayTitleSuffix.Length) {
                    displayTitle += displayTitleSuffix[count];
                }
                else {
                    displayTitle += " [" + count.ToString(CultureInfo.CurrentCulture) + "]";
                }
            }

            return displayTitle;
        }

        private IDictionary CreateDisplayTitles() {
            Hashtable displayTitles = new Hashtable();

            Hashtable titles = new Hashtable();
            foreach (WebPart part in Controls) {
                string title = part.Title;
                if (String.IsNullOrEmpty(title)) {
                    title = SR.GetString(SR.Part_Untitled);
                }

                if (part is UnauthorizedWebPart) {
                    displayTitles[part] = title;
                    continue;
                }

                ArrayList parts = (ArrayList)titles[title];
                if (parts == null) {
                    parts = new ArrayList();
                    titles[title] = parts;
                    displayTitles[part] = CreateDisplayTitle(title, part, 0);
                }
                else {
                    int count = parts.Count;
                    if (count == 1) {
                        WebPart firstPart = (WebPart)parts[0];
                        displayTitles[firstPart] = CreateDisplayTitle(title, firstPart, 1);
                    }
                    displayTitles[part] = CreateDisplayTitle(title, part, count + 1);
                }

                parts.Add(part);
            }

            return displayTitles;
        }

        protected virtual string CreateDynamicConnectionID() {
            Debug.Assert(Personalization.IsModifiable);
            // 
            int guidHash = Math.Abs(Guid.NewGuid().GetHashCode());
            return DynamicConnectionIDPrefix + guidHash.ToString(CultureInfo.InvariantCulture);
        }

        protected virtual string CreateDynamicWebPartID(Type webPartType) {
            if (webPartType == null) {
                throw new ArgumentNullException("webPartType");
            }

            Debug.Assert(Personalization.IsModifiable);

            // 

            int guidHash = Math.Abs(Guid.NewGuid().GetHashCode());
            string id = DynamicWebPartIDPrefix + guidHash.ToString(CultureInfo.InvariantCulture);

            if (Page != null && Page.Trace.IsEnabled) {
                id += webPartType.Name;
            }

            return id;
        }

        protected virtual ErrorWebPart CreateErrorWebPart(string originalID, string originalTypeName,
                                                          string originalPath, string genericWebPartID,
                                                          string errorMessage) {
            ErrorWebPart errorWebPart = new ErrorWebPart(originalID, originalTypeName, originalPath, genericWebPartID);
            errorWebPart.ErrorMessage = errorMessage;
            return errorWebPart;
        }

        /// <devdoc>
        /// </devdoc>
        protected virtual WebPartPersonalization CreatePersonalization() {
            return new WebPartPersonalization(this);
        }

        /// <devdoc>
        /// Wraps the control in a GenericWebPart, and returns the GenericWebPart.  Virtual so it can be
        /// overridden to use a derived type of GenericWebPart instead.  Needs to be public so it can
        /// be called by the page developer.
        /// </devdoc>
        public virtual GenericWebPart CreateWebPart(Control control) {
            return CreateWebPartStatic(control);
        }

        // Called by other WebParts classes to create a GenericWebPart, if they do not have
        // a reference to a WebPartManager (i.e. at design time).  This method centralizes
        // the creation of GenericWebParts.
        internal static GenericWebPart CreateWebPartStatic(Control control) {
            GenericWebPart genericWebPart = new GenericWebPart(control);
            
            // The ChildControl should be added to the GenericWebPart.Controls collection when CreateWebPart()
            // is called, instead of waiting until the GenericWebPart.Controls collection is accessed.
            // This is necessary since the caller has a direct reference to the ChildControl, and may
            // perform operations on the ChildControl that assume the ChildControl is parented.
            // (VSWhidbey 498039)
            genericWebPart.CreateChildControls();

            return genericWebPart;
        }

        public void DeleteWebPart(WebPart webPart) {
            CloseOrDeleteWebPart(webPart, /* delete */ true);
        }

        // Disconnects all connections involving the Web Part
        protected virtual void DisconnectWebPart(WebPart webPart) {
            try {
                // We cannot allow any of the WebPartsDisconnecting events to be cancelled, since we may have already
                // disconnected some connections before we hit the one that needs to be cancelled. (VSWhidbey 516012)
                _allowEventCancellation = false;
                foreach (WebPartConnection connection in Connections) {
                    if (connection.Provider == webPart || connection.Consumer == webPart) {
                        DisconnectWebParts(connection);
                    }
                }
            }
            finally {
                _allowEventCancellation = true;
            }
        }

        public virtual void DisconnectWebParts(WebPartConnection connection) {
            Personalization.EnsureEnabled(/* ensureModifiable */ true);

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

            Debug.Assert(!(StaticConnections.Contains(connection) && DynamicConnections.Contains(connection)));

            WebPart provider = connection.Provider;
            ProviderConnectionPoint providerConnectionPoint = connection.ProviderConnectionPoint;
            WebPart consumer = connection.Consumer;
            ConsumerConnectionPoint consumerConnectionPoint = connection.ConsumerConnectionPoint;

            WebPartConnectionsCancelEventArgs ce = new WebPartConnectionsCancelEventArgs(
                provider, providerConnectionPoint, consumer, consumerConnectionPoint, connection);
            OnWebPartsDisconnecting(ce);
            if (_allowEventCancellation && ce.Cancel) {
                return;
            }

            WebPartConnectionsEventArgs eventArgs = new WebPartConnectionsEventArgs(
                provider, providerConnectionPoint, consumer, consumerConnectionPoint);

            if (StaticConnections.Contains(connection)) {
                if (StaticConnections.IsReadOnly) {
                    throw new InvalidOperationException(SR.GetString(SR.WebPartManager_DisconnectTooLate));
                }
                if (Internals.ConnectionDeleted(connection)) {
                    throw new InvalidOperationException(SR.GetString(SR.WebPartManager_AlreadyDisconnected));
                }
                Internals.DeleteConnection(connection);
                _hasDataChanged = true;
                OnWebPartsDisconnected(eventArgs);
            }
            else if (DynamicConnections.Contains(connection)) {
                if (DynamicConnections.IsReadOnly) {
                    throw new InvalidOperationException(SR.GetString(SR.WebPartManager_DisconnectTooLate));
                }

                if (ShouldRemoveConnection(connection)) {
                    // Unshared dynamic connection should never be disabled
                    Debug.Assert(!Internals.ConnectionDeleted(connection));
                    DynamicConnections.Remove(connection);
                }
                else {
                    if (Internals.ConnectionDeleted(connection)) {
                        throw new InvalidOperationException(SR.GetString(SR.WebPartManager_AlreadyDisconnected));
                    }
                    Internals.DeleteConnection(connection);
                }
                _hasDataChanged = true;
                OnWebPartsDisconnected(eventArgs);
            }
            else {
                throw new ArgumentException(SR.GetString(SR.WebPartManager_UnknownConnection), "connection");
            }
        }

        public virtual void EndWebPartConnecting() {
            Personalization.EnsureEnabled(/* ensureModifiable */ true);

            WebPart selectedWebPart = SelectedWebPart;

            if (selectedWebPart == null) {
                throw new InvalidOperationException(SR.GetString(SR.WebPartManager_NoSelectedWebPartConnect));
            }

            WebPartCancelEventArgs ce = new WebPartCancelEventArgs(selectedWebPart);
            OnSelectedWebPartChanging(ce);

            if (_allowEventCancellation && ce.Cancel) {
                return;
            }

            SetSelectedWebPart(null);

            Internals.CallOnConnectModeChanged(selectedWebPart);

            // The EventArg should always contain the new SelectedWebPart, so it should contain null
            // when we are ending connecting.
            OnSelectedWebPartChanged(new WebPartEventArgs(null));
        }

        public virtual void EndWebPartEditing() {
            Personalization.EnsureEnabled(/* ensureModifiable */ true);

            WebPart selectedWebPart = SelectedWebPart;

            if (selectedWebPart == null) {
                throw new InvalidOperationException(SR.GetString(SR.WebPartManager_NoSelectedWebPartEdit));
            }

            WebPartCancelEventArgs ce = new WebPartCancelEventArgs(selectedWebPart);
            OnSelectedWebPartChanging(ce);

            if (_allowEventCancellation && ce.Cancel) {
                return;
            }

            SetSelectedWebPart(null);

            Internals.CallOnEditModeChanged(selectedWebPart);

            // The EventArg should always contain the new SelectedWebPart, so it should contain null
            // when we are ending editing.
            OnSelectedWebPartChanged(new WebPartEventArgs(null));
        }

        public virtual void ExportWebPart(WebPart webPart, XmlWriter writer) {
//            Personalization.EnsureEnabled(/* ensureModifiable */ false);

            if (webPart == null) {
                throw new ArgumentNullException("webPart");
            }
            if (!Controls.Contains(webPart)) {
                throw new ArgumentException(SR.GetString(SR.UnknownWebPart), "webPart");
            }

            if (writer == null) {
                throw new ArgumentNullException("writer");
            }
            if (webPart.ExportMode == WebPartExportMode.None) {
                throw new ArgumentException(SR.GetString(SR.WebPartManager_PartNotExportable), "webPart");
            }
            bool excludeSensitive = (webPart.ExportMode == WebPartExportMode.NonSensitiveData &&
                !(Personalization.Scope == PersonalizationScope.Shared));

            // Write the root elements
            writer.WriteStartElement(ExportRootElement);
            writer.WriteStartElement(ExportPartElement);
            writer.WriteAttributeString(ExportPartNamespaceAttribute, ExportPartNamespaceValue);
            // Write metadata
            writer.WriteStartElement(ExportMetaDataElement);
            writer.WriteStartElement(ExportTypeElement);
            Control control = webPart.ToControl();
            UserControl userControl = control as UserControl;
            if (userControl != null) {
                writer.WriteAttributeString(ExportUserControlSrcAttribute, userControl.AppRelativeVirtualPath);
            }
            else {
                writer.WriteAttributeString(ExportTypeNameAttribute, WebPartUtil.SerializeType(control.GetType()));
            }
            writer.WriteEndElement(); //type
            writer.WriteElementString(ExportErrorMessageElement, webPart.ImportErrorMessage);
            writer.WriteEndElement(); //metadata
            // Write the data
            writer.WriteStartElement(ExportDataElement);
            // We get the personalization data for the current page personalization mode
            IDictionary propBag = PersonalizableAttribute.GetPersonalizablePropertyValues(webPart, PersonalizationScope.Shared, excludeSensitive);

            writer.WriteStartElement(ExportPropertiesElement);

            // Special case GenericWebPart
            GenericWebPart genericWebPart = webPart as GenericWebPart;

            if (genericWebPart != null) {

                // Export IPersonalizable user control data first
                ExportIPersonalizable(writer, control, excludeSensitive);

                IDictionary controlData = PersonalizableAttribute.GetPersonalizablePropertyValues(control,
                                                                                                  PersonalizationScope.Shared,
                                                                                                  excludeSensitive);
                ExportToWriter(controlData, writer);
                writer.WriteEndElement(); //properties
                writer.WriteStartElement(ExportGenericPartPropertiesElement);
                // Export IPersonalizable part data first
                ExportIPersonalizable(writer, webPart, excludeSensitive);
                ExportToWriter(propBag, writer);
            }
            else {
                // Export IPersonalizable part data first
                ExportIPersonalizable(writer, webPart, excludeSensitive);
                ExportToWriter(propBag, writer);
            }
            writer.WriteEndElement(); //properties or genericWebPartProperties
            writer.WriteEndElement(); //data
            writer.WriteEndElement(); //webpart
            writer.WriteEndElement(); //webparts
        }

        private void ExportIPersonalizable(XmlWriter writer, Control control, bool excludeSensitive) {
            IPersonalizable personalizableControl = control as IPersonalizable;
            if (personalizableControl != null) {
                PersonalizationDictionary personalizableData = new PersonalizationDictionary();
                personalizableControl.Save(personalizableData);
                if (personalizableData.Count > 0) {
                    writer.WriteStartElement(ExportIPersonalizableElement);
                    ExportToWriter(personalizableData, writer, /* isIPersonalizable */ true, excludeSensitive);
                    writer.WriteEndElement(); // ipersonalizable
                }
            }
        }

        private static void ExportProperty(XmlWriter writer, string name, string value, Type type,
            PersonalizationScope scope, bool isIPersonalizable) {

            writer.WriteStartElement(ExportPropertyElement);
            writer.WriteAttributeString(ExportPropertyNameAttribute, name);
            writer.WriteAttributeString(ExportPropertyTypeAttribute, GetExportName(type));
            if (isIPersonalizable) {
                writer.WriteAttributeString(ExportPropertyScopeAttribute, scope.ToString());
            }
            if (value == null) {
                writer.WriteAttributeString(ExportPropertyNullAttribute, "true");
            }
            else {
                writer.WriteString(value);
            }
            writer.WriteEndElement(); //property
        }

        private void ExportToWriter(IDictionary propBag, XmlWriter writer) {
            ExportToWriter(propBag, writer, false, false);
        }

        private void ExportToWriter(IDictionary propBag,
                                    XmlWriter writer,
                                    bool isIPersonalizable,
                                    bool excludeSensitive) {
            // We only honor excludeSensitive if isIpersonalizable is true.
            Debug.Assert((!excludeSensitive) || isIPersonalizable);

            // Work on each property in the persomalization data
            foreach(DictionaryEntry entry in propBag) {
                string name = (string)entry.Key;
                if (name == AuthorizationFilterName || name == ImportErrorMessageName) {
                    continue;
                }

                PropertyInfo pi = null;
                object val = null;
                Pair data = entry.Value as Pair;
                PersonalizationScope scope = PersonalizationScope.User;
                // We expect a pair if not exporting types
                // (which happens only for non-IPersonalizable data)
                if (isIPersonalizable == false && data != null) {
                    pi = (PropertyInfo)data.First;
                    val = data.Second;
                }
                else if (isIPersonalizable) {
                    PersonalizationEntry personalizationEntry = entry.Value as PersonalizationEntry;
                    if (personalizationEntry != null &&
                        (Personalization.Scope == PersonalizationScope.Shared ||
                        personalizationEntry.Scope == PersonalizationScope.User)) {

                        val = personalizationEntry.Value;
                        scope = personalizationEntry.Scope;
                    }
                    if (excludeSensitive && personalizationEntry.IsSensitive) {
                        continue;
                    }
                }
                // we get the type from the PropertyInfo if we have it, or from the value if it's not null, or we use object.
                Type valType = ((pi != null) ? pi.PropertyType : ((val != null) ? val.GetType() : typeof(object)));

                string exportString;
                if (ShouldExportProperty(pi, valType, val, out exportString)) {
                    ExportProperty(writer, name, exportString, valType, scope, isIPersonalizable);
                }
            }
        }

        [
        EditorBrowsable(EditorBrowsableState.Never),
        ]
        public override void Focus() {
            throw new NotSupportedException(SR.GetString(SR.NoFocusSupport, this.GetType().Name));
        }

        /// <devdoc>
        /// Returns all the web parts in a zone, excluding closed web parts.
        /// Since this is only a private method, return an IList instead of a WebPartCollection
        /// for better performance.
        /// </devdoc>
        private IList GetAllWebPartsForZone(WebPartZoneBase zone) {
            if (_partsForZone == null) {
                _partsForZone = new HybridDictionary(true /* caseInsensitive */);
                foreach (WebPart part in Controls) {
                    if (!part.IsClosed) {
                        string zoneID = Internals.GetZoneID(part);
                        Debug.Assert(!String.IsNullOrEmpty(zoneID));
                        if (!String.IsNullOrEmpty(zoneID)) {
                            SortedList partsForZone = (SortedList)_partsForZone[zoneID];
                            if (partsForZone == null) {
                                partsForZone = new SortedList(new WebPart.ZoneIndexComparer());
                                _partsForZone[zoneID] = partsForZone;
                            }
                            partsForZone.Add(part, null);
                        }
                    }
                }
            }

            SortedList parts = (SortedList)_partsForZone[zone.ID];
            if (parts == null) {
                parts = new SortedList();
            }

            return parts.GetKeyList();
        }

        private static ICollection[] GetConnectionPoints(Type type) {
            if (ConnectionPointsCache == null) {
                // I don't think there is a race condition here.  Even if multiple threads enter this block
                // at the same time, the worst thing that can happen is that the ConnectionPointsCache gets
                // replaced by a new Hashtable(), and existing entries will need to be recomputed.
                // There is no way for the ConnectionPointsCache to become null.
                ConnectionPointsCache = Hashtable.Synchronized(new Hashtable());
            }

            // DevDiv Bugs 38677: Cache by culture and type as it may vary by culture within this app
            ConnectionPointKey connectionPointKey = new ConnectionPointKey(type, CultureInfo.CurrentCulture, CultureInfo.CurrentUICulture);

            ICollection[] connectionPoints = (ICollection[])ConnectionPointsCache[connectionPointKey];
            if (connectionPoints == null) {
                connectionPoints = CreateConnectionPoints(type);
                ConnectionPointsCache[connectionPointKey] = connectionPoints;
            }

            return connectionPoints;
        }

        internal ConsumerConnectionPoint GetConsumerConnectionPoint(WebPart webPart, string connectionPointID) {
            ConsumerConnectionPointCollection points = GetConsumerConnectionPoints(webPart);
            if (points != null && points.Count > 0) {
                return points[connectionPointID];
            }
            else {
                return null;
            }
        }

        public virtual ConsumerConnectionPointCollection GetConsumerConnectionPoints(WebPart webPart) {
            if (webPart == null) {
                throw new ArgumentNullException("webPart");
            }
            // Do not check that Controls.Contains(webPart), since this may be called on a WebPart
            // outside of a Zone.  Also, this method shouldn't really care whether the WebPart is
            // inside the WebPartManager.

            return GetConsumerConnectionPoints(webPart.ToControl().GetType());
        }

        private static ConsumerConnectionPointCollection GetConsumerConnectionPoints(Type type) {
            ICollection[] connectionPoints = GetConnectionPoints(type);
            return (ConsumerConnectionPointCollection)connectionPoints[0];
        }

        public static WebPartManager GetCurrentWebPartManager(Page page) {
            if (page == null) {
                throw new ArgumentNullException("page");
            }

            return page.Items[typeof(WebPartManager)] as WebPartManager;
        }

        // Before PreRender, return String.Empty.
        // On first call to this function after PreRender, compute DisplayTitle for all WebParts
        // and save it in a dictionary.  WebPart.DisplayTitle is nonvirtual and calls this method every time.
        // A derived WebPartManager can override this method to compute and store DisplayTitle any way it
        // sees fit.  It could compute the values sooner than PreRender.
        protected internal virtual string GetDisplayTitle(WebPart webPart) {
            if (webPart == null) {
                throw new ArgumentNullException("webPart");
            }
            if (!Controls.Contains(webPart)) {
                throw new ArgumentException(SR.GetString(SR.UnknownWebPart), "webPart");
            }

            if (!_allowCreateDisplayTitles) {
                return String.Empty;
            }

            if (_displayTitles == null) {
                _displayTitles = CreateDisplayTitles();
            }

            string displayTitle = (string)_displayTitles[webPart];
            Debug.Assert(!String.IsNullOrEmpty(displayTitle));
            return displayTitle;
        }

        private static ICollection GetEnabledConnectionPoints(ICollection connectionPoints, WebPart webPart) {
            Control control = webPart.ToControl();
            ArrayList enabledPoints = new ArrayList();
            foreach (ConnectionPoint point in connectionPoints) {
                if (point.GetEnabled(control)) {
                    enabledPoints.Add(point);
                }
            }
            return enabledPoints;
        }

        internal ConsumerConnectionPointCollection GetEnabledConsumerConnectionPoints(WebPart webPart) {
            ICollection enabledPoints = GetEnabledConnectionPoints(GetConsumerConnectionPoints(webPart), webPart);
            return new ConsumerConnectionPointCollection(enabledPoints);
        }

        internal ProviderConnectionPointCollection GetEnabledProviderConnectionPoints(WebPart webPart) {
            ICollection enabledPoints = GetEnabledConnectionPoints(GetProviderConnectionPoints(webPart), webPart);
            return new ProviderConnectionPointCollection(enabledPoints);
        }

        public string GetExportUrl(WebPart webPart) {
            string personalizationScope =
                (Personalization.Scope == PersonalizationScope.Shared) ? "&scope=shared" : String.Empty;
            string queryString = Page.Request.QueryStringText;

            return Page.Request.FilePath + "?" + Page.WebPartExportID + "=true&webPart=" +
                HttpUtility.UrlEncode(webPart.ID) +
                (!String.IsNullOrEmpty(queryString) ?
                    "&query=" + HttpUtility.UrlEncode(queryString) :
                    String.Empty) +
                personalizationScope;
        }

        private static Type GetExportType(string name) {
            switch (name) {
                case ExportTypeString:
                    return typeof(string);
                case ExportTypeInt:
                    return typeof(int);
                case ExportTypeBool:
                    return typeof(bool);
                case ExportTypeDouble:
                    return typeof(double);
                case ExportTypeSingle:
                    return typeof(Single);
                case ExportTypeDateTime:
                    return typeof(DateTime);
                case ExportTypeColor:
                    return typeof(Color);
                case ExportTypeUnit:
                    return typeof(Unit);
                case ExportTypeFontSize:
                    return typeof(FontSize);
                case ExportTypeDirection:
                    return typeof(ContentDirection);
                case ExportTypeHelpMode:
                    return typeof(WebPartHelpMode);
                case ExportTypeChromeState:
                    return typeof(PartChromeState);
                case ExportTypeChromeType:
                    return typeof(PartChromeType);
                case ExportTypeExportMode:
                    return typeof(WebPartExportMode);
                case ExportTypeObject:
                    return typeof(object);
                default:
                    return WebPartUtil.DeserializeType(name, false);
            }
        }

        private static string GetExportName(Type type) {
            if (type == typeof(string)) {
                return ExportTypeString;
            }
            else if (type == typeof(int)) {
                return ExportTypeInt;
            }
            else if (type == typeof(bool)) {
                return ExportTypeBool;
            }
            else if (type == typeof(double)) {
                return ExportTypeDouble;
            }
            else if (type == typeof(Single)) {
                return ExportTypeSingle;
            }
            else if (type == typeof(DateTime)) {
                return ExportTypeDateTime;
            }
            else if (type == typeof(Color)) {
                return ExportTypeColor;
            }
            else if (type == typeof(Unit)) {
                return ExportTypeUnit;
            }
            else if (type == typeof(FontSize)) {
                return ExportTypeFontSize;
            }
            else if (type == typeof(ContentDirection)) {
                return ExportTypeDirection;
            }
            else if (type == typeof(WebPartHelpMode)) {
                return ExportTypeHelpMode;
            }
            else if (type == typeof(PartChromeState)) {
                return ExportTypeChromeState;
            }
            else if (type == typeof(PartChromeType)) {
                return ExportTypeChromeType;
            }
            else if (type == typeof(WebPartExportMode)) {
                return ExportTypeExportMode;
            }
            else if (type == typeof(object)) {
                return ExportTypeObject;
            }
            else {
                return type.AssemblyQualifiedName;
            }
        }

        /// <devdoc>
        /// Used by the page developer to get a reference to the WebPart that contains a control
        /// placed in a WebPartZone.  Returns null if the control is not inside a WebPart.
        /// </devdoc>
        public GenericWebPart GetGenericWebPart(Control control) {
             if (control == null) {
                 throw new ArgumentNullException("control");
             }

             // PERF: First check the parent of the control, before looping through all GenericWebParts
             Control parent = control.Parent;
             GenericWebPart genericParent = parent as GenericWebPart;
             if (genericParent != null && genericParent.ChildControl == control) {
                 return genericParent;
             }
             else {
                 foreach (WebPart part in Controls) {
                     GenericWebPart genericPart = part as GenericWebPart;
                     if (genericPart != null && genericPart.ChildControl == control) {
                         return genericPart;
                     }
                 }
             }

             return null;
        }

        internal ProviderConnectionPoint GetProviderConnectionPoint(WebPart webPart, string connectionPointID) {
            ProviderConnectionPointCollection points = GetProviderConnectionPoints(webPart);
            if (points != null && points.Count > 0) {
                return points[connectionPointID];
            }
            else {
                return null;
            }
        }

        public virtual ProviderConnectionPointCollection GetProviderConnectionPoints(WebPart webPart) {
            if (webPart == null) {
                throw new ArgumentNullException("webPart");
            }
            // Do not check that Controls.Contains(webPart), since this may be called on a WebPart
            // outside of a Zone.  Also, this method shouldn't really care whether the WebPart is
            // inside the WebPartManager.

            return GetProviderConnectionPoints(webPart.ToControl().GetType());
        }

        private static ProviderConnectionPointCollection GetProviderConnectionPoints(Type type) {
            ICollection[] connectionPoints = GetConnectionPoints(type);
            return (ProviderConnectionPointCollection)connectionPoints[1];
        }

        /// <devdoc>
        /// Returns the web parts that should currently be rendered by the zone.  It is important that
        /// this method filter out any web parts that will not be rendered by the zone, otherwise
        /// the AddWebPart method will not work correctly (VSWhidbey 77719)
        /// </devdoc>
        internal WebPartCollection GetWebPartsForZone(WebPartZoneBase zone) {
            if (zone == null) {
                throw new ArgumentNullException("zone");
            }
            if (_webPartZones.Contains(zone) == false) {
                throw new ArgumentException(SR.GetString(SR.WebPartManager_MustRegister), "zone");
            }

            IList allWebPartsForZone = GetAllWebPartsForZone(zone);
            WebPartCollection webParts = new WebPartCollection();

            if (allWebPartsForZone.Count > 0) {
                foreach (WebPart part in allWebPartsForZone) {
                    if (ShouldRenderWebPartInZone(part, zone)) {
                        webParts.Add(part);
                    }
                }
            }

            return webParts;
        }

        /// <devdoc>
        /// If the WebPart is a consumer on the given connection point, returns the corresponding connection.
        /// Else, returns null.
        /// </devdoc>
        internal WebPartConnection GetConnectionForConsumer(WebPart consumer, ConsumerConnectionPoint connectionPoint) {
            ConsumerConnectionPoint actualConnectionPoint = connectionPoint;
            // 
            if (connectionPoint == null) {
                actualConnectionPoint = GetConsumerConnectionPoint(consumer, null);
            }

            // PERF: Use the StaticConnections and DynamicConnections collections separately, instead
            // of using the Connections property which is created on every call.
            foreach (WebPartConnection connection in StaticConnections) {
                if (!Internals.ConnectionDeleted(connection) && connection.Consumer == consumer) {
                    ConsumerConnectionPoint c =
                        GetConsumerConnectionPoint(consumer, connection.ConsumerConnectionPointID);
                    if (c == actualConnectionPoint) {
                        return connection;
                    }
                }
            }

            foreach (WebPartConnection connection in DynamicConnections) {
                if (!Internals.ConnectionDeleted(connection) && connection.Consumer == consumer) {
                    ConsumerConnectionPoint c =
                        GetConsumerConnectionPoint(consumer, connection.ConsumerConnectionPointID);
                    if (c == actualConnectionPoint) {
                        return connection;
                    }
                }
            }

            return null;
        }

        /// <devdoc>
        /// If the WebPart is a provider on the given connection point, returns the corresponding connection.
        /// Else, returns null.
        /// </devdoc>
        internal WebPartConnection GetConnectionForProvider(WebPart provider, ProviderConnectionPoint connectionPoint) {
            ProviderConnectionPoint actualConnectionPoint = connectionPoint;
            if (connectionPoint == null) {
                actualConnectionPoint = GetProviderConnectionPoint(provider, null);
            }

            // PERF: Use the StaticConnections and DynamicConnections collections separately, instead
            // of using the Connections property which is created on every call.
            foreach (WebPartConnection connection in StaticConnections) {
                if (!Internals.ConnectionDeleted(connection) && connection.Provider == provider) {
                    ProviderConnectionPoint c =
                        GetProviderConnectionPoint(provider, connection.ProviderConnectionPointID);
                    if (c == actualConnectionPoint) {
                        return connection;
                    }
                }
            }

            foreach (WebPartConnection connection in DynamicConnections) {
                if (!Internals.ConnectionDeleted(connection) && connection.Provider == provider) {
                    ProviderConnectionPoint c =
                        GetProviderConnectionPoint(provider, connection.ProviderConnectionPointID);
                    if (c == actualConnectionPoint) {
                        return connection;
                    }
                }
            }

            return null;
        }

        private static void ImportReadTo(XmlReader reader, string elementToFind) {
            while (reader.Name != elementToFind) {
                if (!reader.Read()) {
                    throw new XmlException();
                }
            }
        }

        private static void ImportReadTo(XmlReader reader, string elementToFindA, string elementToFindB) {
            while (reader.Name != elementToFindA && reader.Name != elementToFindB) {
                if (!reader.Read()) {
                    throw new XmlException();
                }
            }
        }

        private static void ImportSkipTo(XmlReader reader, string elementToFind) {
            while (reader.Name != elementToFind) {
                reader.Skip();
                if (reader.EOF) {
                    throw new XmlException();
                }
            }
        }

        /// <devdoc>
        /// Never throws except for null arguments. Returns an error message in the out parameter instead.
        /// [Microsoft] I investigated whether this could be refactored to share common code with
        ///           LoadDynamicWebPart(), but it seems the methods are too different.
        /// </devdoc>
        public virtual WebPart ImportWebPart(XmlReader reader, out string errorMessage) {
            Personalization.EnsureEnabled(/* ensureModifiable */ true);

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

            bool permitOnly = false;

            if (UsePermitOnly) {
                MinimalPermissionSet.PermitOnly();
                permitOnly = true;
            }
            string importErrorMessage = string.Empty;
            // Extra try-catch block to prevent elevation of privilege attack via exception filter
            try {
                try {
                    // Get to the metadata
                    reader.MoveToContent();
                    reader.ReadStartElement(ExportRootElement);
                    ImportSkipTo(reader, ExportPartElement);
                    // Check the version on the webPart element
                    string version = reader.GetAttribute(ExportPartNamespaceAttribute);
                    if (String.IsNullOrEmpty(version)) {
                        errorMessage = SR.GetString(SR.WebPart_ImportErrorNoVersion);
                        return null;
                    }
                    if (!String.Equals(version, ExportPartNamespaceValue, StringComparison.OrdinalIgnoreCase)) {
                        errorMessage = SR.GetString(SR.WebPart_ImportErrorInvalidVersion);
                        return null;
                    }
                    ImportReadTo(reader, ExportMetaDataElement);
                    reader.ReadStartElement(ExportMetaDataElement);
                    // Get the type name
                    string partTypeName = null;
                    string userControlTypeName = null;
                    ImportSkipTo(reader, ExportTypeElement);
                    partTypeName = reader.GetAttribute(ExportTypeNameAttribute);
                    userControlTypeName = reader.GetAttribute(ExportUserControlSrcAttribute);
                    // Get the error message to display if unsuccessful to load the type
                    ImportSkipTo(reader, ExportErrorMessageElement);
                    importErrorMessage = reader.ReadElementString();
                    // Get a type object from the type name
                    Type partType;
                    WebPart part = null;
                    Control childControl = null;

                    try {
                        // If we are in shared scope, we are importing a shared WebPart
                        bool isShared = (Personalization.Scope == PersonalizationScope.Shared);

                        if (!String.IsNullOrEmpty(partTypeName)) {

                            if (UsePermitOnly) {
                                CodeAccessPermission.RevertPermitOnly();
                                permitOnly = false;
                                MediumPermissionSet.PermitOnly();
                                permitOnly = true;
                            }

                            partType = WebPartUtil.DeserializeType(partTypeName, true);

                            if (UsePermitOnly) {
                                CodeAccessPermission.RevertPermitOnly();
                                permitOnly = false;
                                MinimalPermissionSet.PermitOnly();
                                permitOnly = true;
                            }

                            // First check if the type is authorized
                            if (!IsAuthorized(partType, null, null, isShared)) {
                                errorMessage = SR.GetString(SR.WebPartManager_ForbiddenType);
                                return null;
                            }
                            // If the type is not a webpart, create a generic Web Part
                            if (!partType.IsSubclassOf(typeof(WebPart))) {
                                if (!partType.IsSubclassOf(typeof(Control))) {
                                    // We only allow for Controls (VSWhidbey 428511)
                                    errorMessage = SR.GetString(SR.WebPartManager_TypeMustDeriveFromControl);
                                    return null;
                                }
                                // Create an instance of the object
                                childControl = (Control)(Internals.CreateObjectFromType(partType));
                                childControl.ID = CreateDynamicWebPartID(partType);
                                part = CreateWebPart(childControl);
                            }
                            else {
                                // Create an instance of the object
                                part = (WebPart)(Internals.CreateObjectFromType(partType));
                            }
                        }
                        else {
                            // Instantiate a user control in a generic web part

                            // Check if the path is authorized
                            if (!IsAuthorized(typeof(UserControl), userControlTypeName, null, isShared)) {
                                errorMessage = SR.GetString(SR.WebPartManager_ForbiddenType);
                                return null;
                            }

                            if (UsePermitOnly) {
                                CodeAccessPermission.RevertPermitOnly();
                                permitOnly = false;
                            }
                            childControl = Page.LoadControl(userControlTypeName);
                            partType = childControl.GetType();
                            if (UsePermitOnly) {
                                MinimalPermissionSet.PermitOnly();
                                permitOnly = true;
                            }
                            childControl.ID = CreateDynamicWebPartID(partType);
                            part = CreateWebPart(childControl);
                        }
                    }
                    catch {
                        if (!String.IsNullOrEmpty(importErrorMessage)) {
                            errorMessage = importErrorMessage;
                        }
                        else {
                            errorMessage = SR.GetString(SR.WebPartManager_ErrorLoadingWebPartType);
                        }
                        return null;
                    }

                    // Set default error message for all subsequent errors
                    if (String.IsNullOrEmpty(importErrorMessage)) {
                        importErrorMessage = SR.GetString(SR.WebPart_DefaultImportErrorMessage);
                    }
                    // Get to the data
                    ImportSkipTo(reader, ExportDataElement);
                    reader.ReadStartElement(ExportDataElement);
                    ImportSkipTo(reader, ExportPropertiesElement);
                    if (!reader.IsEmptyElement) {
                        reader.ReadStartElement(ExportPropertiesElement);
                        // Special-case IPersonalizable controls
                        // ImportFromReader will set the right permission set when appropriate, reverting before we call
                        if (UsePermitOnly) {
                            CodeAccessPermission.RevertPermitOnly();
                            permitOnly = false;
                        }
                        ImportIPersonalizable(reader, (childControl != null ? childControl : part));
                        if (UsePermitOnly) {
                            MinimalPermissionSet.PermitOnly();
                            permitOnly = true;
                        }
                    }
                    // Set property values from XML description
                    IDictionary personalizableProperties;
                    if (childControl != null) {
                        if (!reader.IsEmptyElement) {
                            // Get the collection of personalizable properties for the child control
                            personalizableProperties = PersonalizableAttribute.GetPersonalizablePropertyEntries(partType);

                            // Copied from below.  We must also execute this code when parsing the ChildControl
                            // IPersonalizable and Personalizable properties.
                            while (reader.Name != ExportPropertyElement) {
                                reader.Skip();
                                if (reader.EOF) {
                                    errorMessage = null;
                                    return part;
                                }
                            }                            
                            
                            // ImportFromReader will set the right permission set when appropriate, reverting before we call
                            if (UsePermitOnly) {
                                CodeAccessPermission.RevertPermitOnly();
                                permitOnly = false;
                            }
                            ImportFromReader(personalizableProperties, childControl, reader);
                            if (UsePermitOnly) {
                                MinimalPermissionSet.PermitOnly();
                                permitOnly = true;
                            }
                        }
                        // And then for the generic WebPart
                        ImportSkipTo(reader, ExportGenericPartPropertiesElement);
                        reader.ReadStartElement(ExportGenericPartPropertiesElement);
                        // ImportFromReader will set the right permission set when appropriate, reverting before we call
                        if (UsePermitOnly) {
                            CodeAccessPermission.RevertPermitOnly();
                            permitOnly = false;
                        }
                        ImportIPersonalizable(reader, part);
                        if (UsePermitOnly) {
                            MinimalPermissionSet.PermitOnly();
                            permitOnly = true;
                        }
                        personalizableProperties = PersonalizableAttribute.GetPersonalizablePropertyEntries(part.GetType());
                    }
                    else {
                        // Get the collection of personalizable properties
                        personalizableProperties = PersonalizableAttribute.GetPersonalizablePropertyEntries(partType);
                    }

                    while (reader.Name != ExportPropertyElement) {
                        reader.Skip();
                        if (reader.EOF) {
                            errorMessage = null;
                            return part;
                        }
                    }

                    // ImportFromReader will set the right permission set when appropriate, reverting before we call
                    if (UsePermitOnly) {
                        CodeAccessPermission.RevertPermitOnly();
                        permitOnly = false;
                    }
                    ImportFromReader(personalizableProperties, part, reader);
                    if (UsePermitOnly) {
                        MinimalPermissionSet.PermitOnly();
                        permitOnly = true;
                    }
                    errorMessage = null;
                    // Return imported part
                    return part;
                }
                catch (XmlException) {
                    errorMessage = SR.GetString(SR.WebPartManager_ImportInvalidFormat);
                    return null;
                }
                catch (Exception e) {
                    if ((Context != null) && (Context.IsCustomErrorEnabled)) {
                        errorMessage = (importErrorMessage.Length != 0) ?
                            importErrorMessage :
                            SR.GetString(SR.WebPart_DefaultImportErrorMessage);
                    }
                    else {
                        errorMessage = e.Message;
                    }
                    return null;
                }
                finally {
                    if (permitOnly) {
                        // revert if you're not just exiting the stack frame anyway
                        CodeAccessPermission.RevertPermitOnly();
                    }
                }
            }
            catch {
                throw;
            }
        }

        private void ImportIPersonalizable(XmlReader reader, Control control) {
            if (control is IPersonalizable) {
                // The control may implement IPersonalizable, but the .WebPart file may not contain
                // an "ipersonalizable" element.  The WebPart may have returned no data from its
                // IPersonalizable.Save() method, or the WebPart may have been recently changed to
                // implement IPersonalizable.  This are valid scenarios, so we should not require
                // the XML to contain the "ipersonalizable" element. (VSWhidbey 499016)

                // Read to the next element that is either "property" or "ipersonalizable".
                ImportReadTo(reader, ExportIPersonalizableElement, ExportPropertyElement);

                // If the next element is "ipersonalizable", then we import the IPersonalizable data.
                // Else, we do nothing, and the current "property" element will be imported as a standard
                // personalizable property.
                if (reader.Name == ExportIPersonalizableElement) {
                    // Create a dictionary from the XML description
                    reader.ReadStartElement(ExportIPersonalizableElement);
                    ImportFromReader(null, control, reader);
                }
            }
        }

        private void ImportFromReader(IDictionary personalizableProperties,
                                      Control target,
                                      XmlReader reader) {

            Debug.Assert(target != null);

            ImportReadTo(reader, ExportPropertyElement);

            bool permitOnly = false;

            if (UsePermitOnly) {
                MinimalPermissionSet.PermitOnly();
                permitOnly = true;
            }

            try {
                try {
                    IDictionary properties;
                    if (personalizableProperties != null) {
                        properties = new HybridDictionary();
                    }
                    else {
                        properties = new PersonalizationDictionary();
                    }
                    // Set properties from the xml document
                    while (reader.Name == ExportPropertyElement) {
                        // Get the name of the property
                        string propertyName = reader.GetAttribute(ExportPropertyNameAttribute);
                        string typeName = reader.GetAttribute(ExportPropertyTypeAttribute);
                        string scope = reader.GetAttribute(ExportPropertyScopeAttribute);
                        bool isNull = String.Equals(
                            reader.GetAttribute(ExportPropertyNullAttribute),
                            "true",
                            StringComparison.OrdinalIgnoreCase);

                        // Do not import Zone information or AuthorizationFilter or custom data
                        if (propertyName == AuthorizationFilterName ||
                             propertyName == ZoneIDName ||
                             propertyName == ZoneIndexName) {

                            reader.ReadElementString();
                            if (!reader.Read()) {
                                throw new XmlException();
                            }
                        }
                        else {
                            string valString = reader.ReadElementString();
                            object val = null;
                            bool valueComputed = false;
                            PropertyInfo pi = null;
                            if (personalizableProperties != null) {
                                // Get the relevant personalizable property on the target (no need to check the property is personalizable)
                                PersonalizablePropertyEntry entry = (PersonalizablePropertyEntry)(personalizableProperties[propertyName]);
                                if (entry != null) {
                                    pi = entry.PropertyInfo;
                                    Debug.Assert(pi != null);
                                    // If the property is a url, validate protocol (VSWhidbey 290418)
                                    UrlPropertyAttribute urlAttr = Attribute.GetCustomAttribute(pi, typeof(UrlPropertyAttribute), true) as UrlPropertyAttribute;
                                    if (urlAttr != null && CrossSiteScriptingValidation.IsDangerousUrl(valString)) {
                                        throw new InvalidDataException(SR.GetString(SR.WebPart_BadUrl, valString));
                                    }
                                }
                            }

                            Type type = null;
                            if (!String.IsNullOrEmpty(typeName)) {
                                if (UsePermitOnly) {
                                    // Need medium trust to call BuildManager.GetType()
                                    CodeAccessPermission.RevertPermitOnly();
                                    permitOnly = false;
                                    MediumPermissionSet.PermitOnly();
                                    permitOnly = true;
                                }
                                type = GetExportType(typeName);

                                if (UsePermitOnly) {
                                    CodeAccessPermission.RevertPermitOnly();
                                    permitOnly = false;
                                    MinimalPermissionSet.PermitOnly();
                                    permitOnly = true;
                                }
                            }

                            if ((pi != null) && ((pi.PropertyType == type) || (type == null))) {
                                // Look at the target property
                                // See if the property itself has a type converter associated with it
                                TypeConverterAttribute attr = Attribute.GetCustomAttribute(pi, typeof(TypeConverterAttribute), true) as TypeConverterAttribute;
                                if (attr != null) {
                                    if (UsePermitOnly) {
                                        // Need medium trust to call BuildManager.GetType()
                                        CodeAccessPermission.RevertPermitOnly();
                                        permitOnly = false;
                                        MediumPermissionSet.PermitOnly();
                                        permitOnly = true;
                                    }

                                    Type converterType = WebPartUtil.DeserializeType(attr.ConverterTypeName, false);

                                    if (UsePermitOnly) {
                                        CodeAccessPermission.RevertPermitOnly();
                                        permitOnly = false;
                                        MinimalPermissionSet.PermitOnly();
                                        permitOnly = true;
                                    }

                                    // SECURITY: Check that the type is a subclass of TypeConverter before instantiating.
                                    if (converterType != null && converterType.IsSubclassOf(typeof(TypeConverter))) {
                                        TypeConverter converter = (TypeConverter)(Internals.CreateObjectFromType(converterType));
                                        if (Util.CanConvertToFrom(converter, typeof(string))) {
                                            if (!isNull) {
                                                val = converter.ConvertFromInvariantString(valString);
                                            }
                                            valueComputed = true;
                                        }
                                    }
                                }
                                // Then, look at the converters on the property type
                                if (!valueComputed) {
                                    // Use the type converter associated with the type itself
                                    TypeConverter converter = TypeDescriptor.GetConverter(pi.PropertyType);
                                    if (Util.CanConvertToFrom(converter, typeof(string))) {
                                        if (!isNull) {
                                            val = converter.ConvertFromInvariantString(valString);
                                        }
                                        valueComputed = true;
                                        // Not importing anything else for security reasons
                                    }
                                }
                            }
                            // finally, use the XML-specified type
                            if (!valueComputed && (type != null)) {
                                // Look at the XML-declared type
                                if (type == typeof(string)) {
                                    if (!isNull) {
                                        val = valString;
                                    }
                                    valueComputed = true;
                                }
                                else {
                                    TypeConverter typeConverter = TypeDescriptor.GetConverter(type);
                                    if (Util.CanConvertToFrom(typeConverter, typeof(string))) {
                                        if (!isNull) {
                                            val = typeConverter.ConvertFromInvariantString(valString);
                                        }
                                        valueComputed = true;
                                    }
                                }
                            }

                            // Always want to import a null IPersonalizable value, since we will never have a type
                            // converter for the value.  However, we should not import a null Personalizable value
                            // unless the PropertyInfo had a type converter, since the property may be a value type
                            // that cannot accept null as a value. (VSWhidbey 537895)
                            if (isNull && personalizableProperties == null) {
                                valueComputed = true;
                            }

                            // Now we should have a value (val)
                            if (valueComputed) {
                                if (personalizableProperties != null) {
                                    properties.Add(propertyName, val);
                                }
                                else {
                                    // Determine scope:
                                    PersonalizationScope personalizationScope =
                                        String.Equals(scope, PersonalizationScope.Shared.ToString(), StringComparison.OrdinalIgnoreCase) ?
                                        PersonalizationScope.Shared : PersonalizationScope.User;
                                    properties.Add(propertyName, new PersonalizationEntry(val, personalizationScope));
                                }
                            }
                            else {
                                throw new HttpException(SR.GetString(SR.WebPartManager_ImportInvalidData, propertyName));
                            }
                        }
                        while (reader.Name != ExportPropertyElement) {
                            if (reader.EOF ||
                                (reader.Name == ExportGenericPartPropertiesElement) ||
                                (reader.Name == ExportPropertiesElement) ||
                                ((reader.Name == ExportIPersonalizableElement) && (reader.NodeType == XmlNodeType.EndElement))) {
                                goto EndOfData;
                            }
                            reader.Skip();
                        }
                    }
                    EndOfData:
                    if (personalizableProperties != null) {
                        IDictionary unused = BlobPersonalizationState.SetPersonalizedProperties(target, properties);
                        if ((unused != null) && (unused.Count > 0)) {
                            IVersioningPersonalizable versioningTarget = target as IVersioningPersonalizable;
                            if (versioningTarget != null) {
                                versioningTarget.Load(unused);
                            }
                        }
                    }
                    else {
                        Debug.Assert(target is IPersonalizable);
                        ((IPersonalizable)target).Load((PersonalizationDictionary)properties);
                    }
                }
                finally {
                    if (permitOnly) {
                        // revert if you're not just exiting the stack frame anyway
                        CodeAccessPermission.RevertPermitOnly();
                    }
                }
            }
            catch {
                throw;
            }
        }

        public virtual bool IsAuthorized(Type type, string path, string authorizationFilter, bool isShared) {
            if (type == null) {
                throw new ArgumentNullException("type");
            }

            if (type == typeof(UserControl)) {
                if (String.IsNullOrEmpty(path)) {
                    throw new ArgumentException(SR.GetString(SR.WebPartManager_PathCannotBeEmpty));
                }
            }
            else {
                if (!String.IsNullOrEmpty(path)) {
                    throw new ArgumentException(SR.GetString(SR.WebPartManager_PathMustBeEmpty, path));
                }
            }

            WebPartAuthorizationEventArgs auth = new WebPartAuthorizationEventArgs(type, path, authorizationFilter, isShared);
            OnAuthorizeWebPart(auth);
            return auth.IsAuthorized;
        }

        public bool IsAuthorized(WebPart webPart) {
            if (webPart == null) {
                throw new ArgumentNullException("webPart");
            }

            // Do not check that Controls.Contains(webPart), since this will be called on a WebPart
            // before it is added to the Controls collection.

            // Calculate authorizationFilter from property value and personalization data
            string authorizationFilter = webPart.AuthorizationFilter;

            // webPart.ID will be null for imported WebParts.  Also, a user may want to call
            // this method on a WebPart before it has an ID.
            string webPartID = webPart.ID;
            if (!String.IsNullOrEmpty(webPartID) && Personalization.IsEnabled) {
                string personalizedAuthorizationFilter = Personalization.GetAuthorizationFilter(webPart.ID);
                if (personalizedAuthorizationFilter != null) {
                    authorizationFilter = personalizedAuthorizationFilter;
                }
            }

            GenericWebPart genericWebPart = webPart as GenericWebPart;
            if (genericWebPart != null) {
                Type childType = null;
                string childPath = null;

                Control childControl = genericWebPart.ChildControl;
                UserControl childUserControl = childControl as UserControl;
                if (childUserControl != null) {
                    childType = typeof(UserControl);
                    childPath = childUserControl.AppRelativeVirtualPath;
                }
                else {
                    childType = childControl.GetType();
                }

                // Only authorize the type/path of the child control
                // Don't need to authorize the GenericWebPart as well
                return IsAuthorized(childType, childPath, authorizationFilter, webPart.IsShared);
            }
            else {
                return IsAuthorized(webPart.GetType(), null, authorizationFilter, webPart.IsShared);
            }
        }

        internal bool IsConsumerConnected(WebPart consumer, ConsumerConnectionPoint connectionPoint) {
            return (GetConnectionForConsumer(consumer, connectionPoint) != null);
        }

        internal bool IsProviderConnected(WebPart provider, ProviderConnectionPoint connectionPoint) {
            return (GetConnectionForProvider(provider, connectionPoint) != null);
        }

        /// <devdoc>
        /// Loads the control state for those properties that should persist across postbacks
        /// even when EnableViewState=false.
        /// </devdoc>
        protected internal override void LoadControlState(object savedState) {
            if (savedState == null) {
                base.LoadControlState(null);
            }
            else {
                object[] myState = (object[])savedState;
                if (myState.Length != controlStateArrayLength) {
                    throw new ArgumentException(SR.GetString(SR.Invalid_ControlState));
                }

                base.LoadControlState(myState[baseIndex]);

                // 

                if (myState[selectedWebPartIndex] != null) {
                    // All dynamic parts must be loaded before this point, in case a dynamic part is the
                    // SelectedWebPart.
                    WebPart selectedWebPart = WebParts[(string)myState[selectedWebPartIndex]];
                    if (selectedWebPart == null || selectedWebPart.IsClosed) {
                        // The SelectedWebPart was either closed or deleted between requests.
                        // Raise the changed event, since the SelectedWebPart was not null on the previous request.
                        SetSelectedWebPart(null);
                        OnSelectedWebPartChanged(new WebPartEventArgs(null));
                    }
                    else {
                        SetSelectedWebPart(selectedWebPart);
                    }
                }
                if (myState[displayModeIndex] != null) {
                    string modeName = (string)myState[displayModeIndex];

                    WebPartDisplayMode restoredDisplayMode = SupportedDisplayModes[modeName];
                    if (!restoredDisplayMode.IsEnabled(this)) {
                        // Throw
                    }

                    if (restoredDisplayMode == null) {
                        _displayMode = BrowseDisplayMode;
                        OnDisplayModeChanged(new WebPartDisplayModeEventArgs(null));
                    }
                    else {
                        _displayMode = restoredDisplayMode;
                    }
                }
            }
        }

        protected virtual void LoadCustomPersonalizationState(PersonalizationDictionary state) {
            // The state must be loaded after the Static Connections and WebParts have been added
            // to the WebPartManager (after the WebPartZone's and ProxyWebPartManager's Init methods)
            _personalizationState = state;
        }

        private void LoadDynamicConnections(PersonalizationEntry entry) {
            if (entry != null) {
                object[] dynamicConnectionState = (object[])entry.Value;
                if (dynamicConnectionState != null) {
                    Debug.Assert(dynamicConnectionState.Length % 7 == 0);
                    for (int i = 0; i < dynamicConnectionState.Length; i += 7) {
                        string ID = (string)dynamicConnectionState[i];
                        string consumerID = (string)dynamicConnectionState[i + 1];
                        string consumerConnectionPointID = (string)dynamicConnectionState[i + 2];
                        string providerID = (string)dynamicConnectionState[i + 3];
                        string providerConnectionPointID = (string)dynamicConnectionState[i + 4];

                        // Add a new connection to the collection
                        WebPartConnection connection = new WebPartConnection();
                        connection.ID = ID;
                        connection.ConsumerID = consumerID;
                        connection.ConsumerConnectionPointID = consumerConnectionPointID;
                        connection.ProviderID = providerID;
                        connection.ProviderConnectionPointID = providerConnectionPointID;
                        Internals.SetIsShared(connection, (entry.Scope == PersonalizationScope.Shared));
                        Internals.SetIsStatic(connection, false);

                        Type type = dynamicConnectionState[i + 5] as Type;
                        if (type != null) {
                            // SECURITY: Only instantiate type if it is a subclass of WebPartTransformer
                            if (type.IsSubclassOf(typeof(WebPartTransformer))) {
                                object configuration = dynamicConnectionState[i + 6];
                                WebPartTransformer transformer = (WebPartTransformer)Internals.CreateObjectFromType(type);
                                Internals.LoadConfigurationState(transformer, configuration);
                                Internals.SetTransformer(connection, transformer);
                            }
                            else {
                                throw new InvalidOperationException(SR.GetString(SR.WebPartTransformerAttribute_NotTransformer, type.Name));
                            }
                        }

                        DynamicConnections.Add(connection);
                    }
                }
            }
        }

        private void LoadDynamicWebPart(string id, string typeName, string path, string genericWebPartID, bool isShared) {
            WebPart dynamicWebPart = null;
            Type type = WebPartUtil.DeserializeType(typeName, false);
            if (type == null) {
                string errorMessage;
                if (Context != null && Context.IsCustomErrorEnabled) {
                    errorMessage = SR.GetString(SR.WebPartManager_ErrorLoadingWebPartType);
                }
                else {
                    errorMessage = SR.GetString(SR.Invalid_type, typeName);
                }
                dynamicWebPart = CreateErrorWebPart(id, typeName, path, genericWebPartID, errorMessage);
            }
            else if (type.IsSubclassOf(typeof(WebPart))) {
                string authorizationFilter = Personalization.GetAuthorizationFilter(id);
                if (IsAuthorized(type, null, authorizationFilter, isShared)) {
                    try {
                        dynamicWebPart = (WebPart)Internals.CreateObjectFromType(type);
                        dynamicWebPart.ID = id;
                    }
                    catch {
                        // If custom errors are enabled, we do not want to render the type name to the browser.
                        // (VSWhidbey 381646)
                        string errorMessage;
                        if (Context != null && Context.IsCustomErrorEnabled) {
                            errorMessage = SR.GetString(SR.WebPartManager_CantCreateInstance);
                        }
                        else {
                            errorMessage = SR.GetString(SR.WebPartManager_CantCreateInstanceWithType, typeName);
                        }
                        dynamicWebPart = CreateErrorWebPart(id, typeName, path, genericWebPartID, errorMessage);
                    }
                }
                else {
                    dynamicWebPart = new UnauthorizedWebPart(id, typeName, path, genericWebPartID);
                }
            }
            else if (type.IsSubclassOf(typeof(Control))) {
                string authorizationFilter = Personalization.GetAuthorizationFilter(genericWebPartID);
                if (IsAuthorized(type, path, authorizationFilter, isShared)) {
                    Control childControl = null;
                    try {
                        if (!String.IsNullOrEmpty(path)) {
                            Debug.Assert(type == typeof(UserControl));
                            childControl = Page.LoadControl(path);
                        }
                        else {
                            childControl = (Control)Internals.CreateObjectFromType(type);
                        }
                        childControl.ID = id;

                        dynamicWebPart = CreateWebPart(childControl);
                        dynamicWebPart.ID = genericWebPartID;
                    }
                    catch {
                        string errorMessage;
                        if (childControl == null && String.IsNullOrEmpty(path)) {
                            if (Context != null && Context.IsCustomErrorEnabled) {
                                errorMessage = SR.GetString(SR.WebPartManager_CantCreateInstance);
                            }
                            else {
                                errorMessage = SR.GetString(SR.WebPartManager_CantCreateInstanceWithType, typeName);
                            }
                        }
                        else if (childControl == null) {
                            if (Context != null && Context.IsCustomErrorEnabled) {
                                errorMessage = SR.GetString(SR.WebPartManager_InvalidPath);
                            }
                            else {
                                errorMessage = SR.GetString(SR.WebPartManager_InvalidPathWithPath, path);
                            }
                        }
                        else {
                            errorMessage = SR.GetString(SR.WebPartManager_CantCreateGeneric);
                        }
                        dynamicWebPart = CreateErrorWebPart(id, typeName, path, genericWebPartID, errorMessage);
                    }
                }
                else {
                    dynamicWebPart = new UnauthorizedWebPart(id, typeName, path, genericWebPartID);
                }
            }
            else {
                // Type is not a subclass of Control.  For security, do not even instantiate
                // the type (VSWhidbey 428511).
                string errorMessage;
                if (Context != null && Context.IsCustomErrorEnabled) {
                    errorMessage = SR.GetString(SR.WebPartManager_TypeMustDeriveFromControl);
                }
                else {
                    errorMessage = SR.GetString(SR.WebPartManager_TypeMustDeriveFromControlWithType, typeName);
                }
                dynamicWebPart = CreateErrorWebPart(id, typeName, path, genericWebPartID, errorMessage);
            }

            Debug.Assert(dynamicWebPart != null);
            Internals.SetIsStatic(dynamicWebPart, false);
            Internals.SetIsShared(dynamicWebPart, isShared);
            Internals.AddWebPart(dynamicWebPart);
        }

        private void LoadDynamicWebParts(PersonalizationEntry entry) {
            if (entry != null) {
                object[] dynamicWebPartState = (object[])entry.Value;
                if (dynamicWebPartState != null) {
                    Debug.Assert(dynamicWebPartState.Length % 4 == 0);
                    bool isShared = (entry.Scope == PersonalizationScope.Shared);

                    // 
                    for (int i = 0; i < dynamicWebPartState.Length; i += 4) {
                        string id = (string)dynamicWebPartState[i];
                        string typeName = (string)dynamicWebPartState[i + 1];
                        string path = (string)dynamicWebPartState[i + 2];
                        string genericWebPartID = (string)dynamicWebPartState[i + 3];

                        LoadDynamicWebPart(id, typeName, path, genericWebPartID, isShared);
                    }
                }
            }
        }

        private void LoadDeletedConnectionState(PersonalizationEntry entry) {
            if (entry != null) {
                string[] deletedConnections = (string[])entry.Value;
                if (deletedConnections != null) {
                    for (int i=0; i < deletedConnections.Length; i++) {
                        string idToDelete = deletedConnections[i];
                        WebPartConnection connectionToDelete = null;

                        foreach (WebPartConnection connection in StaticConnections) {
                            if (String.Equals(connection.ID, idToDelete, StringComparison.OrdinalIgnoreCase)) {
                                connectionToDelete = connection;
                                break;
                            }
                        }
                        if (connectionToDelete == null) {
                            foreach (WebPartConnection connection in DynamicConnections) {
                                if (String.Equals(connection.ID, idToDelete, StringComparison.OrdinalIgnoreCase)) {
                                    connectionToDelete = connection;
                                    break;
                                }
                            }
                        }

                        if (connectionToDelete != null) {
                            // Only shared connections can be deleted
                            Debug.Assert(connectionToDelete.IsShared);

                            // In shared scope, only static connections should be deleted
                            // In user scope, static and dynamic connections can be deleted
                            Debug.Assert(connectionToDelete.IsStatic || entry.Scope == PersonalizationScope.User);

                            Internals.DeleteConnection(connectionToDelete);
                        }
                        else {
                            // Some of the personalization data is invalid, so we should mark ourselves
                            // as dirty so the data will be re-saved, and the invalid data will be removed.
                            _hasDataChanged = true;
                        }
                    }
                }
            }
        }

        /// <devdoc>
        /// Sets the ZoneID, ZoneIndex, and IsClosed properties on the WebParts.  The state
        /// was loaded from personalization.
        /// </devdoc>
        private void LoadWebPartState(PersonalizationEntry entry) {
            if (entry != null) {
                object[] webPartState = (object[])entry.Value;
                if (webPartState != null) {
                    Debug.Assert(webPartState.Length % 4 == 0);
                    for (int i=0; i < webPartState.Length; i += 4) {
                        string id = (string)webPartState[i];
                        string zoneID = (string)webPartState[i + 1];
                        int zoneIndex = (int)webPartState[i + 2];
                        bool isClosed = (bool)webPartState[i + 3];

                        WebPart part = (WebPart)FindControl(id);
                        if (part != null) {
                            Internals.SetZoneID(part, zoneID);
                            Internals.SetZoneIndex(part, zoneIndex);
                            // 

                            Internals.SetIsClosed(part, isClosed);
                        }
                        else {
                            // Some of the personalization data is invalid, so we should mark ourselves
                            // as dirty so the data will be re-saved, and the invalid data will be removed.
                            _hasDataChanged = true;
                        }
                    }
                }
            }
        }

        /// <devdoc>
        /// </devdoc>
        public virtual void MoveWebPart(WebPart webPart, WebPartZoneBase zone, int zoneIndex) {
            Personalization.EnsureEnabled(/* ensureModifiable */ true);

            if (webPart == null) {
                throw new ArgumentNullException("webPart");
            }
            if (!Controls.Contains(webPart)) {
                throw new ArgumentException(SR.GetString(SR.UnknownWebPart), "webPart");
            }
            if (zone == null) {
                throw new ArgumentNullException("zone");
            }
            if (_webPartZones.Contains(zone) == false) {
                throw new ArgumentException(SR.GetString(SR.WebPartManager_MustRegister), "zone");
            }
            if (zoneIndex < 0) {
                throw new ArgumentOutOfRangeException("zoneIndex");
            }
            if (webPart.Zone == null || webPart.IsClosed) {
                throw new ArgumentException(SR.GetString(SR.WebPartManager_MustBeInZone), "webPart");
            }

            // Return immediately if moving part to its current location
            if ((webPart.Zone == zone) && (webPart.ZoneIndex == zoneIndex)) {
                return;
            }

            WebPartMovingEventArgs e = new WebPartMovingEventArgs(webPart, zone, zoneIndex);
            OnWebPartMoving(e);
            if (_allowEventCancellation && e.Cancel) {
                return;
            }

            RemoveWebPartFromZone(webPart);
            AddWebPartToZone(webPart, zone, zoneIndex);

            // Raise event at very end of Move method
            OnWebPartMoved(new WebPartEventArgs(webPart));

#if DEBUG
            CheckPartZoneIndexes(webPart.Zone);
            CheckPartZoneIndexes(zone);
#endif
        }

        protected virtual void OnAuthorizeWebPart(WebPartAuthorizationEventArgs e) {
            WebPartAuthorizationEventHandler handler = (WebPartAuthorizationEventHandler)Events[AuthorizeWebPartEvent];
            if (handler != null) {
                handler(this, e);
            }
        }

        protected virtual void OnConnectionsActivated(EventArgs e) {
            EventHandler handler = (EventHandler)Events[ConnectionsActivatedEvent];
            if (handler != null) {
                handler(this, e);
            }
        }

        protected virtual void OnConnectionsActivating(EventArgs e) {
            EventHandler handler = (EventHandler)Events[ConnectionsActivatingEvent];
            if (handler != null) {
                handler(this, e);
            }
        }

        protected virtual void OnDisplayModeChanged(WebPartDisplayModeEventArgs e) {
            WebPartDisplayModeEventHandler handler = (WebPartDisplayModeEventHandler)Events[DisplayModeChangedEvent];
            if (handler != null) {
                handler(this, e);
            }
        }

        protected virtual void OnDisplayModeChanging(WebPartDisplayModeCancelEventArgs e) {
            WebPartDisplayModeCancelEventHandler handler = (WebPartDisplayModeCancelEventHandler)Events[DisplayModeChangingEvent];
            if (handler != null) {
                handler(this, e);
            }
        }

        /// <devdoc>
        /// </devdoc>
        protected internal override void OnInit(EventArgs e) {
            base.OnInit(e);

            if (!DesignMode) {
                Page page = Page;
                if (page != null) {
                    WebPartManager existingInstance = (WebPartManager)page.Items[typeof(WebPartManager)];

                    if (existingInstance != null) {
                        Debug.Assert(existingInstance != this);
                        throw new InvalidOperationException(SR.GetString(SR.WebPartManager_OnlyOneInstance));
                    }

                    page.Items[typeof(WebPartManager)] = this;

                    page.InitComplete += new EventHandler(this.OnPageInitComplete);
                    page.LoadComplete += new EventHandler(this.OnPageLoadComplete);
                    page.SaveStateComplete += new EventHandler(this.OnPageSaveStateComplete);
                    page.RegisterRequiresControlState(this);

                    Personalization.LoadInternal();
                }
            }
        }

        /// <devdoc>
        /// </devdoc>
        protected internal override void OnUnload(EventArgs e) {
            base.OnUnload(e);

            if (!DesignMode) {
                Page page = Page;

                Debug.Assert(page != null);
                if (page != null) {
                    page.Items.Remove(typeof(WebPartManager));
                }
            }
        }

        private void OnPageInitComplete(object sender, EventArgs e) {
            if (_personalizationState != null) {
                // These must be loaded after the Static Connections have been added to the WebPartManager
                // (after the ProxyWebPartManager's Init methods)
                LoadDynamicConnections(_personalizationState["DynamicConnectionsShared"]);
                LoadDynamicConnections(_personalizationState["DynamicConnectionsUser"]);
                LoadDeletedConnectionState(_personalizationState["DeletedConnectionsShared"]);
                LoadDeletedConnectionState(_personalizationState["DeletedConnectionsUser"]);

                // These must be loaded after the Static WebParts have been added to the WebPartManager
                // (after the WebPartZone's Init methods)
                LoadDynamicWebParts(_personalizationState["DynamicWebPartsShared"]);
                LoadDynamicWebParts(_personalizationState["DynamicWebPartsUser"]);
                LoadWebPartState(_personalizationState["WebPartStateShared"]);
                LoadWebPartState(_personalizationState["WebPartStateUser"]);
            }

            _pageInitComplete = true;
        }

        private void OnPageLoadComplete(object sender, EventArgs e) {
            // VSWhidbey 77708
            CloseOrphanedParts();

            _allowCreateDisplayTitles = true;

            // Raise events outside of ActivateConnections() method, since the method is virtual
            OnConnectionsActivating(EventArgs.Empty);
            // Activate connections in Page.LoadComplete instead of WebPartManager.PreRender.
            // Additional connection types can be activated here, so this improves our compatibility. (VSWhidbey 266995)
            ActivateConnections();
            OnConnectionsActivated(EventArgs.Empty);
        }

        private void OnPageSaveStateComplete(object sender, EventArgs e) {
            // NOTE: Ideally this would be done by overriding SaveViewState in
            //       WebPartManager and WebPart to be symmetric with Personalization
            //       loading which happens in TrackViewState.
            //       However SaveViewState is not called when view state is disabled. Also,
            //       we don't want to have everything register for the SaveStateComplete event,
            //       because that creates more management issues for the event handler list.
            //       We don't want to change how the Apply works either, because we'd have
            //       to set up listeners for the Init event on every webpart.
            Personalization.ExtractPersonalizationState();
            foreach (WebPart webPart in Controls) {
                Personalization.ExtractPersonalizationState(webPart);
            }

            Personalization.SaveInternal();
        }

        protected internal override void OnPreRender(EventArgs e) {
            base.OnPreRender(e);

            if (Page != null) {
                Page.ClientScript.RegisterStartupScript(
                    this,
                    typeof(WebPartManager),
                    ExportSensitiveDataWarningDeclaration,
                    "var __wpmExportWarning='" + Util.QuoteJScriptString(ExportSensitiveDataWarning) + "';",
                    true);

                Page.ClientScript.RegisterStartupScript(
                    this,
                    typeof(WebPartManager),
                    CloseProviderWarningDeclaration,
                    "var __wpmCloseProviderWarning='" + Util.QuoteJScriptString(CloseProviderWarning) + "';",
                    true);

                Page.ClientScript.RegisterStartupScript(
                    this,
                    typeof(WebPartManager),
                    DeleteWarningDeclaration,
                    "var __wpmDeleteWarning='" + Util.QuoteJScriptString(DeleteWarning) + "';",
                    true);

                _renderClientScript = CheckRenderClientScript();
                if (_renderClientScript) {
                    // 

                    Page.RegisterPostBackScript();

                    RegisterClientScript();
                }
            }
        }

        protected virtual void OnSelectedWebPartChanged(WebPartEventArgs e) {
            WebPartEventHandler handler = (WebPartEventHandler)Events[SelectedWebPartChangedEvent];
            if (handler != null) {
                handler(this, e);
            }
        }

        protected virtual void OnSelectedWebPartChanging(WebPartCancelEventArgs e) {
            WebPartCancelEventHandler handler = (WebPartCancelEventHandler)Events[SelectedWebPartChangingEvent];
            if (handler != null) {
                handler(this, e);
            }
        }

        protected virtual void OnWebPartAdded(WebPartEventArgs e) {
            WebPartEventHandler handler = (WebPartEventHandler)Events[WebPartAddedEvent];
            if (handler != null) {
                handler(this, e);
            }
        }

        protected virtual void OnWebPartAdding(WebPartAddingEventArgs e) {
            WebPartAddingEventHandler handler = (WebPartAddingEventHandler)Events[WebPartAddingEvent];
            if (handler != null) {
                handler(this, e);
            }
        }

        protected virtual void OnWebPartClosed(WebPartEventArgs e) {
            WebPartEventHandler handler = (WebPartEventHandler)Events[WebPartClosedEvent];
            if (handler != null) {
                handler(this, e);
            }
        }

        protected virtual void OnWebPartClosing(WebPartCancelEventArgs e) {
            WebPartCancelEventHandler handler = (WebPartCancelEventHandler)Events[WebPartClosingEvent];
            if (handler != null) {
                handler(this, e);
            }

        }

        protected virtual void OnWebPartDeleted(WebPartEventArgs e) {
            WebPartEventHandler handler = (WebPartEventHandler)Events[WebPartDeletedEvent];
            if (handler != null) {
                handler(this, e);
            }
        }

        protected virtual void OnWebPartDeleting(WebPartCancelEventArgs e) {
            WebPartCancelEventHandler handler = (WebPartCancelEventHandler)Events[WebPartDeletingEvent];
            if (handler != null) {
                handler(this, e);
            }
        }

        protected virtual void OnWebPartMoved(WebPartEventArgs e) {
            WebPartEventHandler handler = (WebPartEventHandler)Events[WebPartMovedEvent];
            if (handler != null) {
                handler(this, e);
            }
        }

        protected virtual void OnWebPartMoving(WebPartMovingEventArgs e) {
            WebPartMovingEventHandler handler = (WebPartMovingEventHandler)Events[WebPartMovingEvent];
            if (handler != null) {
                handler(this, e);
            }
        }

        protected virtual void OnWebPartsConnected(WebPartConnectionsEventArgs e) {
            WebPartConnectionsEventHandler handler = (WebPartConnectionsEventHandler)Events[WebPartsConnectedEvent];
            if (handler != null) {
                handler(this, e);
            }
        }

        protected virtual void OnWebPartsConnecting(WebPartConnectionsCancelEventArgs e) {
            WebPartConnectionsCancelEventHandler handler = (WebPartConnectionsCancelEventHandler)Events[WebPartsConnectingEvent];
            if (handler != null) {
                handler(this, e);
            }
        }

        protected virtual void OnWebPartsDisconnected(WebPartConnectionsEventArgs e) {
            WebPartConnectionsEventHandler handler = (WebPartConnectionsEventHandler)Events[WebPartsDisconnectedEvent];
            if (handler != null) {
                handler(this, e);
            }
        }

        protected virtual void OnWebPartsDisconnecting(WebPartConnectionsCancelEventArgs e) {
            WebPartConnectionsCancelEventHandler handler = (WebPartConnectionsCancelEventHandler)Events[WebPartsDisconnectingEvent];
            if (handler != null) {
                handler(this, e);
            }
        }

        protected virtual void RegisterClientScript() {
            Page.ClientScript.RegisterClientScriptResource(this, typeof(WebPartManager), "WebParts.js");

            bool allowPageDesign = DisplayMode.AllowPageDesign;

            string dragOverlayElementReference = "null";
            if (allowPageDesign) {
                dragOverlayElementReference = "document.getElementById('" + ClientID + "___Drag')";
            }

            StringBuilder zoneCode = new StringBuilder(1024);
            foreach (WebPartZoneBase zone in _webPartZones) {
                string isVertical = (zone.LayoutOrientation == Orientation.Vertical) ? "true" : "false";

                string allowLayoutChange = "false";
                string dragHighlightColor = "black";
                if (allowPageDesign && zone.AllowLayoutChange) {
                    allowLayoutChange = "true";
                    dragHighlightColor = ColorTranslator.ToHtml(zone.DragHighlightColor);
                }

                zoneCode.AppendFormat(CultureInfo.InvariantCulture, ZoneScript, zone.ClientID, zone.UniqueID, isVertical,
                                      allowLayoutChange, dragHighlightColor);

                WebPartCollection webParts = GetWebPartsForZone(zone);
                foreach (WebPart webPart in webParts) {
                    string titleBarElementReference = "null";
                    string allowMove = "false";
                    if (allowPageDesign) {
                        titleBarElementReference = "document.getElementById('" + webPart.TitleBarID + "')";
                        if (webPart.AllowZoneChange) {
                            allowMove = "true";
                        }
                    }
                    zoneCode.AppendFormat(ZonePartScript, webPart.WholePartID, titleBarElementReference, allowMove);
                }

                zoneCode.Append(ZoneEndScript);
            }

            string startupScript = String.Format(CultureInfo.InvariantCulture,
                                                 StartupScript,
                                                 dragOverlayElementReference,
                                                 (Personalization.Scope == PersonalizationScope.Shared ? "true" : "false"),
                                                 zoneCode.ToString());
            Page.ClientScript.RegisterStartupScript(this, typeof(WebPartManager), String.Empty, startupScript, false);

            IScriptManager scriptManager = Page.ScriptManager;
            if ((scriptManager != null) && scriptManager.SupportsPartialRendering) {
                scriptManager.RegisterDispose(this, "WebPartManager_Dispose();");
            }
        }

        internal void RegisterZone(WebZone zone) {
            Debug.Assert(zone != null);

            if (_pageInitComplete) {
                throw new InvalidOperationException(SR.GetString(SR.WebPartManager_RegisterTooLate));
            }

            string zoneID = zone.ID;
            if (String.IsNullOrEmpty(zoneID)) {
                throw new ArgumentException(SR.GetString(SR.WebPartManager_NoZoneID), "zone");
            }
            if (_zoneIDs.Contains(zoneID)) {
                throw new ArgumentException(SR.GetString(SR.WebPartManager_DuplicateZoneID, zoneID));
            }
            _zoneIDs.Add(zoneID, zone);

            WebPartZoneBase webPartZone = zone as WebPartZoneBase;
            if (webPartZone != null) {
                if (_webPartZones.Contains(webPartZone)) {
                    throw new ArgumentException(SR.GetString(SR.WebPartManager_AlreadyRegistered), "zone");
                }

                _webPartZones.Add(webPartZone);

                WebPartCollection initialWebParts = webPartZone.GetInitialWebParts();
                ((WebPartManagerControlCollection)Controls).AddWebPartsFromZone(webPartZone, initialWebParts);
            }
            else {
                Debug.Assert(zone is ToolZone);
                ToolZone toolZone = (ToolZone)zone;

                WebPartDisplayModeCollection allDisplayModes = DisplayModes;
                WebPartDisplayModeCollection supportedDisplayModes = SupportedDisplayModes;
                foreach (WebPartDisplayMode displayMode in toolZone.AssociatedDisplayModes) {
                    if (allDisplayModes.Contains(displayMode) && !supportedDisplayModes.Contains(displayMode)) {
                        supportedDisplayModes.AddInternal(displayMode);
                    }
                }
            }
        }

        /// <devdoc>
        /// Deletes the part from the dictionary mapping zones to parts.
        /// </devdoc>
        private void RemoveWebPartFromDictionary(WebPart webPart) {
            if (_partsForZone != null) {
                string zoneID = Internals.GetZoneID(webPart);
                if (!String.IsNullOrEmpty(zoneID)) {
                    SortedList partsForZone = (SortedList)(_partsForZone[zoneID]);
                    if (partsForZone != null) {
                        partsForZone.Remove(webPart);
                    }
                }
            }
        }

        // Called by WebPartManagerInternals
        internal void RemoveWebPart(WebPart webPart) {
            ((WebPartManagerControlCollection)Controls).RemoveWebPart(webPart);
        }

        /// <devdoc>
        /// Removes a web part from its zone, and renumbers all the remaining parts sequentially.
        /// </devdoc>
        private void RemoveWebPartFromZone(WebPart webPart) {
            Debug.Assert(!webPart.IsClosed);

            WebPartZoneBase zone = webPart.Zone;
            Internals.SetIsClosed(webPart, true);
            _hasDataChanged = true;

            RemoveWebPartFromDictionary(webPart);

            // 

            if (zone != null) {
                IList parts = GetAllWebPartsForZone(zone);
                for (int i = 0; i < parts.Count; i++) {
                    WebPart part = ((WebPart)parts[i]);
                    Internals.SetZoneIndex(part, i);
                }
            }
        }

        protected internal override void Render(HtmlTextWriter writer) {
            if (DisplayMode.AllowPageDesign) {
                string dragOverlayElementHtml = String.Format(CultureInfo.InvariantCulture, DragOverlayElementHtmlTemplate, ClientID);
                writer.WriteLine(dragOverlayElementHtml);
            }
        }

        /// <devdoc>
        /// Saves the control state for those properties that should persist across postbacks
        /// even when EnableViewState=false.
        /// </devdoc>
        protected internal override object SaveControlState() {
            object[] myState = new object[controlStateArrayLength];

            myState[baseIndex] = base.SaveControlState();
            if (SelectedWebPart != null) {
                myState[selectedWebPartIndex] = SelectedWebPart.ID;
            }
            if (_displayMode != BrowseDisplayMode) {
                myState[displayModeIndex] = _displayMode.Name;
            }

            for (int i=0; i < controlStateArrayLength; i++) {
                if (myState[i] != null) {
                    return myState;
                }
            }

            // More performant to return null than an array of null values
            return null;
        }

        protected virtual void SaveCustomPersonalizationState(PersonalizationDictionary state) {
            PersonalizationScope scope = Personalization.Scope;

            int webPartsCount = Controls.Count;
            if (webPartsCount > 0) {
                object[] webPartState = new object[webPartsCount * 4];
                for (int i=0; i < webPartsCount; i++) {
                    WebPart webPart = (WebPart)Controls[i];
                    webPartState[4*i] = webPart.ID;
                    webPartState[4*i + 1] = Internals.GetZoneID(webPart);
                    webPartState[4*i + 2] = webPart.ZoneIndex;
                    webPartState[4*i + 3] = webPart.IsClosed;
                }
                if (scope == PersonalizationScope.Shared) {
                    state["WebPartStateShared"] =
                        new PersonalizationEntry(webPartState, PersonalizationScope.Shared);
                }
                else {
                    state["WebPartStateUser"] =
                        new PersonalizationEntry(webPartState, PersonalizationScope.User);
                }
            }

            // Select only the dynamic WebParts that should be saved for this mode
            ArrayList dynamicWebParts = new ArrayList();
            foreach (WebPart webPart in Controls) {
                if (!webPart.IsStatic &&
                    ((scope == PersonalizationScope.User && !webPart.IsShared) ||
                     (scope == PersonalizationScope.Shared && webPart.IsShared))) {
                    dynamicWebParts.Add(webPart);
                }
            }

            int dynamicWebPartsCount = dynamicWebParts.Count;
            if (dynamicWebPartsCount > 0) {
                // Use a 1-dimensional array for smallest storage space
                object[] dynamicWebPartState = new object[dynamicWebPartsCount * 4];
                for (int i = 0; i < dynamicWebPartsCount; i++) {
                    WebPart webPart = (WebPart)dynamicWebParts[i];

                    string id;
                    string typeName;
                    string path = null;
                    string genericWebPartID = null;
                    ProxyWebPart proxyWebPart = webPart as ProxyWebPart;
                    if (proxyWebPart != null) {
                        id = proxyWebPart.OriginalID;
                        typeName = proxyWebPart.OriginalTypeName;
                        path = proxyWebPart.OriginalPath;
                        genericWebPartID = proxyWebPart.GenericWebPartID;
                    }
                    else {
                        GenericWebPart genericWebPart = webPart as GenericWebPart;
                        if (genericWebPart != null) {
                            Control childControl = genericWebPart.ChildControl;
                            UserControl userControl = childControl as UserControl;

                            id = childControl.ID;
                            if (userControl != null) {
                                typeName = WebPartUtil.SerializeType(typeof(UserControl));
                                path = userControl.AppRelativeVirtualPath;
                            }
                            else {
                                typeName = WebPartUtil.SerializeType(childControl.GetType());
                            }
                            genericWebPartID = genericWebPart.ID;
                        }
                        else {
                            id = webPart.ID;
                            typeName = WebPartUtil.SerializeType(webPart.GetType());
                        }
                    }

                    dynamicWebPartState[4*i] = id;
                    dynamicWebPartState[4*i + 1] = typeName;
                    if (!String.IsNullOrEmpty(path)) {
                        dynamicWebPartState[4*i + 2] = path;
                    }
                    if (!String.IsNullOrEmpty(genericWebPartID)) {
                        dynamicWebPartState[4*i + 3] = genericWebPartID;
                    }
                }
                if (scope == PersonalizationScope.Shared) {
                    state["DynamicWebPartsShared"] =
                        new PersonalizationEntry(dynamicWebPartState, PersonalizationScope.Shared);
                }
                else {
                    state["DynamicWebPartsUser"] =
                        new PersonalizationEntry(dynamicWebPartState, PersonalizationScope.User);
                }
            }

            // Save deleted connections
            // 

            ArrayList deletedConnections = new ArrayList();
            // PERF: Use the StaticConnections and DynamicConnections collections separately, instead
            // of using the Connections property which is created on every call.
            foreach (WebPartConnection connection in StaticConnections) {
                if (Internals.ConnectionDeleted(connection)) {
                    deletedConnections.Add(connection);
                }
            }
            foreach (WebPartConnection connection in DynamicConnections) {
                if (Internals.ConnectionDeleted(connection)) {
                    deletedConnections.Add(connection);
                }
            }

            int deletedConnectionsCount = deletedConnections.Count;
            if (deletedConnections.Count > 0) {
                string[] deletedConnectionsState = new string[deletedConnectionsCount];
                for (int i=0; i < deletedConnectionsCount; i++) {
                    WebPartConnection deletedConnection = (WebPartConnection)deletedConnections[i];
                    // Only shared connections can be deleted
                    Debug.Assert(deletedConnection.IsShared);
                    // In shared scope, only static connections should be deleted
                    // In user scope, static and dynamic connections can be deleted
                    Debug.Assert(deletedConnection.IsStatic || scope == PersonalizationScope.User);
                    deletedConnectionsState[i] = deletedConnection.ID;
                }
                if (scope == PersonalizationScope.Shared) {
                    state["DeletedConnectionsShared"] =
                        new PersonalizationEntry(deletedConnectionsState, PersonalizationScope.Shared);
                }
                else {
                    state["DeletedConnectionsUser"] =
                        new PersonalizationEntry(deletedConnectionsState, PersonalizationScope.User);
                }
            }

            // Select only the dynamic Connections that should be saved for this mode
            ArrayList dynamicConnections = new ArrayList();
            foreach (WebPartConnection connection in DynamicConnections) {
                if (((scope == PersonalizationScope.User) && (!connection.IsShared)) ||
                    ((scope == PersonalizationScope.Shared) && (connection.IsShared))) {
                    dynamicConnections.Add(connection);
                }
            }

            int dynamicConnectionsCount = dynamicConnections.Count;
            if (dynamicConnectionsCount > 0) {
                // Use a 1-dimensional array for smallest storage space
                object[] dynamicConnectionState = new object[dynamicConnectionsCount * 7];
                for (int i = 0; i < dynamicConnectionsCount; i++) {
                    WebPartConnection connection = (WebPartConnection)dynamicConnections[i];
                    WebPartTransformer transformer = connection.Transformer;

                    // We should never be saving a deleted dynamic connection.  If the User has deleted a
                    // a shared connection, the connection will be saved in the Shared data, not here.
                    Debug.Assert(!Internals.ConnectionDeleted(connection));

                    dynamicConnectionState[7*i] = connection.ID;
                    dynamicConnectionState[7*i + 1] = connection.ConsumerID;
                    dynamicConnectionState[7*i + 2] = connection.ConsumerConnectionPointID;
                    dynamicConnectionState[7*i + 3] = connection.ProviderID;
                    dynamicConnectionState[7*i + 4] = connection.ProviderConnectionPointID;
                    if (transformer != null) {
                        dynamicConnectionState[7*i + 5] = transformer.GetType();
                        dynamicConnectionState[7*i + 6] = Internals.SaveConfigurationState(transformer);
                    }
                }

                if (scope == PersonalizationScope.Shared) {
                    state["DynamicConnectionsShared"] =
                        new PersonalizationEntry(dynamicConnectionState, PersonalizationScope.Shared);
                }
                else {
                    state["DynamicConnectionsUser"] =
                        new PersonalizationEntry(dynamicConnectionState, PersonalizationScope.User);
                }
            }
        }

        // Can be called by a derived WebPartManager to mark itself as dirty
        protected void SetPersonalizationDirty() {
            Personalization.SetDirty();
        }

        // Returns true if the WebPart should currently be rendered in the Zone.  Determines
        // which WebParts are returned by GetWebPartsForZone.
        private bool ShouldRenderWebPartInZone(WebPart part, WebPartZoneBase zone) {
            Debug.Assert(part.Zone == zone);

            // Never render UnauthorizedWebParts
            if (part is UnauthorizedWebPart) {
                return false;
            }

            return true;
        }

        protected void SetSelectedWebPart(WebPart webPart) {
            _selectedWebPart = webPart;
        }

        // PropertyInfo will be null for an IPersonalizable property, since there is no associated PropertyInfo
        private bool ShouldExportProperty(PropertyInfo propertyInfo, Type propertyValueType,
                                          object propertyValue, out string exportString) {
            string propertyValueAsString = propertyValue as string;
            if (propertyValueAsString != null) {
                exportString = propertyValueAsString;
                return true;
            }
            else {
                TypeConverter converter = null;

                if (propertyInfo != null) {
                    // See if the property itself has a type converter associated with it
                    TypeConverterAttribute attr =
                        Attribute.GetCustomAttribute(propertyInfo, typeof(TypeConverterAttribute), true) as TypeConverterAttribute;
                    if (attr != null) {
                        // Get the type using DeserializeType(), which calls BuildManager.GetType(),
                        // since we want this to work with a non-assembly qualified typename
                        // in the Code directory.
                        Type converterType = WebPartUtil.DeserializeType(attr.ConverterTypeName, false);
                        // SECURITY: Check that the type is a subclass of TypeConverter before instantiating.
                        if (converterType != null && converterType.IsSubclassOf(typeof(TypeConverter))) {
                            TypeConverter tempConverter = (TypeConverter)(Internals.CreateObjectFromType(converterType));
                            if (Util.CanConvertToFrom(tempConverter, typeof(string))) {
                                converter = tempConverter;
                            }
                        }
                    }
                }

                if (converter == null) {
                    // If there was no valid type converter on the property info, look on the type of the value
                    TypeConverter tempConverter = TypeDescriptor.GetConverter(propertyValueType);
                    if (Util.CanConvertToFrom(tempConverter, typeof(string))) {
                        converter = tempConverter;
                    }
                }

                // Only export property if we found a valid type converter (VSWhidbey 496495)
                if (converter != null) {
                    if (propertyValue != null) {
                        exportString = converter.ConvertToInvariantString(propertyValue);
                        return true;
                    }
                    else {
                        // Special-case null value
                        exportString = null;
                        return true;
                    }
                }
                else {
                    exportString = null;
                    if (propertyInfo == null && propertyValue == null) {
                        // Always want to export a null IPersonalizable value, since we will never have a type
                        // converter for the value.  However, we should not export a null Personalizable value
                        // unless the propertyInfo had a type converter, since we may not be able to import a
                        // null value, since the property may be a value type that cannot accept null as a value.
                        // (VSWhidbey 537895)
                        return true;
                    }
                    else {
                        return false;
                    }
                }
            }
        }

        /// <devdoc>
        /// Returns true if the connection should be removed from the dynamic connection
        /// collection when deleted.
        /// </devdoc>
        private bool ShouldRemoveConnection(WebPartConnection connection) {
            Debug.Assert(Personalization.IsModifiable);

            if (connection.IsShared && (Personalization.Scope == PersonalizationScope.User)) {
                // Can't remove shared connection in user mode
                return false;
            }
            else {
                return true;
            }
        }

        /// <internalonly />
        protected override void TrackViewState() {
            Personalization.ApplyPersonalizationState();
            base.TrackViewState();
        }

        // Throw if the type cannot be loaded by BuildManager
        // For instance, we cannot load a type defined in the Page class
        private void VerifyType(Control control) {
            // Don't need to verify type of UserControls, since we load them using
            // their path instead of their type
            if (control is UserControl) {
                return;
            }

            Type type = control.GetType();
            string typeName = WebPartUtil.SerializeType(type);
            Type loadedType = WebPartUtil.DeserializeType(typeName, /* throwOnError */ false);
            if (loadedType != type) {
                throw new InvalidOperationException(
                    SR.GetString(SR.WebPartManager_CantAddControlType, typeName));
            }
        }

        #region Implementation of IPersonalizable
        /// <internalonly/>
        bool IPersonalizable.IsDirty {
            get {
                return IsCustomPersonalizationStateDirty;
            }
        }

        /// <internalonly/>
        void IPersonalizable.Load(PersonalizationDictionary state) {
            LoadCustomPersonalizationState(state);
        }

        /// <internalonly/>
        void IPersonalizable.Save(PersonalizationDictionary state) {
            SaveCustomPersonalizationState(state);
        }
        #endregion

        private sealed class WebPartManagerControlCollection : ControlCollection {

            private WebPartManager _manager;

            public WebPartManagerControlCollection(WebPartManager owner) : base(owner) {
                _manager = owner;
                SetCollectionReadOnly(SR.WebPartManager_CannotModify);
            }

            internal void AddWebPart(WebPart webPart) {
                string originalError = SetCollectionReadOnly(null);
                // Extra try-catch block to prevent elevation of privilege attack via exception filter
                try {
                    try {
                        AddWebPartHelper(webPart);
                    }
                    finally {
                        SetCollectionReadOnly(originalError);
                    }
                }
                catch {
                    throw;
                }
            }

            private void AddWebPartHelper(WebPart webPart) {
                string partID = webPart.ID;
                if (String.IsNullOrEmpty(partID)) {
                    throw new InvalidOperationException(SR.GetString(SR.WebPartManager_NoWebPartID));
                }
                if (_manager._partAndChildControlIDs.Contains(partID)) {
                   throw new InvalidOperationException(SR.GetString(SR.WebPartManager_DuplicateWebPartID, partID));
                }

                // Add to dictionary to prevent duplicate IDs, even if this part is not authorized.  Don't want page
                // developer to have 2 parts with the same ID, and not get the exception until they are both authorized.
                _manager._partAndChildControlIDs.Add(partID, null);

                // Check and add child control ID (VSWhidbey 339482)
                GenericWebPart genericWebPart = webPart as GenericWebPart;
                if (genericWebPart != null) {
                    string childControlID = genericWebPart.ChildControl.ID;

                    if (String.IsNullOrEmpty(childControlID)) {
                        throw new InvalidOperationException(SR.GetString(SR.WebPartManager_NoChildControlID));
                    }

                    if (_manager._partAndChildControlIDs.Contains(childControlID)) {
                        throw new InvalidOperationException(SR.GetString(SR.WebPartManager_DuplicateWebPartID, childControlID));
                    }

                    _manager._partAndChildControlIDs.Add(childControlID, null);
                }

                _manager.Internals.SetIsStandalone(webPart, false);
                webPart.SetWebPartManager(_manager);
                Add(webPart);

                // Invalidate the part dictionary if it has already been created
                _manager._partsForZone = null;
            }

            internal void AddWebPartsFromZone(WebPartZoneBase zone, WebPartCollection webParts) {
                if ((webParts != null) && (webParts.Count != 0)) {
                    string originalError = SetCollectionReadOnly(null);

                    // Extra try-catch block to prevent elevation of privilege attack via exception filter
                    try {
                        try {
                            string zoneID = zone.ID;
                            int index = 0;

                            foreach (WebPart webPart in webParts) {
                                // Need to set IsShared before calling IsAuthorized
                                _manager.Internals.SetIsShared(webPart, true);

                                WebPart webPartOrProxy = webPart;
                                if (!_manager.IsAuthorized(webPart)) {
                                    webPartOrProxy = new UnauthorizedWebPart(webPart);
                                }

                                _manager.Internals.SetIsStatic(webPartOrProxy, true);
                                _manager.Internals.SetIsShared(webPartOrProxy, true);
                                _manager.Internals.SetZoneID(webPartOrProxy, zoneID);
                                _manager.Internals.SetZoneIndex(webPartOrProxy, index);

                                AddWebPartHelper(webPartOrProxy);
                                index++;
                            }
                        }
                        finally {
                            SetCollectionReadOnly(originalError);
                        }
                    } catch {
                        throw;
                    }
                }
            }

            internal void RemoveWebPart(WebPart webPart) {
                string originalError = SetCollectionReadOnly(null);
                // Extra try-catch block to prevent elevation of privilege attack via exception filter
                try {
                    try {
                        _manager._partAndChildControlIDs.Remove(webPart.ID);

                        // Remove child control ID (VSWhidbey 339482)
                        GenericWebPart genericWebPart = webPart as GenericWebPart;
                        if (genericWebPart != null) {
                            _manager._partAndChildControlIDs.Remove(genericWebPart.ChildControl.ID);
                        }

                        Remove(webPart);
                        _manager._hasDataChanged = true;
                        webPart.SetWebPartManager(null);
                        _manager.Internals.SetIsStandalone(webPart, true);

                        // Invalidate the part dictionary if it has already been created
                        _manager._partsForZone = null;
                    }
                    finally {
                        SetCollectionReadOnly(originalError);
                    }
                }
                catch {
                    throw;
                }
            }
        }

        private sealed class BrowseWebPartDisplayMode : WebPartDisplayMode {

            public BrowseWebPartDisplayMode() : base("Browse") {
            }
        }

        private sealed class CatalogWebPartDisplayMode : WebPartDisplayMode {

            public CatalogWebPartDisplayMode() : base("Catalog") {
            }

            public override bool AllowPageDesign {
                get {
                    return true;
                }
            }

            public override bool AssociatedWithToolZone {
                get {
                    return true;
                }
            }

            public override bool RequiresPersonalization {
                get {
                    return true;
                }
            }

            public override bool ShowHiddenWebParts {
                get {
                    return true;
                }
            }
        }

        private sealed class ConnectionPointKey {
            // DevDiv Bugs 38677
            // used as the Cache key for Connection Points, using Type and Culture
            private Type _type;
            private CultureInfo _culture;
            private CultureInfo _uiCulture;

            public ConnectionPointKey(Type type, CultureInfo culture, CultureInfo uiCulture) {
                 Debug.Assert(type != null && culture != null && uiCulture != null);

                 _type = type;
                 _culture = culture;
                 _uiCulture = uiCulture;
            }

            public override bool Equals(object obj) {
                 if (obj == this) {
                      return true;
                 }

                 ConnectionPointKey other = obj as ConnectionPointKey;
                 return (other != null) &&
				    (other._type.Equals(_type)) &&
				    (other._culture.Equals(_culture)) &&
				    (other._uiCulture.Equals(_uiCulture));
            }

            [SuppressMessage("Microsoft.Usage", "CA2303:FlagTypeGetHashCode", Justification = "The types are Sytem.Web.UI.Control derived classes and not com interop types.")]
            public override int GetHashCode()
            {
                 int typeHashCode = _type.GetHashCode();
                 // This is the algorithm used in Whidbey to combine hashcodes.
                 // It adheres better than a simple XOR to the randomness requirement for hashcodes.
                 int hashCode = ((typeHashCode << 5) + typeHashCode) ^ _culture.GetHashCode();
                 return ((hashCode << 5) + hashCode) ^ _uiCulture.GetHashCode();
            }
        }

        private sealed class ConnectWebPartDisplayMode : WebPartDisplayMode {

            public ConnectWebPartDisplayMode() : base("Connect") {
            }

            public override bool AllowPageDesign {
                get {
                    return true;
                }
            }

            public override bool AssociatedWithToolZone {
                get {
                    return true;
                }
            }

            public override bool RequiresPersonalization {
                get {
                    return true;
                }
            }

            public override bool ShowHiddenWebParts {
                get {
                    return true;
                }
            }
        }

        private sealed class DesignWebPartDisplayMode : WebPartDisplayMode {

            public DesignWebPartDisplayMode() : base("Design") {
            }

            public override bool AllowPageDesign {
                get {
                    return true;
                }
            }

            public override bool RequiresPersonalization {
                get {
                    return true;
                }
            }

            public override bool ShowHiddenWebParts {
                get {
                    return true;
                }
            }
        }

        private sealed class EditWebPartDisplayMode : WebPartDisplayMode {

            public EditWebPartDisplayMode() : base("Edit") {
            }

            public override bool AllowPageDesign {
                get {
                    return true;
                }
            }

            public override bool AssociatedWithToolZone {
                get {
                    return true;
                }
            }

            public override bool RequiresPersonalization {
                get {
                    return true;
                }
            }

            public override bool ShowHiddenWebParts {
                get {
                    return true;
                }
            }
        }
    }
}