392 lines
13 KiB
C#
392 lines
13 KiB
C#
//------------------------------------------------------------------------------
|
|
// <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;
|
|
}
|
|
}
|