mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
721 lines
33 KiB
C#
721 lines
33 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="ScriptRegistrationManager.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
|
|
namespace System.Web.UI {
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Specialized;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using System.Web.Handlers;
|
|
using System.Web.Resources;
|
|
using System.Web.Script.Serialization;
|
|
using System.Web.UI;
|
|
using AppSettings = System.Web.Util.AppSettings;
|
|
|
|
internal sealed class ScriptRegistrationManager {
|
|
private static Regex ScriptTagRegex = new Regex(
|
|
@"<script" +
|
|
@"(" +
|
|
@"\s+(?<attrname>\w[-\w:]*)" + // Attribute name
|
|
@"(" +
|
|
@"\s*=\s*""(?<attrval>[^""]*)""|" + // ="bar" attribute value
|
|
@"\s*=\s*'(?<attrval>[^']*)'" + // ='bar' attribute value
|
|
@")" +
|
|
@")*" +
|
|
@"\s*(?<empty>/)?>",
|
|
RegexOptions.Singleline | RegexOptions.Multiline | RegexOptions.IgnoreCase | RegexOptions.Compiled);
|
|
|
|
private static Dictionary<ScriptKey, string> _fallbackScripts;
|
|
private ScriptManager _scriptManager;
|
|
private List<RegisteredDisposeScript> _scriptDisposes;
|
|
private List<RegisteredArrayDeclaration> _scriptArrays;
|
|
private List<RegisteredScript> _clientScriptBlocks;
|
|
private List<RegisteredScript> _startupScriptBlocks;
|
|
private List<RegisteredHiddenField> _hiddenFields;
|
|
private List<RegisteredExpandoAttribute> _expandos;
|
|
private List<RegisteredScript> _submitStatements;
|
|
|
|
public ScriptRegistrationManager(ScriptManager scriptManager) {
|
|
_scriptManager = scriptManager;
|
|
}
|
|
|
|
public List<RegisteredArrayDeclaration> ScriptArrays {
|
|
get {
|
|
if (_scriptArrays == null) {
|
|
_scriptArrays = new List<RegisteredArrayDeclaration>();
|
|
}
|
|
return _scriptArrays;
|
|
}
|
|
}
|
|
|
|
public List<RegisteredScript> ScriptBlocks {
|
|
get {
|
|
if (_clientScriptBlocks == null) {
|
|
_clientScriptBlocks = new List<RegisteredScript>();
|
|
}
|
|
return _clientScriptBlocks;
|
|
}
|
|
}
|
|
|
|
public List<RegisteredDisposeScript> ScriptDisposes {
|
|
get {
|
|
if (_scriptDisposes == null) {
|
|
_scriptDisposes = new List<RegisteredDisposeScript>();
|
|
}
|
|
return _scriptDisposes;
|
|
}
|
|
}
|
|
|
|
public List<RegisteredExpandoAttribute> ScriptExpandos {
|
|
get {
|
|
if (_expandos == null) {
|
|
_expandos = new List<RegisteredExpandoAttribute>();
|
|
}
|
|
return _expandos;
|
|
}
|
|
}
|
|
|
|
public List<RegisteredHiddenField> ScriptHiddenFields {
|
|
get {
|
|
if (_hiddenFields == null) {
|
|
_hiddenFields = new List<RegisteredHiddenField>();
|
|
}
|
|
return _hiddenFields;
|
|
}
|
|
}
|
|
|
|
public List<RegisteredScript> ScriptStartupBlocks {
|
|
get {
|
|
if (_startupScriptBlocks == null) {
|
|
_startupScriptBlocks = new List<RegisteredScript>();
|
|
}
|
|
return _startupScriptBlocks;
|
|
}
|
|
}
|
|
|
|
public List<RegisteredScript> ScriptSubmitStatements {
|
|
get {
|
|
if (_submitStatements == null) {
|
|
_submitStatements = new List<RegisteredScript>();
|
|
}
|
|
return _submitStatements;
|
|
}
|
|
}
|
|
|
|
private Dictionary<ScriptKey, string> FallbackScripts {
|
|
get {
|
|
if (_fallbackScripts == null) {
|
|
_fallbackScripts = new Dictionary<ScriptKey, string>();
|
|
}
|
|
return _fallbackScripts;
|
|
}
|
|
}
|
|
|
|
private static void CheckScriptTagTweenSpace(RegisteredScript entry, string text, int start, int length) {
|
|
// Check the range between the matches to make sure there is no extraneous content
|
|
string tweenSpace = text.Substring(start, length);
|
|
if (tweenSpace.Trim().Length != 0) {
|
|
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, AtlasWeb.ScriptRegistrationManager_InvalidChars, entry.Type.FullName, entry.Key, tweenSpace));
|
|
}
|
|
}
|
|
|
|
private bool IsControlRegistrationActive(
|
|
List<UpdatePanel> updatingUpdatePanels,
|
|
Control child,
|
|
bool pageAlwaysActive) {
|
|
|
|
// Determines if a registered resource, like a client script block, should be included in the partial
|
|
// update response. It should be included if the owning control is a child of an updating update panel
|
|
// or if the owning control is the Page and this is a type of resource where Page is allowed as an owner.
|
|
// When page is the owner, it means always include the resource regardless of which update panels are
|
|
// updating. Expandos and dispose scripts do not support Page as the owner.
|
|
|
|
// is this a resource that allows Page as the owner, and is the owner the Page?
|
|
if (pageAlwaysActive) {
|
|
Page childAsPage = child as Page;
|
|
if (childAsPage == _scriptManager.Page) {
|
|
// owner is page so the registration is automatically active
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// registration is active if owner is a child of any updating update panels
|
|
if (updatingUpdatePanels != null && updatingUpdatePanels.Count > 0) {
|
|
// navigate up the parent controls and see if any are an updating update panel.
|
|
while (child != null) {
|
|
if (child is UpdatePanel) {
|
|
// enumerate with for loop instead of foreach so we don't recreate an enumerator.
|
|
// enumerate instead of using Contains so we do not have to cast or use a comparer.
|
|
for (int i = 0; i < updatingUpdatePanels.Count; i++) {
|
|
if (child == updatingUpdatePanels[i]) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
child = child.Parent;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static void RegisterArrayDeclaration(Control control, string arrayName, string arrayValue) {
|
|
if (control == null) {
|
|
throw new ArgumentNullException("control");
|
|
}
|
|
if (control.Page == null) {
|
|
throw new ArgumentException(AtlasWeb.ScriptRegistrationManager_ControlNotOnPage, "control");
|
|
}
|
|
|
|
control.Page.ClientScript.RegisterArrayDeclaration(arrayName, arrayValue);
|
|
|
|
ScriptManager sm = ScriptManager.GetCurrent(control.Page);
|
|
if (sm != null) {
|
|
RegisteredArrayDeclaration entry = new RegisteredArrayDeclaration(control, arrayName, arrayValue);
|
|
sm.ScriptRegistration.ScriptArrays.Add(entry);
|
|
}
|
|
}
|
|
|
|
public static void RegisterClientScriptBlock(Control control, Type type, string key, string script, bool addScriptTags) {
|
|
if (control == null) {
|
|
throw new ArgumentNullException("control");
|
|
}
|
|
if (control.Page == null) {
|
|
throw new ArgumentException(AtlasWeb.ScriptRegistrationManager_ControlNotOnPage, "control");
|
|
}
|
|
|
|
control.Page.ClientScript.RegisterClientScriptBlock(type, key, script, addScriptTags);
|
|
|
|
ScriptManager sm = ScriptManager.GetCurrent(control.Page);
|
|
if (sm != null) {
|
|
RegisteredScript entry =
|
|
new RegisteredScript(RegisteredScriptType.ClientScriptBlock,
|
|
control,
|
|
type,
|
|
key,
|
|
script,
|
|
addScriptTags);
|
|
sm.ScriptRegistration.ScriptBlocks.Add(entry);
|
|
}
|
|
}
|
|
|
|
public static void RegisterClientScriptInclude(Control control, Type type, string key, string url) {
|
|
if (control == null) {
|
|
throw new ArgumentNullException("control");
|
|
}
|
|
if (control.Page == null) {
|
|
throw new ArgumentException(AtlasWeb.ScriptRegistrationManager_ControlNotOnPage, "control");
|
|
}
|
|
|
|
control.Page.ClientScript.RegisterClientScriptInclude(type, key, url);
|
|
|
|
ScriptManager sm = ScriptManager.GetCurrent(control.Page);
|
|
if (sm != null) {
|
|
RegisteredScript entry = new RegisteredScript(control, type, key, url);
|
|
sm.ScriptRegistration.ScriptBlocks.Add(entry);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Registers a fallback script that would be rendered as a data item token during Ajax postbacks.
|
|
/// Invoking this method has no effect on non-Ajax postback scenarios.
|
|
/// </summary>
|
|
public static void RegisterFallbackScriptForAjaxPostbacks(Control control, Type type, string key, string fallbackExpression, string fallbackPath) {
|
|
if (control == null) {
|
|
throw new ArgumentNullException("control");
|
|
}
|
|
if (control.Page == null) {
|
|
throw new ArgumentException(AtlasWeb.ScriptRegistrationManager_ControlNotOnPage, "control");
|
|
}
|
|
|
|
ScriptManager sm = ScriptManager.GetCurrent(control.Page);
|
|
if (sm != null) {
|
|
sm.ScriptRegistration.FallbackScripts[new ScriptKey(type, key)] = fallbackPath;
|
|
}
|
|
}
|
|
|
|
public static void RegisterClientScriptResource(Control control, Type type, string resourceName) {
|
|
if (control == null) {
|
|
throw new ArgumentNullException("control");
|
|
}
|
|
if (control.Page == null) {
|
|
throw new ArgumentException(AtlasWeb.ScriptRegistrationManager_ControlNotOnPage, "control");
|
|
}
|
|
if (type == null) {
|
|
throw new ArgumentNullException("type");
|
|
}
|
|
if (String.IsNullOrEmpty(resourceName)) {
|
|
throw new ArgumentNullException("resourceName");
|
|
}
|
|
|
|
ScriptManager sm = ScriptManager.GetCurrent(control.Page);
|
|
if (sm == null) {
|
|
control.Page.ClientScript.RegisterClientScriptResource(type, resourceName);
|
|
}
|
|
else {
|
|
Assembly assembly = AssemblyResourceLoader.GetAssemblyFromType(type);
|
|
ScriptReference script = new ScriptReference {
|
|
Name = resourceName,
|
|
Assembly = assembly.FullName,
|
|
IsDirectRegistration = true,
|
|
ClientUrlResolver = sm
|
|
};
|
|
string resourceUrl = script.GetUrlInternal(sm, sm.Zip);
|
|
control.Page.ClientScript.RegisterClientScriptInclude(type, resourceName, resourceUrl, true);
|
|
RegisteredScript entry = new RegisteredScript(control, type, resourceName, resourceUrl);
|
|
sm.ScriptRegistration.ScriptBlocks.Add(entry);
|
|
}
|
|
}
|
|
|
|
internal void RegisterDispose(Control control, string disposeScript) {
|
|
if (control == null) {
|
|
throw new ArgumentNullException("control");
|
|
}
|
|
if (control.Page == null) {
|
|
throw new ArgumentException(AtlasWeb.ScriptRegistrationManager_ControlNotOnPage, "control");
|
|
}
|
|
if (disposeScript == null) {
|
|
throw new ArgumentNullException("disposeScript");
|
|
}
|
|
|
|
// Locate the parent UpdatePanel of the control
|
|
Control parent = control.Parent;
|
|
UpdatePanel parentUpdatePanel = null;
|
|
while (parent != null) {
|
|
parentUpdatePanel = parent as UpdatePanel;
|
|
if (parentUpdatePanel != null) {
|
|
break;
|
|
}
|
|
parent = parent.Parent;
|
|
}
|
|
if (parentUpdatePanel != null) {
|
|
// During async posts we build up a list of ScriptDisposes. Later
|
|
// we go through the list and filter out ones that aren't inside
|
|
// UpdatePanels that are refreshing.
|
|
// DevDiv Bugs 128123: Build the list on non-async postbacks as well,
|
|
// so that GetRegisteredDisposeScripts returns them.
|
|
RegisteredDisposeScript entry = new RegisteredDisposeScript(control, disposeScript, parentUpdatePanel);
|
|
ScriptDisposes.Add(entry);
|
|
|
|
if (!_scriptManager.IsInAsyncPostBack) {
|
|
// During non-async requests we register script immediately to do the
|
|
// dispose. This is necessary because some controls will register as late
|
|
// as Render(), at which point it would be too late to build up a list
|
|
// for processing later.
|
|
JavaScriptSerializer serializer = new JavaScriptSerializer();
|
|
// 256 seems like a nice number so that we don't have to resize the StringBuilder except in very rare cases
|
|
StringBuilder sb = new StringBuilder(256);
|
|
sb.Append("Sys.WebForms.PageRequestManager.getInstance()._registerDisposeScript(");
|
|
serializer.Serialize(parentUpdatePanel.ClientID, sb);
|
|
sb.Append(", ");
|
|
serializer.Serialize(disposeScript, sb);
|
|
sb.AppendLine(");");
|
|
|
|
// DevDiv Bugs 128123: Register directly with ClientScriptManager so that a RegisteredScript
|
|
// entry is not created. Otherwise, calls to RegisterDispose would result in viewable
|
|
// RegisteredScript entries through GetRegisteredStartupScripts().
|
|
_scriptManager.IPage.ClientScript.RegisterStartupScript(typeof(ScriptRegistrationManager),
|
|
_scriptManager.CreateUniqueScriptKey(),
|
|
sb.ToString(),
|
|
true);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void RegisterExpandoAttribute(Control control, string controlId, string attributeName, string attributeValue, bool encode) {
|
|
if (control == null) {
|
|
throw new ArgumentNullException("control");
|
|
}
|
|
if (control.Page == null) {
|
|
throw new ArgumentException(AtlasWeb.ScriptRegistrationManager_ControlNotOnPage, "control");
|
|
}
|
|
|
|
control.Page.ClientScript.RegisterExpandoAttribute(controlId, attributeName, attributeValue, encode);
|
|
|
|
ScriptManager sm = ScriptManager.GetCurrent(control.Page);
|
|
if (sm != null) {
|
|
RegisteredExpandoAttribute entry =
|
|
new RegisteredExpandoAttribute(control,
|
|
controlId,
|
|
attributeName,
|
|
attributeValue,
|
|
encode);
|
|
sm.ScriptRegistration.ScriptExpandos.Add(entry);
|
|
}
|
|
}
|
|
|
|
public static void RegisterHiddenField(Control control, string hiddenFieldName, string hiddenFieldInitialValue) {
|
|
if (control == null) {
|
|
throw new ArgumentNullException("control");
|
|
}
|
|
if (control.Page == null) {
|
|
throw new ArgumentException(AtlasWeb.ScriptRegistrationManager_ControlNotOnPage, "control");
|
|
}
|
|
|
|
control.Page.ClientScript.RegisterHiddenField(hiddenFieldName, hiddenFieldInitialValue);
|
|
|
|
ScriptManager sm = ScriptManager.GetCurrent(control.Page);
|
|
if (sm != null) {
|
|
RegisteredHiddenField entry =
|
|
new RegisteredHiddenField(control,
|
|
hiddenFieldName,
|
|
hiddenFieldInitialValue);
|
|
sm.ScriptRegistration.ScriptHiddenFields.Add(entry);
|
|
}
|
|
}
|
|
|
|
public static void RegisterOnSubmitStatement(Control control, Type type, string key, string script) {
|
|
if (control == null) {
|
|
throw new ArgumentNullException("control");
|
|
}
|
|
if (control.Page == null) {
|
|
throw new ArgumentException(AtlasWeb.ScriptRegistrationManager_ControlNotOnPage, "control");
|
|
}
|
|
|
|
control.Page.ClientScript.RegisterOnSubmitStatement(type, key, script);
|
|
|
|
ScriptManager sm = ScriptManager.GetCurrent(control.Page);
|
|
if (sm != null) {
|
|
RegisteredScript entry =
|
|
new RegisteredScript(RegisteredScriptType.OnSubmitStatement,
|
|
control,
|
|
type,
|
|
key,
|
|
script,
|
|
false);
|
|
sm.ScriptRegistration.ScriptSubmitStatements.Add(entry);
|
|
}
|
|
}
|
|
|
|
public static void RegisterStartupScript(Control control, Type type, string key, string script, bool addScriptTags) {
|
|
if (control == null) {
|
|
throw new ArgumentNullException("control");
|
|
}
|
|
if (control.Page == null) {
|
|
throw new ArgumentException(AtlasWeb.ScriptRegistrationManager_ControlNotOnPage, "control");
|
|
}
|
|
|
|
control.Page.ClientScript.RegisterStartupScript(type, key, script, addScriptTags);
|
|
|
|
ScriptManager sm = ScriptManager.GetCurrent(control.Page);
|
|
if (sm != null) {
|
|
RegisteredScript entry =
|
|
new RegisteredScript(RegisteredScriptType.ClientStartupScript,
|
|
control,
|
|
type,
|
|
key,
|
|
script,
|
|
addScriptTags);
|
|
sm.ScriptRegistration.ScriptStartupBlocks.Add(entry);
|
|
}
|
|
}
|
|
|
|
public void RenderActiveArrayDeclarations(List<UpdatePanel> updatePanels, HtmlTextWriter writer) {
|
|
Debug.Assert(writer != null, "Should always have a writer");
|
|
List<RegisteredArrayDeclaration> entriesToRender = new List<RegisteredArrayDeclaration>();
|
|
|
|
// For each entry registered in the page, check and see which ones
|
|
// came from controls within UpdatePanels that are going to be updated.
|
|
Control lastControl = null;
|
|
foreach (RegisteredArrayDeclaration entry in ScriptArrays) {
|
|
Control child = entry.Control;
|
|
// if the owning control is the same as the last one that we know was active,
|
|
// no need to check IsControlRegistrationActive
|
|
bool isActive = ((lastControl != null) && (child == lastControl)) ||
|
|
IsControlRegistrationActive(updatePanels, child, true);
|
|
|
|
if (isActive) {
|
|
lastControl = child;
|
|
if (!entriesToRender.Contains(entry)) {
|
|
entriesToRender.Add(entry);
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (RegisteredArrayDeclaration activeRegistration in entriesToRender) {
|
|
PageRequestManager.EncodeString(writer,
|
|
PageRequestManager.ArrayDeclarationToken,
|
|
activeRegistration.Name,
|
|
activeRegistration.Value);
|
|
}
|
|
}
|
|
|
|
public void RenderActiveExpandos(List<UpdatePanel> updatePanels, HtmlTextWriter writer) {
|
|
Debug.Assert(writer != null, "Should always have a writer");
|
|
if (updatePanels == null) {
|
|
return;
|
|
}
|
|
List<RegisteredExpandoAttribute> entriesToRender = new List<RegisteredExpandoAttribute>();
|
|
|
|
// For each entry registered in the page, check and see which ones
|
|
// came from controls within UpdatePanels that are going to be updated.
|
|
Control lastControl = null;
|
|
foreach (RegisteredExpandoAttribute entry in ScriptExpandos) {
|
|
Control child = entry.Control;
|
|
|
|
bool isActive = ((lastControl != null) && (child == lastControl)) ||
|
|
IsControlRegistrationActive(updatePanels, child, false);
|
|
|
|
if (isActive) {
|
|
lastControl = child;
|
|
if (!entriesToRender.Contains(entry)) {
|
|
entriesToRender.Add(entry);
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (RegisteredExpandoAttribute activeRegistration in entriesToRender) {
|
|
string propertyReference = "document.getElementById('" +
|
|
activeRegistration.ControlId + "')['" + activeRegistration.Name + "']";
|
|
string value;
|
|
if (activeRegistration.Encode) {
|
|
value = "\"" + HttpUtility.JavaScriptStringEncode(activeRegistration.Value) + "\"";
|
|
}
|
|
else if (activeRegistration.Value != null) {
|
|
value = "\"" + activeRegistration.Value + "\"";
|
|
}
|
|
else {
|
|
value = "null";
|
|
}
|
|
PageRequestManager.EncodeString(writer, PageRequestManager.ExpandoToken, propertyReference, value);
|
|
}
|
|
}
|
|
|
|
public void RenderActiveHiddenFields(List<UpdatePanel> updatePanels, HtmlTextWriter writer) {
|
|
Debug.Assert(writer != null, "Should always have a writer");
|
|
List<RegisteredHiddenField> entriesToRender = new List<RegisteredHiddenField>();
|
|
ListDictionary uniqueEntries = new ListDictionary(StringComparer.Ordinal);
|
|
|
|
// For each entry registered in the page, check and see which ones
|
|
// came from controls within UpdatePanels that are going to be updated.
|
|
Control lastControl = null;
|
|
foreach (RegisteredHiddenField entry in ScriptHiddenFields) {
|
|
Control child = entry.Control;
|
|
|
|
bool isActive = ((lastControl != null) && (child == lastControl)) ||
|
|
IsControlRegistrationActive(updatePanels, child, true);
|
|
|
|
if (isActive) {
|
|
lastControl = child;
|
|
if (!uniqueEntries.Contains(entry.Name)) {
|
|
entriesToRender.Add(entry);
|
|
uniqueEntries.Add(entry.Name, entry);
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (RegisteredHiddenField activeRegistration in entriesToRender) {
|
|
PageRequestManager.EncodeString(writer,
|
|
PageRequestManager.HiddenFieldToken,
|
|
activeRegistration.Name,
|
|
activeRegistration.InitialValue);
|
|
}
|
|
}
|
|
|
|
private void RenderActiveScriptBlocks(List<UpdatePanel> updatePanels,
|
|
HtmlTextWriter writer,
|
|
string token,
|
|
List<RegisteredScript> scriptRegistrations) {
|
|
|
|
List<RegisteredScript> entriesToRender = new List<RegisteredScript>();
|
|
// no comparer needed because it will contain ScriptKeys which implement Equals
|
|
ListDictionary uniqueEntries = new ListDictionary();
|
|
|
|
// For each entry registered in the page, check and see which ones
|
|
// came from controls within UpdatePanels that are going to be updated.
|
|
Control lastControl = null;
|
|
foreach (RegisteredScript entry in scriptRegistrations) {
|
|
Control child = entry.Control;
|
|
|
|
bool isActive = ((lastControl != null) && (child == lastControl)) ||
|
|
IsControlRegistrationActive(updatePanels, child, true);
|
|
|
|
if (isActive) {
|
|
lastControl = child;
|
|
ScriptKey scriptKey = new ScriptKey(entry.Type, entry.Key);
|
|
if (!uniqueEntries.Contains(scriptKey)) {
|
|
entriesToRender.Add(entry);
|
|
uniqueEntries.Add(scriptKey, entry);
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (RegisteredScript activeRegistration in entriesToRender) {
|
|
if (String.IsNullOrEmpty(activeRegistration.Url)) {
|
|
if (activeRegistration.AddScriptTags) {
|
|
PageRequestManager.EncodeString(writer,
|
|
token,
|
|
"ScriptContentNoTags",
|
|
activeRegistration.Script);
|
|
}
|
|
else {
|
|
WriteScriptWithTags(writer, token, activeRegistration);
|
|
}
|
|
}
|
|
else {
|
|
PageRequestManager.EncodeString(writer,
|
|
token,
|
|
"ScriptPath",
|
|
activeRegistration.Url);
|
|
}
|
|
|
|
string fallbackScriptPath;
|
|
if (_fallbackScripts != null && _fallbackScripts.TryGetValue(new ScriptKey(activeRegistration.Type, activeRegistration.Key), out fallbackScriptPath)) {
|
|
// Only encode the fallback path and not the expression. On the client, we would use the success flag on load / readystatechanged to
|
|
// determine if the script was successfully fetched.
|
|
PageRequestManager.EncodeString(writer,
|
|
"fallbackScript",
|
|
fallbackScriptPath,
|
|
content: null);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void RenderActiveScriptDisposes(List<UpdatePanel> updatePanels, HtmlTextWriter writer) {
|
|
Debug.Assert(writer != null, "Should always have a writer");
|
|
if (updatePanels == null) {
|
|
return;
|
|
}
|
|
|
|
// For each entry registered in the page, check and see which ones
|
|
// came from controls within UpdatePanels that are going to be updated.
|
|
foreach (RegisteredDisposeScript entry in ScriptDisposes) {
|
|
if (IsControlRegistrationActive(updatePanels, entry.ParentUpdatePanel, false)) {
|
|
PageRequestManager.EncodeString(
|
|
writer,
|
|
PageRequestManager.ScriptDisposeToken,
|
|
entry.ParentUpdatePanel.ClientID,
|
|
entry.Script);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void RenderActiveScripts(List<UpdatePanel> updatePanels, HtmlTextWriter writer) {
|
|
Debug.Assert(writer != null, "Should always have a writer");
|
|
// Client script blocks and includes go first
|
|
RenderActiveScriptBlocks(updatePanels,
|
|
writer,
|
|
PageRequestManager.ScriptBlockToken,
|
|
ScriptBlocks);
|
|
|
|
// Startup scripts at end
|
|
RenderActiveScriptBlocks(updatePanels,
|
|
writer,
|
|
PageRequestManager.ScriptStartupBlockToken,
|
|
ScriptStartupBlocks);
|
|
}
|
|
|
|
public void RenderActiveSubmitStatements(List<UpdatePanel> updatePanels, HtmlTextWriter writer) {
|
|
Debug.Assert(writer != null, "Should always have a writer");
|
|
List<RegisteredScript> entriesToRender = new List<RegisteredScript>();
|
|
// no comparer needed because it will contain ScriptKeys which implement Equals
|
|
ListDictionary uniqueEntries = new ListDictionary();
|
|
|
|
// For each entry registered in the page, check and see which ones
|
|
// came from controls within UpdatePanels that are going to be updated.
|
|
Control lastControl = null;
|
|
foreach (RegisteredScript entry in ScriptSubmitStatements) {
|
|
Control child = entry.Control;
|
|
|
|
bool isActive = ((lastControl != null) && (child == lastControl)) ||
|
|
IsControlRegistrationActive(updatePanels, child, true);
|
|
|
|
if (isActive) {
|
|
lastControl = child;
|
|
ScriptKey scriptKey = new ScriptKey(entry.Type, entry.Key);
|
|
if (!uniqueEntries.Contains(scriptKey)) {
|
|
entriesToRender.Add(entry);
|
|
uniqueEntries.Add(scriptKey, entry);
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (RegisteredScript activeRegistration in entriesToRender) {
|
|
PageRequestManager.EncodeString(writer, PageRequestManager.OnSubmitToken, null, activeRegistration.Script);
|
|
}
|
|
}
|
|
|
|
private static void WriteScriptWithTags(HtmlTextWriter writer,
|
|
string token,
|
|
RegisteredScript activeRegistration) {
|
|
|
|
// If the content already has script tags, we need to parse out the contents
|
|
// so that the client doesn't have to. The contents may include more than one
|
|
// script tag, but no other content (such as arbitrary HTML).
|
|
string scriptContent = activeRegistration.Script;
|
|
|
|
int lastIndex = 0;
|
|
for (Match match = ScriptTagRegex.Match(scriptContent, lastIndex); match.Success; match = ScriptTagRegex.Match(scriptContent, lastIndex)) {
|
|
CheckScriptTagTweenSpace(activeRegistration, scriptContent, lastIndex, match.Index - lastIndex);
|
|
|
|
OrderedDictionary attrs = new OrderedDictionary();
|
|
|
|
if (match.Groups["empty"].Captures.Count > 0) {
|
|
// Self-closing tag
|
|
|
|
// No need to do anything since attributes are processed later
|
|
lastIndex = match.Index + match.Length;
|
|
}
|
|
else {
|
|
// Open tag with explicit close tag
|
|
|
|
// Need to find close tag so that we can locate the inner contents
|
|
int indexOfEndOfScriptBeginTag = match.Index + match.Length;
|
|
int indexOfScriptEndTag = scriptContent.IndexOf("</script>", indexOfEndOfScriptBeginTag, StringComparison.OrdinalIgnoreCase);
|
|
if (indexOfScriptEndTag == -1) {
|
|
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, AtlasWeb.ScriptRegistrationManager_NoCloseTag, activeRegistration.Type.FullName, activeRegistration.Key));
|
|
}
|
|
string scriptBlockContents = scriptContent.Substring(indexOfEndOfScriptBeginTag, (indexOfScriptEndTag - indexOfEndOfScriptBeginTag));
|
|
|
|
// Turn the text content into a text attribute
|
|
attrs.Add("text", scriptBlockContents);
|
|
|
|
lastIndex = indexOfScriptEndTag + 9;
|
|
}
|
|
|
|
// Process all the explicit attributes on the script tag
|
|
CaptureCollection attrnames = match.Groups["attrname"].Captures;
|
|
CaptureCollection attrvalues = match.Groups["attrval"].Captures;
|
|
for (int i = 0; i < attrnames.Count; i++) {
|
|
string attribName = attrnames[i].ToString();
|
|
string attribValue = attrvalues[i].ToString();
|
|
|
|
// DevDev Bugs 123213: script elements registered with RegisterStartupScript are normally rendered
|
|
// into the html of the page. Any html encoded values in the attributes are interpreted by the
|
|
// browser, so the actual data is not html encoded. We must HtmlDecode any attribute values we find
|
|
// here to remain consistent during async posts, since the data will be dynamically injected into
|
|
// the dom, bypassing the browser's natural html decoding.
|
|
attribValue = HttpUtility.HtmlDecode(attribValue);
|
|
attrs.Add(attribName, attribValue);
|
|
}
|
|
|
|
// Serialize the attributes to JSON and write them out
|
|
JavaScriptSerializer serializer = new JavaScriptSerializer();
|
|
|
|
// Dev10# 877767 - Allow configurable UpdatePanel script block length
|
|
// The default is JavaScriptSerializer.DefaultMaxJsonLength
|
|
if (AppSettings.UpdatePanelMaxScriptLength > 0) {
|
|
serializer.MaxJsonLength = AppSettings.UpdatePanelMaxScriptLength;
|
|
}
|
|
|
|
string attrText = serializer.Serialize(attrs);
|
|
PageRequestManager.EncodeString(writer, token, "ScriptContentWithTags", attrText);
|
|
}
|
|
|
|
CheckScriptTagTweenSpace(activeRegistration, scriptContent, lastIndex, scriptContent.Length - lastIndex);
|
|
|
|
if (lastIndex == 0) {
|
|
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, AtlasWeb.ScriptRegistrationManager_NoTags, activeRegistration.Type.FullName, activeRegistration.Key));
|
|
}
|
|
}
|
|
}
|
|
}
|