Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

249 lines
8.5 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="Content.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.Globalization;
using System.Linq;
using System.Security.Permissions;
using System.Web.UI;
using System.Web.Util;
// ContentBuilder is a builder for content control but acts like a template builder.
// Designertime it will create the <asp:Content> as a control, but a template
// builder at runtime. ContentBuilder only works if the parent builder is a
// MasterPageBuilder, otherwise this builder is simply ignored.
internal class ContentBuilderInternal: TemplateBuilder {
private const string _contentPlaceHolderIDPropName = "ContentPlaceHolderID";
// This can be an array for now since the set is small so lookup perf is not an issue
private static string[] attributesToPreserve = new[] { "ClientIDMode", "ViewStateMode" };
private string _contentPlaceHolder;
private string _contentPlaceHolderFilter;
/// <devdoc>
/// </devdoc>
public override Type BindingContainerType {
get {
return typeof(Control);
}
}
internal string ContentPlaceHolderFilter {
get {
return _contentPlaceHolderFilter;
}
}
internal string ContentPlaceHolder {
get {
return _contentPlaceHolder;
}
}
// To return the content control for designtime support
public override object BuildObject() {
if (InDesigner)
return BuildObjectInternal();
return base.BuildObject();
}
public override void InstantiateIn(Control container) {
base.InstantiateIn(container);
// Set all the children's TemplateControl properties to the owning page,
// to prevent them from incorrectly resolving to the Master page (VSWhidbey 602525)
HttpContext context = HttpContext.Current;
if (context != null) {
TemplateControl templateControl = context.TemplateControl;
if (templateControl != null && templateControl.NoCompile) {
foreach (Control child in container.Controls) {
child.TemplateControl = templateControl;
}
}
}
}
public override void Init(TemplateParser parser, ControlBuilder parentBuilder,
Type type, string tagName, string ID, IDictionary attribs) {
Dictionary<string, string> preservedAttributes = new Dictionary<string, string>();
ParsedAttributeCollection parsedAttributes = ConvertDictionaryToParsedAttributeCollection(attribs);
foreach (FilteredAttributeDictionary filteredAttributes in parsedAttributes.GetFilteredAttributeDictionaries()) {
string filter = filteredAttributes.Filter;
foreach (DictionaryEntry entry in filteredAttributes) {
string key = (string)entry.Key;
if (StringUtil.EqualsIgnoreCase(key, _contentPlaceHolderIDPropName)) {
if (_contentPlaceHolder != null) {
throw new HttpException(SR.GetString(SR.Content_only_one_contentPlaceHolderID_allowed));
}
_contentPlaceHolder = entry.Value.ToString();
_contentPlaceHolderFilter = filter;
}
else if (attributesToPreserve.Contains(key, StringComparer.OrdinalIgnoreCase)) {
// Save the attribute if it is in our list
preservedAttributes[key] = entry.Value.ToString();
}
}
}
if (!parser.FInDesigner) {
if (_contentPlaceHolder == null)
throw new HttpException(SR.GetString(SR.Control_Missing_Attribute, _contentPlaceHolderIDPropName, type.Name));
attribs.Clear();
// Add the preserevd attributes back to the control
foreach (var pair in preservedAttributes) {
attribs[pair.Key] = pair.Value;
}
}
base.Init(parser, parentBuilder, type, tagName, ID, attribs);
}
internal override void SetParentBuilder(ControlBuilder parentBuilder) {
if (!InDesigner && !(parentBuilder is FileLevelPageControlBuilder)) {
throw new HttpException(SR.GetString(SR.Content_allowed_in_top_level_only));
}
base.SetParentBuilder(parentBuilder);
}
}
// Factory used to efficiently create builder instances
internal class ContentBuilderInternalFactory: IWebObjectFactory {
object IWebObjectFactory.CreateInstance() {
return new ContentBuilderInternal();
}
}
/* This control represents the ITemplate property on the content page that will be applied
to the MasterPage template property. The ContentPlaceHolderID is never assigned at runtime. */
[
ControlBuilderAttribute(typeof(ContentBuilderInternal)),
]
[Designer("System.Web.UI.Design.WebControls.ContentDesigner, " + AssemblyRef.SystemDesign)]
[ToolboxItem(false)]
public class Content : Control, INonBindingContainer {
private string _contentPlaceHolderID;
[
DefaultValue(""),
IDReferenceProperty(typeof(ContentPlaceHolder)),
Themeable(false),
WebCategory("Behavior"),
WebSysDescription(SR.Content_ContentPlaceHolderID),
]
public string ContentPlaceHolderID {
get {
if (_contentPlaceHolderID == null) {
return String.Empty;
}
return _contentPlaceHolderID;
}
set {
if (!DesignMode)
throw new NotSupportedException(SR.GetString(SR.Property_Set_Not_Supported, "ContentPlaceHolderID", this.GetType().ToString()));
_contentPlaceHolderID = value;
}
}
#region hide these events in the designer since they will not be invoked.
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
]
public new event EventHandler DataBinding {
add {
base.DataBinding += value;
}
remove {
base.DataBinding -= value;
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
]
public new event EventHandler Disposed {
add {
base.Disposed += value;
}
remove {
base.Disposed -= value;
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
]
public new event EventHandler Init {
add {
base.Init += value;
}
remove {
base.Init -= value;
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
]
public new event EventHandler Load {
add {
base.Load += value;
}
remove {
base.Load -= value;
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
]
public new event EventHandler PreRender {
add {
base.PreRender += value;
}
remove {
base.PreRender -= value;
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
]
public new event EventHandler Unload {
add {
base.Unload += value;
}
remove {
base.Unload -= value;
}
}
#endregion
}
}