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

753 lines
29 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="DeviceSpecificChoice.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Web;
using System.Web.UI;
using System.Web.Mobile;
using System.Security.Permissions;
namespace System.Web.UI.MobileControls
{
/*
* DeviceSpecificChoice object.
*
* Copyright (c) 2000 Microsoft Corporation
*/
/// <include file='doc\DeviceSpecificChoice.uex' path='docs/doc[@for="DeviceSpecificChoice"]/*' />
[
ControlBuilderAttribute(typeof(DeviceSpecificChoiceControlBuilder)),
PersistName("Choice"),
PersistChildren(false),
]
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
[AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
[Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
public class DeviceSpecificChoice : IParserAccessor, IAttributeAccessor
{
private String _deviceFilter = String.Empty;
private String _argument;
private String _xmlns;
private IDictionary _contents;
private IDictionary _templates;
private DeviceSpecific _owner;
private static IComparer _caseInsensitiveComparer =
new CaseInsensitiveComparer(CultureInfo.InvariantCulture);
/// <include file='doc\DeviceSpecificChoice.uex' path='docs/doc[@for="DeviceSpecificChoice.Filter"]/*' />
[
DefaultValue("")
]
public String Filter
{
get
{
Debug.Assert(_deviceFilter != null);
return _deviceFilter;
}
set
{
if (value == null)
{
value = String.Empty;
}
_deviceFilter = value;
}
}
/// <include file='doc\DeviceSpecificChoice.uex' path='docs/doc[@for="DeviceSpecificChoice.Argument"]/*' />
public String Argument
{
get
{
return _argument;
}
set
{
_argument = value;
}
}
// This property is used by the Designer, and has no runtime effect
/// <include file='doc\DeviceSpecificChoice.uex' path='docs/doc[@for="DeviceSpecificChoice.Xmlns"]/*' />
[
DefaultValue("")
]
public String Xmlns
{
get
{
return _xmlns;
}
set
{
_xmlns = value;
}
}
/// <include file='doc\DeviceSpecificChoice.uex' path='docs/doc[@for="DeviceSpecificChoice.Contents"]/*' />
[
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
]
public IDictionary Contents
{
get
{
if (_contents == null)
{
_contents = new ListDictionary(_caseInsensitiveComparer);
}
return _contents;
}
}
/// <include file='doc\DeviceSpecificChoice.uex' path='docs/doc[@for="DeviceSpecificChoice.Templates"]/*' />
[
PersistenceMode(PersistenceMode.InnerProperty),
]
public IDictionary Templates
{
get
{
if (_templates == null)
{
_templates = new ListDictionary(_caseInsensitiveComparer);
}
return _templates;
}
}
/// <include file='doc\DeviceSpecificChoice.uex' path='docs/doc[@for="DeviceSpecificChoice.HasTemplates"]/*' />
[
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
]
public bool HasTemplates
{
get
{
return _templates != null && _templates.Count > 0;
}
}
internal void ApplyProperties()
{
IDictionaryEnumerator enumerator = Contents.GetEnumerator();
while (enumerator.MoveNext())
{
Object parentObject = Owner.Owner;
String propertyName = (String)enumerator.Key;
String propertyValue = enumerator.Value as String;
// The ID property may not be overridden, according to spec
// (since it will override the parent's ID, not very useful).
if (String.Equals(propertyName, "id", StringComparison.OrdinalIgnoreCase)) {
throw new ArgumentException(
SR.GetString(SR.DeviceSpecificChoice_InvalidPropertyOverride,
propertyName));
}
if (propertyValue != null)
{
// Parse through any "-" syntax items.
int dash;
while ((dash = propertyName.IndexOf("-", StringComparison.Ordinal)) != -1)
{
String containingObjectName = propertyName.Substring(0, dash);
PropertyDescriptor pd = TypeDescriptor.GetProperties(parentObject).Find(
containingObjectName, true);
if (pd == null)
{
throw new ArgumentException(
SR.GetString(SR.DeviceSpecificChoice_OverridingPropertyNotFound,
propertyName));
}
parentObject = pd.GetValue(parentObject);
propertyName = propertyName.Substring(dash + 1);
}
if (!FindAndApplyProperty(parentObject, propertyName, propertyValue) &&
!FindAndApplyEvent(parentObject, propertyName, propertyValue))
{
// If control supports IAttributeAccessor (which it should)
// use it to set a custom attribute.
IAttributeAccessor a = parentObject as IAttributeAccessor;
if (a != null)
{
a.SetAttribute(propertyName, propertyValue);
}
else
{
throw new ArgumentException(
SR.GetString(SR.DeviceSpecificChoice_OverridingPropertyNotFound,
propertyName));
}
}
}
}
}
private bool FindAndApplyProperty(Object parentObject, String name, String value)
{
PropertyDescriptor pd = TypeDescriptor.GetProperties(parentObject).Find(name, true);
if (pd == null)
{
return false;
}
// Make sure the property is declarable.
if (pd.Attributes.Contains(DesignerSerializationVisibilityAttribute.Hidden))
{
throw new ArgumentException(
SR.GetString(SR.DeviceSpecificChoice_OverridingPropertyNotDeclarable, name));
}
Object o;
Type type = pd.PropertyType;
if (type.IsAssignableFrom(typeof(String)))
{
o = value;
}
else if (type.IsAssignableFrom(typeof(int)))
{
o = Int32.Parse(value, CultureInfo.InvariantCulture);
}
else if (type.IsEnum)
{
o = Enum.Parse(type, value, true);
}
else if (value.Length == 0)
{
o = null;
}
else
{
TypeConverter converter = pd.Converter;
if (converter != null)
{
o = converter.ConvertFromInvariantString(value);
}
else
{
throw new InvalidCastException(
SR.GetString(SR.DeviceSpecificChoice_OverridingPropertyTypeCast, name));
}
}
pd.SetValue(parentObject, o);
return true;
}
private bool FindAndApplyEvent(Object parentObject, String name, String value)
{
if (name.Length > 2 &&
Char.ToLower(name[0], CultureInfo.InvariantCulture) == 'o' &&
Char.ToLower(name[1], CultureInfo.InvariantCulture) == 'n')
{
String eventName = name.Substring(2);
EventDescriptor ed = TypeDescriptor.GetEvents(parentObject).Find(eventName, true);
if (ed != null)
{
Delegate d = Delegate.CreateDelegate(ed.EventType, Owner.MobilePage, value);
ed.AddEventHandler(parentObject, d);
return true;
}
}
return false;
}
internal DeviceSpecific Owner
{
get
{
return _owner;
}
set
{
_owner = value;
}
}
internal bool Evaluate(MobileCapabilities capabilities)
{
// Evaluate the <Choice> by first looking to see if it's null, then
// checking against evaluators defined in code on the page, then by
// consulting the MobileCapabilities object.
bool result;
if (_deviceFilter != null && _deviceFilter.Length == 0) {
// indicates device-independent <choice> clause
result = true;
}
else if (CheckOnPageEvaluator(capabilities, out result))
{
// result already been set through the out-bound parameter
// above.
}
else
{
// The exception message generated by HasCapability() failing is
// inappropriate, so we substitute a more specific one.
try
{
result = capabilities.HasCapability(_deviceFilter, _argument);
}
catch
{
throw new ArgumentException(SR.GetString(
SR.DeviceSpecificChoice_CantFindFilter,
_deviceFilter));
}
}
return result;
}
// Return true if specified evaluator exists on the page with the
// correct signature. If it does, return result of invoking it in
// evaluatorResult.
private bool CheckOnPageEvaluator(MobileCapabilities capabilities,
out bool evaluatorResult)
{
evaluatorResult = false;
TemplateControl containingTemplateControl = Owner.ClosestTemplateControl;
MethodInfo methodInfo =
containingTemplateControl.GetType().GetMethod(_deviceFilter,
new Type[]
{
typeof(MobileCapabilities),
typeof(String)
}
);
if (methodInfo == null || methodInfo.ReturnType != typeof(bool))
{
return false;
}
else
{
evaluatorResult = (bool)
methodInfo.Invoke(containingTemplateControl,
new Object[]
{
capabilities,
_argument
}
);
return true;
}
}
/// <include file='doc\DeviceSpecificChoice.uex' path='docs/doc[@for="DeviceSpecificChoice.IAttributeAccessor.GetAttribute"]/*' />
/// <internalonly/>
protected String GetAttribute(String key)
{
Object o = Contents[key];
if (o != null & !(o is String))
{
throw new ArgumentException(SR.GetString(
SR.DeviceSpecificChoice_PropertyNotAnAttribute));
}
return (String)o;
}
/// <include file='doc\DeviceSpecificChoice.uex' path='docs/doc[@for="DeviceSpecificChoice.IAttributeAccessor.SetAttribute"]/*' />
/// <internalonly/>
protected void SetAttribute(String key, String value)
{
Contents[key] = value;
}
/// <include file='doc\DeviceSpecificChoice.uex' path='docs/doc[@for="DeviceSpecificChoice.IParserAccessor.AddParsedSubObject"]/*' />
/// <internalonly/>
protected void AddParsedSubObject(Object obj)
{
DeviceSpecificChoiceTemplateContainer c = obj as DeviceSpecificChoiceTemplateContainer;
if (c != null)
{
Templates[c.Name] = c.Template;
}
}
#region IAttributeAccessor implementation
String IAttributeAccessor.GetAttribute(String name) {
return GetAttribute(name);
}
void IAttributeAccessor.SetAttribute(String name, String value) {
SetAttribute(name, value);
}
#endregion
#region IParserAccessor implementation
void IParserAccessor.AddParsedSubObject(Object obj) {
AddParsedSubObject(obj);
}
#endregion
}
// TEMPLATE BAG
//
// The following classes are public by necessity (since they are exposed to
// the framework), but all internal to the DeviceSpecificChoice. They have to do with
// persistence of arbitrary templates in a choice. Here's a description of what is done:
//
// ASP.NET provides no way for an object or control to allow an arbitrary bag of
// templates. It only allows one way to define templates - the parent object must have
// a property, of type ITemplate, with the same name as the template name. For example,
// the code
//
// <ParentCtl>
// <FirstTemplate>....</FirstTemplate>
// <SecondTemplate>....</SecondTemplate>
// <ThirdTemplate>....</ThirdTemplate>
// </ParentCtl>
//
// only works if the ParentCtl class exposes ITemplate properties with names FirstTemplate,
// SecondTemplate, and ThirdTemplate.
//
// Because Choices apply to any control, that could potentially require any named template,
// what we really need is something like a "template bag" that takes arbitrary templates.
//
// To work around this, here's what is done. First, at compile time:
//
// 1) DeviceSpecificChoice has its own control builder at compile time. When it is given a
// sub-object (in GetChildControlType), it returns DeviceSpecificChoiceTemplateType, which
// is a marker type similar to that used in ASP.NET. However, it is our own class, and
// has DeviceSpecificChoiceTemplateBuilder as its builder.
// 2) DeviceSpecificChoiceTemplateBuilder inherits from TemplateBuilder, and thus has the same
// behavior as TemplateBuilder for parsing and compiling a template. However, it has
// an overriden Init method, which changes the tag name (and thus, the template name)
// to a constant, "Template". It also saves the real template name in a property.
// 3) When parsed, the framework calls the AppendSubBuilder method of the
// DeviceSpecificChoiceBuilder, to add the template builder into it. But this builder
// first creates an intermediate builder, for the class DeviceSpecificChoiceTemplateContainer,
// adding the template name as a property in the builder's attribute dictionary. It then
// adds the intermediate builder into itself, and the template builder into it.
//
// All this has the net effect of automatically transforming something like
//
// <Choice>
// <ItemTemplate>...</ItemTemplate>
// <HeaderTemplate>...</HeaderTemplate>
// </Choice>
//
// into
//
// <Choice>
// <DeviceSpecificChoiceTemplateContainer Name="ItemTemplate">
// <Template>...</Template>
// </DeviceSpecificChoiceTemplateContainer>
// <DeviceSpecificChoiceTemplateContainer Name="HeaderTemplate">
// <Template>...</Template>
// </DeviceSpecificChoiceTemplateContainer>
// </Choice>
//
// Now, at runtime the compiled code creates a DeviceSpecificChoiceTemplateContainer object,
// and calls the AddParsedSubObject method of the DeviceSpecificChoice with it. This code (above)
// then extracts the template referred to by the Template property of the object, and
// uses the Name property to add it to the template bag. Presto, we have a general template bag.
/*
* DeviceSpecificChoice control builder. For more information, see note on "Template Bag" above.
*
* Copyright (c) 2000 Microsoft Corporation
*/
/// <include file='doc\DeviceSpecificChoice.uex' path='docs/doc[@for="DeviceSpecificChoiceControlBuilder"]/*' />
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
[AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
[Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
public class DeviceSpecificChoiceControlBuilder : ControlBuilder
{
private bool _isDeviceIndependent = false;
internal bool IsDeviceIndependent()
{
return _isDeviceIndependent;
}
/// <include file='doc\DeviceSpecificChoice.uex' path='docs/doc[@for="DeviceSpecificChoiceControlBuilder.Init"]/*' />
public override void Init(TemplateParser parser,
ControlBuilder parentBuilder,
Type type,
String tagName,
String id,
IDictionary attributes)
{
if (!(parentBuilder is DeviceSpecificControlBuilder))
{
throw new ArgumentException(
SR.GetString(SR.DeviceSpecificChoice_ChoiceOnlyExistInDeviceSpecific));
}
_isDeviceIndependent = attributes == null || attributes["Filter"] == null;
base.Init (parser, parentBuilder, type, tagName, id, attributes);
}
/// <include file='doc\DeviceSpecificChoice.uex' path='docs/doc[@for="DeviceSpecificChoiceControlBuilder.AppendLiteralString"]/*' />
public override void AppendLiteralString(String text)
{
// Ignore literal strings.
}
/// <include file='doc\DeviceSpecificChoice.uex' path='docs/doc[@for="DeviceSpecificChoiceControlBuilder.GetChildControlType"]/*' />
public override Type GetChildControlType(String tagName, IDictionary attributes)
{
// Assume children are templates.
return typeof(DeviceSpecificChoiceTemplateType);
}
/// <include file='doc\DeviceSpecificChoice.uex' path='docs/doc[@for="DeviceSpecificChoiceControlBuilder.AppendSubBuilder"]/*' />
public override void AppendSubBuilder(ControlBuilder subBuilder)
{
DeviceSpecificChoiceTemplateBuilder tplBuilder =
subBuilder as DeviceSpecificChoiceTemplateBuilder;
if (tplBuilder != null)
{
// Called to add a template. Insert an intermediate control,
// by creating and adding its builder.
ListDictionary dict = new ListDictionary();
// Add the template's name as a Name attribute for the control.
dict["Name"] = tplBuilder.TemplateName;
// 1 and "xxxx" are bogus filename/line number values.
ControlBuilder container = ControlBuilder.CreateBuilderFromType(
Parser, this,
typeof(DeviceSpecificChoiceTemplateContainer),
"Templates",
null, dict, 1, null);
base.AppendSubBuilder(container);
// Now, append the template builder into the new intermediate builder.
container.AppendSubBuilder(subBuilder);
}
else
{
base.AppendSubBuilder(subBuilder);
}
}
}
/*
* DeviceSpecificChoiceTemplateType - marker type for a template that goes inside
* a Choice. Used only at compile time, and never instantiated. See note
* on "Template Bag" above.
*
* Copyright (c) 2000 Microsoft Corporation
*/
[
ControlBuilderAttribute(typeof(DeviceSpecificChoiceTemplateBuilder))
]
[Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
internal class DeviceSpecificChoiceTemplateType : Control, IParserAccessor
{
private DeviceSpecificChoiceTemplateType()
{
}
void IParserAccessor.AddParsedSubObject(Object o)
{
}
}
/*
* DeviceSpecificChoiceTemplateBuilder - builder for a template that goes inside
* a Choice. See note on "Template Bag" above.
* When a Choice is device-independent, it also parses literal text content.
* The code for this is copied from LiteralTextContainerControlBuilder.cs
*
* Copyright (c) 2000 Microsoft Corporation
*/
/// <include file='doc\DeviceSpecificChoice.uex' path='docs/doc[@for="DeviceSpecificChoiceTemplateBuilder"]/*' />
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
[AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
[Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
public class DeviceSpecificChoiceTemplateBuilder : TemplateBuilder
{
private String _templateName;
private bool _doLiteralText = false;
private bool _controlsInserted = false;
internal String TemplateName
{
get
{
return _templateName;
}
}
CompileLiteralTextParser _textParser = null;
internal CompileLiteralTextParser TextParser
{
get
{
if (_textParser == null)
{
_textParser =
new CompileLiteralTextParser(Parser, this, "xxxx", 1);
if (_controlsInserted)
{
_textParser.ResetBreaking();
_textParser.ResetNewParagraph();
}
}
return _textParser;
}
}
/// <include file='doc\DeviceSpecificChoice.uex' path='docs/doc[@for="DeviceSpecificChoiceTemplateBuilder.Init"]/*' />
public override void Init(TemplateParser parser,
ControlBuilder parentBuilder,
Type type,
String tagName,
String id,
IDictionary attributes)
{
// Save off template name, and always pass the name "Template" to the base
// class, because the intermediate object has this property as the name.
_templateName = tagName;
base.Init(parser, parentBuilder, type, "Template", id, attributes);
// Are we a device-independent template?
if (!InDesigner)
{
DeviceSpecificChoiceControlBuilder choiceBuilder =
parentBuilder as DeviceSpecificChoiceControlBuilder;
_doLiteralText = choiceBuilder != null && choiceBuilder.IsDeviceIndependent();
}
}
/// <include file='doc\DeviceSpecificChoice.uex' path='docs/doc[@for="DeviceSpecificChoiceTemplateBuilder.AppendLiteralString"]/*' />
public override void AppendLiteralString(String text)
{
if (_doLiteralText)
{
if (LiteralTextParser.IsValidText(text))
{
TextParser.Parse(text);
}
}
else
{
base.AppendLiteralString(text);
}
}
/// <include file='doc\DeviceSpecificChoice.uex' path='docs/doc[@for="DeviceSpecificChoiceTemplateBuilder.AppendSubBuilder"]/*' />
public override void AppendSubBuilder(ControlBuilder subBuilder)
{
if (_doLiteralText)
{
// The first one is used if ASP.NET is compiled with FAST_DATABINDING off. The second
// is used if it is compiled with FAST_DATABINDING on. Note: We can't do a type
// comparison because CodeBlockBuilder is internal.
// if (typeof(DataBoundLiteralControl).IsAssignableFrom(subBuilder.ControlType))
if (subBuilder.GetType().FullName == "System.Web.UI.CodeBlockBuilder")
{
TextParser.AddDataBinding(subBuilder);
}
else
{
base.AppendSubBuilder(subBuilder);
if (subBuilder.ControlType != typeof(LiteralText))
{
if (_textParser != null)
{
_textParser.ResetBreaking();
}
else
{
_controlsInserted = true;
}
}
}
}
else
{
base.AppendSubBuilder(subBuilder);
}
}
}
/*
* DeviceSpecificChoiceTemplateContainer - "dummy" container object for
* a template that goes inside a Choice. Once the Choice receives and
* extracts the information out of it, this object is simply discarded.
* See note on "Template Bag" above.
*
* Copyright (c) 2000 Microsoft Corporation
*/
/// <include file='doc\DeviceSpecificChoice.uex' path='docs/doc[@for="DeviceSpecificChoiceTemplateContainer"]/*' />
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
[AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
[Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
public class DeviceSpecificChoiceTemplateContainer
{
private ITemplate _template;
private String _name;
/// <include file='doc\DeviceSpecificChoice.uex' path='docs/doc[@for="DeviceSpecificChoiceTemplateContainer.Template"]/*' />
[
Filterable(false),
TemplateContainer(typeof(TemplateContainer)),
]
public ITemplate Template
{
get
{
return _template;
}
set
{
_template = value;
}
}
/// <include file='doc\DeviceSpecificChoice.uex' path='docs/doc[@for="DeviceSpecificChoiceTemplateContainer.Name"]/*' />
public String Name
{
get
{
return _name;
}
set
{
_name = value;
}
}
}
}