Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web/UI/WebParts/LayoutEditorPart.cs

@@ -0,0 +1,271 @@
+//------------------------------------------------------------------------------
+// <copyright file="LayoutEditorPart.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web.UI.WebControls.WebParts {
+
+    using System;
+    using System.Collections;
+    using System.ComponentModel;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.Web.UI;
+    using System.Web.UI.WebControls;
+
+    public sealed class LayoutEditorPart : EditorPart {
+
+        private DropDownList _chromeState;
+        private DropDownList _zone;
+        // 
+
+        private TextBox _zoneIndex;
+
+        private string _chromeStateErrorMessage;
+        private string _zoneIndexErrorMessage;
+
+        private const int TextBoxColumns = 10;
+        private const int MinZoneIndex = 0;
+
+        private bool CanChangeChromeState {
+            get {
+                WebPart webPart = WebPartToEdit;
+                if (!webPart.Zone.AllowLayoutChange) {
+                    return false;
+                }
+                else if (!webPart.AllowMinimize) {
+                    // If AllowMinimize is false, the dropdown can be used to restore the WebPart
+                    // but not to minimize the WebPart.
+                    return (webPart.ChromeState == PartChromeState.Minimized);
+                }
+                else {
+                    return true;
+                }
+            }
+        }
+
+        private bool CanChangeZone {
+            get {
+                WebPart webPart = WebPartToEdit;
+                WebPartZoneBase currentZone = webPart.Zone;
+                return (currentZone.AllowLayoutChange && webPart.AllowZoneChange);
+            }
+        }
+
+        private bool CanChangeZoneIndex {
+            get {
+                return WebPartToEdit.Zone.AllowLayoutChange;
+            }
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never), Themeable(false)]
+        public override string DefaultButton {
+            get { return base.DefaultButton; }
+            set { base.DefaultButton = value; }
+        }
+
+        public override bool Display {
+            get {
+                // Don't return base.Display, since we want to show the layout editor part even
+                // if AllowEdit is false on the WebPartToEdit, or the WebPartToEdit is a ProxyWebPart.
+                return true;
+            }
+        }
+
+        private bool HasError {
+            get {
+                return (_chromeStateErrorMessage != null || _zoneIndexErrorMessage != null);
+            }
+        }
+
+        [
+        WebSysDefaultValue(SR.LayoutEditorPart_PartTitle),
+        ]
+        public override string Title {
+            get {
+                string s = (string)ViewState["Title"];
+                return (s != null) ? s : SR.GetString(SR.LayoutEditorPart_PartTitle);
+            }
+            set {
+                ViewState["Title"] = value;
+            }
+        }
+
+        public override bool ApplyChanges() {
+            WebPart webPart = WebPartToEdit;
+            if (webPart != null) {
+                EnsureChildControls();
+
+                try {
+                    if (CanChangeChromeState) {
+                        TypeConverter chromeStateConverter = TypeDescriptor.GetConverter(typeof(PartChromeState));
+                        webPart.ChromeState = (PartChromeState)chromeStateConverter.ConvertFromString(_chromeState.SelectedValue);
+                    }
+                }
+                catch (Exception e) {
+                    _chromeStateErrorMessage = CreateErrorMessage(e.Message);
+                }
+
+                int zoneIndex = webPart.ZoneIndex;
+                if (CanChangeZoneIndex) {
+                    if (Int32.TryParse(_zoneIndex.Text, NumberStyles.Integer, CultureInfo.CurrentCulture, out zoneIndex)) {
+                        if (zoneIndex < MinZoneIndex) {
+                            _zoneIndexErrorMessage = SR.GetString(SR.EditorPart_PropertyMinValue, MinZoneIndex.ToString(CultureInfo.CurrentCulture));
+                        }
+                    }
+                    else {
+                        _zoneIndexErrorMessage = SR.GetString(SR.EditorPart_PropertyMustBeInteger);
+                    }
+                }
+
+                WebPartZoneBase oldZone = webPart.Zone;
+                WebPartZoneBase newZone = oldZone;
+                if (CanChangeZone) {
+                    newZone = WebPartManager.Zones[_zone.SelectedValue];
+                }
+
+                // Do not call MoveWebPart if the WebPart is currently in the correct position (VSWhidbey 374634)
+                if (_zoneIndexErrorMessage == null && oldZone.AllowLayoutChange && newZone.AllowLayoutChange &&
+                    (webPart.Zone != newZone || webPart.ZoneIndex != zoneIndex)) {
+                    try {
+                        WebPartManager.MoveWebPart(webPart, newZone, zoneIndex);
+                    }
+                    catch (Exception e) {
+                        // Zone and ZoneIndex are set at the same time.  Use the _zoneIndexErrorMessage, since it is
+                        // more likely that a bogus ZoneIndex would cause an error.
+                        _zoneIndexErrorMessage = CreateErrorMessage(e.Message);
+                    }
+                }
+            }
+
+            return !HasError;
+        }
+
+        protected internal override void CreateChildControls() {
+            ControlCollection controls = Controls;
+            controls.Clear();
+
+            TypeConverter chromeStateConverter = TypeDescriptor.GetConverter(typeof(PartChromeState));
+            _chromeState = new DropDownList();
+            _chromeState.Items.Add(new ListItem(SR.GetString(SR.PartChromeState_Normal),
+                                               chromeStateConverter.ConvertToString(PartChromeState.Normal)));
+            _chromeState.Items.Add(new ListItem(SR.GetString(SR.PartChromeState_Minimized),
+                                               chromeStateConverter.ConvertToString(PartChromeState.Minimized)));
+            controls.Add(_chromeState);
+
+            // Add all zones to dropdown in CreateChildControls.  Items will be selected and/or disabled
+            // in SyncChanges.  Assumes no Zones are added or removed during page execution.
+            _zone = new DropDownList();
+            WebPartManager manager = WebPartManager;
+            if (manager != null) {
+                WebPartZoneCollection zones = manager.Zones;
+                if (zones != null) {
+                    foreach (WebPartZoneBase zone in zones) {
+                        ListItem item = new ListItem(zone.DisplayTitle, zone.ID);
+                        _zone.Items.Add(item);
+                    }
+                }
+            }
+            controls.Add(_zone);
+
+            _zoneIndex = new TextBox();
+            _zoneIndex.Columns = TextBoxColumns;
+            controls.Add(_zoneIndex);
+
+            // We don't need viewstate enabled on our child controls.  Disable for perf.
+            foreach (Control c in controls) {
+                c.EnableViewState = false;
+            }
+        }
+
+        protected internal override void OnPreRender(EventArgs e) {
+            base.OnPreRender(e);
+
+            // We want to synchronize the EditorPart to the state of the WebPart on every page load,
+            // so we stay current if the WebPart changes in the background.
+            if (Display && Visible && !HasError) {
+                SyncChanges();
+            }
+        }
+
+        protected internal override void RenderContents(HtmlTextWriter writer) {
+            if (Page != null) {
+                Page.VerifyRenderingInServerForm(this);
+            }
+
+            // HACK: Need this for child controls to be created at design-time when control is inside template
+            EnsureChildControls();
+
+            if (DesignMode) {
+                // Add sample zone to dropdown
+                _zone.Items.Add(SR.GetString(SR.Zone_SampleHeaderText));
+            }
+
+            string[] propertyDisplayNames = new string[] {
+                SR.GetString(SR.LayoutEditorPart_ChromeState),
+                SR.GetString(SR.LayoutEditorPart_Zone),
+                SR.GetString(SR.LayoutEditorPart_ZoneIndex),
+            };
+
+            WebControl[] propertyEditors = new WebControl[] {
+                _chromeState,
+                _zone,
+                _zoneIndex,
+            };
+
+            string[] errorMessages = new string[] {
+                _chromeStateErrorMessage,
+                null,
+                _zoneIndexErrorMessage,
+            };
+
+            RenderPropertyEditors(writer, propertyDisplayNames, null /* propertyDescriptions */,
+                                  propertyEditors, errorMessages);
+        }
+
+        public override void SyncChanges() {
+            WebPart webPart = WebPartToEdit;
+
+            Debug.Assert(webPart != null);
+            if (webPart != null) {
+                WebPartZoneBase currentZone = webPart.Zone;
+                bool allowLayoutChange = currentZone.AllowLayoutChange;
+
+                EnsureChildControls();
+
+                TypeConverter chromeStateConverter = TypeDescriptor.GetConverter(typeof(PartChromeState));
+                _chromeState.SelectedValue = chromeStateConverter.ConvertToString(webPart.ChromeState);
+                _chromeState.Enabled = CanChangeChromeState;
+
+                WebPartManager manager = WebPartManager;
+                Debug.Assert(manager != null);
+                if (manager != null) {
+                    WebPartZoneCollection zones = manager.Zones;
+                    bool allowZoneChange = webPart.AllowZoneChange;
+
+                    _zone.ClearSelection();
+                    foreach (ListItem item in _zone.Items) {
+                        string zoneID = item.Value;
+                        WebPartZoneBase zone = zones[zoneID];
+                        if (zone == currentZone || (allowZoneChange && zone.AllowLayoutChange)) {
+                            item.Enabled = true;
+                        }
+                        else {
+                            item.Enabled = false;
+                        }
+
+                        if (zone == currentZone) {
+                            item.Selected = true;
+                        }
+                    }
+
+                    _zone.Enabled = CanChangeZone;
+                }
+
+                _zoneIndex.Text = webPart.ZoneIndex.ToString(CultureInfo.CurrentCulture);
+                _zoneIndex.Enabled = CanChangeZoneIndex;
+            }
+        }
+    }
+}