Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web/UI/HtmlControls/HtmlHead.cs

@@ -0,0 +1,391 @@
+//------------------------------------------------------------------------------
+// <copyright file="HtmlHead.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web.UI.HtmlControls {
+    using System;
+    using System.Collections;
+    using System.Collections.Specialized;
+    using System.ComponentModel;
+    using System.Globalization;
+    using System.Web;
+    using System.Web.UI;
+    using System.Web.UI.WebControls;
+    using System.Security.Permissions;
+
+    public class HtmlHeadBuilder : ControlBuilder {
+
+
+        public override Type GetChildControlType(string tagName, IDictionary attribs) {
+            if (String.Equals(tagName, "title", StringComparison.OrdinalIgnoreCase))
+                return typeof(HtmlTitle);
+
+            if (String.Equals(tagName, "link", StringComparison.OrdinalIgnoreCase))
+                return typeof(HtmlLink);
+
+            if (String.Equals(tagName, "meta", StringComparison.OrdinalIgnoreCase))
+                return typeof(HtmlMeta);
+
+            return null;
+        }
+
+
+        public override bool AllowWhitespaceLiterals() {
+            return false;
+        }
+    }
+
+    /// <devdoc>
+    /// Represents the HEAD element.
+    /// </devdoc>
+    [
+    ControlBuilderAttribute(typeof(HtmlHeadBuilder))
+    ]
+    public sealed class HtmlHead : HtmlGenericControl {
+
+        private StyleSheetInternal _styleSheet;
+        private HtmlTitle _title;
+        private String _cachedTitleText;
+        private HtmlMeta _description;
+        private String _cachedDescription;
+        private HtmlMeta _keywords;
+        private String _cachedKeywords;
+
+        /// <devdoc>
+        /// Initializes an instance of an HtmlHead class.
+        /// </devdoc>
+        public HtmlHead() : base("head") {
+        }
+
+        public HtmlHead(string tag) : base(tag) {
+            if (tag == null) {
+                tag = String.Empty;
+            }
+            _tagName = tag;
+        }
+
+        public IStyleSheet StyleSheet {
+            get {
+                if (_styleSheet == null) {
+                    _styleSheet = new StyleSheetInternal(this);
+                }
+
+                return _styleSheet;
+            }
+        }
+
+        public String Title {
+            get {
+                if (_title == null) {
+                    return _cachedTitleText;
+                }
+
+                return _title.Text;
+            }
+            set {
+                if (_title == null) {
+                    // Side effect of adding a title to the control assigns _title
+                    _cachedTitleText = value;
+                }
+                else {
+                    _title.Text = value;
+                }
+            }
+        }
+
+        public String Description {
+            get {
+                if (_description == null) {
+                    return _cachedDescription;
+                }
+
+                return _description.Content;
+            }
+            set {
+                if (_description == null) {
+                    // Side effect of adding a description to the control assigns _description
+                    _cachedDescription = value;
+                }
+                else {
+                    _description.Content = value;
+                }
+            }
+        }
+
+        public String Keywords {
+            get {
+                if (_keywords == null) {
+                    return _cachedKeywords;
+                }
+
+                return _keywords.Content;
+            }
+            set {
+                if (_keywords == null) {
+                    // Side effect of adding a title to the control assigns _title
+                    _cachedKeywords = value;
+                }
+                else {
+                    _keywords.Content = value;
+                }
+            }
+        }
+
+        protected internal override void AddedControl(Control control, int index) {
+            base.AddedControl(control, index);
+
+            if (control is HtmlTitle) {
+                if (_title != null) {
+                    throw new HttpException(SR.GetString(SR.HtmlHead_OnlyOneTitleAllowed));
+                }
+
+                _title = (HtmlTitle)control;
+            }
+            else if (control is HtmlMeta) {
+                // We will only use the first matching meta tag per, and ignore any others
+                HtmlMeta meta = (HtmlMeta)control;
+                if (_description == null && string.Equals(meta.Name, "description", StringComparison.OrdinalIgnoreCase)) {
+                    _description = meta;
+                }
+                else if (_keywords == null && string.Equals(meta.Name, "keywords", StringComparison.OrdinalIgnoreCase)) {
+                    _keywords = meta;
+                }
+            }
+        }
+
+        /// <internalonly/>
+        /// <devdoc>
+        /// Allows the HEAD element to register itself with the page.
+        /// </devdoc>
+        protected internal override void OnInit(EventArgs e) {
+            base.OnInit(e);
+
+            Page p = Page;
+            if (p == null) {
+                throw new HttpException(SR.GetString(SR.Head_Needs_Page));
+            }
+            if (p.Header != null) {
+                throw new HttpException(SR.GetString(SR.HtmlHead_OnlyOneHeadAllowed));
+            }
+            p.SetHeader(this);
+        }
+
+        internal void RegisterCssStyleString(string outputString) {
+            ((StyleSheetInternal)StyleSheet).CSSStyleString = outputString;
+        }
+
+        protected internal override void RemovedControl(Control control) {
+            base.RemovedControl(control);
+
+            if (control is HtmlTitle) {
+                _title = null;
+            }
+            // There can be many meta tags, so we only clear it if its the correct meta
+            else if (control == _description) {
+                _description = null;
+            }
+            else if (control == _keywords) {
+                _keywords = null;
+            }
+        }
+
+        /// <internalonly/>
+        /// <devdoc>
+        /// Notifies the Page when the HEAD is being rendered.
+        /// </devdoc>
+        protected internal override void RenderChildren(HtmlTextWriter writer) {
+            base.RenderChildren(writer);
+
+            if (_title == null) {
+                // Always render out a <title> tag since it is required for xhtml 1.1 compliance
+                writer.RenderBeginTag(HtmlTextWriterTag.Title);
+                if (_cachedTitleText != null) {
+                    writer.Write(_cachedTitleText);
+                }
+                writer.RenderEndTag();
+            }
+
+            if (_description == null && !String.IsNullOrEmpty(_cachedDescription)) {
+                // Go ahead and render out a meta tag if they set description but don't have a meta tag
+                writer.AddAttribute(HtmlTextWriterAttribute.Name, "description");
+                writer.AddAttribute(HtmlTextWriterAttribute.Content, _cachedDescription);
+                writer.RenderBeginTag(HtmlTextWriterTag.Meta);
+                writer.RenderEndTag();
+            }
+
+            if (_keywords == null && !String.IsNullOrEmpty(_cachedKeywords)) {
+                // Go ahead and render out a meta tag if they set keywords but don't have a meta tag
+                writer.AddAttribute(HtmlTextWriterAttribute.Name, "keywords");
+                writer.AddAttribute(HtmlTextWriterAttribute.Content, _cachedKeywords);
+                writer.RenderBeginTag(HtmlTextWriterTag.Meta);
+                writer.RenderEndTag();
+            }
+
+            if ((string)Page.Request.Browser["requiresXhtmlCssSuppression"] != "true") {
+                RenderStyleSheet(writer);
+            }
+        }
+
+        internal void RenderStyleSheet(HtmlTextWriter writer) {
+            if(_styleSheet != null) {
+                _styleSheet.Render(writer);
+            }
+        }
+
+        internal static void RenderCssRule(CssTextWriter cssWriter, string selector,
+            Style style, IUrlResolutionService urlResolver) {
+
+            cssWriter.WriteBeginCssRule(selector);
+
+            CssStyleCollection attrs = style.GetStyleAttributes(urlResolver);
+            attrs.Render(cssWriter);
+
+            cssWriter.WriteEndCssRule();
+        }
+
+        /// <devdoc>
+        /// Implements the IStyleSheet interface to represent an embedded
+        /// style sheet within the HEAD element.
+        /// </devdoc>
+        private sealed class StyleSheetInternal : IStyleSheet, IUrlResolutionService {
+
+            private HtmlHead _owner;
+            private ArrayList _styles;
+            private ArrayList _selectorStyles;
+
+            private int _autoGenCount;
+
+            public StyleSheetInternal(HtmlHead owner) {
+                _owner = owner;
+            }
+
+            // CssStyleString registered by the PartialCachingControl
+            private string _cssStyleString;
+            internal string CSSStyleString {
+                get {
+                    return _cssStyleString;
+                }
+                set {
+                    _cssStyleString = value;
+                }
+            }
+
+            public void Render(HtmlTextWriter writer) {
+                if ((_styles == null) && (_selectorStyles == null) && CSSStyleString == null) {
+                    return;
+                }
+
+                writer.AddAttribute(HtmlTextWriterAttribute.Type, "text/css");
+                writer.RenderBeginTag(HtmlTextWriterTag.Style);
+
+                CssTextWriter cssWriter = new CssTextWriter(writer);
+                if (_styles != null) {
+                    for (int i = 0; i < _styles.Count; i++) {
+                        StyleInfo si = (StyleInfo)_styles[i];
+
+                        string cssClass = si.style.RegisteredCssClass;
+                        if (cssClass.Length != 0) {
+                            RenderCssRule(cssWriter, "." + cssClass, si.style, si.urlResolver);
+                        }
+                    }
+                }
+
+                if (_selectorStyles != null) {
+                    for (int i = 0; i < _selectorStyles.Count; i++) {
+                        SelectorStyleInfo si = (SelectorStyleInfo)_selectorStyles[i];
+                        RenderCssRule(cssWriter, si.selector, si.style, si.urlResolver);
+                    }
+                }
+
+                if (CSSStyleString != null) {
+                    writer.Write(CSSStyleString);
+                }
+
+                writer.RenderEndTag();
+            }
+
+            #region Implementation of IStyleSheet
+            void IStyleSheet.CreateStyleRule(Style style, IUrlResolutionService urlResolver, string selector) {
+                if (style == null) {
+                    throw new ArgumentNullException("style");
+                }
+
+                if (selector.Length == 0) {
+                    throw new ArgumentNullException("selector");
+                }
+
+                if (_selectorStyles == null) {
+                    _selectorStyles = new ArrayList();
+                }
+
+                if (urlResolver == null) {
+                    urlResolver = this;
+                }
+
+                SelectorStyleInfo styleInfo = new SelectorStyleInfo();
+                styleInfo.selector = selector;
+                styleInfo.style = style;
+                styleInfo.urlResolver = urlResolver;
+
+                _selectorStyles.Add(styleInfo);
+
+                Page page = _owner.Page;
+
+                // If there are any partial caching controls on the stack, forward the styleInfo to them
+                if (page.PartialCachingControlStack != null) {
+                    foreach (BasePartialCachingControl c in page.PartialCachingControlStack) {
+                        c.RegisterStyleInfo(styleInfo);
+                    }
+                }
+            }
+
+            void IStyleSheet.RegisterStyle(Style style, IUrlResolutionService urlResolver) {
+                if (style == null) {
+                    throw new ArgumentNullException("style");
+                }
+
+                if (_styles == null) {
+                    _styles = new ArrayList();
+                }
+                else if (style.RegisteredCssClass.Length != 0) {
+                    // if it's already registered, throw an exception
+                    throw new InvalidOperationException(SR.GetString(SR.HtmlHead_StyleAlreadyRegistered));
+                }
+
+                if (urlResolver == null) {
+                    urlResolver = this;
+                }
+
+                StyleInfo styleInfo = new StyleInfo();
+                styleInfo.style = style;
+                styleInfo.urlResolver = urlResolver;
+
+                int index = _autoGenCount++;
+                string name = "aspnet_s" + index.ToString(NumberFormatInfo.InvariantInfo);
+
+                style.SetRegisteredCssClass(name);
+                _styles.Add(styleInfo);
+            }
+            #endregion
+
+            #region Implementation of IUrlResolutionService
+            string IUrlResolutionService.ResolveClientUrl(string relativeUrl) {
+                return _owner.ResolveClientUrl(relativeUrl);
+            }
+            #endregion
+
+            private sealed class StyleInfo {
+                public Style style;
+                public IUrlResolutionService urlResolver;
+            }
+        }
+    }
+
+    internal sealed class SelectorStyleInfo {
+        public string selector;
+        public Style style;
+        public IUrlResolutionService urlResolver;
+    }
+}