mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
847 lines
29 KiB
C#
847 lines
29 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="Style.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.ComponentModel;
|
|
using System.ComponentModel.Design;
|
|
using System.Drawing;
|
|
using System.Drawing.Design;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.Web;
|
|
using System.Web.UI;
|
|
using System.Web.UI.Design.WebControls;
|
|
using System.Web.UI.HtmlControls;
|
|
using System.Web.UI.WebControls;
|
|
|
|
using WebCtrlStyle = System.Web.UI.WebControls.Style;
|
|
using System.Security.Permissions;
|
|
|
|
namespace System.Web.UI.MobileControls
|
|
{
|
|
|
|
/*
|
|
* Mobile Style class.
|
|
* This class can be used to define external styles that can be referenced by other controls.
|
|
*/
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style"]/*' />
|
|
[
|
|
ControlBuilderAttribute(typeof(MobileControlBuilder)),
|
|
TypeConverterAttribute(typeof(ExpandableObjectConverter))
|
|
]
|
|
[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 Style : IParserAccessor, ITemplateable, IStateManager, ICloneable
|
|
{
|
|
// registers styles and retrieves keys used for storing properties in internal hashtable
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.AlignmentKey"]/*' />
|
|
public static readonly Object
|
|
AlignmentKey = RegisterStyle("Alignment", typeof(Alignment) , System.Web.UI.MobileControls.Alignment.NotSet, true),
|
|
WrappingKey = RegisterStyle("Wrapping" , typeof(Wrapping) , System.Web.UI.MobileControls.Wrapping.NotSet , true),
|
|
BoldKey = RegisterStyle("Bold", typeof(BooleanOption), BooleanOption.NotSet, true),
|
|
ItalicKey = RegisterStyle("Italic", typeof(BooleanOption), BooleanOption.NotSet, true),
|
|
FontSizeKey = RegisterStyle("FontSize" , typeof(FontSize) , System.Web.UI.MobileControls.FontSize.NotSet , true),
|
|
FontNameKey = RegisterStyle("FontName" , typeof(String) , String.Empty , true),
|
|
ForeColorKey = RegisterStyle("ForeColor", typeof(Color) , Color.Empty , true),
|
|
BackColorKey = RegisterStyle("BackColor", typeof(Color) , Color.Empty , false);
|
|
|
|
private bool _marked = false; // used by IStateManager
|
|
private MobileControl _control; // containing control
|
|
private Style _referredStyle; // referred style
|
|
private bool _checkedStyleReference;// referred style is valid.
|
|
private StateBag _state; // name => object pairs
|
|
private DeviceSpecific _deviceSpecific;
|
|
private FontInfo _font;
|
|
private Style _cachedParentStyle;
|
|
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.Style"]/*' />
|
|
public Style()
|
|
{
|
|
}
|
|
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.Clone"]/*' />
|
|
public object Clone()
|
|
{
|
|
Style clone = new Style();
|
|
foreach(String key in State.Keys)
|
|
{
|
|
clone.State[key] = State[key];
|
|
}
|
|
clone._control = _control;
|
|
return clone;
|
|
}
|
|
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.ApplyTo"]/*' />
|
|
public void ApplyTo(WebControl control)
|
|
{
|
|
control.Font.Name = (String)this[FontNameKey, true];
|
|
switch ((FontSize)this[FontSizeKey, true])
|
|
{
|
|
case FontSize.Small:
|
|
control.Font.Size = FontUnit.Small;
|
|
break;
|
|
case FontSize.Large:
|
|
control.Font.Size = FontUnit.Large;
|
|
break;
|
|
default:
|
|
control.Font.Size = FontUnit.Medium;
|
|
break;
|
|
}
|
|
control.Font.Bold = ((BooleanOption)this[BoldKey, true]) == BooleanOption.True;
|
|
control.Font.Italic = ((BooleanOption)this[ItalicKey, true]) == BooleanOption.True;
|
|
control.ForeColor = (Color)this[ForeColorKey, true];
|
|
control.BackColor = (Color)this[BackColorKey, true];
|
|
}
|
|
|
|
internal void ApplyTo(WebCtrlStyle style)
|
|
{
|
|
style.Font.Bold = ((BooleanOption)this[BoldKey, true]) == BooleanOption.True;
|
|
style.Font.Italic = ((BooleanOption)this[ItalicKey, true]) == BooleanOption.True;
|
|
style.Font.Name = (String)this[FontNameKey, true];
|
|
style.ForeColor = (Color)this[ForeColorKey, true];
|
|
style.BackColor = (Color)this[BackColorKey, true];
|
|
|
|
switch ((FontSize)this[FontSizeKey, true])
|
|
{
|
|
case FontSize.Large :
|
|
style.Font.Size = FontUnit.Larger;
|
|
break;
|
|
|
|
case FontSize.Small :
|
|
style.Font.Size = FontUnit.Smaller;
|
|
break;
|
|
|
|
default :
|
|
break;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.State"]/*' />
|
|
protected internal StateBag State
|
|
{
|
|
get
|
|
{
|
|
if (_state == null)
|
|
{
|
|
_state = new StateBag();
|
|
if (((IStateManager)this).IsTrackingViewState)
|
|
{
|
|
((IStateManager)_state).TrackViewState();
|
|
}
|
|
}
|
|
|
|
return _state;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.IStateManager.IsTrackingViewState"]/*' />
|
|
/// <internalonly/>
|
|
protected bool IsTrackingViewState
|
|
{
|
|
get
|
|
{
|
|
return _marked;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.IStateManager.TrackViewState"]/*' />
|
|
/// <internalonly/>
|
|
protected void TrackViewState()
|
|
{
|
|
_marked = true;
|
|
if (_state != null)
|
|
{
|
|
((IStateManager)_state).TrackViewState();
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.IStateManager.SaveViewState"]/*' />
|
|
/// <internalonly/>
|
|
protected Object SaveViewState()
|
|
{
|
|
return _state != null ? ((IStateManager)_state).SaveViewState() : null;
|
|
}
|
|
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.IStateManager.LoadViewState"]/*' />
|
|
/// <internalonly/>
|
|
protected void LoadViewState(Object state)
|
|
{
|
|
if (state != null)
|
|
{
|
|
// mark _referredStyle as dirty to force reload from viewstate.
|
|
Refresh();
|
|
|
|
((IStateManager)State).LoadViewState(state);
|
|
}
|
|
}
|
|
|
|
internal void SetDirty()
|
|
{
|
|
// VSWHIDBEY 236464. The bag needs to be set dirty not individual items.
|
|
State.SetDirty(true);
|
|
/*
|
|
foreach (StateItem item in State.Values)
|
|
{
|
|
item.IsDirty = true;
|
|
}
|
|
*/
|
|
}
|
|
|
|
internal void Refresh()
|
|
{
|
|
_referredStyle = null;
|
|
_checkedStyleReference = false;
|
|
}
|
|
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.Control"]/*' />
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
]
|
|
public MobileControl Control
|
|
{
|
|
get
|
|
{
|
|
return _control;
|
|
}
|
|
}
|
|
|
|
internal void SetControl(MobileControl control)
|
|
{
|
|
_control = control;
|
|
_cachedParentStyle = null;
|
|
}
|
|
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.Name"]/*' />
|
|
[
|
|
Browsable(false),
|
|
DefaultValue(""),
|
|
MobileSysDescription(SR.Style_Name),
|
|
NotifyParentProperty(true),
|
|
]
|
|
public String Name
|
|
{
|
|
get
|
|
{
|
|
String name = (String)State["Name"];
|
|
return name != null ? name : String.Empty;
|
|
}
|
|
set
|
|
{
|
|
State["Name"] = value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.StyleReference"]/*' />
|
|
[
|
|
Bindable(false),
|
|
DefaultValue(null),
|
|
MobileCategory(SR.Category_Appearance),
|
|
MobileSysDescription(SR.Style_Reference),
|
|
NotifyParentProperty(true),
|
|
TypeConverter(typeof(System.Web.UI.Design.MobileControls.Converters.StyleReferenceConverter)),
|
|
]
|
|
public virtual String StyleReference
|
|
{
|
|
get
|
|
{
|
|
return (String)State["StyleReference"];
|
|
}
|
|
set
|
|
{
|
|
State["StyleReference"] = value;
|
|
Refresh(); // mark referred style as dirty
|
|
}
|
|
}
|
|
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
]
|
|
internal Style ReferredStyle
|
|
{
|
|
get
|
|
{
|
|
if (_checkedStyleReference)
|
|
{
|
|
return _referredStyle;
|
|
}
|
|
|
|
_checkedStyleReference = true;
|
|
String reference = StyleReference;
|
|
|
|
if (String.IsNullOrEmpty(reference))
|
|
{
|
|
_referredStyle = null;
|
|
return null;
|
|
}
|
|
|
|
Debug.Assert(_referredStyle == null ||
|
|
String.Equals(reference, _referredStyle.Name, StringComparison.OrdinalIgnoreCase),
|
|
"Inconsistency in style names - _referredStyle must be dirty.");
|
|
|
|
if (_referredStyle == null)
|
|
{
|
|
// Look in the stylesheet in the nearest templated control
|
|
TemplateControl nearestTemplatedControl =
|
|
_control.FindContainingTemplateControl();
|
|
|
|
StyleSheet stylesheet = null;
|
|
MobilePage mobilePage = nearestTemplatedControl as MobilePage;
|
|
if (mobilePage != null)
|
|
{
|
|
stylesheet = mobilePage.StyleSheet;
|
|
}
|
|
else
|
|
{
|
|
MobileUserControl mobileUserControl =
|
|
nearestTemplatedControl as MobileUserControl;
|
|
if (mobileUserControl != null)
|
|
{
|
|
stylesheet = mobileUserControl.StyleSheet;
|
|
|
|
// If stylesheet is in mobileUserControl at designtime,
|
|
// simply use the one in MobilePage
|
|
if (_control.MobilePage.DesignMode)
|
|
{
|
|
Debug.Assert(stylesheet == StyleSheet.Default);
|
|
stylesheet = _control.MobilePage.StyleSheet;
|
|
}
|
|
}
|
|
|
|
// Stylesheets won't be recognized in regular user
|
|
// controls.
|
|
}
|
|
|
|
if (stylesheet != null)
|
|
{
|
|
// when page does not contain StyleSheet
|
|
// controls, Default stylesheet will search twice.
|
|
_referredStyle = stylesheet[reference];
|
|
}
|
|
|
|
if (_referredStyle == null)
|
|
{
|
|
// built in styles
|
|
_referredStyle = StyleSheet.Default[reference];
|
|
|
|
// No exceptions in Designer, will handle differently.
|
|
if (_referredStyle == null && !_control.MobilePage.DesignMode)
|
|
{
|
|
String exceptionResource;
|
|
if (nearestTemplatedControl is UserControl &&
|
|
!(nearestTemplatedControl is MobileUserControl))
|
|
{
|
|
// Throw a specific error message in this case
|
|
exceptionResource =
|
|
SR.Style_StyleNotFoundOnGenericUserControl;
|
|
}
|
|
else
|
|
{
|
|
exceptionResource =
|
|
SR.Style_StyleNotFound;
|
|
}
|
|
|
|
throw new Exception(SR.GetString(exceptionResource,
|
|
reference));
|
|
}
|
|
}
|
|
}
|
|
|
|
return _referredStyle;
|
|
}
|
|
}
|
|
|
|
// late bound method for accessing style properties
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.this"]/*' />
|
|
public Object this[Object key]
|
|
{
|
|
get
|
|
{
|
|
return GetValue((Property)key, false, true, null);
|
|
}
|
|
set
|
|
{
|
|
Property property = (Property)key;
|
|
Object defaultValue = property.DefaultValue;
|
|
State[property.Name] = defaultValue.Equals(value) ? null : value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.this1"]/*' />
|
|
public Object this[Object key, bool inherit]
|
|
{
|
|
get
|
|
{
|
|
return GetValue((Property)key, inherit, true, null);
|
|
}
|
|
}
|
|
|
|
private Object GetValue(Property property, bool inherit, bool returnDefault, Hashtable stylesEncountered)
|
|
{
|
|
// try to retrieve from internal value
|
|
Object value = State[property.Name];
|
|
|
|
if (value == null)
|
|
{
|
|
// else retrieve from style reference
|
|
if (inherit)
|
|
{
|
|
Style style = this.ReferredStyle;
|
|
if (style != null)
|
|
{
|
|
if (stylesEncountered == null)
|
|
{
|
|
stylesEncountered = new Hashtable();
|
|
}
|
|
|
|
if (stylesEncountered.ContainsKey(style))
|
|
{
|
|
if (_control.MobilePage != null && _control.MobilePage.DesignMode)
|
|
{
|
|
return property.DefaultValue;
|
|
}
|
|
else
|
|
{
|
|
throw new Exception(SR.GetString(SR.Style_CircularReference, this.Name));
|
|
}
|
|
}
|
|
stylesEncountered[style] = true;
|
|
value = style.GetValue(property, inherit, false, stylesEncountered);
|
|
}
|
|
}
|
|
|
|
if (value == null)
|
|
{
|
|
// else retrieve from control ancestor
|
|
if (inherit && property.Inherit && _control != null)
|
|
{
|
|
Style parentStyle = null;
|
|
if (_cachedParentStyle == null)
|
|
{
|
|
if (_control.Parent is MobileControl)
|
|
{
|
|
parentStyle = ((MobileControl)_control.Parent).Style;
|
|
_cachedParentStyle = parentStyle;
|
|
}
|
|
// DeviceSpecific is treated as control at design time, however, we need to get
|
|
// the styles from devicespecific's parent.
|
|
else if (_control.MobilePage != null &&
|
|
_control.MobilePage.DesignMode &&
|
|
_control.Parent is DeviceSpecific &&
|
|
_control.Parent.Parent is MobileControl)
|
|
{
|
|
parentStyle = ((MobileControl)_control.Parent.Parent).Style;
|
|
}
|
|
else if(!(_control is Form))
|
|
{
|
|
Control _tempControl = _control.Parent;
|
|
while(!(_tempControl is MobileControl) && (_tempControl != null))
|
|
{
|
|
_tempControl = _tempControl.Parent;
|
|
}
|
|
if(_tempControl != null)
|
|
{
|
|
parentStyle = ((MobileControl)_tempControl).Style;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
parentStyle = _cachedParentStyle;
|
|
}
|
|
|
|
if (parentStyle != null)
|
|
{
|
|
value = parentStyle.GetValue(property, inherit, false, null);
|
|
}
|
|
}
|
|
|
|
// else retrieve default value
|
|
if (value == null && returnDefault)
|
|
{
|
|
value = property.DefaultValue;
|
|
}
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
|
|
internal void InvalidateParentStyle()
|
|
{
|
|
_cachedParentStyle = null;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// BEGIN STYLES
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.Font"]/*' />
|
|
[
|
|
DefaultValue(null),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
|
|
MobileCategory(SR.Category_Appearance),
|
|
MobileSysDescription(SR.Style_Font),
|
|
NotifyParentProperty(true)
|
|
]
|
|
public FontInfo Font
|
|
{
|
|
get
|
|
{
|
|
if (_font == null)
|
|
{
|
|
_font = new FontInfo(this);
|
|
}
|
|
return _font;
|
|
}
|
|
}
|
|
|
|
// FontSize and FontName internal
|
|
// we still need these methods on style due to their inheritance and
|
|
// persistence behavior, they're referenced from FontInfo.cs.
|
|
//
|
|
|
|
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
]
|
|
internal String FontName
|
|
{
|
|
get
|
|
{
|
|
return (String)this[FontNameKey];
|
|
}
|
|
set
|
|
{
|
|
this[FontNameKey] = value;
|
|
}
|
|
}
|
|
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
]
|
|
internal BooleanOption Bold
|
|
{
|
|
get
|
|
{
|
|
return (BooleanOption)this[BoldKey];
|
|
}
|
|
set
|
|
{
|
|
this[BoldKey] = value;
|
|
}
|
|
}
|
|
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
]
|
|
internal BooleanOption Italic
|
|
{
|
|
get
|
|
{
|
|
return (BooleanOption)this[ItalicKey];
|
|
}
|
|
set
|
|
{
|
|
this[ItalicKey] = value;
|
|
}
|
|
}
|
|
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
]
|
|
internal FontSize FontSize
|
|
{
|
|
get
|
|
{
|
|
return (FontSize)this[FontSizeKey];
|
|
}
|
|
set
|
|
{
|
|
this[FontSizeKey] = value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.Alignment"]/*' />
|
|
[
|
|
Bindable(true),
|
|
DefaultValue(Alignment.NotSet),
|
|
MobileCategory(SR.Category_Appearance),
|
|
MobileSysDescription(SR.Style_Alignment),
|
|
NotifyParentProperty(true),
|
|
]
|
|
public Alignment Alignment
|
|
{
|
|
get
|
|
{
|
|
return (Alignment)this[AlignmentKey];
|
|
}
|
|
set
|
|
{
|
|
this[AlignmentKey] = value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.Wrapping"]/*' />
|
|
[
|
|
Bindable(true),
|
|
DefaultValue(Wrapping.NotSet),
|
|
MobileCategory(SR.Category_Appearance),
|
|
MobileSysDescription(SR.Style_Wrapping),
|
|
NotifyParentProperty(true),
|
|
]
|
|
public Wrapping Wrapping
|
|
{
|
|
get
|
|
{
|
|
return (Wrapping)this[WrappingKey];
|
|
}
|
|
set
|
|
{
|
|
this[WrappingKey] = value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.ForeColor"]/*' />
|
|
[
|
|
Bindable(true),
|
|
DefaultValue(typeof(Color), ""),
|
|
MobileCategory(SR.Category_Appearance),
|
|
MobileSysDescription(SR.Style_ForeColor),
|
|
NotifyParentProperty(true),
|
|
TypeConverterAttribute(typeof(WebColorConverter)),
|
|
]
|
|
public Color ForeColor
|
|
{
|
|
get
|
|
{
|
|
return (Color)this[ForeColorKey];
|
|
}
|
|
set
|
|
{
|
|
this[ForeColorKey] = value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.BackColor"]/*' />
|
|
[
|
|
Bindable(true),
|
|
DefaultValue(typeof(Color), ""),
|
|
MobileCategory(SR.Category_Appearance),
|
|
MobileSysDescription(SR.Style_BackColor),
|
|
NotifyParentProperty(true),
|
|
TypeConverterAttribute(typeof(WebColorConverter))
|
|
]
|
|
public Color BackColor
|
|
{
|
|
get
|
|
{
|
|
return (Color)this[BackColorKey];
|
|
}
|
|
set
|
|
{
|
|
this[BackColorKey] = value;
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
// TEMPLATES SUPPORT
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.IParserAccessor.AddParsedSubObject"]/*' />
|
|
/// <internalonly/>
|
|
protected void AddParsedSubObject(Object o)
|
|
{
|
|
if (o is DeviceSpecific)
|
|
{
|
|
if (DeviceSpecific != null)
|
|
{
|
|
throw new Exception(
|
|
SR.GetString(SR.MobileControl_NoMultipleDeviceSpecifics));
|
|
}
|
|
DeviceSpecific = (DeviceSpecific)o;
|
|
|
|
// This code works by assuming that the time this
|
|
// method is called, that Control has not yet been
|
|
// set. Thus, we set the DeviceSpecific's parent
|
|
// control when the Control itself is set. If Control
|
|
// != null here, then we won't get that opportunity.
|
|
Debug.Assert(Control == null);
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.IsTemplated"]/*' />
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
]
|
|
public bool IsTemplated
|
|
{
|
|
get
|
|
{
|
|
return IsTemplatedInternal(null);
|
|
}
|
|
}
|
|
|
|
internal bool IsTemplatedInternal(Hashtable stylesEncountered)
|
|
{
|
|
if (_deviceSpecific != null && _deviceSpecific.HasTemplates)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
Style referredStyle = ReferredStyle;
|
|
if (referredStyle == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (stylesEncountered == null)
|
|
{
|
|
stylesEncountered = new Hashtable();
|
|
}
|
|
if (stylesEncountered.ContainsKey(referredStyle))
|
|
{
|
|
if (_control.MobilePage != null && _control.MobilePage.DesignMode)
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
throw new Exception(SR.GetString(SR.Style_CircularReference, this.Name));
|
|
}
|
|
}
|
|
// referredStyle != null
|
|
stylesEncountered[referredStyle] = true;
|
|
return referredStyle.IsTemplatedInternal(stylesEncountered);
|
|
}
|
|
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.GetTemplate"]/*' />
|
|
public ITemplate GetTemplate(String templateName)
|
|
{
|
|
return GetTemplateInternal(templateName, null);
|
|
}
|
|
|
|
internal ITemplate GetTemplateInternal(String templateName, Hashtable stylesEncountered)
|
|
{
|
|
ITemplate t = null;
|
|
if (_deviceSpecific != null)
|
|
{
|
|
t = (ITemplate)_deviceSpecific.GetTemplate (templateName);
|
|
}
|
|
|
|
Style referredStyle = ReferredStyle;
|
|
if (t == null && referredStyle != null)
|
|
{
|
|
// Check for cyclical style references.
|
|
if (stylesEncountered == null)
|
|
{
|
|
stylesEncountered = new Hashtable ();
|
|
}
|
|
if (stylesEncountered.ContainsKey(referredStyle))
|
|
{
|
|
if (_control.MobilePage != null && _control.MobilePage.DesignMode)
|
|
{
|
|
return null;
|
|
}
|
|
else
|
|
{
|
|
throw new Exception(SR.GetString(SR.Style_CircularReference, this.Name));
|
|
}
|
|
}
|
|
|
|
// No cycle detected.
|
|
stylesEncountered[referredStyle] = true;
|
|
t = referredStyle.GetTemplateInternal(templateName, stylesEncountered);
|
|
}
|
|
|
|
return t;
|
|
}
|
|
|
|
// Design-time only property
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.DeviceSpecific"]/*' />
|
|
[
|
|
Browsable(false),
|
|
PersistenceMode(PersistenceMode.InnerProperty)
|
|
]
|
|
public DeviceSpecific DeviceSpecific
|
|
{
|
|
get
|
|
{
|
|
return _deviceSpecific;
|
|
}
|
|
set
|
|
{
|
|
_deviceSpecific = value;
|
|
if (null != value)
|
|
{
|
|
value.SetOwner(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
// registers a new type of style and returns the KEY for accessing it
|
|
/// <include file='doc\Style.uex' path='docs/doc[@for="Style.RegisterStyle"]/*' />
|
|
public static Object RegisterStyle(String name, Type type, Object defaultValue, bool inherit)
|
|
{
|
|
return new Property(name, type, defaultValue, inherit);
|
|
}
|
|
|
|
class Property
|
|
{
|
|
public String Name;
|
|
public Type Type;
|
|
public Object DefaultValue;
|
|
public bool Inherit; // can be inherited from parent?
|
|
|
|
public Property(String name, Type type, Object defaultValue, bool inherit)
|
|
{
|
|
this.Name = name;
|
|
this.Type = type;
|
|
this.DefaultValue = defaultValue;
|
|
this.Inherit = inherit;
|
|
}
|
|
}
|
|
|
|
#region Implementation of IStateManager
|
|
/// <internalonly/>
|
|
bool IStateManager.IsTrackingViewState {
|
|
get {
|
|
return IsTrackingViewState;
|
|
}
|
|
}
|
|
|
|
/// <internalonly/>
|
|
void IStateManager.LoadViewState(object state) {
|
|
LoadViewState(state);
|
|
}
|
|
|
|
/// <internalonly/>
|
|
void IStateManager.TrackViewState() {
|
|
TrackViewState();
|
|
}
|
|
|
|
/// <internalonly/>
|
|
object IStateManager.SaveViewState() {
|
|
return SaveViewState();
|
|
}
|
|
#endregion
|
|
|
|
#region IParserAccessor implementation
|
|
void IParserAccessor.AddParsedSubObject(Object o) {
|
|
AddParsedSubObject(o);
|
|
}
|
|
#endregion
|
|
}
|
|
}
|