mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-16 17:10:20 -10:00
* System.Web/HttpRequest.cs: implemented CurrentExecutionFilePath. * System.Web.UI/Control.cs: some more tweaks to naming containers stuff. * System.Web.UI/DataBinder.cs: don't throw exception if the container is null. * System.Web.UI/Page.cs: now we can render client scripts, startup scripts and hidden fields. Only render __VIEWSTATE if there is someone that will take care of it. (RaisePostBackEvents): first try the last one that required raise event, then try __EVENTTARGET. * System.Web.UI.HtmlControls/HtmlForm.cs: render 'action' attribute. * System.Web.UI.WebControls/BaseDataList.cs: what can I say for this one? I spent so many time until I finally found this that I'm gonna miss this f....g bug... ;-). Farewell. Now we can get events from image buttons inside Data*. * System.Web.UI.WebControls/DataList.cs: now the value stored in ViewState for item count is correct. svn path=/trunk/mcs/; revision=10627
707 lines
15 KiB
C#
Executable File
707 lines
15 KiB
C#
Executable File
//
|
|
// System.Web.UI.Page
|
|
//
|
|
// Authors:
|
|
// Duncan Mak ([email protected])
|
|
// Gonzalo Paniagua ([email protected])
|
|
//
|
|
// (C) 2002 Ximian, Inc. (http://www.ximian.com)
|
|
//
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.IO;
|
|
using System.Security.Principal;
|
|
using System.Text;
|
|
using System.Web;
|
|
using System.Web.Caching;
|
|
using System.Web.SessionState;
|
|
using System.Web.Util;
|
|
|
|
namespace System.Web.UI
|
|
{
|
|
|
|
public class Page : TemplateControl, IHttpHandler
|
|
{
|
|
private string _culture;
|
|
private bool _viewState = true;
|
|
private bool _viewStateMac = false;
|
|
private string _errorPage;
|
|
private string _ID;
|
|
private bool _isValid;
|
|
private bool _smartNavigation = false;
|
|
private TraceContext _trace;
|
|
private bool _traceEnabled;
|
|
private TraceMode _traceModeValue;
|
|
private int _transactionMode;
|
|
private string _UICulture;
|
|
private HttpContext _context;
|
|
private ValidatorCollection _validators;
|
|
private bool renderingForm;
|
|
private object _savedViewState;
|
|
private ArrayList _requiresPostBack;
|
|
private ArrayList requiresPostDataChanged;
|
|
private IPostBackEventHandler requiresRaiseEvent;
|
|
private NameValueCollection secondPostData;
|
|
private bool requiresPostBackScript = false;
|
|
private bool postBackScriptRendered = false;
|
|
Hashtable clientScriptBlocks;
|
|
Hashtable startupScriptBlocks;
|
|
Hashtable hiddenFields;
|
|
bool handleViewState;
|
|
|
|
protected const string postEventArgumentID = "__EVENTARGUMENT";
|
|
protected const string postEventSourceID = "__EVENTTARGET";
|
|
|
|
#region Constructor
|
|
public Page ()
|
|
{
|
|
Page = this;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Properties
|
|
|
|
public HttpApplicationState Application
|
|
{
|
|
get { return _context.Application; }
|
|
}
|
|
|
|
bool AspCompatMode
|
|
{
|
|
set { throw new NotImplementedException (); }
|
|
}
|
|
|
|
bool Buffer
|
|
{
|
|
set { Response.BufferOutput = value; }
|
|
}
|
|
|
|
public Cache Cache
|
|
{
|
|
get { return _context.Cache; }
|
|
}
|
|
|
|
[MonoTODO]
|
|
public string ClientTarget
|
|
{
|
|
get { throw new NotImplementedException (); }
|
|
set { throw new NotImplementedException (); }
|
|
}
|
|
|
|
[MonoTODO]
|
|
int CodePage
|
|
{
|
|
set { throw new NotImplementedException (); }
|
|
}
|
|
|
|
[MonoTODO]
|
|
string ContentType
|
|
{
|
|
set { throw new NotImplementedException (); }
|
|
}
|
|
|
|
protected override HttpContext Context
|
|
{
|
|
get { return _context; }
|
|
}
|
|
|
|
string Culture
|
|
{
|
|
set { _culture = value; }
|
|
}
|
|
|
|
public override bool EnableViewState
|
|
{
|
|
get { return _viewState; }
|
|
set { _viewState = value; }
|
|
}
|
|
|
|
protected bool EnableViewStateMac
|
|
{
|
|
get { return _viewStateMac; }
|
|
set { _viewStateMac = value; }
|
|
}
|
|
|
|
public string ErrorPage
|
|
{
|
|
get { return _errorPage; }
|
|
set { _errorPage = value; }
|
|
}
|
|
|
|
protected ArrayList FileDependencies
|
|
{
|
|
set {
|
|
if (Response != null)
|
|
Response.AddFileDependencies (value);
|
|
}
|
|
}
|
|
|
|
public override string ID
|
|
{
|
|
get { return _ID; }
|
|
set { _ID = value; }
|
|
}
|
|
|
|
public bool IsPostBack
|
|
{
|
|
get {
|
|
return (0 == String.Compare (Request.HttpMethod, "POST", true));
|
|
}
|
|
}
|
|
|
|
public bool IsReusable {
|
|
get { return false; }
|
|
}
|
|
|
|
public bool IsValid
|
|
{
|
|
get { return _isValid; }
|
|
}
|
|
|
|
[MonoTODO]
|
|
int LCID {
|
|
set { throw new NotImplementedException (); }
|
|
}
|
|
|
|
public HttpRequest Request
|
|
{
|
|
get { return _context.Request; }
|
|
}
|
|
|
|
public HttpResponse Response
|
|
{
|
|
get { return _context.Response; }
|
|
}
|
|
|
|
string ResponseEncoding
|
|
{
|
|
set { Response.ContentEncoding = Encoding.GetEncoding (value); }
|
|
}
|
|
|
|
public HttpServerUtility Server
|
|
{
|
|
get {
|
|
return Context.Server;
|
|
}
|
|
}
|
|
|
|
public virtual HttpSessionState Session
|
|
{
|
|
get { return _context.Session; }
|
|
}
|
|
|
|
public bool SmartNavigation
|
|
{
|
|
get { return _smartNavigation; }
|
|
set { _smartNavigation = value; }
|
|
}
|
|
|
|
public TraceContext Trace
|
|
{
|
|
get { return _trace; }
|
|
}
|
|
|
|
bool TraceEnabled
|
|
{
|
|
set { _traceEnabled = value; }
|
|
}
|
|
|
|
TraceMode TraceModeValue
|
|
{
|
|
set { _traceModeValue = value; }
|
|
}
|
|
|
|
int TransactionMode
|
|
{
|
|
set { _transactionMode = value; }
|
|
}
|
|
|
|
string UICulture
|
|
{
|
|
set { _UICulture = value; }
|
|
}
|
|
|
|
public IPrincipal User
|
|
{
|
|
get { return _context.User; }
|
|
}
|
|
|
|
public ValidatorCollection Validators
|
|
{
|
|
get {
|
|
if (_validators == null)
|
|
_validators = new ValidatorCollection ();
|
|
return _validators;
|
|
}
|
|
}
|
|
|
|
public override bool Visible
|
|
{
|
|
get { return base.Visible; }
|
|
set { base.Visible = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Methods
|
|
|
|
[MonoTODO]
|
|
protected IAsyncResult AspCompatBeginProcessRequest (HttpContext context,
|
|
AsyncCallback cb,
|
|
object extraData)
|
|
{
|
|
throw new NotImplementedException ();
|
|
}
|
|
|
|
[MonoTODO]
|
|
protected void AspcompatEndProcessRequest (IAsyncResult result)
|
|
{
|
|
throw new NotImplementedException ();
|
|
}
|
|
|
|
protected virtual HtmlTextWriter CreateHtmlTextWriter (TextWriter tw)
|
|
{
|
|
return new HtmlTextWriter (tw);
|
|
}
|
|
|
|
[MonoTODO]
|
|
public void DesignerInitialize ()
|
|
{
|
|
throw new NotImplementedException ();
|
|
}
|
|
|
|
protected virtual NameValueCollection DeterminePostBackMode ()
|
|
{
|
|
if (_context == null)
|
|
return null;
|
|
|
|
HttpRequest req = _context.Request;
|
|
if (req == null)
|
|
return null;
|
|
|
|
NameValueCollection coll = null;
|
|
if (IsPostBack)
|
|
coll = req.Form;
|
|
else
|
|
coll = req.QueryString;
|
|
|
|
|
|
if (coll == null || coll ["__VIEWSTATE"] == null)
|
|
return null;
|
|
|
|
return coll;
|
|
}
|
|
|
|
public string GetPostBackClientEvent (Control control, string argument)
|
|
{
|
|
return GetPostBackEventReference (control, argument);
|
|
}
|
|
|
|
public string GetPostBackClientHyperlink (Control control, string argument)
|
|
{
|
|
return "javascript:" + GetPostBackEventReference (control, argument);
|
|
}
|
|
|
|
public string GetPostBackEventReference (Control control)
|
|
{
|
|
return GetPostBackEventReference (control, "");
|
|
}
|
|
|
|
public string GetPostBackEventReference (Control control, string argument)
|
|
{
|
|
RequiresPostBackScript ();
|
|
return String.Format ("__doPostBack ('{0}', '{1}')", control.UniqueID, argument);
|
|
}
|
|
|
|
internal void RequiresPostBackScript ()
|
|
{
|
|
requiresPostBackScript = true;
|
|
}
|
|
|
|
public virtual int GetTypeHashCode ()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
[MonoTODO]
|
|
protected virtual void InitOutputCache (int duration,
|
|
string varyByHeader,
|
|
string varyByCustom,
|
|
OutputCacheLocation location,
|
|
string varyByParam)
|
|
{
|
|
throw new NotImplementedException ();
|
|
}
|
|
|
|
public bool IsClientScriptBlockRegistered (string key)
|
|
{
|
|
if (clientScriptBlocks == null)
|
|
return false;
|
|
|
|
return clientScriptBlocks.ContainsKey (key);
|
|
}
|
|
|
|
public bool IsStartupScriptRegistered (string key)
|
|
{
|
|
if (startupScriptBlocks == null)
|
|
return false;
|
|
|
|
return startupScriptBlocks.ContainsKey (key);
|
|
}
|
|
|
|
public string MapPath (string virtualPath)
|
|
{
|
|
return Request.MapPath (virtualPath);
|
|
}
|
|
|
|
private void RenderPostBackScript (HtmlTextWriter writer, string formUniqueID)
|
|
{
|
|
writer.WriteLine ("<input type=\"hidden\" name=\"{0}\" value=\"\" />", postEventSourceID);
|
|
writer.WriteLine ("<input type=\"hidden\" name=\"{0}\" value=\"\" />", postEventArgumentID);
|
|
writer.WriteLine ();
|
|
writer.WriteLine ("<script language=\"javascript\">");
|
|
writer.WriteLine ("<!--");
|
|
writer.WriteLine ("\tfunction __doPostBack(eventTarget, eventArgument) {");
|
|
writer.WriteLine ("\t\tvar theform = document.{0};", formUniqueID);
|
|
writer.WriteLine ("\t\ttheform.{0}.value = eventTarget;", postEventSourceID);
|
|
writer.WriteLine ("\t\ttheform.{0}.value = eventArgument;", postEventArgumentID);
|
|
writer.WriteLine ("\t\ttheform.submit();");
|
|
writer.WriteLine ("\t}");
|
|
writer.WriteLine ("// -->");
|
|
writer.WriteLine ("</script>");
|
|
}
|
|
|
|
static void WriteScripts (HtmlTextWriter writer, Hashtable scripts)
|
|
{
|
|
if (scripts == null)
|
|
return;
|
|
|
|
foreach (string key in scripts.Values)
|
|
writer.WriteLine (key);
|
|
}
|
|
|
|
void WriteHiddenFields (HtmlTextWriter writer)
|
|
{
|
|
if (hiddenFields == null)
|
|
return;
|
|
|
|
foreach (string key in hiddenFields.Keys) {
|
|
string value = hiddenFields [key] as string;
|
|
writer.WriteLine ("\n<input type=\"hidden\" name=\"{0}\" value=\"{1}\" />", key, value);
|
|
}
|
|
|
|
hiddenFields = null;
|
|
}
|
|
|
|
internal void OnFormRender (HtmlTextWriter writer, string formUniqueID)
|
|
{
|
|
if (renderingForm)
|
|
throw new HttpException ("Only 1 HtmlForm is allowed per page.");
|
|
|
|
renderingForm = true;
|
|
writer.WriteLine ();
|
|
WriteHiddenFields (writer);
|
|
if (requiresPostBackScript) {
|
|
RenderPostBackScript (writer, formUniqueID);
|
|
postBackScriptRendered = true;
|
|
}
|
|
|
|
if (handleViewState) {
|
|
writer.Write ("<input type=\"hidden\" name=\"__VIEWSTATE\" ");
|
|
writer.WriteLine ("value=\"{0}\" />", GetViewStateString ());
|
|
}
|
|
|
|
WriteScripts (writer, clientScriptBlocks);
|
|
}
|
|
|
|
internal string GetViewStateString ()
|
|
{
|
|
StringWriter sr = new StringWriter ();
|
|
LosFormatter fmt = new LosFormatter ();
|
|
fmt.Serialize (sr, _savedViewState);
|
|
return sr.GetStringBuilder ().ToString ();
|
|
}
|
|
|
|
internal void OnFormPostRender (HtmlTextWriter writer, string formUniqueID)
|
|
{
|
|
if (!postBackScriptRendered && requiresPostBackScript)
|
|
RenderPostBackScript (writer, formUniqueID);
|
|
|
|
WriteHiddenFields (writer);
|
|
WriteScripts (writer, startupScriptBlocks);
|
|
renderingForm = false;
|
|
postBackScriptRendered = false;
|
|
}
|
|
|
|
private void ProcessPostData (NameValueCollection data, bool second)
|
|
{
|
|
if (data == null)
|
|
return;
|
|
|
|
Hashtable used = new Hashtable ();
|
|
foreach (string id in data.AllKeys){
|
|
if (id == "__VIEWSTATE" || id == postEventSourceID || id == postEventArgumentID)
|
|
continue;
|
|
|
|
string real_id = id;
|
|
int dot = real_id.IndexOf ('.');
|
|
if (dot >= 1)
|
|
real_id = real_id.Substring (0, dot);
|
|
|
|
if (real_id == null || used.ContainsKey (real_id))
|
|
continue;
|
|
|
|
used.Add (real_id, real_id);
|
|
|
|
Control ctrl = FindControl (real_id);
|
|
if (ctrl != null){
|
|
IPostBackDataHandler pbdh = ctrl as IPostBackDataHandler;
|
|
IPostBackEventHandler pbeh = ctrl as IPostBackEventHandler;
|
|
|
|
if (pbdh == null) {
|
|
if (pbeh != null)
|
|
RegisterRequiresRaiseEvent (pbeh);
|
|
continue;
|
|
}
|
|
|
|
if (pbdh.LoadPostData (real_id, data) == true) {
|
|
if (requiresPostDataChanged == null)
|
|
requiresPostDataChanged = new ArrayList ();
|
|
requiresPostDataChanged.Add (pbdh);
|
|
}
|
|
} else if (!second) {
|
|
if (secondPostData == null)
|
|
secondPostData = new NameValueCollection ();
|
|
secondPostData.Add (real_id, null);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ProcessRequest (HttpContext context)
|
|
{
|
|
_context = context;
|
|
WebTrace.PushContext ("Page.ProcessRequest ()");
|
|
WebTrace.WriteLine ("Entering");
|
|
WireupAutomaticEvents ();
|
|
WebTrace.WriteLine ("Finished hookup");
|
|
//-- Control execution lifecycle in the docs
|
|
WebTrace.WriteLine ("FrameworkInitialize");
|
|
FrameworkInitialize ();
|
|
WebTrace.WriteLine ("InitRecursive");
|
|
InitRecursive (null);
|
|
renderingForm = false;
|
|
if (IsPostBack) {
|
|
LoadPageViewState ();
|
|
ProcessPostData (DeterminePostBackMode (), false);
|
|
}
|
|
|
|
WebTrace.WriteLine ("LoadRecursive");
|
|
LoadRecursive ();
|
|
if (IsPostBack) {
|
|
ProcessPostData (secondPostData, true);
|
|
RaiseChangedEvents ();
|
|
RaisePostBackEvents ();
|
|
}
|
|
WebTrace.WriteLine ("PreRenderRecursiveInternal");
|
|
PreRenderRecursiveInternal ();
|
|
|
|
WebTrace.WriteLine ("SavePageViewState");
|
|
SavePageViewState ();
|
|
//--
|
|
HtmlTextWriter output = new HtmlTextWriter (context.Response.Output);
|
|
WebTrace.WriteLine ("RenderControl");
|
|
RenderControl (output);
|
|
_context = null;
|
|
WebTrace.WriteLine ("UnloadRecursive");
|
|
UnloadRecursive (true);
|
|
WebTrace.WriteLine ("End");
|
|
WebTrace.PopContext ();
|
|
}
|
|
|
|
internal void RaisePostBackEvents ()
|
|
{
|
|
if (requiresRaiseEvent != null) {
|
|
RaisePostBackEvent (requiresRaiseEvent, null);
|
|
return;
|
|
}
|
|
|
|
NameValueCollection postdata = DeterminePostBackMode ();
|
|
if (postdata == null)
|
|
return;
|
|
|
|
string eventTarget = postdata [postEventSourceID];
|
|
if (eventTarget == null || eventTarget.Length == 0)
|
|
return;
|
|
|
|
IPostBackEventHandler target = FindControl (eventTarget) as IPostBackEventHandler;
|
|
if (target == null)
|
|
return;
|
|
|
|
string eventArgument = postdata [postEventArgumentID];
|
|
RaisePostBackEvent (target, eventArgument);
|
|
}
|
|
|
|
internal void RaiseChangedEvents ()
|
|
{
|
|
if (requiresPostDataChanged == null)
|
|
return;
|
|
|
|
foreach (IPostBackDataHandler ipdh in requiresPostDataChanged)
|
|
ipdh.RaisePostDataChangedEvent ();
|
|
|
|
requiresPostDataChanged.Clear ();
|
|
}
|
|
|
|
protected virtual void RaisePostBackEvent (IPostBackEventHandler sourceControl, string eventArgument)
|
|
{
|
|
sourceControl.RaisePostBackEvent (eventArgument);
|
|
}
|
|
|
|
[MonoTODO]
|
|
public void RegisterArrayDeclaration (string arrayName, string arrayValue)
|
|
{
|
|
throw new NotImplementedException ();
|
|
}
|
|
|
|
public virtual void RegisterClientScriptBlock (string key, string script)
|
|
{
|
|
if (IsClientScriptBlockRegistered (key))
|
|
return;
|
|
|
|
if (clientScriptBlocks == null)
|
|
clientScriptBlocks = new Hashtable ();
|
|
|
|
clientScriptBlocks.Add (key, script);
|
|
}
|
|
|
|
public virtual void RegisterHiddenField (string hiddenFieldName, string hiddenFieldInitialValue)
|
|
{
|
|
if (hiddenFields == null)
|
|
hiddenFields = new Hashtable ();
|
|
|
|
if (!hiddenFields.ContainsKey (hiddenFieldName))
|
|
hiddenFields.Add (hiddenFieldName, hiddenFieldInitialValue);
|
|
}
|
|
|
|
[MonoTODO]
|
|
public void RegisterClientScriptFile (string a, string b, string c)
|
|
{
|
|
throw new NotImplementedException ();
|
|
}
|
|
|
|
[MonoTODO]
|
|
public void RegisterOnSubmitStatement (string key, string script)
|
|
{
|
|
throw new NotImplementedException ();
|
|
}
|
|
|
|
public void RegisterRequiresPostBack (Control control)
|
|
{
|
|
if (_requiresPostBack == null)
|
|
_requiresPostBack = new ArrayList ();
|
|
|
|
_requiresPostBack.Add (control.ID);
|
|
}
|
|
|
|
public virtual void RegisterRequiresRaiseEvent (IPostBackEventHandler control)
|
|
{
|
|
requiresRaiseEvent = control;
|
|
}
|
|
|
|
public virtual void RegisterStartupScript (string key, string script)
|
|
{
|
|
if (IsStartupScriptRegistered (key))
|
|
return;
|
|
|
|
if (startupScriptBlocks == null)
|
|
startupScriptBlocks = new Hashtable ();
|
|
|
|
startupScriptBlocks.Add (key, script);
|
|
}
|
|
|
|
public void RegisterViewStateHandler ()
|
|
{
|
|
handleViewState = true;
|
|
}
|
|
|
|
protected virtual void SavePageStateToPersistenceMedium (object viewState)
|
|
{
|
|
_savedViewState = viewState;
|
|
}
|
|
|
|
protected virtual object LoadPageStateFromPersistenceMedium ()
|
|
{
|
|
NameValueCollection postdata = DeterminePostBackMode ();
|
|
string view_state;
|
|
if (postdata == null || (view_state = postdata ["__VIEWSTATE"]) == null)
|
|
return null;
|
|
|
|
_savedViewState = null;
|
|
LosFormatter fmt = new LosFormatter ();
|
|
|
|
try {
|
|
_savedViewState = fmt.Deserialize (view_state);
|
|
} catch (Exception e) {
|
|
throw new HttpException ("Error restoring page viewstate.\n{0}", e);
|
|
}
|
|
|
|
return _savedViewState;
|
|
}
|
|
|
|
internal void LoadPageViewState()
|
|
{
|
|
WebTrace.PushContext ("LoadPageViewState");
|
|
object sState = LoadPageStateFromPersistenceMedium ();
|
|
WebTrace.WriteLine ("sState = '{0}'", sState);
|
|
if (sState != null) {
|
|
Pair pair = (Pair) sState;
|
|
LoadViewStateRecursive (pair.First);
|
|
_requiresPostBack = pair.Second as ArrayList;
|
|
}
|
|
WebTrace.PopContext ();
|
|
}
|
|
|
|
internal void SavePageViewState ()
|
|
{
|
|
if (!handleViewState)
|
|
return;
|
|
|
|
Pair pair = new Pair ();
|
|
pair.First = SaveViewStateRecursive ();
|
|
if (_requiresPostBack != null && _requiresPostBack.Count > 0)
|
|
pair.Second = _requiresPostBack;
|
|
SavePageStateToPersistenceMedium (pair);
|
|
}
|
|
|
|
public virtual void Validate ()
|
|
{
|
|
if (_validators == null || _validators.Count == 0){
|
|
_isValid = true;
|
|
return;
|
|
}
|
|
|
|
bool all_valid = true;
|
|
foreach (IValidator v in _validators){
|
|
v.Validate ();
|
|
if (v.IsValid == false)
|
|
all_valid = false;
|
|
}
|
|
|
|
if (all_valid)
|
|
_isValid = true;
|
|
}
|
|
|
|
public virtual void VerifyRenderingInServerForm (Control control)
|
|
{
|
|
if (!renderingForm)
|
|
throw new HttpException ("Control '" + control.ClientID + " " + control.GetType () +
|
|
"' must be rendered within a HtmlForm");
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|