ImageMap.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Web / UI / WebControls / ImageMap.cs / 1305376 / ImageMap.cs
                        
                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 
namespace System.Web.UI.WebControls {
 
    using System; 
    using System.ComponentModel;
    using System.Globalization; 
    using System.Web.UI;
    using System.Web.UI.WebControls;
    using System.Web.Util;
    using System.Web; 

    ///  
    /// ImageMap class.  Provides support for multiple 
    /// region-defined actions within an image.
    ///  
    [
    DefaultEvent("Click"),
    DefaultProperty("HotSpots"),
    ParseChildren(true, "HotSpots"), 
    SupportsEventValidation,
    ] 
    public class ImageMap : Image, IPostBackEventHandler { 

        private static readonly object EventClick = new object(); 
        private bool _hasHotSpots;
        private HotSpotCollection _hotSpots;

        [ 
        Browsable(true),
        EditorBrowsableAttribute(EditorBrowsableState.Always) 
        ] 
        public override bool Enabled {
            get { 
                return base.Enabled;
            }
            set {
                base.Enabled = value; 
            }
        } 
 
        /// 
        /// Gets the HotSpotCollection with defines the regions of ImageMap hot spots. 
        /// 
        [
        WebCategory("Behavior"),
        WebSysDescription(SR.ImageMap_HotSpots), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true), 
        PersistenceMode(PersistenceMode.InnerDefaultProperty) 
        ]
        public HotSpotCollection HotSpots { 
            get {
                if (_hotSpots == null) {
                    _hotSpots = new HotSpotCollection();
                    if (IsTrackingViewState) { 
                        ((IStateManager)_hotSpots).TrackViewState();
                    } 
                } 
                return _hotSpots;
            } 
        }


        ///  
        /// Gets or sets the HotSpotMode to either postback or navigation.
        ///  
        [ 
        WebCategory("Behavior"),
        DefaultValue(HotSpotMode.NotSet), 
        WebSysDescription(SR.HotSpot_HotSpotMode),
        ]
        public virtual HotSpotMode HotSpotMode {
            get { 
                object obj = ViewState["HotSpotMode"];
                return (obj == null) ? HotSpotMode.NotSet : (HotSpotMode)obj; 
            } 
            set {
                if (value < HotSpotMode.NotSet || value > HotSpotMode.Inactive) { 
                    throw new ArgumentOutOfRangeException("value");
                }
                ViewState["HotSpotMode"] = value;
            } 
        }
 
 
        /// 
        /// Gets or sets the name of the window for navigation. 
        /// 
        [
        WebCategory("Behavior"),
        DefaultValue(""), 
        WebSysDescription(SR.HotSpot_Target),
        ] 
        public virtual string Target { 
            get {
                object value = ViewState["Target"]; 
                return (value == null)? String.Empty : (string)value;
            }
            set {
                ViewState["Target"] = value; 
            }
        } 
 
        /// 
        /// The event raised when a hotspot is clicked. 
        /// 
        [
        Category("Action"),
        WebSysDescription(SR.ImageMap_Click) 
        ]
        public event ImageMapEventHandler Click { 
            add { 
                Events.AddHandler(EventClick, value);
            } 
            remove {
                Events.RemoveHandler(EventClick, value);
            }
        } 

 
        ///  
        /// 
        /// Overridden to add the "usemap" attribute the the image tag. 
        /// Overrides WebControl.AddAttributesToRender.
        /// 
        protected override void AddAttributesToRender(HtmlTextWriter writer) {
            base.AddAttributesToRender(writer); 

            if (_hasHotSpots) { 
                writer.AddAttribute(HtmlTextWriterAttribute.Usemap, "#ImageMap" + ClientID, false); 
            }
        } 

        /// 
        /// Restores view-state information that was saved by SaveViewState.
        /// Implements IStateManager.LoadViewState. 
        /// 
        protected override void LoadViewState(object savedState) { 
            object baseState = null; 
            object[] myState = null;
 
            if (savedState != null) {
                myState = (object[])savedState;
                if (myState.Length != 2) {
                    throw new ArgumentException(SR.GetString(SR.ViewState_InvalidViewState)); 
                }
 
                baseState = myState[0]; 
            }
 
            base.LoadViewState(baseState);

            if ((myState != null) && (myState[1] != null)) {
                ((IStateManager)HotSpots).LoadViewState(myState[1]); 
            }
        } 
 

        ///  
        /// Called when the user clicks the ImageMap.
        /// 
        protected virtual void OnClick(ImageMapEventArgs e) {
            ImageMapEventHandler clickHandler = (ImageMapEventHandler)Events[EventClick]; 
            if (clickHandler != null) {
                clickHandler(this, e); 
            } 
        }
 
        /// 
        /// 
        /// Sends server control content to a provided HtmlTextWriter, which writes the content
        /// to be rendered to the client. 
        /// Overrides Control.Render.
        ///  
        protected internal override void Render(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");
            }
 
            _hasHotSpots = ((_hotSpots != null) && (_hotSpots.Count > 0));
 
            base.Render(writer); 

            if (_hasHotSpots) { 
                string fullClientID = "ImageMap" + ClientID;
                writer.AddAttribute(HtmlTextWriterAttribute.Name, fullClientID);
                writer.AddAttribute(HtmlTextWriterAttribute.Id, fullClientID);
                writer.RenderBeginTag(HtmlTextWriterTag.Map); 

                HotSpotMode mapMode = HotSpotMode; 
                if (mapMode == HotSpotMode.NotSet) { 
                    mapMode = HotSpotMode.Navigate;
                } 
                HotSpotMode spotMode;
                int hotSpotIndex = 0;
                string controlTarget = Target;
                foreach (HotSpot item in _hotSpots) { 
                    writer.AddAttribute(HtmlTextWriterAttribute.Shape, item.MarkupName, false);
                    writer.AddAttribute(HtmlTextWriterAttribute.Coords, item.GetCoordinates()); 
                    spotMode = item.HotSpotMode; 
                    if (spotMode == HotSpotMode.NotSet) {
                        spotMode = mapMode; 
                    }
                    if (spotMode == HotSpotMode.PostBack) {
                        // Make sure the page has a server side form if we are posting back
                        if (Page != null) { 
                            Page.VerifyRenderingInServerForm(this);
                        } 
                        if ((RenderingCompatibility < VersionUtil.Framework40) || IsEnabled) { 
                            string eventArgument = hotSpotIndex.ToString(CultureInfo.InvariantCulture);
                            writer.AddAttribute(HtmlTextWriterAttribute.Href, 
                                Page.ClientScript.GetPostBackClientHyperlink(this, eventArgument, true));
                        }
                    }
                    else if (spotMode == HotSpotMode.Navigate) { 
                        if ((RenderingCompatibility < VersionUtil.Framework40) || IsEnabled) {
                            String resolvedUrl = ResolveClientUrl(item.NavigateUrl); 
                            writer.AddAttribute(HtmlTextWriterAttribute.Href, resolvedUrl); 
                        }
                        // Use HotSpot target first, if not specified, use ImageMap's target 
                        string target = item.Target;
                        if (target.Length == 0) target = controlTarget;
                        if (target.Length > 0) writer.AddAttribute(HtmlTextWriterAttribute.Target, target);
                    } 
                    else if (spotMode == HotSpotMode.Inactive) {
                        writer.AddAttribute("nohref", "true"); 
                    } 
                    writer.AddAttribute(HtmlTextWriterAttribute.Title, item.AlternateText);
                    writer.AddAttribute(HtmlTextWriterAttribute.Alt, item.AlternateText); 
                    string s = item.AccessKey;
                    if (s.Length > 0) {
                        writer.AddAttribute(HtmlTextWriterAttribute.Accesskey, s);
                    } 
                    int n = item.TabIndex;
                    if (n != 0) { 
                        writer.AddAttribute(HtmlTextWriterAttribute.Tabindex, n.ToString(NumberFormatInfo.InvariantInfo)); 
                    }
 
                    writer.RenderBeginTag(HtmlTextWriterTag.Area);
                    writer.RenderEndTag();
                    ++hotSpotIndex;
                } 
                writer.RenderEndTag();  // Map
            } 
        } 

 
        /// 
        /// Saves any server control view-state changes that have
        /// occurred since the time the page was posted back to the server.
        /// Implements IStateManager.SaveViewState. 
        /// 
        protected override object SaveViewState() { 
            object baseState = base.SaveViewState(); 
            object hotSpotsState = null;
 
            if ((_hotSpots != null) && (_hotSpots.Count > 0)) {
                hotSpotsState = ((IStateManager)_hotSpots).SaveViewState();
            }
 
            if ((baseState != null) || (hotSpotsState != null)) {
                object[] savedState = new object[2]; 
                savedState[0] = baseState; 
                savedState[1] = hotSpotsState;
 
                return savedState;
            }

            return null; 
        }
 
 
        /// 
        /// Causes the tracking of view-state changes to the server control. 
        /// Implements IStateManager.TrackViewState.
        /// 
        protected override void TrackViewState() {
            base.TrackViewState(); 
            if (_hotSpots != null) {
                ((IStateManager)_hotSpots).TrackViewState(); 
            } 
        }
 
        #region Implementation of IPostBackEventHandler

        /// 
        ///  
        /// Notifies the server control that caused the postback that
        /// it should handle an incoming post back event. 
        /// Implements IPostBackEventHandler. 
        /// 
        void IPostBackEventHandler.RaisePostBackEvent(string eventArgument) { 
            RaisePostBackEvent(eventArgument);
        }

 
        /// 
        ///  
        /// Notifies the server control that caused the postback that 
        /// it should handle an incoming post back event.
        /// Implements IPostBackEventHandler. 
        /// 
        protected virtual void RaisePostBackEvent(string eventArgument) {
            ValidateEvent(UniqueID, eventArgument);
 
            string postBackValue = null;
            if (eventArgument != null && _hotSpots != null) { 
                int hotSpotIndex = Int32.Parse(eventArgument, CultureInfo.InvariantCulture); 

                if (hotSpotIndex >= 0 && hotSpotIndex < _hotSpots.Count) { 
                    HotSpot hotSpot = _hotSpots[hotSpotIndex];
                    HotSpotMode mode = hotSpot.HotSpotMode;
                    if (mode == HotSpotMode.NotSet) {
                        mode = HotSpotMode; 
                    }
                    if (mode == HotSpotMode.PostBack) { 
                        postBackValue = hotSpot.PostBackValue; 
                    }
                } 
            }
            // Ignore invalid indexes silently(VSWhidbey 185738)
            if (postBackValue != null) {
                OnClick(new ImageMapEventArgs(postBackValue)); 
            }
        } 
        #endregion 
    }
} 

// 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
ImageMap.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
