EditorPart.cs source code in C# .NET

                        Code:
                         / FXUpdate3074 / FXUpdate3074 / 1.1 / untmp / whidbey / QFE / ndp / fx / src / xsp / System / Web / UI / WebParts / EditorPart.cs / 2 / EditorPart.cs
                        
                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Web.UI.WebControls.WebParts { 
 
    using System;
    using System.Collections; 
    using System.Collections.Specialized;
    using System.ComponentModel;
    using System.Diagnostics;
    using System.Drawing; 
    using System.Globalization;
    using System.Security.Permissions; 
    using System.Web.UI; 
    using System.Web.UI.WebControls;
 
    [
    Bindable(false),
    Designer("System.Web.UI.Design.WebControls.WebParts.EditorPartDesigner, " + AssemblyRef.SystemDesign),
    ] 
    [AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
    [AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)] 
    public abstract class EditorPart : Part { 

        private WebPart _webPartToEdit; 
        private WebPartManager _webPartManager;
        private EditorZoneBase _zone;

        ///  
        /// Whether the editor part should be displayed to the user.
        /// An editor part may decide that it should not be shown based on the state 
        /// or the type of web part it is associated with. 
        /// 
        [ 
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public virtual bool Display { 
            get {
                // Always want EditorPart to be visible at design time ( 
                if (DesignMode) { 
                    return true;
                } 

                if (WebPartToEdit != null) {
                    // Do not display EditorParts for a ProxyWebPart, regardless of the value
                    // of AllowEdit, IsShared, and PersonalizationScope 
                    if (WebPartToEdit is ProxyWebPart) {
                        return false; 
                    } 

                    if (!WebPartToEdit.AllowEdit && 
                        WebPartToEdit.IsShared &&
                        WebPartManager != null &&
                        WebPartManager.Personalization.Scope == PersonalizationScope.User) {
                        return false; 
                    }
 
                    return true; 
                }
 
                // If there is no WebPartToEdit, return false as a default case
                return false;
            }
        } 

        [ 
        Browsable(false), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ] 
        public string DisplayTitle {
            get {
                string displayTitle = Title;
                if (String.IsNullOrEmpty(displayTitle)) { 
                    displayTitle = SR.GetString(SR.Part_Untitled);
                } 
                return displayTitle; 
            }
        } 

        protected WebPartManager WebPartManager {
            get {
                return _webPartManager; 
            }
        } 
 
        /// 
        /// The web part that is being edited by this editor part.  Set by the EditorZoneBase after 
        /// the EditorPart is added to the zone's control collection.
        /// 
        protected WebPart WebPartToEdit {
            get { 
                return _webPartToEdit;
            } 
        } 

        protected EditorZoneBase Zone { 
            get {
                return _zone;
            }
        } 

        ///  
        /// Called by the Zone when the EditorPart should apply values to its associated control.  True indicates 
        /// that the save was successful, false indicates that an error occurred.
        ///  
        public abstract bool ApplyChanges();

        // If custom errors are enabled, we do not want to render the exception message to the browser. (
        internal string CreateErrorMessage(string exceptionMessage) { 
            if (Context != null && Context.IsCustomErrorEnabled) {
                return SR.GetString(SR.EditorPart_ErrorSettingProperty); 
            } 
            else {
                return SR.GetString(SR.EditorPart_ErrorSettingPropertyWithExceptionMessage, exceptionMessage); 
            }
        }

        [SecurityPermission(SecurityAction.Demand, Unrestricted = true)] 
        protected override IDictionary GetDesignModeState() {
            IDictionary state = new HybridDictionary(1); 
            state["Zone"] = Zone; 
            return state;
        } 

        protected internal override void OnPreRender(EventArgs e) {
            base.OnPreRender(e);
 
            if (Zone == null) {
                throw new InvalidOperationException(SR.GetString(SR.EditorPart_MustBeInZone, ID)); 
            } 

            // Need to set Visible=false so postback is handled correctly for child controls 
            // i.e. CheckBox child controls will always be set to false after postback unless
            // they are marked as not visible
            if (Display == false) {
                Visible = false; 
            }
        } 
 
        private void RenderDisplayName(HtmlTextWriter writer, string displayName, string associatedClientID) {
            if (Zone != null) { 
                Zone.LabelStyle.AddAttributesToRender(writer, this);
            }
            writer.AddAttribute(HtmlTextWriterAttribute.For, associatedClientID);
            writer.RenderBeginTag(HtmlTextWriterTag.Label); 
            writer.WriteEncodedText(displayName);
            writer.RenderEndTag();  // Label 
        } 

        internal void RenderPropertyEditors(HtmlTextWriter writer, string[] propertyDisplayNames, string[] propertyDescriptions, 
                                            WebControl[] propertyEditors, string[] errorMessages) {
            Debug.Assert(propertyDisplayNames.Length == propertyEditors.Length);
            Debug.Assert(propertyDisplayNames.Length == errorMessages.Length);
            Debug.Assert(propertyDescriptions == null || (propertyDescriptions.Length == propertyDisplayNames.Length)); 

            if (propertyDisplayNames.Length == 0) { 
                return; 
            }
 
            writer.AddAttribute(HtmlTextWriterAttribute.Border, "0");
            writer.AddAttribute(HtmlTextWriterAttribute.Cellspacing, "4");
            writer.RenderBeginTag(HtmlTextWriterTag.Table);
 
            for (int i = 0; i < propertyDisplayNames.Length; i++) {
                WebControl editUIControl = propertyEditors[i]; 
                if (Zone != null && !Zone.EditUIStyle.IsEmpty) { 
                    editUIControl.ApplyStyle(Zone.EditUIStyle);
                } 

                string propertyDescription = (propertyDescriptions != null) ? propertyDescriptions[i] : null;
                if (!String.IsNullOrEmpty(propertyDescription)) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Title, propertyDescription); 
                }
 
                writer.RenderBeginTag(HtmlTextWriterTag.Tr); 
                writer.RenderBeginTag(HtmlTextWriterTag.Td);
 
                if (editUIControl is CheckBox) {
                    editUIControl.RenderControl(writer);
                    writer.Write(" ");
                    RenderDisplayName(writer, propertyDisplayNames[i], editUIControl.ClientID); 
                }
                else { 
                    string associatedClientID; 
                    CompositeControl compositeControl = editUIControl as CompositeControl;
                    if (compositeControl != null) { 
                        // The  tag should point to the first child control of the
                        // composite control. (
                        associatedClientID = compositeControl.Controls[0].ClientID;
                    } 
                    else {
                        // The  tag should point to the editUIControl itself. 
                        associatedClientID = editUIControl.ClientID; 
                    }
 
                    RenderDisplayName(writer, propertyDisplayNames[i] + ":", associatedClientID);
                    writer.WriteBreak();
                    writer.WriteLine();
                    editUIControl.RenderControl(writer); 
                }
                writer.WriteBreak(); 
                writer.WriteLine(); 

                string errorMessage = errorMessages[i]; 
                if (!String.IsNullOrEmpty(errorMessage)) {
                    if (Zone != null && !Zone.ErrorStyle.IsEmpty) {
                        Zone.ErrorStyle.AddAttributesToRender(writer, this);
                    } 

                    writer.RenderBeginTag(HtmlTextWriterTag.Span); 
                    writer.WriteEncodedText(errorMessage); 
                    writer.RenderEndTag();  // Span
                    writer.WriteBreak(); 
                    writer.WriteLine();
                }

                writer.RenderEndTag();  // Td 
                writer.RenderEndTag();  // Tr
            } 
 
            writer.RenderEndTag();  // Table
        } 

        [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
        protected override void SetDesignModeState(IDictionary data) {
            if (data != null) { 
                object o = data["Zone"];
                if (o != null) { 
                    SetZone((EditorZoneBase)o); 
                }
            } 
        }

        internal void SetWebPartToEdit(WebPart webPartToEdit) {
            _webPartToEdit = webPartToEdit; 
        }
 
        internal void SetWebPartManager(WebPartManager webPartManager) { 
            _webPartManager = webPartManager;
        } 

        internal void SetZone(EditorZoneBase zone) {
            _zone = zone;
        } 

        ///  
        /// Called by the Zone when the EditorPart should sync its values because other EditorParts 
        /// may have changed control properties.  This is only called after all the ApplyChanges have returned.
        ///  
        public abstract void SyncChanges();
    }
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu

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

Source code for the .NET framework in C#

Code:

Link Menu
