// Andreas Nahr (ClassDevelopment@A-SoftTech.com)
//
// (C) 2002,2003 Ximian, Inc. (http://www.ximian.com)
+// (c) 2003 Novell, Inc. (http://www.novell.com)
+//
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.ComponentModel.Design.Serialization;
+using System.Globalization;
using System.IO;
using System.Security.Principal;
using System.Text;
+using System.Threading;
using System.Web;
using System.Web.Caching;
using System.Web.SessionState;
using System.Web.Util;
+#if NET_2_0
+using System.Web.UI.HtmlControls;
+#endif
namespace System.Web.UI
{
-// TODO FIXME missing the IRootDesigner Attribute
+#if !NET_2_0
+[RootDesignerSerializer ("Microsoft.VSDesigner.WebForms.RootCodeDomSerializer, " + Consts.AssemblyMicrosoft_VSDesigner, "System.ComponentModel.Design.Serialization.CodeDomSerializer, " + Consts.AssemblySystem_Design, true)]
+#endif
[DefaultEvent ("Load"), DesignerCategory ("ASPXCodeBehind")]
[ToolboxItem (false)]
[Designer ("System.Web.UI.Design.ControlDesigner, " + Consts.AssemblySystem_Design, typeof (IDesigner))]
-[RootDesignerSerializer ("Microsoft.VSDesigner.WebForms.RootCodeDomSerializer, " + Consts.AssemblyMicrosoft_VSDesigner, "System.ComponentModel.Design.Serialization.CodeDomSerializer, " + Consts.AssemblySystem_Design, true)]
public class Page : TemplateControl, IHttpHandler
{
- private string _culture;
private bool _viewState = true;
- private bool _viewStateMac = false;
+ private bool _viewStateMac;
private string _errorPage;
- private string _ID;
private bool _isValid;
- private bool _smartNavigation = false;
- private TraceContext _trace;
- private bool _traceEnabled;
- private TraceMode _traceModeValue;
+ private bool _smartNavigation;
private int _transactionMode;
- private string _UICulture;
private HttpContext _context;
private ValidatorCollection _validators;
private bool renderingForm;
private object _savedViewState;
private ArrayList _requiresPostBack;
+ private ArrayList _requiresPostBackCopy;
private ArrayList requiresPostDataChanged;
private IPostBackEventHandler requiresRaiseEvent;
private NameValueCollection secondPostData;
- private bool requiresPostBackScript = false;
- private bool postBackScriptRendered = false;
- Hashtable clientScriptBlocks;
- Hashtable startupScriptBlocks;
- Hashtable hiddenFields;
+ private bool requiresPostBackScript;
+ private bool postBackScriptRendered;
bool handleViewState;
+ string viewStateUserKey;
+ NameValueCollection _requestValueCollection;
+ string clientTarget;
+ ClientScriptManager scriptManager;
+ [EditorBrowsable (EditorBrowsableState.Never)]
protected const string postEventArgumentID = "__EVENTARGUMENT";
+ [EditorBrowsable (EditorBrowsableState.Never)]
protected const string postEventSourceID = "__EVENTTARGET";
+#if NET_2_0
+ internal const string CallbackArgumentID = "__CALLBACKARGUMENT";
+ internal const string CallbackSourceID = "__CALLBACKTARGET";
+ internal const string PreviousPageID = "__PREVIOUSPAGE";
+
+ IPageHeader htmlHeader;
+
+ MasterPage masterPage;
+ string masterPageFile;
+
+ Page previousPage;
+ bool isCrossPagePostBack;
+ ArrayList requireStateControls;
+ Hashtable _validatorsByGroup;
+ HtmlForm _form;
+#endif
+
#region Constructor
public Page ()
{
+ scriptManager = new ClientScriptManager (this);
Page = this;
}
}
[EditorBrowsable (EditorBrowsableState.Never)]
+#if NET_2_0
+ public bool AspCompatMode
+ {
+ get { return false; }
+ set { throw new NotImplementedException (); }
+ }
+#else
protected bool AspCompatMode
{
set { throw new NotImplementedException (); }
}
+#endif
[EditorBrowsable (EditorBrowsableState.Never)]
+#if NET_2_0
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ [BrowsableAttribute (false)]
+ public bool Buffer
+ {
+ get { return Response.BufferOutput; }
+ set { Response.BufferOutput = value; }
+ }
+#else
protected bool Buffer
{
set { Response.BufferOutput = value; }
}
+#endif
[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
[Browsable (false)]
get { return _context.Cache; }
}
- [MonoTODO]
+#if NET_2_0
+ [EditorBrowsableAttribute (EditorBrowsableState.Advanced)]
+#endif
[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
[Browsable (false), DefaultValue ("")]
[WebSysDescription ("Value do override the automatic browser detection and force the page to use the specified browser.")]
public string ClientTarget
{
- get { throw new NotImplementedException (); }
- set { throw new NotImplementedException (); }
+ get { return (clientTarget == null) ? "" : clientTarget; }
+ set {
+ clientTarget = value;
+ if (value == "")
+ clientTarget = null;
+ }
}
- [MonoTODO]
[EditorBrowsable (EditorBrowsableState.Never)]
+#if NET_2_0
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ [BrowsableAttribute (false)]
+ public int CodePage
+ {
+ get { return Response.ContentEncoding.CodePage; }
+ set { Response.ContentEncoding = Encoding.GetEncoding (value); }
+ }
+#else
protected int CodePage
{
- set { throw new NotImplementedException (); }
+ set { Response.ContentEncoding = Encoding.GetEncoding (value); }
}
+#endif
- [MonoTODO]
[EditorBrowsable (EditorBrowsableState.Never)]
+#if NET_2_0
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ [BrowsableAttribute (false)]
+ public string ContentType
+ {
+ get { return Response.ContentType; }
+ set { Response.ContentType = value; }
+ }
+#else
protected string ContentType
{
- set { throw new NotImplementedException (); }
+ set { Response.ContentType = value; }
}
+#endif
protected override HttpContext Context
{
- get { return _context; }
+ get {
+ if (_context == null)
+ return HttpContext.Current;
+
+ return _context;
+ }
}
[EditorBrowsable (EditorBrowsableState.Never)]
+#if NET_2_0
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ [BrowsableAttribute (false)]
+ public string Culture
+ {
+ get { return Thread.CurrentThread.CurrentCulture.Name; }
+ set { Thread.CurrentThread.CurrentCulture = new CultureInfo (value); }
+ }
+#else
protected string Culture
{
- set { _culture = value; }
+ set { Thread.CurrentThread.CurrentCulture = new CultureInfo (value); }
}
+#endif
[Browsable (false)]
public override bool EnableViewState
set { _viewState = value; }
}
+#if NET_2_0
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ [BrowsableAttribute (false)]
+#endif
[EditorBrowsable (EditorBrowsableState.Never)]
protected bool EnableViewStateMac
{
public string ErrorPage
{
get { return _errorPage; }
- set { _errorPage = value; }
+ set {
+ _errorPage = value;
+ if (_context != null)
+ _context.ErrorPage = value;
+ }
}
+#if NET_2_0
+ [Obsolete]
+#endif
[EditorBrowsable (EditorBrowsableState.Never)]
protected ArrayList FileDependencies
{
[Browsable (false)]
public override string ID
{
- get { return _ID; }
- set { _ID = value; }
+ get { return base.ID; }
+ set { base.ID = value; }
}
[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
public bool IsPostBack
{
get {
- return (0 == String.Compare (Request.HttpMethod, "POST", true));
+ return _requestValueCollection != null;
}
}
get { return _isValid; }
}
- [MonoTODO]
[EditorBrowsable (EditorBrowsableState.Never)]
+#if NET_2_0
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ [BrowsableAttribute (false)]
+ public int LCID {
+ get { return Thread.CurrentThread.CurrentCulture.LCID; }
+ set { Thread.CurrentThread.CurrentCulture = new CultureInfo (value); }
+ }
+#else
protected int LCID {
- set { throw new NotImplementedException (); }
+ set { Thread.CurrentThread.CurrentCulture = new CultureInfo (value); }
}
+#endif
[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
[Browsable (false)]
}
[EditorBrowsable (EditorBrowsableState.Never)]
+#if NET_2_0
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ [BrowsableAttribute (false)]
+ public string ResponseEncoding
+ {
+ get { return Response.ContentEncoding.WebName; }
+ set { Response.ContentEncoding = Encoding.GetEncoding (value); }
+ }
+#else
protected string ResponseEncoding
{
set { Response.ContentEncoding = Encoding.GetEncoding (value); }
}
+#endif
[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
[Browsable (false)]
[Browsable (false)]
public virtual HttpSessionState Session
{
- get { return _context.Session; }
+ get {
+ if (_context.Session == null)
+ throw new HttpException ("Session state can only be used " +
+ "when enableSessionState is set to true, either " +
+ "in a configuration file or in the Page directive.");
+
+ return _context.Session;
+ }
}
+#if NET_2_0
+ [FilterableAttribute (false)]
+#endif
[Browsable (false)]
public bool SmartNavigation
{
[Browsable (false)]
public TraceContext Trace
{
- get { return _trace; }
+ get { return Context.Trace; }
}
[EditorBrowsable (EditorBrowsableState.Never)]
+#if NET_2_0
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ [BrowsableAttribute (false)]
+ public bool TraceEnabled
+ {
+ get { return Trace.IsEnabled; }
+ set { Trace.IsEnabled = value; }
+ }
+#else
protected bool TraceEnabled
{
- set { _traceEnabled = value; }
+ set { Trace.IsEnabled = value; }
}
+#endif
[EditorBrowsable (EditorBrowsableState.Never)]
+#if NET_2_0
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ [BrowsableAttribute (false)]
+ public TraceMode TraceModeValue
+ {
+ get { return Trace.TraceMode; }
+ set { Trace.TraceMode = value; }
+ }
+#else
protected TraceMode TraceModeValue
{
- set { _traceModeValue = value; }
+ set { Trace.TraceMode = value; }
}
+#endif
[EditorBrowsable (EditorBrowsableState.Never)]
+#if NET_2_0
+ public int TransactionMode
+ {
+ get { return _transactionMode; }
+ set { _transactionMode = value; }
+ }
+#else
protected int TransactionMode
{
set { _transactionMode = value; }
}
+#endif
[EditorBrowsable (EditorBrowsableState.Never)]
+#if NET_2_0
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ [BrowsableAttribute (false)]
+ public string UICulture
+ {
+ get { return Thread.CurrentThread.CurrentUICulture.Name; }
+ set { Thread.CurrentThread.CurrentUICulture = new CultureInfo (value); }
+ }
+#else
protected string UICulture
{
- set { _UICulture = value; }
+ set { Thread.CurrentThread.CurrentUICulture = new CultureInfo (value); }
}
+#endif
[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
[Browsable (false)]
}
}
+ [MonoTODO ("Use this when encrypting/decrypting ViewState")]
+ [Browsable (false)]
+ public string ViewStateUserKey {
+ get { return viewStateUserKey; }
+ set { viewStateUserKey = value; }
+ }
+
[Browsable (false)]
public override bool Visible
{
#region Methods
- [MonoTODO]
[EditorBrowsable (EditorBrowsableState.Never)]
protected IAsyncResult AspCompatBeginProcessRequest (HttpContext context,
AsyncCallback cb,
throw new NotImplementedException ();
}
- [MonoTODO]
[EditorBrowsable (EditorBrowsableState.Never)]
protected void AspCompatEndProcessRequest (IAsyncResult result)
{
return new HtmlTextWriter (tw);
}
- [MonoTODO]
[EditorBrowsable (EditorBrowsableState.Never)]
public void DesignerInitialize ()
{
- throw new NotImplementedException ();
+ InitRecursive (null);
}
[EditorBrowsable (EditorBrowsableState.Advanced)]
return null;
NameValueCollection coll = null;
- if (IsPostBack)
- coll = req.Form;
+ if (0 == String.Compare (Request.HttpMethod, "POST", true))
+ coll = req.Form;
else
coll = req.QueryString;
return coll;
}
-
+
+#if NET_2_0
+ [Obsolete]
+#endif
[EditorBrowsable (EditorBrowsableState.Advanced)]
public string GetPostBackClientEvent (Control control, string argument)
{
- return GetPostBackEventReference (control, argument);
+ return scriptManager.GetPostBackClientEvent (control, argument);
}
+#if NET_2_0
+ [Obsolete]
+#endif
[EditorBrowsable (EditorBrowsableState.Advanced)]
public string GetPostBackClientHyperlink (Control control, string argument)
{
- return "javascript:" + GetPostBackEventReference (control, argument);
+ return scriptManager.GetPostBackClientHyperlink (control, argument);
}
+#if NET_2_0
+ [Obsolete]
+#endif
[EditorBrowsable (EditorBrowsableState.Advanced)]
public string GetPostBackEventReference (Control control)
{
- return GetPostBackEventReference (control, "");
+ return scriptManager.GetPostBackEventReference (control);
}
+#if NET_2_0
+ [Obsolete]
+#endif
[EditorBrowsable (EditorBrowsableState.Advanced)]
public string GetPostBackEventReference (Control control, string argument)
{
- RequiresPostBackScript ();
- return String.Format ("__doPostBack ('{0}', '{1}')", control.UniqueID, argument);
+ return scriptManager.GetPostBackEventReference (control, argument);
}
internal void RequiresPostBackScript ()
return 0;
}
- [MonoTODO]
[EditorBrowsable (EditorBrowsableState.Never)]
protected virtual void InitOutputCache (int duration,
string varyByHeader,
OutputCacheLocation location,
string varyByParam)
{
- throw new NotImplementedException ();
+ HttpCachePolicy cache = _context.Response.Cache;
+ bool set_vary = false;
+
+ switch (location) {
+ case OutputCacheLocation.Any:
+ cache.SetCacheability (HttpCacheability.Public);
+ cache.SetMaxAge (new TimeSpan (0, 0, duration));
+ cache.SetLastModified (_context.Timestamp);
+ set_vary = true;
+ break;
+ case OutputCacheLocation.Client:
+ cache.SetCacheability (HttpCacheability.Private);
+ cache.SetMaxAge (new TimeSpan (0, 0, duration));
+ cache.SetLastModified (_context.Timestamp);
+ break;
+ case OutputCacheLocation.Downstream:
+ cache.SetCacheability (HttpCacheability.Public);
+ cache.SetMaxAge (new TimeSpan (0, 0, duration));
+ cache.SetLastModified (_context.Timestamp);
+ break;
+ case OutputCacheLocation.Server:
+ cache.SetCacheability (HttpCacheability.Server);
+ set_vary = true;
+ break;
+ case OutputCacheLocation.None:
+ break;
+ }
+
+ if (set_vary) {
+ if (varyByCustom != null)
+ cache.SetVaryByCustom (varyByCustom);
+
+ if (varyByParam != null && varyByParam.Length > 0) {
+ string[] prms = varyByParam.Split (';');
+ foreach (string p in prms)
+ cache.VaryByParams [p.Trim ()] = true;
+ cache.VaryByParams.IgnoreParams = false;
+ } else {
+ cache.VaryByParams.IgnoreParams = true;
+ }
+
+ if (varyByHeader != null && varyByHeader.Length > 0) {
+ string[] hdrs = varyByHeader.Split (';');
+ foreach (string h in hdrs)
+ cache.VaryByHeaders [h.Trim ()] = true;
+ }
+ }
+
+ cache.Duration = duration;
+ cache.SetExpires (_context.Timestamp.AddSeconds (duration));
}
+#if NET_2_0
+ [Obsolete]
+#else
[EditorBrowsable (EditorBrowsableState.Advanced)]
+#endif
public bool IsClientScriptBlockRegistered (string key)
{
- if (clientScriptBlocks == null)
- return false;
-
- return clientScriptBlocks.ContainsKey (key);
+ return scriptManager.IsClientScriptBlockRegistered (key);
}
+#if NET_2_0
+ [Obsolete]
+#else
[EditorBrowsable (EditorBrowsableState.Advanced)]
+#endif
public bool IsStartupScriptRegistered (string key)
{
- if (startupScriptBlocks == null)
- return false;
-
- return startupScriptBlocks.ContainsKey (key);
+ return scriptManager.IsStartupScriptRegistered (key);
}
public string MapPath (string virtualPath)
writer.WriteLine ();
writer.WriteLine ("<script language=\"javascript\">");
writer.WriteLine ("<!--");
+
+ if (Request.Browser.Browser == ("Netscape") && Request.Browser.MajorVersion == 4)
+ writer.WriteLine ("\tvar theForm = document.{0};", formUniqueID);
+ else
+ writer.WriteLine ("\tvar theForm = document.getElementById ('{0}');", formUniqueID);
+
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\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)
renderingForm = true;
writer.WriteLine ();
- WriteHiddenFields (writer);
+ scriptManager.WriteHiddenFields (writer);
if (requiresPostBackScript) {
RenderPostBackScript (writer, formUniqueID);
postBackScriptRendered = true;
}
if (handleViewState) {
+ string vs = GetViewStateString ();
writer.Write ("<input type=\"hidden\" name=\"__VIEWSTATE\" ");
- writer.WriteLine ("value=\"{0}\" />", GetViewStateString ());
+ writer.WriteLine ("value=\"{0}\" />", vs);
}
- WriteScripts (writer, clientScriptBlocks);
+ scriptManager.WriteClientScriptBlocks (writer);
}
internal string GetViewStateString ()
{
+ if (_savedViewState == null)
+ return null;
StringWriter sr = new StringWriter ();
LosFormatter fmt = new LosFormatter ();
fmt.Serialize (sr, _savedViewState);
internal void OnFormPostRender (HtmlTextWriter writer, string formUniqueID)
{
+ scriptManager.WriteArrayDeclares (writer);
+
if (!postBackScriptRendered && requiresPostBackScript)
RenderPostBackScript (writer, formUniqueID);
- WriteHiddenFields (writer);
- WriteScripts (writer, startupScriptBlocks);
+ scriptManager.WriteHiddenFields (writer);
+ scriptManager.WriteClientScriptIncludes (writer);
+ scriptManager.WriteStartupScriptBlocks (writer);
renderingForm = false;
postBackScriptRendered = false;
}
if (data == null)
return;
+ if (_requiresPostBackCopy == null && _requiresPostBack != null)
+ _requiresPostBackCopy = (ArrayList) _requiresPostBack.Clone ();
+
Hashtable used = new Hashtable ();
foreach (string id in data.AllKeys){
if (id == "__VIEWSTATE" || id == postEventSourceID || id == postEventArgumentID)
if (requiresPostDataChanged == null)
requiresPostDataChanged = new ArrayList ();
requiresPostDataChanged.Add (pbdh);
+ if (_requiresPostBackCopy != null)
+ _requiresPostBackCopy.Remove (ctrl.UniqueID);
}
} else if (!second) {
if (secondPostData == null)
secondPostData.Add (real_id, data [id]);
}
}
+
+ ArrayList list1 = null;
+ if (_requiresPostBackCopy != null && _requiresPostBackCopy.Count > 0) {
+ string [] handlers = (string []) _requiresPostBackCopy.ToArray (typeof (string));
+ foreach (string id in handlers) {
+ IPostBackDataHandler pbdh = FindControl (id) as IPostBackDataHandler;
+ if (pbdh != null) {
+ _requiresPostBackCopy.Remove (id);
+ if (pbdh.LoadPostData (id, data)) {
+ if (requiresPostDataChanged == null)
+ requiresPostDataChanged = new ArrayList ();
+
+ requiresPostDataChanged.Add (pbdh);
+ }
+ } else if (second) {
+ if (list1 == null)
+ list1 = new ArrayList ();
+ list1.Add (id);
+ }
+ }
+ }
+ _requiresPostBack = list1;
}
[EditorBrowsable (EditorBrowsableState.Never)]
public void ProcessRequest (HttpContext context)
{
_context = context;
- WebTrace.PushContext ("Page.ProcessRequest ()");
- WebTrace.WriteLine ("Entering");
+ if (clientTarget != null)
+ Request.ClientTarget = clientTarget;
+
WireupAutomaticEvents ();
- WebTrace.WriteLine ("Finished hookup");
//-- Control execution lifecycle in the docs
- WebTrace.WriteLine ("FrameworkInitialize");
+
+ // Save culture information because it can be modified in FrameworkInitialize()
+ CultureInfo culture = Thread.CurrentThread.CurrentCulture;
+ CultureInfo uiculture = Thread.CurrentThread.CurrentUICulture;
FrameworkInitialize ();
- WebTrace.WriteLine ("InitRecursive");
+ context.ErrorPage = _errorPage;
+
+ try {
+ InternalProcessRequest ();
+ } finally {
+ try {
+ UnloadRecursive (true);
+ } catch {}
+ Thread.CurrentThread.CurrentCulture = culture;
+ Thread.CurrentThread.CurrentUICulture = uiculture;
+ }
+ }
+
+#if NET_2_0
+ internal void ProcessCrossPagePostBack (HttpContext context)
+ {
+ isCrossPagePostBack = true;
+ ProcessRequest (context);
+ }
+#endif
+
+ void InternalProcessRequest ()
+ {
+ _requestValueCollection = this.DeterminePostBackMode();
+
+#if NET_2_0
+ if (!IsCrossPagePostBack)
+ LoadPreviousPageReference ();
+
+ OnPreInit (EventArgs.Empty);
+#endif
+ Trace.Write ("aspx.page", "Begin Init");
InitRecursive (null);
+ Trace.Write ("aspx.page", "End Init");
+
+#if NET_2_0
+ OnInitComplete (EventArgs.Empty);
+
+ if (masterPageFile != null) {
+ Controls.Add (Master);
+ Master.FillPlaceHolders ();
+ }
+#endif
+
renderingForm = false;
if (IsPostBack) {
+ Trace.Write ("aspx.page", "Begin LoadViewState");
LoadPageViewState ();
- ProcessPostData (DeterminePostBackMode (), false);
+ Trace.Write ("aspx.page", "End LoadViewState");
+ Trace.Write ("aspx.page", "Begin ProcessPostData");
+ ProcessPostData (_requestValueCollection, false);
+ Trace.Write ("aspx.page", "End ProcessPostData");
}
+
+#if NET_2_0
+ if (IsCrossPagePostBack)
+ return;
+
+ OnPreLoad (EventArgs.Empty);
+#endif
- WebTrace.WriteLine ("LoadRecursive");
LoadRecursive ();
if (IsPostBack) {
+ Trace.Write ("aspx.page", "Begin ProcessPostData Second Try");
ProcessPostData (secondPostData, true);
+ Trace.Write ("aspx.page", "End ProcessPostData Second Try");
+ Trace.Write ("aspx.page", "Begin Raise ChangedEvents");
RaiseChangedEvents ();
+ Trace.Write ("aspx.page", "End Raise ChangedEvents");
+ Trace.Write ("aspx.page", "Begin Raise PostBackEvent");
RaisePostBackEvents ();
+ Trace.Write ("aspx.page", "End Raise PostBackEvent");
}
- WebTrace.WriteLine ("PreRenderRecursiveInternal");
+
+#if NET_2_0
+ OnLoadComplete (EventArgs.Empty);
+
+ if (IsCallback) {
+ string result = ProcessCallbackData ();
+ HtmlTextWriter callbackOutput = new HtmlTextWriter (_context.Response.Output);
+ callbackOutput.Write (result);
+ callbackOutput.Flush ();
+ return;
+ }
+#endif
+
+ Trace.Write ("aspx.page", "Begin PreRender");
PreRenderRecursiveInternal ();
+ Trace.Write ("aspx.page", "End PreRender");
+
+#if NET_2_0
+ OnPreRenderComplete (EventArgs.Empty);
+#endif
- WebTrace.WriteLine ("SavePageViewState");
+ Trace.Write ("aspx.page", "Begin SaveViewState");
SavePageViewState ();
+ Trace.Write ("aspx.page", "End SaveViewState");
+
+#if NET_2_0
+ OnSaveStateComplete (EventArgs.Empty);
+#endif
+
//--
- HtmlTextWriter output = new HtmlTextWriter (context.Response.Output);
- WebTrace.WriteLine ("RenderControl");
+ Trace.Write ("aspx.page", "Begin Render");
+ HtmlTextWriter output = new HtmlTextWriter (_context.Response.Output);
RenderControl (output);
- _context = null;
- WebTrace.WriteLine ("UnloadRecursive");
- UnloadRecursive (true);
- WebTrace.WriteLine ("End");
- WebTrace.PopContext ();
+ Trace.Write ("aspx.page", "End Render");
+
+ RenderTrace (output);
}
- [EditorBrowsable (EditorBrowsableState.Advanced)]
+
+ private void RenderTrace (HtmlTextWriter output)
+ {
+ TraceManager traceManager = HttpRuntime.TraceManager;
+
+ if (Trace.HaveTrace && !Trace.IsEnabled || !Trace.HaveTrace && !traceManager.Enabled)
+ return;
+
+ Trace.SaveData ();
+
+ if (!Trace.HaveTrace && traceManager.Enabled && !traceManager.PageOutput)
+ return;
+
+ if (!traceManager.LocalOnly || Context.Request.IsLocal)
+ Trace.Render (output);
+ }
+
internal void RaisePostBackEvents ()
{
if (requiresRaiseEvent != null) {
return;
}
- NameValueCollection postdata = DeterminePostBackMode ();
+ NameValueCollection postdata = _requestValueCollection;
if (postdata == null)
return;
string eventTarget = postdata [postEventSourceID];
- if (eventTarget == null || eventTarget.Length == 0)
+ if (eventTarget == null || eventTarget.Length == 0) {
+ Validate ();
return;
+ }
IPostBackEventHandler target = FindControl (eventTarget) as IPostBackEventHandler;
if (target == null)
foreach (IPostBackDataHandler ipdh in requiresPostDataChanged)
ipdh.RaisePostDataChangedEvent ();
- requiresPostDataChanged.Clear ();
+ requiresPostDataChanged = null;
}
+ [EditorBrowsable (EditorBrowsableState.Advanced)]
protected virtual void RaisePostBackEvent (IPostBackEventHandler sourceControl, string eventArgument)
{
sourceControl.RaisePostBackEvent (eventArgument);
}
- [MonoTODO]
+#if NET_2_0
+ [Obsolete]
+#endif
[EditorBrowsable (EditorBrowsableState.Advanced)]
public void RegisterArrayDeclaration (string arrayName, string arrayValue)
{
- throw new NotImplementedException ();
+ scriptManager.RegisterArrayDeclaration (arrayName, arrayValue);
}
+#if NET_2_0
+ [Obsolete]
+#endif
[EditorBrowsable (EditorBrowsableState.Advanced)]
public virtual void RegisterClientScriptBlock (string key, string script)
{
- if (IsClientScriptBlockRegistered (key))
- return;
-
- if (clientScriptBlocks == null)
- clientScriptBlocks = new Hashtable ();
-
- clientScriptBlocks.Add (key, script);
+ scriptManager.RegisterClientScriptBlock (key, script);
}
+#if NET_2_0
+ [Obsolete]
+#endif
[EditorBrowsable (EditorBrowsableState.Advanced)]
public virtual void RegisterHiddenField (string hiddenFieldName, string hiddenFieldInitialValue)
{
- if (hiddenFields == null)
- hiddenFields = new Hashtable ();
-
- if (!hiddenFields.ContainsKey (hiddenFieldName))
- hiddenFields.Add (hiddenFieldName, hiddenFieldInitialValue);
+ scriptManager.RegisterHiddenField (hiddenFieldName, hiddenFieldInitialValue);
}
-
- [MonoTODO]
- public void RegisterClientScriptFile (string a, string b, string c)
+
+ [MonoTODO("Used in HtmlForm")]
+ internal void RegisterClientScriptFile (string a, string b, string c)
{
throw new NotImplementedException ();
}
- [MonoTODO]
+#if NET_2_0
+ [Obsolete]
+#endif
[EditorBrowsable (EditorBrowsableState.Advanced)]
public void RegisterOnSubmitStatement (string key, string script)
{
- throw new NotImplementedException ();
+ scriptManager.RegisterOnSubmitStatement (key, script);
}
[EditorBrowsable (EditorBrowsableState.Advanced)]
if (_requiresPostBack == null)
_requiresPostBack = new ArrayList ();
- _requiresPostBack.Add (control.ID);
+ _requiresPostBack.Add (control.UniqueID);
}
[EditorBrowsable (EditorBrowsableState.Advanced)]
requiresRaiseEvent = control;
}
+#if NET_2_0
+ [Obsolete]
+#endif
[EditorBrowsable (EditorBrowsableState.Advanced)]
public virtual void RegisterStartupScript (string key, string script)
{
- if (IsStartupScriptRegistered (key))
- return;
-
- if (startupScriptBlocks == null)
- startupScriptBlocks = new Hashtable ();
-
- startupScriptBlocks.Add (key, script);
+ scriptManager.RegisterStartupScript (key, script);
}
[EditorBrowsable (EditorBrowsableState.Advanced)]
handleViewState = true;
}
+ [EditorBrowsable (EditorBrowsableState.Advanced)]
protected virtual void SavePageStateToPersistenceMedium (object viewState)
{
_savedViewState = viewState;
[EditorBrowsable (EditorBrowsableState.Advanced)]
protected virtual object LoadPageStateFromPersistenceMedium ()
{
- NameValueCollection postdata = DeterminePostBackMode ();
+ NameValueCollection postdata = _requestValueCollection;
string view_state;
if (postdata == null || (view_state = postdata ["__VIEWSTATE"]) == null)
return null;
try {
_savedViewState = fmt.Deserialize (view_state);
} catch (Exception e) {
- throw new HttpException ("Error restoring page viewstate.\n{0}", e);
+ throw new HttpException ("Error restoring page viewstate.\n", e);
}
return _savedViewState;
internal void LoadPageViewState()
{
- WebTrace.PushContext ("LoadPageViewState");
object sState = LoadPageStateFromPersistenceMedium ();
- WebTrace.WriteLine ("sState = '{0}'", sState);
if (sState != null) {
+#if NET_2_0
+ Triplet data = (Triplet) sState;
+ LoadPageControlState (data.Third);
+ LoadViewStateRecursive (data.First);
+ _requiresPostBack = data.Second as ArrayList;
+#else
Pair pair = (Pair) sState;
LoadViewStateRecursive (pair.First);
_requiresPostBack = pair.Second as ArrayList;
+#endif
}
- WebTrace.PopContext ();
}
internal void SavePageViewState ()
if (!handleViewState)
return;
+#if NET_2_0
+ object controlState = SavePageControlState ();
+#endif
+
+ object viewState = SaveViewStateRecursive ();
+ object reqPostback = (_requiresPostBack != null && _requiresPostBack.Count > 0) ? _requiresPostBack : null;
+
+#if NET_2_0
+ Triplet triplet = new Triplet ();
+ triplet.First = viewState;
+ triplet.Second = reqPostback;
+ triplet.Third = controlState;
+
+ if (triplet.First == null && triplet.Second == null && triplet.Third == null)
+ triplet = null;
+
+ SavePageStateToPersistenceMedium (triplet);
+#else
Pair pair = new Pair ();
- pair.First = SaveViewStateRecursive ();
- if (_requiresPostBack != null && _requiresPostBack.Count > 0)
- pair.Second = _requiresPostBack;
+ pair.First = viewState;
+ pair.Second = reqPostback;
+
+ if (pair.First == null && pair.Second == null)
+ pair = null;
+
SavePageStateToPersistenceMedium (pair);
+#endif
}
public virtual void Validate ()
{
- if (_validators == null || _validators.Count == 0){
+ ValidateCollection (_validators);
+ }
+
+ void ValidateCollection (ValidatorCollection validators)
+ {
+ if (validators == null || validators.Count == 0){
_isValid = true;
return;
}
bool all_valid = true;
- foreach (IValidator v in _validators){
+ foreach (IValidator v in validators){
v.Validate ();
if (v.IsValid == false)
all_valid = false;
throw new HttpException ("Control '" + control.ClientID + " " + control.GetType () +
"' must be rendered within a HtmlForm");
}
-
+
#endregion
+
+ #if NET_2_0
+ public
+ #else
+ internal
+ #endif
+ ClientScriptManager ClientScript {
+ get { return scriptManager; }
+ }
+
+ #if NET_2_0
+
+ static readonly object InitCompleteEvent = new object ();
+ static readonly object LoadCompleteEvent = new object ();
+ static readonly object PreInitEvent = new object ();
+ static readonly object PreLoadEvent = new object ();
+ static readonly object PreRenderCompleteEvent = new object ();
+ static readonly object SaveStateCompleteEvent = new object ();
+
+ public event EventHandler InitComplete {
+ add { Events.AddHandler (InitCompleteEvent, value); }
+ remove { Events.RemoveHandler (InitCompleteEvent, value); }
+ }
+
+ public event EventHandler LoadComplete {
+ add { Events.AddHandler (LoadCompleteEvent, value); }
+ remove { Events.RemoveHandler (LoadCompleteEvent, value); }
+ }
+
+ public event EventHandler PreInit {
+ add { Events.AddHandler (PreInitEvent, value); }
+ remove { Events.RemoveHandler (PreInitEvent, value); }
+ }
+
+ public event EventHandler PreLoad {
+ add { Events.AddHandler (PreLoadEvent, value); }
+ remove { Events.RemoveHandler (PreLoadEvent, value); }
+ }
+
+ public event EventHandler PreRenderComplete {
+ add { Events.AddHandler (PreRenderCompleteEvent, value); }
+ remove { Events.RemoveHandler (PreRenderCompleteEvent, value); }
+ }
+
+ public event EventHandler SaveStateComplete {
+ add { Events.AddHandler (SaveStateCompleteEvent, value); }
+ remove { Events.RemoveHandler (SaveStateCompleteEvent, value); }
+ }
+
+ protected virtual void OnInitComplete (EventArgs e)
+ {
+ if (Events != null) {
+ EventHandler eh = (EventHandler) (Events [InitCompleteEvent]);
+ if (eh != null) eh (this, e);
+ }
+ }
+
+ protected virtual void OnLoadComplete (EventArgs e)
+ {
+ if (Events != null) {
+ EventHandler eh = (EventHandler) (Events [LoadCompleteEvent]);
+ if (eh != null) eh (this, e);
+ }
+ }
+
+ protected virtual void OnPreInit (EventArgs e)
+ {
+ if (Events != null) {
+ EventHandler eh = (EventHandler) (Events [PreInitEvent]);
+ if (eh != null) eh (this, e);
+ }
+ }
+
+ protected virtual void OnPreLoad (EventArgs e)
+ {
+ if (Events != null) {
+ EventHandler eh = (EventHandler) (Events [PreLoadEvent]);
+ if (eh != null) eh (this, e);
+ }
+ }
+
+ protected virtual void OnPreRenderComplete (EventArgs e)
+ {
+ if (Events != null) {
+ EventHandler eh = (EventHandler) (Events [PreRenderCompleteEvent]);
+ if (eh != null) eh (this, e);
+ }
+ }
+
+ protected virtual void OnSaveStateComplete (EventArgs e)
+ {
+ if (Events != null) {
+ EventHandler eh = (EventHandler) (Events [SaveStateCompleteEvent]);
+ if (eh != null) eh (this, e);
+ }
+ }
+
+ public HtmlForm Form {
+ get { return _form; }
+ }
+
+ internal void RegisterForm (HtmlForm form)
+ {
+ _form = form;
+ }
+
+ [BrowsableAttribute (false)]
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ public Page PreviousPage {
+ get { return previousPage; }
+ }
+
+
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ [BrowsableAttribute (false)]
+ public bool IsCallback {
+ get { return _requestValueCollection != null && _requestValueCollection [CallbackArgumentID] != null; }
+ }
+
+ [BrowsableAttribute (false)]
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ public bool IsCrossPagePostBack {
+ get { return _requestValueCollection != null && isCrossPagePostBack; }
+ }
+
+ string ProcessCallbackData ()
+ {
+ string callbackTarget = _requestValueCollection [CallbackSourceID];
+ if (callbackTarget == null || callbackTarget.Length == 0)
+ throw new HttpException ("Callback target not provided.");
+
+ ICallbackEventHandler target = FindControl (callbackTarget) as ICallbackEventHandler;
+ if (target == null)
+ throw new HttpException (string.Format ("Invalid callback target '{0}'.", callbackTarget));
+
+ string callbackArgument = _requestValueCollection [CallbackArgumentID];
+ return target.RaiseCallbackEvent (callbackArgument);
+ }
+
+ [BrowsableAttribute (false)]
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ public IPageHeader Header {
+ get { return htmlHeader; }
+ }
+
+ internal void SetHeader (IPageHeader header)
+ {
+ htmlHeader = header;
+ }
+
+ [DefaultValueAttribute ("")]
+ public string MasterPageFile {
+ get { return masterPageFile; }
+ set { masterPageFile = value; masterPage = null; }
+ }
+
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ [BrowsableAttribute (false)]
+ public MasterPage Master {
+ get {
+ if (masterPage == null)
+ masterPage = MasterPageParser.GetCompiledMasterInstance (masterPageFile, Server.MapPath (masterPageFile), Context);
+ return masterPage;
+ }
+ }
+
+ [EditorBrowsable (EditorBrowsableState.Advanced)]
+ public void RegisterRequiresControlState (Control control)
+ {
+ if (requireStateControls == null) requireStateControls = new ArrayList ();
+ requireStateControls.Add (control);
+ }
+
+ public bool RequiresControlState (Control control)
+ {
+ if (requireStateControls == null) return false;
+ return requireStateControls.Contains (control);
+ }
+
+ [EditorBrowsable (EditorBrowsableState.Advanced)]
+ public void UnregisterRequiresControlState (Control control)
+ {
+ if (requireStateControls != null)
+ requireStateControls.Remove (control);
+ }
+
+ public ValidatorCollection GetValidators (string validationGroup)
+ {
+ if (validationGroup == null || validationGroup == "")
+ return Validators;
+
+ if (_validatorsByGroup == null) _validatorsByGroup = new Hashtable ();
+ ValidatorCollection col = _validatorsByGroup [validationGroup] as ValidatorCollection;
+ if (col == null) {
+ col = new ValidatorCollection ();
+ _validatorsByGroup [validationGroup] = col;
+ }
+ return col;
+ }
+
+ public virtual void Validate (string validationGroup)
+ {
+ if (validationGroup == null || validationGroup == "")
+ ValidateCollection (_validators);
+ else {
+ if (_validatorsByGroup != null) {
+ ValidateCollection (_validatorsByGroup [validationGroup] as ValidatorCollection);
+ } else {
+ _isValid = true;
+ }
+ }
+ }
+
+ object SavePageControlState ()
+ {
+ if (requireStateControls == null) return null;
+ object[] state = new object [requireStateControls.Count];
+
+ bool allNull = true;
+ for (int n=0; n<state.Length; n++) {
+ state [n] = ((Control) requireStateControls [n]).SaveControlState ();
+ if (state [n] != null) allNull = false;
+ }
+ if (allNull) return null;
+ else return state;
+ }
+
+ void LoadPageControlState (object data)
+ {
+ if (requireStateControls == null) return;
+
+ object[] state = (object[]) data;
+ int max = Math.Min (requireStateControls.Count, state != null ? state.Length : requireStateControls.Count);
+ for (int n=0; n < max; n++) {
+ Control ctl = (Control) requireStateControls [n];
+ ctl.LoadControlState (state != null ? state [n] : null);
+ }
+ }
+
+ void LoadPreviousPageReference ()
+ {
+ if (_requestValueCollection != null) {
+ string prevPage = _requestValueCollection [PreviousPageID];
+ if (prevPage != null) {
+ previousPage = (Page) PageParser.GetCompiledPageInstance (prevPage, Server.MapPath (prevPage), Context);
+ previousPage.ProcessCrossPagePostBack (_context);
+ } else {
+ previousPage = _context.LastPage;
+ }
+ }
+ _context.LastPage = this;
+ }
+
+
+ #endif
}
}
projects / mono.git / blobdiff