2024 lines
72 KiB
C#
2024 lines
72 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="MobileCapabilities.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.Mobile
|
|
{
|
|
using System.Web;
|
|
using System.Collections;
|
|
using System.Configuration;
|
|
using System.Reflection;
|
|
using System.Diagnostics;
|
|
using System.ComponentModel;
|
|
using System.Globalization;
|
|
using System.Security.Permissions;
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities"]/*' />
|
|
[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 MobileCapabilities : HttpBrowserCapabilities
|
|
{
|
|
internal delegate bool EvaluateCapabilitiesDelegate(MobileCapabilities capabilities,
|
|
String evalParameter);
|
|
|
|
private Hashtable _evaluatorResults = Hashtable.Synchronized(new Hashtable());
|
|
|
|
private const String _kDeviceFiltersConfig = "system.web/deviceFilters";
|
|
private static readonly object _staticLock = new object();
|
|
|
|
[AspNetHostingPermission(SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
|
|
[AspNetHostingPermission(SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
|
|
[ConfigurationPermission(SecurityAction.Assert, Unrestricted = true)]
|
|
private DeviceFilterDictionary GetCurrentFilters()
|
|
{
|
|
object config = ConfigurationManager.GetSection(_kDeviceFiltersConfig);
|
|
DeviceFiltersSection controlSection = config as DeviceFiltersSection;
|
|
if (controlSection != null)
|
|
{
|
|
return controlSection.GetDeviceFilters();
|
|
}
|
|
return (DeviceFilterDictionary)config;
|
|
}
|
|
|
|
private bool HasComparisonEvaluator(String evaluatorName, out bool result)
|
|
{
|
|
result = false;
|
|
String evaluator;
|
|
String argument;
|
|
|
|
DeviceFilterDictionary currentFilters = GetCurrentFilters();
|
|
if(currentFilters == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if(!currentFilters.FindComparisonEvaluator(evaluatorName, out evaluator, out argument))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
result = HasCapability(evaluator, argument);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
private bool HasDelegatedEvaluator(String evaluatorName, String parameter,
|
|
out bool result)
|
|
{
|
|
result = false;
|
|
EvaluateCapabilitiesDelegate evaluator;
|
|
|
|
DeviceFilterDictionary currentFilters = GetCurrentFilters();
|
|
if(currentFilters == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if(!currentFilters.FindDelegateEvaluator(evaluatorName, out evaluator))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
result = evaluator(this, parameter);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
private bool HasItem(String evaluatorName, String parameter,
|
|
out bool result)
|
|
{
|
|
result = false;
|
|
String item;
|
|
|
|
item = this[evaluatorName];
|
|
if(item == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
result = (item == parameter);
|
|
return true;
|
|
}
|
|
|
|
|
|
private bool HasProperty(String evaluatorName, String parameter,
|
|
out bool result)
|
|
{
|
|
result = false;
|
|
PropertyDescriptor propertyDescriptor =
|
|
TypeDescriptor.GetProperties(this)[evaluatorName];
|
|
if(propertyDescriptor == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
String propertyValue = propertyDescriptor.GetValue(this).ToString();
|
|
bool invariantCultureIgnoreCase = (propertyDescriptor.PropertyType == typeof(bool) && parameter != null);
|
|
StringComparison compareOption = invariantCultureIgnoreCase ? StringComparison.InvariantCultureIgnoreCase : StringComparison.CurrentCulture;
|
|
result = (String.Equals(propertyValue, parameter, compareOption));
|
|
return true;
|
|
}
|
|
|
|
|
|
private bool IsComparisonEvaluator(String evaluatorName)
|
|
{
|
|
DeviceFilterDictionary currentFilters = GetCurrentFilters();
|
|
|
|
if(currentFilters == null)
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
return currentFilters.IsComparisonEvaluator(evaluatorName) &&
|
|
!currentFilters.IsDelegateEvaluator(evaluatorName);
|
|
}
|
|
}
|
|
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.HasCapability"]/*' />
|
|
public bool HasCapability(String delegateName, String optionalParameter)
|
|
{
|
|
bool result;
|
|
bool resultFound;
|
|
|
|
if(String.IsNullOrEmpty(delegateName))
|
|
{
|
|
throw new ArgumentException(SR.GetString(SR.MobCap_DelegateNameNoValue),
|
|
"delegateName");
|
|
}
|
|
|
|
// Check for cached results
|
|
|
|
DeviceFilterDictionary currentFilters = GetCurrentFilters();
|
|
String hashKey = ((currentFilters == null) ? "null" : currentFilters.GetHashCode().ToString(CultureInfo.InvariantCulture))
|
|
+ delegateName;
|
|
|
|
if(optionalParameter != null && !IsComparisonEvaluator(delegateName))
|
|
{
|
|
hashKey += optionalParameter;
|
|
}
|
|
|
|
if (_evaluatorResults.Contains(hashKey))
|
|
{
|
|
return (bool)_evaluatorResults[hashKey];
|
|
}
|
|
|
|
lock (_staticLock)
|
|
{
|
|
if (_evaluatorResults.Contains(hashKey))
|
|
{
|
|
return (bool)_evaluatorResults[hashKey];
|
|
}
|
|
|
|
// Note: The fact that delegate evaluators are checked before comparison evaluators
|
|
// determines the implementation of IsComparisonEvaluator above.
|
|
|
|
resultFound = HasDelegatedEvaluator(delegateName, optionalParameter, out result);
|
|
|
|
if (!resultFound)
|
|
{
|
|
resultFound = HasComparisonEvaluator(delegateName, out result);
|
|
|
|
if (!resultFound)
|
|
{
|
|
resultFound = HasProperty(delegateName, optionalParameter, out result);
|
|
|
|
if (!resultFound)
|
|
{
|
|
resultFound = HasItem(delegateName, optionalParameter, out result);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (resultFound)
|
|
{
|
|
_evaluatorResults.Add(hashKey, result);
|
|
}
|
|
else
|
|
{
|
|
throw new ArgumentOutOfRangeException(
|
|
"delegateName",
|
|
SR.GetString(SR.MobCap_CantFindCapability, delegateName));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|
|
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.MobileDeviceManufacturer"]/*' />
|
|
/* public virtual String MobileDeviceManufacturer
|
|
{
|
|
get
|
|
{
|
|
if(!_haveMobileDeviceManufacturer)
|
|
{
|
|
_mobileDeviceManufacturer = this["mobileDeviceManufacturer"];
|
|
_haveMobileDeviceManufacturer = true;
|
|
}
|
|
return _mobileDeviceManufacturer;
|
|
}
|
|
}
|
|
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.MobileDeviceModel"]/*' />
|
|
public virtual String MobileDeviceModel
|
|
{
|
|
get
|
|
{
|
|
if(!_haveMobileDeviceModel)
|
|
{
|
|
_mobileDeviceModel = this["mobileDeviceModel"];
|
|
_haveMobileDeviceModel = true;
|
|
}
|
|
return _mobileDeviceModel;
|
|
}
|
|
}
|
|
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.GatewayVersion"]/*' />
|
|
public virtual String GatewayVersion
|
|
{
|
|
get
|
|
{
|
|
if(!_haveGatewayVersion)
|
|
{
|
|
_gatewayVersion = this["gatewayVersion"];
|
|
_haveGatewayVersion = true;
|
|
}
|
|
return _gatewayVersion;
|
|
}
|
|
}
|
|
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.GatewayMajorVersion"]/*' />
|
|
public virtual int GatewayMajorVersion
|
|
{
|
|
get
|
|
{
|
|
if(!_haveGatewayMajorVersion)
|
|
{
|
|
_gatewayMajorVersion = Convert.ToInt32(this["gatewayMajorVersion"]);
|
|
_haveGatewayMajorVersion = true;
|
|
}
|
|
return _gatewayMajorVersion;
|
|
}
|
|
}
|
|
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.GatewayMinorVersion"]/*' />
|
|
public virtual double GatewayMinorVersion
|
|
{
|
|
get
|
|
{
|
|
if(!_haveGatewayMinorVersion)
|
|
{
|
|
// The conversion below does not use Convert.ToDouble()
|
|
// because it depends on the current locale. So a german machine it would look for
|
|
// a comma as a seperator "1,5" where all user-agent strings use english
|
|
// decimal points "1.5". URT11176
|
|
//
|
|
_gatewayMinorVersion = double.Parse(
|
|
this["gatewayMinorVersion"],
|
|
NumberStyles.Float | NumberStyles.AllowDecimalPoint,
|
|
NumberFormatInfo.InvariantInfo);
|
|
_haveGatewayMinorVersion = true;
|
|
}
|
|
return _gatewayMinorVersion;
|
|
}
|
|
}
|
|
|
|
*/
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.PreferredRenderingTypeHtml32"]/*' />
|
|
public static readonly String PreferredRenderingTypeHtml32 = "html32";
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.PreferredRenderingTypeWml11"]/*' />
|
|
public static readonly String PreferredRenderingTypeWml11 = "wml11";
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.PreferredRenderingTypeWml12"]/*' />
|
|
public static readonly String PreferredRenderingTypeWml12 = "wml12";
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.PreferredRenderingTypeChtml10"]/*' />
|
|
public static readonly String PreferredRenderingTypeChtml10 = "chtml10";
|
|
|
|
/*
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.PreferredRenderingType"]/*' />
|
|
public virtual String PreferredRenderingType
|
|
{
|
|
get
|
|
{
|
|
if(!_havePreferredRenderingType)
|
|
{
|
|
_preferredRenderingType = this["preferredRenderingType"];
|
|
_havePreferredRenderingType = true;
|
|
}
|
|
return _preferredRenderingType;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.PreferredRenderingMime"]/*' />
|
|
public virtual String PreferredRenderingMime
|
|
{
|
|
get
|
|
{
|
|
if(!_havePreferredRenderingMime)
|
|
{
|
|
_preferredRenderingMime = this["preferredRenderingMime"];
|
|
_havePreferredRenderingMime = true;
|
|
}
|
|
return _preferredRenderingMime;
|
|
}
|
|
}
|
|
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.PreferredImageMime"]/*' />
|
|
public virtual String PreferredImageMime
|
|
{
|
|
get
|
|
{
|
|
if(!_havePreferredImageMime)
|
|
{
|
|
_preferredImageMime = this["preferredImageMime"];
|
|
_havePreferredImageMime = true;
|
|
}
|
|
return _preferredImageMime;
|
|
}
|
|
}
|
|
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.ScreenCharactersWidth"]/*' />
|
|
public virtual int ScreenCharactersWidth
|
|
{
|
|
get
|
|
{
|
|
if(!_haveScreenCharactersWidth)
|
|
{
|
|
if(this["screenCharactersWidth"] == null)
|
|
{
|
|
// calculate from best partial information
|
|
|
|
int screenPixelsWidthToUse = 640;
|
|
int characterWidthToUse = 8;
|
|
|
|
if(this["screenPixelsWidth"] != null && this["characterWidth"] != null)
|
|
{
|
|
screenPixelsWidthToUse = Convert.ToInt32(this["screenPixelsWidth"]);
|
|
characterWidthToUse = Convert.ToInt32(this["characterWidth"]);
|
|
}
|
|
else if(this["screenPixelsWidth"] != null)
|
|
{
|
|
screenPixelsWidthToUse = Convert.ToInt32(this["screenPixelsWidth"]);
|
|
characterWidthToUse = Convert.ToInt32(this["defaultCharacterWidth"]);
|
|
}
|
|
else if(this["characterWidth"] != null)
|
|
{
|
|
screenPixelsWidthToUse = Convert.ToInt32(this["defaultScreenPixelsWidth"]);
|
|
characterWidthToUse = Convert.ToInt32(this["characterWidth"]);
|
|
}
|
|
else if(this["defaultScreenCharactersWidth"] != null)
|
|
{
|
|
screenPixelsWidthToUse = Convert.ToInt32(this["defaultScreenCharactersWidth"]);
|
|
characterWidthToUse = 1;
|
|
}
|
|
|
|
_screenCharactersWidth = screenPixelsWidthToUse / characterWidthToUse;
|
|
}
|
|
else
|
|
{
|
|
_screenCharactersWidth = Convert.ToInt32(this["screenCharactersWidth"]);
|
|
}
|
|
_haveScreenCharactersWidth = true;
|
|
}
|
|
return _screenCharactersWidth;
|
|
}
|
|
}
|
|
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.ScreenCharactersHeight"]/*' />
|
|
public virtual int ScreenCharactersHeight
|
|
{
|
|
get
|
|
{
|
|
if(!_haveScreenCharactersHeight)
|
|
{
|
|
if(this["screenCharactersHeight"] == null)
|
|
{
|
|
// calculate from best partial information
|
|
|
|
int screenPixelHeightToUse = 480;
|
|
int characterHeightToUse = 12;
|
|
|
|
if(this["screenPixelsHeight"] != null && this["characterHeight"] != null)
|
|
{
|
|
screenPixelHeightToUse = Convert.ToInt32(this["screenPixelsHeight"]);
|
|
characterHeightToUse = Convert.ToInt32(this["characterHeight"]);
|
|
}
|
|
else if(this["screenPixelsHeight"] != null)
|
|
{
|
|
screenPixelHeightToUse = Convert.ToInt32(this["screenPixelsHeight"]);
|
|
characterHeightToUse = Convert.ToInt32(this["defaultCharacterHeight"]);
|
|
}
|
|
else if(this["characterHeight"] != null)
|
|
{
|
|
screenPixelHeightToUse = Convert.ToInt32(this["defaultScreenPixelsHeight"]);
|
|
characterHeightToUse = Convert.ToInt32(this["characterHeight"]);
|
|
}
|
|
else if(this["defaultScreenCharactersHeight"] != null)
|
|
{
|
|
screenPixelHeightToUse = Convert.ToInt32(this["defaultScreenCharactersHeight"]);
|
|
characterHeightToUse = 1;
|
|
}
|
|
|
|
_screenCharactersHeight = screenPixelHeightToUse / characterHeightToUse;
|
|
}
|
|
else
|
|
{
|
|
_screenCharactersHeight = Convert.ToInt32(this["screenCharactersHeight"]);
|
|
}
|
|
_haveScreenCharactersHeight = true;
|
|
}
|
|
return _screenCharactersHeight;
|
|
}
|
|
}
|
|
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.ScreenPixelsWidth"]/*' />
|
|
public virtual int ScreenPixelsWidth
|
|
{
|
|
get
|
|
{
|
|
if(!_haveScreenPixelsWidth)
|
|
{
|
|
if(this["screenPixelsWidth"] == null)
|
|
{
|
|
// calculate from best partial information
|
|
|
|
int screenCharactersWidthToUse = 80;
|
|
int characterWidthToUse = 8;
|
|
|
|
if(this["screenCharactersWidth"] != null && this["characterWidth"] != null)
|
|
{
|
|
screenCharactersWidthToUse = Convert.ToInt32(this["screenCharactersWidth"]);
|
|
characterWidthToUse = Convert.ToInt32(this["characterWidth"]);
|
|
}
|
|
else if(this["screenCharactersWidth"] != null)
|
|
{
|
|
screenCharactersWidthToUse = Convert.ToInt32(this["screenCharactersWidth"]);
|
|
characterWidthToUse = Convert.ToInt32(this["defaultCharacterWidth"]);
|
|
}
|
|
else if(this["characterWidth"] != null)
|
|
{
|
|
screenCharactersWidthToUse = Convert.ToInt32(this["defaultScreenCharactersWidth"]);
|
|
characterWidthToUse = Convert.ToInt32(this["characterWidth"]);
|
|
}
|
|
else if(this["defaultScreenPixelsWidth"] != null)
|
|
{
|
|
screenCharactersWidthToUse = Convert.ToInt32(this["defaultScreenPixelsWidth"]);
|
|
characterWidthToUse = 1;
|
|
}
|
|
|
|
_screenPixelsWidth = screenCharactersWidthToUse * characterWidthToUse;
|
|
}
|
|
else
|
|
{
|
|
_screenPixelsWidth = Convert.ToInt32(this["screenPixelsWidth"]);
|
|
}
|
|
_haveScreenPixelsWidth = true;
|
|
}
|
|
return _screenPixelsWidth;
|
|
}
|
|
}
|
|
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.ScreenPixelsHeight"]/*' />
|
|
public virtual int ScreenPixelsHeight
|
|
{
|
|
get
|
|
{
|
|
if(!_haveScreenPixelsHeight)
|
|
{
|
|
if(this["screenPixelsHeight"] == null)
|
|
{
|
|
int screenCharactersHeightToUse = 480 / 12;
|
|
int characterHeightToUse = 12;
|
|
|
|
if(this["screenCharactersHeight"] != null && this["characterHeight"] != null)
|
|
{
|
|
screenCharactersHeightToUse = Convert.ToInt32(this["screenCharactersHeight"]);
|
|
characterHeightToUse = Convert.ToInt32(this["characterHeight"]);
|
|
}
|
|
else if(this["screenCharactersHeight"] != null)
|
|
{
|
|
screenCharactersHeightToUse = Convert.ToInt32(this["screenCharactersHeight"]);
|
|
characterHeightToUse = Convert.ToInt32(this["defaultCharacterHeight"]);
|
|
}
|
|
else if(this["characterHeight"] != null)
|
|
{
|
|
screenCharactersHeightToUse = Convert.ToInt32(this["defaultScreenCharactersHeight"]);
|
|
characterHeightToUse = Convert.ToInt32(this["characterHeight"]);
|
|
}
|
|
else if(this["defaultScreenPixelsHeight"] != null)
|
|
{
|
|
screenCharactersHeightToUse = Convert.ToInt32(this["defaultScreenPixelsHeight"]);
|
|
characterHeightToUse = 1;
|
|
}
|
|
|
|
_screenPixelsHeight = screenCharactersHeightToUse * characterHeightToUse;
|
|
}
|
|
else
|
|
{
|
|
_screenPixelsHeight = Convert.ToInt32(this["screenPixelsHeight"]);
|
|
}
|
|
_haveScreenPixelsHeight = true;
|
|
}
|
|
return _screenPixelsHeight;
|
|
}
|
|
}
|
|
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.ScreenBitDepth"]/*' />
|
|
public virtual int ScreenBitDepth
|
|
{
|
|
get
|
|
{
|
|
if(!_haveScreenBitDepth)
|
|
{
|
|
_screenBitDepth = Convert.ToInt32(this["screenBitDepth"]);
|
|
_haveScreenBitDepth = true;
|
|
}
|
|
return _screenBitDepth;
|
|
}
|
|
}
|
|
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.IsColor"]/*' />
|
|
public virtual bool IsColor
|
|
{
|
|
get
|
|
{
|
|
if(!_haveIsColor)
|
|
{
|
|
String isColorString = this["isColor"];
|
|
if(isColorString == null)
|
|
{
|
|
_isColor = false;
|
|
}
|
|
else
|
|
{
|
|
_isColor = Convert.ToBoolean(this["isColor"]);
|
|
}
|
|
_haveIsColor = true;
|
|
}
|
|
return _isColor;
|
|
}
|
|
}
|
|
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.InputType"]/*' />
|
|
public virtual String InputType
|
|
{
|
|
get
|
|
{
|
|
if(!_haveInputType)
|
|
{
|
|
_inputType = this["inputType"];
|
|
_haveInputType = true;
|
|
}
|
|
return _inputType;
|
|
}
|
|
}
|
|
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.NumberOfSoftkeys"]/*' />
|
|
public virtual int NumberOfSoftkeys
|
|
{
|
|
get
|
|
{
|
|
if(!_haveNumberOfSoftkeys)
|
|
{
|
|
_numberOfSoftkeys = Convert.ToInt32(this["numberOfSoftkeys"]);
|
|
_haveNumberOfSoftkeys = true;
|
|
}
|
|
return _numberOfSoftkeys;
|
|
}
|
|
}
|
|
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.MaximumSoftkeyLabelLength"]/*' />
|
|
public virtual int MaximumSoftkeyLabelLength
|
|
{
|
|
get
|
|
{
|
|
if(!_haveMaximumSoftkeyLabelLength)
|
|
{
|
|
_maximumSoftkeyLabelLength = Convert.ToInt32(this["maximumSoftkeyLabelLength"]);
|
|
_haveMaximumSoftkeyLabelLength = true;
|
|
}
|
|
return _maximumSoftkeyLabelLength;
|
|
}
|
|
}
|
|
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.CanInitiateVoiceCall"]/*' />
|
|
public virtual bool CanInitiateVoiceCall
|
|
{
|
|
get
|
|
{
|
|
if(!_haveCanInitiateVoiceCall)
|
|
{
|
|
String canInitiateVoiceCallString = this["canInitiateVoiceCall"];
|
|
if(canInitiateVoiceCallString == null)
|
|
{
|
|
_canInitiateVoiceCall = false;
|
|
}
|
|
else
|
|
{
|
|
_canInitiateVoiceCall = Convert.ToBoolean(canInitiateVoiceCallString);
|
|
}
|
|
_haveCanInitiateVoiceCall = true;
|
|
}
|
|
return _canInitiateVoiceCall;
|
|
}
|
|
}
|
|
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.CanSendMail"]/*' />
|
|
public virtual bool CanSendMail
|
|
{
|
|
get
|
|
{
|
|
if(!_haveCanSendMail)
|
|
{
|
|
String canSendMailString = this["canSendMail"];
|
|
if(canSendMailString == null)
|
|
{
|
|
_canSendMail = true;
|
|
}
|
|
else
|
|
{
|
|
_canSendMail = Convert.ToBoolean(canSendMailString);
|
|
}
|
|
_haveCanSendMail = true;
|
|
}
|
|
return _canSendMail;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.HasBackButton"]/*' />
|
|
public virtual bool HasBackButton
|
|
{
|
|
get
|
|
{
|
|
if(!_haveHasBackButton)
|
|
{
|
|
String hasBackButtonString = this["hasBackButton"];
|
|
if(hasBackButtonString == null)
|
|
{
|
|
_hasBackButton = true;
|
|
}
|
|
else
|
|
{
|
|
_hasBackButton = Convert.ToBoolean(hasBackButtonString);
|
|
}
|
|
_haveHasBackButton = true;
|
|
}
|
|
return _hasBackButton;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.RendersWmlDoAcceptsInline"]/*' />
|
|
public virtual bool RendersWmlDoAcceptsInline
|
|
{
|
|
get
|
|
{
|
|
if(!_haveRendersWmlDoAcceptsInline)
|
|
{
|
|
String rendersWmlDoAcceptsInlineString = this["rendersWmlDoAcceptsInline"];
|
|
if(rendersWmlDoAcceptsInlineString == null)
|
|
{
|
|
_rendersWmlDoAcceptsInline = true;
|
|
}
|
|
else
|
|
{
|
|
_rendersWmlDoAcceptsInline = Convert.ToBoolean(rendersWmlDoAcceptsInlineString);
|
|
}
|
|
_haveRendersWmlDoAcceptsInline = true;
|
|
}
|
|
return _rendersWmlDoAcceptsInline;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.RendersWmlSelectsAsMenuCards"]/*' />
|
|
public virtual bool RendersWmlSelectsAsMenuCards
|
|
{
|
|
get
|
|
{
|
|
if(!_haveRendersWmlSelectsAsMenuCards)
|
|
{
|
|
String rendersWmlSelectsAsMenuCardsString = this["rendersWmlSelectsAsMenuCards"];
|
|
if(rendersWmlSelectsAsMenuCardsString == null)
|
|
{
|
|
_rendersWmlSelectsAsMenuCards = false;
|
|
}
|
|
else
|
|
{
|
|
_rendersWmlSelectsAsMenuCards = Convert.ToBoolean(rendersWmlSelectsAsMenuCardsString);
|
|
}
|
|
_haveRendersWmlSelectsAsMenuCards = true;
|
|
}
|
|
return _rendersWmlSelectsAsMenuCards;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.RendersBreaksAfterWmlAnchor"]/*' />
|
|
public virtual bool RendersBreaksAfterWmlAnchor
|
|
{
|
|
get
|
|
{
|
|
if(!_haveRendersBreaksAfterWmlAnchor)
|
|
{
|
|
String rendersBreaksAfterWmlAnchorString = this["rendersBreaksAfterWmlAnchor"];
|
|
if(rendersBreaksAfterWmlAnchorString == null)
|
|
{
|
|
_rendersBreaksAfterWmlAnchor = true;
|
|
}
|
|
else
|
|
{
|
|
_rendersBreaksAfterWmlAnchor = Convert.ToBoolean(rendersBreaksAfterWmlAnchorString);
|
|
}
|
|
_haveRendersBreaksAfterWmlAnchor = true;
|
|
}
|
|
return _rendersBreaksAfterWmlAnchor;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.RendersBreaksAfterWmlInput"]/*' />
|
|
public virtual bool RendersBreaksAfterWmlInput
|
|
{
|
|
get
|
|
{
|
|
if(!_haveRendersBreaksAfterWmlInput)
|
|
{
|
|
String rendersBreaksAfterWmlInputString = this["rendersBreaksAfterWmlInput"];
|
|
if(rendersBreaksAfterWmlInputString == null)
|
|
{
|
|
_rendersBreaksAfterWmlInput = true;
|
|
}
|
|
else
|
|
{
|
|
_rendersBreaksAfterWmlInput = Convert.ToBoolean(rendersBreaksAfterWmlInputString);
|
|
}
|
|
_haveRendersBreaksAfterWmlInput = true;
|
|
}
|
|
return _rendersBreaksAfterWmlInput;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.RendersBreakBeforeWmlSelectAndInput"]/*' />
|
|
public virtual bool RendersBreakBeforeWmlSelectAndInput
|
|
{
|
|
get
|
|
{
|
|
if(!_haveRendersBreakBeforeWmlSelectAndInput)
|
|
{
|
|
String rendersBreaksBeforeWmlSelectAndInputString = this["rendersBreakBeforeWmlSelectAndInput"];
|
|
if(rendersBreaksBeforeWmlSelectAndInputString == null)
|
|
{
|
|
_rendersBreakBeforeWmlSelectAndInput = false;
|
|
}
|
|
else
|
|
{
|
|
_rendersBreakBeforeWmlSelectAndInput = Convert.ToBoolean(rendersBreaksBeforeWmlSelectAndInputString);
|
|
}
|
|
_haveRendersBreakBeforeWmlSelectAndInput = true;
|
|
}
|
|
return _rendersBreakBeforeWmlSelectAndInput;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.RequiresPhoneNumbersAsPlainText"]/*' />
|
|
public virtual bool RequiresPhoneNumbersAsPlainText
|
|
{
|
|
get
|
|
{
|
|
if(!_haveRequiresPhoneNumbersAsPlainText)
|
|
{
|
|
String requiresPhoneNumbersAsPlainTextString = this["requiresPhoneNumbersAsPlainText"];
|
|
if(requiresPhoneNumbersAsPlainTextString == null)
|
|
{
|
|
_requiresPhoneNumbersAsPlainText = false;
|
|
}
|
|
else
|
|
{
|
|
_requiresPhoneNumbersAsPlainText = Convert.ToBoolean(requiresPhoneNumbersAsPlainTextString);
|
|
}
|
|
_haveRequiresPhoneNumbersAsPlainText = true;
|
|
}
|
|
return _requiresPhoneNumbersAsPlainText;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.RequiresUrlEncodedPostfieldValues"]/*' />
|
|
public virtual bool RequiresUrlEncodedPostfieldValues
|
|
{
|
|
get
|
|
{
|
|
if(!_haveRequiresUrlEncodedPostfieldValues)
|
|
{
|
|
String requiresUrlEncodedPostfieldValuesString = this["requiresUrlEncodedPostfieldValues"];
|
|
if(requiresUrlEncodedPostfieldValuesString == null)
|
|
{
|
|
_requiresUrlEncodedPostfieldValues = true;
|
|
}
|
|
else
|
|
{
|
|
_requiresUrlEncodedPostfieldValues = Convert.ToBoolean(requiresUrlEncodedPostfieldValuesString);
|
|
}
|
|
_haveRequiresUrlEncodedPostfieldValues = true;
|
|
}
|
|
return _requiresUrlEncodedPostfieldValues;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.RequiredMetaTagNameValue"]/*' />
|
|
public virtual String RequiredMetaTagNameValue
|
|
{
|
|
get
|
|
{
|
|
if(!_haveRequiredMetaTagNameValue)
|
|
{
|
|
String value = this["requiredMetaTagNameValue"];
|
|
if(value == null || value == String.Empty)
|
|
{
|
|
_requiredMetaTagNameValue = null;
|
|
}
|
|
else
|
|
{
|
|
_requiredMetaTagNameValue = value;
|
|
}
|
|
_haveRequiredMetaTagNameValue = true;
|
|
}
|
|
return _requiredMetaTagNameValue;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.RendersBreaksAfterHtmlLists"]/*' />
|
|
public virtual bool RendersBreaksAfterHtmlLists
|
|
{
|
|
get
|
|
{
|
|
if(!_haveRendersBreaksAfterHtmlLists)
|
|
{
|
|
String rendersBreaksAfterHtmlListsString = this["rendersBreaksAfterHtmlLists"];
|
|
if(rendersBreaksAfterHtmlListsString == null)
|
|
{
|
|
_rendersBreaksAfterHtmlLists = true;
|
|
}
|
|
else
|
|
{
|
|
_rendersBreaksAfterHtmlLists = Convert.ToBoolean(rendersBreaksAfterHtmlListsString);
|
|
}
|
|
_haveRendersBreaksAfterHtmlLists = true;
|
|
}
|
|
return _rendersBreaksAfterHtmlLists;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.RequiresUniqueHtmlInputNames"]/*' />
|
|
public virtual bool RequiresUniqueHtmlInputNames
|
|
{
|
|
get
|
|
{
|
|
if(!_haveRequiresUniqueHtmlInputNames)
|
|
{
|
|
String requiresUniqueHtmlInputNamesString = this["requiresUniqueHtmlInputNames"];
|
|
if(requiresUniqueHtmlInputNamesString == null)
|
|
{
|
|
_requiresUniqueHtmlInputNames = false;
|
|
}
|
|
else
|
|
{
|
|
_requiresUniqueHtmlInputNames = Convert.ToBoolean(requiresUniqueHtmlInputNamesString);
|
|
}
|
|
_haveRequiresUniqueHtmlInputNames = true;
|
|
}
|
|
return _requiresUniqueHtmlInputNames;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.RequiresUniqueHtmlCheckboxNames"]/*' />
|
|
public virtual bool RequiresUniqueHtmlCheckboxNames
|
|
{
|
|
get
|
|
{
|
|
if(!_haveRequiresUniqueHtmlCheckboxNames)
|
|
{
|
|
String requiresUniqueHtmlCheckboxNamesString = this["requiresUniqueHtmlCheckboxNames"];
|
|
if(requiresUniqueHtmlCheckboxNamesString == null)
|
|
{
|
|
_requiresUniqueHtmlCheckboxNames = false;
|
|
}
|
|
else
|
|
{
|
|
_requiresUniqueHtmlCheckboxNames = Convert.ToBoolean(requiresUniqueHtmlCheckboxNamesString);
|
|
}
|
|
_haveRequiresUniqueHtmlCheckboxNames = true;
|
|
}
|
|
return _requiresUniqueHtmlCheckboxNames;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.SupportsCss"]/*' />
|
|
public virtual bool SupportsCss
|
|
{
|
|
get
|
|
{
|
|
if(!_haveSupportsCss)
|
|
{
|
|
String supportsCssString = this["supportsCss"];
|
|
if(supportsCssString == null)
|
|
{
|
|
_supportsCss = false;
|
|
}
|
|
else
|
|
{
|
|
_supportsCss = Convert.ToBoolean(supportsCssString);
|
|
}
|
|
_haveSupportsCss = true;
|
|
}
|
|
return _supportsCss;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.HidesRightAlignedMultiselectScrollbars"]/*' />
|
|
public virtual bool HidesRightAlignedMultiselectScrollbars
|
|
{
|
|
get
|
|
{
|
|
if(!_haveHidesRightAlignedMultiselectScrollbars)
|
|
{
|
|
String hidesRightAlignedMultiselectScrollbarsString = this["hidesRightAlignedMultiselectScrollbars"];
|
|
if(hidesRightAlignedMultiselectScrollbarsString == null)
|
|
{
|
|
_hidesRightAlignedMultiselectScrollbars = false;
|
|
}
|
|
else
|
|
{
|
|
_hidesRightAlignedMultiselectScrollbars = Convert.ToBoolean(hidesRightAlignedMultiselectScrollbarsString);
|
|
}
|
|
_haveHidesRightAlignedMultiselectScrollbars = true;
|
|
}
|
|
return _hidesRightAlignedMultiselectScrollbars;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.IsMobileDevice"]/*' />
|
|
public virtual bool IsMobileDevice
|
|
{
|
|
get
|
|
{
|
|
if(!_haveIsMobileDevice)
|
|
{
|
|
String isMobileDeviceString = this["isMobileDevice"];
|
|
if(isMobileDeviceString == null)
|
|
{
|
|
_isMobileDevice = false;
|
|
}
|
|
else
|
|
{
|
|
_isMobileDevice = Convert.ToBoolean(isMobileDeviceString);
|
|
}
|
|
_haveIsMobileDevice = true;
|
|
}
|
|
return _isMobileDevice;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.RequiresAttributeColonSubstitution"]/*' />
|
|
public virtual bool RequiresAttributeColonSubstitution
|
|
{
|
|
get
|
|
{
|
|
if(!_haveRequiresAttributeColonSubstitution)
|
|
{
|
|
String requiresAttributeColonSubstitution = this["requiresAttributeColonSubstitution"];
|
|
if(requiresAttributeColonSubstitution == null)
|
|
{
|
|
_requiresAttributeColonSubstitution = false;
|
|
}
|
|
else
|
|
{
|
|
_requiresAttributeColonSubstitution = Convert.ToBoolean(requiresAttributeColonSubstitution);
|
|
}
|
|
_haveRequiresAttributeColonSubstitution = true;
|
|
}
|
|
return _requiresAttributeColonSubstitution;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.CanRenderOneventAndPrevElementsTogether"]/*' />
|
|
public virtual bool CanRenderOneventAndPrevElementsTogether
|
|
{
|
|
get
|
|
{
|
|
if(!_haveCanRenderOneventAndPrevElementsTogether)
|
|
{
|
|
String canRenderOneventAndPrevElementsTogetherString = this["canRenderOneventAndPrevElementsTogether"];
|
|
if(canRenderOneventAndPrevElementsTogetherString == null)
|
|
{
|
|
_canRenderOneventAndPrevElementsTogether = true;
|
|
}
|
|
else
|
|
{
|
|
_canRenderOneventAndPrevElementsTogether = Convert.ToBoolean(canRenderOneventAndPrevElementsTogetherString);
|
|
}
|
|
_haveCanRenderOneventAndPrevElementsTogether = true;
|
|
}
|
|
return _canRenderOneventAndPrevElementsTogether;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.CanRenderInputAndSelectElementsTogether"]/*' />
|
|
public virtual bool CanRenderInputAndSelectElementsTogether
|
|
{
|
|
get
|
|
{
|
|
if(!_haveCanRenderInputAndSelectElementsTogether)
|
|
{
|
|
String canRenderInputAndSelectElementsTogetherString = this["canRenderInputAndSelectElementsTogether"];
|
|
if(canRenderInputAndSelectElementsTogetherString == null)
|
|
{
|
|
_canRenderInputAndSelectElementsTogether = true;
|
|
}
|
|
else
|
|
{
|
|
_canRenderInputAndSelectElementsTogether = Convert.ToBoolean(canRenderInputAndSelectElementsTogetherString);
|
|
}
|
|
_haveCanRenderInputAndSelectElementsTogether = true;
|
|
}
|
|
return _canRenderInputAndSelectElementsTogether;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.CanRenderAfterInputOrSelectElement"]/*' />
|
|
public virtual bool CanRenderAfterInputOrSelectElement
|
|
{
|
|
get
|
|
{
|
|
if(!_haveCanRenderAfterInputOrSelectElement)
|
|
{
|
|
String canRenderAfterInputOrSelectElementString = this["canRenderAfterInputOrSelectElement"];
|
|
if(canRenderAfterInputOrSelectElementString == null)
|
|
{
|
|
_canRenderAfterInputOrSelectElement = true;
|
|
}
|
|
else
|
|
{
|
|
_canRenderAfterInputOrSelectElement = Convert.ToBoolean(canRenderAfterInputOrSelectElementString);
|
|
}
|
|
_haveCanRenderAfterInputOrSelectElement = true;
|
|
}
|
|
return _canRenderAfterInputOrSelectElement;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.CanRenderPostBackCards"]/*' />
|
|
public virtual bool CanRenderPostBackCards
|
|
{
|
|
get
|
|
{
|
|
if(!_haveCanRenderPostBackCards)
|
|
{
|
|
String canRenderPostBackCardsString = this["canRenderPostBackCards"];
|
|
if(canRenderPostBackCardsString == null)
|
|
{
|
|
_canRenderPostBackCards = true;
|
|
}
|
|
else
|
|
{
|
|
_canRenderPostBackCards = Convert.ToBoolean(canRenderPostBackCardsString);
|
|
}
|
|
_haveCanRenderPostBackCards = true;
|
|
}
|
|
return _canRenderPostBackCards;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.CanRenderMixedSelects"]/*' />
|
|
public virtual bool CanRenderMixedSelects
|
|
{
|
|
get
|
|
{
|
|
if(!_haveCanRenderMixedSelects)
|
|
{
|
|
String canRenderMixedSelectsString = this["canRenderMixedSelects"];
|
|
if(canRenderMixedSelectsString == null)
|
|
{
|
|
_canRenderMixedSelects = true;
|
|
}
|
|
else
|
|
{
|
|
_canRenderMixedSelects = Convert.ToBoolean(canRenderMixedSelectsString);
|
|
}
|
|
_haveCanRenderMixedSelects = true;
|
|
}
|
|
return _canRenderMixedSelects;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.CanCombineFormsInDeck"]/*' />
|
|
public virtual bool CanCombineFormsInDeck
|
|
{
|
|
get
|
|
{
|
|
if(!_haveCanCombineFormsInDeck)
|
|
{
|
|
String canCombineFormsInDeckString = this["canCombineFormsInDeck"];
|
|
if(canCombineFormsInDeckString == null)
|
|
{
|
|
_canCombineFormsInDeck = true;
|
|
}
|
|
else
|
|
{
|
|
_canCombineFormsInDeck = Convert.ToBoolean(canCombineFormsInDeckString);
|
|
}
|
|
_haveCanCombineFormsInDeck = true;
|
|
}
|
|
return _canCombineFormsInDeck;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.CanRenderSetvarZeroWithMultiSelectionList"]/*' />
|
|
public virtual bool CanRenderSetvarZeroWithMultiSelectionList
|
|
{
|
|
get
|
|
{
|
|
if(!_haveCanRenderSetvarZeroWithMultiSelectionList)
|
|
{
|
|
String canRenderSetvarZeroWithMultiSelectionListString = this["canRenderSetvarZeroWithMultiSelectionList"];
|
|
if(canRenderSetvarZeroWithMultiSelectionListString == null)
|
|
{
|
|
_canRenderSetvarZeroWithMultiSelectionList = true;
|
|
}
|
|
else
|
|
{
|
|
_canRenderSetvarZeroWithMultiSelectionList = Convert.ToBoolean(canRenderSetvarZeroWithMultiSelectionListString);
|
|
}
|
|
_haveCanRenderSetvarZeroWithMultiSelectionList = true;
|
|
}
|
|
return _canRenderSetvarZeroWithMultiSelectionList;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.SupportsImageSubmit"]/*' />
|
|
public virtual bool SupportsImageSubmit
|
|
{
|
|
get
|
|
{
|
|
if(!_haveSupportsImageSubmit)
|
|
{
|
|
String supportsImageSubmitString = this["supportsImageSubmit"];
|
|
if(supportsImageSubmitString == null)
|
|
{
|
|
_supportsImageSubmit = false;
|
|
}
|
|
else
|
|
{
|
|
_supportsImageSubmit = Convert.ToBoolean(supportsImageSubmitString);
|
|
}
|
|
_haveSupportsImageSubmit = true;
|
|
}
|
|
return _supportsImageSubmit;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.RequiresUniqueFilePathSuffix"]/*' />
|
|
public virtual bool RequiresUniqueFilePathSuffix
|
|
{
|
|
get
|
|
{
|
|
if(!_haveRequiresUniqueFilePathSuffix)
|
|
{
|
|
String requiresUniqueFilePathSuffixString = this["requiresUniqueFilePathSuffix"];
|
|
if(requiresUniqueFilePathSuffixString == null)
|
|
{
|
|
_requiresUniqueFilePathSuffix = false;
|
|
}
|
|
else
|
|
{
|
|
_requiresUniqueFilePathSuffix = Convert.ToBoolean(requiresUniqueFilePathSuffixString);
|
|
}
|
|
_haveRequiresUniqueFilePathSuffix = true;
|
|
}
|
|
return _requiresUniqueFilePathSuffix;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.RequiresNoBreakInFormatting"]/*' />
|
|
public virtual bool RequiresNoBreakInFormatting
|
|
{
|
|
get
|
|
{
|
|
if(!_haveRequiresNoBreakInFormatting)
|
|
{
|
|
String requiresNoBreakInFormatting = this["requiresNoBreakInFormatting"];
|
|
if(requiresNoBreakInFormatting == null)
|
|
{
|
|
_requiresNoBreakInFormatting = false;
|
|
}
|
|
else
|
|
{
|
|
_requiresNoBreakInFormatting = Convert.ToBoolean(requiresNoBreakInFormatting);
|
|
}
|
|
_haveRequiresNoBreakInFormatting = true;
|
|
}
|
|
return _requiresNoBreakInFormatting;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.RequiresLeadingPageBreak"]/*' />
|
|
public virtual bool RequiresLeadingPageBreak
|
|
{
|
|
get
|
|
{
|
|
if(!_haveRequiresLeadingPageBreak)
|
|
{
|
|
String requiresLeadingPageBreak = this["requiresLeadingPageBreak"];
|
|
if(requiresLeadingPageBreak == null)
|
|
{
|
|
_requiresLeadingPageBreak = false;
|
|
}
|
|
else
|
|
{
|
|
_requiresLeadingPageBreak = Convert.ToBoolean(requiresLeadingPageBreak);
|
|
}
|
|
_haveRequiresLeadingPageBreak = true;
|
|
}
|
|
return _requiresLeadingPageBreak;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.SupportsSelectMultiple"]/*' />
|
|
public virtual bool SupportsSelectMultiple
|
|
{
|
|
get
|
|
{
|
|
if(!_haveSupportsSelectMultiple)
|
|
{
|
|
String supportsSelectMultipleString = this["supportsSelectMultiple"];
|
|
if(supportsSelectMultipleString == null)
|
|
{
|
|
_supportsSelectMultiple = false;
|
|
}
|
|
else
|
|
{
|
|
_supportsSelectMultiple = Convert.ToBoolean(supportsSelectMultipleString);
|
|
}
|
|
_haveSupportsSelectMultiple = true;
|
|
}
|
|
return _supportsSelectMultiple;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.SupportsBold"]/*' />
|
|
public new virtual bool SupportsBold
|
|
{
|
|
get
|
|
{
|
|
if(!_haveSupportsBold)
|
|
{
|
|
String supportsBold = this["supportsBold"];
|
|
if(supportsBold == null)
|
|
{
|
|
_supportsBold = false;
|
|
}
|
|
else
|
|
{
|
|
_supportsBold = Convert.ToBoolean(supportsBold);
|
|
}
|
|
_haveSupportsBold = true;
|
|
}
|
|
return _supportsBold;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.SupportsItalic"]/*' />
|
|
public new virtual bool SupportsItalic
|
|
{
|
|
get
|
|
{
|
|
if(!_haveSupportsItalic)
|
|
{
|
|
String supportsItalic = this["supportsItalic"];
|
|
if(supportsItalic == null)
|
|
{
|
|
_supportsItalic = false;
|
|
}
|
|
else
|
|
{
|
|
_supportsItalic = Convert.ToBoolean(supportsItalic);
|
|
}
|
|
_haveSupportsItalic = true;
|
|
}
|
|
return _supportsItalic;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.SupportsFontSize"]/*' />
|
|
public virtual bool SupportsFontSize
|
|
{
|
|
get
|
|
{
|
|
if(!_haveSupportsFontSize)
|
|
{
|
|
String supportsFontSize = this["supportsFontSize"];
|
|
if(supportsFontSize == null)
|
|
{
|
|
_supportsFontSize = false;
|
|
}
|
|
else
|
|
{
|
|
_supportsFontSize = Convert.ToBoolean(supportsFontSize);
|
|
}
|
|
_haveSupportsFontSize = true;
|
|
}
|
|
return _supportsFontSize;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.SupportsFontName"]/*' />
|
|
public virtual bool SupportsFontName
|
|
{
|
|
get
|
|
{
|
|
if(!_haveSupportsFontName)
|
|
{
|
|
String supportsFontName = this["supportsFontName"];
|
|
if(supportsFontName == null)
|
|
{
|
|
_supportsFontName = false;
|
|
}
|
|
else
|
|
{
|
|
_supportsFontName = Convert.ToBoolean(supportsFontName);
|
|
}
|
|
_haveSupportsFontName = true;
|
|
}
|
|
return _supportsFontName;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.SupportsFontColor"]/*' />
|
|
public virtual bool SupportsFontColor
|
|
{
|
|
get
|
|
{
|
|
if(!_haveSupportsFontColor)
|
|
{
|
|
String supportsFontColor = this["supportsFontColor"];
|
|
if(supportsFontColor == null)
|
|
{
|
|
_supportsFontColor = false;
|
|
}
|
|
else
|
|
{
|
|
_supportsFontColor = Convert.ToBoolean(supportsFontColor);
|
|
}
|
|
_haveSupportsFontColor = true;
|
|
}
|
|
return _supportsFontColor;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.SupportsBodyColor"]/*' />
|
|
public virtual bool SupportsBodyColor
|
|
{
|
|
get
|
|
{
|
|
if(!_haveSupportsBodyColor)
|
|
{
|
|
String supportsBodyColor = this["supportsBodyColor"];
|
|
if(supportsBodyColor == null)
|
|
{
|
|
_supportsBodyColor = false;
|
|
}
|
|
else
|
|
{
|
|
_supportsBodyColor = Convert.ToBoolean(supportsBodyColor);
|
|
}
|
|
_haveSupportsBodyColor = true;
|
|
}
|
|
return _supportsBodyColor;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.SupportsDivAlign"]/*' />
|
|
public virtual bool SupportsDivAlign
|
|
{
|
|
get
|
|
{
|
|
if(!_haveSupportsDivAlign)
|
|
{
|
|
String supportsDivAlign = this["supportsDivAlign"];
|
|
if(supportsDivAlign == null)
|
|
{
|
|
_supportsDivAlign = false;
|
|
}
|
|
else
|
|
{
|
|
_supportsDivAlign = Convert.ToBoolean(supportsDivAlign);
|
|
}
|
|
_haveSupportsDivAlign = true;
|
|
}
|
|
return _supportsDivAlign;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.SupportsDivNoWrap"]/*' />
|
|
public virtual bool SupportsDivNoWrap
|
|
{
|
|
get
|
|
{
|
|
if(!_haveSupportsDivNoWrap)
|
|
{
|
|
String supportsDivNoWrap = this["supportsDivNoWrap"];
|
|
if(supportsDivNoWrap == null)
|
|
{
|
|
_supportsDivNoWrap = false;
|
|
}
|
|
else
|
|
{
|
|
_supportsDivNoWrap = Convert.ToBoolean(supportsDivNoWrap);
|
|
}
|
|
_haveSupportsDivNoWrap = true;
|
|
}
|
|
return _supportsDivNoWrap;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.RequiresContentTypeMetaTag"]/*' />
|
|
public virtual bool RequiresContentTypeMetaTag
|
|
{
|
|
get
|
|
{
|
|
if(!_haveRequiresContentTypeMetaTag)
|
|
{
|
|
String requiresContentTypeMetaTag = this["requiresContentTypeMetaTag"];
|
|
if(requiresContentTypeMetaTag == null)
|
|
{
|
|
_requiresContentTypeMetaTag = false;
|
|
}
|
|
else
|
|
{
|
|
_requiresContentTypeMetaTag =
|
|
Convert.ToBoolean(requiresContentTypeMetaTag);
|
|
}
|
|
_haveRequiresContentTypeMetaTag = true;
|
|
}
|
|
return _requiresContentTypeMetaTag;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.RequiresDBCSCharacter"]/*' />
|
|
public virtual bool RequiresDBCSCharacter
|
|
{
|
|
get
|
|
{
|
|
if(!_haveRequiresDBCSCharacter)
|
|
{
|
|
String requiresDBCSCharacter = this["requiresDBCSCharacter"];
|
|
if(requiresDBCSCharacter == null)
|
|
{
|
|
_requiresDBCSCharacter = false;
|
|
}
|
|
else
|
|
{
|
|
_requiresDBCSCharacter =
|
|
Convert.ToBoolean(requiresDBCSCharacter);
|
|
}
|
|
_haveRequiresDBCSCharacter = true;
|
|
}
|
|
return _requiresDBCSCharacter;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.RequiresHtmlAdaptiveErrorReporting"]/*' />
|
|
public virtual bool RequiresHtmlAdaptiveErrorReporting
|
|
{
|
|
get
|
|
{
|
|
if(!_haveRequiresHtmlAdaptiveErrorReporting)
|
|
{
|
|
String requiresHtmlAdaptiveErrorReporting = this["requiresHtmlAdaptiveErrorReporting"];
|
|
if(requiresHtmlAdaptiveErrorReporting == null)
|
|
{
|
|
_requiresHtmlAdaptiveErrorReporting = false;
|
|
}
|
|
else
|
|
{
|
|
_requiresHtmlAdaptiveErrorReporting =
|
|
Convert.ToBoolean(requiresHtmlAdaptiveErrorReporting);
|
|
}
|
|
_haveRequiresHtmlAdaptiveErrorReporting = true;
|
|
}
|
|
return _requiresHtmlAdaptiveErrorReporting;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.RequiresOutputOptimization"]/*' />
|
|
public virtual bool RequiresOutputOptimization
|
|
{
|
|
get
|
|
{
|
|
if(!_haveRequiresOutputOptimization)
|
|
{
|
|
String RequiresOutputOptimizationString = this["requiresOutputOptimization"];
|
|
if(RequiresOutputOptimizationString == null)
|
|
{
|
|
_requiresOutputOptimization = false;
|
|
}
|
|
else
|
|
{
|
|
_requiresOutputOptimization = Convert.ToBoolean(RequiresOutputOptimizationString);
|
|
}
|
|
_haveRequiresOutputOptimization = true;
|
|
}
|
|
return _requiresOutputOptimization;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.SupportsAccesskeyAttribute"]/*' />
|
|
public virtual bool SupportsAccesskeyAttribute
|
|
{
|
|
get
|
|
{
|
|
if(!_haveSupportsAccesskeyAttribute)
|
|
{
|
|
String SupportsAccesskeyAttributeString = this["supportsAccesskeyAttribute"];
|
|
if(SupportsAccesskeyAttributeString == null)
|
|
{
|
|
_supportsAccesskeyAttribute = false;
|
|
}
|
|
else
|
|
{
|
|
_supportsAccesskeyAttribute = Convert.ToBoolean(SupportsAccesskeyAttributeString);
|
|
}
|
|
_haveSupportsAccesskeyAttribute = true;
|
|
}
|
|
return _supportsAccesskeyAttribute;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.SupportsInputIStyle"]/*' />
|
|
public virtual bool SupportsInputIStyle
|
|
{
|
|
get
|
|
{
|
|
if(!_haveSupportsInputIStyle)
|
|
{
|
|
String SupportsInputIStyleString = this["supportsInputIStyle"];
|
|
if(SupportsInputIStyleString == null)
|
|
{
|
|
_supportsInputIStyle = false;
|
|
}
|
|
else
|
|
{
|
|
_supportsInputIStyle = Convert.ToBoolean(SupportsInputIStyleString);
|
|
}
|
|
_haveSupportsInputIStyle = true;
|
|
}
|
|
return _supportsInputIStyle;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.SupportsInputMode"]/*' />
|
|
public virtual bool SupportsInputMode
|
|
{
|
|
get
|
|
{
|
|
if(!_haveSupportsInputMode)
|
|
{
|
|
String SupportsInputModeString = this["supportsInputMode"];
|
|
if(SupportsInputModeString == null)
|
|
{
|
|
_supportsInputMode = false;
|
|
}
|
|
else
|
|
{
|
|
_supportsInputMode = Convert.ToBoolean(SupportsInputModeString);
|
|
}
|
|
_haveSupportsInputMode = true;
|
|
}
|
|
return _supportsInputMode;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.SupportsIModeSymbols"]/*' />
|
|
public virtual bool SupportsIModeSymbols
|
|
{
|
|
get
|
|
{
|
|
if(!_haveSupportsIModeSymbols)
|
|
{
|
|
String SupportsIModeSymbolsString = this["supportsIModeSymbols"];
|
|
if(SupportsIModeSymbolsString == null)
|
|
{
|
|
_supportsIModeSymbols = false;
|
|
}
|
|
else
|
|
{
|
|
_supportsIModeSymbols = Convert.ToBoolean(SupportsIModeSymbolsString);
|
|
}
|
|
_haveSupportsIModeSymbols = true;
|
|
}
|
|
return _supportsIModeSymbols;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.SupportsJPhoneSymbols"]/*' />
|
|
public virtual bool SupportsJPhoneSymbols
|
|
{
|
|
get
|
|
{
|
|
if(!_haveSupportsJPhoneSymbols)
|
|
{
|
|
String SupportsJPhoneSymbolsString = this["supportsJPhoneSymbols"];
|
|
if(SupportsJPhoneSymbolsString == null)
|
|
{
|
|
_supportsJPhoneSymbols = false;
|
|
}
|
|
else
|
|
{
|
|
_supportsJPhoneSymbols = Convert.ToBoolean(SupportsJPhoneSymbolsString);
|
|
}
|
|
_haveSupportsJPhoneSymbols = true;
|
|
}
|
|
return _supportsJPhoneSymbols;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.SupportsJPhoneMultiMediaAttributes"]/*' />
|
|
public virtual bool SupportsJPhoneMultiMediaAttributes
|
|
{
|
|
get
|
|
{
|
|
if(!_haveSupportsJPhoneMultiMediaAttributes)
|
|
{
|
|
String SupportsJPhoneMultiMediaAttributesString = this["supportsJPhoneMultiMediaAttributes"];
|
|
if(SupportsJPhoneMultiMediaAttributesString == null)
|
|
{
|
|
_supportsJPhoneMultiMediaAttributes = false;
|
|
}
|
|
else
|
|
{
|
|
_supportsJPhoneMultiMediaAttributes = Convert.ToBoolean(SupportsJPhoneMultiMediaAttributesString);
|
|
}
|
|
_haveSupportsJPhoneMultiMediaAttributes = true;
|
|
}
|
|
return _supportsJPhoneMultiMediaAttributes;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.MaximumRenderedPageSize"]/*' />
|
|
public virtual int MaximumRenderedPageSize
|
|
{
|
|
get
|
|
{
|
|
if(!_haveMaximumRenderedPageSize)
|
|
{
|
|
_maximumRenderedPageSize = Convert.ToInt32(this["maximumRenderedPageSize"]);
|
|
_haveMaximumRenderedPageSize = true;
|
|
}
|
|
return _maximumRenderedPageSize;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.RequiresSpecialViewStateEncoding"]/*' />
|
|
public virtual bool RequiresSpecialViewStateEncoding
|
|
{
|
|
get
|
|
{
|
|
if(!_haveRequiresSpecialViewStateEncoding)
|
|
{
|
|
String RequiresSpecialViewStateEncodingString = this["requiresSpecialViewStateEncoding"];
|
|
if(RequiresSpecialViewStateEncodingString == null)
|
|
{
|
|
_requiresSpecialViewStateEncoding = false;
|
|
}
|
|
else
|
|
{
|
|
_requiresSpecialViewStateEncoding = Convert.ToBoolean(RequiresSpecialViewStateEncodingString);
|
|
}
|
|
_haveRequiresSpecialViewStateEncoding = true;
|
|
}
|
|
return _requiresSpecialViewStateEncoding;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.SupportsQueryStringInFormAction"]/*' />
|
|
public virtual bool SupportsQueryStringInFormAction
|
|
{
|
|
get
|
|
{
|
|
if(!_haveSupportsQueryStringInFormAction)
|
|
{
|
|
String SupportsQueryStringInFormActionString = this["supportsQueryStringInFormAction"];
|
|
if(SupportsQueryStringInFormActionString == null)
|
|
{
|
|
_supportsQueryStringInFormAction = true;
|
|
}
|
|
else
|
|
{
|
|
_supportsQueryStringInFormAction = Convert.ToBoolean(SupportsQueryStringInFormActionString);
|
|
}
|
|
_haveSupportsQueryStringInFormAction = true;
|
|
}
|
|
return _supportsQueryStringInFormAction;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.SupportsCacheControlMetaTag"]/*' />
|
|
public virtual bool SupportsCacheControlMetaTag
|
|
{
|
|
get
|
|
{
|
|
if(!_haveSupportsCacheControlMetaTag)
|
|
{
|
|
String SupportsCacheControlMetaTagString = this["supportsCacheControlMetaTag"];
|
|
if(SupportsCacheControlMetaTagString == null)
|
|
{
|
|
_supportsCacheControlMetaTag = true;
|
|
}
|
|
else
|
|
{
|
|
_supportsCacheControlMetaTag = Convert.ToBoolean(SupportsCacheControlMetaTagString);
|
|
}
|
|
_haveSupportsCacheControlMetaTag = true;
|
|
}
|
|
return _supportsCacheControlMetaTag;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.SupportsUncheck"]/*' />
|
|
public virtual bool SupportsUncheck
|
|
{
|
|
get
|
|
{
|
|
if(!_haveSupportsUncheck)
|
|
{
|
|
String SupportsUncheckString = this["supportsUncheck"];
|
|
if(SupportsUncheckString == null)
|
|
{
|
|
_supportsUncheck = true;
|
|
}
|
|
else
|
|
{
|
|
_supportsUncheck = Convert.ToBoolean(SupportsUncheckString);
|
|
}
|
|
_haveSupportsUncheck = true;
|
|
}
|
|
return _supportsUncheck;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.CanRenderEmptySelects"]/*' />
|
|
public virtual bool CanRenderEmptySelects
|
|
{
|
|
get
|
|
{
|
|
if(!_haveCanRenderEmptySelects)
|
|
{
|
|
String CanRenderEmptySelectsString = this["canRenderEmptySelects"];
|
|
if(CanRenderEmptySelectsString == null)
|
|
{
|
|
_canRenderEmptySelects = true;
|
|
}
|
|
else
|
|
{
|
|
_canRenderEmptySelects = Convert.ToBoolean(CanRenderEmptySelectsString);
|
|
}
|
|
_haveCanRenderEmptySelects = true;
|
|
}
|
|
return _canRenderEmptySelects;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.SupportsRedirectWithCookie"]/*' />
|
|
public virtual bool SupportsRedirectWithCookie
|
|
{
|
|
get
|
|
{
|
|
if(!_haveSupportsRedirectWithCookie)
|
|
{
|
|
String supportsRedirectWithCookie = this["supportsRedirectWithCookie"];
|
|
if(supportsRedirectWithCookie == null)
|
|
{
|
|
_supportsRedirectWithCookie = true;
|
|
}
|
|
else
|
|
{
|
|
_supportsRedirectWithCookie = Convert.ToBoolean(supportsRedirectWithCookie);
|
|
}
|
|
_haveSupportsRedirectWithCookie = true;
|
|
}
|
|
return _supportsRedirectWithCookie;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.SupportsEmptyStringInCookieValue"]/*' />
|
|
public virtual bool SupportsEmptyStringInCookieValue
|
|
{
|
|
get
|
|
{
|
|
if (!_haveSupportsEmptyStringInCookieValue)
|
|
{
|
|
String supportsEmptyStringInCookieValue = this["supportsEmptyStringInCookieValue"];
|
|
if (supportsEmptyStringInCookieValue == null)
|
|
{
|
|
_supportsEmptyStringInCookieValue = true;
|
|
}
|
|
else
|
|
{
|
|
_supportsEmptyStringInCookieValue =
|
|
Convert.ToBoolean (supportsEmptyStringInCookieValue);
|
|
}
|
|
_haveSupportsEmptyStringInCookieValue = true;
|
|
}
|
|
return _supportsEmptyStringInCookieValue;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileCapabilities.uex' path='docs/doc[@for="MobileCapabilities.DefaultSubmitButtonLimit"]/*' />
|
|
public virtual int DefaultSubmitButtonLimit
|
|
{
|
|
get
|
|
{
|
|
if(!_haveDefaultSubmitButtonLimit)
|
|
{
|
|
String s = this["defaultSubmitButtonLimit"];
|
|
_defaultSubmitButtonLimit = s != null ? Convert.ToInt32(this["defaultSubmitButtonLimit"]) : 1;
|
|
_haveDefaultSubmitButtonLimit = true;
|
|
}
|
|
return _defaultSubmitButtonLimit;
|
|
}
|
|
}
|
|
|
|
|
|
private String _mobileDeviceManufacturer;
|
|
private String _mobileDeviceModel;
|
|
private String _gatewayVersion;
|
|
private int _gatewayMajorVersion;
|
|
private double _gatewayMinorVersion;
|
|
private String _preferredRenderingType; //
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
*/
|
|
}
|
|
}
|
|
|