753 lines
29 KiB
C#
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;
|
|
}
|
|
}
|
|
}
|
|
}
|