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 != null && 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 && varyByHeader.Length > 0) {
 449                                 string[] hdrs = varyByHeader.Split (';');
 450                                 foreach (string h in hdrs)
 451                                         cache.VaryByHeaders [h.Trim ()] = true;
 452                         }
 453
 454                         cache.SetCacheability (HttpCacheability.Server);
 455                         break;
 456                 case OutputCacheLocation.None:
 457                         break;
 458                 }
 459                 cache.Duration = duration;
 460                 cache.SetExpires (_context.Timestamp.AddSeconds (duration));
 461         }
 462
 463         [EditorBrowsable (EditorBrowsableState.Advanced)]
 464         public bool IsClientScriptBlockRegistered (string key)
 465         {
 466                 if (clientScriptBlocks == null)
 467                         return false;
 468
 469                 return clientScriptBlocks.ContainsKey (key);
 470         }
 471
 472         [EditorBrowsable (EditorBrowsableState.Advanced)]
 473         public bool IsStartupScriptRegistered (string key)
 474         {
 475                 if (startupScriptBlocks == null)
 476                         return false;
 477
 478                 return startupScriptBlocks.ContainsKey (key);
 479         }
 480
 481         public string MapPath (string virtualPath)
 482         {
 483                 return Request.MapPath (virtualPath);
 484         }
 485
 486         private void RenderPostBackScript (HtmlTextWriter writer, string formUniqueID)
 487         {
 488                 writer.WriteLine ("<input type=\"hidden\" name=\"{0}\" value=\"\" />", postEventSourceID);
 489                 writer.WriteLine ("<input type=\"hidden\" name=\"{0}\" value=\"\" />", postEventArgumentID);
 490                 writer.WriteLine ();
 491                 writer.WriteLine ("<script language=\"javascript\">");
 492                 writer.WriteLine ("<!--");
 493                 writer.WriteLine ("\tfunction __doPostBack(eventTarget, eventArgument) {");
 494                 writer.WriteLine ("\t\tvar theform = document.getElementById ('{0}');", formUniqueID);
 495                 writer.WriteLine ("\t\ttheform.{0}.value = eventTarget;", postEventSourceID);
 496                 writer.WriteLine ("\t\ttheform.{0}.value = eventArgument;", postEventArgumentID);
 497                 writer.WriteLine ("\t\ttheform.submit();");
 498                 writer.WriteLine ("\t}");
 499                 writer.WriteLine ("// -->");
 500                 writer.WriteLine ("</script>");
 501         }
 502
 503         static void WriteScripts (HtmlTextWriter writer, Hashtable scripts)
 504         {
 505                 if (scripts == null)
 506                         return;
 507
 508                 foreach (string key in scripts.Values)
 509                         writer.WriteLine (key);
 510         }
 511
 512         void WriteHiddenFields (HtmlTextWriter writer)
 513         {
 514                 if (hiddenFields == null)
 515                         return;
 516
 517                 foreach (string key in hiddenFields.Keys) {
 518                         string value = hiddenFields [key] as string;
 519                         writer.WriteLine ("\n<input type=\"hidden\" name=\"{0}\" value=\"{1}\" />", key, value);
 520                 }
 521
 522                 hiddenFields = null;
 523         }
 524
 525         internal void OnFormRender (HtmlTextWriter writer, string formUniqueID)
 526         {
 527                 if (renderingForm)
 528                         throw new HttpException ("Only 1 HtmlForm is allowed per page.");
 529
 530                 renderingForm = true;
 531                 writer.WriteLine ();
 532                 WriteHiddenFields (writer);
 533                 if (requiresPostBackScript) {
 534                         RenderPostBackScript (writer, formUniqueID);
 535                         postBackScriptRendered = true;
 536                 }
 537
 538                 if (handleViewState) {
 539                         writer.Write ("<input type=\"hidden\" name=\"__VIEWSTATE\" ");
 540                         writer.WriteLine ("value=\"{0}\" />", GetViewStateString ());
 541                 }
 542
 543                 WriteScripts (writer, clientScriptBlocks);
 544         }
 545
 546         internal string GetViewStateString ()
 547         {
 548                 StringWriter sr = new StringWriter ();
 549                 LosFormatter fmt = new LosFormatter ();
 550                 fmt.Serialize (sr, _savedViewState);
 551                 return sr.GetStringBuilder ().ToString ();
 552         }
 553
 554         internal void OnFormPostRender (HtmlTextWriter writer, string formUniqueID)
 555         {
 556                 if (registeredArrayDeclares != null) {
 557                         writer.WriteLine();
 558                         writer.WriteLine("<script language=\"javascript\">");
 559                         writer.WriteLine("<!--");
 560                         IDictionaryEnumerator arrayEnum = registeredArrayDeclares.GetEnumerator();
 561                         while (arrayEnum.MoveNext()) {
 562                                 writer.Write("\tvar ");
 563                                 writer.Write(arrayEnum.Key);
 564                                 writer.Write(" =  new Array(");
 565                                 IEnumerator arrayListEnum = ((ArrayList) arrayEnum.Value).GetEnumerator();
 566                                 bool isFirst = true;
 567                                 while (arrayListEnum.MoveNext()) {
 568                                         if (isFirst)
 569                                                 isFirst = false;
 570                                         else
 571                                                 writer.Write(", ");
 572                                         writer.Write(arrayListEnum.Current);
 573                                 }
 574                                 writer.WriteLine(");");
 575                         }
 576                         writer.WriteLine("// -->");
 577                         writer.WriteLine("</script>");
 578                         writer.WriteLine();
 579                 }
 580
 581                 if (!postBackScriptRendered && requiresPostBackScript)
 582                         RenderPostBackScript (writer, formUniqueID);
 583
 584                 WriteHiddenFields (writer);
 585                 WriteScripts (writer, startupScriptBlocks);
 586                 renderingForm = false;
 587                 postBackScriptRendered = false;
 588         }
 589
 590         private void ProcessPostData (NameValueCollection data, bool second)
 591         {
 592                 if (data == null)
 593                         return;
 594
 595                 if (_requiresPostBackCopy == null && _requiresPostBack != null)
 596                         _requiresPostBackCopy = (ArrayList) _requiresPostBack.Clone ();
 597
 598                 Hashtable used = new Hashtable ();
 599                 foreach (string id in data.AllKeys){
 600                         if (id == "__VIEWSTATE" || id == postEventSourceID || id == postEventArgumentID)
 601                                 continue;
 602
 603                         string real_id = id;
 604                         int dot = real_id.IndexOf ('.');
 605                         if (dot >= 1)
 606                                 real_id = real_id.Substring (0, dot);
 607
 608                         if (real_id == null || used.ContainsKey (real_id))
 609                                 continue;
 610
 611                         used.Add (real_id, real_id);
 612
 613                         Control ctrl = FindControl (real_id);
 614                         if (ctrl != null){
 615                                 IPostBackDataHandler pbdh = ctrl as IPostBackDataHandler;
 616                                 IPostBackEventHandler pbeh = ctrl as IPostBackEventHandler;
 617
 618                                 if (pbdh == null) {
 619                                         if (pbeh != null)
 620                                                 RegisterRequiresRaiseEvent (pbeh);
 621                                         continue;
 622                                 }
 623
 624                                 if (pbdh.LoadPostData (real_id, data) == true) {
 625                                         if (requiresPostDataChanged == null)
 626                                                 requiresPostDataChanged = new ArrayList ();
 627                                         requiresPostDataChanged.Add (pbdh);
 628                                         if (_requiresPostBackCopy != null)
 629                                                 _requiresPostBackCopy.Remove (ctrl.UniqueID);
 630                                 }
 631                         } else if (!second) {
 632                                 if (secondPostData == null)
 633                                         secondPostData = new NameValueCollection ();
 634                                 secondPostData.Add (real_id, data [id]);
 635                         }
 636                 }
 637
 638                 if (_requiresPostBackCopy != null && _requiresPostBackCopy.Count > 0) {
 639                         string [] handlers = (string []) _requiresPostBackCopy.ToArray (typeof (string));
 640                         foreach (string id in handlers) {
 641                                 IPostBackDataHandler pbdh = FindControl (id) as IPostBackDataHandler;
 642                                 if (pbdh == null)
 643                                         continue;
 644
 645                                 _requiresPostBackCopy.Remove (id);
 646                                 if (pbdh.LoadPostData (id, data)) {
 647                                         if (requiresPostDataChanged == null)
 648                                                 requiresPostDataChanged = new ArrayList ();
 649
 650                                         requiresPostDataChanged.Add (pbdh);
 651                                 }
 652                         }
 653                 }
 654         }
 655
 656         [EditorBrowsable (EditorBrowsableState.Never)]
 657         public void ProcessRequest (HttpContext context)
 658         {
 659                 _context = context;
 660                 WireupAutomaticEvents ();
 661                 //-- Control execution lifecycle in the docs
 662
 663                 // Save culture information because it can be modified in FrameworkInitialize()
 664                 CultureInfo culture = Thread.CurrentThread.CurrentCulture;
 665                 CultureInfo uiculture = Thread.CurrentThread.CurrentUICulture;
 666                 FrameworkInitialize ();
 667                 context.ErrorPage = _errorPage;
 668
 669                 try {
 670                         InternalProcessRequest ();
 671                 } finally {
 672                         try {
 673                                 UnloadRecursive (true);
 674                         } catch {}
 675                         Thread.CurrentThread.CurrentCulture = culture;
 676                         Thread.CurrentThread.CurrentUICulture = uiculture;
 677                 }
 678         }
 679
 680         void InternalProcessRequest ()
 681         {
 682                 Trace.Write ("aspx.page", "Begin Init");
 683                 InitRecursive (null);
 684                 Trace.Write ("aspx.page", "End Init");
 685
 686                 renderingForm = false;
 687                 if (IsPostBack) {
 688                         Trace.Write ("aspx.page", "Begin LoadViewState");
 689                         LoadPageViewState ();
 690                         Trace.Write ("aspx.page", "End LoadViewState");
 691                         Trace.Write ("aspx.page", "Begin ProcessPostData");
 692                         ProcessPostData (DeterminePostBackMode (), false);
 693                         Trace.Write ("aspx.page", "End ProcessPostData");
 694                 }
 695
 696                 LoadRecursive ();
 697                 if (IsPostBack) {
 698                         Trace.Write ("aspx.page", "Begin ProcessPostData Second Try");
 699                         ProcessPostData (secondPostData, true);
 700                         Trace.Write ("aspx.page", "End ProcessPostData Second Try");
 701                         Trace.Write ("aspx.page", "Begin Raise ChangedEvents");
 702                         RaiseChangedEvents ();
 703                         Trace.Write ("aspx.page", "End Raise ChangedEvents");
 704                         Trace.Write ("aspx.page", "Begin Raise PostBackEvent");
 705                         RaisePostBackEvents ();
 706                         Trace.Write ("aspx.page", "End Raise PostBackEvent");
 707                 }
 708                 Trace.Write ("aspx.page", "Begin PreRender");
 709                 PreRenderRecursiveInternal ();
 710                 Trace.Write ("aspx.page", "End PreRender");
 711
 712                 Trace.Write ("aspx.page", "Begin SaveViewState");
 713                 SavePageViewState ();
 714                 Trace.Write ("aspx.page", "End SaveViewState");
 715
 716                 //--
 717                 Trace.Write ("aspx.page", "Begin Render");
 718                 HtmlTextWriter output = new HtmlTextWriter (_context.Response.Output);
 719                 RenderControl (output);
 720                 Trace.Write ("aspx.page", "End Render");
 721
 722                 RenderTrace (output);
 723                 _context = null;
 724         }
 725
 726         private void RenderTrace (HtmlTextWriter output)
 727         {
 728                 TraceManager manager = HttpRuntime.TraceManager;
 729
 730                 if (!Trace.IsEnabled && !manager.Enabled)
 731                         return;
 732
 733                 Trace.SaveData ();
 734
 735                 if (Trace.IsEnabled || manager.PageOutput)
 736                         Trace.Render (output);
 737         }
 738
 739         internal void RaisePostBackEvents ()
 740         {
 741                 if (requiresRaiseEvent != null) {
 742                         RaisePostBackEvent (requiresRaiseEvent, null);
 743                         return;
 744                 }
 745
 746                 NameValueCollection postdata = DeterminePostBackMode ();
 747                 if (postdata == null)
 748                         return;
 749
 750                 string eventTarget = postdata [postEventSourceID];
 751                 if (eventTarget == null || eventTarget.Length == 0) {
 752                         Validate ();
 753                         return;
 754                 }
 755
 756                 IPostBackEventHandler target = FindControl (eventTarget) as IPostBackEventHandler;
 757                 if (target == null)
 758                         return;
 759
 760                 string eventArgument = postdata [postEventArgumentID];
 761                 RaisePostBackEvent (target, eventArgument);
 762         }
 763
 764         internal void RaiseChangedEvents ()
 765         {
 766                 if (requiresPostDataChanged == null)
 767                         return;
 768
 769                 foreach (IPostBackDataHandler ipdh in requiresPostDataChanged)
 770                         ipdh.RaisePostDataChangedEvent ();
 771
 772                 requiresPostDataChanged = null;
 773         }
 774
 775         [EditorBrowsable (EditorBrowsableState.Advanced)]
 776         protected virtual void RaisePostBackEvent (IPostBackEventHandler sourceControl, string eventArgument)
 777         {
 778                 sourceControl.RaisePostBackEvent (eventArgument);
 779         }
 780
 781         [EditorBrowsable (EditorBrowsableState.Advanced)]
 782         public void RegisterArrayDeclaration (string arrayName, string arrayValue)
 783         {
 784                 if (registeredArrayDeclares == null)
 785                         registeredArrayDeclares = new Hashtable();
 786
 787                 if (!registeredArrayDeclares.ContainsKey (arrayName))
 788                         registeredArrayDeclares.Add (arrayName, new ArrayList());
 789
 790                 ((ArrayList) registeredArrayDeclares[arrayName]).Add(arrayValue);
 791         }
 792
 793         [EditorBrowsable (EditorBrowsableState.Advanced)]
 794         public virtual void RegisterClientScriptBlock (string key, string script)
 795         {
 796                 if (IsClientScriptBlockRegistered (key))
 797                         return;
 798
 799                 if (clientScriptBlocks == null)
 800                         clientScriptBlocks = new Hashtable ();
 801
 802                 clientScriptBlocks.Add (key, script);
 803         }
 804
 805         [EditorBrowsable (EditorBrowsableState.Advanced)]
 806         public virtual void RegisterHiddenField (string hiddenFieldName, string hiddenFieldInitialValue)
 807         {
 808                 if (hiddenFields == null)
 809                         hiddenFields = new Hashtable ();
 810
 811                 if (!hiddenFields.ContainsKey (hiddenFieldName))
 812                         hiddenFields.Add (hiddenFieldName, hiddenFieldInitialValue);
 813         }
 814         [MonoTODO("Used in HtmlForm")]
 815         internal void RegisterClientScriptFile (string a, string b, string c)
 816         {
 817                 throw new NotImplementedException ();
 818         }
 819
 820
 821         [MonoTODO]
 822         [EditorBrowsable (EditorBrowsableState.Advanced)]
 823         public void RegisterOnSubmitStatement (string key, string script)
 824         {
 825                 if (submitStatements == null)
 826                         submitStatements = new Hashtable ();
 827
 828                 if (submitStatements.ContainsKey (key))
 829                         return;
 830
 831                 submitStatements.Add (key, script);
 832         }
 833
 834         [EditorBrowsable (EditorBrowsableState.Advanced)]
 835         public void RegisterRequiresPostBack (Control control)
 836         {
 837                 if (_requiresPostBack == null)
 838                         _requiresPostBack = new ArrayList ();
 839
 840                 _requiresPostBack.Add (control.UniqueID);
 841         }
 842
 843         [EditorBrowsable (EditorBrowsableState.Advanced)]
 844         public virtual void RegisterRequiresRaiseEvent (IPostBackEventHandler control)
 845         {
 846                 requiresRaiseEvent = control;
 847         }
 848
 849         [EditorBrowsable (EditorBrowsableState.Advanced)]
 850         public virtual void RegisterStartupScript (string key, string script)
 851         {
 852                 if (IsStartupScriptRegistered (key))
 853                         return;
 854
 855                 if (startupScriptBlocks == null)
 856                         startupScriptBlocks = new Hashtable ();
 857
 858                 startupScriptBlocks.Add (key, script);
 859         }
 860
 861         [EditorBrowsable (EditorBrowsableState.Advanced)]
 862         public void RegisterViewStateHandler ()
 863         {
 864                 handleViewState = true;
 865         }
 866
 867         [EditorBrowsable (EditorBrowsableState.Advanced)]
 868         protected virtual void SavePageStateToPersistenceMedium (object viewState)
 869         {
 870                 _savedViewState = viewState;
 871         }
 872
 873         [EditorBrowsable (EditorBrowsableState.Advanced)]
 874         protected virtual object LoadPageStateFromPersistenceMedium ()
 875         {
 876                 NameValueCollection postdata = DeterminePostBackMode ();
 877                 string view_state;
 878                 if (postdata == null || (view_state = postdata ["__VIEWSTATE"]) == null)
 879                         return null;
 880
 881                 _savedViewState = null;
 882                 LosFormatter fmt = new LosFormatter ();
 883
 884                 try {
 885                         _savedViewState = fmt.Deserialize (view_state);
 886                 } catch (Exception e) {
 887                         throw new HttpException ("Error restoring page viewstate.\n", e);
 888                 }
 889
 890                 return _savedViewState;
 891         }
 892
 893         internal void LoadPageViewState()
 894         {
 895                 object sState = LoadPageStateFromPersistenceMedium ();
 896                 if (sState != null) {
 897                         Pair pair = (Pair) sState;
 898                         LoadViewStateRecursive (pair.First);
 899                         _requiresPostBack = pair.Second as ArrayList;
 900                 }
 901         }
 902
 903         internal void SavePageViewState ()
 904         {
 905                 if (!handleViewState)
 906                         return;
 907
 908                 Pair pair = new Pair ();
 909                 pair.First = SaveViewStateRecursive ();
 910                 if (_requiresPostBack != null && _requiresPostBack.Count > 0)
 911                         pair.Second = _requiresPostBack;
 912
 913                 if (pair.First == null && pair.Second == null)
 914                         pair = null;
 915
 916                 SavePageStateToPersistenceMedium (pair);
 917         }
 918
 919         public virtual void Validate ()
 920         {
 921                 if (_validators == null || _validators.Count == 0){
 922                         _isValid = true;
 923                         return;
 924                 }
 925
 926                 bool all_valid = true;
 927                 foreach (IValidator v in _validators){
 928                         v.Validate ();
 929                         if (v.IsValid == false)
 930                                 all_valid = false;
 931                 }
 932
 933                 if (all_valid)
 934                         _isValid = true;
 935         }
 936
 937         [EditorBrowsable (EditorBrowsableState.Advanced)]
 938         public virtual void VerifyRenderingInServerForm (Control control)
 939         {
 940                 if (!renderingForm)
 941                         throw new HttpException ("Control '" + control.ClientID + " " + control.GetType () +
 942                                                  "' must be rendered within a HtmlForm");
 943         }
 944
 945         #endregion
 946
 947         #if NET_1_2
 948         public string GetWebResourceUrl(Type type, string resourceName)
 949         {
 950                 if (type == null)
 951                         throw new ArgumentNullException ("type");
 952
 953                 if (resourceName == null || resourceName.Length == 0)
 954                         throw new ArgumentNullException ("type");
 955
 956                 return System.Web.Handlers.AssemblyResourceLoader.GetResourceUrl (type, resourceName);
 957         }
 958
 959         Stack dataItemCtx;
 960
 961         internal void PushDataItemContext (object o)
 962         {
 963                 if (dataItemCtx == null)
 964                         dataItemCtx = new Stack ();
 965
 966                 dataItemCtx.Push (o);
 967         }
 968
 969         internal void PopDataItemContext ()
 970         {
 971                 if (dataItemCtx == null)
 972                         throw new InvalidOperationException ();
 973
 974                 dataItemCtx.Pop ();
 975         }
 976
 977         internal object CurrentDataItem {
 978                 get {
 979                         if (dataItemCtx == null)
 980                                 throw new InvalidOperationException ("No data item");
 981
 982                         return dataItemCtx.Peek ();
 983                 }
 984         }
 985
 986         protected object Eval (string expression)
 987         {
 988                 return DataBinder.Eval (CurrentDataItem, expression);
 989         }
 990
 991         protected object Eval (string expression, string format)
 992         {
 993                 return DataBinder.Eval (CurrentDataItem, expression, format);
 994         }
 995
 996         protected object XPath (string xpathexpression)
 997         {
 998                 return XPathBinder.Eval (CurrentDataItem, xpathexpression);
 999         }
1000
1001         protected object XPath (string xpathexpression, string format)
1002         {
1003                 return XPathBinder.Eval (CurrentDataItem, xpathexpression, format);
1004         }
1005
1006         protected IEnumerable XPathSelect (string xpathexpression)
1007         {
1008                 return XPathBinder.Select (CurrentDataItem, xpathexpression);
1009         }
1010
1011         #endif
1012 }
1013 }