//------------------------------------------------------------------------------
// <copyright file="MenuItem.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------

namespace System.Web.UI.WebControls {
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Drawing;
    using System.Drawing.Design;
    using System.Globalization;
    using System.IO;
    using System.Text;
    using System.Web.UI;
    using System.Web.Util;


    /// <devdoc>
    ///     Provides a hierarchical menu item for use in the Menu class
    /// </devdoc>
    [ParseChildren(true, "ChildItems")]
    public sealed class MenuItem : IStateManager, ICloneable {
        
        private static readonly Unit HorizontalDefaultSpacing = Unit.Pixel(3);

        private bool _isTrackingViewState;
        private StateBag _viewState;

        private MenuItemCollection _childItems;
        private Menu _owner;
        private MenuItem _parent;

        private int _selectDesired;

        private object _dataItem;
        private MenuItemTemplateContainer _container;

        private int _index;
        internal string _id = string.Empty;

        private string _valuePath;
        private string _internalValuePath;
        private int _depth = -2;

        private bool _isRoot;


        /// <devdoc>
        ///     Constructs a new MenuItem without a text or value
        /// </devdoc>
        public MenuItem() {
            _selectDesired = 0;
        }


        /// <devdoc>
        ///     Constructs a new MenuItem with the specified owner Menu
        /// </devdoc>
        internal MenuItem(Menu owner, bool isRoot)
            : this() {
            _owner = owner;
            _isRoot = isRoot;
        }


        /// <devdoc>
        ///     Constructs a new MenuItem with the specified text
        /// </devdoc>
        public MenuItem(string text)
            : this(text, null, null, null, null) {
        }


        /// <devdoc>
        ///     Constructs a new MenuItem with the specified text, and value
        /// </devdoc>
        public MenuItem(string text, string value)
            : this(text, value, null, null, null) {
        }


        /// <devdoc>
        ///     Constructs a new MenuItem with the specified text, value, and image URL
        /// </devdoc>
        public MenuItem(string text, string value, string imageUrl)
            : this(text, value, imageUrl, null, null) {
        }


        /// <devdoc>
        ///     Constructs a new MenuItem with the specified text, value, image URL and navigateUrl
        /// </devdoc>
        public MenuItem(string text, string value, string imageUrl, string navigateUrl)
            : this(text, value, imageUrl, navigateUrl, null) {
        }


        /// <devdoc>
        ///     Constructs a new MenuItem with the specified text, value, image URL, navigation URL, and target.
        /// </devdoc>
        public MenuItem(string text, string value, string imageUrl, string navigateUrl, string target)
            : this() {
            if (text != null) {
                Text = text;
            }

            if (value != null) {
                Value = value;
            }

            if (!String.IsNullOrEmpty(imageUrl)) {
                ImageUrl = imageUrl;
            }

            if (!String.IsNullOrEmpty(navigateUrl)) {
                NavigateUrl = navigateUrl;
            }

            if (!String.IsNullOrEmpty(target)) {
                Target = target;
            }
        }


        /// <devdoc>
        ///     Gets the collection of children items parented to this MenuItem
        /// </devdoc>
        [Browsable(false)]
        [MergableProperty(false)]
        [PersistenceMode(PersistenceMode.InnerDefaultProperty)]
        public MenuItemCollection ChildItems {
            get {
                if (_childItems == null) {
                    _childItems = new MenuItemCollection(this);
                }
                return _childItems;
            }
        }

        internal MenuItemTemplateContainer Container {
            get {
                return _container;
            }
            set {
                _container = value;
            }
        }


        /// <devdoc>
        ///     Gets whether this item was created through databinding
        /// </devdoc>
        [Browsable(false)]
        [DefaultValue(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool DataBound {
            get {
                object o = ViewState["DataBound"];
                if (o == null) {
                    return false;
                }
                return (bool)o;
            }
        }


        /// <devdoc>
        ///     Gets path to the data to which this item is bound.
        /// </devdoc>
        [Browsable(false)]
        [DefaultValue("")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public string DataPath {
            get {
                object s = ViewState["DataPath"];
                if (s == null) {
                    return String.Empty;
                }
                return (string)s;
            }
        }


        /// <devdoc>
        ///     Gets the depth of the menu item.
        /// </devdoc>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int Depth {
            get {
                // -2 means not set yet, -1 means root
                if (_depth == -2) {
                    if (_isRoot) {
                        return -1;
                    }

                    if (Parent != null) {
                        _depth = Parent.Depth + 1;
                    }
                    else {
                        return 0;
                    }
                }
                return _depth;
            }
        }


        /// <devdoc>
        ///     Gets the data item for the menu item.
        /// </devdoc>
        [Browsable(false)]
        [DefaultValue(null)]
        public object DataItem {
            get {
                return _dataItem;
            }
        }

        [Browsable(true)]
        [DefaultValue(true)]
        [WebSysDescription(SR.MenuItem_Enabled)]
        public bool Enabled {
            get {
                object o = ViewState["Enabled"];
                return (o == null ? true : (bool)o);
            }
            set {
                ViewState["Enabled"] = value;
            }
        }

        internal string FormattedText {
            get {
                if (_owner.StaticItemFormatString.Length > 0 && Depth < _owner.StaticDisplayLevels) {
                    return String.Format(CultureInfo.CurrentCulture, _owner.StaticItemFormatString, Text);
                }
                else if (_owner.DynamicItemFormatString.Length > 0 && Depth >= _owner.StaticDisplayLevels) {
                    return String.Format(CultureInfo.CurrentCulture, _owner.DynamicItemFormatString, Text);
                }
                else {
                    return Text;
                }
            }
        }

        internal string Id {
            get {
                if (_id.Length == 0) {
                    Index = _owner.CreateItemIndex();
                    _id = _owner.ClientID + 'n' + Index;
                }
                return _id;
            }
        }


        /// <devdoc>
        ///     Gets and sets the image URl to be rendered for this item
        /// </devdoc>
        [DefaultValue("")]
        [Editor("System.Web.UI.Design.ImageUrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor))]
        [UrlProperty()]
        [WebSysDescription(SR.MenuItem_ImageUrl)]
        public string ImageUrl {
            get {
                object s = ViewState["ImageUrl"];
                if (s == null) {
                    return String.Empty;
                }
                return (string)s;
            }
            set {
                ViewState["ImageUrl"] = value;
            }
        }


        /// <devdoc>
        ///     Gets and sets the unique index for the menu item
        /// </devdoc>
        internal int Index {
            get {
                return _index;
            }
            set {
                _index = value;
            }
        }

        internal string InternalValuePath {
            get {
                if (_internalValuePath != null) {
                    return _internalValuePath;
                }
                if (_parent != null) {
                    // StringBuilder.Insert is expensive, but we need to build starting from the end.
                    // First build a list, then build the string starting from the end of the list.
                    List<string> pathParts = new List<string>();
                    pathParts.Add(TreeView.Escape(Value));
                    MenuItem parent = _parent;
                    while ((parent != null) && !parent._isRoot) {
                        if (parent._internalValuePath != null) {
                            pathParts.Add(parent._internalValuePath);
                            break;
                        }
                        else {
                            pathParts.Add(TreeView.Escape(parent.Value));
                        }
                        parent = parent._parent;
                    }
                    pathParts.Reverse();
                    _internalValuePath = String.Join(TreeView.InternalPathSeparator.ToString(), pathParts.ToArray());
                    return _internalValuePath;
                }
                else {
                    return String.Empty;
                }
            }
        }

        internal bool IsEnabled {
            get {
                return IsEnabledNoOwner && Owner.IsEnabled;
            }
        }

        internal bool IsEnabledNoOwner {
            get {
                MenuItem current = this;
                while (current != null) {
                    if (!current.Enabled) {
                        return false;
                    }

                    current = current.Parent;
                }

                return true;
            }
        }


        /// <devdoc>
        ///     Gets and sets the URL to navigate to when the item is clicked
        /// </devdoc>
        [DefaultValue("")]
        [Editor("System.Web.UI.Design.UrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor))]
        [UrlProperty()]
        [WebSysDescription(SR.MenuItem_NavigateUrl)]
        public string NavigateUrl {
            get {
                object s = ViewState["NavigateUrl"];
                if (s == null) {
                    return String.Empty;
                }
                return (string)s;
            }
            set {
                ViewState["NavigateUrl"] = value;
            }
        }


        /// <devdoc>
        ///     Gets the owner Menu for this MenuItem, if there is one
        /// </devdoc>
        internal Menu Owner {
            get {
                return _owner;
            }
        }


        /// <devdoc>
        ///     Gets the parent MenuItem
        /// </devdoc>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public MenuItem Parent {
            get {
                if ((_parent == null) || _parent._isRoot) {
                    return null;
                }

                return _parent;
            }

        }


        /// <devdoc>
        ///     Gets and sets the image URl to be rendered as a pop-out icon for this item if it has children
        /// </devdoc>
        [DefaultValue("")]
        [Editor("System.Web.UI.Design.ImageUrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor))]
        [UrlProperty()]
        [WebSysDescription(SR.MenuItem_PopOutImageUrl)]
        public string PopOutImageUrl {
            get {
                object s = ViewState["PopOutImageUrl"];
                if (s == null) {
                    return String.Empty;
                }
                return (string)s;
            }
            set {
                ViewState["PopOutImageUrl"] = value;
            }
        }

        [Browsable(true)]
        [DefaultValue(true)]
        [WebSysDescription(SR.MenuItem_Selectable)]
        public bool Selectable {
            get {
                object o = ViewState["Selectable"];
                return (o == null ? true : (bool)o);
            }
            set {
                ViewState["Selectable"] = value;
            }
        }


        /// <devdoc>
        ///     Gets and sets the selected state
        /// </devdoc>
        [Browsable(true)]
        [DefaultValue(false)]
        [WebSysDescription(SR.MenuItem_Selected)]
        public bool Selected {
            get {
                object o = ViewState["Selected"];
                if (o == null) {
                    return false;
                }
                return (bool)o;
            }
            set {
                SetSelected(value);
                NotifyOwnerSelected();
            }
        }


        /// <devdoc>
        ///     Gets and sets the image URl to be rendered as a separator for this item
        /// </devdoc>
        [DefaultValue("")]
        [Editor("System.Web.UI.Design.ImageUrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor))]
        [UrlProperty()]
        [WebSysDescription(SR.MenuItem_SeparatorImageUrl)]
        public string SeparatorImageUrl {
            get {
                object s = ViewState["SeparatorImageUrl"];
                if (s == null) {
                    return String.Empty;
                }
                return (string)s;
            }
            set {
                ViewState["SeparatorImageUrl"] = value;
            }
        }


        /// <devdoc>
        ///     Gets and sets the target window that the MenuItem will browse to if selected
        /// </devdoc>
        [DefaultValue("")]
        [WebSysDescription(SR.MenuItem_Target)]
        public string Target {
            get {
                object s = ViewState["Target"];
                if (s == null) {
                    return String.Empty;
                }
                return (string)s;
            }
            set {
                ViewState["Target"] = value;
            }
        }


        /// <devdoc>
        ///     Gets and sets the display text
        /// </devdoc>
        [DefaultValue("")]
        [Localizable(true)]
        [WebSysDescription(SR.MenuItem_Text)]
        public string Text {
            get {
                object s = ViewState["Text"];
                if (s == null) {
                    s = ViewState["Value"];
                    if (s == null) {
                        return String.Empty;
                    }
                }
                return (string)s;
            }
            set {
                ViewState["Text"] = value;
            }
        }


        /// <devdoc>
        ///     Gets and sets the MenuItem tooltip
        /// </devdoc>
        [DefaultValue("")]
        [Localizable(true)]
        [WebSysDescription(SR.MenuItem_ToolTip)]
        public string ToolTip {
            get {
                object s = ViewState["ToolTip"];
                if (s == null) {
                    return String.Empty;
                }
                return (string)s;
            }
            set {
                ViewState["ToolTip"] = value;
            }
        }


        /// <devdoc>
        ///     Gets and sets the value
        /// </devdoc>
        [DefaultValue("")]
        [Localizable(true)]
        [WebSysDescription(SR.MenuItem_Value)]
        public string Value {
            get {
                object s = ViewState["Value"];
                if (s == null) {
                    s = ViewState["Text"];
                    if (s == null) {
                        return String.Empty;
                    }
                }
                return (string)s;
            }
            set {
                ViewState["Value"] = value;
                ResetValuePathRecursive();
            }
        }


        /// <devdoc>
        ///     Gets the full path of the MenuItem
        /// </devdoc>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public string ValuePath {
            get {
                if (_valuePath != null) {
                    return _valuePath;
                }

                if (_parent != null) {
                    string parentPath = _parent.ValuePath;
                    _valuePath = ((parentPath.Length == 0) && (_parent.Depth == -1)) ?
                        Value : parentPath + _owner.PathSeparator + Value;
                    return _valuePath;
                }
                else {
                    return String.Empty;
                }
            }
        }


        /// <devdoc>
        ///     The state for this MenuItem
        /// </devdoc>
        private StateBag ViewState {
            get {
                if (_viewState == null) {
                    _viewState = new StateBag();
                    if (_isTrackingViewState) {
                        ((IStateManager)_viewState).TrackViewState();
                    }
                }
                return _viewState;
            }
        }

        internal string GetExpandImageUrl() {
            if (ChildItems.Count > 0) {
                if (PopOutImageUrl.Length != 0) {
                    return _owner.ResolveClientUrl(PopOutImageUrl);
                }
                else {
                    if (Depth < _owner.StaticDisplayLevels) {
                        if (_owner.StaticPopOutImageUrl.Length != 0) {
                            return _owner.ResolveClientUrl(_owner.StaticPopOutImageUrl);
                        }
                        else if (_owner.StaticEnableDefaultPopOutImage) {
                            return _owner.GetImageUrl(Menu.PopOutImageIndex);
                        }
                    }
                    else {
                        if (_owner.DynamicPopOutImageUrl.Length != 0) {
                            return _owner.ResolveClientUrl(_owner.DynamicPopOutImageUrl);
                        }
                        else if (_owner.DynamicEnableDefaultPopOutImage) {
                            return _owner.GetImageUrl(Menu.PopOutImageIndex);
                        }
                    }
                }
            }
            return String.Empty;
        }

        internal bool NotTemplated() {
            return ((_owner.StaticItemTemplate == null || Depth >= _owner.StaticDisplayLevels) &&
                    (_owner.DynamicItemTemplate == null || Depth < _owner.StaticDisplayLevels));
        }

        private void NotifyOwnerSelected() {
            object o = ViewState["Selected"];
            bool value = (o == null ? false : (bool)o);
            // If the owner hasn't been set, remember that we want to select this item
            // when the owner is determined
            if (_owner == null) {
                _selectDesired = (value ? +1 : -1);
                return;
            }
            else if (value) {
                // Set the Menu's selected item to this one
                _owner.SetSelectedItem(this);
            }
            else if (this == _owner.SelectedItem) {
                _owner.SetSelectedItem(null);
            }
        }


        /// <devdoc>
        ///     Renders the contents of the item and its children.
        /// </devdoc>
        internal void Render(HtmlTextWriter writer, bool enabled, bool staticOnly) {
            Render(writer, enabled, staticOnly, true);
        }


        /// <devdoc>
        ///     Renders the contents of the item and its children.
        /// </devdoc>
        internal void Render(HtmlTextWriter writer, bool enabled, bool staticOnly, bool recursive) {
            enabled = enabled && Enabled;
            // If children exist, maybe render them
            int nextDepth = Depth + 1;
            if (ChildItems.Count > 0 && nextDepth < _owner.MaximumDepth) {
                // <table cellpadding="0" cellspacing="0" border="0">
                // Find the right style:
                SubMenuStyle subMenuStyle = _owner.GetSubMenuStyle(this);
                string styleClass = null;
                if (_owner.Page != null && _owner.Page.SupportsStyleSheets) {
                    styleClass = _owner.GetSubMenuCssClassName(this);
                }

                if (nextDepth >= _owner.StaticDisplayLevels) {
                    // The submenu is dynamic
                    if (!staticOnly && enabled && !(_owner.DesignMode && recursive)) {
                        // Not recreating a panel each time: panel is created and configured only once from Menu.Panel.
                        PopOutPanel panel = _owner.Panel;
                        if (_owner.Page != null && _owner.Page.SupportsStyleSheets) {
                            panel.ScrollerClass = _owner.GetCssClassName(ChildItems[0], false);
                            panel.ScrollerStyle = null;
                        }
                        else {
                            panel.ScrollerClass = null;
                            panel.ScrollerStyle = _owner.GetMenuItemStyle(ChildItems[0]);
                        }
                        if (_owner.Page != null && _owner.Page.SupportsStyleSheets) {
                            panel.CssClass = styleClass;
                            panel.SetInternalStyle(null);
                        }
                        else if (!subMenuStyle.IsEmpty) {
                            panel.CssClass = String.Empty;
                            panel.SetInternalStyle(subMenuStyle);
                        }
                        else {
                            panel.CssClass = String.Empty;
                            panel.SetInternalStyle(null);
                            panel.BackColor = Color.Empty;
                        }
                        panel.ID = Id + "Items";
                        panel.RenderBeginTag(writer);
                        writer.AddAttribute(HtmlTextWriterAttribute.Border, "0");
                        writer.AddAttribute(HtmlTextWriterAttribute.Cellpadding, "0");
                        writer.AddAttribute(HtmlTextWriterAttribute.Cellspacing, "0");
                        writer.RenderBeginTag(HtmlTextWriterTag.Table);
                        for (int i = 0; i < ChildItems.Count; i++) {
                            ChildItems[i].RenderItem(writer, i, enabled, Orientation.Vertical);
                        }
                        writer.RenderEndTag(); // Table
                        panel.RenderEndTag(writer);

                        if (recursive) {
                            for (int i = 0; i < ChildItems.Count; i++) {
                                ChildItems[i].Render(writer, enabled, false);
                            }
                        }
                    }
                }
                else {
                    // The submenu is static
                    writer.AddAttribute(HtmlTextWriterAttribute.Border, "0");
                    writer.AddAttribute(HtmlTextWriterAttribute.Cellpadding, "0");
                    writer.AddAttribute(HtmlTextWriterAttribute.Cellspacing, "0");
                    writer.AddAttribute(HtmlTextWriterAttribute.Width, "100%");
                    if (_owner.Page != null && _owner.Page.SupportsStyleSheets) {
                        if (styleClass != null && styleClass.Length > 0) {
                            writer.AddAttribute(HtmlTextWriterAttribute.Class, styleClass);
                        }
                    }
                    else {
                        subMenuStyle.AddAttributesToRender(writer);
                    }
                    writer.RenderBeginTag(HtmlTextWriterTag.Table);
                    if (_owner.Orientation == Orientation.Horizontal) {
                        // Render one global tr as items won't render any
                        writer.RenderBeginTag(HtmlTextWriterTag.Tr);
                    }
                    bool isNextStatic = (nextDepth + 1 < _owner.StaticDisplayLevels);
                    bool isNextInRange = (nextDepth + 1 < _owner.MaximumDepth);
                    for (int i = 0; i < ChildItems.Count; i++) {
                        if (recursive
                            && ChildItems[i].ChildItems.Count != 0
                            && ((enabled && ChildItems[i].Enabled) || isNextStatic)
                            && isNextInRange) {

                            // If the next items are dynamic, we want to render the div inside the item's
                            // td so that we don't generate a tr that contains only absolute positioned
                            // divs, which would cause a gap to appear (VSWhidbey 354884)
                            if (isNextStatic) {
                                ChildItems[i].RenderItem(writer, i, enabled, _owner.Orientation);
                                if (_owner.Orientation == Orientation.Vertical) {
                                    writer.RenderBeginTag(HtmlTextWriterTag.Tr);
                                    writer.RenderBeginTag(HtmlTextWriterTag.Td);
                                    ChildItems[i].Render(writer, enabled, staticOnly);
                                    writer.RenderEndTag(); //td
                                    writer.RenderEndTag(); //tr
                                }
                                else {
                                    writer.RenderBeginTag(HtmlTextWriterTag.Td);
                                    ChildItems[i].Render(writer, enabled, staticOnly);
                                    writer.RenderEndTag(); //td
                                }
                            }
                            else {
                                ChildItems[i].RenderItem(writer, i, enabled, _owner.Orientation, staticOnly);
                            }
                        }
                        else {
                            ChildItems[i].RenderItem(writer, i, enabled, _owner.Orientation);
                        }
                    }
                    if (_owner.Orientation == Orientation.Horizontal) {
                        // Render global /tr
                        writer.RenderEndTag();
                    }
                    writer.RenderEndTag(); //table
                    if (!isNextStatic && !staticOnly && recursive && isNextInRange) {
                        for (int i = 0; i < ChildItems.Count; i++) {
                            if (ChildItems[i].ChildItems.Count != 0
                                && ((enabled && ChildItems[i].Enabled))) {

                                // The next items are dynamic, so we want to render the div outside the menu table
                                // so that we don't generate a tr that contains only absolute positioned
                                // divs, which would cause a gap to appear (VSWhidbey 354884)
                                ChildItems[i].Render(writer, enabled, false, true);
                            }
                        }
                    }
                }
            }
        }


        /// <devdoc>
        ///     Renders the contents of the item but not its children.
        /// </devdoc>
        internal void RenderItem(HtmlTextWriter writer, int position, bool enabled, Orientation orientation) {
            RenderItem(writer, position, enabled, orientation, false);
        }

        internal void RenderItem(HtmlTextWriter writer, int position, bool enabled, Orientation orientation, bool staticOnly) {
            enabled = enabled && Enabled;
            int depth = Depth;
            MenuItemStyle mergedStyle = _owner.GetMenuItemStyle(this);

            int depthPlusOne = Depth + 1;

            bool staticTopSeparator = (depth < _owner.StaticDisplayLevels) && (_owner.StaticTopSeparatorImageUrl.Length != 0);
            bool dynamicTopSeparator = (depth >= _owner.StaticDisplayLevels) && (_owner.DynamicTopSeparatorImageUrl.Length != 0);
            // The separator is in a separate td in the vertical case, in a separate tr otherwise.
            if (staticTopSeparator || dynamicTopSeparator) {
                if (orientation == Orientation.Vertical) {
                    writer.RenderBeginTag(HtmlTextWriterTag.Tr);
                }
                writer.RenderBeginTag(HtmlTextWriterTag.Td);
                if (staticTopSeparator) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Src, _owner.ResolveClientUrl(_owner.StaticTopSeparatorImageUrl));
                }
                else {
                    writer.AddAttribute(HtmlTextWriterAttribute.Src, _owner.ResolveClientUrl(_owner.DynamicTopSeparatorImageUrl));
                }
                writer.AddAttribute(HtmlTextWriterAttribute.Alt, String.Empty);
                writer.RenderBeginTag(HtmlTextWriterTag.Img);
                writer.RenderEndTag(); // Img
                writer.RenderEndTag(); // Td
                if (orientation == Orientation.Vertical) {
                    writer.RenderEndTag(); // Tr
                }
            }

            // Top spacing
            if ((mergedStyle != null) && !mergedStyle.ItemSpacing.IsEmpty && ((depth != 0) || (position != 0))) {
                RenderItemSpacing(writer, mergedStyle.ItemSpacing, orientation);
            }

            if (!staticOnly && _owner.Enabled) {
                if (depthPlusOne > _owner.StaticDisplayLevels) {
                    // Only the last static level and dynamic levels need hover behavior.
                    // And then only if they are selectable or have children.
                    if ((Selectable && Enabled) || ChildItems.Count != 0) {
                        writer.AddAttribute("onmouseover", "Menu_HoverDynamic(this)");
                        RenderItemEvents(writer);
                    }
                    else {
                        // dynamic disabled or unselectable items without children still need to maintain the menu open
                        writer.AddAttribute("onmouseover", "Menu_HoverDisabled(this)");
                        writer.AddAttribute("onmouseout", "Menu_Unhover(this)");
                    }
                }
                else if (depthPlusOne == _owner.StaticDisplayLevels) {
                    // Here's for the last static level
                    if ((Selectable && Enabled) || ChildItems.Count != 0) {
                        writer.AddAttribute("onmouseover", "Menu_HoverStatic(this)");
                        RenderItemEvents(writer);
                    }
                }
                else if (Selectable && Enabled) {
                    // Other nodes need hover styles but no expand
                    writer.AddAttribute("onmouseover", "Menu_HoverRoot(this)");
                    RenderItemEvents(writer);
                }
            }
            // Tooltip
            if (ToolTip.Length != 0) {
                writer.AddAttribute(HtmlTextWriterAttribute.Title, ToolTip);
            }
            // Set the id
            writer.AddAttribute(HtmlTextWriterAttribute.Id, Id);
            if (orientation == Orientation.Vertical) {
                // <tr>
                writer.RenderBeginTag(HtmlTextWriterTag.Tr);
            }

            writer.RenderBeginTag(HtmlTextWriterTag.Td);

            // Set the style
            if (_owner.Page != null && _owner.Page.SupportsStyleSheets) {
                string styleClass = _owner.GetCssClassName(this, false);
                if (styleClass.Trim().Length > 0) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Class, styleClass);
                }
            }
            else if (mergedStyle != null) {
                mergedStyle.AddAttributesToRender(writer);
            }

            writer.AddAttribute(HtmlTextWriterAttribute.Cellpadding, "0");
            writer.AddAttribute(HtmlTextWriterAttribute.Cellspacing, "0");
            writer.AddAttribute(HtmlTextWriterAttribute.Border, "0");
            writer.AddAttribute(HtmlTextWriterAttribute.Width, "100%");
            writer.RenderBeginTag(HtmlTextWriterTag.Table);
            writer.RenderBeginTag(HtmlTextWriterTag.Tr);
            if (!_owner.ItemWrap) {
                writer.AddStyleAttribute(HtmlTextWriterStyle.WhiteSpace, "nowrap");
            }
            if (orientation == Orientation.Vertical) {
                writer.AddStyleAttribute(HtmlTextWriterStyle.Width, "100%");
            }

            writer.RenderBeginTag(HtmlTextWriterTag.Td);

            if (_owner.Page != null && _owner.Page.SupportsStyleSheets) {
                bool applyInlineBorder;
                string styleClass = _owner.GetCssClassName(this, true, out applyInlineBorder);
                if (styleClass.Trim().Length > 0) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Class, styleClass);
                    if (applyInlineBorder) {
                        // Add inline style to force the border to none to override any CssClass (VSWhidbey 336610)
                        writer.AddStyleAttribute(HtmlTextWriterStyle.BorderStyle, "none");
                        // And an inline font-size of 1em to avoid squaring relative font sizes by applying them twice
                        writer.AddStyleAttribute(HtmlTextWriterStyle.FontSize, "1em");
                    }
                }
            }
            else {
                if (mergedStyle != null) {
                    mergedStyle.HyperLinkStyle.AddAttributesToRender(writer);
                }
            }

            string accessKey = _owner.AccessKey;
            if (enabled && Selectable) {
                // If there is a navigation url on this item, set up the navigation stuff
                if (NavigateUrl.Length > 0) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Href, _owner.ResolveClientUrl(NavigateUrl));

                    // Use the MenuItem Target if it has one, the Menu's if it doesn't
                    string target = ViewState["Target"] as string;
                    if (target == null) {
                        target = _owner.Target;
                    }

                    if (target.Length > 0) {
                        writer.AddAttribute(HtmlTextWriterAttribute.Target, target);
                    }
                }
                // Otherwise, write out a postback that will select the item
                else {
                    writer.AddAttribute(HtmlTextWriterAttribute.Href,
                        _owner.Page.ClientScript.GetPostBackClientHyperlink(_owner, InternalValuePath, true, true));
                }
                // AccessKey
                if (!_owner.AccessKeyRendered && (accessKey.Length != 0)) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Accesskey, accessKey, true);
                    _owner.AccessKeyRendered = true;
                }

            }
            else {
                // Span if disabled or not selectable
                if (!enabled) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Disabled, "true");
                }
                else if ((ChildItems.Count != 0) && (depthPlusOne >= _owner.StaticDisplayLevels)) {
                    // For accessibility reasons, we want the a to have an href even if it's not selectable
                    // because we want it to be focusable if it has dynamic children.
                    writer.AddAttribute(HtmlTextWriterAttribute.Href, "#");
                    writer.AddStyleAttribute(HtmlTextWriterStyle.Cursor, "text");
                    // AccessKey
                    if (!_owner.AccessKeyRendered && (accessKey.Length != 0)) {
                        writer.AddAttribute(HtmlTextWriterAttribute.Accesskey, accessKey, true);
                        _owner.AccessKeyRendered = true;
                    }
                }
            }
            if (depth != 0 && depth < _owner.StaticDisplayLevels) {
                Unit indent = _owner.StaticSubMenuIndent;

                // In 4.0, the default value of Menu.StaticSubMenuIndent was changed from 16px to Unit.Empty,
                // since the table and list rendering modes need to have different effective default values.
                // To maintain back compat, the effective default value for table rendering is 16px.
                // Dev10 Bug 741543
                if (indent.IsEmpty) {
                    indent = Unit.Pixel(16);
                }

                if (indent.Value != 0) {
                    double indentValue = indent.Value * depth;
                    if (indentValue <  Unit.MaxValue) {
                        indent = new Unit(indentValue, indent.Type);
                    }
                    else {
                        indent = new Unit(Unit.MaxValue, indent.Type);
                    }
                    writer.AddStyleAttribute("margin-left", indent.ToString(CultureInfo.InvariantCulture));
                }
            }
            // <a href=href>
            // We're rendering an A tag in all cases so that the client script can always find the items by tag name
            writer.RenderBeginTag(HtmlTextWriterTag.A);

            // Render out the item icon, if it is set and if the item is not templated
            if (ImageUrl.Length > 0 && NotTemplated()) {
                // <img>
                writer.AddAttribute(HtmlTextWriterAttribute.Src, _owner.ResolveClientUrl(ImageUrl));
                writer.AddAttribute(HtmlTextWriterAttribute.Alt, ToolTip);
                writer.AddStyleAttribute(HtmlTextWriterStyle.BorderStyle, "none");
                writer.AddStyleAttribute("vertical-align", "middle");
                writer.RenderBeginTag(HtmlTextWriterTag.Img);
                writer.RenderEndTag();
            }

            // Item text
            RenderText(writer);

            // </a> or </span>
            writer.RenderEndTag();

            bool shouldRenderExpandImage = ((depthPlusOne >= _owner.StaticDisplayLevels) &&
                (depthPlusOne < _owner.MaximumDepth));
            string expandImageUrl = (shouldRenderExpandImage ? GetExpandImageUrl() : String.Empty);

            // Render some space if horizontal
            bool needsSpace = false;
            if ((orientation == Orientation.Horizontal) &&
                (depth < _owner.StaticDisplayLevels) &&
                (!shouldRenderExpandImage || (expandImageUrl.Length == 0)) &&
                ((mergedStyle == null) || mergedStyle.ItemSpacing.IsEmpty)) {


                if (((Depth + 1) < _owner.StaticDisplayLevels) && (ChildItems.Count != 0)) {
                    // next level is static too and exists, so we're not the last static
                    needsSpace = true;
                }
                else {
                    // Static item with no static children.
                    // We need to check if there are any static items at any level after this one.
                    // This is done by checking if any ancestor is not last.
                    // This walk should be marginally executed as multiple static display levels
                    // don't make sense on a horizontal menu.
                    MenuItem parent = this;
                    while (parent != null) {
                        if (((parent.Parent == null) &&
                             (_owner.Items.Count != 0) &&
                             (parent != _owner.Items[_owner.Items.Count - 1])) ||
                            ((parent.Parent != null) &&
                             (parent.Parent.ChildItems.Count != 0) &&
                             (parent != parent.Parent.ChildItems[parent.Parent.ChildItems.Count - 1]))) {

                            needsSpace = true;
                            break;
                        }
                        parent = parent.Parent;
                    }
                }
            }

            // </td>
            writer.RenderEndTag();

            if (shouldRenderExpandImage && expandImageUrl.Length > 0) {
                // <td>
                writer.AddStyleAttribute(HtmlTextWriterStyle.Width, "0");
                writer.RenderBeginTag(HtmlTextWriterTag.Td);
                // <img>
                writer.AddAttribute(HtmlTextWriterAttribute.Src, expandImageUrl);
                writer.AddStyleAttribute(HtmlTextWriterStyle.BorderStyle, "none");
                writer.AddStyleAttribute(HtmlTextWriterStyle.VerticalAlign, "middle");
                if (depth < _owner.StaticDisplayLevels) {

                    writer.AddAttribute(HtmlTextWriterAttribute.Alt,
                                        String.Format(CultureInfo.CurrentCulture, _owner.StaticPopOutImageTextFormatString, Text));
                }
                else if (depth >= _owner.StaticDisplayLevels) {

                    writer.AddAttribute(HtmlTextWriterAttribute.Alt,
                                        String.Format(CultureInfo.CurrentCulture, _owner.DynamicPopOutImageTextFormatString, Text));
                }
                writer.RenderBeginTag(HtmlTextWriterTag.Img);
                writer.RenderEndTag();
                // </td>
                writer.RenderEndTag();
            }

            
            writer.RenderEndTag(); // </tr>
            writer.RenderEndTag(); // </table>

            writer.RenderEndTag(); // </td>
            if (orientation == Orientation.Vertical) {
                writer.RenderEndTag(); // </tr>
            }
            // Bottom (or right) item spacing
            // We do not render the spacing on the last static item or on the last item of a dynamic submenu
            if ((mergedStyle != null) && !mergedStyle.ItemSpacing.IsEmpty) {
                RenderItemSpacing(writer, mergedStyle.ItemSpacing, orientation);
            }
            else if (needsSpace) {
                RenderItemSpacing(writer, HorizontalDefaultSpacing, orientation);
            }
            // Bottom separator
            bool separator = (SeparatorImageUrl.Length != 0);
            bool staticBottomSeparator = (depth < _owner.StaticDisplayLevels) && (_owner.StaticBottomSeparatorImageUrl.Length != 0);
            bool dynamicBottomSeparator = (depth >= _owner.StaticDisplayLevels) && (_owner.DynamicBottomSeparatorImageUrl.Length != 0);
            if (separator || staticBottomSeparator || dynamicBottomSeparator) {
                if (orientation == Orientation.Vertical) {
                    writer.RenderBeginTag(HtmlTextWriterTag.Tr);
                }
                writer.RenderBeginTag(HtmlTextWriterTag.Td);
                if (separator) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Src, _owner.ResolveClientUrl(SeparatorImageUrl));
                }
                else if (staticBottomSeparator) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Src, _owner.ResolveClientUrl(_owner.StaticBottomSeparatorImageUrl));
                }
                else {
                writer.AddAttribute(HtmlTextWriterAttribute.Src, _owner.ResolveClientUrl(_owner.DynamicBottomSeparatorImageUrl));
                }
                writer.AddAttribute(HtmlTextWriterAttribute.Alt, String.Empty);
                writer.RenderBeginTag(HtmlTextWriterTag.Img);
                writer.RenderEndTag(); // Img
                writer.RenderEndTag(); // Td
                if (orientation == Orientation.Vertical) {
                    writer.RenderEndTag(); // Tr
                }
            }
        }

        private void RenderItemEvents(HtmlTextWriter writer) {
            writer.AddAttribute("onmouseout", "Menu_Unhover(this)");
            if (_owner.IsNotIE) {
                writer.AddAttribute("onkeyup", "Menu_Key(event)");
            }
            else {
                writer.AddAttribute("onkeyup", "Menu_Key(this)");
            }
        }

        private void RenderItemSpacing(HtmlTextWriter writer, Unit spacing, Orientation orientation) {
            if (orientation == Orientation.Vertical) {
                writer.AddStyleAttribute(HtmlTextWriterStyle.Height,
                    spacing.ToString(CultureInfo.InvariantCulture));
                writer.RenderBeginTag(HtmlTextWriterTag.Tr);
                writer.RenderBeginTag(HtmlTextWriterTag.Td);
                writer.RenderEndTag();
                writer.RenderEndTag();
            }
            else {
                writer.AddStyleAttribute(HtmlTextWriterStyle.Width,
                    spacing.ToString(CultureInfo.InvariantCulture));
                writer.RenderBeginTag(HtmlTextWriterTag.Td);
                writer.RenderEndTag();
            }
        }

        internal void RenderText(HtmlTextWriter writer) {
            if (Container != null &&
                ((_owner.StaticItemTemplate != null && Depth < _owner.StaticDisplayLevels) ||
                (_owner.DynamicItemTemplate != null && Depth >= _owner.StaticDisplayLevels))) {

                Container.RenderControl(writer);
            }
            else {
                writer.Write(FormattedText);
            }
        }

        internal void ResetValuePathRecursive() {
            if (_valuePath != null) {
                _valuePath = null;
                foreach (MenuItem child in ChildItems) {
                    child.ResetValuePathRecursive();
                }
            }
        }


        /// <devdoc>
        ///     Marks this item as a databound item
        /// </devdoc>
        internal void SetDataBound(bool dataBound) {
            ViewState["DataBound"] = dataBound;
        }


        /// <devdoc>
        ///     Sets the data item for use by the user in databinding
        /// </devdoc>
        internal void SetDataItem(object dataItem) {
            _dataItem = dataItem;
        }

        /// <devdoc>
        ///     Sets the data path for use by the Menu in databinding
        /// </devdoc>
        internal void SetDataPath(string dataPath) {
            ViewState["DataPath"] = dataPath;
        }

        internal void SetDepth(int depth) {
            _depth = depth;
        }

        internal void SetDirty() {
            ViewState.SetDirty(true);

            if (ChildItems.Count > 0) {
                ChildItems.SetDirty();
            }
        }


        /// <devdoc>
        ///     Sets the owner Menu of this item.
        /// </devdoc>
        internal void SetOwner(Menu owner) {
            _owner = owner;

            if (_selectDesired == +1) {
                _selectDesired = 0;
                Selected = true;
            }
            else if (_selectDesired == -1) {
                _selectDesired = 0;
                Selected = false;
            }

            foreach (MenuItem item in ChildItems) {
                item.SetOwner(_owner);
            }
        }


        /// <devdoc>
        ///     Sets the parent MenuItem of the item
        /// </devdoc>
        internal void SetParent(MenuItem parent) {
            _parent = parent;
            SetPath(null);
        }

        internal void SetPath(string newPath) {
            _internalValuePath = newPath;
            _depth = -2;
        }

        internal void SetSelected(bool value) {
            ViewState["Selected"] = value;

            // If the owner hasn't been set, remember that we want to select this node
            // when the owner is determined
            if (_owner == null) {
                _selectDesired = (value ? +1 : -1);
            }
        }

            #region IStateManager implementation

        /// <internalonly/>
        bool IStateManager.IsTrackingViewState {
            get {
                return _isTrackingViewState;
            }
        }


        /// <internalonly/>
        void IStateManager.LoadViewState(object state) {
            object[] itemState = (object[])state;

            if (itemState != null) {
                if (itemState[0] != null) {
                    ((IStateManager)ViewState).LoadViewState(itemState[0]);
                }
                // We need to call the selected setter so that the owner can be notified
                // N.B. The treeview does not need to do that
                // because it's loading the state of its node differently because of the richer client-side behavior.
                NotifyOwnerSelected();

                if (itemState[1] != null) {
                    ((IStateManager)ChildItems).LoadViewState(itemState[1]);
                }
            }
        }


        /// <internalonly/>
        object IStateManager.SaveViewState() {
            object[] state = new object[2];
            if (_viewState != null) {
                state[0] = ((IStateManager)_viewState).SaveViewState();
            }

            if (_childItems != null) {
                state[1] = ((IStateManager)_childItems).SaveViewState();
            }

            if ((state[0] == null) && (state[1] == null)) {
                return null;
            }

            return state;
        }


        /// <internalonly/>
        void IStateManager.TrackViewState() {
            _isTrackingViewState = true;

            if (_viewState != null) {
                ((IStateManager)_viewState).TrackViewState();
            }

            if (_childItems != null) {
                ((IStateManager)_childItems).TrackViewState();
            }
        }
            #endregion

            #region ICloneable implementation

        /// <internalonly/>
        object ICloneable.Clone() {
            MenuItem newItem = new MenuItem();
            newItem.Enabled = Enabled;
            newItem.ImageUrl = ImageUrl;
            newItem.NavigateUrl = NavigateUrl;
            newItem.PopOutImageUrl = PopOutImageUrl;
            newItem.Selectable = Selectable;
            newItem.Selected = Selected;
            newItem.SeparatorImageUrl = SeparatorImageUrl;
            newItem.Target = Target;
            newItem.Text = Text;
            newItem.ToolTip = ToolTip;
            newItem.Value = Value;

            return newItem;
        }
            #endregion
    }

    public sealed class MenuItemTemplateContainer : Control, IDataItemContainer {

        private int _itemIndex;
        private object _dataItem;

        public MenuItemTemplateContainer(int itemIndex, MenuItem dataItem) {
            _itemIndex = itemIndex;
            _dataItem = dataItem;
        }

        public object DataItem {
            get {
                return _dataItem;
            }
            set {
                _dataItem = value;
            }
        }

        public int ItemIndex {
            get {
                return _itemIndex;
            }
        }

        protected override bool OnBubbleEvent(object source, EventArgs e) {
            CommandEventArgs ce = e as CommandEventArgs;
            if (ce != null) {
                if (ce is MenuEventArgs) {
                    RaiseBubbleEvent(this, ce);
                }
                else {
                    MenuEventArgs args = new MenuEventArgs((MenuItem)_dataItem, source, ce);
                    RaiseBubbleEvent(this, args);
                }
                return true;
            }
            return false;
        }

        object IDataItemContainer.DataItem {
            get {
                return _dataItem;
            }
        }

        int IDataItemContainer.DataItemIndex {
            get {
                return ItemIndex;
            }
        }

        int IDataItemContainer.DisplayIndex {
            get {
                return ItemIndex;
            }
        }
    }
}