1592 lines
58 KiB
C#
1592 lines
58 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="MobilePage.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.ComponentModel;
|
|
using System.ComponentModel.Design;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Text;
|
|
using System.Web.SessionState;
|
|
using System.Web.Mobile;
|
|
using System.Web.Security;
|
|
using System.Web.Util;
|
|
using System.Security.Permissions;
|
|
|
|
namespace System.Web.UI.MobileControls
|
|
{
|
|
|
|
/*
|
|
* Mobile page class.
|
|
* The page will use device id to create the appropriate DeviceAdapter,
|
|
* and then delegate all major functions to the adapter.
|
|
*
|
|
* THE MOBILE PAGE CLASS DOES NOT CONTAIN DEVICE-SPECIFIC CODE.
|
|
*
|
|
* All mobile aspx pages MUST extend from this using page inherit directive:
|
|
* <%@ Page Inherits="System.Web.UI.MobileControls.MobilePage" Language="cs" %>
|
|
*
|
|
* Copyright (c) 2000 Microsoft Corporation
|
|
*/
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage"]/*' />
|
|
[
|
|
Designer("Microsoft.VisualStudio.Web.WebForms.MobileWebFormDesigner, " + AssemblyRef.MicrosoftVisualStudioWeb, typeof(IRootDesigner)),
|
|
ToolboxItem(false)
|
|
]
|
|
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
|
|
[AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
|
|
[Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
|
|
public class MobilePage : Page
|
|
{
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.HiddenPostEventSourceId"]/*' />
|
|
public static readonly String HiddenPostEventSourceId = postEventSourceID;
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.HiddenPostEventArgumentId"]/*' />
|
|
public static readonly String HiddenPostEventArgumentId = postEventArgumentID;
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.ViewStateID"]/*' />
|
|
public static readonly String ViewStateID = "__VIEWSTATE";
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.HiddenVariablePrefix"]/*' />
|
|
public static readonly String HiddenVariablePrefix = "__V_";
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.PageClientViewStateKey"]/*' />
|
|
public static readonly String PageClientViewStateKey = "__P";
|
|
|
|
private const String DesignerAdapter = "System.Web.UI.MobileControls.Adapters.HtmlPageAdapter";
|
|
private IPageAdapter _pageAdapter;
|
|
private bool _debugMode = false;
|
|
private StyleSheet _styleSheet = null;
|
|
private IDictionary _hiddenVariables;
|
|
private Hashtable _clientViewState;
|
|
private String _eventSource;
|
|
private Hashtable _privateViewState = new Hashtable();
|
|
bool _privateViewStateLoaded = false;
|
|
private NameValueCollection _requestValueCollection;
|
|
private bool _isRenderingInForm = false;
|
|
private bool _afterPreInit;
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.AddParsedSubObject"]/*' />
|
|
protected override void AddParsedSubObject(Object o)
|
|
{
|
|
// Note : AddParsedSubObject is never called at DesignTime
|
|
if (o is StyleSheet)
|
|
{
|
|
if (_styleSheet != null)
|
|
{
|
|
throw new
|
|
Exception(SR.GetString(SR.StyleSheet_DuplicateWarningMessage));
|
|
}
|
|
else
|
|
{
|
|
_styleSheet = (StyleSheet)o;
|
|
}
|
|
}
|
|
|
|
base.AddParsedSubObject(o);
|
|
}
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.Device"]/*' />
|
|
[
|
|
Browsable(false),
|
|
Bindable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
]
|
|
public virtual MobileCapabilities Device
|
|
{
|
|
get
|
|
{
|
|
if (DesignMode)
|
|
{
|
|
return new
|
|
System.Web.UI.Design.MobileControls.DesignerCapabilities();
|
|
}
|
|
return (MobileCapabilities)Request.Browser;
|
|
}
|
|
}
|
|
|
|
[
|
|
Browsable(false),
|
|
Bindable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
EditorBrowsable(EditorBrowsableState.Advanced)
|
|
]
|
|
public override sealed string MasterPageFile {
|
|
get {
|
|
return null;
|
|
}
|
|
set {
|
|
if (_afterPreInit) {
|
|
throw new NotSupportedException(SR.GetString(SR.Feature_Not_Supported_On_MobilePage, "MasterPage"));
|
|
}
|
|
}
|
|
}
|
|
|
|
// EventValidation is not supported on a mobile page.
|
|
public override bool EnableEventValidation {
|
|
get {
|
|
return false;
|
|
}
|
|
set {
|
|
if (_afterPreInit && value) {
|
|
throw new NotSupportedException(SR.GetString(SR.Feature_Not_Supported_On_MobilePage, "EventValidation"));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.StyleSheet"]/*' />
|
|
[
|
|
Browsable(false),
|
|
Bindable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
]
|
|
public StyleSheet StyleSheet
|
|
{
|
|
get
|
|
{
|
|
return (_styleSheet != null) ? _styleSheet : StyleSheet.Default;
|
|
}
|
|
|
|
set
|
|
{
|
|
_styleSheet = value;
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Advanced)]
|
|
public override String Theme {
|
|
get {
|
|
return base.Theme;
|
|
}
|
|
set {
|
|
if (_afterPreInit) {
|
|
throw new NotSupportedException(SR.GetString(SR.Feature_Not_Supported_On_MobilePage, "Theme"));
|
|
}
|
|
}
|
|
}
|
|
|
|
[
|
|
Bindable(false),
|
|
Localizable(false),
|
|
EditorBrowsable(EditorBrowsableState.Never),
|
|
]
|
|
public new String Title {
|
|
get {
|
|
return String.Empty;
|
|
}
|
|
set {
|
|
throw new NotSupportedException(SR.GetString(SR.Feature_Not_Supported_On_MobilePage, "Title"));
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Advanced)]
|
|
public override String StyleSheetTheme {
|
|
get {
|
|
return base.StyleSheetTheme;
|
|
}
|
|
set {
|
|
if (_afterPreInit) {
|
|
throw new NotSupportedException(SR.GetString(SR.Feature_Not_Supported_On_MobilePage, "StyleSheetTheme"));
|
|
}
|
|
}
|
|
}
|
|
|
|
[
|
|
Browsable(false),
|
|
EditorBrowsable(EditorBrowsableState.Advanced)
|
|
]
|
|
public override bool EnableTheming {
|
|
get {
|
|
return base.EnableTheming;
|
|
}
|
|
set {
|
|
throw new NotSupportedException(SR.GetString(SR.Feature_Not_Supported_On_MobilePage, "Theme"));
|
|
}
|
|
}
|
|
|
|
private IList _forms;
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.Forms"]/*' />
|
|
[
|
|
Browsable(false),
|
|
Bindable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
]
|
|
public IList Forms
|
|
{
|
|
get
|
|
{
|
|
if (_forms == null)
|
|
{
|
|
int probableFormCount = Controls.Count / 2; // since there are literal controls between each
|
|
_forms = new ArrayList(probableFormCount);
|
|
AddForms(this);
|
|
}
|
|
return _forms;
|
|
}
|
|
}
|
|
|
|
private void AddForms(Control parent)
|
|
{
|
|
foreach (Control control in parent.Controls)
|
|
{
|
|
if (control is Form)
|
|
{
|
|
_forms.Add(control);
|
|
}
|
|
else if (control is UserControl)
|
|
{
|
|
AddForms(control);
|
|
}
|
|
}
|
|
}
|
|
|
|
private enum RunMode
|
|
{
|
|
Unknown,
|
|
Design,
|
|
Runtime,
|
|
};
|
|
private RunMode _runMode = RunMode.Unknown;
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.DesignMode"]/*' />
|
|
[
|
|
Browsable(false),
|
|
Bindable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
EditorBrowsable(EditorBrowsableState.Never),
|
|
]
|
|
public new bool DesignMode
|
|
{
|
|
get
|
|
{
|
|
if (_runMode == RunMode.Unknown)
|
|
{
|
|
_runMode = RunMode.Runtime;
|
|
try
|
|
{
|
|
_runMode = (HttpContext.Current == null) ? RunMode.Design : RunMode.Runtime;
|
|
}
|
|
catch
|
|
{
|
|
_runMode = RunMode.Design;
|
|
}
|
|
}
|
|
return _runMode == RunMode.Design;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.Adapter"]/*' />
|
|
[
|
|
Browsable(false),
|
|
Bindable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
]
|
|
public new IPageAdapter Adapter
|
|
{
|
|
get
|
|
{
|
|
if (_pageAdapter == null)
|
|
{
|
|
IPageAdapter pageAdapter = RequestingDeviceConfig.NewPageAdapter();
|
|
pageAdapter.Page = this;
|
|
_pageAdapter = pageAdapter;
|
|
if(!DesignMode)
|
|
{
|
|
Type t = ControlsConfig.GetFromContext(HttpContext.Current).CookielessDataDictionaryType;
|
|
if(t != null && typeof(IDictionary).IsAssignableFrom(t))
|
|
{
|
|
pageAdapter.CookielessDataDictionary = Activator.CreateInstance(t) as IDictionary;
|
|
pageAdapter.PersistCookielessData = true;
|
|
}
|
|
}
|
|
}
|
|
return _pageAdapter;
|
|
}
|
|
}
|
|
|
|
|
|
private bool _haveIdSeparator;
|
|
private char _idSeparator;
|
|
public override char IdSeparator {
|
|
get {
|
|
if (_haveIdSeparator) {
|
|
return _idSeparator;
|
|
}
|
|
|
|
_haveIdSeparator = true;
|
|
IPageAdapter pageAdapter = Adapter;
|
|
Debug.Assert(pageAdapter != null);
|
|
|
|
// VSWhidbey 280485
|
|
if (pageAdapter is System.Web.UI.MobileControls.Adapters.WmlPageAdapter ||
|
|
pageAdapter is System.Web.UI.MobileControls.Adapters.XhtmlAdapters.XhtmlPageAdapter) {
|
|
_idSeparator = ':';
|
|
}
|
|
else {
|
|
_idSeparator = base.IdSeparator;
|
|
}
|
|
return _idSeparator;
|
|
}
|
|
}
|
|
|
|
String _clientViewStateString;
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.ClientViewState"]/*' />
|
|
[
|
|
Browsable(false),
|
|
Bindable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
]
|
|
public String ClientViewState
|
|
{
|
|
get
|
|
{
|
|
if (_clientViewState == null || _clientViewState.Count == 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
if (_clientViewStateString == null)
|
|
{
|
|
StringWriter writer = new StringWriter(CultureInfo.InvariantCulture);
|
|
StateFormatter.Serialize(writer, _clientViewState);
|
|
_clientViewStateString = writer.ToString();
|
|
}
|
|
|
|
return _clientViewStateString;
|
|
}
|
|
}
|
|
|
|
private BooleanOption _allowCustomAttributes = BooleanOption.NotSet;
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.AllowCustomAttributes"]/*' />
|
|
[
|
|
Browsable(false),
|
|
Bindable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
]
|
|
public bool AllowCustomAttributes
|
|
{
|
|
get
|
|
{
|
|
if (DesignMode)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (_allowCustomAttributes == BooleanOption.NotSet)
|
|
{
|
|
_allowCustomAttributes =
|
|
ControlsConfig.GetFromContext(Context).AllowCustomAttributes ?
|
|
BooleanOption.True : BooleanOption.False;
|
|
}
|
|
return _allowCustomAttributes == BooleanOption.True;
|
|
}
|
|
|
|
set
|
|
{
|
|
_allowCustomAttributes = value ? BooleanOption.True : BooleanOption.False;
|
|
}
|
|
}
|
|
|
|
private void AddClientViewState(String id, Object viewState)
|
|
{
|
|
if (_clientViewState == null)
|
|
{
|
|
_clientViewState = new Hashtable();
|
|
}
|
|
_clientViewState[id] = viewState;
|
|
_clientViewStateString = null;
|
|
}
|
|
|
|
internal void AddClientViewState(MobileControl control, Object viewState)
|
|
{
|
|
AddClientViewState(control.UniqueID, viewState);
|
|
}
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.GetControlAdapter"]/*' />
|
|
public virtual IControlAdapter GetControlAdapter(MobileControl control)
|
|
{
|
|
IControlAdapter adapter = RequestingDeviceConfig.NewControlAdapter(control.GetType ());
|
|
adapter.Control = control;
|
|
return adapter;
|
|
}
|
|
|
|
private IndividualDeviceConfig _deviceConfig = null;
|
|
private IndividualDeviceConfig RequestingDeviceConfig
|
|
{
|
|
get
|
|
{
|
|
if (_deviceConfig == null)
|
|
{
|
|
if (DesignMode)
|
|
{
|
|
_deviceConfig = new DesignerDeviceConfig(DesignerAdapter);
|
|
}
|
|
else
|
|
{
|
|
_deviceConfig =
|
|
ControlsConfig.GetFromContext(Context).GetDeviceConfig(Context);
|
|
}
|
|
}
|
|
return _deviceConfig;
|
|
}
|
|
}
|
|
|
|
private String _appPath;
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.MakePathAbsolute"]/*' />
|
|
public String MakePathAbsolute(String virtualPath)
|
|
{
|
|
if (virtualPath == null || virtualPath.Length == 0)
|
|
{
|
|
return virtualPath;
|
|
}
|
|
|
|
if (!UrlPath.IsRelativeUrl(virtualPath))
|
|
{
|
|
// For consistency with ResolveUrl, do not apply app path modifier to rooted paths.
|
|
//return Response.ApplyAppPathModifier(virtualPath);
|
|
return virtualPath;
|
|
}
|
|
else
|
|
{
|
|
if (_appPath == null)
|
|
{
|
|
String path = Request.CurrentExecutionFilePath;
|
|
path = Response.ApplyAppPathModifier(path);
|
|
int slash = path.LastIndexOf('/');
|
|
if (slash != -1)
|
|
{
|
|
path = path.Substring(0, slash);
|
|
}
|
|
if (path.IndexOf(' ') != -1)
|
|
{
|
|
path = path.Replace(" ", "%20");
|
|
}
|
|
_appPath = path;
|
|
}
|
|
|
|
virtualPath = UrlPath.Combine(_appPath, virtualPath);
|
|
return virtualPath;
|
|
}
|
|
}
|
|
|
|
private String _relativeFilePath;
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.RelativeFilePath"]/*' />
|
|
[
|
|
Browsable(false),
|
|
]
|
|
public String RelativeFilePath
|
|
{
|
|
get
|
|
{
|
|
// Vs7 Property sig will always try to access public properties with get methods no
|
|
// matter Brosable attribute is off or not. We need to check if is DesignMode in
|
|
// order to prevent the exception from vs7 at design time.
|
|
if (DesignMode)
|
|
{
|
|
return String.Empty;
|
|
}
|
|
|
|
if (_relativeFilePath == null)
|
|
{
|
|
String s = Context.Request.CurrentExecutionFilePath;
|
|
String filePath = Context.Request.FilePath;
|
|
if(filePath.Equals(s))
|
|
{
|
|
int slash = s.LastIndexOf('/');
|
|
if (slash >= 0)
|
|
{
|
|
s = s.Substring(slash+1);
|
|
}
|
|
_relativeFilePath = s;
|
|
}
|
|
else
|
|
{
|
|
_relativeFilePath = Server.UrlDecode(UrlPath.MakeRelative(filePath, s));
|
|
}
|
|
}
|
|
return _relativeFilePath;
|
|
}
|
|
}
|
|
|
|
private String _absoluteFilePath;
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.AbsoluteFilePath"]/*' />
|
|
[
|
|
Browsable(false),
|
|
]
|
|
public String AbsoluteFilePath
|
|
{
|
|
get
|
|
{
|
|
// Vs7 Property sig will always try to access public properties with get methods no
|
|
// matter Brosable attribute is off or not. We need to check if Context is null in
|
|
// order to prevent the exception from vs7 at design time.
|
|
if (_absoluteFilePath == null && Context != null)
|
|
{
|
|
_absoluteFilePath = Response.ApplyAppPathModifier(Context.Request.CurrentExecutionFilePath);
|
|
}
|
|
return _absoluteFilePath;
|
|
}
|
|
}
|
|
|
|
private String _uniqueFilePathSuffix;
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.UniqueFilePathSuffix"]/*' />
|
|
[
|
|
Browsable(false),
|
|
]
|
|
public new String UniqueFilePathSuffix
|
|
{
|
|
// Required for browsers that don't properly handle
|
|
// self-referential form posts.
|
|
|
|
get
|
|
{
|
|
if (_uniqueFilePathSuffix == null)
|
|
{
|
|
// Only need a few digits, so save space by modulo'ing by a prime.
|
|
// The chosen prime is the highest of six digits.
|
|
long ticks = DateTime.Now.Ticks % 999983;
|
|
_uniqueFilePathSuffix = String.Concat(
|
|
Constants.UniqueFilePathSuffixVariable,
|
|
ticks.ToString("D6", CultureInfo.InvariantCulture));
|
|
}
|
|
return _uniqueFilePathSuffix;
|
|
}
|
|
}
|
|
|
|
private static String RemoveQueryStringElement(String queryStringText, String elementName)
|
|
{
|
|
int n = elementName.Length;
|
|
int i = 0;
|
|
for (i = 0; i < queryStringText.Length;)
|
|
{
|
|
i = queryStringText.IndexOf(elementName, i, StringComparison.Ordinal);
|
|
if (i < 0)
|
|
{
|
|
break;
|
|
}
|
|
if (i == 0 || queryStringText[i-1] == '&')
|
|
{
|
|
if (i+n < queryStringText.Length && queryStringText[i+n] == '=')
|
|
{
|
|
int j = queryStringText.IndexOf('&', i+n);
|
|
if (j < 0)
|
|
{
|
|
if (i == 0)
|
|
{
|
|
queryStringText = String.Empty;
|
|
}
|
|
else
|
|
{
|
|
queryStringText = queryStringText.Substring(0, i-1);
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
queryStringText = queryStringText.Remove(i, j-i+1);
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
i += n;
|
|
}
|
|
return queryStringText;
|
|
}
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.QueryStringText"]/*' />
|
|
[
|
|
Browsable(false),
|
|
]
|
|
public String QueryStringText
|
|
{
|
|
// Returns the query string text, stripping off a unique file path
|
|
// suffix as required. Also assumes that if the suffix is
|
|
// present, the query string part is the text after it.
|
|
|
|
get
|
|
{
|
|
// Vs7 Property sig will always try to access public properties with get methods no
|
|
// matter Brosable attribute is off or not. We need to check if Context is null in
|
|
// order to prevent the exception from vs7 at design time.
|
|
if(DesignMode)
|
|
{
|
|
return String.Empty;
|
|
}
|
|
|
|
String fullQueryString;
|
|
|
|
if (Request.HttpMethod != "POST")
|
|
{
|
|
fullQueryString = CreateQueryStringTextFromCollection(Request.QueryString);
|
|
}
|
|
else if (Device.SupportsQueryStringInFormAction)
|
|
{
|
|
fullQueryString = Request.ServerVariables["QUERY_STRING"];
|
|
}
|
|
else
|
|
{
|
|
fullQueryString = CreateQueryStringTextFromCollection(_requestValueCollection);
|
|
}
|
|
|
|
if(fullQueryString != null && fullQueryString.Length > 0)
|
|
{
|
|
fullQueryString = RemoveQueryStringElement(fullQueryString, Constants.UniqueFilePathSuffixVariableWithoutEqual);
|
|
fullQueryString = RemoveQueryStringElement(fullQueryString, MobileRedirect.QueryStringVariable);
|
|
if (!Adapter.PersistCookielessData)
|
|
{
|
|
fullQueryString = RemoveQueryStringElement(fullQueryString, FormsAuthentication.FormsCookieName);
|
|
}
|
|
}
|
|
return fullQueryString;
|
|
}
|
|
}
|
|
|
|
private String _activeFormID;
|
|
private Form _activeForm;
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.ActiveForm"]/*' />
|
|
[
|
|
Browsable(false),
|
|
Bindable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
]
|
|
public Form ActiveForm
|
|
{
|
|
get
|
|
{
|
|
// retrieve form cached in local variable
|
|
if (_activeForm != null)
|
|
{
|
|
return _activeForm;
|
|
}
|
|
|
|
// else get the id from state and retrieve form
|
|
if (_activeFormID != null)
|
|
{
|
|
_activeForm = GetForm(_activeFormID);
|
|
_activeForm.Activated = true;
|
|
return _activeForm;
|
|
}
|
|
|
|
// else first visit to page, so activate first form
|
|
if (_activeForm == null && Forms.Count > 0)
|
|
{
|
|
_activeForm = (Form)Forms[0];
|
|
if(IsPostBack) {
|
|
_activeForm.Activated = true;
|
|
}
|
|
return _activeForm;
|
|
}
|
|
|
|
if (DesignMode)
|
|
{
|
|
return null;
|
|
}
|
|
else
|
|
{
|
|
throw new Exception(
|
|
SR.GetString(SR.MobilePage_AtLeastOneFormInPage));
|
|
}
|
|
}
|
|
set
|
|
{
|
|
Form oldForm = ActiveForm;
|
|
Form newForm = value;
|
|
|
|
_activeForm = newForm;
|
|
_activeFormID = newForm.UniqueID;
|
|
|
|
if (newForm != oldForm)
|
|
{
|
|
oldForm.FireDeactivate(EventArgs.Empty);
|
|
newForm.FireActivate(EventArgs.Empty);
|
|
|
|
// AUI 5577
|
|
newForm.PaginationStateChanged = true;
|
|
}
|
|
else
|
|
{
|
|
newForm.FireActivate(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.GetForm"]/*' />
|
|
public Form GetForm(String id)
|
|
{
|
|
Form form = FindControl(id) as Form;
|
|
if (form == null)
|
|
{
|
|
throw new ArgumentException(SR.GetString(
|
|
SR.MobilePage_FormNotFound, id));
|
|
}
|
|
return form;
|
|
}
|
|
|
|
|
|
// Perform a "safe" redirect on postback.
|
|
// Abstracts away differences between clients in redirect behavior after a
|
|
// postback. Some clients do a GET to the new URL (treating it as a HTTP 303),
|
|
// others do a POST, with old data. This method ads a query string parameter to
|
|
// the redirection URL, so that the new target page can determine that it's a result
|
|
// of a redirection.
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.RedirectToMobilePage"]/*' />
|
|
public void RedirectToMobilePage(String url)
|
|
{
|
|
RedirectToMobilePage(url, true);
|
|
}
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.RedirectToMobilePage1"]/*' />
|
|
public void RedirectToMobilePage(String url, bool endResponse)
|
|
{
|
|
bool queryStringWritten = url.IndexOf("?", StringComparison.Ordinal) != -1 ? true : false;
|
|
if(Adapter.PersistCookielessData)
|
|
{
|
|
IDictionary dictionary = Adapter.CookielessDataDictionary;
|
|
if(dictionary != null)
|
|
{
|
|
foreach(String name in dictionary.Keys)
|
|
{
|
|
if(queryStringWritten)
|
|
{
|
|
url = String.Concat(url, "&");
|
|
}
|
|
else
|
|
{
|
|
url = String.Concat(url, "?");
|
|
queryStringWritten = true;
|
|
}
|
|
url = String.Concat(url, name + "=" + dictionary[name]);
|
|
}
|
|
}
|
|
}
|
|
Response.Redirect(url, endResponse);
|
|
// MobileRedirect.RedirectToUrl(Context, url, endResponse);
|
|
}
|
|
|
|
// Override Page.Validate to do the validation only for mobile
|
|
// validators that are in the current active form. Other validators in
|
|
// Page.Validators collection like aggregated web validators and mobile
|
|
// validators in other forms shouldn't be checked.
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.Validate"]/*' />
|
|
public override void Validate()
|
|
{
|
|
// We can safely remove other validators from the validator list
|
|
// since they shouldn't be checked.
|
|
for (int i = Validators.Count - 1; i >= 0; i--)
|
|
{
|
|
IValidator validator = Validators[i];
|
|
if (!(validator is BaseValidator) ||
|
|
((BaseValidator) validator).Form != ActiveForm)
|
|
{
|
|
Validators.Remove(validator);
|
|
}
|
|
}
|
|
|
|
base.Validate();
|
|
}
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.VerifyRenderingInServerForm"]/*' />
|
|
[
|
|
EditorBrowsable(EditorBrowsableState.Never),
|
|
]
|
|
public override void VerifyRenderingInServerForm(Control control)
|
|
{
|
|
if (!_isRenderingInForm && !DesignMode)
|
|
{
|
|
throw new Exception(SR.GetString(SR.MobileControl_MustBeInForm,
|
|
control.UniqueID,
|
|
control.GetType().Name));
|
|
}
|
|
}
|
|
|
|
internal void EnterFormRender(Form form)
|
|
{
|
|
_isRenderingInForm = true;
|
|
}
|
|
|
|
internal void ExitFormRender()
|
|
{
|
|
_isRenderingInForm = false;
|
|
}
|
|
|
|
// Override Page.InitOutputCache to add additional VaryByHeader
|
|
// keywords to provide correct caching of page outputs since by
|
|
// default ASP.NET only keys on URL for caching. In the case that
|
|
// different markup devices browse to the same URL, caching key on
|
|
// the URL is not good enough. So in addition to URL, User-Agent
|
|
// header is also added for the key. Also any additional headers can
|
|
// be added by the associated page adapter.
|
|
|
|
private const String UserAgentHeader = "User-Agent";
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.InitOutputCache"]/*' />
|
|
protected override void InitOutputCache(int duration,
|
|
String varyByHeader,
|
|
String varyByCustom,
|
|
OutputCacheLocation location,
|
|
String varyByParam)
|
|
{
|
|
InitOutputCache(duration, null, varyByHeader, varyByCustom, location, varyByParam);
|
|
}
|
|
|
|
protected override void InitOutputCache(int duration,
|
|
String varyByContentEncoding,
|
|
String varyByHeader,
|
|
String varyByCustom,
|
|
OutputCacheLocation location,
|
|
String varyByParam)
|
|
{
|
|
base.InitOutputCache(duration, varyByContentEncoding, varyByHeader, varyByCustom,
|
|
location, varyByParam);
|
|
Response.Cache.SetCacheability(HttpCacheability.ServerAndPrivate);
|
|
Response.Cache.VaryByHeaders[UserAgentHeader] = true;
|
|
|
|
IList headerList = Adapter.CacheVaryByHeaders;
|
|
if (headerList != null)
|
|
{
|
|
foreach (String header in headerList)
|
|
{
|
|
Response.Cache.VaryByHeaders[header] = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
// HIDDEN FORM VARIABLES
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.HasHiddenVariables"]/*' />
|
|
public bool HasHiddenVariables()
|
|
{
|
|
return _hiddenVariables != null;
|
|
}
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.HiddenVariables"]/*' />
|
|
[
|
|
Browsable(false),
|
|
Bindable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
]
|
|
public IDictionary HiddenVariables
|
|
{
|
|
get
|
|
{
|
|
if (_hiddenVariables == null)
|
|
{
|
|
_hiddenVariables = new Hashtable();
|
|
}
|
|
return _hiddenVariables;
|
|
}
|
|
}
|
|
|
|
protected override void OnPreInit(EventArgs e) {
|
|
_afterPreInit = true;
|
|
base.OnPreInit(e);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
// DEVICE-INDEPENDENT POSTBACK
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
// The functionality required here is to trap and handle
|
|
// postback events at the page level (delegating to the adapter),
|
|
// rather than expecting a control to handle it.
|
|
// This has to be done in DeterminePostBackMode, because there isn't
|
|
// anything else overrideable.
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.DeterminePostBackMode"]/*' />
|
|
protected override NameValueCollection DeterminePostBackMode()
|
|
{
|
|
// Ignore the transfer case.
|
|
if (Context.Handler != this)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Let the specific adapter to manipulate the base collection if
|
|
// necessary.
|
|
NameValueCollection collection =
|
|
Adapter.DeterminePostBackMode(Context.Request,
|
|
postEventSourceID,
|
|
postEventArgumentID,
|
|
base.DeterminePostBackMode());
|
|
|
|
// Get hidden variables out of the collection.
|
|
if (collection != null)
|
|
{
|
|
// If the page was posted due to a redirect started by calling
|
|
// RedirectToMobilePage, then ignore the postback. For details,
|
|
// see RedirectToMobilePage method elsewhere in this class.
|
|
|
|
if (Page.Request.QueryString[MobileRedirect.QueryStringVariable] == MobileRedirect.QueryStringValue)
|
|
{
|
|
collection = null;
|
|
}
|
|
else
|
|
{
|
|
int count = collection.Count;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
String key = collection.GetKey(i);
|
|
if (key.StartsWith(HiddenVariablePrefix, StringComparison.Ordinal))
|
|
{
|
|
HiddenVariables[key.Substring(HiddenVariablePrefix.Length)] = collection[i];
|
|
}
|
|
}
|
|
|
|
String eventSource = collection[postEventSourceID];
|
|
if (eventSource != null)
|
|
{
|
|
// Page level event
|
|
RaisePagePostBackEvent(eventSource, collection[postEventArgumentID]);
|
|
_eventSource = eventSource;
|
|
}
|
|
}
|
|
}
|
|
|
|
_requestValueCollection = collection;
|
|
|
|
/* Obsolete.
|
|
// If doing a postback, don't allow redirections.
|
|
|
|
if (collection != null)
|
|
{
|
|
MobileRedirect.DisallowRedirection(Context);
|
|
}
|
|
*/
|
|
|
|
return collection;
|
|
}
|
|
|
|
private void RaisePagePostBackEvent(String eventSource, String eventArgument)
|
|
{
|
|
// Let the adapter handle it.
|
|
Adapter.HandlePagePostBackEvent(eventSource, eventArgument);
|
|
}
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.RaisePostBackEvent"]/*' />
|
|
protected override void RaisePostBackEvent(IPostBackEventHandler sourceControl, String eventArgument)
|
|
{
|
|
if (eventArgument == null && sourceControl is Form)
|
|
{
|
|
// This is really a default event sent by an HTML browser. Try to find
|
|
// the default event handler from the active form, and call it.
|
|
|
|
Form activeForm = ActiveForm;
|
|
if (activeForm != null)
|
|
{
|
|
IPostBackEventHandler defaultHandler = activeForm.DefaultEventHandler;
|
|
if (defaultHandler != null)
|
|
{
|
|
base.RaisePostBackEvent(defaultHandler, null);
|
|
}
|
|
}
|
|
|
|
// Otherwise, eat the event - there's no one to send it to, and the form
|
|
// can't use it.
|
|
}
|
|
else
|
|
{
|
|
base.RaisePostBackEvent(sourceControl, eventArgument);
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
// BEGIN ADAPTER PLUMBING
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.OnInit"]/*' />
|
|
protected override void OnInit(EventArgs e)
|
|
{
|
|
#if ICECAP
|
|
IceCapAPI.StartProfile(IceCapAPI.PROFILE_THREADLEVEL, IceCapAPI.PROFILE_CURRENTID);
|
|
#endif
|
|
OnDeviceCustomize(new EventArgs());
|
|
|
|
// Accessing Request throws exception at designtime
|
|
if(!DesignMode && Request.Headers["__vs_debug"] != null)
|
|
{
|
|
_debugMode = true;
|
|
}
|
|
|
|
// ASP.NET requires the following method to be called to have
|
|
// ViewState calculated for the page.
|
|
RegisterViewStateHandler();
|
|
|
|
Adapter.OnInit(e);
|
|
base.OnInit(e);
|
|
}
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.OnLoad"]/*' />
|
|
protected override void OnLoad(EventArgs e)
|
|
{
|
|
// AUI 865
|
|
|
|
if (_eventSource != null && _eventSource.Length > 0)
|
|
{
|
|
MobileControl control = FindControl (_eventSource) as MobileControl;
|
|
if (control != null && (control is IPostBackEventHandler))
|
|
{
|
|
_activeForm = control.Form;
|
|
_activeForm.Activated = true;
|
|
}
|
|
}
|
|
|
|
Adapter.OnLoad(e);
|
|
base.OnLoad(e);
|
|
|
|
if (!IsPostBack)
|
|
{
|
|
ActiveForm.FireActivate(EventArgs.Empty);
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.OnPreRender"]/*' />
|
|
protected override void OnPreRender(EventArgs e)
|
|
{
|
|
Adapter.OnPreRender(e);
|
|
base.OnPreRender(e);
|
|
}
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.Render"]/*' />
|
|
protected override void Render(HtmlTextWriter writer)
|
|
{
|
|
#if TRACE
|
|
DumpSessionViewState();
|
|
#endif
|
|
|
|
Adapter.Render(writer);
|
|
}
|
|
|
|
#if TRACE
|
|
void DumpSessionViewState()
|
|
{
|
|
ArrayList arr;
|
|
_sessionViewState.Dump(this, out arr);
|
|
StringBuilder sb = new StringBuilder();
|
|
foreach (String s in arr)
|
|
{
|
|
sb.Append(s);
|
|
sb.Append("\r\n");
|
|
}
|
|
Trace.Write("SessionViewState", sb.ToString());
|
|
}
|
|
#endif
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.OnUnload"]/*' />
|
|
protected override void OnUnload(EventArgs e)
|
|
{
|
|
base.OnUnload(e);
|
|
Adapter.OnUnload(e);
|
|
#if ICECAP
|
|
IceCapAPI.StopProfile(IceCapAPI.PROFILE_THREADLEVEL, IceCapAPI.PROFILE_CURRENTID);
|
|
#endif
|
|
}
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.OnDeviceCustomize"]/*' />
|
|
protected virtual void OnDeviceCustomize(EventArgs e)
|
|
{
|
|
}
|
|
|
|
internal bool PrivateViewStateLoaded
|
|
{
|
|
get
|
|
{
|
|
return _privateViewStateLoaded;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.GetPrivateViewState"]/*' />
|
|
public Object GetPrivateViewState(MobileControl ctl)
|
|
{
|
|
return _privateViewState == null ?
|
|
null :
|
|
_privateViewState[ctl.UniqueID];
|
|
}
|
|
|
|
private SessionViewState _sessionViewState = new SessionViewState();
|
|
private static readonly String _controlsRequiringPostBackKey = ".PBC";
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.LoadPageStateFromPersistenceMedium"]/*' />
|
|
protected override Object LoadPageStateFromPersistenceMedium()
|
|
{
|
|
Object state = null;
|
|
|
|
String clientViewStateString = _requestValueCollection[ViewStateID];
|
|
if (clientViewStateString != null)
|
|
{
|
|
try {
|
|
_privateViewState = StateFormatter.Deserialize(clientViewStateString) as Hashtable;
|
|
}
|
|
catch (Exception e) {
|
|
if (IsViewStateException(e)) {
|
|
_privateViewState = null;
|
|
|
|
// DevDiv #461378: Suppress validation errors for cross-page postbacks.
|
|
// This is a much simplified form of the check in Page.LoadPageStateFromPersistenceMedium.
|
|
if (Context != null && TraceEnabled) {
|
|
Trace.Write("aspx.page", "Ignoring page state", e);
|
|
}
|
|
}
|
|
else {
|
|
// we shouldn't ---- this exception; let the app error handler take care of it
|
|
throw;
|
|
}
|
|
}
|
|
|
|
if (_privateViewState != null)
|
|
{
|
|
Pair pair = _privateViewState[PageClientViewStateKey] as Pair;
|
|
if (pair != null)
|
|
{
|
|
_activeFormID = (String) pair.First;
|
|
|
|
Pair id = (Pair) pair.Second;
|
|
if (id != null)
|
|
{
|
|
_sessionViewState.Load(this, id);
|
|
state = _sessionViewState.ViewState;
|
|
if(state == null)
|
|
{
|
|
OnViewStateExpire(EventArgs.Empty);
|
|
}
|
|
else
|
|
{
|
|
Object[] arrState = state as Object[];
|
|
if (arrState != null)
|
|
{
|
|
_privateViewState = (Hashtable) arrState[1];
|
|
state = arrState[0];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
_privateViewState.Remove(PageClientViewStateKey);
|
|
|
|
// If the page had no view state, but had controls requiring postback,
|
|
// this information was saved in client view state.
|
|
|
|
Object controlsRequiringPostBack =
|
|
_privateViewState[_controlsRequiringPostBackKey];
|
|
if (controlsRequiringPostBack != null)
|
|
{
|
|
state = new Pair(null,
|
|
new Triplet(GetTypeHashCode().ToString(CultureInfo.InvariantCulture),
|
|
null,
|
|
controlsRequiringPostBack));
|
|
_privateViewState.Remove(_controlsRequiringPostBackKey);
|
|
}
|
|
|
|
// Apply whatever private view state can be applied now.
|
|
|
|
foreach (DictionaryEntry entry in _privateViewState)
|
|
{
|
|
if (entry.Value != null)
|
|
{
|
|
MobileControl ctl = FindControl((String)entry.Key) as MobileControl;
|
|
if (ctl != null)
|
|
{
|
|
ctl.LoadPrivateViewStateInternal(entry.Value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
_privateViewStateLoaded = true;
|
|
|
|
if (state == null)
|
|
{
|
|
// Give framework back an empty page view state
|
|
state = new Pair(null, new Triplet(GetTypeHashCode().ToString(CultureInfo.InvariantCulture), null, null));
|
|
}
|
|
return state;
|
|
}
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.OnViewStateExpire"]/*' />
|
|
protected virtual void OnViewStateExpire(EventArgs e)
|
|
{
|
|
throw new Exception(SR.GetString(SR.SessionViewState_ExpiredOrCookieless));
|
|
}
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.SavePageStateToPersistenceMedium"]/*' />
|
|
protected override void SavePageStateToPersistenceMedium(Object view)
|
|
{
|
|
Object viewState = null;
|
|
Object privateViewState = null;
|
|
Pair serverViewStateID;
|
|
|
|
SavePrivateViewStateRecursive(this);
|
|
|
|
if (!CheckEmptyViewState(view))
|
|
{
|
|
viewState = view;
|
|
}
|
|
|
|
if (Device.RequiresOutputOptimization &&
|
|
_clientViewState != null &&
|
|
_clientViewState.Count > 0 &&
|
|
EnableViewState)
|
|
{
|
|
// Here we take over the content in _clientViewState. It
|
|
// should be reset to null. Then subsequently any info added
|
|
// will be set to the client accordingly.
|
|
privateViewState = _clientViewState;
|
|
_clientViewState = null;
|
|
_clientViewStateString = null;
|
|
}
|
|
|
|
// Are we being asked to save an empty view state?
|
|
|
|
if (viewState == null && privateViewState == null)
|
|
{
|
|
serverViewStateID = null;
|
|
}
|
|
else
|
|
{
|
|
// Our view state is dependent on session state. So, make sure session
|
|
// state is available.
|
|
|
|
if (!(this is IRequiresSessionState) || (this is IReadOnlySessionState))
|
|
{
|
|
throw new Exception(SR.GetString(SR.MobilePage_RequiresSessionState));
|
|
}
|
|
|
|
_sessionViewState.ViewState = (privateViewState == null) ?
|
|
viewState : new Object[2] { viewState, privateViewState };
|
|
|
|
serverViewStateID = _sessionViewState.Save(this);
|
|
if (Device.PreferredRenderingMime != "text/vnd.wap.wml" && Device["cachesAllResponsesWithExpires"] != "true")
|
|
{
|
|
if (String.Compare(Request.HttpMethod, "GET", StringComparison.OrdinalIgnoreCase) == 0)
|
|
{
|
|
Response.Expires = 0;
|
|
}
|
|
else
|
|
{
|
|
Response.Expires = HttpContext.Current.Session.Timeout;
|
|
}
|
|
}
|
|
}
|
|
|
|
String activeFormID = ActiveForm == Forms[0] ? null : ActiveForm.UniqueID;
|
|
|
|
// Optimize what is written out.
|
|
|
|
if (activeFormID != null || serverViewStateID != null)
|
|
{
|
|
AddClientViewState(PageClientViewStateKey,
|
|
new Pair(activeFormID, serverViewStateID));
|
|
}
|
|
}
|
|
|
|
// NOTE: Make sure this stays in sync with Page.PageRegisteredControlsThatRequirePostBackKey
|
|
private const string PageRegisteredControlsThatRequirePostBackKey = "__ControlsRequirePostBackKey__";
|
|
private bool CheckEmptyViewState(Object viewState)
|
|
{
|
|
Pair pair = viewState as Pair;
|
|
if (pair == null) {
|
|
return false;
|
|
}
|
|
|
|
Pair allViewState = pair.Second as Pair;
|
|
if (allViewState == null || allViewState.Second != null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
IDictionary controlStates = pair.First as IDictionary;
|
|
if (controlStates != null)
|
|
{
|
|
// If the only thing in control is the set of controls
|
|
// requiring postback, then save the information in client-side
|
|
// state instead.
|
|
if (controlStates.Count == 1 &&
|
|
controlStates[PageRegisteredControlsThatRequirePostBackKey] != null) {
|
|
AddClientViewState(_controlsRequiringPostBackKey, controlStates[PageRegisteredControlsThatRequirePostBackKey]);
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private void SavePrivateViewStateRecursive(Control control)
|
|
{
|
|
if (control.HasControls())
|
|
{
|
|
IEnumerator e = control.Controls.GetEnumerator();
|
|
while (e.MoveNext())
|
|
{
|
|
MobileControl c = e.Current as MobileControl;
|
|
if (c != null)
|
|
{
|
|
c.SavePrivateViewStateInternal();
|
|
SavePrivateViewStateRecursive(c);
|
|
}
|
|
else
|
|
{
|
|
SavePrivateViewStateRecursive((Control)e.Current);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.LoadViewState"]/*' />
|
|
protected override void LoadViewState(Object savedState)
|
|
{
|
|
if (savedState != null)
|
|
{
|
|
Object[] state = (Object[])savedState;
|
|
if (state.Length > 0)
|
|
{
|
|
base.LoadViewState(state[0]);
|
|
if (state.Length > 1)
|
|
{
|
|
Adapter.LoadAdapterState(state[1]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.SaveViewState"]/*' />
|
|
protected override Object SaveViewState()
|
|
{
|
|
Object baseState = base.SaveViewState();
|
|
Object adapterState = Adapter.SaveAdapterState();
|
|
if (adapterState == null)
|
|
{
|
|
return (baseState == null) ? null : new Object[1] { baseState };
|
|
}
|
|
else
|
|
{
|
|
return new Object[2] { baseState, adapterState };
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.OnError"]/*' />
|
|
protected override void OnError(EventArgs e)
|
|
{
|
|
// Let the base class deal with it. A user-written error handler
|
|
// may catch and handle it.
|
|
|
|
base.OnError(e);
|
|
|
|
Exception error = Server.GetLastError();
|
|
if (error == null || error is System.Threading.ThreadAbortException)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!_debugMode)
|
|
{
|
|
if(!HttpContext.Current.IsCustomErrorEnabled)
|
|
{
|
|
Response.Clear();
|
|
if (Adapter.HandleError(error, (HtmlTextWriter)CreateHtmlTextWriter(Response.Output)))
|
|
{
|
|
Server.ClearError();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.CreateMarkupTextWriter"]/*' />
|
|
protected override HtmlTextWriter CreateHtmlTextWriter(TextWriter writer)
|
|
{
|
|
HtmlTextWriter htmlwriter = Adapter.CreateTextWriter(writer);
|
|
if (htmlwriter == null)
|
|
{
|
|
htmlwriter = base.CreateHtmlTextWriter(writer);
|
|
}
|
|
return htmlwriter;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
// END ADAPTER PLUMBING
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.AddedControl"]/*' />
|
|
protected override void AddedControl(Control control, int index)
|
|
{
|
|
if (control is Form || control is UserControl)
|
|
{
|
|
_forms = null;
|
|
}
|
|
base.AddedControl(control, index);
|
|
}
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.RemovedControl"]/*' />
|
|
protected override void RemovedControl(Control control)
|
|
{
|
|
if (control is Form || control is UserControl)
|
|
{
|
|
_forms = null;
|
|
}
|
|
base.RemovedControl(control);
|
|
}
|
|
|
|
private byte[] GetMacKeyModifier()
|
|
{
|
|
//NOTE: duplicate of the version in objectstateformatter.cs, keep in sync
|
|
|
|
// Use the page's directory and class name as part of the key (ASURT 64044)
|
|
// We need to make sure that the hash is case insensitive, since the file system
|
|
// is, and strange view state errors could otherwise happen (ASURT 128657)
|
|
|
|
int pageHashCode = StringComparer.InvariantCultureIgnoreCase.GetHashCode(
|
|
TemplateSourceDirectory);
|
|
pageHashCode += StringComparer.InvariantCultureIgnoreCase.GetHashCode(GetType().Name);
|
|
|
|
|
|
byte[] macKeyModifier;
|
|
|
|
if (ViewStateUserKey != null) {
|
|
// Modify the key with the ViewStateUserKey, if any (ASURT 126375)
|
|
int count = Encoding.Unicode.GetByteCount(ViewStateUserKey);
|
|
macKeyModifier = new byte[count + 4];
|
|
Encoding.Unicode.GetBytes(ViewStateUserKey,0, ViewStateUserKey.Length, macKeyModifier, 4);
|
|
}
|
|
else {
|
|
macKeyModifier = new byte[4];
|
|
}
|
|
|
|
macKeyModifier[0] = (byte) pageHashCode;
|
|
macKeyModifier[1] = (byte) (pageHashCode >> 8);
|
|
macKeyModifier[2] = (byte) (pageHashCode >> 16);
|
|
macKeyModifier[3] = (byte) (pageHashCode >> 24);
|
|
|
|
return macKeyModifier;
|
|
}
|
|
|
|
private LosFormatter _stateFormatter;
|
|
private LosFormatter StateFormatter
|
|
{
|
|
get
|
|
{
|
|
if (_stateFormatter == null)
|
|
{
|
|
if(!EnableViewStateMac)
|
|
{
|
|
_stateFormatter = new LosFormatter();
|
|
}
|
|
else
|
|
{
|
|
_stateFormatter = new LosFormatter(true, GetMacKeyModifier());
|
|
}
|
|
}
|
|
return _stateFormatter;
|
|
}
|
|
}
|
|
|
|
private String CreateQueryStringTextFromCollection(
|
|
NameValueCollection collection)
|
|
{
|
|
const String systemPostFieldPrefix = "__";
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
|
|
if (collection == null)
|
|
{
|
|
return String.Empty;
|
|
}
|
|
|
|
for (int i = 0; i < collection.Count; i++)
|
|
{
|
|
String name = collection.GetKey(i);
|
|
|
|
if (name != null)
|
|
{
|
|
if (name.StartsWith(systemPostFieldPrefix, StringComparison.Ordinal))
|
|
{
|
|
// Remove well-known postback elements
|
|
if (name == ViewStateID ||
|
|
name == postEventSourceID ||
|
|
name == postEventArgumentID ||
|
|
name == Constants.EventSourceID ||
|
|
name == Constants.EventArgumentID ||
|
|
name.StartsWith(HiddenVariablePrefix, StringComparison.Ordinal))
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
String controlId = name;
|
|
if (controlId.EndsWith(".x", StringComparison.Ordinal) ||
|
|
controlId.EndsWith(".y", StringComparison.Ordinal))
|
|
{
|
|
// Remove the .x and .y coordinates if the control is
|
|
// an image button
|
|
controlId = controlId.Substring(0, name.Length - 2);
|
|
}
|
|
|
|
if (FindControl(controlId) != null)
|
|
{
|
|
// Remove control id/value pairs if present
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
AppendParameters(collection, name, stringBuilder);
|
|
}
|
|
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
private void AppendParameters(NameValueCollection sourceCollection,
|
|
String sourceKey,
|
|
StringBuilder stringBuilder)
|
|
{
|
|
String [] values = sourceCollection.GetValues(sourceKey);
|
|
foreach (String value in values)
|
|
{
|
|
if (stringBuilder.Length != 0)
|
|
{
|
|
stringBuilder.Append('&');
|
|
}
|
|
|
|
if (sourceKey == null)
|
|
{
|
|
// name can be null if there is a query name without equal
|
|
// sign appended
|
|
stringBuilder.Append(Server.UrlEncode(value));
|
|
}
|
|
else
|
|
{
|
|
stringBuilder.Append(Server.UrlEncode(sourceKey));
|
|
stringBuilder.Append('=');
|
|
stringBuilder.Append(Server.UrlEncode(value));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobilePage.uex' path='docs/doc[@for="MobilePage.RenderControl"]/*' />
|
|
public override void RenderControl(HtmlTextWriter writer) {
|
|
RenderControl(writer, null); // Use legacy adapter, not V2 adapter.
|
|
}
|
|
|
|
// Similar to the logic in ViewStateException.cs, but we can only check for
|
|
// ViewState exceptions in general, not MAC-specific exceptions.
|
|
private static bool IsViewStateException(Exception e) {
|
|
for (; e != null; e = e.InnerException) {
|
|
if (e is ViewStateException) { return true; }
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
}
|