-//
+//
// System.Web.UI.PageParser
//
// Authors:
// Gonzalo Paniagua Javier (gonzalo@ximian.com)
//
// (C) 2002,2003 Ximian, Inc (http://www.ximian.com)
-// Copyright (C) 2005 Novell, Inc (http://www.novell.com)
+// Copyright (C) 2005-2010 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
using System.Text;
using System.Web.Compilation;
using System.Web.Configuration;
+using System.Web.Hosting;
using System.Web.Util;
using System.IO;
[AspNetHostingPermission (SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
public sealed class PageParser : TemplateControlParser
{
- bool enableSessionState = true;
+#if NET_4_0
+ static Type defaultPageBaseType;
+ static Type defaultApplicationBaseType;
+ static Type defaultPageParserFilterType;
+ static Type defaultUserControlBaseType;
+ static bool enableLongStringsAsResources = true;
+#endif
+ PagesEnableSessionState enableSessionState = PagesEnableSessionState.True;
+ bool enableViewStateMac;
+ bool enableViewStateMacSet;
+ bool smartNavigation;
bool haveTrace;
bool trace;
bool notBuffer;
- TraceMode tracemode;
- bool readonlySessionState;
- string responseEncoding;
+ TraceMode tracemode = TraceMode.Default;
string contentType;
- int codepage = -1;
- int lcid = -1;
+ MainDirectiveAttribute <int> codepage;
+ MainDirectiveAttribute <string> responseEncoding;
+ MainDirectiveAttribute <int> lcid;
+ MainDirectiveAttribute <string> clientTarget;
+ MainDirectiveAttribute <string> masterPage;
+ MainDirectiveAttribute <string> title;
+ MainDirectiveAttribute <string> theme;
+#if NET_4_0
+ MainDirectiveAttribute <string> metaDescription;
+ MainDirectiveAttribute <string> metaKeywords;
+#endif
string culture;
string uiculture;
string errorPage;
bool validateRequest;
- string clientTarget;
- Type baseType = typeof (Page);
-
-#if NET_2_0
- string masterPage;
+ bool async;
+ int asyncTimeout = -1;
Type masterType;
- string title;
- string theme;
+ string masterVirtualPath;
string styleSheetTheme;
bool enable_event_validation;
-#endif
+ bool maintainScrollPositionOnPostBack;
+ int maxPageStateFieldLength = -1;
+ Type previousPageType;
+ string previousPageVirtualPath;
+#if NET_4_0
+ public static bool EnableLongStringsAsResources {
+ get { return enableLongStringsAsResources; }
+ set {
+ BuildManager.AssertPreStartMethodsRunning ();
+ enableLongStringsAsResources = value;
+ }
+ }
+
+ public static Type DefaultPageBaseType {
+ get { return defaultPageBaseType; }
+ set {
+ BuildManager.AssertPreStartMethodsRunning ();
+ if (value != null && !typeof (Page).IsAssignableFrom (value))
+ throw new ArgumentException (String.Format ("The value assigned to property '{0}' is invalid.", "DefaultPageBaseType"));
+
+ defaultPageBaseType = value;
+ }
+ }
+
+ public static Type DefaultApplicationBaseType {
+ get { return defaultApplicationBaseType; }
+ set {
+ BuildManager.AssertPreStartMethodsRunning ();
+ if (value != null && !typeof (HttpApplication).IsAssignableFrom (value))
+ throw new ArgumentException (String.Format ("The value assigned to property '{0}' is invalid.", "DefaultApplicationBaseType"));
+ defaultApplicationBaseType = value;
+ }
+ }
+
+ public static Type DefaultPageParserFilterType {
+ get { return defaultPageParserFilterType; }
+ set {
+ BuildManager.AssertPreStartMethodsRunning ();
+ if (value != null && !typeof (PageParserFilter).IsAssignableFrom (value))
+ throw new ArgumentException (String.Format ("The value assigned to property '{0}' is invalid.", "DefaultPageParserFilterType"));
+ defaultPageParserFilterType = value;
+ }
+ }
+ public static Type DefaultUserControlBaseType {
+ get { return defaultUserControlBaseType; }
+ set {
+ if (value != null && !typeof (UserControl).IsAssignableFrom (value))
+ throw new ArgumentException (String.Format ("The value assigned to property '{0}' is invalid.", "DefaultUserControlBaseType"));
+ BuildManager.AssertPreStartMethodsRunning ();
+ defaultUserControlBaseType = value;
+ }
+ }
+#endif
public PageParser ()
{
+ LoadConfigDefaults ();
}
internal PageParser (string virtualPath, string inputFile, HttpContext context)
{
+ this.VirtualPath = new VirtualPath (virtualPath);
Context = context;
- BaseVirtualDir = UrlUtils.GetDirectory (virtualPath);
+ BaseVirtualDir = VirtualPathUtility.GetDirectory (virtualPath, false);
InputFile = inputFile;
- SetBaseType (PagesConfig.PageBaseType);
+ SetBaseType (null);
AddApplicationAssembly ();
+ LoadConfigDefaults ();
}
-#if NET_2_0
- internal PageParser (string virtualPath, TextReader reader, HttpContext context)
+ internal PageParser (VirtualPath virtualPath, TextReader reader, HttpContext context)
+ : this (virtualPath, null, reader, context)
{
+ }
+
+ internal PageParser (VirtualPath virtualPath, string inputFile, TextReader reader, HttpContext context)
+ {
+ this.VirtualPath = virtualPath;
Context = context;
- BaseVirtualDir = UrlUtils.GetDirectory (virtualPath);
+ BaseVirtualDir = virtualPath.DirectoryNoNormalize;
Reader = reader;
- SetBaseType (PagesConfig.PageBaseType);
+ if (String.IsNullOrEmpty (inputFile))
+ InputFile = virtualPath.PhysicalPath;
+ else
+ InputFile = inputFile;
+ SetBaseType (null);
AddApplicationAssembly ();
+ LoadConfigDefaults ();
}
-#endif
- public static IHttpHandler GetCompiledPageInstance (string virtualPath,
- string inputFile,
- HttpContext context)
+ internal override void LoadConfigDefaults ()
{
- PageParser pp = new PageParser (virtualPath, inputFile, context);
- IHttpHandler h = (IHttpHandler) pp.GetCompiledInstance ();
- return h;
+ base.LoadConfigDefaults ();
+ PagesSection ps = PagesConfig;
+
+ notBuffer = !ps.Buffer;
+ enableSessionState = ps.EnableSessionState;
+ enableViewStateMac = ps.EnableViewStateMac;
+ smartNavigation = ps.SmartNavigation;
+ validateRequest = ps.ValidateRequest;
+
+ string value = ps.MasterPageFile;
+ if (value.Length > 0)
+ masterPage = new MainDirectiveAttribute <string> (value, true);
+
+ enable_event_validation = ps.EnableEventValidation;
+ maxPageStateFieldLength = ps.MaxPageStateFieldLength;
+ value = ps.Theme;
+ if (value.Length > 0)
+ theme = new MainDirectiveAttribute <string> (value, true);
+
+ styleSheetTheme = ps.StyleSheetTheme;
+ if (styleSheetTheme.Length == 0)
+ styleSheetTheme = null;
+ maintainScrollPositionOnPostBack = ps.MaintainScrollPositionOnPostBack;
}
+
+ public static IHttpHandler GetCompiledPageInstance (string virtualPath, string inputFile, HttpContext context)
+ {
+ bool isFake = false;
- internal override void ProcessMainAttributes (Hashtable atts)
+ if (!String.IsNullOrEmpty (inputFile))
+ isFake = !inputFile.StartsWith (HttpRuntime.AppDomainAppPath);
+
+ return BuildManager.CreateInstanceFromVirtualPath (new VirtualPath (virtualPath, inputFile, isFake), typeof (IHttpHandler)) as IHttpHandler;
+ }
+
+ internal override void ProcessMainAttributes (IDictionary atts)
{
- string enabless = GetString (atts, "EnableSessionState",
-#if NET_2_0
- PagesConfig.EnableSessionState.ToString()
-#else
- PagesConfig.EnableSessionState
-#endif
- );
+ // note: the 'enableSessionState' configuration property is
+ // processed in a case-sensitive manner while the page-level
+ // attribute is processed case-insensitive
+ string enabless = GetString (atts, "EnableSessionState", null);
if (enabless != null) {
- readonlySessionState = (String.Compare (enabless, "readonly", true) == 0);
- if (readonlySessionState == true || String.Compare (enabless, "true", true) == 0) {
- enableSessionState = true;
- } else if (String.Compare (enabless, "false", true) == 0) {
- enableSessionState = false;
- } else {
- ThrowParseException ("Invalid value for EnableSessionState: " + enabless);
- }
+ if (String.Compare (enabless, "readonly", true, Helpers.InvariantCulture) == 0)
+ enableSessionState = PagesEnableSessionState.ReadOnly;
+ else if (String.Compare (enabless, "true", true, Helpers.InvariantCulture) == 0)
+ enableSessionState = PagesEnableSessionState.True;
+ else if (String.Compare (enabless, "false", true, Helpers.InvariantCulture) == 0)
+ enableSessionState = PagesEnableSessionState.False;
+ else
+ ThrowParseException ("Invalid value for enableSessionState: " + enabless);
}
- string cp = GetString (atts, "CodePage", null);
- if (cp != null) {
+ string value = GetString (atts, "CodePage", null);
+ if (value != null) {
if (responseEncoding != null)
- ThrowParseException ("CodePage and ResponseEncoding are " +
- "mutually exclusive.");
+ ThrowParseException ("CodePage and ResponseEncoding are mutually exclusive.");
+
+ if (!BaseParser.IsExpression (value)) {
+ int cpval = -1;
- int codepage = 0;
- try {
- codepage = (int) UInt32.Parse (cp);
- } catch {
- ThrowParseException ("Invalid value for CodePage: " + cp);
- }
+ try {
+ cpval = (int) UInt32.Parse (value);
+ } catch {
+ ThrowParseException ("Invalid value for CodePage: " + value);
+ }
- try {
- Encoding.GetEncoding (codepage);
- } catch {
- ThrowParseException ("Unsupported codepage: " + cp);
- }
+ try {
+ Encoding.GetEncoding (cpval);
+ } catch {
+ ThrowParseException ("Unsupported codepage: " + value);
+ }
+ codepage = new MainDirectiveAttribute <int> (cpval, true);
+ } else
+ codepage = new MainDirectiveAttribute <int> (value);
}
- responseEncoding = GetString (atts, "ResponseEncoding", null);
- if (responseEncoding != null) {
- if (codepage != -1)
- ThrowParseException ("CodePage and ResponseEncoding are " +
- "mutually exclusive.");
-
- try {
- Encoding.GetEncoding (responseEncoding);
- } catch {
- ThrowParseException ("Unsupported encoding: " + responseEncoding);
- }
+ value = GetString (atts, "ResponseEncoding", null);
+ if (value != null) {
+ if (codepage != null)
+ ThrowParseException ("CodePage and ResponseEncoding are mutually exclusive.");
+
+ if (!BaseParser.IsExpression (value)) {
+ try {
+ Encoding.GetEncoding (value);
+ } catch {
+ ThrowParseException ("Unsupported encoding: " + value);
+ }
+ responseEncoding = new MainDirectiveAttribute <string> (value, true);
+ } else
+ responseEncoding = new MainDirectiveAttribute <string> (value);
}
contentType = GetString (atts, "ContentType", null);
- string lcidStr = GetString (atts, "LCID", null);
- if (lcidStr != null) {
- try {
- lcid = (int) UInt32.Parse (lcidStr);
- } catch {
- ThrowParseException ("Invalid value for LCID: " + lcid);
- }
+ value = GetString (atts, "LCID", null);
+ if (value != null) {
+ if (!BaseParser.IsExpression (value)) {
+ int parsedLcid = -1;
+ try {
+ parsedLcid = (int) UInt32.Parse (value);
+ } catch {
+ ThrowParseException ("Invalid value for LCID: " + value);
+ }
- CultureInfo ci = null;
- try {
- ci = new CultureInfo (lcid);
- } catch {
- ThrowParseException ("Unsupported LCID: " + lcid);
- }
+ CultureInfo ci = null;
+ try {
+ ci = new CultureInfo (parsedLcid);
+ } catch {
+ ThrowParseException ("Unsupported LCID: " + value);
+ }
- if (ci.IsNeutralCulture) {
- string suggestedCulture = SuggestCulture (ci.Name);
- string fmt = "LCID attribute must be set to a non-neutral Culture.";
- if (suggestedCulture != null) {
- ThrowParseException (fmt + " Please try one of these: " +
- suggestedCulture);
- } else {
- ThrowParseException (fmt);
+ if (ci.IsNeutralCulture) {
+ string suggestedCulture = SuggestCulture (ci.Name);
+ string fmt = "LCID attribute must be set to a non-neutral Culture.";
+ if (suggestedCulture != null) {
+ ThrowParseException (fmt + " Please try one of these: " +
+ suggestedCulture);
+ } else {
+ ThrowParseException (fmt);
+ }
}
- }
+ lcid = new MainDirectiveAttribute <int> (parsedLcid, true);
+ } else
+ lcid = new MainDirectiveAttribute <int> (value);
}
culture = GetString (atts, "Culture", null);
if (culture != null) {
- if (lcidStr != null)
+ if (lcid != null)
ThrowParseException ("Culture and LCID are mutually exclusive.");
CultureInfo ci = null;
try {
- ci = new CultureInfo (culture);
+ if (!culture.StartsWith ("auto"))
+ ci = new CultureInfo (culture);
} catch {
ThrowParseException ("Unsupported Culture: " + culture);
}
- if (ci.IsNeutralCulture) {
+ if (ci != null && ci.IsNeutralCulture) {
string suggestedCulture = SuggestCulture (culture);
string fmt = "Culture attribute must be set to a non-neutral Culture.";
if (suggestedCulture != null)
if (uiculture != null) {
CultureInfo ci = null;
try {
- ci = new CultureInfo (uiculture);
+ if (!uiculture.StartsWith ("auto"))
+ ci = new CultureInfo (uiculture);
} catch {
ThrowParseException ("Unsupported Culture: " + uiculture);
}
- if (ci.IsNeutralCulture) {
+ if (ci != null && ci.IsNeutralCulture) {
string suggestedCulture = SuggestCulture (uiculture);
string fmt = "UICulture attribute must be set to a non-neutral Culture.";
if (suggestedCulture != null)
}
errorPage = GetString (atts, "ErrorPage", null);
- validateRequest = GetBool (atts, "ValidateRequest", PagesConfig.ValidateRequest);
- clientTarget = GetString (atts, "ClientTarget", null);
- if (clientTarget != null) {
-#if NET_2_0
- ClientTargetSection sec = (ClientTargetSection)WebConfigurationManager.GetSection ("system.web/clientTarget");
- if (sec.ClientTargets[clientTarget] == null) {
- ThrowParseException (String.Format (
- "ClientTarget '{0}' is an invalid alias. See the " +
- "documentation for <clientTarget> config. section.",
- clientTarget));
- }
- clientTarget = sec.ClientTargets[clientTarget].UserAgent;
-#else
- NameValueCollection coll;
- coll = (NameValueCollection) Context.GetConfig ("system.web/clientTarget");
- if (coll == null || coll [clientTarget] == null) {
- ThrowParseException (String.Format (
- "ClientTarget '{0}' is an invalid alias. See the " +
- "documentation for <clientTarget> config. section.",
- clientTarget));
- }
- clientTarget = (string) coll [clientTarget];
-#endif
+ validateRequest = GetBool (atts, "ValidateRequest", validateRequest);
+ value = GetString (atts, "ClientTarget", null);
+ if (value != null) {
+ if (!BaseParser.IsExpression (value)) {
+ value = value.Trim ();
+
+ ClientTargetSection sec = GetConfigSection <ClientTargetSection> ("system.web/clientTarget");
+ ClientTarget ct = null;
+
+ if ((ct = sec.ClientTargets [value]) == null)
+ value = value.ToLowerInvariant ();
+
+ if (ct == null && (ct = sec.ClientTargets [value]) == null) {
+ ThrowParseException (String.Format (
+ "ClientTarget '{0}' is an invalid alias. See the " +
+ "documentation for <clientTarget> config. section.",
+ clientTarget));
+ }
+ value = ct.UserAgent;
+ clientTarget = new MainDirectiveAttribute <string> (value, true);
+ } else
+ clientTarget = new MainDirectiveAttribute <string> (value);
}
notBuffer = !GetBool (atts, "Buffer", true);
+ async = GetBool (atts, "Async", false);
+ string asyncTimeoutVal = GetString (atts, "AsyncTimeout", null);
+ if (asyncTimeoutVal != null) {
+ try {
+ asyncTimeout = Int32.Parse (asyncTimeoutVal);
+ } catch (Exception) {
+ ThrowParseException ("AsyncTimeout must be an integer value");
+ }
+ }
-#if NET_2_0
- masterPage = GetString (atts, "MasterPageFile", null);
+ value = GetString (atts, "MasterPageFile", masterPage != null ? masterPage.Value : null);
+ if (!String.IsNullOrEmpty (value)) {
+ if (!BaseParser.IsExpression (value)) {
+ value = System.Web.VirtualPathUtility.Combine(BaseVirtualDir, value);
+ var vpp = HostingEnvironment.VirtualPathProvider;
+ if (!vpp.FileExists (value))
+ ThrowParseFileNotFound (value);
+ value = vpp.CombineVirtualPaths (VirtualPath.Absolute, VirtualPathUtility.ToAbsolute (value));
+ AddDependency (value, false);
+ masterPage = new MainDirectiveAttribute <string> (value, true);
+ } else
+ masterPage = new MainDirectiveAttribute <string> (value);
+ }
- // Make sure the page exists
- if (masterPage != null)
- MasterPageParser.GetCompiledMasterType (masterPage, MapPath (masterPage), HttpContext.Current);
+ value = GetString(atts, "Title", null);
+ if (value != null) {
+ if (!BaseParser.IsExpression (value))
+ title = new MainDirectiveAttribute <string> (value, true);
+ else
+ title = new MainDirectiveAttribute <string> (value);
+ }
+
+ value = GetString (atts, "Theme", theme != null ? theme.Value : null);
+ if (value != null) {
+ if (!BaseParser.IsExpression (value))
+ theme = new MainDirectiveAttribute <string> (value, true);
+ else
+ theme = new MainDirectiveAttribute <string> (value);
+ }
+
+ styleSheetTheme = GetString (atts, "StyleSheetTheme", styleSheetTheme);
+ enable_event_validation = GetBool (atts, "EnableEventValidation", enable_event_validation);
+ maintainScrollPositionOnPostBack = GetBool (atts, "MaintainScrollPositionOnPostBack", maintainScrollPositionOnPostBack);
- title = GetString(atts, "Title", null);
+ if (atts.Contains ("EnableViewStateMac")) {
+ enableViewStateMac = GetBool (atts, "EnableViewStateMac", enableViewStateMac);
+ enableViewStateMacSet = true;
+ }
+#if NET_4_0
+ value = GetString (atts, "MetaDescription", null);
+ if (value != null) {
+ if (!BaseParser.IsExpression (value))
+ metaDescription = new MainDirectiveAttribute <string> (value, true);
+ else
+ metaDescription = new MainDirectiveAttribute <string> (value);
+ }
- theme = GetString (atts, "Theme", null);
- styleSheetTheme = GetString (atts, "StyleSheetTheme", null);
- enable_event_validation = GetBool (atts, "EnableEventValidation", true);
+ value = GetString (atts, "MetaKeywords", null);
+ if (value != null) {
+ if (!BaseParser.IsExpression (value))
+ metaKeywords = new MainDirectiveAttribute <string> (value, true);
+ else
+ metaKeywords = new MainDirectiveAttribute <string> (value);
+ }
#endif
// Ignored by now
- GetString (atts, "EnableViewStateMac", null);
GetString (atts, "SmartNavigation", null);
base.ProcessMainAttributes (atts);
}
-#if NET_2_0
- internal override void AddDirective (string directive, Hashtable atts)
+ internal override void AddDirective (string directive, IDictionary atts)
{
- if (String.Compare ("MasterType", directive, true) == 0) {
- string type = GetString (atts, "TypeName", null);
- if (type != null) {
- masterType = LoadType (type);
- if (masterType == null)
- ThrowParseException ("Could not load type '" + type + "'.");
- } else {
- string path = GetString (atts, "VirtualPath", null);
- if (path != null)
- masterType = MasterPageParser.GetCompiledMasterType (path, MapPath (path), HttpContext.Current);
+ bool isMasterType = String.Compare ("MasterType", directive, StringComparison.OrdinalIgnoreCase) == 0;
+ bool isPreviousPageType = isMasterType ? false : String.Compare ("PreviousPageType", directive,
+ StringComparison.OrdinalIgnoreCase) == 0;
+
+ string typeName = null;
+ string virtualPath = null;
+ Type type = null;
+
+ if (isMasterType || isPreviousPageType) {
+ PageParserFilter pfilter = PageParserFilter;
+ if (pfilter != null)
+ pfilter.PreprocessDirective (directive.ToLowerInvariant (), atts);
+
+ typeName = GetString (atts, "TypeName", null);
+ virtualPath = GetString (atts, "VirtualPath", null);
+
+ if (typeName != null && virtualPath != null)
+ ThrowParseException (
+ String.Format ("The '{0}' directive must have exactly one attribute: TypeName or VirtualPath", directive));
+ if (typeName != null) {
+ type = LoadType (typeName);
+ if (type == null)
+ ThrowParseException (String.Format ("Could not load type '{0}'.", typeName));
+ if (isMasterType)
+ masterType = type;
else
- ThrowParseException ("The MasterType directive must have either a TypeName or a VirtualPath attribute.");
- }
- AddAssembly (masterType.Assembly, true);
- }
- else
+ previousPageType = type;
+ } else if (!String.IsNullOrEmpty (virtualPath)) {
+ if (!HostingEnvironment.VirtualPathProvider.FileExists (virtualPath))
+ ThrowParseFileNotFound (virtualPath);
+
+ AddDependency (virtualPath, true);
+ if (isMasterType)
+ masterVirtualPath = virtualPath;
+ else
+ previousPageVirtualPath = virtualPath;
+ } else
+ ThrowParseException (String.Format ("The {0} directive must have either a TypeName or a VirtualPath attribute.", directive));
+
+ if (type != null)
+ AddAssembly (type.Assembly, true);
+ } else
base.AddDirective (directive, atts);
}
-#endif
static string SuggestCulture (string culture)
{
return retval;
}
- protected override Type CompileIntoType ()
+ internal Type GetCompiledPageType (string virtualPath, string inputFile, HttpContext context)
+ {
+ return BuildManager.GetCompiledType (virtualPath);
+ }
+
+ internal override Type CompileIntoType ()
{
AspGenerator generator = new AspGenerator (this);
return generator.GetCompiledType ();
}
internal bool EnableSessionState {
- get { return enableSessionState; }
+ get {
+ return enableSessionState == PagesEnableSessionState.True ||
+ ReadOnlySessionState;
+ }
+ }
+
+ internal bool EnableViewStateMac {
+ get { return enableViewStateMac; }
+ }
+
+ internal bool EnableViewStateMacSet {
+ get { return enableViewStateMacSet; }
+ }
+
+ internal bool SmartNavigation {
+ get { return smartNavigation; }
}
internal bool ReadOnlySessionState {
- get { return readonlySessionState; }
+ get {
+ return enableSessionState == PagesEnableSessionState.ReadOnly;
+ }
}
internal bool HaveTrace {
internal TraceMode TraceMode {
get { return tracemode; }
- }
-
+ }
+#if NET_4_0
internal override Type DefaultBaseType {
- get { return baseType; }
- }
+ get {
+ Type ret = DefaultPageBaseType;
+ if (ret == null)
+ return base.DefaultBaseType;
+ return ret;
+ }
+ }
+#endif
internal override string DefaultBaseTypeName {
- get { return "System.Web.UI.Page"; }
+ get { return PagesConfig.PageBaseType; }
}
-
+
internal override string DefaultDirectiveName {
get { return "page"; }
}
- internal string ResponseEncoding {
- get { return responseEncoding; }
- }
-
internal string ContentType {
get { return contentType; }
}
- internal int CodePage {
+ internal MainDirectiveAttribute <string> ResponseEncoding {
+ get { return responseEncoding; }
+ }
+
+ internal MainDirectiveAttribute <int> CodePage {
get { return codepage; }
}
+ internal MainDirectiveAttribute <int> LCID {
+ get { return lcid; }
+ }
+
+ internal MainDirectiveAttribute <string> ClientTarget {
+ get { return clientTarget; }
+ }
+
+ internal MainDirectiveAttribute <string> MasterPageFile {
+ get { return masterPage; }
+ }
+
+ internal MainDirectiveAttribute <string> Title {
+ get { return title; }
+ }
+
+ internal MainDirectiveAttribute <string> Theme {
+ get { return theme; }
+ }
+#if NET_4_0
+ internal MainDirectiveAttribute <string> MetaDescription {
+ get { return metaDescription; }
+ }
+
+ internal MainDirectiveAttribute <string> MetaKeywords {
+ get { return metaKeywords; }
+ }
+#endif
internal string Culture {
get { return culture; }
}
get { return uiculture; }
}
- internal int LCID {
- get { return lcid; }
- }
-
internal string ErrorPage {
get { return errorPage; }
}
get { return validateRequest; }
}
- internal string ClientTarget {
- get { return clientTarget; }
- }
-
internal bool NotBuffer {
get { return notBuffer; }
}
-#if NET_2_0
- internal string Theme {
- get { return theme; }
+ internal bool Async {
+ get { return async; }
}
- internal string StyleSheetTheme {
- get { return styleSheetTheme; }
+ internal int AsyncTimeout {
+ get { return asyncTimeout; }
}
- internal string MasterPageFile {
- get { return masterPage; }
+ internal string StyleSheetTheme {
+ get { return styleSheetTheme; }
}
internal Type MasterType {
- get { return masterType; }
- }
-
- internal string Title {
- get { return title; }
+ get {
+ if (masterType == null && !String.IsNullOrEmpty (masterVirtualPath))
+ masterType = BuildManager.GetCompiledType (masterVirtualPath);
+
+ return masterType;
+ }
}
internal bool EnableEventValidation {
get { return enable_event_validation; }
}
-#endif
+
+ internal bool MaintainScrollPositionOnPostBack {
+ get { return maintainScrollPositionOnPostBack; }
+ }
+
+ internal int MaxPageStateFieldLength {
+ get { return maxPageStateFieldLength; }
+ }
+
+ internal Type PreviousPageType {
+ get {
+ if (previousPageType == null && !String.IsNullOrEmpty (previousPageVirtualPath)) {
+ string mappedPath = MapPath (previousPageVirtualPath);
+ previousPageType = GetCompiledPageType (previousPageVirtualPath, mappedPath, HttpContext.Current);
+ }
+
+ return previousPageType;
+ }
+ }
}
}