1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
|
//------------------------------------------------------------------------------
// <copyright file="PageTheme.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.UI {
using System;
using System.Collections;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Globalization;
using System.Web.UI.HtmlControls;
using System.Web.Util;
using System.Xml;
using System.Security.Permissions;
internal class FileLevelPageThemeBuilder : RootBuilder {
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public override void AppendLiteralString(string s) {
// Don't allow any literal contents at theme top level
if (s != null) {
if (!Util.IsWhiteSpaceString(s)) {
throw new HttpException(SR.GetString(SR.Literal_content_not_allowed, SR.GetString(SR.Page_theme_skin_file), s.Trim()));
}
}
base.AppendLiteralString(s);
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public override void AppendSubBuilder(ControlBuilder subBuilder) {
// Only allow controls at theme top level
Type ctrlType = subBuilder.ControlType;
if (!typeof(Control).IsAssignableFrom(ctrlType)) {
throw new HttpException(SR.GetString(SR.Page_theme_only_controls_allowed, ctrlType == null ?
String.Empty : ctrlType.ToString()));
}
// Check if the control theme type is themeable.
if (InPageTheme && !ThemeableAttribute.IsTypeThemeable(subBuilder.ControlType)) {
throw new HttpParseException(SR.GetString(SR.Type_theme_disabled, subBuilder.ControlType.FullName),
null, subBuilder.VirtualPath, null, subBuilder.Line);
}
base.AppendSubBuilder(subBuilder);
}
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
public abstract class PageTheme {
private Page _page;
private bool _styleSheetTheme;
protected abstract String[] LinkedStyleSheets { get; }
protected abstract IDictionary ControlSkins { get; }
protected abstract String AppRelativeTemplateSourceDirectory { get; }
protected Page Page {
get {
return _page;
}
}
internal void Initialize(Page page, bool styleSheetTheme) {
Debug.Assert(page != null);
_page = page;
_styleSheetTheme = styleSheetTheme;
}
protected object Eval(string expression) {
return Page.Eval(expression);
}
protected string Eval(string expression, string format) {
return Page.Eval(expression, format);
}
public static object CreateSkinKey(Type controlType, String skinID) {
if (controlType == null) {
throw new ArgumentNullException("controlType");
}
return new SkinKey(controlType.ToString(), skinID);
}
internal void ApplyControlSkin(Control control) {
if (control == null) {
throw new ArgumentNullException("control");
}
ControlSkin skin = null;
String skinId = control.SkinID;
skin = (ControlSkin)ControlSkins[CreateSkinKey(control.GetType(), skinId)];
// Don't throw if ControlSkin corresponds to the skinID does not exist.
Debug.Assert(skin == null || skin.ControlType == control.GetType());
if (skin != null) {
skin.ApplySkin(control);
}
}
internal void SetStyleSheet() {
if (LinkedStyleSheets != null && LinkedStyleSheets.Length > 0) {
if (Page.Header == null)
throw new InvalidOperationException(SR.GetString(SR.Page_theme_requires_page_header));
int index = 0;
foreach(string styleSheetPath in LinkedStyleSheets) {
HtmlLink link = new HtmlLink();
link.Href = styleSheetPath;
link.Attributes["type"] = "text/css";
link.Attributes["rel"] = "stylesheet";
if (_styleSheetTheme) {
Page.Header.Controls.AddAt(index ++, link);
}
else {
Page.Header.Controls.Add(link);
}
}
}
}
public bool TestDeviceFilter(string deviceFilterName) {
return Page.TestDeviceFilter(deviceFilterName);
}
protected object XPath(string xPathExpression) {
return Page.XPath(xPathExpression);
}
protected object XPath(string xPathExpression, IXmlNamespaceResolver resolver) {
return Page.XPath(xPathExpression, resolver);
}
protected string XPath(string xPathExpression, string format) {
return Page.XPath(xPathExpression, format);
}
protected string XPath(string xPathExpression, string format, IXmlNamespaceResolver resolver) {
return Page.XPath(xPathExpression, format, resolver);
}
protected IEnumerable XPathSelect(string xPathExpression) {
return Page.XPathSelect(xPathExpression);
}
protected IEnumerable XPathSelect(string xPathExpression, IXmlNamespaceResolver resolver) {
return Page.XPathSelect(xPathExpression, resolver);
}
private class SkinKey {
private string _skinID;
private string _typeName;
internal SkinKey(string typeName, string skinID) {
_typeName = typeName;
if (String.IsNullOrEmpty(skinID)) {
_skinID = null;
}
else {
_skinID = skinID.ToLower(CultureInfo.InvariantCulture);
}
}
public override int GetHashCode() {
if (_skinID == null) {
return _typeName.GetHashCode();
}
return HashCodeCombiner.CombineHashCodes(_typeName.GetHashCode(), _skinID.GetHashCode());
}
public override bool Equals(object o) {
SkinKey key = (SkinKey)o;
return (_typeName == key._typeName) &&
(_skinID == key._skinID);
}
}
}
}
|
