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

namespace System.Web.UI.WebControls {
    using System.Collections;
    using System.Collections.Generic;
    using System.Drawing;
    using System.Globalization;
    using System.Linq;
    using System.Web.Util;

    public partial class Menu {
        /// <devdoc>The standards-compliant Menu renderer</devdoc>
        internal class MenuRendererStandards : MenuRenderer {
            private string _dynamicPopOutUrl;
            private string _staticPopOutUrl;

            public MenuRendererStandards(Menu menu) : base(menu) { }

            private string DynamicPopOutUrl {
                get {
                    if (_dynamicPopOutUrl == null) {
                        _dynamicPopOutUrl = GetDynamicPopOutImageUrl();
                    }
                    return _dynamicPopOutUrl;
                }
            }

            protected virtual string SpacerImageUrl {
                get {
                    return Menu.SpacerImageUrl;
                }
            }

            private string StaticPopOutUrl {
                get {
                    if (_staticPopOutUrl == null) {
                        _staticPopOutUrl = GetStaticPopOutImageUrl();
                    }
                    return _staticPopOutUrl;
                }
            }

            private void AddScriptReference() {
                string key = "_registerMenu_" + Menu.ClientID;
                string initScript = String.Format(CultureInfo.InvariantCulture,
                    "<script type='text/javascript'>" +
                    "new Sys.WebForms.Menu({{ element: '{0}', disappearAfter: {1}, orientation: '{2}', tabIndex: {3}, disabled: {4} }});" +
                    "</script>",
                    Menu.ClientID,
                    Menu.DisappearAfter,
                    Menu.Orientation.ToString().ToLowerInvariant(),
                    Menu.TabIndex,
                    (!Menu.IsEnabled).ToString().ToLowerInvariant());

                if (Menu.Page.ScriptManager != null) {
                    Menu.Page.ScriptManager.RegisterClientScriptResource(Menu.Page, typeof(Menu), "MenuStandards.js");
                    Menu.Page.ScriptManager.RegisterStartupScript(Menu, typeof(MenuRendererStandards), key, initScript, false);
                }
                else {
                    Menu.Page.ClientScript.RegisterClientScriptResource(Menu.Page, typeof(Menu), "MenuStandards.js");
                    Menu.Page.ClientScript.RegisterStartupScript(typeof(MenuRendererStandards), key, initScript);
                }
            }

            private void AddStyleBlock() {
                if (Menu.IncludeStyleBlock) {
                    Menu.Page.Header.Controls.Add(CreateStyleBlock());
                }
            }

            private StyleBlock CreateStyleBlock() {
                StyleBlock styleBlock = new StyleBlock();
                Style rootMenuItemStyle = Menu.RootMenuItemStyle;

                // drop the font and forecolor from the control style, those are applied
                // to the anchors directly with rootMenuItemStyle.
                Style menuStyle = null;
                if (!Menu.ControlStyle.IsEmpty) {
                    menuStyle = new Style();
                    menuStyle.CopyFrom(Menu.ControlStyle);
                    // Relative sizes should not be multiplied (VSWhidbey 457610)
                    menuStyle.Font.Reset();
                    menuStyle.ForeColor = Color.Empty;
                }

                // Menu surrounding DIV style -- without ForeColor or Font,
                // those are applied directly to the '#Menu a' selector.

                styleBlock.AddStyleDefinition("#{0}", Menu.ClientID)
                          .AddStyles(menuStyle);

                // Image styles

                styleBlock.AddStyleDefinition("#{0} img.icon", Menu.ClientID)
                          .AddStyle(HtmlTextWriterStyle.BorderStyle, "none")
                          .AddStyle(HtmlTextWriterStyle.VerticalAlign, "middle");

                styleBlock.AddStyleDefinition("#{0} img.separator", Menu.ClientID)
                          .AddStyle(HtmlTextWriterStyle.BorderStyle, "none")
                          .AddStyle(HtmlTextWriterStyle.Display, "block");

                if (Menu.Orientation == Orientation.Horizontal) {
                    styleBlock.AddStyleDefinition("#{0} img.horizontal-separator", Menu.ClientID)
                              .AddStyle(HtmlTextWriterStyle.BorderStyle, "none")
                              .AddStyle(HtmlTextWriterStyle.VerticalAlign, "middle");
                }

                // Menu styles

                styleBlock.AddStyleDefinition("#{0} ul", Menu.ClientID)
                          .AddStyle("list-style", "none")
                          .AddStyle(HtmlTextWriterStyle.Margin, "0")
                          .AddStyle(HtmlTextWriterStyle.Padding, "0")
                          .AddStyle(HtmlTextWriterStyle.Width, "auto");

                styleBlock.AddStyleDefinition("#{0} ul.static", Menu.ClientID)
                          .AddStyles(Menu._staticMenuStyle);

                var ulDynamic = styleBlock.AddStyleDefinition("#{0} ul.dynamic", Menu.ClientID)
                                          .AddStyles(Menu._dynamicMenuStyle)
                                          .AddStyle(HtmlTextWriterStyle.ZIndex, "1");

                if (Menu.DynamicHorizontalOffset != 0) {
                    ulDynamic.AddStyle(HtmlTextWriterStyle.MarginLeft, Menu.DynamicHorizontalOffset.ToString(CultureInfo.InvariantCulture) + "px");
                }

                if (Menu.DynamicVerticalOffset != 0) {
                    ulDynamic.AddStyle(HtmlTextWriterStyle.MarginTop, Menu.DynamicVerticalOffset.ToString(CultureInfo.InvariantCulture) + "px");
                }

                if (Menu._levelStyles != null) {
                    int index = 1;

                    foreach (SubMenuStyle style in Menu._levelStyles) {
                        styleBlock.AddStyleDefinition("#{0} ul.level{1}", Menu.ClientID, index++)
                                  .AddStyles(style);
                    }
                }

                // Menu item styles

                // MenuItems have a 14px default right padding.
                // This is necessary to prevent the default (and the typical) popout image from going under
                // the menu item text when it is one of the longer items in the parent menu.
                // It is 'px' based since its based on the image size not font size.
                styleBlock.AddStyleDefinition("#{0} a", Menu.ClientID)
                          .AddStyle(HtmlTextWriterStyle.WhiteSpace, "nowrap")
                          .AddStyle(HtmlTextWriterStyle.Display, "block")
                          .AddStyles(rootMenuItemStyle);

                var menuItemStatic = styleBlock.AddStyleDefinition("#{0} a.static", Menu.ClientID);
                if ((Menu.Orientation == Orientation.Horizontal) &&
                    ((Menu._staticItemStyle == null) || (Menu._staticItemStyle.HorizontalPadding.IsEmpty))) {
                    menuItemStatic.AddStyle(HtmlTextWriterStyle.PaddingLeft, "0.15em")
                                  .AddStyle(HtmlTextWriterStyle.PaddingRight, "0.15em");
                }
                menuItemStatic.AddStyles(Menu._staticItemStyle);

                if (Menu._staticItemStyle != null) {
                    menuItemStatic.AddStyles(Menu._staticItemStyle.HyperLinkStyle);
                }

                if (!String.IsNullOrEmpty(StaticPopOutUrl)) {
                    styleBlock.AddStyleDefinition("#{0} a.popout", Menu.ClientID)
                        .AddStyle("background-image", "url(\"" + Menu.ResolveClientUrl(StaticPopOutUrl).Replace("\"", "\\\"") + "\")")
                        .AddStyle("background-repeat", "no-repeat")
                        .AddStyle("background-position", "right center")
                        .AddStyle(HtmlTextWriterStyle.PaddingRight, "14px");
                }

                if (!String.IsNullOrEmpty(DynamicPopOutUrl)) {
                    // Check if dynamic popout is the same as the static one, so there's no need for a separate rule
                    if (DynamicPopOutUrl != StaticPopOutUrl) {
                        styleBlock.AddStyleDefinition("#{0} a.popout-dynamic", Menu.ClientID)
                            .AddStyle("background", "url(\"" + Menu.ResolveClientUrl(DynamicPopOutUrl).Replace("\"", "\\\"") + "\") no-repeat right center")
                            .AddStyle(HtmlTextWriterStyle.PaddingRight, "14px");
                    }
                }

                var styleBlockStyles = styleBlock.AddStyleDefinition("#{0} a.dynamic", Menu.ClientID)
                    .AddStyles(Menu._dynamicItemStyle);
                if (Menu._dynamicItemStyle != null) {
                    styleBlockStyles.AddStyles(Menu._dynamicItemStyle.HyperLinkStyle);
                }

                if (Menu._levelMenuItemStyles != null || Menu.StaticDisplayLevels > 1) {
                    int lastIndex = Menu.StaticDisplayLevels;
                    if (Menu._levelMenuItemStyles != null) {
                        lastIndex = Math.Max(lastIndex, Menu._levelMenuItemStyles.Count);
                    }

                    for (int index = 0; index < lastIndex; ++index) {
                        var style = styleBlock.AddStyleDefinition("#{0} a.level{1}", Menu.ClientID, index + 1);

                        if (index > 0 && index < Menu.StaticDisplayLevels) {
                            Unit indent = Menu.StaticSubMenuIndent;
                            
                            // The default value of Menu.StaticSubMenuIndent is Unit.Empty, and the effective default value
                            // for list rendering is either 1em (vertical) or empty (horizontal).
                            if (indent.IsEmpty && Menu.Orientation == Orientation.Vertical) {
                                indent = new Unit(1, UnitType.Em);
                            }

                            if (!indent.IsEmpty && indent.Value != 0) {
                                double indentValue = indent.Value * index;
                                if (indentValue < Unit.MaxValue) {
                                    indent = new Unit(indentValue, indent.Type);
                                }
                                else {
                                    indent = new Unit(Unit.MaxValue, indent.Type);
                                }

                                style.AddStyle(HtmlTextWriterStyle.PaddingLeft, indent.ToString(CultureInfo.InvariantCulture));
                            }
                        }

                        if (Menu._levelMenuItemStyles != null && index < Menu._levelMenuItemStyles.Count) {
                            var levelItemStyle = Menu._levelMenuItemStyles[index];
                            style.AddStyles(levelItemStyle).AddStyles(levelItemStyle.HyperLinkStyle);
                        }
                    }
                }

                styleBlockStyles = styleBlock.AddStyleDefinition("#{0} a.static.selected", Menu.ClientID)
                          .AddStyles(Menu._staticSelectedStyle);
                if (Menu._staticSelectedStyle != null) {
                    styleBlockStyles.AddStyles(Menu._staticSelectedStyle.HyperLinkStyle);
                }

                styleBlockStyles = styleBlock.AddStyleDefinition("#{0} a.dynamic.selected", Menu.ClientID)
                          .AddStyles(Menu._dynamicSelectedStyle);
                if (Menu._dynamicSelectedStyle != null) {
                    styleBlockStyles.AddStyles(Menu._dynamicSelectedStyle.HyperLinkStyle);
                }

                styleBlock.AddStyleDefinition("#{0} a.static.highlighted", Menu.ClientID)
                          .AddStyles(Menu._staticHoverStyle);

                styleBlock.AddStyleDefinition("#{0} a.dynamic.highlighted", Menu.ClientID)
                          .AddStyles(Menu._dynamicHoverStyle);

                if (Menu._levelSelectedStyles != null) {
                    int index = 1;

                    foreach (MenuItemStyle style in Menu._levelSelectedStyles) {
                        styleBlock.AddStyleDefinition("#{0} a.selected.level{1}", Menu.ClientID, index++)
                                  .AddStyles(style).AddStyles(style.HyperLinkStyle);
                    }
                }

                return styleBlock;
            }

            private string GetCssClass(int level, Style staticStyle, Style dynamicStyle, IList levelStyles) {
                string result = "level" + level;
                Style style;

                if (level > Menu.StaticDisplayLevels) {
                    style = dynamicStyle;
                }
                else {
                    if (Menu.DesignMode) {
                        result += " static";
                        if (Menu.Orientation == Orientation.Horizontal) {
                            result += " horizontal";
                        }
                    }

                    style = staticStyle;
                }

                if (style != null && !String.IsNullOrEmpty(style.CssClass)) {
                    result += " " + style.CssClass;
                }

                if (levelStyles != null && levelStyles.Count >= level) {
                    Style levelStyle = (Style)levelStyles[level - 1];

                    if (levelStyle != null && !String.IsNullOrEmpty(levelStyle.CssClass)) {
                        result += " " + levelStyle.CssClass;
                    }
                }

                return result;
            }

            protected virtual string GetDynamicPopOutImageUrl() {
                string url = Menu.DynamicPopOutImageUrl;
                if (String.IsNullOrEmpty(url) && Menu.DynamicEnableDefaultPopOutImage) {
                    url = Menu.GetImageUrl(Menu.PopOutImageIndex);
                }
                return url;
            }

            protected virtual string GetStaticPopOutImageUrl() {
                string url = Menu.StaticPopOutImageUrl;
                if (String.IsNullOrEmpty(url) && Menu.StaticEnableDefaultPopOutImage) {
                    url = Menu.GetImageUrl(Menu.PopOutImageIndex);
                }
                return url;
            }

            private string GetMenuCssClass(int level) {
                return GetCssClass(level, Menu.StaticMenuStyle, Menu.DynamicMenuStyle, Menu._levelStyles);
            }

            private string GetMenuItemCssClass(MenuItem item, int level) {
                // give the A the proper popout class
                string cssClass = null;
                if (ShouldHavePopOutImage(item)) {
                    if (level > Menu.StaticDisplayLevels) {
                        if (!String.IsNullOrEmpty(DynamicPopOutUrl)) {
                            cssClass = (DynamicPopOutUrl == StaticPopOutUrl) ? "popout" : "popout-dynamic";
                        }
                    }
                    else if (!String.IsNullOrEmpty(StaticPopOutUrl)) {
                        cssClass = "popout";
                    }
                }
                string levelCssClass = GetCssClass(level, Menu.StaticMenuItemStyle, Menu.DynamicMenuItemStyle, Menu._levelMenuItemStyles);
                if (!String.IsNullOrEmpty(cssClass)) {
                    return cssClass + " " + levelCssClass;
                }
                else {
                    return levelCssClass;
                }
            }

            protected virtual string GetPostBackEventReference(MenuItem item) {
                return Menu.Page.ClientScript.GetPostBackEventReference(Menu, item.InternalValuePath, true);
            }

            private bool IsChildPastMaximumDepth(MenuItem item) {
                return (item.Depth + 1 >= Menu.MaximumDepth);
            }

            private bool IsChildDepthDynamic(MenuItem item) {
                return (item.Depth + 1 >= Menu.StaticDisplayLevels);
            }

            private bool IsDepthDynamic(MenuItem item) {
                // Depth is 0 based. StaticDisplayLevels is 1 based because it is a counter
                // (1 means show "one level" statically -- so, show Depth 0 statically but not Depth 1).
                // Therefore, it is dynamic if the item's depth is greater than or equal to the static levels.
                // Depth = 2 (3rd level), StaticDisplayLevels = 3 ==> Static
                // Depth = 2 (3rd level), StaticDisplayLevels = 2 ==> Dynamic
                return (item.Depth >= Menu.StaticDisplayLevels);
            }

            private bool IsDepthStatic(MenuItem item) {
                return !IsDepthDynamic(item);
            }

            public override void PreRender(bool registerScript) {
                if (Menu.DesignMode || Menu.Page == null) {
                    return;
                }

                if (Menu.IncludeStyleBlock && Menu.Page.Header == null) {
                    throw new InvalidOperationException(SR.GetString(SR.NeedHeader, "Menu.IncludeStyleBlock"));
                }

                AddScriptReference();  // We always need our script, even if we're disabled, because the script sets our styles
                AddStyleBlock();
            }

            public override void RenderBeginTag(HtmlTextWriter writer, bool staticOnly) {
                ControlRenderingHelper.WriteSkipLinkStart(writer, Menu.RenderingCompatibility, Menu.DesignMode, Menu.SkipLinkText, SpacerImageUrl, Menu.ClientID);

                if (Menu.DesignMode && Menu.IncludeStyleBlock) {
                    // Need to render style block in design mode, since it won't be present
                    CreateStyleBlock().Render(writer);
                }

                // Add expando attributes
                if (Menu.HasAttributes) {
                    foreach (string key in Menu.Attributes.Keys) {
                        writer.AddAttribute(key, Menu.Attributes[key]);
                    }
                }

                // CSS class, including disabled class if it's set
                string cssClass = Menu.CssClass ?? "";
                if (!Menu.Enabled) {
                    cssClass = (cssClass + " " + DisabledCssClass).Trim();
                }
                if (!String.IsNullOrEmpty(cssClass)) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Class, cssClass);
                }

                // Need to simulate the float done by Javascript when we're in design mode
                if (Menu.DesignMode) {
                    writer.AddStyleAttribute("float", "left");
                }

                writer.AddAttribute(HtmlTextWriterAttribute.Id, Menu.ClientID);
                writer.RenderBeginTag(HtmlTextWriterTag.Div);
            }

            public override void RenderContents(HtmlTextWriter writer, bool staticOnly) {
                RenderItems(writer, staticOnly || Menu.DesignMode || !Menu.Enabled, Menu.Items, 1, !String.IsNullOrEmpty(Menu.AccessKey));
            }

            public override void RenderEndTag(HtmlTextWriter writer, bool staticOnly) {
                writer.RenderEndTag();

                // Need to simulate the clear done by Javascript when we're in design mode
                if (Menu.DesignMode) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Style, "clear: left");
                    writer.RenderBeginTag(HtmlTextWriterTag.Div);
                    writer.RenderEndTag();
                }

                ControlRenderingHelper.WriteSkipLinkEnd(writer, Menu.DesignMode, Menu.SkipLinkText, Menu.ClientID);
            }

            private bool RenderItem(HtmlTextWriter writer, MenuItem item, int level, string cssClass, bool needsAccessKey) {
                RenderItemPreSeparator(writer, item);

                if (Menu.DesignMode && Menu.Orientation == Orientation.Horizontal) {
                    writer.AddStyleAttribute(HtmlTextWriterStyle.WhiteSpace, "nowrap");
                }
                needsAccessKey = RenderItemLinkAttributes(writer, item, level, cssClass, needsAccessKey);
                writer.RenderBeginTag(HtmlTextWriterTag.A);
                RenderItemIcon(writer, item);
                item.RenderText(writer);
                // popout image is in the A's background css
                writer.RenderEndTag();  // </a>

                RenderItemPostSeparator(writer, item);

                return needsAccessKey;
            }

            private void RenderItemIcon(HtmlTextWriter writer, MenuItem item) {
                if (String.IsNullOrEmpty(item.ImageUrl) || !item.NotTemplated()) {
                    return;
                }

                writer.AddAttribute(HtmlTextWriterAttribute.Src, Menu.ResolveClientUrl(item.ImageUrl));
                writer.AddAttribute(HtmlTextWriterAttribute.Alt, item.ToolTip);
                writer.AddAttribute(HtmlTextWriterAttribute.Title, item.ToolTip);
                writer.AddAttribute(HtmlTextWriterAttribute.Class, "icon");
                writer.RenderBeginTag(HtmlTextWriterTag.Img);
                writer.RenderEndTag();
            }

            private bool RenderItemLinkAttributes(HtmlTextWriter writer, MenuItem item, int level, string cssClass, bool needsAccessKey) {
                if (!String.IsNullOrEmpty(item.ToolTip)) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Title, item.ToolTip);
                }

                // Bail out for for disabled or non-selectable menu items
                if (!item.Enabled || !Menu.Enabled) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Class, cssClass + " " + DisabledCssClass);
                    return needsAccessKey;
                }
                if (!item.Selectable) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Class, cssClass);
                    return needsAccessKey;
                }

                // Selected
                if (item.Selected) {
                    cssClass += " selected";
                }
                writer.AddAttribute(HtmlTextWriterAttribute.Class, cssClass);

                // Attach the access key to the first link we render
                if (needsAccessKey) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Accesskey, Menu.AccessKey);
                }

                // Postback...
                if (String.IsNullOrEmpty(item.NavigateUrl)) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Href, "#");
                    writer.AddAttribute(HtmlTextWriterAttribute.Onclick, GetPostBackEventReference(item));
                }
                // ...or direct link
                else {
                    writer.AddAttribute(HtmlTextWriterAttribute.Href, Menu.ResolveClientUrl(item.NavigateUrl));

                    string target = item.Target;
                    if (String.IsNullOrEmpty(target)) {
                        target = Menu.Target;
                    }
                    if (!String.IsNullOrEmpty(target)) {
                        writer.AddAttribute(HtmlTextWriterAttribute.Target, target);
                    }
                }

                return false;
            }

            private void RenderItemPostSeparator(HtmlTextWriter writer, MenuItem item) {
                string separatorImageUrl = item.SeparatorImageUrl;
                if (String.IsNullOrEmpty(separatorImageUrl)) {
                    separatorImageUrl = IsDepthStatic(item)
                                       ? Menu.StaticBottomSeparatorImageUrl
                                       : Menu.DynamicBottomSeparatorImageUrl;
                }

                if (!String.IsNullOrEmpty(separatorImageUrl)) {
                    RenderItemSeparatorImage(writer, item, separatorImageUrl);
                }
            }

            private void RenderItemPreSeparator(HtmlTextWriter writer, MenuItem item) {
                string separatorImageUrl = IsDepthStatic(item)
                                   ? Menu.StaticTopSeparatorImageUrl
                                   : Menu.DynamicTopSeparatorImageUrl;

                if (!String.IsNullOrEmpty(separatorImageUrl)) {
                    RenderItemSeparatorImage(writer, item, separatorImageUrl);
                }
            }

            private void RenderItemSeparatorImage(HtmlTextWriter writer, MenuItem item, string separatorImageUrl) {
                if (Menu.RenderingCompatibility >= VersionUtil.Framework45) {
                    // Dev10 #867750, Dev11 #436206: We need to be consistent with other controls by calling ResolveClientUrl,
                    // but we need to hide this behavior behind a compat switch so that upgrading to 4.5 doesn't break
                    // customers who have implemented their own manual workaround.
                    separatorImageUrl = Menu.ResolveClientUrl(separatorImageUrl);
                }

                writer.AddAttribute(HtmlTextWriterAttribute.Src, separatorImageUrl);
                writer.AddAttribute(HtmlTextWriterAttribute.Alt, String.Empty);
                writer.AddAttribute(HtmlTextWriterAttribute.Class,
                                    IsDepthStatic(item) && Menu.Orientation == Orientation.Horizontal ? "horizontal-separator" : "separator");
                writer.RenderBeginTag(HtmlTextWriterTag.Img);
                writer.RenderEndTag();
            }

            private void RenderItems(HtmlTextWriter writer, bool staticOnly, MenuItemCollection items, int level, bool needsAccessKey) {
                if (level == 1 || level > Menu.StaticDisplayLevels) {  // Render a <UL> to start, and for all dynamic descendents
                    if (Menu.DesignMode && Menu.Orientation == Orientation.Horizontal) {
                        writer.AddStyleAttribute("float", "left");
                    }
                    writer.AddAttribute(HtmlTextWriterAttribute.Class, GetMenuCssClass(level));
                    writer.RenderBeginTag(HtmlTextWriterTag.Ul);
                }

                foreach (MenuItem item in items) {
                    if (Menu.DesignMode && Menu.Orientation == Orientation.Horizontal) {
                        writer.AddStyleAttribute("float", "left");
                        writer.AddStyleAttribute(HtmlTextWriterStyle.WhiteSpace, "nowrap");
                    }
                    writer.RenderBeginTag(HtmlTextWriterTag.Li);

                    needsAccessKey = RenderItem(writer, item, level, GetMenuItemCssClass(item, level), needsAccessKey);

                    if (level < Menu.StaticDisplayLevels) {  // Close off <LI> if we (and our direct descendents) are static
                        writer.RenderEndTag();
                    }

                    if (item.ChildItems.Count > 0 && !IsChildPastMaximumDepth(item) && item.Enabled) {
                        if (level < Menu.StaticDisplayLevels || !staticOnly) {
                            RenderItems(writer, staticOnly, item.ChildItems, level + 1, needsAccessKey);
                        }
                    }

                    if (level >= Menu.StaticDisplayLevels) {  // Close off <LI> if we (or our direct descendents) are dynamic
                        writer.RenderEndTag();
                    }
                }

                if (level == 1 || level > Menu.StaticDisplayLevels) {
                    writer.RenderEndTag();
                }
            }

            private bool ShouldHavePopOutImage(MenuItem item) {
                return (item.ChildItems.Count > 0) && IsChildDepthDynamic(item) && !IsChildPastMaximumDepth(item);
            }
        }
    }

    internal class StyleBlock : Control {
        List<StyleBlockStyles> _styles = new List<StyleBlockStyles>();

        public StyleBlockStyles AddStyleDefinition(string selector) {
            StyleBlockStyles result = new StyleBlockStyles(selector, this);
            _styles.Add(result);
            return result;
        }

        public StyleBlockStyles AddStyleDefinition(string selectorFormat, params object[] args) {
            return AddStyleDefinition(String.Format(CultureInfo.InvariantCulture, selectorFormat, args));
        }

        protected internal override void Render(HtmlTextWriter writer) {
            if (_styles.Any(s => !s.Empty)) {
                writer.AddAttribute(HtmlTextWriterAttribute.Type, "text/css");
                writer.RenderBeginTag(HtmlTextWriterTag.Style);
                writer.WriteLine("/* <![CDATA[ */");

                foreach (var style in _styles.Where(s => !s.Empty)) {
                    style.Render(writer);
                }

                writer.Write("/* ]]> */");
                writer.RenderEndTag();
            }
        }
    }

    internal class StyleBlockStyles {
        private string _selector;
        private StyleBlock _styleControl;
        private CssStyleCollection _styles = new CssStyleCollection();

        public StyleBlockStyles(string selector, StyleBlock styleControl) {
            _selector = selector;
            _styleControl = styleControl;
        }

        public bool Empty {
            get { return _styles.Count == 0; }
        }

        public StyleBlockStyles AddStyle(HtmlTextWriterStyle styleName, string value) {
            _styles.Add(styleName, value);
            return this;
        }

        public StyleBlockStyles AddStyle(string styleName, string value) {
            _styles.Add(styleName, value);
            return this;
        }

        public StyleBlockStyles AddStyles(Style style) {
            if (style != null) {
                AddStyles(style.GetStyleAttributes(_styleControl));
            }
            return this;
        }

        public StyleBlockStyles AddStyles(CssStyleCollection styles) {
            if (styles != null) {
                foreach (string key in styles.Keys) {
                    _styles.Add(key, styles[key]);
                }
            }
            return this;
        }

        public void Render(HtmlTextWriter writer) {
            writer.WriteLine("{0} {{ {1} }}", _selector, _styles.Value);
        }
    }
}