1488 lines
64 KiB
C#
1488 lines
64 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="ClientScriptManager.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.UI {
|
|
using System;
|
|
using System.ComponentModel;
|
|
using System.ComponentModel.Design;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.Globalization;
|
|
using System.Text;
|
|
using System.Web.Compilation;
|
|
using System.Web.Handlers;
|
|
using System.Web.UI.WebControls;
|
|
using System.Web.Util;
|
|
using ExceptionUtil=System.Web.Util.ExceptionUtil;
|
|
using WebUtil = System.Web.Util;
|
|
using System.Security.Permissions;
|
|
using System.Reflection;
|
|
using System.Runtime.Serialization;
|
|
using System.Collections.Generic;
|
|
using System.Web.Security.Cryptography;
|
|
|
|
// The various types of client API's that can be registered
|
|
internal enum ClientAPIRegisterType {
|
|
WebFormsScript,
|
|
PostBackScript,
|
|
FocusScript,
|
|
ClientScriptBlocks,
|
|
ClientScriptBlocksWithoutTags,
|
|
ClientStartupScripts,
|
|
ClientStartupScriptsWithoutTags,
|
|
OnSubmitStatement,
|
|
ArrayDeclaration,
|
|
HiddenField,
|
|
ExpandoAttribute,
|
|
EventValidation,
|
|
}
|
|
|
|
public sealed class ClientScriptManager {
|
|
private const string IncludeScriptBegin = @"
|
|
<script src=""";
|
|
private const string IncludeScriptEnd = @""" type=""text/javascript""></script>";
|
|
internal const string ClientScriptStart = "\r\n<script type=\"text/javascript\">\r\n//<![CDATA[\r\n";
|
|
internal const string ClientScriptStartLegacy = "\r\n<script type=\"text/javascript\">\r\n<!--\r\n";
|
|
internal const string ClientScriptEnd = "//]]>\r\n</script>\r\n";
|
|
internal const string ClientScriptEndLegacy = "// -->\r\n</script>\r\n";
|
|
internal const string JscriptPrefix = "javascript:";
|
|
|
|
private const string _callbackFunctionName = "WebForm_DoCallback";
|
|
private const string _postbackOptionsFunctionName = "WebForm_DoPostBackWithOptions";
|
|
private const string _postBackFunctionName = "__doPostBack";
|
|
private const string PageCallbackScriptKey = "PageCallbackScript";
|
|
|
|
internal static IScriptResourceMapping _scriptResourceMapping;
|
|
|
|
private ListDictionary _registeredClientScriptBlocks;
|
|
private ArrayList _clientScriptBlocks;
|
|
private ListDictionary _registeredClientStartupScripts;
|
|
private ArrayList _clientStartupScripts;
|
|
private Dictionary<Assembly, Dictionary<String, Object>> _registeredResourcesToSuppress;
|
|
private bool _eventValidationFieldLoaded;
|
|
|
|
private ListDictionary _registeredOnSubmitStatements;
|
|
|
|
private IDictionary _registeredArrayDeclares;
|
|
private ListDictionary _registeredHiddenFields;
|
|
private ListDictionary _registeredControlsWithExpandoAttributes;
|
|
|
|
private IEventValidationProvider _eventValidationProvider;
|
|
|
|
private Page _owner;
|
|
|
|
internal ClientScriptManager(Page owner) {
|
|
_owner = owner;
|
|
}
|
|
|
|
internal bool HasRegisteredHiddenFields {
|
|
get {
|
|
return (_registeredHiddenFields != null && _registeredHiddenFields.Count > 0);
|
|
}
|
|
}
|
|
|
|
internal bool HasSubmitStatements {
|
|
get {
|
|
return (_registeredOnSubmitStatements != null && _registeredOnSubmitStatements.Count > 0);
|
|
}
|
|
}
|
|
|
|
internal Dictionary<Assembly, Dictionary<String, Object>> RegisteredResourcesToSuppress {
|
|
get {
|
|
if (_registeredResourcesToSuppress == null) {
|
|
_registeredResourcesToSuppress = new Dictionary<Assembly, Dictionary<String, Object>>();
|
|
}
|
|
return _registeredResourcesToSuppress;
|
|
}
|
|
}
|
|
|
|
private IEventValidationProvider EventValidationProvider {
|
|
get {
|
|
if (_eventValidationProvider == null) {
|
|
if (AppSettings.UseLegacyEventValidationCompatibility) {
|
|
_eventValidationProvider = new LegacyEventValidationProvider(this);
|
|
}
|
|
else {
|
|
_eventValidationProvider = new DefaultEventValidationProvider(this);
|
|
}
|
|
}
|
|
return _eventValidationProvider;
|
|
}
|
|
}
|
|
|
|
internal string GetEventValidationFieldValue() {
|
|
// Access the _eventValidationProvider field instead of the EventValidationProvider property so that we
|
|
// don't end up instantiating objects if not necessary.
|
|
if (_eventValidationProvider != null) {
|
|
object eventValidationStoreObject = _eventValidationProvider.GetEventValidationStoreObject();
|
|
if (eventValidationStoreObject != null) {
|
|
// Make cryptographically secure
|
|
IStateFormatter2 formatter = _owner.CreateStateFormatter();
|
|
return formatter.Serialize(eventValidationStoreObject, Purpose.WebForms_ClientScriptManager_EventValidation);
|
|
}
|
|
}
|
|
|
|
// If we got here, there was no store data.
|
|
return String.Empty;
|
|
}
|
|
|
|
public void RegisterForEventValidation(PostBackOptions options) {
|
|
RegisterForEventValidation(options.TargetControl.UniqueID, options.Argument);
|
|
}
|
|
|
|
public void RegisterForEventValidation(string uniqueId) {
|
|
RegisterForEventValidation(uniqueId, String.Empty);
|
|
}
|
|
|
|
public void RegisterForEventValidation(string uniqueId, string argument) {
|
|
// Step 1: argument and precondition checks
|
|
if (!_owner.EnableEventValidation || _owner.DesignMode) {
|
|
return;
|
|
}
|
|
|
|
// VSWhidbey 497632. Ignore if uniqueID is empty since the postback won't be valid anyway.
|
|
if (String.IsNullOrEmpty(uniqueId)) {
|
|
return;
|
|
}
|
|
|
|
if ((_owner.ControlState < ControlState.PreRendered) && (!_owner.IsCallback)) {
|
|
throw new InvalidOperationException(
|
|
SR.GetString(SR.ClientScriptManager_RegisterForEventValidation_Too_Early));
|
|
}
|
|
|
|
// Step 2: Add this tuple to the list
|
|
EventValidationProvider.RegisterForEventValidation(uniqueId, argument);
|
|
|
|
// Step 3: If there are any partial caching controls on the stack, forward the call to them
|
|
if (_owner.PartialCachingControlStack != null) {
|
|
foreach (BasePartialCachingControl c in _owner.PartialCachingControlStack) {
|
|
c.RegisterForEventValidation(uniqueId, argument);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void SaveEventValidationField() {
|
|
string fieldValue = GetEventValidationFieldValue();
|
|
if (!String.IsNullOrEmpty(fieldValue)) {
|
|
RegisterHiddenField(Page.EventValidationPrefixID, fieldValue);
|
|
}
|
|
}
|
|
|
|
// Used by unobtrusive javascript validators to verify that a scriptresource mapping for jquery is registered
|
|
internal static void EnsureJqueryRegistered() {
|
|
if (_scriptResourceMapping != null) {
|
|
if (_scriptResourceMapping.GetDefinition("jquery", typeof(Page).Assembly) == null &&
|
|
_scriptResourceMapping.GetDefinition("jquery") == null) {
|
|
throw new InvalidOperationException(SR.GetString(SR.ClientScriptManager_JqueryNotRegistered));
|
|
}
|
|
}
|
|
}
|
|
|
|
private void EnsureEventValidationFieldLoaded() {
|
|
if (_eventValidationFieldLoaded) {
|
|
return;
|
|
}
|
|
|
|
_eventValidationFieldLoaded = true;
|
|
|
|
// Step 1: Read the event validation field
|
|
string unsafeField = null;
|
|
if (_owner.RequestValueCollection != null) {
|
|
unsafeField = _owner.RequestValueCollection[Page.EventValidationPrefixID];
|
|
}
|
|
|
|
if (String.IsNullOrEmpty(unsafeField)) {
|
|
return;
|
|
}
|
|
|
|
// Step 2: Decrypt the event validation field
|
|
IStateFormatter2 formatter = _owner.CreateStateFormatter();
|
|
object eventValidationField = null;
|
|
try {
|
|
eventValidationField = formatter.Deserialize(unsafeField, Purpose.WebForms_ClientScriptManager_EventValidation);
|
|
}
|
|
catch (Exception ex) {
|
|
// DevDiv #461378: Ignore validation errors for cross-page postbacks. Since the ValidateEvent method
|
|
// is most likely on the call stack right now, this will result in an event validation failure rather
|
|
// than a MAC validation failure.
|
|
if (!_owner.ShouldSuppressMacValidationException(ex)) {
|
|
ViewStateException.ThrowViewStateError(ex, unsafeField);
|
|
}
|
|
}
|
|
|
|
// Step 3: Load the event validation field into the appropriate provider
|
|
if (!EventValidationProvider.TryLoadEventValidationField(eventValidationField)) {
|
|
// Something went wrong while loading the incoming event validation object; the
|
|
// most likely cause is that it wasn't submitted with the correct ViewState.
|
|
ViewStateException.ThrowViewStateError(null, unsafeField);
|
|
}
|
|
}
|
|
|
|
public void ValidateEvent(string uniqueId) {
|
|
ValidateEvent(uniqueId, String.Empty);
|
|
}
|
|
|
|
public void ValidateEvent(string uniqueId, string argument) {
|
|
if (!_owner.EnableEventValidation) {
|
|
return;
|
|
}
|
|
|
|
if (String.IsNullOrEmpty(uniqueId)) {
|
|
throw new ArgumentException(SR.GetString(SR.Parameter_NullOrEmpty, "uniqueId"), "uniqueId");
|
|
}
|
|
|
|
EnsureEventValidationFieldLoaded();
|
|
|
|
// Go against the _eventValidationProvider field instead of the EventValidationProvider
|
|
// property to avoid the lazy instantiation code if not necessary.
|
|
if (_eventValidationProvider == null || !_eventValidationProvider.IsValid(uniqueId, argument)) {
|
|
throw new ArgumentException(SR.GetString(SR.ClientScriptManager_InvalidPostBackArgument));
|
|
}
|
|
}
|
|
|
|
internal void ClearHiddenFields() {
|
|
_registeredHiddenFields = null;
|
|
}
|
|
|
|
internal static ScriptKey CreateScriptKey(Type type, string key) {
|
|
return new ScriptKey(type, key);
|
|
}
|
|
|
|
internal static ScriptKey CreateScriptIncludeKey(Type type, string key, bool isResource) {
|
|
return new ScriptKey(type, key, true, isResource);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Enables controls to obtain client-side script function that will cause
|
|
/// (when invoked) an out-of-band callback to the server
|
|
/// </devdoc>
|
|
public string GetCallbackEventReference(Control control, string argument, string clientCallback, string context) {
|
|
return GetCallbackEventReference(control, argument, clientCallback, context, false);
|
|
}
|
|
|
|
public string GetCallbackEventReference(Control control, string argument, string clientCallback, string context, bool useAsync) {
|
|
return GetCallbackEventReference(control, argument, clientCallback, context, null, useAsync);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Enables controls to obtain client-side script function that will cause
|
|
/// (when invoked) an out-of-band callback to the server and allows the user to specify a client-side error callback
|
|
/// </devdoc>
|
|
public string GetCallbackEventReference(Control control, string argument, string clientCallback, string context, string clientErrorCallback, bool useAsync) {
|
|
if (control == null) {
|
|
throw new ArgumentNullException("control");
|
|
}
|
|
if (!(control is ICallbackEventHandler)) {
|
|
throw new InvalidOperationException(SR.GetString(SR.Page_CallBackTargetInvalid, control.UniqueID));
|
|
}
|
|
return GetCallbackEventReference("'" + control.UniqueID + "'", argument, clientCallback, context, clientErrorCallback, useAsync);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Enables controls to obtain client-side script function that will cause
|
|
/// (when invoked) an out-of-band callback to the server and allows the user to specify a client-side error callback
|
|
/// </devdoc>
|
|
public string GetCallbackEventReference(string target, string argument, string clientCallback, string context, string clientErrorCallback, bool useAsync) {
|
|
_owner.RegisterWebFormsScript();
|
|
if (_owner.ClientSupportsJavaScript && (_owner.RequestInternal != null) && _owner.RequestInternal.Browser.SupportsCallback) {
|
|
RegisterStartupScript(typeof(Page), PageCallbackScriptKey, (((_owner.RequestInternal != null) &&
|
|
(String.Equals(_owner.RequestInternal.Url.Scheme, "https", StringComparison.OrdinalIgnoreCase))) ?
|
|
@"
|
|
var callBackFrameUrl='" + Util.QuoteJScriptString(GetWebResourceUrl(typeof(Page), "SmartNav.htm"), false) + @"';
|
|
WebForm_InitCallback();" :
|
|
@"
|
|
WebForm_InitCallback();"), true);
|
|
}
|
|
if (argument == null) {
|
|
argument = "null";
|
|
}
|
|
else if (argument.Length == 0) {
|
|
argument = "\"\"";
|
|
}
|
|
if (context == null) {
|
|
context = "null";
|
|
}
|
|
else if (context.Length == 0) {
|
|
context = "\"\"";
|
|
}
|
|
return _callbackFunctionName +
|
|
"(" +
|
|
target +
|
|
"," +
|
|
argument +
|
|
"," +
|
|
clientCallback +
|
|
"," +
|
|
context +
|
|
"," +
|
|
((clientErrorCallback == null) ? "null" : clientErrorCallback) +
|
|
"," +
|
|
(useAsync ? "true" : "false") +
|
|
")";
|
|
}
|
|
|
|
public string GetPostBackClientHyperlink(Control control, string argument) {
|
|
// We're using escapePercent=true here and false in Page
|
|
// because true in Page would be a breaking change:
|
|
// People may already be encoding percent characters before calling this,
|
|
// and we may double encode it.
|
|
// Our own classes and new code should almost always use the override with escapePercent=true.
|
|
return GetPostBackClientHyperlink(control, argument, true, false);
|
|
}
|
|
|
|
public string GetPostBackClientHyperlink(Control control, string argument, bool registerForEventValidation) {
|
|
// We're using escapePercent=true here and false in Page
|
|
// because true in Page would be a breaking change:
|
|
// People may already be encoding percent characters before calling this,
|
|
// and we may double encode it.
|
|
// Our own classes and new code should almost always use the override with escapePercent=true.
|
|
return GetPostBackClientHyperlink(control, argument, true, registerForEventValidation);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>This returs a string that can be put in client event to post back to the named control</para>
|
|
/// </devdoc>
|
|
internal string GetPostBackClientHyperlink(Control control, string argument, bool escapePercent, bool registerForEventValidation) {
|
|
// Hyperlinks always need the language prefix
|
|
// If used in a hyperlink, the event argument needs to be escaped for % characters
|
|
// which will otherwise be interpreted as escape sequences (VSWhidbey 421874)
|
|
return JscriptPrefix + GetPostBackEventReference(control, argument, escapePercent, registerForEventValidation);
|
|
}
|
|
|
|
public string GetPostBackEventReference(Control control, string argument) {
|
|
return GetPostBackEventReference(control, argument, false, false);
|
|
}
|
|
|
|
public string GetPostBackEventReference(Control control, string argument, bool registerForEventValidation) {
|
|
return GetPostBackEventReference(control, argument, false, registerForEventValidation);
|
|
}
|
|
|
|
/*
|
|
* Enables controls to obtain client-side script function that will cause
|
|
* (when invoked) a server post-back to the form.
|
|
* argument: Parameter that will be passed to control on server
|
|
*/
|
|
/// <devdoc>
|
|
/// <para>Passes a parameter to the control that will do the postback processing on the
|
|
/// server.</para>
|
|
/// </devdoc>
|
|
private string GetPostBackEventReference(Control control, string argument, bool forUrl, bool registerForEventValidation) {
|
|
if (control == null) {
|
|
throw new ArgumentNullException("control");
|
|
}
|
|
|
|
_owner.RegisterPostBackScript();
|
|
|
|
string controlID = control.UniqueID;
|
|
|
|
if (registerForEventValidation) {
|
|
RegisterForEventValidation(controlID, argument);
|
|
}
|
|
|
|
// VSWhidbey 475945
|
|
if (control.EnableLegacyRendering && _owner.IsInOnFormRender &&
|
|
controlID != null && controlID.IndexOf(Control.LEGACY_ID_SEPARATOR) >= 0) {
|
|
|
|
controlID = controlID.Replace(Control.LEGACY_ID_SEPARATOR, Control.ID_SEPARATOR);
|
|
}
|
|
|
|
// Split into 2 calls to String.Concat to improve performance.
|
|
// CLR is investigating whether this should be fixed at a lower level.
|
|
string postBackEventReference = _postBackFunctionName + "('" + controlID + "','";
|
|
// The argument needs to be quoted, in case in contains characters that
|
|
// can't be used in JScript strings (ASURT 71818).
|
|
postBackEventReference += Util.QuoteJScriptString(argument, forUrl) + "')";
|
|
|
|
return postBackEventReference;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Passes a parameter to the control that will do the postback processing on the
|
|
/// server.</para>
|
|
/// </devdoc>
|
|
public string GetPostBackEventReference(PostBackOptions options) {
|
|
return GetPostBackEventReference(options, false);
|
|
}
|
|
|
|
public string GetPostBackEventReference(PostBackOptions options, bool registerForEventValidation) {
|
|
if (options == null) {
|
|
throw new ArgumentNullException("options");
|
|
}
|
|
|
|
if (registerForEventValidation) {
|
|
RegisterForEventValidation(options);
|
|
}
|
|
|
|
StringBuilder builder = new StringBuilder();
|
|
bool shouldRenderPostBackReferenceString = false;
|
|
|
|
if (options.RequiresJavaScriptProtocol) {
|
|
builder.Append(JscriptPrefix);
|
|
}
|
|
|
|
if (options.AutoPostBack) {
|
|
builder.Append("setTimeout('");
|
|
}
|
|
|
|
// Use the old __doPostBack method if not using other postback features.
|
|
if (!options.PerformValidation && !options.TrackFocus && options.ClientSubmit &&
|
|
string.IsNullOrEmpty(options.ActionUrl)) {
|
|
string postbackRef = GetPostBackEventReference(options.TargetControl, options.Argument);
|
|
|
|
// Need to quote the string if auto posting back
|
|
if (options.AutoPostBack) {
|
|
builder.Append(Util.QuoteJScriptString(postbackRef));
|
|
builder.Append("', 0)");
|
|
}
|
|
else {
|
|
builder.Append(postbackRef);
|
|
}
|
|
|
|
return builder.ToString();
|
|
}
|
|
|
|
builder.Append(_postbackOptionsFunctionName);
|
|
builder.Append("(new WebForm_PostBackOptions(\"");
|
|
builder.Append(options.TargetControl.UniqueID);
|
|
builder.Append("\", ");
|
|
|
|
if (String.IsNullOrEmpty(options.Argument)) {
|
|
builder.Append("\"\", ");
|
|
}
|
|
else {
|
|
builder.Append("\"");
|
|
builder.Append(Util.QuoteJScriptString(options.Argument));
|
|
builder.Append("\", ");
|
|
}
|
|
|
|
if (options.PerformValidation) {
|
|
shouldRenderPostBackReferenceString = true;
|
|
builder.Append("true, ");
|
|
}
|
|
else {
|
|
builder.Append("false, ");
|
|
}
|
|
|
|
if (options.ValidationGroup != null && options.ValidationGroup.Length > 0) {
|
|
shouldRenderPostBackReferenceString = true;
|
|
|
|
builder.Append("\"");
|
|
builder.Append(options.ValidationGroup);
|
|
builder.Append("\", ");
|
|
}
|
|
else {
|
|
builder.Append("\"\", ");
|
|
}
|
|
|
|
if (options.ActionUrl != null && options.ActionUrl.Length > 0) {
|
|
shouldRenderPostBackReferenceString = true;
|
|
_owner.ContainsCrossPagePost = true;
|
|
|
|
builder.Append("\"");
|
|
builder.Append(Util.QuoteJScriptString(options.ActionUrl));
|
|
builder.Append("\", ");
|
|
}
|
|
else {
|
|
builder.Append("\"\", ");
|
|
}
|
|
|
|
if (options.TrackFocus) {
|
|
_owner.RegisterFocusScript();
|
|
shouldRenderPostBackReferenceString = true;
|
|
builder.Append("true, ");
|
|
}
|
|
else {
|
|
builder.Append("false, ");
|
|
}
|
|
|
|
if (options.ClientSubmit) {
|
|
shouldRenderPostBackReferenceString = true;
|
|
_owner.RegisterPostBackScript();
|
|
|
|
builder.Append("true))");
|
|
}
|
|
else {
|
|
builder.Append("false))");
|
|
}
|
|
|
|
if (options.AutoPostBack) {
|
|
builder.Append("', 0)");
|
|
}
|
|
|
|
string reference = null;
|
|
if (shouldRenderPostBackReferenceString) {
|
|
reference = builder.ToString();
|
|
_owner.RegisterWebFormsScript();
|
|
}
|
|
|
|
return reference;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Gets a URL resource reference to a client-side resource
|
|
/// </devdoc>
|
|
public string GetWebResourceUrl(Type type, string resourceName) {
|
|
return GetWebResourceUrl(_owner, type, resourceName, false,
|
|
(_owner == null ? null : _owner.ScriptManager));
|
|
}
|
|
|
|
internal static string GetWebResourceUrl(Page owner, Type type, string resourceName, bool htmlEncoded, IScriptManager scriptManager) {
|
|
bool enableCdn = scriptManager != null && scriptManager.EnableCdn;
|
|
return GetWebResourceUrl(owner, type, resourceName, htmlEncoded, scriptManager, enableCdn);
|
|
}
|
|
|
|
internal static string GetWebResourceUrl(Page owner, Type type, string resourceName, bool htmlEncoded, IScriptManager scriptManager, bool enableCdn) {
|
|
if (type == null) {
|
|
throw new ArgumentNullException("type");
|
|
}
|
|
|
|
if (String.IsNullOrEmpty(resourceName)) {
|
|
throw new ArgumentNullException("resourceName");
|
|
}
|
|
|
|
if (owner != null && owner.DesignMode) {
|
|
ISite site = ((IComponent)owner).Site;
|
|
if (site != null) {
|
|
IResourceUrlGenerator urlGenerator = site.GetService(typeof(IResourceUrlGenerator)) as IResourceUrlGenerator;
|
|
if (urlGenerator != null) {
|
|
return urlGenerator.GetResourceUrl(type, resourceName);
|
|
}
|
|
}
|
|
|
|
return resourceName;
|
|
}
|
|
else {
|
|
return AssemblyResourceLoader.GetWebResourceUrl(type, resourceName, htmlEncoded, scriptManager, enableCdn: enableCdn);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Determines if the client script block is registered with the page.</para>
|
|
/// </devdoc>
|
|
public bool IsClientScriptBlockRegistered(string key) {
|
|
return IsClientScriptBlockRegistered(typeof(Page), key);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Determines if the client script block is registered with the page.</para>
|
|
/// </devdoc>
|
|
public bool IsClientScriptBlockRegistered(Type type, string key) {
|
|
if (type == null) {
|
|
throw new ArgumentNullException("type");
|
|
}
|
|
|
|
return (_registeredClientScriptBlocks != null
|
|
&& (_registeredClientScriptBlocks.Contains(CreateScriptKey(type, key))));
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Determines if the onsubmit script is registered with the page.</para>
|
|
/// </devdoc>
|
|
public bool IsClientScriptIncludeRegistered(string key) {
|
|
return IsClientScriptIncludeRegistered(typeof(Page), key);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Determines if the onsubmit script is registered with the page.</para>
|
|
/// </devdoc>
|
|
public bool IsClientScriptIncludeRegistered(Type type, string key) {
|
|
if (type == null) {
|
|
throw new ArgumentNullException("type");
|
|
}
|
|
|
|
return (_registeredClientScriptBlocks != null
|
|
&& (_registeredClientScriptBlocks.Contains(CreateScriptIncludeKey(type, key, false))));
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Determines if the client startup script is registered with the
|
|
/// page.</para>
|
|
/// </devdoc>
|
|
public bool IsStartupScriptRegistered(string key) {
|
|
return IsStartupScriptRegistered(typeof(Page), key);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Determines if the client startup script is registered with the
|
|
/// page.</para>
|
|
/// </devdoc>
|
|
public bool IsStartupScriptRegistered(Type type, string key) {
|
|
if (type == null) {
|
|
throw new ArgumentNullException("type");
|
|
}
|
|
|
|
return (_registeredClientStartupScripts != null
|
|
&& (_registeredClientStartupScripts.Contains(CreateScriptKey(type, key))));
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Determines if the onsubmit script is registered with the page.</para>
|
|
/// </devdoc>
|
|
public bool IsOnSubmitStatementRegistered(string key) {
|
|
return IsOnSubmitStatementRegistered(typeof(Page), key);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Determines if the onsubmit script is registered with the page.</para>
|
|
/// </devdoc>
|
|
public bool IsOnSubmitStatementRegistered(Type type, string key) {
|
|
if (type == null) {
|
|
throw new ArgumentNullException("type");
|
|
}
|
|
|
|
return (_registeredOnSubmitStatements != null
|
|
&& (_registeredOnSubmitStatements.Contains(CreateScriptKey(type, key))));
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Declares a value that will be declared as a JavaScript array declaration
|
|
/// when the page renders. This can be used by script-based controls to declare
|
|
/// themselves within an array so that a client script library can work with
|
|
/// all the controls of the same type.</para>
|
|
/// </devdoc>
|
|
public void RegisterArrayDeclaration(string arrayName, string arrayValue) {
|
|
if (arrayName == null) {
|
|
throw new ArgumentNullException("arrayName");
|
|
}
|
|
if (_registeredArrayDeclares == null) {
|
|
_registeredArrayDeclares = new ListDictionary();
|
|
}
|
|
if (!_registeredArrayDeclares.Contains(arrayName)) {
|
|
_registeredArrayDeclares[arrayName] = new ArrayList();
|
|
}
|
|
|
|
ArrayList elements = (ArrayList)_registeredArrayDeclares[arrayName];
|
|
elements.Add(arrayValue);
|
|
|
|
// If there are any partial caching controls on the stack, forward the call to them
|
|
if (_owner.PartialCachingControlStack != null) {
|
|
foreach (BasePartialCachingControl c in _owner.PartialCachingControlStack) {
|
|
c.RegisterArrayDeclaration(arrayName, arrayValue);
|
|
}
|
|
}
|
|
}
|
|
|
|
// RegisterArrayDeclaration implementation that supports partial rendering.
|
|
internal void RegisterArrayDeclaration(Control control, string arrayName, string arrayValue) {
|
|
IScriptManager scriptManager = _owner.ScriptManager;
|
|
if ((scriptManager != null) && scriptManager.SupportsPartialRendering) {
|
|
scriptManager.RegisterArrayDeclaration(control, arrayName, arrayValue);
|
|
}
|
|
else {
|
|
RegisterArrayDeclaration(arrayName, arrayValue);
|
|
}
|
|
}
|
|
|
|
public void RegisterExpandoAttribute(string controlId, string attributeName, string attributeValue) {
|
|
RegisterExpandoAttribute(controlId, attributeName, attributeValue, true);
|
|
}
|
|
|
|
public void RegisterExpandoAttribute(string controlId, string attributeName, string attributeValue, bool encode) {
|
|
// check paramters
|
|
WebUtil.StringUtil.CheckAndTrimString(controlId, "controlId");
|
|
WebUtil.StringUtil.CheckAndTrimString(attributeName, "attributeName");
|
|
|
|
ListDictionary expandoAttributes = null;
|
|
if (_registeredControlsWithExpandoAttributes == null) {
|
|
_registeredControlsWithExpandoAttributes = new ListDictionary(StringComparer.Ordinal);
|
|
}
|
|
else {
|
|
expandoAttributes = (ListDictionary)_registeredControlsWithExpandoAttributes[controlId];
|
|
}
|
|
|
|
if (expandoAttributes == null) {
|
|
expandoAttributes = new ListDictionary(StringComparer.Ordinal);
|
|
_registeredControlsWithExpandoAttributes.Add(controlId, expandoAttributes);
|
|
}
|
|
|
|
if (encode) {
|
|
attributeValue = Util.QuoteJScriptString(attributeValue);
|
|
}
|
|
|
|
expandoAttributes.Add(attributeName, attributeValue);
|
|
|
|
// If there are any partial caching controls on the stack, forward the call to them
|
|
if (_owner.PartialCachingControlStack != null) {
|
|
foreach (BasePartialCachingControl c in _owner.PartialCachingControlStack) {
|
|
c.RegisterExpandoAttribute(controlId, attributeName, attributeValue);
|
|
}
|
|
}
|
|
}
|
|
|
|
// RegisterExpandoAttribute implementation that supports partial rendering.
|
|
internal void RegisterExpandoAttribute(Control control, string controlId, string attributeName, string attributeValue, bool encode) {
|
|
IScriptManager scriptManager = _owner.ScriptManager;
|
|
if ((scriptManager != null) && scriptManager.SupportsPartialRendering) {
|
|
scriptManager.RegisterExpandoAttribute(control, controlId, attributeName, attributeValue, encode);
|
|
}
|
|
else {
|
|
RegisterExpandoAttribute(controlId, attributeName, attributeValue, encode);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Allows controls to automatically register a hidden field on the form. The
|
|
/// field will be emitted when the form control renders itself.
|
|
/// </para>
|
|
/// </devdoc>
|
|
public void RegisterHiddenField(string hiddenFieldName,
|
|
string hiddenFieldInitialValue) {
|
|
if (hiddenFieldName == null) {
|
|
throw new ArgumentNullException("hiddenFieldName");
|
|
}
|
|
if (_registeredHiddenFields == null)
|
|
_registeredHiddenFields = new ListDictionary();
|
|
|
|
if (!_registeredHiddenFields.Contains(hiddenFieldName))
|
|
_registeredHiddenFields.Add(hiddenFieldName, hiddenFieldInitialValue);
|
|
if (_owner._hiddenFieldsToRender == null) {
|
|
_owner._hiddenFieldsToRender = new Dictionary<String, String>();
|
|
}
|
|
_owner._hiddenFieldsToRender[hiddenFieldName] = hiddenFieldInitialValue;
|
|
|
|
// If there are any partial caching controls on the stack, forward the call to them
|
|
if (_owner.PartialCachingControlStack != null) {
|
|
foreach (BasePartialCachingControl c in _owner.PartialCachingControlStack) {
|
|
c.RegisterHiddenField(hiddenFieldName, hiddenFieldInitialValue);
|
|
}
|
|
}
|
|
}
|
|
|
|
// RegisterHiddenField implementation that supports partial rendering.
|
|
internal void RegisterHiddenField(Control control, string hiddenFieldName, string hiddenFieldValue) {
|
|
IScriptManager scriptManager = _owner.ScriptManager;
|
|
if ((scriptManager != null) && scriptManager.SupportsPartialRendering) {
|
|
scriptManager.RegisterHiddenField(control, hiddenFieldName, hiddenFieldValue);
|
|
}
|
|
else {
|
|
RegisterHiddenField(hiddenFieldName, hiddenFieldValue);
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Prevents controls from sending duplicate blocks of
|
|
/// client-side script to the client. Any script blocks with the same type and key
|
|
/// values are considered duplicates.</para>
|
|
/// </devdoc>
|
|
public void RegisterClientScriptBlock(Type type, string key, string script) {
|
|
RegisterClientScriptBlock(type, key, script, false);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Prevents controls from sending duplicate blocks of
|
|
/// client-side script to the client. Any script blocks with the same type and key
|
|
/// values are considered duplicates.</para>
|
|
/// </devdoc>
|
|
public void RegisterClientScriptBlock(Type type, string key, string script, bool addScriptTags) {
|
|
if (type == null) {
|
|
throw new ArgumentNullException("type");
|
|
}
|
|
|
|
if (addScriptTags) {
|
|
RegisterScriptBlock(CreateScriptKey(type, key), script, ClientAPIRegisterType.ClientScriptBlocksWithoutTags);
|
|
}
|
|
else {
|
|
RegisterScriptBlock(CreateScriptKey(type, key), script, ClientAPIRegisterType.ClientScriptBlocks);
|
|
}
|
|
}
|
|
|
|
// RegisterClientScriptBlock implementation that supports partial rendering.
|
|
internal void RegisterClientScriptBlock(Control control, Type type, string key, string script, bool addScriptTags) {
|
|
IScriptManager scriptManager = _owner.ScriptManager;
|
|
if ((scriptManager != null) && scriptManager.SupportsPartialRendering) {
|
|
scriptManager.RegisterClientScriptBlock(control, type, key, script, addScriptTags);
|
|
}
|
|
else {
|
|
RegisterClientScriptBlock(type, key, script, addScriptTags);
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para> Prevents controls from sending duplicate blocks of
|
|
/// client-side script to the client. Any script blocks with the same <paramref name="key"/> parameter
|
|
/// values are considered duplicates.</para>
|
|
/// </devdoc>
|
|
public void RegisterClientScriptInclude(string key, string url) {
|
|
RegisterClientScriptInclude(typeof(Page), key, url);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Prevents controls from sending duplicate blocks of
|
|
/// client-side script to the client. Any script blocks with the same type and key
|
|
/// values are considered duplicates.</para>
|
|
/// </devdoc>
|
|
public void RegisterClientScriptInclude(Type type, string key, string url) {
|
|
RegisterClientScriptInclude(type, key, url, false);
|
|
}
|
|
|
|
internal void RegisterClientScriptInclude(Type type, string key, string url, bool isResource) {
|
|
if (type == null) {
|
|
throw new ArgumentNullException("type");
|
|
}
|
|
if (String.IsNullOrEmpty(url)) {
|
|
throw ExceptionUtil.ParameterNullOrEmpty("url");
|
|
}
|
|
|
|
// VSWhidbey 499036: encode the url
|
|
string script = IncludeScriptBegin + HttpUtility.HtmlAttributeEncode(url) + IncludeScriptEnd;
|
|
RegisterScriptBlock(CreateScriptIncludeKey(type, key, isResource), script, ClientAPIRegisterType.ClientScriptBlocks);
|
|
}
|
|
|
|
// RegisterClientScriptInclude implementation that supports partial rendering.
|
|
internal void RegisterClientScriptInclude(Control control, Type type, string key, string url) {
|
|
IScriptManager scriptManager = _owner.ScriptManager;
|
|
if ((scriptManager != null) && scriptManager.SupportsPartialRendering) {
|
|
scriptManager.RegisterClientScriptInclude(control, type, key, url);
|
|
}
|
|
else {
|
|
RegisterClientScriptInclude(type, key, url);
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
public void RegisterClientScriptResource(Type type, string resourceName) {
|
|
if (type == null) {
|
|
throw new ArgumentNullException("type");
|
|
}
|
|
|
|
RegisterClientScriptInclude(type, resourceName, GetWebResourceUrl(type, resourceName), true);
|
|
}
|
|
|
|
// RegisterClientScriptResource implementation that supports partial rendering.
|
|
internal void RegisterClientScriptResource(Control control, Type type, string resourceName) {
|
|
IScriptManager scriptManager = _owner.ScriptManager;
|
|
if ((scriptManager != null) && scriptManager.SupportsPartialRendering) {
|
|
scriptManager.RegisterClientScriptResource(control, type, resourceName);
|
|
}
|
|
else {
|
|
RegisterClientScriptResource(type, resourceName);
|
|
}
|
|
}
|
|
|
|
|
|
internal void RegisterDefaultButtonScript(Control button, HtmlTextWriter writer, bool useAddAttribute) {
|
|
_owner.RegisterWebFormsScript();
|
|
if (_owner.EnableLegacyRendering) {
|
|
if (useAddAttribute) {
|
|
writer.AddAttribute("language", "javascript", false);
|
|
}
|
|
else {
|
|
writer.WriteAttribute("language", "javascript", false);
|
|
}
|
|
}
|
|
string keyPress = "javascript:return WebForm_FireDefaultButton(event, '" + button.ClientID + "')";
|
|
if (useAddAttribute) {
|
|
writer.AddAttribute("onkeypress", keyPress);
|
|
}
|
|
else {
|
|
writer.WriteAttribute("onkeypress", keyPress);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Allows a control to access a the client
|
|
/// <see langword='onsubmit'/> event.
|
|
/// The script should be a function call to client code registered elsewhere.</para>
|
|
/// </devdoc>
|
|
public void RegisterOnSubmitStatement(Type type, string key, string script) {
|
|
if (type == null) {
|
|
throw new ArgumentNullException("type");
|
|
}
|
|
|
|
RegisterOnSubmitStatementInternal(CreateScriptKey(type, key), script);
|
|
}
|
|
|
|
|
|
// RegisterOnSubmitStatement implementation that supports partial rendering.
|
|
internal void RegisterOnSubmitStatement(Control control, Type type, string key, string script) {
|
|
IScriptManager scriptManager = _owner.ScriptManager;
|
|
if ((scriptManager != null) && scriptManager.SupportsPartialRendering) {
|
|
scriptManager.RegisterOnSubmitStatement(control, type, key, script);
|
|
}
|
|
else {
|
|
RegisterOnSubmitStatement(type, key, script);
|
|
}
|
|
}
|
|
|
|
|
|
internal void RegisterOnSubmitStatementInternal(ScriptKey key, string script) {
|
|
if (String.IsNullOrEmpty(script)) {
|
|
throw ExceptionUtil.ParameterNullOrEmpty("script");
|
|
}
|
|
if (_registeredOnSubmitStatements == null)
|
|
_registeredOnSubmitStatements = new ListDictionary();
|
|
|
|
// Make sure the script block ends in a semicolon
|
|
int index = script.Length - 1;
|
|
while ((index >= 0) && Char.IsWhiteSpace(script, index)) {
|
|
index--;
|
|
}
|
|
|
|
if ((index >= 0) && (script[index] != ';')) {
|
|
script = script.Substring(0, index + 1) + ";" + script.Substring(index + 1);
|
|
}
|
|
|
|
if (!_registeredOnSubmitStatements.Contains(key))
|
|
_registeredOnSubmitStatements.Add(key, script);
|
|
|
|
// If there are any partial caching controls on the stack, forward the call to them
|
|
if (_owner.PartialCachingControlStack != null) {
|
|
foreach (BasePartialCachingControl c in _owner.PartialCachingControlStack) {
|
|
c.RegisterOnSubmitStatement(key, script);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void RegisterScriptBlock(ScriptKey key, string script, ClientAPIRegisterType type) {
|
|
|
|
// Call RegisterScriptBlock with the correct collection based on the blockType
|
|
switch (type) {
|
|
case ClientAPIRegisterType.ClientScriptBlocks:
|
|
RegisterScriptBlock(key, script, ref _registeredClientScriptBlocks, ref _clientScriptBlocks, false);
|
|
break;
|
|
case ClientAPIRegisterType.ClientScriptBlocksWithoutTags:
|
|
RegisterScriptBlock(key, script, ref _registeredClientScriptBlocks, ref _clientScriptBlocks, true);
|
|
break;
|
|
case ClientAPIRegisterType.ClientStartupScripts:
|
|
RegisterScriptBlock(key, script, ref _registeredClientStartupScripts, ref _clientStartupScripts, false);
|
|
break;
|
|
case ClientAPIRegisterType.ClientStartupScriptsWithoutTags:
|
|
RegisterScriptBlock(key, script, ref _registeredClientStartupScripts, ref _clientStartupScripts, true);
|
|
break;
|
|
default:
|
|
Debug.Assert(false);
|
|
break;
|
|
}
|
|
|
|
// If there are any partial caching controls on the stack, forward the call to them
|
|
if (_owner.PartialCachingControlStack != null) {
|
|
foreach (BasePartialCachingControl c in _owner.PartialCachingControlStack) {
|
|
c.RegisterScriptBlock(type, key, script);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void RegisterScriptBlock(ScriptKey key, string script, ref ListDictionary scriptBlocks, ref ArrayList scriptList, bool needsScriptTags) {
|
|
if (scriptBlocks == null) {
|
|
scriptBlocks = new ListDictionary();
|
|
scriptList = new ArrayList();
|
|
}
|
|
|
|
if (!scriptBlocks.Contains(key)) {
|
|
Tuple<ScriptKey, String, Boolean> entry = new Tuple<ScriptKey, String, Boolean>(key, script, needsScriptTags);
|
|
scriptBlocks.Add(key, null);
|
|
scriptList.Add(entry);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Allows controls to keep duplicate blocks of client-side script code from
|
|
/// being sent to the client. Any script blocks with the same type and key
|
|
/// value are considered duplicates.
|
|
/// </para>
|
|
/// </devdoc>
|
|
public void RegisterStartupScript(Type type, string key, string script) {
|
|
RegisterStartupScript(type, key, script, false);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Allows controls to keep duplicate blocks of client-side script code from
|
|
/// being sent to the client. Any script blocks with the same type and key
|
|
/// value are considered duplicates.
|
|
/// </para>
|
|
/// </devdoc>
|
|
public void RegisterStartupScript(Type type, string key, string script, bool addScriptTags) {
|
|
if (type == null) {
|
|
throw new ArgumentNullException("type");
|
|
}
|
|
|
|
if (addScriptTags) {
|
|
RegisterScriptBlock(CreateScriptKey(type, key), script, ClientAPIRegisterType.ClientStartupScriptsWithoutTags);
|
|
}
|
|
else {
|
|
RegisterScriptBlock(CreateScriptKey(type, key), script, ClientAPIRegisterType.ClientStartupScripts);
|
|
}
|
|
}
|
|
|
|
// RegisterStartupScript implementation that supports partial rendering.
|
|
internal void RegisterStartupScript(Control control, Type type, string key, string script, bool addScriptTags) {
|
|
IScriptManager scriptManager = _owner.ScriptManager;
|
|
if ((scriptManager != null) && scriptManager.SupportsPartialRendering) {
|
|
scriptManager.RegisterStartupScript(control, type, key, script, addScriptTags);
|
|
}
|
|
else {
|
|
RegisterStartupScript(type, key, script, addScriptTags);
|
|
}
|
|
}
|
|
|
|
|
|
internal void RenderArrayDeclares(HtmlTextWriter writer) {
|
|
if (_registeredArrayDeclares == null || _registeredArrayDeclares.Count == 0) {
|
|
return;
|
|
}
|
|
|
|
writer.Write(_owner.EnableLegacyRendering ? ClientScriptStartLegacy : ClientScriptStart);
|
|
|
|
// Write out each array
|
|
IDictionaryEnumerator arrays = _registeredArrayDeclares.GetEnumerator();
|
|
while (arrays.MoveNext()) {
|
|
// Write the declaration
|
|
writer.Write("var ");
|
|
writer.Write(arrays.Key);
|
|
writer.Write(" = new Array(");
|
|
|
|
// Write each element
|
|
IEnumerator elements = ((ArrayList)arrays.Value).GetEnumerator();
|
|
bool first = true;
|
|
while (elements.MoveNext()) {
|
|
if (first) {
|
|
first = false;
|
|
}
|
|
else {
|
|
writer.Write(", ");
|
|
}
|
|
writer.Write(elements.Current);
|
|
}
|
|
|
|
// Close the declaration
|
|
writer.WriteLine(");");
|
|
}
|
|
|
|
writer.Write(_owner.EnableLegacyRendering ? ClientScriptEndLegacy : ClientScriptEnd);
|
|
}
|
|
|
|
internal void RenderExpandoAttribute(HtmlTextWriter writer) {
|
|
if (_registeredControlsWithExpandoAttributes == null ||
|
|
_registeredControlsWithExpandoAttributes.Count == 0) {
|
|
return;
|
|
}
|
|
|
|
writer.Write(_owner.EnableLegacyRendering ? ClientScriptStartLegacy : ClientScriptStart);
|
|
|
|
foreach (DictionaryEntry controlEntry in _registeredControlsWithExpandoAttributes) {
|
|
string controlId = (string)controlEntry.Key;
|
|
writer.Write("var ");
|
|
writer.Write(controlId);
|
|
writer.Write(" = document.all ? document.all[\"");
|
|
writer.Write(controlId);
|
|
writer.Write("\"] : document.getElementById(\"");
|
|
writer.Write(controlId);
|
|
writer.WriteLine("\");");
|
|
|
|
ListDictionary expandoAttributes = (ListDictionary)controlEntry.Value;
|
|
Debug.Assert(expandoAttributes != null && expandoAttributes.Count > 0);
|
|
foreach (DictionaryEntry expandoAttribute in expandoAttributes) {
|
|
writer.Write(controlId);
|
|
writer.Write(".");
|
|
writer.Write(expandoAttribute.Key);
|
|
if (expandoAttribute.Value == null) {
|
|
// VSWhidbey 382151 Render out null string for nulls
|
|
writer.WriteLine(" = null;");
|
|
}
|
|
else {
|
|
writer.Write(" = \"");
|
|
writer.Write(expandoAttribute.Value);
|
|
writer.WriteLine("\";");
|
|
}
|
|
}
|
|
}
|
|
|
|
writer.Write(_owner.EnableLegacyRendering ? ClientScriptEndLegacy : ClientScriptEnd);
|
|
}
|
|
|
|
internal void RenderHiddenFields(HtmlTextWriter writer) {
|
|
if (_registeredHiddenFields == null || _registeredHiddenFields.Count == 0) {
|
|
return;
|
|
}
|
|
|
|
foreach (DictionaryEntry entry in _registeredHiddenFields) {
|
|
string entryKey = (string)entry.Key;
|
|
if (entryKey == null) {
|
|
entryKey = String.Empty;
|
|
}
|
|
writer.WriteLine();
|
|
writer.Write("<input type=\"hidden\" name=\"");
|
|
writer.Write(entryKey);
|
|
writer.Write("\" id=\"");
|
|
writer.Write(entryKey);
|
|
writer.Write("\" value=\"");
|
|
HttpUtility.HtmlEncode((string)entry.Value, writer);
|
|
writer.Write("\" />");
|
|
}
|
|
|
|
ClearHiddenFields();
|
|
}
|
|
|
|
internal void RenderClientScriptBlocks(HtmlTextWriter writer) {
|
|
bool inScriptBlock = false;
|
|
if (_clientScriptBlocks != null) {
|
|
inScriptBlock = RenderRegisteredScripts(writer, _clientScriptBlocks, true);
|
|
}
|
|
|
|
// Emit the onSubmit function, in necessary
|
|
if (!String.IsNullOrEmpty(_owner.ClientOnSubmitEvent) && _owner.ClientSupportsJavaScript) {
|
|
// If we were already inside a script tag, don't emit a new open script tag
|
|
if (!inScriptBlock) {
|
|
writer.Write(_owner.EnableLegacyRendering ? ClientScriptStartLegacy : ClientScriptStart);
|
|
}
|
|
|
|
writer.Write(@"function WebForm_OnSubmit() {
|
|
");
|
|
if (_registeredOnSubmitStatements != null) {
|
|
foreach (string s in _registeredOnSubmitStatements.Values) {
|
|
writer.Write(s);
|
|
}
|
|
}
|
|
writer.WriteLine(@"
|
|
return true;
|
|
}");
|
|
// We always need to close the script tag
|
|
writer.Write(_owner.EnableLegacyRendering ? ClientScriptEndLegacy : ClientScriptEnd);
|
|
}
|
|
// If there was no onSubmit function, close the script tag if needed
|
|
else if (inScriptBlock) {
|
|
writer.Write(_owner.EnableLegacyRendering ? ClientScriptEndLegacy : ClientScriptEnd);
|
|
}
|
|
}
|
|
|
|
internal void RenderClientStartupScripts(HtmlTextWriter writer) {
|
|
if (_clientStartupScripts != null) {
|
|
bool inScriptBlock = RenderRegisteredScripts(writer, _clientStartupScripts, false);
|
|
// Close the script tag if needed
|
|
if (inScriptBlock) {
|
|
writer.Write(_owner.EnableLegacyRendering ? ClientScriptEndLegacy : ClientScriptEnd);
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool RenderRegisteredScripts(HtmlTextWriter writer, ArrayList scripts, bool checkForScriptManagerRegistrations) {
|
|
writer.WriteLine();
|
|
bool inScriptBlock = false;
|
|
checkForScriptManagerRegistrations &= (_registeredResourcesToSuppress != null);
|
|
// Write out each registered script block
|
|
foreach (Tuple<ScriptKey, String, Boolean> entry in scripts) {
|
|
if (checkForScriptManagerRegistrations) {
|
|
ScriptKey scriptKey = entry.Item1;
|
|
if (scriptKey.IsResource) {
|
|
Dictionary<String, Object> resources;
|
|
if (_registeredResourcesToSuppress.TryGetValue(scriptKey.Assembly, out resources)
|
|
&& resources.ContainsKey(scriptKey.Key)) {
|
|
// this is a suppressed resource
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
if (entry.Item3) {
|
|
if (!inScriptBlock) {
|
|
// If we need script tags and we're not in a script tag, emit a start script tag
|
|
writer.Write(_owner.EnableLegacyRendering ? ClientScriptStartLegacy : ClientScriptStart);
|
|
inScriptBlock = true;
|
|
}
|
|
}
|
|
else if (inScriptBlock) {
|
|
// If we don't need script tags, and we're in a script tag, emit an end script tag
|
|
writer.Write(_owner.EnableLegacyRendering ? ClientScriptEndLegacy : ClientScriptEnd);
|
|
inScriptBlock = false;
|
|
}
|
|
writer.Write(entry.Item2);
|
|
}
|
|
return inScriptBlock;
|
|
}
|
|
|
|
internal void RenderWebFormsScript(HtmlTextWriter writer) {
|
|
const string webFormScript = "WebForms.js";
|
|
if (_registeredResourcesToSuppress != null) {
|
|
Dictionary<String, Object> systemWebResources;
|
|
if (_registeredResourcesToSuppress.TryGetValue(AssemblyResourceLoader.GetAssemblyFromType(typeof(Page)),
|
|
out systemWebResources) &&
|
|
systemWebResources.ContainsKey("WebForms.js")) {
|
|
return;
|
|
}
|
|
}
|
|
writer.Write(IncludeScriptBegin);
|
|
writer.Write(GetWebResourceUrl(_owner, typeof(Page), webFormScript, htmlEncoded: true, scriptManager: _owner.ScriptManager));
|
|
writer.Write(IncludeScriptEnd);
|
|
|
|
// Render the fallback script for WebForm.js
|
|
if (_owner.ScriptManager != null && _owner.ScriptManager.EnableCdn && _owner.ScriptManager.EnableCdnFallback) {
|
|
var localPath = GetWebResourceUrl(_owner, typeof(Page), webFormScript, htmlEncoded: true, scriptManager: _owner.ScriptManager, enableCdn: false);
|
|
if (!String.IsNullOrEmpty(localPath)) {
|
|
writer.Write(ClientScriptStart);
|
|
writer.Write(@"window.WebForm_PostBackOptions||document.write('<script type=""text/javascript"" src=""" + localPath + @"""><\/script>');");
|
|
writer.Write(ClientScriptEnd);
|
|
}
|
|
}
|
|
writer.WriteLine();
|
|
}
|
|
|
|
private interface IEventValidationProvider {
|
|
// Gets an object that - when serialized and encrypted - is the outbound __EVENTVALIDATION field value.
|
|
object GetEventValidationStoreObject();
|
|
|
|
// Returns a value denoting whether this (uniqueId, argument) tuple is valid for the current postback.
|
|
bool IsValid(string uniqueId, string argument);
|
|
|
|
// Registers the tuple (uniqueId, argument) as a valid event for the next postback.
|
|
void RegisterForEventValidation(string uniqueId, string argument);
|
|
|
|
// Given the deserialized form of an incoming __EVENTVALIDATION field, tries to load the valid
|
|
// event references for this postback. Returns true on success, false on failure.
|
|
bool TryLoadEventValidationField(object eventValidationField);
|
|
}
|
|
|
|
// provides a more secure implementation of event validation (fix for DevDiv #233564)
|
|
private sealed class DefaultEventValidationProvider : IEventValidationProvider {
|
|
private readonly ClientScriptManager _clientScriptManager;
|
|
private EventValidationStore _inboundEvents; // events which are valid for the current postback
|
|
private EventValidationStore _outboundEvents; // events which will be valid on the next postback
|
|
|
|
internal DefaultEventValidationProvider(ClientScriptManager clientScriptManager) {
|
|
_clientScriptManager = clientScriptManager;
|
|
}
|
|
|
|
public object GetEventValidationStoreObject() {
|
|
// We only produce the object to be serialized if there is data in the store
|
|
if (_outboundEvents != null && _outboundEvents.Count > 0) {
|
|
return _outboundEvents;
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public bool IsValid(string uniqueId, string argument) {
|
|
return _inboundEvents != null && _inboundEvents.Contains(uniqueId, argument);
|
|
}
|
|
|
|
public void RegisterForEventValidation(string uniqueId, string argument) {
|
|
if (_outboundEvents == null) {
|
|
if (_clientScriptManager._owner.IsCallback) {
|
|
_clientScriptManager.EnsureEventValidationFieldLoaded();
|
|
|
|
// _outboundEvents could have been initialized by the call to EnsureEventValidationFieldLoaded.
|
|
if (_outboundEvents == null) {
|
|
_outboundEvents = new EventValidationStore();
|
|
}
|
|
}
|
|
else {
|
|
// Make a new store object and tie it to the outbound __VIEWSTATE field.
|
|
// (This is the only field which can have a null/empty 'target'.)
|
|
_outboundEvents = new EventValidationStore();
|
|
_outboundEvents.Add(null, _clientScriptManager._owner.ClientState);
|
|
}
|
|
}
|
|
|
|
_outboundEvents.Add(uniqueId, argument);
|
|
}
|
|
|
|
public bool TryLoadEventValidationField(object eventValidationField) {
|
|
EventValidationStore validatedIncomingEvents = eventValidationField as EventValidationStore;
|
|
if (validatedIncomingEvents == null || validatedIncomingEvents.Count < 1) {
|
|
return true; // empty collection is not an error condition
|
|
}
|
|
|
|
Debug.Assert(_outboundEvents == null);
|
|
|
|
string viewStateString = _clientScriptManager._owner.RequestViewStateString;
|
|
if (!validatedIncomingEvents.Contains(null, viewStateString)) {
|
|
return false; // error: this event validation store isn't associated with the incoming __VIEWSTATE
|
|
}
|
|
_inboundEvents = validatedIncomingEvents;
|
|
|
|
if (_clientScriptManager._owner.IsCallback) {
|
|
// Seed the outbound provider with the valid inbound values; clone so that any outbound values
|
|
// added during page processing aren't accidentally treated as valid inbound values.
|
|
EventValidationStore clonedEventValidationStore = validatedIncomingEvents.Clone();
|
|
_outboundEvents = clonedEventValidationStore;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// provides the legacy implementation of event validation (before DevDiv #233564)
|
|
private sealed class LegacyEventValidationProvider : IEventValidationProvider {
|
|
private readonly ClientScriptManager _clientScriptManager;
|
|
private ArrayList _validEventReferences;
|
|
private HybridDictionary _clientPostBackValidatedEventTable;
|
|
|
|
internal LegacyEventValidationProvider(ClientScriptManager clientScriptManager) {
|
|
_clientScriptManager = clientScriptManager;
|
|
}
|
|
|
|
private static int ComputeHashKey(String uniqueId, String argument) {
|
|
if (String.IsNullOrEmpty(argument)) {
|
|
return StringUtil.GetStringHashCode(uniqueId);
|
|
}
|
|
|
|
return StringUtil.GetStringHashCode(uniqueId) ^ StringUtil.GetStringHashCode(argument);
|
|
}
|
|
|
|
public object GetEventValidationStoreObject() {
|
|
// We only produce the object to be serialized if there is data in the store
|
|
if (_validEventReferences != null && _validEventReferences.Count > 0) {
|
|
return _validEventReferences;
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public bool IsValid(string uniqueId, string argument) {
|
|
if (_clientPostBackValidatedEventTable == null) {
|
|
return false;
|
|
}
|
|
|
|
#if DEBUGEVENTVALIDATION
|
|
String hashCode = uniqueId + "@" + argument;
|
|
#else
|
|
int hashCode = ComputeHashKey(uniqueId, argument);
|
|
#endif //DEBUGEVENTVALIDATION
|
|
|
|
return _clientPostBackValidatedEventTable.Contains(hashCode);
|
|
}
|
|
|
|
public void RegisterForEventValidation(string uniqueId, string argument) {
|
|
#if DEBUGEVENTVALIDATION
|
|
string key = uniqueId + "@" + argument;
|
|
#else
|
|
int key = ComputeHashKey(uniqueId, argument);
|
|
#endif //DEBUGEVENTVALIDATION
|
|
|
|
string stateString = _clientScriptManager._owner.ClientState;
|
|
if (stateString == null) {
|
|
stateString = String.Empty;
|
|
}
|
|
|
|
if (_validEventReferences == null) {
|
|
if (_clientScriptManager._owner.IsCallback) {
|
|
_clientScriptManager.EnsureEventValidationFieldLoaded();
|
|
if (_validEventReferences == null) {
|
|
_validEventReferences = new ArrayList();
|
|
}
|
|
}
|
|
else {
|
|
_validEventReferences = new ArrayList();
|
|
_validEventReferences.Add(
|
|
StringUtil.GetStringHashCode(stateString));
|
|
}
|
|
}
|
|
|
|
#if DEBUGEVENTVALIDATION
|
|
Debug.Assert(!_validEventReferences.Contains(key));
|
|
#endif //DEBUGEVENTVALIDATION
|
|
|
|
_validEventReferences.Add(key);
|
|
}
|
|
|
|
public bool TryLoadEventValidationField(object eventValidationField) {
|
|
ArrayList validatedClientEvents = eventValidationField as ArrayList;
|
|
if (validatedClientEvents == null || validatedClientEvents.Count < 1) {
|
|
return true; // empty collection is not an error condition
|
|
}
|
|
|
|
Debug.Assert(_clientPostBackValidatedEventTable == null);
|
|
int viewStateHashCode = (int)validatedClientEvents[0];
|
|
|
|
string viewStateString = _clientScriptManager._owner.RequestViewStateString;
|
|
|
|
if (viewStateHashCode != StringUtil.GetStringHashCode(viewStateString)) {
|
|
return false; // hash mismatch is an error condition
|
|
}
|
|
|
|
_clientPostBackValidatedEventTable = new HybridDictionary(validatedClientEvents.Count - 1, true);
|
|
|
|
// Ignore the first item in the arrayList, which is the controlstate
|
|
for (int index = 1; index < validatedClientEvents.Count; index++) {
|
|
#if DEBUGEVENTVALIDATION
|
|
string hashKey = (string)validatedClientEvents[index];
|
|
#else
|
|
int hashKey = (int)validatedClientEvents[index];
|
|
#endif //DEBUGEVENTVALIDATION
|
|
_clientPostBackValidatedEventTable[hashKey] = null;
|
|
}
|
|
|
|
if (_clientScriptManager._owner.IsCallback) {
|
|
_validEventReferences = validatedClientEvents;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
internal class ScriptKey {
|
|
[NonSerialized]
|
|
private Type _type;
|
|
private string _typeNameForSerialization;
|
|
private string _key;
|
|
private bool _isInclude;
|
|
private bool _isResource;
|
|
|
|
internal ScriptKey(Type type, string key) : this(type, key, false, false) {
|
|
}
|
|
|
|
internal ScriptKey(Type type, string key, bool isInclude, bool isResource) {
|
|
Debug.Assert(type != null);
|
|
_type = type;
|
|
|
|
// To treat nulls the same as empty strings, make them empty string.
|
|
if (key == null) {
|
|
key = String.Empty;
|
|
}
|
|
_key = key;
|
|
_isInclude = isInclude;
|
|
_isResource = isResource;
|
|
}
|
|
|
|
public Assembly Assembly {
|
|
get {
|
|
return _type == null ? null : AssemblyResourceLoader.GetAssemblyFromType(_type);
|
|
}
|
|
}
|
|
|
|
public bool IsResource {
|
|
get {
|
|
return _isResource;
|
|
}
|
|
}
|
|
|
|
public string Key {
|
|
get {
|
|
return _key;
|
|
}
|
|
}
|
|
|
|
public override int GetHashCode() {
|
|
return WebUtil.HashCodeCombiner.CombineHashCodes(_type.GetHashCode(), _key.GetHashCode(),
|
|
_isInclude.GetHashCode());
|
|
}
|
|
|
|
public override bool Equals(object o) {
|
|
ScriptKey key = (ScriptKey)o;
|
|
return (key._type == _type) && (key._key == _key) && (key._isInclude == _isInclude);
|
|
}
|
|
|
|
[OnSerializing()]
|
|
private void OnSerializingMethod(StreamingContext context) {
|
|
// create a string representation of _type
|
|
_typeNameForSerialization = System.Web.UI.Util.GetAssemblyQualifiedTypeName(_type);
|
|
}
|
|
|
|
[OnDeserialized()]
|
|
private void OnDeserializedMethod(StreamingContext context) {
|
|
// re-create _type from its string representation
|
|
_type = BuildManager.GetType(_typeNameForSerialization, true /*throwOnFail*/, false /*ignoreCase*/);
|
|
}
|
|
}
|
|
}
|