mcs/class/System.Web/System.Web.UI/Page.cs

   1 //
   2 // System.Web.UI.Page.cs
   3 //
   4 // Authors:
   5 //   Duncan Mak  (duncan@ximian.com)
   6 //   Gonzalo Paniagua (gonzalo@ximian.com)
   7 //   Andreas Nahr (ClassDevelopment@A-SoftTech.com)
   8 //
   9 // (C) 2002,2003 Ximian, Inc. (http://www.ximian.com)
  10 // (c) 2003 Novell, Inc. (http://www.novell.com)
  11 //
  12
  13 using System;
  14 using System.Collections;
  15 using System.Collections.Specialized;
  16 using System.ComponentModel;
  17 using System.ComponentModel.Design;
  18 using System.ComponentModel.Design.Serialization;
  19 using System.Globalization;
  20 using System.IO;
  21 using System.Security.Principal;
  22 using System.Text;
  23 using System.Threading;
  24 using System.Web;
  25 using System.Web.Caching;
  26 using System.Web.SessionState;
  27 using System.Web.Util;
  28
  29 namespace System.Web.UI
  30 {
  31
  32 [MonoTODO ("FIXME missing the IRootDesigner Attribute")]
  33 [DefaultEvent ("Load"), DesignerCategory ("ASPXCodeBehind")]
  34 [ToolboxItem (false)]
  35 [Designer ("System.Web.UI.Design.ControlDesigner, " + Consts.AssemblySystem_Design, typeof (IDesigner))]
  36 [RootDesignerSerializer ("Microsoft.VSDesigner.WebForms.RootCodeDomSerializer, " + Consts.AssemblyMicrosoft_VSDesigner, "System.ComponentModel.Design.Serialization.CodeDomSerializer, " + Consts.AssemblySystem_Design, true)]
  37 public class Page : TemplateControl, IHttpHandler
  38 {
  39         private bool _viewState = true;
  40         private bool _viewStateMac;
  41         private string _errorPage;
  42         private bool _isValid;
  43         private bool _smartNavigation;
  44         private int _transactionMode;
  45         private HttpContext _context;
  46         private ValidatorCollection _validators;
  47         private bool renderingForm;
  48         private object _savedViewState;
  49         private ArrayList _requiresPostBack;
  50         private ArrayList _requiresPostBackCopy;
  51         private ArrayList requiresPostDataChanged;
  52         private IPostBackEventHandler requiresRaiseEvent;
  53         private NameValueCollection secondPostData;
  54         private bool requiresPostBackScript;
  55         private bool postBackScriptRendered;
  56         private Hashtable registeredArrayDeclares;
  57         Hashtable clientScriptBlocks;
  58         Hashtable startupScriptBlocks;
  59         Hashtable hiddenFields;
  60         internal Hashtable submitStatements;
  61         bool handleViewState;
  62         string viewStateUserKey;
  63
  64         [EditorBrowsable (EditorBrowsableState.Never)]
  65         protected const string postEventArgumentID = "__EVENTARGUMENT";
  66         [EditorBrowsable (EditorBrowsableState.Never)]
  67         protected const string postEventSourceID = "__EVENTTARGET";
  68
  69         #region Constructor
  70         public Page ()
  71         {
  72                 Page = this;
  73         }
  74
  75         #endregion
  76
  77         #region Properties
  78
  79         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
  80         [Browsable (false)]
  81         public HttpApplicationState Application
  82         {
  83                 get { return _context.Application; }
  84         }
  85
  86         [EditorBrowsable (EditorBrowsableState.Never)]
  87         protected bool AspCompatMode
  88         {
  89                 set { throw new NotImplementedException (); }
  90         }
  91
  92         [EditorBrowsable (EditorBrowsableState.Never)]
  93         protected bool Buffer
  94         {
  95                 set { Response.BufferOutput = value; }
  96         }
  97
  98         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
  99         [Browsable (false)]
 100         public Cache Cache
 101         {
 102                 get { return _context.Cache; }
 103         }
 104
 105         [MonoTODO]
 106         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 107         [Browsable (false), DefaultValue ("")]
 108         [WebSysDescription ("Value do override the automatic browser detection and force the page to use the specified browser.")]
 109         public string ClientTarget
 110         {
 111                 get { throw new NotImplementedException (); }
 112                 set { throw new NotImplementedException (); }
 113         }
 114
 115         [EditorBrowsable (EditorBrowsableState.Never)]
 116         protected int CodePage
 117         {
 118                 set { Response.ContentEncoding = Encoding.GetEncoding (value); }
 119         }
 120
 121         [EditorBrowsable (EditorBrowsableState.Never)]
 122         protected string ContentType
 123         {
 124                 set { Response.ContentType = value; }
 125         }
 126
 127         protected override HttpContext Context
 128         {
 129                 get { return _context; }
 130         }
 131
 132         [EditorBrowsable (EditorBrowsableState.Never)]
 133         protected string Culture
 134         {
 135                 set { Thread.CurrentThread.CurrentCulture = new CultureInfo (value); }
 136         }
 137
 138         [Browsable (false)]
 139         public override bool EnableViewState
 140         {
 141                 get { return _viewState; }
 142                 set { _viewState = value; }
 143         }
 144
 145         [EditorBrowsable (EditorBrowsableState.Never)]
 146         protected bool EnableViewStateMac
 147         {
 148                 get { return _viewStateMac; }
 149                 set { _viewStateMac = value; }
 150         }
 151
 152         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 153         [Browsable (false), DefaultValue ("")]
 154         [WebSysDescription ("The URL of a page used for error redirection.")]
 155         public string ErrorPage
 156         {
 157                 get { return _errorPage; }
 158                 set {
 159                         _errorPage = value;
 160                         if (_context != null)
 161                                 _context.ErrorPage = value;
 162                 }
 163         }
 164
 165         [EditorBrowsable (EditorBrowsableState.Never)]
 166         protected ArrayList FileDependencies
 167         {
 168                 set {
 169                         if (Response != null)
 170                                 Response.AddFileDependencies (value);
 171                 }
 172         }
 173
 174         [Browsable (false)]
 175         public override string ID
 176         {
 177                 get { return base.ID; }
 178                 set { base.ID = value; }
 179         }
 180
 181         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 182         [Browsable (false)]
 183         public bool IsPostBack
 184         {
 185                 get {
 186                         return (0 == String.Compare (Request.HttpMethod, "POST", true));
 187                 }
 188         }
 189
 190         [EditorBrowsable (EditorBrowsableState.Never), Browsable (false)]
 191         public bool IsReusable {
 192                 get { return false; }
 193         }
 194
 195         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 196         [Browsable (false)]
 197         public bool IsValid
 198         {
 199                 get { return _isValid; }
 200         }
 201
 202         [EditorBrowsable (EditorBrowsableState.Never)]
 203         protected int LCID {
 204                 set { Thread.CurrentThread.CurrentCulture = new CultureInfo (value); }
 205         }
 206
 207         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 208         [Browsable (false)]
 209         public HttpRequest Request
 210         {
 211                 get { return _context.Request; }
 212         }
 213
 214         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 215         [Browsable (false)]
 216         public HttpResponse Response
 217         {
 218                 get { return _context.Response; }
 219         }
 220
 221         [EditorBrowsable (EditorBrowsableState.Never)]
 222         protected string ResponseEncoding
 223         {
 224                 set { Response.ContentEncoding = Encoding.GetEncoding (value); }
 225         }
 226
 227         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 228         [Browsable (false)]
 229         public HttpServerUtility Server
 230         {
 231                 get {
 232                         return Context.Server;
 233                 }
 234         }
 235
 236         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 237         [Browsable (false)]
 238         public virtual HttpSessionState Session
 239         {
 240                 get {
 241                         if (_context.Session == null)
 242                                 throw new HttpException ("Session state can only be used " +
 243                                                 "when enableSessionState is set to true, either " +
 244                                                 "in a configuration file or in the Page directive.");
 245
 246                         return _context.Session;
 247                 }
 248         }
 249
 250         [Browsable (false)]
 251         public bool SmartNavigation
 252         {
 253                 get { return _smartNavigation; }
 254                 set { _smartNavigation = value; }
 255         }
 256
 257         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 258         [Browsable (false)]
 259         public TraceContext Trace
 260         {
 261                 get { return Context.Trace; }
 262         }
 263
 264         [EditorBrowsable (EditorBrowsableState.Never)]
 265         protected bool TraceEnabled
 266         {
 267                 set { Trace.IsEnabled = value; }
 268         }
 269
 270         [EditorBrowsable (EditorBrowsableState.Never)]
 271         protected TraceMode TraceModeValue
 272         {
 273                 set { Trace.TraceMode = value; }
 274         }
 275
 276         [EditorBrowsable (EditorBrowsableState.Never)]
 277         protected int TransactionMode
 278         {
 279                 set { _transactionMode = value; }
 280         }
 281
 282         [EditorBrowsable (EditorBrowsableState.Never)]
 283         protected string UICulture
 284         {
 285                 set { Thread.CurrentThread.CurrentUICulture = new CultureInfo (value); }
 286         }
 287
 288         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 289         [Browsable (false)]
 290         public IPrincipal User
 291         {
 292                 get { return _context.User; }
 293         }
 294
 295         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 296         [Browsable (false)]
 297         public ValidatorCollection Validators
 298         {
 299                 get {
 300                         if (_validators == null)
 301                                 _validators = new ValidatorCollection ();
 302                         return _validators;
 303                 }
 304         }
 305
 306         [MonoTODO ("Use this when encrypting/decrypting ViewState")]
 307         [Browsable (false)]
 308         public string ViewStateUserKey {
 309                 get { return viewStateUserKey; }
 310                 set { viewStateUserKey = value; }
 311         }
 312
 313         [Browsable (false)]
 314         public override bool Visible
 315         {
 316                 get { return base.Visible; }
 317                 set { base.Visible = value; }
 318         }
 319
 320         #endregion
 321
 322         #region Methods
 323
 324         [EditorBrowsable (EditorBrowsableState.Never)]
 325         protected IAsyncResult AspCompatBeginProcessRequest (HttpContext context,
 326                                                              AsyncCallback cb,
 327                                                              object extraData)
 328         {
 329                 throw new NotImplementedException ();
 330         }
 331
 332         [EditorBrowsable (EditorBrowsableState.Never)]
 333         protected void AspCompatEndProcessRequest (IAsyncResult result)
 334         {
 335                 throw new NotImplementedException ();
 336         }
 337
 338         [EditorBrowsable (EditorBrowsableState.Advanced)]
 339         protected virtual HtmlTextWriter CreateHtmlTextWriter (TextWriter tw)
 340         {
 341                 return new HtmlTextWriter (tw);
 342         }
 343
 344         [EditorBrowsable (EditorBrowsableState.Never)]
 345         public void DesignerInitialize ()
 346         {
 347                 InitRecursive (null);
 348         }
 349
 350         [EditorBrowsable (EditorBrowsableState.Advanced)]
 351         protected virtual NameValueCollection DeterminePostBackMode ()
 352         {
 353                 if (_context == null)
 354                         return null;
 355
 356                 HttpRequest req = _context.Request;
 357                 if (req == null)
 358                         return null;
 359
 360                 NameValueCollection coll = null;
 361                 if (IsPostBack)
 362                         coll =  req.Form;
 363                 else
 364                         coll = req.QueryString;
 365
 366
 367                 if (coll == null || coll ["__VIEWSTATE"] == null)
 368                         return null;
 369
 370                 return coll;
 371         }
 372
 373         [EditorBrowsable (EditorBrowsableState.Advanced)]
 374         public string GetPostBackClientEvent (Control control, string argument)
 375         {
 376                 return GetPostBackEventReference (control, argument);
 377         }
 378
 379         [EditorBrowsable (EditorBrowsableState.Advanced)]
 380         public string GetPostBackClientHyperlink (Control control, string argument)
 381         {
 382                 return "javascript:" + GetPostBackEventReference (control, argument);
 383         }
 384
 385         [EditorBrowsable (EditorBrowsableState.Advanced)]
 386         public string GetPostBackEventReference (Control control)
 387         {
 388                 return GetPostBackEventReference (control, "");
 389         }
 390
 391         [EditorBrowsable (EditorBrowsableState.Advanced)]
 392         public string GetPostBackEventReference (Control control, string argument)
 393         {
 394                 RequiresPostBackScript ();
 395                 return String.Format ("__doPostBack('{0}','{1}')", control.UniqueID, argument);
 396         }
 397
 398         internal void RequiresPostBackScript ()
 399         {
 400                 requiresPostBackScript = true;
 401         }
 402
 403         [EditorBrowsable (EditorBrowsableState.Never)]
 404         public virtual int GetTypeHashCode ()
 405         {
 406                 return 0;
 407         }
 408
 409         [MonoTODO]
 410         [EditorBrowsable (EditorBrowsableState.Never)]
 411         protected virtual void InitOutputCache (int duration,
 412                                                 string varyByHeader,
 413                                                 string varyByCustom,
 414                                                 OutputCacheLocation location,
 415                                                 string varyByParam)
 416         {
 417                 HttpCachePolicy cache = _context.Response.Cache;
 418
 419                 switch (location) {
 420                 case OutputCacheLocation.Any:
 421                         cache.SetCacheability (HttpCacheability.Public);
 422                         cache.SetMaxAge (new TimeSpan (0, 0, duration));
 423                         cache.SetLastModified (_context.Timestamp);
 424                         goto case OutputCacheLocation.Server;
 425                 case OutputCacheLocation.Client:
 426                         cache.SetCacheability (HttpCacheability.Private);
 427                         cache.SetMaxAge (new TimeSpan (0, 0, duration));
 428                         cache.SetLastModified (_context.Timestamp);
 429                         break;
 430                 case OutputCacheLocation.Downstream:
 431                         cache.SetCacheability (HttpCacheability.Public);
 432                         cache.SetMaxAge (new TimeSpan (0, 0, duration));
 433                         cache.SetLastModified (_context.Timestamp);
 434                         break;
 435                 case OutputCacheLocation.Server:
 436                         if (varyByCustom != null)
 437                                 cache.SetVaryByCustom (varyByCustom);
 438
 439                         if (varyByParam.Length > 0) {
 440                                 string[] prms = varyByParam.Split (';');
 441                                 foreach (string p in prms)
 442                                         cache.VaryByParams [p.Trim ()] = true;
 443                                 cache.VaryByParams.IgnoreParams = false;
 444                         } else {
 445                                 cache.VaryByParams.IgnoreParams = true;
 446                         }
 447
 448                         if (varyByHeader != null) {
 449                                 string[] hdrs = varyByHeader.Split (';');
 450                                 foreach (string h in hdrs)
 451                                         cache.VaryByHeaders [h.Trim ()] = true;
 452                         }
 453                         break;
 454                 case OutputCacheLocation.None:
 455                         break;
 456                 }
 457                 cache.Duration = duration;
 458                 cache.SetExpires (_context.Timestamp.AddSeconds (duration));
 459         }
 460
 461         [EditorBrowsable (EditorBrowsableState.Advanced)]
 462         public bool IsClientScriptBlockRegistered (string key)
 463         {
 464                 if (clientScriptBlocks == null)
 465                         return false;
 466
 467                 return clientScriptBlocks.ContainsKey (key);
 468         }
 469
 470         [EditorBrowsable (EditorBrowsableState.Advanced)]
 471         public bool IsStartupScriptRegistered (string key)
 472         {
 473                 if (startupScriptBlocks == null)
 474                         return false;
 475
 476                 return startupScriptBlocks.ContainsKey (key);
 477         }
 478
 479         public string MapPath (string virtualPath)
 480         {
 481                 return Request.MapPath (virtualPath);
 482         }
 483
 484         private void RenderPostBackScript (HtmlTextWriter writer, string formUniqueID)
 485         {
 486                 writer.WriteLine ("<input type=\"hidden\" name=\"{0}\" value=\"\" />", postEventSourceID);
 487                 writer.WriteLine ("<input type=\"hidden\" name=\"{0}\" value=\"\" />", postEventArgumentID);
 488                 writer.WriteLine ();
 489                 writer.WriteLine ("<script language=\"javascript\">");
 490                 writer.WriteLine ("<!--");
 491                 writer.WriteLine ("\tfunction __doPostBack(eventTarget, eventArgument) {");
 492                 writer.WriteLine ("\t\tvar theform = document.getElementById ('{0}');", formUniqueID);
 493                 writer.WriteLine ("\t\ttheform.{0}.value = eventTarget;", postEventSourceID);
 494                 writer.WriteLine ("\t\ttheform.{0}.value = eventArgument;", postEventArgumentID);
 495                 writer.WriteLine ("\t\ttheform.submit();");
 496                 writer.WriteLine ("\t}");
 497                 writer.WriteLine ("// -->");
 498                 writer.WriteLine ("</script>");
 499         }
 500
 501         static void WriteScripts (HtmlTextWriter writer, Hashtable scripts)
 502         {
 503                 if (scripts == null)
 504                         return;
 505
 506                 foreach (string key in scripts.Values)
 507                         writer.WriteLine (key);
 508         }
 509
 510         void WriteHiddenFields (HtmlTextWriter writer)
 511         {
 512                 if (hiddenFields == null)
 513                         return;
 514
 515                 foreach (string key in hiddenFields.Keys) {
 516                         string value = hiddenFields [key] as string;
 517                         writer.WriteLine ("\n<input type=\"hidden\" name=\"{0}\" value=\"{1}\" />", key, value);
 518                 }
 519
 520                 hiddenFields = null;
 521         }
 522
 523         internal void OnFormRender (HtmlTextWriter writer, string formUniqueID)
 524         {
 525                 if (renderingForm)
 526                         throw new HttpException ("Only 1 HtmlForm is allowed per page.");
 527
 528                 renderingForm = true;
 529                 writer.WriteLine ();
 530                 WriteHiddenFields (writer);
 531                 if (requiresPostBackScript) {
 532                         RenderPostBackScript (writer, formUniqueID);
 533                         postBackScriptRendered = true;
 534                 }
 535
 536                 if (handleViewState) {
 537                         writer.Write ("<input type=\"hidden\" name=\"__VIEWSTATE\" ");
 538                         writer.WriteLine ("value=\"{0}\" />", GetViewStateString ());
 539                 }
 540
 541                 WriteScripts (writer, clientScriptBlocks);
 542         }
 543
 544         internal string GetViewStateString ()
 545         {
 546                 StringWriter sr = new StringWriter ();
 547                 LosFormatter fmt = new LosFormatter ();
 548                 fmt.Serialize (sr, _savedViewState);
 549                 return sr.GetStringBuilder ().ToString ();
 550         }
 551
 552         internal void OnFormPostRender (HtmlTextWriter writer, string formUniqueID)
 553         {
 554                 if (registeredArrayDeclares != null) {
 555                         writer.WriteLine();
 556                         writer.WriteLine("<script language=\"javascript\">");
 557                         writer.WriteLine("<!--");
 558                         IDictionaryEnumerator arrayEnum = registeredArrayDeclares.GetEnumerator();
 559                         while (arrayEnum.MoveNext()) {
 560                                 writer.Write("\tvar ");
 561                                 writer.Write(arrayEnum.Key);
 562                                 writer.Write(" =  new Array(");
 563                                 IEnumerator arrayListEnum = ((ArrayList) arrayEnum.Value).GetEnumerator();
 564                                 bool isFirst = true;
 565                                 while (arrayListEnum.MoveNext()) {
 566                                         if (isFirst)
 567                                                 isFirst = false;
 568                                         else
 569                                                 writer.Write(", ");
 570                                         writer.Write(arrayListEnum.Current);
 571                                 }
 572                                 writer.WriteLine(");");
 573                         }
 574                         writer.WriteLine("// -->");
 575                         writer.WriteLine("</script>");
 576                         writer.WriteLine();
 577                 }
 578
 579                 if (!postBackScriptRendered && requiresPostBackScript)
 580                         RenderPostBackScript (writer, formUniqueID);
 581
 582                 WriteHiddenFields (writer);
 583                 WriteScripts (writer, startupScriptBlocks);
 584                 renderingForm = false;
 585                 postBackScriptRendered = false;
 586         }
 587
 588         private void ProcessPostData (NameValueCollection data, bool second)
 589         {
 590                 if (data == null)
 591                         return;
 592
 593                 if (_requiresPostBackCopy == null && _requiresPostBack != null)
 594                         _requiresPostBackCopy = (ArrayList) _requiresPostBack.Clone ();
 595
 596                 Hashtable used = new Hashtable ();
 597                 foreach (string id in data.AllKeys){
 598                         if (id == "__VIEWSTATE" || id == postEventSourceID || id == postEventArgumentID)
 599                                 continue;
 600
 601                         string real_id = id;
 602                         int dot = real_id.IndexOf ('.');
 603                         if (dot >= 1)
 604                                 real_id = real_id.Substring (0, dot);
 605
 606                         if (real_id == null || used.ContainsKey (real_id))
 607                                 continue;
 608
 609                         used.Add (real_id, real_id);
 610
 611                         Control ctrl = FindControl (real_id);
 612                         if (ctrl != null){
 613                                 IPostBackDataHandler pbdh = ctrl as IPostBackDataHandler;
 614                                 IPostBackEventHandler pbeh = ctrl as IPostBackEventHandler;
 615
 616                                 if (pbdh == null) {
 617                                         if (pbeh != null)
 618                                                 RegisterRequiresRaiseEvent (pbeh);
 619                                         continue;
 620                                 }
 621
 622                                 if (pbdh.LoadPostData (real_id, data) == true) {
 623                                         if (requiresPostDataChanged == null)
 624                                                 requiresPostDataChanged = new ArrayList ();
 625                                         requiresPostDataChanged.Add (pbdh);
 626                                         if (_requiresPostBackCopy != null)
 627                                                 _requiresPostBackCopy.Remove (ctrl.UniqueID);
 628                                 }
 629                         } else if (!second) {
 630                                 if (secondPostData == null)
 631                                         secondPostData = new NameValueCollection ();
 632                                 secondPostData.Add (real_id, data [id]);
 633                         }
 634                 }
 635
 636                 if (_requiresPostBackCopy != null && _requiresPostBackCopy.Count > 0) {
 637                         string [] handlers = (string []) _requiresPostBackCopy.ToArray (typeof (string));
 638                         foreach (string id in handlers) {
 639                                 IPostBackDataHandler pbdh = FindControl (id) as IPostBackDataHandler;
 640                                 if (pbdh == null)
 641                                         continue;
 642
 643                                 _requiresPostBackCopy.Remove (id);
 644                                 if (pbdh.LoadPostData (id, data)) {
 645                                         if (requiresPostDataChanged == null)
 646                                                 requiresPostDataChanged = new ArrayList ();
 647
 648                                         requiresPostDataChanged.Add (pbdh);
 649                                 }
 650                         }
 651                 }
 652         }
 653
 654         [EditorBrowsable (EditorBrowsableState.Never)]
 655         public void ProcessRequest (HttpContext context)
 656         {
 657                 _context = context;
 658                 WireupAutomaticEvents ();
 659                 //-- Control execution lifecycle in the docs
 660
 661                 // Save culture information because it can be modified in FrameworkInitialize()
 662                 CultureInfo culture = Thread.CurrentThread.CurrentCulture;
 663                 CultureInfo uiculture = Thread.CurrentThread.CurrentUICulture;
 664                 FrameworkInitialize ();
 665                 context.ErrorPage = _errorPage;
 666
 667                 try {
 668                         InternalProcessRequest ();
 669                 } finally {
 670                         try {
 671                                 UnloadRecursive (true);
 672                         } catch {}
 673                         Thread.CurrentThread.CurrentCulture = culture;
 674                         Thread.CurrentThread.CurrentUICulture = uiculture;
 675                 }
 676         }
 677
 678         void InternalProcessRequest ()
 679         {
 680                 Trace.Write ("aspx.page", "Begin Init");
 681                 InitRecursive (null);
 682                 Trace.Write ("aspx.page", "End Init");
 683
 684                 renderingForm = false;
 685                 if (IsPostBack) {
 686                         Trace.Write ("aspx.page", "Begin LoadViewState");
 687                         LoadPageViewState ();
 688                         Trace.Write ("aspx.page", "End LoadViewState");
 689                         Trace.Write ("aspx.page", "Begin ProcessPostData");
 690                         ProcessPostData (DeterminePostBackMode (), false);
 691                         Trace.Write ("aspx.page", "End ProcessPostData");
 692                 }
 693
 694                 LoadRecursive ();
 695                 if (IsPostBack) {
 696                         Trace.Write ("aspx.page", "Begin ProcessPostData Second Try");
 697                         ProcessPostData (secondPostData, true);
 698                         Trace.Write ("aspx.page", "End ProcessPostData Second Try");
 699                         Trace.Write ("aspx.page", "Begin Raise ChangedEvents");
 700                         RaiseChangedEvents ();
 701                         Trace.Write ("aspx.page", "End Raise ChangedEvents");
 702                         Trace.Write ("aspx.page", "Begin Raise PostBackEvent");
 703                         RaisePostBackEvents ();
 704                         Trace.Write ("aspx.page", "End Raise PostBackEvent");
 705                 }
 706                 Trace.Write ("aspx.page", "Begin PreRender");
 707                 PreRenderRecursiveInternal ();
 708                 Trace.Write ("aspx.page", "End PreRender");
 709
 710                 Trace.Write ("aspx.page", "Begin SaveViewState");
 711                 SavePageViewState ();
 712                 Trace.Write ("aspx.page", "End SaveViewState");
 713
 714                 //--
 715                 Trace.Write ("aspx.page", "Begin Render");
 716                 HtmlTextWriter output = new HtmlTextWriter (_context.Response.Output);
 717                 RenderControl (output);
 718                 Trace.Write ("aspx.page", "End Render");
 719
 720                 RenderTrace (output);
 721                 _context = null;
 722         }
 723
 724         private void RenderTrace (HtmlTextWriter output)
 725         {
 726                 TraceManager manager = HttpRuntime.TraceManager;
 727
 728                 if (!Trace.IsEnabled && !manager.Enabled)
 729                         return;
 730
 731                 Trace.SaveData ();
 732
 733                 if (Trace.IsEnabled || manager.PageOutput)
 734                         Trace.Render (output);
 735         }
 736
 737         internal void RaisePostBackEvents ()
 738         {
 739                 if (requiresRaiseEvent != null) {
 740                         RaisePostBackEvent (requiresRaiseEvent, null);
 741                         return;
 742                 }
 743
 744                 NameValueCollection postdata = DeterminePostBackMode ();
 745                 if (postdata == null)
 746                         return;
 747
 748                 string eventTarget = postdata [postEventSourceID];
 749                 if (eventTarget == null || eventTarget.Length == 0)
 750                         return;
 751
 752                 IPostBackEventHandler target = FindControl (eventTarget) as IPostBackEventHandler;
 753                 if (target == null)
 754                         return;
 755
 756                 string eventArgument = postdata [postEventArgumentID];
 757                 RaisePostBackEvent (target, eventArgument);
 758         }
 759
 760         internal void RaiseChangedEvents ()
 761         {
 762                 if (requiresPostDataChanged == null)
 763                         return;
 764
 765                 foreach (IPostBackDataHandler ipdh in requiresPostDataChanged)
 766                         ipdh.RaisePostDataChangedEvent ();
 767
 768                 requiresPostDataChanged = null;
 769         }
 770
 771         [EditorBrowsable (EditorBrowsableState.Advanced)]
 772         protected virtual void RaisePostBackEvent (IPostBackEventHandler sourceControl, string eventArgument)
 773         {
 774                 sourceControl.RaisePostBackEvent (eventArgument);
 775         }
 776
 777         [EditorBrowsable (EditorBrowsableState.Advanced)]
 778         public void RegisterArrayDeclaration (string arrayName, string arrayValue)
 779         {
 780                 if (registeredArrayDeclares == null)
 781                         registeredArrayDeclares = new Hashtable();
 782
 783                 if (!registeredArrayDeclares.ContainsKey (arrayName))
 784                         registeredArrayDeclares.Add (arrayName, new ArrayList());
 785
 786                 ((ArrayList) registeredArrayDeclares[arrayName]).Add(arrayValue);
 787         }
 788
 789         [EditorBrowsable (EditorBrowsableState.Advanced)]
 790         public virtual void RegisterClientScriptBlock (string key, string script)
 791         {
 792                 if (IsClientScriptBlockRegistered (key))
 793                         return;
 794
 795                 if (clientScriptBlocks == null)
 796                         clientScriptBlocks = new Hashtable ();
 797
 798                 clientScriptBlocks.Add (key, script);
 799         }
 800
 801         [EditorBrowsable (EditorBrowsableState.Advanced)]
 802         public virtual void RegisterHiddenField (string hiddenFieldName, string hiddenFieldInitialValue)
 803         {
 804                 if (hiddenFields == null)
 805                         hiddenFields = new Hashtable ();
 806
 807                 if (!hiddenFields.ContainsKey (hiddenFieldName))
 808                         hiddenFields.Add (hiddenFieldName, hiddenFieldInitialValue);
 809         }
 810         [MonoTODO("Used in HtmlForm")]
 811         internal void RegisterClientScriptFile (string a, string b, string c)
 812         {
 813                 throw new NotImplementedException ();
 814         }
 815
 816
 817         [MonoTODO]
 818         [EditorBrowsable (EditorBrowsableState.Advanced)]
 819         public void RegisterOnSubmitStatement (string key, string script)
 820         {
 821                 if (submitStatements == null)
 822                         submitStatements = new Hashtable ();
 823
 824                 if (submitStatements.ContainsKey (key))
 825                         return;
 826
 827                 submitStatements.Add (key, script);
 828         }
 829
 830         [EditorBrowsable (EditorBrowsableState.Advanced)]
 831         public void RegisterRequiresPostBack (Control control)
 832         {
 833                 if (_requiresPostBack == null)
 834                         _requiresPostBack = new ArrayList ();
 835
 836                 _requiresPostBack.Add (control.UniqueID);
 837         }
 838
 839         [EditorBrowsable (EditorBrowsableState.Advanced)]
 840         public virtual void RegisterRequiresRaiseEvent (IPostBackEventHandler control)
 841         {
 842                 requiresRaiseEvent = control;
 843         }
 844
 845         [EditorBrowsable (EditorBrowsableState.Advanced)]
 846         public virtual void RegisterStartupScript (string key, string script)
 847         {
 848                 if (IsStartupScriptRegistered (key))
 849                         return;
 850
 851                 if (startupScriptBlocks == null)
 852                         startupScriptBlocks = new Hashtable ();
 853
 854                 startupScriptBlocks.Add (key, script);
 855         }
 856
 857         [EditorBrowsable (EditorBrowsableState.Advanced)]
 858         public void RegisterViewStateHandler ()
 859         {
 860                 handleViewState = true;
 861         }
 862
 863         [EditorBrowsable (EditorBrowsableState.Advanced)]
 864         protected virtual void SavePageStateToPersistenceMedium (object viewState)
 865         {
 866                 _savedViewState = viewState;
 867         }
 868
 869         [EditorBrowsable (EditorBrowsableState.Advanced)]
 870         protected virtual object LoadPageStateFromPersistenceMedium ()
 871         {
 872                 NameValueCollection postdata = DeterminePostBackMode ();
 873                 string view_state;
 874                 if (postdata == null || (view_state = postdata ["__VIEWSTATE"]) == null)
 875                         return null;
 876
 877                 _savedViewState = null;
 878                 LosFormatter fmt = new LosFormatter ();
 879
 880                 try {
 881                         _savedViewState = fmt.Deserialize (view_state);
 882                 } catch (Exception e) {
 883                         throw new HttpException ("Error restoring page viewstate.\n", e);
 884                 }
 885
 886                 return _savedViewState;
 887         }
 888
 889         internal void LoadPageViewState()
 890         {
 891                 object sState = LoadPageStateFromPersistenceMedium ();
 892                 if (sState != null) {
 893                         Pair pair = (Pair) sState;
 894                         LoadViewStateRecursive (pair.First);
 895                         _requiresPostBack = pair.Second as ArrayList;
 896                 }
 897         }
 898
 899         internal void SavePageViewState ()
 900         {
 901                 if (!handleViewState)
 902                         return;
 903
 904                 Pair pair = new Pair ();
 905                 pair.First = SaveViewStateRecursive ();
 906                 if (_requiresPostBack != null && _requiresPostBack.Count > 0)
 907                         pair.Second = _requiresPostBack;
 908
 909                 if (pair.First == null && pair.Second == null)
 910                         pair = null;
 911
 912                 SavePageStateToPersistenceMedium (pair);
 913         }
 914
 915         public virtual void Validate ()
 916         {
 917                 if (_validators == null || _validators.Count == 0){
 918                         _isValid = true;
 919                         return;
 920                 }
 921
 922                 bool all_valid = true;
 923                 foreach (IValidator v in _validators){
 924                         v.Validate ();
 925                         if (v.IsValid == false)
 926                                 all_valid = false;
 927                 }
 928
 929                 if (all_valid)
 930                         _isValid = true;
 931         }
 932
 933         [EditorBrowsable (EditorBrowsableState.Advanced)]
 934         public virtual void VerifyRenderingInServerForm (Control control)
 935         {
 936                 if (!renderingForm)
 937                         throw new HttpException ("Control '" + control.ClientID + " " + control.GetType () +
 938                                                  "' must be rendered within a HtmlForm");
 939         }
 940
 941         #endregion
 942
 943         #if NET_1_2
 944         public string GetWebResourceUrl(Type type, string resourceName)
 945         {
 946                 if (type == null)
 947                         throw new ArgumentNullException ("type");
 948
 949                 if (resourceName == null || resourceName.Length == 0)
 950                         throw new ArgumentNullException ("type");
 951
 952                 return System.Web.Handlers.AssemblyResourceLoader.GetResourceUrl (type, resourceName);
 953         }
 954
 955         Stack dataItemCtx;
 956
 957         internal void PushDataItemContext (object o)
 958         {
 959                 if (dataItemCtx == null)
 960                         dataItemCtx = new Stack ();
 961
 962                 dataItemCtx.Push (o);
 963         }
 964
 965         internal void PopDataItemContext ()
 966         {
 967                 if (dataItemCtx == null)
 968                         throw new InvalidOperationException ();
 969
 970                 dataItemCtx.Pop ();
 971         }
 972
 973         internal object CurrentDataItem {
 974                 get {
 975                         if (dataItemCtx == null)
 976                                 throw new InvalidOperationException ("No data item");
 977
 978                         return dataItemCtx.Peek ();
 979                 }
 980         }
 981
 982         protected object Eval (string expression)
 983         {
 984                 return DataBinder.Eval (CurrentDataItem, expression);
 985         }
 986
 987         protected object Eval (string expression, string format)
 988         {
 989                 return DataBinder.Eval (CurrentDataItem, expression, format);
 990         }
 991
 992         protected object XPath (string xpathexpression)
 993         {
 994                 return XPathBinder.Eval (CurrentDataItem, xpathexpression);
 995         }
 996
 997         protected object XPath (string xpathexpression, string format)
 998         {
 999                 return XPathBinder.Eval (CurrentDataItem, xpathexpression, format);
1000         }
1001
1002         protected IEnumerable XPathSelect (string xpathexpression)
1003         {
1004                 return XPathBinder.Select (CurrentDataItem, xpathexpression);
1005         }
1006
1007         #endif
1008 }
1009 }