HyperLink.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Web / UI / WebControls / HyperLink.cs / 1305376 / HyperLink.cs

                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Web.UI.WebControls { 
 
    using System;
    using System.ComponentModel; 
    using System.Drawing.Design;
    using System.Web;
    using System.Web.UI;
    using System.Web.Util; 

    ///  
    /// Interacts with the parser to build a . 
    /// 
    public class HyperLinkControlBuilder : ControlBuilder { 


        /// 
        ///    Gets a value to indicate whether or not white spaces are allowed in literals for this control. This 
        ///       property is read-only.
        ///  
        public override bool AllowWhitespaceLiterals() { 
            return false;
        } 
    }


 
    /// 
    ///    Creates a link for the browser to navigate to another page. 
    ///  
    [
    ControlBuilderAttribute(typeof(HyperLinkControlBuilder)), 
    DataBindingHandler("System.Web.UI.Design.HyperLinkDataBindingHandler, " + AssemblyRef.SystemDesign),
    DefaultProperty("Text"),
    Designer("System.Web.UI.Design.WebControls.HyperLinkDesigner, " + AssemblyRef.SystemDesign),
    ToolboxData("<{0}:HyperLink runat=\"server\">HyperLink"), 
    ParseChildren(false)
    ] 
    public class HyperLink : WebControl { 
        private bool _textSetByAddParsedSubObject = false;
 
        /// 
        /// Initializes a new instance of the  class.
        /// 
        public HyperLink() : base(HtmlTextWriterTag.A) { 
        }
 
 
        /// 
        ///    Gets or sets the URL reference to an image to display as an alternative to plain text for the 
        ///       hyperlink.
        /// 
        [
        Bindable(true), 
        WebCategory("Appearance"),
        DefaultValue(""), 
        Editor("System.Web.UI.Design.ImageUrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)), 
        UrlProperty(),
        WebSysDescription(SR.HyperLink_ImageUrl) 
        ]
        public virtual string ImageUrl {
            get {
                string s = (string)ViewState["ImageUrl"]; 
                return((s == null) ? String.Empty : s);
            } 
            set { 
                ViewState["ImageUrl"] = value;
            } 
        }


 
        /// 
        ///    Gets or sets the URL reference to navigate to when the hyperlink is clicked. 
        ///  
        [
        Bindable(true), 
        WebCategory("Navigation"),
        DefaultValue(""),
        Editor("System.Web.UI.Design.UrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
        UrlProperty(), 
        WebSysDescription(SR.HyperLink_NavigateUrl)
        ] 
        public string NavigateUrl { 
            get {
                string s = (string)ViewState["NavigateUrl"]; 
                return((s == null) ? String.Empty : s);
            }
            set {
                ViewState["NavigateUrl"] = value; 
            }
        } 
 
        public override bool SupportsDisabledAttribute {
            get { 
                return RenderingCompatibility < VersionUtil.Framework40;
            }
        }
 
        internal override bool RequiresLegacyRendering {
            get { 
                return true; 
            }
        } 


        /// 
        ///    Gets or sets the target window or frame the contents of 
        ///       the  will be displayed into when clicked.
        ///  
        [ 
        WebCategory("Navigation"),
        DefaultValue(""), 
        WebSysDescription(SR.HyperLink_Target),
        TypeConverter(typeof(TargetConverter))
        ]
        public string Target { 
            get {
                string s = (string)ViewState["Target"]; 
                return((s == null) ? String.Empty : s); 
            }
            set { 
                ViewState["Target"] = value;
            }
        }
 

        ///  
        ///     
        ///       Gets or sets the text displayed for the .
        ///  
        [
        Localizable(true),
        Bindable(true),
        WebCategory("Appearance"), 
        DefaultValue(""),
        WebSysDescription(SR.HyperLink_Text), 
        PersistenceMode(PersistenceMode.InnerDefaultProperty) 
        ]
        public virtual string Text { 
            get {
                object o = ViewState["Text"];
                return((o == null) ? String.Empty : (string)o);
            } 
            set {
                if (HasControls()) { 
                    Controls.Clear(); 
                }
                ViewState["Text"] = value; 
            }
        }

        ///  
        /// 
        /// Adds the attribututes of the a  to the output 
        ///    stream for rendering. 
        /// 
        protected override void AddAttributesToRender(HtmlTextWriter writer) { 
            if (Enabled && !IsEnabled && SupportsDisabledAttribute) {
                // We need to do the cascade effect on the server, because the browser
                // only renders as disabled, but doesn't disable the functionality.
                writer.AddAttribute(HtmlTextWriterAttribute.Disabled, "disabled"); 
            }
 
            base.AddAttributesToRender(writer); 

            string s = NavigateUrl; 
            if ((s.Length > 0) && IsEnabled) {
                string resolvedUrl = ResolveClientUrl(s);
                writer.AddAttribute(HtmlTextWriterAttribute.Href, resolvedUrl);
            } 
            s = Target;
            if (s.Length > 0) { 
                writer.AddAttribute(HtmlTextWriterAttribute.Target, s); 
            }
        } 

        protected override void AddParsedSubObject(object obj) {
            if (HasControls()) {
                base.AddParsedSubObject(obj); 
            }
            else { 
                if (obj is LiteralControl) { 
                    if (_textSetByAddParsedSubObject) {
                        Text += ((LiteralControl)obj).Text; 
                    }
                    else {
                        Text = ((LiteralControl)obj).Text;
                    } 
                    _textSetByAddParsedSubObject = true;
                } 
                else { 
                    string currentText = Text;
                    if (currentText.Length != 0) { 
                        //Text was set to String.Empty, which cause clearing all child controls when LoadViewState(DevDiv Bugs 159505)
                        Text = null;
                        base.AddParsedSubObject(new LiteralControl(currentText));
                    } 
                    base.AddParsedSubObject(obj);
                } 
            } 
        }
 

        /// 
        /// 
        ///    Load previously saved state. 
        ///    Overridden to synchronize Text property with LiteralContent.
        ///  
        protected override void LoadViewState(object savedState) { 
            if (savedState != null) {
                base.LoadViewState(savedState); 
                string s = (string)ViewState["Text"];
                // Dev10 703061 If Text is set, we want to clear out any child controls, but not dirty viewstate
                if (s != null && HasControls()) {
                    Controls.Clear(); 
                }
            } 
        } 

 
        /// 
        /// 
        /// Displays the  on a page.
        ///  
        protected internal override void RenderContents(HtmlTextWriter writer) {
            string s = ImageUrl; 
            if (s.Length > 0) { 
                Image img = new Image();
 
                // NOTE: The Url resolution happens right here, because the image is not parented
                //       and will not be able to resolve when it tries to do so.
                img.ImageUrl = ResolveClientUrl(s);
                img.UrlResolved = true; 
                img.GenerateEmptyAlternateText = true;
 
                s = ToolTip; 
                if (s.Length != 0) {
                    img.ToolTip = s; 
                }

                s = Text;
                if (s.Length != 0) { 
                    img.AlternateText = s;
                } 
                img.RenderControl(writer); 
            }
            else { 
                if (HasRenderingData()) {
                    base.RenderContents(writer);
                }
                else { 
                    writer.Write(Text);
                } 
            } 
        }
    } 
}


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

Link Menu

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