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 // Copyright (C) 2003,2005 Novell, Inc (http://www.novell.com)
  11 //
  12 // Permission is hereby granted, free of charge, to any person obtaining
  13 // a copy of this software and associated documentation files (the
  14 // "Software"), to deal in the Software without restriction, including
  15 // without limitation the rights to use, copy, modify, merge, publish,
  16 // distribute, sublicense, and/or sell copies of the Software, and to
  17 // permit persons to whom the Software is furnished to do so, subject to
  18 // the following conditions:
  19 //
  20 // The above copyright notice and this permission notice shall be
  21 // included in all copies or substantial portions of the Software.
  22 //
  23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30 //
  31
  32 using System;
  33 using System.Collections;
  34 using System.Collections.Specialized;
  35 using System.ComponentModel;
  36 using System.ComponentModel.Design;
  37 using System.ComponentModel.Design.Serialization;
  38 using System.Globalization;
  39 using System.IO;
  40 using System.Security.Cryptography;
  41 using System.Security.Permissions;
  42 using System.Security.Principal;
  43 using System.Text;
  44 using System.Threading;
  45 using System.Web;
  46 using System.Web.Caching;
  47 using System.Web.Configuration;
  48 using System.Web.SessionState;
  49 using System.Web.Util;
  50 using System.Web.UI.HtmlControls;
  51 using System.Web.UI.WebControls;
  52 #if NET_2_0
  53 using System.Web.UI.Adapters;
  54 using System.Collections.Generic;
  55 using System.Reflection;
  56 #endif
  57
  58 namespace System.Web.UI
  59 {
  60 // CAS
  61 [AspNetHostingPermission (SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
  62 [AspNetHostingPermission (SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
  63 #if !NET_2_0
  64 [RootDesignerSerializer ("Microsoft.VSDesigner.WebForms.RootCodeDomSerializer, " + Consts.AssemblyMicrosoft_VSDesigner, "System.ComponentModel.Design.Serialization.CodeDomSerializer, " + Consts.AssemblySystem_Design, true)]
  65 #endif
  66 [DefaultEvent ("Load"), DesignerCategory ("ASPXCodeBehind")]
  67 [ToolboxItem (false)]
  68 #if NET_2_0
  69 [Designer ("Microsoft.VisualStudio.Web.WebForms.WebFormDesigner, " + Consts.AssemblyMicrosoft_VisualStudio_Web, typeof (IRootDesigner))]
  70 #else
  71 [Designer ("Microsoft.VSDesigner.WebForms.WebFormDesigner, " + Consts.AssemblyMicrosoft_VSDesigner, typeof (IRootDesigner))]
  72 #endif
  73 public partial class Page : TemplateControl, IHttpHandler
  74 {
  75         static string machineKeyConfigPath = "system.web/machineKey";
  76 #if NET_2_0
  77         private PageLifeCycle _lifeCycle = PageLifeCycle.Unknown;
  78         private bool _eventValidation = true;
  79         private object [] _savedControlState;
  80         private bool _doLoadPreviousPage;
  81         string _focusedControlID;
  82         bool _hasEnabledControlArray;
  83 #endif
  84         private bool _viewState = true;
  85         private bool _viewStateMac;
  86         private string _errorPage;
  87         private bool is_validated;
  88         private bool _smartNavigation;
  89         private int _transactionMode;
  90         private HttpContext _context;
  91         private ValidatorCollection _validators;
  92         private bool renderingForm;
  93         private string _savedViewState;
  94         private ArrayList _requiresPostBack;
  95         private ArrayList _requiresPostBackCopy;
  96         private ArrayList requiresPostDataChanged;
  97         private IPostBackEventHandler requiresRaiseEvent;
  98         private NameValueCollection secondPostData;
  99         private bool requiresPostBackScript;
 100         private bool postBackScriptRendered;
 101         bool handleViewState;
 102         string viewStateUserKey;
 103         NameValueCollection _requestValueCollection;
 104         string clientTarget;
 105         ClientScriptManager scriptManager;
 106         bool allow_load; // true when the Form collection belongs to this page (GetTypeHashCode)
 107         PageStatePersister page_state_persister;
 108
 109         [EditorBrowsable (EditorBrowsableState.Never)]
 110 #if NET_2_0
 111         public
 112 #else
 113         protected
 114 #endif
 115         const string postEventArgumentID = "__EVENTARGUMENT";
 116
 117         [EditorBrowsable (EditorBrowsableState.Never)]
 118 #if NET_2_0
 119         public
 120 #else
 121         protected
 122 #endif
 123         const string postEventSourceID = "__EVENTTARGET";
 124
 125 #if NET_2_0
 126         const string ScrollPositionXID = "__SCROLLPOSITIONX";
 127         const string ScrollPositionYID = "__SCROLLPOSITIONY";
 128         const string EnabledControlArrayID = "__enabledControlArray";
 129 #endif
 130
 131 #if NET_2_0
 132         internal const string LastFocusID = "__LASTFOCUS";
 133         internal const string CallbackArgumentID = "__CALLBACKARGUMENT";
 134         internal const string CallbackSourceID = "__CALLBACKTARGET";
 135         internal const string PreviousPageID = "__PREVIOUSPAGE";
 136
 137         HtmlHead htmlHeader;
 138
 139         MasterPage masterPage;
 140         string masterPageFile;
 141
 142         Page previousPage;
 143         bool isCrossPagePostBack;
 144         bool isPostBack;
 145         bool isCallback;
 146         ArrayList requireStateControls;
 147         Hashtable _validatorsByGroup;
 148         HtmlForm _form;
 149
 150         string _title;
 151         string _theme;
 152         string _styleSheetTheme;
 153         Hashtable items;
 154
 155         bool _maintainScrollPositionOnPostBack;
 156
 157         private bool asyncMode = false;
 158         private TimeSpan asyncTimeout;
 159         private const double DefaultAsyncTimeout = 45.0;
 160         private List<PageAsyncTask> parallelTasks;
 161         private List<PageAsyncTask> serialTasks;
 162
 163         private ViewStateEncryptionMode viewStateEncryptionMode;
 164         private bool controlRegisteredForViewStateEncryption = false;
 165 #endif
 166
 167         #region Constructor
 168         public Page ()
 169         {
 170                 scriptManager = new ClientScriptManager (this);
 171                 Page = this;
 172                 ID = "__Page";
 173 #if NET_2_0
 174                 PagesSection ps = WebConfigurationManager.GetSection ("system.web/pages") as PagesSection;
 175                 if (ps != null) {
 176                         asyncTimeout = ps.AsyncTimeout;
 177                         viewStateEncryptionMode = ps.ViewStateEncryptionMode;
 178                 } else {
 179                         asyncTimeout = TimeSpan.FromSeconds (DefaultAsyncTimeout);
 180                         viewStateEncryptionMode = ViewStateEncryptionMode.Auto;
 181                 }
 182 #endif
 183         }
 184
 185         #endregion
 186
 187         #region Properties
 188
 189         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 190         [Browsable (false)]
 191         public HttpApplicationState Application
 192         {
 193                 get {
 194                         if (_context == null)
 195                                 return null;
 196                         return _context.Application;
 197                 }
 198         }
 199
 200         [EditorBrowsable (EditorBrowsableState.Never)]
 201         protected bool AspCompatMode
 202         {
 203 #if NET_2_0
 204                 get { return false; }
 205 #endif
 206                 set { throw new NotImplementedException (); }
 207         }
 208
 209         [EditorBrowsable (EditorBrowsableState.Never)]
 210 #if NET_2_0
 211         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 212         [BrowsableAttribute (false)]
 213         public bool Buffer
 214         {
 215                 get { return Response.BufferOutput; }
 216                 set { Response.BufferOutput = value; }
 217         }
 218 #else
 219         protected bool Buffer
 220         {
 221                 set { Response.BufferOutput = value; }
 222         }
 223 #endif
 224
 225         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 226         [Browsable (false)]
 227         public Cache Cache
 228         {
 229                 get {
 230                         if (_context == null)
 231                                 throw new HttpException ("No cache available without a context.");
 232                         return _context.Cache;
 233                 }
 234         }
 235
 236 #if NET_2_0
 237         [EditorBrowsableAttribute (EditorBrowsableState.Advanced)]
 238 #endif
 239         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 240         [Browsable (false), DefaultValue ("")]
 241         [WebSysDescription ("Value do override the automatic browser detection and force the page to use the specified browser.")]
 242         public string ClientTarget
 243         {
 244                 get { return (clientTarget == null) ? "" : clientTarget; }
 245                 set {
 246                         clientTarget = value;
 247                         if (value == "")
 248                                 clientTarget = null;
 249                 }
 250         }
 251
 252         [EditorBrowsable (EditorBrowsableState.Never)]
 253 #if NET_2_0
 254         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 255         [BrowsableAttribute (false)]
 256         public int CodePage
 257         {
 258                 get { return Response.ContentEncoding.CodePage; }
 259                 set { Response.ContentEncoding = Encoding.GetEncoding (value); }
 260         }
 261 #else
 262         protected int CodePage
 263         {
 264                 set { Response.ContentEncoding = Encoding.GetEncoding (value); }
 265         }
 266 #endif
 267
 268         [EditorBrowsable (EditorBrowsableState.Never)]
 269 #if NET_2_0
 270         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 271         [BrowsableAttribute (false)]
 272         public string ContentType
 273         {
 274                 get { return Response.ContentType; }
 275                 set { Response.ContentType = value; }
 276         }
 277 #else
 278         protected string ContentType
 279         {
 280                 set { Response.ContentType = value; }
 281         }
 282 #endif
 283
 284         protected override HttpContext Context
 285         {
 286                 get {
 287                         if (_context == null)
 288                                 return HttpContext.Current;
 289
 290                         return _context;
 291                 }
 292         }
 293
 294 #if NET_2_0
 295         [EditorBrowsable (EditorBrowsableState.Advanced)]
 296         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 297         [BrowsableAttribute (false)]
 298         public string Culture
 299         {
 300                 get { return Thread.CurrentThread.CurrentCulture.Name; }
 301                 set { Thread.CurrentThread.CurrentCulture = GetPageCulture (value, Thread.CurrentThread.CurrentCulture); }
 302         }
 303 #else
 304         [EditorBrowsable (EditorBrowsableState.Never)]
 305         protected string Culture
 306         {
 307                 set { Thread.CurrentThread.CurrentCulture = new CultureInfo (value); }
 308         }
 309 #endif
 310
 311 #if NET_2_0
 312         public virtual bool EnableEventValidation {
 313                 get { return _eventValidation; }
 314                 set {
 315                         if (_lifeCycle > PageLifeCycle.Init)
 316                                 throw new InvalidOperationException ("The 'EnableEventValidation' property can be set only in the Page_init, the Page directive or in the <pages> configuration section.");
 317                         _eventValidation = value;
 318                 }
 319         }
 320
 321         internal PageLifeCycle LifeCycle {
 322                 get { return _lifeCycle; }
 323         }
 324 #endif
 325
 326         [Browsable (false)]
 327         public override bool EnableViewState
 328         {
 329                 get { return _viewState; }
 330                 set { _viewState = value; }
 331         }
 332
 333 #if NET_2_0
 334         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 335         [BrowsableAttribute (false)]
 336 #endif
 337         [EditorBrowsable (EditorBrowsableState.Never)]
 338 #if NET_2_0
 339         public
 340 #else
 341         protected
 342 #endif
 343         bool EnableViewStateMac
 344         {
 345                 get { return _viewStateMac; }
 346                 set { _viewStateMac = value; }
 347         }
 348
 349 #if NET_1_1
 350         internal bool EnableViewStateMacInternal {
 351                 get { return _viewStateMac; }
 352                 set { _viewStateMac = value; }
 353         }
 354 #endif
 355
 356         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 357         [Browsable (false), DefaultValue ("")]
 358         [WebSysDescription ("The URL of a page used for error redirection.")]
 359         public string ErrorPage
 360         {
 361                 get { return _errorPage; }
 362                 set {
 363                         _errorPage = value;
 364                         if (_context != null)
 365                                 _context.ErrorPage = value;
 366                 }
 367         }
 368
 369 #if NET_2_0
 370         [Obsolete]
 371 #endif
 372         [EditorBrowsable (EditorBrowsableState.Never)]
 373         protected ArrayList FileDependencies
 374         {
 375                 set {
 376                         if (Response != null)
 377                                 Response.AddFileDependencies (value);
 378                 }
 379         }
 380
 381         [Browsable (false)]
 382 #if NET_2_0
 383         [EditorBrowsable (EditorBrowsableState.Never)]
 384 #endif
 385         public override string ID
 386         {
 387                 get { return base.ID; }
 388                 set { base.ID = value; }
 389         }
 390
 391         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 392         [Browsable (false)]
 393         public bool IsPostBack
 394         {
 395                 get {
 396 #if NET_2_0
 397                         return isPostBack;
 398 #else
 399                         return _requestValueCollection != null;
 400 #endif
 401                 }
 402         }
 403
 404         [EditorBrowsable (EditorBrowsableState.Never), Browsable (false)]
 405         public bool IsReusable {
 406                 get { return false; }
 407         }
 408
 409         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 410         [Browsable (false)]
 411         public bool IsValid {
 412                 get {
 413                         if (!is_validated)
 414                                 throw new HttpException (Locale.GetText ("Page hasn't been validated."));
 415
 416 #if NET_2_0
 417                         foreach (IValidator val in Validators)
 418                                 if (!val.IsValid)
 419                                         return false;
 420                         return true;
 421 #else
 422                         return ValidateCollection (_validators);
 423 #endif
 424                 }
 425         }
 426 #if NET_2_0
 427         public IDictionary Items {
 428                 get {
 429                         if (items == null)
 430                                 items = new Hashtable ();
 431                         return items;
 432                 }
 433         }
 434 #endif
 435
 436         [EditorBrowsable (EditorBrowsableState.Never)]
 437 #if NET_2_0
 438         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 439         [BrowsableAttribute (false)]
 440         public int LCID {
 441                 get { return Thread.CurrentThread.CurrentCulture.LCID; }
 442                 set { Thread.CurrentThread.CurrentCulture = new CultureInfo (value); }
 443         }
 444 #else
 445         protected int LCID {
 446                 set { Thread.CurrentThread.CurrentCulture = new CultureInfo (value); }
 447         }
 448 #endif
 449
 450 #if NET_2_0
 451         [Browsable (false)]
 452         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 453         public bool MaintainScrollPositionOnPostBack {
 454                 get { return _maintainScrollPositionOnPostBack; }
 455                 set { _maintainScrollPositionOnPostBack = value; }
 456         }
 457 #endif
 458
 459 #if NET_2_0
 460         public PageAdapter PageAdapter {
 461                 get {
 462                         return (PageAdapter)Adapter;
 463                 }
 464         }
 465 #endif
 466
 467 #if !TARGET_J2EE
 468         internal string theForm {
 469                 get {
 470                         return "theForm";
 471                 }
 472         }
 473 #endif
 474
 475         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 476         [Browsable (false)]
 477         public HttpRequest Request
 478         {
 479                 get {
 480                         if (_context != null)
 481                                 return _context.Request;
 482
 483                         throw new HttpException("Request is not available without context");
 484                 }
 485         }
 486
 487         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 488         [Browsable (false)]
 489         public HttpResponse Response
 490         {
 491                 get {
 492                         if (_context != null)
 493                                 return _context.Response;
 494
 495                         throw new HttpException ("Response is not available without context");
 496                 }
 497         }
 498
 499         [EditorBrowsable (EditorBrowsableState.Never)]
 500 #if NET_2_0
 501         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 502         [BrowsableAttribute (false)]
 503         public string ResponseEncoding
 504         {
 505                 get { return Response.ContentEncoding.WebName; }
 506                 set { Response.ContentEncoding = Encoding.GetEncoding (value); }
 507         }
 508 #else
 509         protected string ResponseEncoding
 510         {
 511                 set { Response.ContentEncoding = Encoding.GetEncoding (value); }
 512         }
 513 #endif
 514
 515         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 516         [Browsable (false)]
 517         public HttpServerUtility Server
 518         {
 519                 get {
 520                         return Context.Server;
 521                 }
 522         }
 523
 524         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 525         [Browsable (false)]
 526         public virtual HttpSessionState Session
 527         {
 528                 get {
 529                         if (_context == null)
 530                                 _context = HttpContext.Current;
 531
 532                         if (_context == null)
 533                                 throw new HttpException ("Session is not available without context");
 534
 535                         if (_context.Session == null)
 536                                 throw new HttpException ("Session state can only be used " +
 537                                                 "when enableSessionState is set to true, either " +
 538                                                 "in a configuration file or in the Page directive.");
 539
 540                         return _context.Session;
 541                 }
 542         }
 543
 544 #if NET_2_0
 545         [FilterableAttribute (false)]
 546         [Obsolete]
 547 #endif
 548         [Browsable (false)]
 549         public bool SmartNavigation
 550         {
 551                 get { return _smartNavigation; }
 552                 set { _smartNavigation = value; }
 553         }
 554
 555 #if NET_2_0
 556         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 557         [Filterable (false)]
 558         [Browsable (false)]
 559         public virtual string StyleSheetTheme {
 560                 get { return _styleSheetTheme; }
 561                 set { _styleSheetTheme = value; }
 562         }
 563
 564         [Browsable (false)]
 565         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 566         public virtual string Theme {
 567                 get { return _theme; }
 568                 set { _theme = value; }
 569         }
 570
 571         void InitializeStyleSheet ()
 572         {
 573                 if (_styleSheetTheme == null) {
 574                         PagesSection ps = WebConfigurationManager.GetSection ("system.web/pages") as PagesSection;
 575                         if (ps != null)
 576                                 _styleSheetTheme = ps.StyleSheetTheme;
 577                 }
 578                 if (_styleSheetTheme != null && _styleSheetTheme != "")
 579                         _styleSheetPageTheme = ThemeDirectoryCompiler.GetCompiledInstance (_styleSheetTheme, _context);
 580         }
 581
 582         void InitializeTheme ()
 583         {
 584                 if (_theme == null) {
 585                         PagesSection ps = WebConfigurationManager.GetSection ("system.web/pages") as PagesSection;
 586                         if (ps != null)
 587                                 _theme = ps.Theme;
 588                 }
 589                 if (_theme != null && _theme != "") {
 590                         _pageTheme = ThemeDirectoryCompiler.GetCompiledInstance (_theme, _context);
 591                         _pageTheme.SetPage (this);
 592                 }
 593         }
 594
 595 #endif
 596
 597 #if NET_2_0
 598         [Localizable (true)]
 599         [Bindable (true)]
 600         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 601         public string Title {
 602                 get {
 603                         if (_title == null)
 604                                 return htmlHeader.Title;
 605                         return _title;
 606                 }
 607                 set {
 608                         if (htmlHeader != null)
 609                                 htmlHeader.Title = value;
 610                         else
 611                                 _title = value;
 612                 }
 613         }
 614 #endif
 615
 616         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 617         [Browsable (false)]
 618         public TraceContext Trace
 619         {
 620                 get { return Context.Trace; }
 621         }
 622
 623         [EditorBrowsable (EditorBrowsableState.Never)]
 624 #if NET_2_0
 625         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 626         [BrowsableAttribute (false)]
 627         public bool TraceEnabled
 628         {
 629                 get { return Trace.IsEnabled; }
 630                 set { Trace.IsEnabled = value; }
 631         }
 632 #else
 633         protected bool TraceEnabled
 634         {
 635                 set { Trace.IsEnabled = value; }
 636         }
 637 #endif
 638
 639         [EditorBrowsable (EditorBrowsableState.Never)]
 640 #if NET_2_0
 641         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 642         [BrowsableAttribute (false)]
 643         public TraceMode TraceModeValue
 644         {
 645                 get { return Trace.TraceMode; }
 646                 set { Trace.TraceMode = value; }
 647         }
 648 #else
 649         protected TraceMode TraceModeValue
 650         {
 651                 set { Trace.TraceMode = value; }
 652         }
 653 #endif
 654
 655         [EditorBrowsable (EditorBrowsableState.Never)]
 656         protected int TransactionMode
 657         {
 658 #if NET_2_0
 659                 get { return _transactionMode; }
 660 #endif
 661                 set { _transactionMode = value; }
 662         }
 663
 664 #if !NET_2_0
 665         //
 666         // This method is here just to remove the warning about "_transactionMode" not being
 667         // used.  We probably will use it internally at some point.
 668         //
 669         internal int GetTransactionMode ()
 670         {
 671                 return _transactionMode;
 672         }
 673 #endif
 674
 675 #if NET_2_0
 676         [EditorBrowsable (EditorBrowsableState.Advanced)]
 677         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 678         [BrowsableAttribute (false)]
 679         public string UICulture
 680         {
 681                 get { return Thread.CurrentThread.CurrentUICulture.Name; }
 682                 set { Thread.CurrentThread.CurrentUICulture = GetPageCulture (value, Thread.CurrentThread.CurrentUICulture); }
 683         }
 684 #else
 685         [EditorBrowsable (EditorBrowsableState.Never)]
 686         protected string UICulture
 687         {
 688                 set { Thread.CurrentThread.CurrentUICulture = new CultureInfo (value); }
 689         }
 690 #endif
 691
 692         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 693         [Browsable (false)]
 694         public IPrincipal User
 695         {
 696                 get { return Context.User; }
 697         }
 698
 699         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 700         [Browsable (false)]
 701         public ValidatorCollection Validators
 702         {
 703                 get {
 704                         if (_validators == null)
 705                                 _validators = new ValidatorCollection ();
 706                         return _validators;
 707                 }
 708         }
 709
 710         [MonoTODO ("Use this when encrypting/decrypting ViewState")]
 711         [Browsable (false)]
 712         public string ViewStateUserKey {
 713                 get { return viewStateUserKey; }
 714                 set { viewStateUserKey = value; }
 715         }
 716
 717         [Browsable (false)]
 718         public override bool Visible
 719         {
 720                 get { return base.Visible; }
 721                 set { base.Visible = value; }
 722         }
 723
 724         #endregion
 725
 726         #region Methods
 727
 728 #if NET_2_0
 729         CultureInfo GetPageCulture (string culture, CultureInfo deflt)
 730         {
 731                 if (culture == null)
 732                         return deflt;
 733                 CultureInfo ret = null;
 734                 if (culture.StartsWith ("auto", StringComparison.InvariantCultureIgnoreCase)) {
 735 #if TARGET_J2EE
 736                         if (Context.IsPortletRequest)
 737                                 return deflt;
 738 #endif
 739                         string[] languages = Request.UserLanguages;
 740                         try {
 741                                 if (languages != null && languages.Length > 0)
 742                                         ret = CultureInfo.CreateSpecificCulture (languages[0]);
 743                         } catch {
 744                         }
 745
 746                         if (ret == null)
 747                                 ret = deflt;
 748                 } else
 749                         ret = CultureInfo.CreateSpecificCulture (culture);
 750
 751                 return ret;
 752         }
 753 #endif
 754
 755         [EditorBrowsable (EditorBrowsableState.Never)]
 756         protected IAsyncResult AspCompatBeginProcessRequest (HttpContext context,
 757                                                              AsyncCallback cb,
 758                                                              object extraData)
 759         {
 760                 throw new NotImplementedException ();
 761         }
 762
 763         [EditorBrowsable (EditorBrowsableState.Never)]
 764         protected void AspCompatEndProcessRequest (IAsyncResult result)
 765         {
 766                 throw new NotImplementedException ();
 767         }
 768
 769         [EditorBrowsable (EditorBrowsableState.Advanced)]
 770         protected virtual HtmlTextWriter CreateHtmlTextWriter (TextWriter tw)
 771         {
 772                 return new HtmlTextWriter (tw);
 773         }
 774
 775         [EditorBrowsable (EditorBrowsableState.Never)]
 776         public void DesignerInitialize ()
 777         {
 778                 InitRecursive (null);
 779         }
 780
 781         [EditorBrowsable (EditorBrowsableState.Advanced)]
 782         protected virtual NameValueCollection DeterminePostBackMode ()
 783         {
 784                 if (_context == null)
 785                         return null;
 786
 787                 HttpRequest req = _context.Request;
 788                 if (req == null)
 789                         return null;
 790
 791                 NameValueCollection coll = null;
 792                 if (0 == String.Compare (Request.HttpMethod, "POST", true, CultureInfo.InvariantCulture))
 793                         coll = req.Form;
 794 #if TARGET_J2EE
 795                 else if (IsPortletRender && req.Form ["__VIEWSTATE"] != null)
 796                         coll = req.Form;
 797 #endif
 798                 else
 799                         coll = req.QueryString;
 800
 801                 WebROCollection c = (WebROCollection) coll;
 802                 allow_load = !c.GotID;
 803                 if (allow_load)
 804                         c.ID = GetTypeHashCode ();
 805                 else
 806                         allow_load = (c.ID == GetTypeHashCode ());
 807
 808                 if (coll != null && coll ["__VIEWSTATE"] == null && coll ["__EVENTTARGET"] == null)
 809                         return null;
 810
 811                 return coll;
 812         }
 813
 814 #if NET_2_0
 815         public override Control FindControl (string id) {
 816                 if (id == ID)
 817                         return this;
 818                 else
 819                         return base.FindControl (id);
 820         }
 821 #endif
 822
 823 #if NET_2_0
 824         [Obsolete]
 825 #endif
 826         [EditorBrowsable (EditorBrowsableState.Advanced)]
 827         public string GetPostBackClientEvent (Control control, string argument)
 828         {
 829                 return scriptManager.GetPostBackEventReference (control, argument);
 830         }
 831
 832 #if NET_2_0
 833         [Obsolete]
 834 #endif
 835         [EditorBrowsable (EditorBrowsableState.Advanced)]
 836         public string GetPostBackClientHyperlink (Control control, string argument)
 837         {
 838                 return scriptManager.GetPostBackClientHyperlink (control, argument);
 839         }
 840
 841 #if NET_2_0
 842         [Obsolete]
 843 #endif
 844         [EditorBrowsable (EditorBrowsableState.Advanced)]
 845         public string GetPostBackEventReference (Control control)
 846         {
 847                 return scriptManager.GetPostBackEventReference (control, "");
 848         }
 849
 850 #if NET_2_0
 851         [Obsolete]
 852 #endif
 853         [EditorBrowsable (EditorBrowsableState.Advanced)]
 854         public string GetPostBackEventReference (Control control, string argument)
 855         {
 856                 return scriptManager.GetPostBackEventReference (control, argument);
 857         }
 858
 859         internal void RequiresPostBackScript ()
 860         {
 861 #if NET_2_0
 862                 if (requiresPostBackScript)
 863                         return;
 864                 ClientScript.RegisterHiddenField (postEventSourceID, String.Empty);
 865                 ClientScript.RegisterHiddenField (postEventArgumentID, String.Empty);
 866 #endif
 867                 requiresPostBackScript = true;
 868         }
 869
 870         [EditorBrowsable (EditorBrowsableState.Never)]
 871         public virtual int GetTypeHashCode ()
 872         {
 873                 return 0;
 874         }
 875
 876 #if NET_2_0
 877     [MonoTODO("The following properties of OutputCacheParameters are silently ignored: CacheProfile, NoStore, SqlDependency")]
 878     protected internal virtual void InitOutputCache(OutputCacheParameters cacheSettings)
 879     {
 880         if (cacheSettings.Enabled)
 881             InitOutputCache(cacheSettings.Duration,
 882                 cacheSettings.VaryByHeader,
 883                 cacheSettings.VaryByCustom,
 884                 cacheSettings.Location,
 885                 cacheSettings.VaryByParam);
 886     }
 887 #endif
 888
 889         [EditorBrowsable (EditorBrowsableState.Never)]
 890         protected virtual void InitOutputCache (int duration,
 891                                                 string varyByHeader,
 892                                                 string varyByCustom,
 893                                                 OutputCacheLocation location,
 894                                                 string varyByParam)
 895         {
 896                 HttpCachePolicy cache = _context.Response.Cache;
 897                 bool set_vary = false;
 898
 899                 switch (location) {
 900                 case OutputCacheLocation.Any:
 901                         cache.SetCacheability (HttpCacheability.Public);
 902                         cache.SetMaxAge (new TimeSpan (0, 0, duration));
 903                         cache.SetLastModified (_context.Timestamp);
 904                         set_vary = true;
 905                         break;
 906                 case OutputCacheLocation.Client:
 907                         cache.SetCacheability (HttpCacheability.Private);
 908                         cache.SetMaxAge (new TimeSpan (0, 0, duration));
 909                         cache.SetLastModified (_context.Timestamp);
 910                         break;
 911                 case OutputCacheLocation.Downstream:
 912                         cache.SetCacheability (HttpCacheability.Public);
 913                         cache.SetMaxAge (new TimeSpan (0, 0, duration));
 914                         cache.SetLastModified (_context.Timestamp);
 915                         break;
 916                 case OutputCacheLocation.Server:
 917                         cache.SetCacheability (HttpCacheability.Server);
 918                         set_vary = true;
 919                         break;
 920                 case OutputCacheLocation.None:
 921                         break;
 922                 }
 923
 924                 if (set_vary) {
 925                         if (varyByCustom != null)
 926                                 cache.SetVaryByCustom (varyByCustom);
 927
 928                         if (varyByParam != null && varyByParam.Length > 0) {
 929                                 string[] prms = varyByParam.Split (';');
 930                                 foreach (string p in prms)
 931                                         cache.VaryByParams [p.Trim ()] = true;
 932                                 cache.VaryByParams.IgnoreParams = false;
 933                         } else {
 934                                 cache.VaryByParams.IgnoreParams = true;
 935                         }
 936
 937                         if (varyByHeader != null && varyByHeader.Length > 0) {
 938                                 string[] hdrs = varyByHeader.Split (';');
 939                                 foreach (string h in hdrs)
 940                                         cache.VaryByHeaders [h.Trim ()] = true;
 941                         }
 942                 }
 943
 944                 cache.Duration = duration;
 945                 cache.SetExpires (_context.Timestamp.AddSeconds (duration));
 946         }
 947
 948 #if NET_2_0
 949         [Obsolete]
 950 #else
 951         [EditorBrowsable (EditorBrowsableState.Advanced)]
 952 #endif
 953         public bool IsClientScriptBlockRegistered (string key)
 954         {
 955                 return scriptManager.IsClientScriptBlockRegistered (key);
 956         }
 957
 958 #if NET_2_0
 959         [Obsolete]
 960 #else
 961         [EditorBrowsable (EditorBrowsableState.Advanced)]
 962 #endif
 963         public bool IsStartupScriptRegistered (string key)
 964         {
 965                 return scriptManager.IsStartupScriptRegistered (key);
 966         }
 967
 968         public string MapPath (string virtualPath)
 969         {
 970                 return Request.MapPath (virtualPath);
 971         }
 972
 973 #if NET_2_0
 974         protected internal override void Render (HtmlTextWriter writer) {
 975                 if (MaintainScrollPositionOnPostBack) {
 976                         ClientScript.RegisterWebFormClientScript ();
 977
 978                         ClientScript.RegisterHiddenField (ScrollPositionXID, Request [ScrollPositionXID]);
 979                         ClientScript.RegisterHiddenField (ScrollPositionYID, Request [ScrollPositionYID]);
 980
 981                         StringBuilder script = new StringBuilder ();
 982                         script.AppendLine ("<script type=\"text/javascript\">");
 983                         script.AppendLine ("<!--");
 984                         script.AppendLine (theForm + ".oldSubmit = " + theForm + ".submit;");
 985                         script.AppendLine (theForm + ".submit = WebForm_SaveScrollPositionSubmit;");
 986                         script.AppendLine (theForm + ".oldOnSubmit = " + theForm + ".onsubmit;");
 987                         script.AppendLine (theForm + ".onsubmit = WebForm_SaveScrollPositionOnSubmit;");
 988                         if (IsPostBack) {
 989                                 script.AppendLine (theForm + ".oldOnLoad = window.onload;");
 990                                 script.AppendLine ("window.onload = function () { WebForm_RestoreScrollPosition (" + theForm + "); };");
 991                         }
 992                         script.AppendLine ("// -->");
 993                         script.AppendLine ("</script>");
 994
 995                         ClientScript.RegisterStartupScript (typeof (Page), "MaintainScrollPositionOnPostBackStartup", script.ToString());
 996                 }
 997                 base.Render (writer);
 998         }
 999 #endif
1000
1001         private void RenderPostBackScript (HtmlTextWriter writer, string formUniqueID)
1002         {
1003 #if ONLY_1_1
1004                 writer.WriteLine ("<input type=\"hidden\" name=\"{0}\" value=\"\" />", postEventSourceID);
1005                 writer.WriteLine ("<input type=\"hidden\" name=\"{0}\" value=\"\" />", postEventArgumentID);
1006 #endif
1007                 writer.WriteLine ();
1008
1009                 ClientScript.WriteBeginScriptBlock (writer);
1010
1011 #if ONLY_1_1
1012                 RenderClientScriptFormDeclaration (writer, formUniqueID);
1013 #endif
1014                 writer.WriteLine ("function __doPostBack(eventTarget, eventArgument) {");
1015                 writer.WriteLine ("\tvar currForm = {0};", theForm);
1016 #if NET_2_0
1017                 writer.WriteLine ("\tcurrForm.__doPostBack(eventTarget, eventArgument);");
1018                 writer.WriteLine ("}");
1019                 writer.WriteLine ("{0}.__doPostBack = function (eventTarget, eventArgument) {{", theForm);
1020                 writer.WriteLine ("\tvar currForm = this;");
1021                 writer.WriteLine ("\tif(currForm.onsubmit && currForm.onsubmit() == false) return;");
1022 #else
1023                 writer.WriteLine ("\tif(document.ValidatorOnSubmit && !ValidatorOnSubmit()) return;");
1024 #endif
1025                 writer.WriteLine ("\tcurrForm.{0}.value = eventTarget;", postEventSourceID);
1026                 writer.WriteLine ("\tcurrForm.{0}.value = eventArgument;", postEventArgumentID);
1027                 writer.WriteLine ("\tcurrForm.submit();");
1028                 writer.WriteLine ("}");
1029
1030                 ClientScript.WriteEndScriptBlock (writer);
1031         }
1032
1033         void RenderClientScriptFormDeclaration (HtmlTextWriter writer, string formUniqueID)
1034         {
1035                 writer.WriteLine ("\tvar {0};\n\tif (document.getElementById) {{ {0} = document.getElementById ('{1}'); }}", theForm, formUniqueID);
1036                 writer.WriteLine ("\telse {{ {0} = document.{1}; }}", theForm, formUniqueID);
1037                 writer.WriteLine ("\t{0}.isAspForm = true;", theForm);
1038 #if TARGET_J2EE
1039                 string serverUrl = Context.ServletResponse.encodeURL (Request.RawUrl);
1040                 writer.WriteLine ("\t{0}.serverURL = {1};", theForm, ClientScriptManager.GetScriptLiteral (serverUrl));
1041 #endif
1042         }
1043
1044         internal void OnFormRender (HtmlTextWriter writer, string formUniqueID)
1045         {
1046                 if (renderingForm)
1047                         throw new HttpException ("Only 1 HtmlForm is allowed per page.");
1048
1049                 renderingForm = true;
1050                 writer.WriteLine ();
1051
1052 #if NET_2_0
1053                 ClientScript.WriteBeginScriptBlock (writer);
1054                 RenderClientScriptFormDeclaration (writer, formUniqueID);
1055                 ClientScript.WriteEndScriptBlock (writer);
1056 #endif
1057
1058                 if (handleViewState)
1059                         scriptManager.RegisterHiddenField ("__VIEWSTATE", _savedViewState);
1060
1061                 scriptManager.WriteHiddenFields (writer);
1062                 if (requiresPostBackScript) {
1063                         RenderPostBackScript (writer, formUniqueID);
1064                         postBackScriptRendered = true;
1065                 }
1066                 scriptManager.WriteClientScriptIncludes (writer);
1067                 scriptManager.WriteClientScriptBlocks (writer);
1068         }
1069
1070         internal IStateFormatter GetFormatter ()
1071         {
1072                 return new ObjectStateFormatter (this);
1073         }
1074
1075         internal string GetSavedViewState ()
1076         {
1077                 return _savedViewState;
1078         }
1079
1080         internal void OnFormPostRender (HtmlTextWriter writer, string formUniqueID)
1081         {
1082                 if (!postBackScriptRendered && requiresPostBackScript)
1083                         RenderPostBackScript (writer, formUniqueID);
1084
1085                 scriptManager.WriteArrayDeclares (writer);
1086
1087 #if NET_2_0
1088                 scriptManager.SaveEventValidationState ();
1089                 scriptManager.WriteExpandoAttributes (writer);
1090 #endif
1091                 scriptManager.WriteHiddenFields (writer);
1092                 scriptManager.WriteClientScriptIncludes (writer);
1093                 scriptManager.WriteStartupScriptBlocks (writer);
1094                 renderingForm = false;
1095                 postBackScriptRendered = false;
1096         }
1097
1098         private void ProcessPostData (NameValueCollection data, bool second)
1099         {
1100                 if (data != null) {
1101                         Hashtable used = new Hashtable ();
1102                         foreach (string id in data.AllKeys){
1103                                 if (id == "__VIEWSTATE" || id == postEventSourceID || id == postEventArgumentID)
1104                                         continue;
1105
1106                                 string real_id = id;
1107                                 int dot = real_id.IndexOf ('.');
1108                                 if (dot >= 1)
1109                                         real_id = real_id.Substring (0, dot);
1110
1111                                 if (real_id == null || used.ContainsKey (real_id))
1112                                         continue;
1113
1114                                 used.Add (real_id, real_id);
1115
1116                                 Control ctrl = FindControl (real_id);
1117                                 if (ctrl != null){
1118                                         IPostBackDataHandler pbdh = ctrl as IPostBackDataHandler;
1119                                         IPostBackEventHandler pbeh = ctrl as IPostBackEventHandler;
1120
1121                                         if (pbdh == null) {
1122                                                 if (pbeh != null)
1123                                                         RegisterRequiresRaiseEvent (pbeh);
1124                                                 continue;
1125                                         }
1126
1127                                         if (pbdh.LoadPostData (real_id, data) == true) {
1128                                                 if (requiresPostDataChanged == null)
1129                                                         requiresPostDataChanged = new ArrayList ();
1130                                                 requiresPostDataChanged.Add (pbdh);
1131                                         }
1132
1133                                         if (_requiresPostBackCopy != null)
1134                                                 _requiresPostBackCopy.Remove (real_id);
1135
1136                                 } else if (!second) {
1137                                         if (secondPostData == null)
1138                                                 secondPostData = new NameValueCollection ();
1139                                         secondPostData.Add (real_id, data [id]);
1140                                 }
1141                         }
1142                 }
1143
1144                 ArrayList list1 = null;
1145                 if (_requiresPostBackCopy != null && _requiresPostBackCopy.Count > 0) {
1146                         string [] handlers = (string []) _requiresPostBackCopy.ToArray (typeof (string));
1147                         foreach (string id in handlers) {
1148                                 IPostBackDataHandler pbdh = FindControl (id) as IPostBackDataHandler;
1149                                 if (pbdh != null) {
1150                                         _requiresPostBackCopy.Remove (id);
1151                                         if (pbdh.LoadPostData (id, data)) {
1152                                                 if (requiresPostDataChanged == null)
1153                                                         requiresPostDataChanged = new ArrayList ();
1154
1155                                                 requiresPostDataChanged.Add (pbdh);
1156                                         }
1157                                 } else if (!second) {
1158                                         if (list1 == null)
1159                                                 list1 = new ArrayList ();
1160                                         list1.Add (id);
1161                                 }
1162                         }
1163                 }
1164                 _requiresPostBackCopy = second ? null : list1;
1165                 if (second)
1166                         secondPostData = null;
1167         }
1168
1169         [EditorBrowsable (EditorBrowsableState.Never)]
1170 #if NET_2_0
1171         public virtual void ProcessRequest (HttpContext context)
1172 #else
1173         public void ProcessRequest (HttpContext context)
1174 #endif
1175         {
1176 #if NET_2_0
1177                 _lifeCycle = PageLifeCycle.Unknown;
1178 #endif
1179                 _context = context;
1180                 if (clientTarget != null)
1181                         Request.ClientTarget = clientTarget;
1182
1183                 WireupAutomaticEvents ();
1184                 //-- Control execution lifecycle in the docs
1185
1186                 // Save culture information because it can be modified in FrameworkInitialize()
1187                 CultureInfo culture = Thread.CurrentThread.CurrentCulture;
1188                 CultureInfo uiculture = Thread.CurrentThread.CurrentUICulture;
1189                 FrameworkInitialize ();
1190                 context.ErrorPage = _errorPage;
1191
1192                 try {
1193                         InternalProcessRequest ();
1194                 } catch (ThreadAbortException) {
1195                         // Do nothing, just ignore it by now.
1196                 } catch (Exception e) {
1197                         context.AddError (e); // OnError might access LastError
1198                         OnError (EventArgs.Empty);
1199                         context.ClearError (e);
1200                         // We want to remove that error, as we're rethrowing to stop
1201                         // further processing.
1202                         Trace.Warn ("Unhandled Exception", e.ToString (), e);
1203                         throw;
1204                 } finally {
1205                         try {
1206 #if NET_2_0
1207                                 _lifeCycle = PageLifeCycle.Unload;
1208 #endif
1209                                 RenderTrace ();
1210                                 UnloadRecursive (true);
1211 #if NET_2_0
1212                                 _lifeCycle = PageLifeCycle.End;
1213 #endif
1214                         } catch {}
1215                         if (Thread.CurrentThread.CurrentCulture.Equals (culture) == false)
1216                                 Thread.CurrentThread.CurrentCulture = culture;
1217
1218                         if (Thread.CurrentThread.CurrentUICulture.Equals (uiculture) == false)
1219                                 Thread.CurrentThread.CurrentUICulture = uiculture;
1220                 }
1221         }
1222
1223 #if NET_2_0
1224         delegate void ProcessRequestDelegate (HttpContext context);
1225
1226         private sealed class DummyAsyncResult : IAsyncResult
1227         {
1228                 readonly object state;
1229                 readonly WaitHandle asyncWaitHandle;
1230                 readonly bool completedSynchronously;
1231                 readonly bool isCompleted;
1232
1233                 public DummyAsyncResult (bool isCompleted, bool completedSynchronously, object state)
1234                 {
1235                         this.isCompleted = isCompleted;
1236                         this.completedSynchronously = completedSynchronously;
1237                         this.state = state;
1238                         if (isCompleted) {
1239                                 asyncWaitHandle = new ManualResetEvent (true);
1240                         }
1241                         else {
1242                                 asyncWaitHandle = new ManualResetEvent (false);
1243                         }
1244                 }
1245
1246                 #region IAsyncResult Members
1247
1248                 public object AsyncState {
1249                         get { return state; }
1250                 }
1251
1252                 public WaitHandle AsyncWaitHandle {
1253                         get { return asyncWaitHandle; }
1254                 }
1255
1256                 public bool CompletedSynchronously {
1257                         get { return completedSynchronously; }
1258                 }
1259
1260                 public bool IsCompleted {
1261                         get { return isCompleted; }
1262                 }
1263
1264                 #endregion
1265         }
1266
1267         protected IAsyncResult AsyncPageBeginProcessRequest (HttpContext context, AsyncCallback callback, object extraData)
1268         {
1269                 ProcessRequest (context);
1270                 DummyAsyncResult asyncResult = new DummyAsyncResult (true, true, extraData);
1271
1272                 if (callback != null) {
1273                         callback (asyncResult);
1274                 }
1275
1276                 return asyncResult;
1277         }
1278
1279         protected void AsyncPageEndProcessRequest (IAsyncResult result)
1280         {
1281         }
1282
1283         internal void ProcessCrossPagePostBack (HttpContext context)
1284         {
1285                 isCrossPagePostBack = true;
1286                 ProcessRequest (context);
1287         }
1288 #endif
1289
1290         void InternalProcessRequest ()
1291         {
1292                 _requestValueCollection = this.DeterminePostBackMode();
1293
1294 #if NET_2_0
1295                 _lifeCycle = PageLifeCycle.Start;
1296                 // http://msdn2.microsoft.com/en-us/library/ms178141.aspx
1297                 if (_requestValueCollection != null) {
1298                         if (!isCrossPagePostBack && _requestValueCollection [PreviousPageID] != null && _requestValueCollection [PreviousPageID] != Request.FilePath) {
1299                                 _doLoadPreviousPage = true;
1300                         }
1301                         else {
1302                                 isCallback = _requestValueCollection [CallbackArgumentID] != null;
1303                                 // LAMESPEC: on Callback IsPostBack is set to false, but true.
1304                                 //isPostBack = !isCallback;
1305                                 isPostBack = true;
1306                         }
1307                         string lastFocus = _requestValueCollection [LastFocusID];
1308                         if (!String.IsNullOrEmpty (lastFocus)) {
1309                                 _focusedControlID = UniqueID2ClientID (lastFocus);
1310                         }
1311                 }
1312
1313                 // if request was transfered from other page - track Prev. Page
1314                 previousPage = _context.LastPage;
1315                 _context.LastPage = this;
1316
1317                 _lifeCycle = PageLifeCycle.PreInit;
1318                 OnPreInit (EventArgs.Empty);
1319
1320                 InitializeTheme ();
1321                 ApplyMasterPage ();
1322                 _lifeCycle = PageLifeCycle.Init;
1323 #endif
1324                 Trace.Write ("aspx.page", "Begin Init");
1325                 InitRecursive (null);
1326                 Trace.Write ("aspx.page", "End Init");
1327
1328 #if NET_2_0
1329                 _lifeCycle = PageLifeCycle.InitComplete;
1330                 OnInitComplete (EventArgs.Empty);
1331 #endif
1332
1333                 renderingForm = false;
1334 #if NET_2_0
1335                 if (IsPostBack || IsCallback) {
1336                         _lifeCycle = PageLifeCycle.PreLoad;
1337                         if (_requestValueCollection != null)
1338                                 scriptManager.RestoreEventValidationState (_requestValueCollection [scriptManager.EventStateFieldName]);
1339 #else
1340                 if (IsPostBack) {
1341 #endif
1342                         Trace.Write ("aspx.page", "Begin LoadViewState");
1343                         LoadPageViewState ();
1344                         Trace.Write ("aspx.page", "End LoadViewState");
1345                         Trace.Write ("aspx.page", "Begin ProcessPostData");
1346                         ProcessPostData (_requestValueCollection, false);
1347                         Trace.Write ("aspx.page", "End ProcessPostData");
1348                 }
1349
1350 #if NET_2_0
1351                 OnPreLoad (EventArgs.Empty);
1352                 _lifeCycle = PageLifeCycle.Load;
1353 #endif
1354
1355                 LoadRecursive ();
1356 #if NET_2_0
1357                 if (IsPostBack || IsCallback) {
1358                         _lifeCycle = PageLifeCycle.ControlEvents;
1359 #else
1360                 if (IsPostBack) {
1361 #endif
1362                         Trace.Write ("aspx.page", "Begin ProcessPostData Second Try");
1363                         ProcessPostData (secondPostData, true);
1364                         Trace.Write ("aspx.page", "End ProcessPostData Second Try");
1365                         Trace.Write ("aspx.page", "Begin Raise ChangedEvents");
1366                         RaiseChangedEvents ();
1367                         Trace.Write ("aspx.page", "End Raise ChangedEvents");
1368                         Trace.Write ("aspx.page", "Begin Raise PostBackEvent");
1369                         RaisePostBackEvents ();
1370                         Trace.Write ("aspx.page", "End Raise PostBackEvent");
1371                 }
1372
1373 #if NET_2_0
1374                 _lifeCycle = PageLifeCycle.LoadComplete;
1375                 OnLoadComplete (EventArgs.Empty);
1376
1377                 if (IsCrossPagePostBack)
1378                         return;
1379
1380                 if (IsCallback) {
1381                         string result = ProcessCallbackData ();
1382                         HtmlTextWriter callbackOutput = new HtmlTextWriter (_context.Response.Output);
1383                         callbackOutput.Write (result);
1384                         callbackOutput.Flush ();
1385                         return;
1386                 }
1387
1388                 _lifeCycle = PageLifeCycle.PreRender;
1389 #endif
1390
1391                 Trace.Write ("aspx.page", "Begin PreRender");
1392                 PreRenderRecursiveInternal ();
1393                 Trace.Write ("aspx.page", "End PreRender");
1394
1395 #if NET_2_0
1396                 ExecuteRegisteredAsyncTasks ();
1397
1398                 _lifeCycle = PageLifeCycle.PreRenderComplete;
1399                 OnPreRenderComplete (EventArgs.Empty);
1400 #endif
1401
1402                 Trace.Write ("aspx.page", "Begin SaveViewState");
1403                 SavePageViewState ();
1404                 Trace.Write ("aspx.page", "End SaveViewState");
1405
1406 #if NET_2_0
1407                 _lifeCycle = PageLifeCycle.SaveStateComplete;
1408                 OnSaveStateComplete (EventArgs.Empty);
1409 #if TARGET_J2EE
1410                 if (OnSaveStateCompleteForPortlet ())
1411                         return;
1412 #endif // TARGET_J2EE
1413 #endif // NET_2_0
1414
1415 #if NET_2_0
1416                 _lifeCycle = PageLifeCycle.Render;
1417 #endif
1418
1419                 //--
1420                 Trace.Write ("aspx.page", "Begin Render");
1421                 HtmlTextWriter output = new HtmlTextWriter (_context.Response.Output);
1422                 RenderControl (output);
1423                 Trace.Write ("aspx.page", "End Render");
1424         }
1425
1426         private void RenderTrace ()
1427         {
1428                 TraceManager traceManager = HttpRuntime.TraceManager;
1429
1430                 if (Trace.HaveTrace && !Trace.IsEnabled || !Trace.HaveTrace && !traceManager.Enabled)
1431                         return;
1432
1433                 Trace.SaveData ();
1434
1435                 if (!Trace.HaveTrace && traceManager.Enabled && !traceManager.PageOutput)
1436                         return;
1437
1438                 if (!traceManager.LocalOnly || Context.Request.IsLocal) {
1439                         HtmlTextWriter output = new HtmlTextWriter (_context.Response.Output);
1440                         Trace.Render (output);
1441                 }
1442         }
1443
1444 #if NET_2_0
1445         bool CheckForValidationSupport (Control targetControl)
1446         {
1447                 if (targetControl == null)
1448                         return false;
1449                 Type type = targetControl.GetType ();
1450                 object[] attributes = type.GetCustomAttributes (false);
1451                 foreach (object attr in attributes)
1452                         if (attr is SupportsEventValidationAttribute)
1453                                 return true;
1454                 return false;
1455         }
1456 #endif
1457
1458         void RaisePostBackEvents ()
1459         {
1460 #if NET_2_0
1461                 Control targetControl;
1462 #endif
1463                 if (requiresRaiseEvent != null) {
1464                         RaisePostBackEvent (requiresRaiseEvent, null);
1465                         return;
1466                 }
1467
1468                 NameValueCollection postdata = _requestValueCollection;
1469                 if (postdata == null)
1470                         return;
1471
1472                 string eventTarget = postdata [postEventSourceID];
1473                 if (eventTarget == null || eventTarget.Length == 0) {
1474                         Validate ();
1475                         return;
1476                 }
1477
1478 #if NET_2_0
1479                 targetControl = FindControl (eventTarget);
1480                 IPostBackEventHandler target = targetControl as IPostBackEventHandler;
1481 #else
1482                 IPostBackEventHandler target = FindControl (eventTarget) as IPostBackEventHandler;
1483 #endif
1484
1485                 if (target == null)
1486                         return;
1487
1488                 string eventArgument = postdata [postEventArgumentID];
1489                 RaisePostBackEvent (target, eventArgument);
1490         }
1491
1492         internal void RaiseChangedEvents ()
1493         {
1494                 if (requiresPostDataChanged == null)
1495                         return;
1496
1497                 foreach (IPostBackDataHandler ipdh in requiresPostDataChanged)
1498                         ipdh.RaisePostDataChangedEvent ();
1499
1500                 requiresPostDataChanged = null;
1501         }
1502
1503         [EditorBrowsable (EditorBrowsableState.Advanced)]
1504         protected virtual void RaisePostBackEvent (IPostBackEventHandler sourceControl, string eventArgument)
1505         {
1506 #if NET_2_0
1507                 Control targetControl = sourceControl as Control;
1508                 if (targetControl != null && CheckForValidationSupport (targetControl))
1509                         scriptManager.ValidateEvent (targetControl.UniqueID, eventArgument);
1510 #endif
1511                 sourceControl.RaisePostBackEvent (eventArgument);
1512         }
1513
1514 #if NET_2_0
1515         [Obsolete]
1516 #endif
1517         [EditorBrowsable (EditorBrowsableState.Advanced)]
1518         public void RegisterArrayDeclaration (string arrayName, string arrayValue)
1519         {
1520                 scriptManager.RegisterArrayDeclaration (arrayName, arrayValue);
1521         }
1522
1523 #if NET_2_0
1524         [Obsolete]
1525 #endif
1526         [EditorBrowsable (EditorBrowsableState.Advanced)]
1527         public virtual void RegisterClientScriptBlock (string key, string script)
1528         {
1529                 scriptManager.RegisterClientScriptBlock (key, script);
1530         }
1531
1532 #if NET_2_0
1533         [Obsolete]
1534 #endif
1535         [EditorBrowsable (EditorBrowsableState.Advanced)]
1536         public virtual void RegisterHiddenField (string hiddenFieldName, string hiddenFieldInitialValue)
1537         {
1538                 scriptManager.RegisterHiddenField (hiddenFieldName, hiddenFieldInitialValue);
1539         }
1540
1541         [MonoTODO("Not implemented, Used in HtmlForm")]
1542         internal void RegisterClientScriptFile (string a, string b, string c)
1543         {
1544                 throw new NotImplementedException ();
1545         }
1546
1547 #if NET_2_0
1548         [Obsolete]
1549 #endif
1550         [EditorBrowsable (EditorBrowsableState.Advanced)]
1551         public void RegisterOnSubmitStatement (string key, string script)
1552         {
1553                 scriptManager.RegisterOnSubmitStatement (key, script);
1554         }
1555
1556         internal string GetSubmitStatements ()
1557         {
1558                 return scriptManager.WriteSubmitStatements ();
1559         }
1560
1561         [EditorBrowsable (EditorBrowsableState.Advanced)]
1562         public void RegisterRequiresPostBack (Control control)
1563         {
1564 #if NET_2_0
1565                 if (!(control is IPostBackDataHandler))
1566                         throw new HttpException ("The control to register does not implement the IPostBackDataHandler interface.");
1567 #endif
1568
1569                 if (_requiresPostBack == null)
1570                         _requiresPostBack = new ArrayList ();
1571
1572                 if (_requiresPostBack.Contains (control.UniqueID))
1573                         return;
1574
1575                 _requiresPostBack.Add (control.UniqueID);
1576         }
1577
1578         [EditorBrowsable (EditorBrowsableState.Advanced)]
1579         public virtual void RegisterRequiresRaiseEvent (IPostBackEventHandler control)
1580         {
1581                 requiresRaiseEvent = control;
1582         }
1583
1584 #if NET_2_0
1585         [Obsolete]
1586 #endif
1587         [EditorBrowsable (EditorBrowsableState.Advanced)]
1588         public virtual void RegisterStartupScript (string key, string script)
1589         {
1590                 scriptManager.RegisterStartupScript (key, script);
1591         }
1592
1593         [EditorBrowsable (EditorBrowsableState.Advanced)]
1594         public void RegisterViewStateHandler ()
1595         {
1596                 handleViewState = true;
1597         }
1598
1599         [EditorBrowsable (EditorBrowsableState.Advanced)]
1600         protected virtual void SavePageStateToPersistenceMedium (object viewState)
1601         {
1602                 PageStatePersister persister = this.PageStatePersister;
1603                 if (persister == null)
1604                         return;
1605                 Pair pair = viewState as Pair;
1606                 if (pair != null) {
1607                         persister.ViewState = pair.First;
1608                         persister.ControlState = pair.Second;
1609                 } else
1610                         persister.ViewState = viewState;
1611                 persister.Save ();
1612         }
1613
1614         internal string RawViewState {
1615                 get {
1616                         NameValueCollection postdata = _requestValueCollection;
1617                         string view_state;
1618                         if (postdata == null || (view_state = postdata ["__VIEWSTATE"]) == null)
1619                                 return null;
1620
1621                         if (view_state == "")
1622                                 return null;
1623                         return view_state;
1624                 }
1625                 set { _savedViewState = value; }
1626         }
1627
1628 #if NET_2_0
1629         protected virtual
1630 #else
1631         internal
1632 #endif
1633         PageStatePersister PageStatePersister {
1634                 get {
1635                         if (page_state_persister == null)
1636                                 page_state_persister = new HiddenFieldPageStatePersister (this);
1637                         return page_state_persister;
1638                 }
1639         }
1640
1641         [EditorBrowsable (EditorBrowsableState.Advanced)]
1642         protected virtual object LoadPageStateFromPersistenceMedium ()
1643         {
1644                 PageStatePersister persister = this.PageStatePersister;
1645                 if (persister == null)
1646                         return null;
1647                 persister.Load ();
1648                 return new Pair (persister.ViewState, persister.ControlState);
1649         }
1650
1651         internal void LoadPageViewState()
1652         {
1653                 Pair sState = LoadPageStateFromPersistenceMedium () as Pair;
1654                 if (sState != null) {
1655                         if (allow_load) {
1656 #if NET_2_0
1657                                 LoadPageControlState (sState.Second);
1658 #endif
1659                                 Pair vsr = sState.First as Pair;
1660                                 if (vsr != null) {
1661                                         LoadViewStateRecursive (vsr.First);
1662                                         _requiresPostBackCopy = vsr.Second as ArrayList;
1663                                 }
1664                         }
1665                 }
1666         }
1667
1668         internal void SavePageViewState ()
1669         {
1670                 if (!handleViewState)
1671                         return;
1672
1673 #if NET_2_0
1674                 object controlState = SavePageControlState ();
1675 #endif
1676
1677                 object viewState = SaveViewStateRecursive ();
1678                 object reqPostback = (_requiresPostBack != null && _requiresPostBack.Count > 0) ? _requiresPostBack : null;
1679                 Pair vsr = null;
1680
1681                 if (viewState != null || reqPostback != null)
1682                         vsr = new Pair (viewState, reqPostback);
1683                 Pair pair = new Pair ();
1684
1685                 pair.First = vsr;
1686 #if NET_2_0
1687                 pair.Second = controlState;
1688 #else
1689                 pair.Second = null;
1690 #endif
1691                 if (pair.First == null && pair.Second == null)
1692                         SavePageStateToPersistenceMedium (null);
1693                 else
1694                         SavePageStateToPersistenceMedium (pair);
1695
1696         }
1697
1698         public virtual void Validate ()
1699         {
1700                 is_validated = true;
1701                 ValidateCollection (_validators);
1702         }
1703
1704 #if NET_2_0
1705         internal bool AreValidatorsUplevel () {
1706                 return AreValidatorsUplevel (String.Empty);
1707         }
1708
1709         internal bool AreValidatorsUplevel (string valGroup)
1710 #else
1711         internal virtual bool AreValidatorsUplevel ()
1712 #endif
1713         {
1714                 bool uplevel = false;
1715
1716                 foreach (IValidator v in Validators) {
1717                         BaseValidator bv = v as BaseValidator;
1718                         if (bv == null) continue;
1719
1720 #if NET_2_0
1721                         if (valGroup != bv.ValidationGroup)
1722                                 continue;
1723 #endif
1724                         if (bv.GetRenderUplevel()) {
1725                                 uplevel = true;
1726                                 break;
1727                         }
1728                 }
1729
1730                 return uplevel;
1731         }
1732
1733         bool ValidateCollection (ValidatorCollection validators)
1734         {
1735 #if NET_2_0
1736                 if (!_eventValidation)
1737                         return true;
1738 #endif
1739
1740                 if (validators == null || validators.Count == 0)
1741                         return true;
1742
1743                 bool all_valid = true;
1744                 foreach (IValidator v in validators){
1745                         v.Validate ();
1746                         if (v.IsValid == false)
1747                                 all_valid = false;
1748                 }
1749
1750                 return all_valid;
1751         }
1752
1753         [EditorBrowsable (EditorBrowsableState.Advanced)]
1754         public virtual void VerifyRenderingInServerForm (Control control)
1755         {
1756                 if (_context == null)
1757                         return;
1758 #if NET_2_0
1759                 if (IsCallback)
1760                         return;
1761 #endif
1762                 if (!renderingForm)
1763                         throw new HttpException ("Control '" +
1764                                                  control.ClientID +
1765                                                  "' of type '" +
1766                                                  control.GetType ().Name +
1767                                                  "' must be placed inside a form tag with runat=server.");
1768         }
1769
1770         protected override void FrameworkInitialize ()
1771         {
1772                 base.FrameworkInitialize ();
1773 #if NET_2_0
1774                 InitializeStyleSheet ();
1775 #endif
1776         }
1777
1778         #endregion
1779
1780         #if NET_2_0
1781         public
1782         #else
1783         internal
1784         #endif
1785                 ClientScriptManager ClientScript {
1786                 get { return scriptManager; }
1787         }
1788
1789         #if NET_2_0
1790
1791         static readonly object InitCompleteEvent = new object ();
1792         static readonly object LoadCompleteEvent = new object ();
1793         static readonly object PreInitEvent = new object ();
1794         static readonly object PreLoadEvent = new object ();
1795         static readonly object PreRenderCompleteEvent = new object ();
1796         static readonly object SaveStateCompleteEvent = new object ();
1797         int event_mask;
1798         const int initcomplete_mask = 1;
1799         const int loadcomplete_mask = 1 << 1;
1800         const int preinit_mask = 1 << 2;
1801         const int preload_mask = 1 << 3;
1802         const int prerendercomplete_mask = 1 << 4;
1803         const int savestatecomplete_mask = 1 << 5;
1804
1805         [EditorBrowsable (EditorBrowsableState.Advanced)]
1806         public event EventHandler InitComplete {
1807                 add {
1808                         event_mask |= initcomplete_mask;
1809                         Events.AddHandler (InitCompleteEvent, value);
1810                 }
1811                 remove { Events.RemoveHandler (InitCompleteEvent, value); }
1812         }
1813
1814         [EditorBrowsable (EditorBrowsableState.Advanced)]
1815         public event EventHandler LoadComplete {
1816                 add {
1817                         event_mask |= loadcomplete_mask;
1818                         Events.AddHandler (LoadCompleteEvent, value);
1819                 }
1820                 remove { Events.RemoveHandler (LoadCompleteEvent, value); }
1821         }
1822
1823         public event EventHandler PreInit {
1824                 add {
1825                         event_mask |= preinit_mask;
1826                         Events.AddHandler (PreInitEvent, value);
1827                 }
1828                 remove { Events.RemoveHandler (PreInitEvent, value); }
1829         }
1830
1831         [EditorBrowsable (EditorBrowsableState.Advanced)]
1832         public event EventHandler PreLoad {
1833                 add {
1834                         event_mask |= preload_mask;
1835                         Events.AddHandler (PreLoadEvent, value);
1836                 }
1837                 remove { Events.RemoveHandler (PreLoadEvent, value); }
1838         }
1839
1840         [EditorBrowsable (EditorBrowsableState.Advanced)]
1841         public event EventHandler PreRenderComplete {
1842                 add {
1843                         event_mask |= prerendercomplete_mask;
1844                         Events.AddHandler (PreRenderCompleteEvent, value);
1845                 }
1846                 remove { Events.RemoveHandler (PreRenderCompleteEvent, value); }
1847         }
1848
1849         [EditorBrowsable (EditorBrowsableState.Advanced)]
1850         public event EventHandler SaveStateComplete {
1851                 add {
1852                         event_mask |= savestatecomplete_mask;
1853                         Events.AddHandler (SaveStateCompleteEvent, value);
1854                 }
1855                 remove { Events.RemoveHandler (SaveStateCompleteEvent, value); }
1856         }
1857
1858         protected virtual void OnInitComplete (EventArgs e)
1859         {
1860                 if ((event_mask & initcomplete_mask) != 0) {
1861                         EventHandler eh = (EventHandler) (Events [InitCompleteEvent]);
1862                         if (eh != null) eh (this, e);
1863                 }
1864         }
1865
1866         protected virtual void OnLoadComplete (EventArgs e)
1867         {
1868                 if ((event_mask & loadcomplete_mask) != 0) {
1869                         EventHandler eh = (EventHandler) (Events [LoadCompleteEvent]);
1870                         if (eh != null) eh (this, e);
1871                 }
1872         }
1873
1874         protected virtual void OnPreInit (EventArgs e)
1875         {
1876                 if ((event_mask & preinit_mask) != 0) {
1877                         EventHandler eh = (EventHandler) (Events [PreInitEvent]);
1878                         if (eh != null) eh (this, e);
1879                 }
1880         }
1881
1882         protected virtual void OnPreLoad (EventArgs e)
1883         {
1884                 if ((event_mask & preload_mask) != 0) {
1885                         EventHandler eh = (EventHandler) (Events [PreLoadEvent]);
1886                         if (eh != null) eh (this, e);
1887                 }
1888         }
1889
1890         protected virtual void OnPreRenderComplete (EventArgs e)
1891         {
1892                 if ((event_mask & prerendercomplete_mask) != 0) {
1893                         EventHandler eh = (EventHandler) (Events [PreRenderCompleteEvent]);
1894                         if (eh != null) eh (this, e);
1895                 }
1896
1897                 if (Form == null)
1898                         return;
1899                 if (!Form.DetermineRenderUplevel ())
1900                         return;
1901
1902                 /* figure out if we have some control we're going to focus */
1903                 if (String.IsNullOrEmpty (_focusedControlID)) {
1904                         _focusedControlID = Form.DefaultFocus;
1905                         if (String.IsNullOrEmpty (_focusedControlID))
1906                                 _focusedControlID = Form.DefaultButton;
1907                 }
1908
1909                         if (!String.IsNullOrEmpty (_focusedControlID)) {
1910                                 ClientScript.RegisterWebFormClientScript ();
1911                                 ClientScript.RegisterStartupScript ("HtmlForm-DefaultButton-StartupScript",
1912                                                                          String.Format ("<script type=\"text/javascript\">\n" +
1913                                                                                         "<!--\n" +
1914                                                                                         "WebForm_AutoFocus('{0}');// -->\n" +
1915                                                                                         "</script>\n", _focusedControlID));
1916                         }
1917
1918                         if (Form.SubmitDisabledControls && _hasEnabledControlArray) {
1919                                 ClientScript.RegisterWebFormClientScript ();
1920                                 ClientScript.RegisterOnSubmitStatement ("HtmlForm-SubmitDisabledControls-SubmitStatement",
1921                                                                                  "WebForm_ReEnableControls(this);");
1922                         }
1923         }
1924
1925         internal void RegisterEnabledControl (Control control)
1926         {
1927                 if (Form == null || !Page.Form.SubmitDisabledControls || !Page.Form.DetermineRenderUplevel ())
1928                         return;
1929                 _hasEnabledControlArray = true;
1930                 Page.ClientScript.RegisterArrayDeclaration (EnabledControlArrayID, String.Format ("'{0}'", control.ClientID));
1931         }
1932
1933         protected virtual void OnSaveStateComplete (EventArgs e)
1934         {
1935                 if ((event_mask & savestatecomplete_mask) != 0) {
1936                         EventHandler eh = (EventHandler) (Events [SaveStateCompleteEvent]);
1937                         if (eh != null) eh (this, e);
1938                 }
1939         }
1940
1941         public HtmlForm Form {
1942                 get { return _form; }
1943         }
1944
1945         internal void RegisterForm (HtmlForm form)
1946         {
1947                 _form = form;
1948         }
1949
1950         [BrowsableAttribute (false)]
1951         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
1952         public Page PreviousPage {
1953                 get {
1954                         if (_doLoadPreviousPage) {
1955                                 _doLoadPreviousPage = false;
1956                                 LoadPreviousPageReference ();
1957                         }
1958                         return previousPage;
1959                 }
1960         }
1961
1962
1963         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
1964         [BrowsableAttribute (false)]
1965         public bool IsCallback {
1966                 get { return isCallback; }
1967         }
1968
1969         [BrowsableAttribute (false)]
1970         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
1971         public bool IsCrossPagePostBack {
1972                 get { return isCrossPagePostBack; }
1973         }
1974
1975         public new virtual char IdSeparator {
1976                 get {
1977                         //TODO: why override?
1978                         return base.IdSeparator;
1979                 }
1980         }
1981
1982         string ProcessCallbackData ()
1983         {
1984                 string callbackTarget = _requestValueCollection [CallbackSourceID];
1985                 if (callbackTarget == null || callbackTarget.Length == 0)
1986                         throw new HttpException ("Callback target not provided.");
1987
1988                 Control targetControl = FindControl (callbackTarget);
1989                 ICallbackEventHandler target = targetControl as ICallbackEventHandler;
1990                 if (target == null)
1991                         throw new HttpException (string.Format ("Invalid callback target '{0}'.", callbackTarget));
1992
1993                 string callbackEventError = String.Empty;
1994                 string callBackResult;
1995                 string callbackArgument = _requestValueCollection [CallbackArgumentID];
1996
1997                 try {
1998                         target.RaiseCallbackEvent (callbackArgument);
1999                 }
2000                 catch (Exception ex) {
2001                         callbackEventError = String.Format ("e{0}", ex.Message);
2002                 }
2003
2004                 try {
2005                         callBackResult = target.GetCallbackResult ();
2006                 }
2007                 catch (Exception ex) {
2008                         return String.Format ("e{0}", ex.Message);
2009                 }
2010
2011                 string eventValidation = ClientScript.GetEventValidationStateFormatted ();
2012                 return String.Format ("{0}{1}|{2}{3}", callbackEventError, eventValidation == null ? 0 : eventValidation.Length, eventValidation, callBackResult);
2013         }
2014
2015         [BrowsableAttribute (false)]
2016         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
2017         public HtmlHead Header {
2018                 get { return htmlHeader; }
2019         }
2020
2021         internal void SetHeader (HtmlHead header)
2022         {
2023                 htmlHeader = header;
2024                 if (_title != null) {
2025                         htmlHeader.Title = _title;
2026                         _title = null;
2027                 }
2028         }
2029
2030         protected bool AsyncMode {
2031                 get { return asyncMode; }
2032                 set { asyncMode = value; }
2033         }
2034
2035         public TimeSpan AsyncTimeout {
2036                 get { return asyncTimeout; }
2037                 set { asyncTimeout = value; }
2038         }
2039
2040         public bool IsAsync {
2041                 get { return AsyncMode; }
2042         }
2043
2044         [MonoTODO ("Not Implemented")]
2045         protected internal virtual string UniqueFilePathSuffix {
2046                 get {
2047                         throw new NotImplementedException ();
2048                 }
2049         }
2050
2051         [MonoTODO ("Not Implemented")]
2052         public int MaxPageStateFieldLength {
2053                 get {
2054                         throw new NotImplementedException ();
2055                 }
2056                 set {
2057                         throw new NotImplementedException ();
2058                 }
2059         }
2060
2061         public void AddOnPreRenderCompleteAsync (BeginEventHandler beginHandler, EndEventHandler endHandler)
2062         {
2063                 AddOnPreRenderCompleteAsync (beginHandler, endHandler, null);
2064         }
2065
2066         public void AddOnPreRenderCompleteAsync (BeginEventHandler beginHandler, EndEventHandler endHandler, Object state)
2067         {
2068                 if (!IsAsync) {
2069                         throw new InvalidOperationException ("AddOnPreRenderCompleteAsync called and Page.IsAsync == false");
2070                 }
2071
2072                 if (_lifeCycle >= PageLifeCycle.PreRender) {
2073                         throw new InvalidOperationException ("AddOnPreRenderCompleteAsync can only be called before PreRender.");
2074                 }
2075
2076                 if (beginHandler == null) {
2077                         throw new ArgumentNullException ("beginHandler");
2078                 }
2079
2080                 if (endHandler == null) {
2081                         throw new ArgumentNullException ("endHandler");
2082                 }
2083
2084                 RegisterAsyncTask (new PageAsyncTask (beginHandler, endHandler, null, state, false));
2085         }
2086
2087         private List<PageAsyncTask> ParallelTasks {
2088                 get
2089                 {
2090                         if (parallelTasks == null) {
2091                                 parallelTasks = new List<PageAsyncTask>();
2092                         }
2093                         return parallelTasks;
2094                 }
2095         }
2096
2097         private List<PageAsyncTask> SerialTasks {
2098                 get {
2099                         if (serialTasks == null) {
2100                                 serialTasks = new List<PageAsyncTask> ();
2101                         }
2102                         return serialTasks;
2103                 }
2104         }
2105
2106         public void RegisterAsyncTask (PageAsyncTask task)
2107         {
2108                 if (task == null) {
2109                         throw new ArgumentNullException ("task");
2110                 }
2111
2112                 if (task.ExecuteInParallel) {
2113                         ParallelTasks.Add (task);
2114                 }
2115                 else {
2116                         SerialTasks.Add (task);
2117                 }
2118         }
2119
2120         public void ExecuteRegisteredAsyncTasks ()
2121         {
2122                 if ((parallelTasks == null || parallelTasks.Count == 0) &&
2123                         (serialTasks == null || serialTasks.Count == 0)){
2124                         return;
2125                 }
2126
2127                 if (parallelTasks != null) {
2128                         DateTime startExecution = DateTime.Now;
2129                         List<PageAsyncTask> localParallelTasks = parallelTasks;
2130                         parallelTasks = null; // Shouldn't execute tasks twice
2131                         List<IAsyncResult> asyncResults = new List<IAsyncResult>();
2132                         foreach (PageAsyncTask parallelTask in localParallelTasks) {
2133                                 IAsyncResult result = parallelTask.BeginHandler (this, EventArgs.Empty, new AsyncCallback (EndAsyncTaskCallback), parallelTask.State);
2134                                 if (result.CompletedSynchronously) {
2135                                         parallelTask.EndHandler (result);
2136                                 }
2137                                 else {
2138                                         asyncResults.Add (result);
2139                                 }
2140                         }
2141
2142                         if (asyncResults.Count > 0) {
2143 #if TARGET_JVM
2144                                 TimeSpan timeout = AsyncTimeout;
2145                                 long t1 = DateTime.Now.Ticks;
2146                                 bool signalled = true;
2147                                 for (int i = 0; i < asyncResults.Count; i++) {
2148                                         if (asyncResults [i].IsCompleted)
2149                                                 continue;
2150
2151                                         if (signalled)
2152                                                 signalled = asyncResults [i].AsyncWaitHandle.WaitOne (timeout, false);
2153
2154                                         if (signalled) {
2155                                                 long t2 = DateTime.Now.Ticks;
2156                                                 timeout = AsyncTimeout - TimeSpan.FromTicks (t2 - t1);
2157                                                 if (timeout.Ticks <= 0)
2158                                                         signalled = false;
2159                                         }
2160                                         else {
2161                                                 localParallelTasks [i].TimeoutHandler (asyncResults [i]);
2162                                         }
2163                                 }
2164 #else
2165                                 WaitHandle [] waitArray = new WaitHandle [asyncResults.Count];
2166                                 int i = 0;
2167                                 for (i = 0; i < asyncResults.Count; i++) {
2168                                         waitArray [i] = asyncResults [i].AsyncWaitHandle;
2169                                 }
2170                                 bool allSignalled = WaitHandle.WaitAll (waitArray, AsyncTimeout, false);
2171                                 if (!allSignalled) {
2172                                         for (i = 0; i < asyncResults.Count; i++) {
2173                                                 if (!asyncResults [i].IsCompleted) {
2174                                                         localParallelTasks [i].TimeoutHandler (asyncResults [i]);
2175                                                 }
2176                                         }
2177                                 }
2178 #endif
2179                         }
2180                         DateTime endWait = DateTime.Now;
2181                         TimeSpan elapsed = endWait - startExecution;
2182                         if (elapsed <= AsyncTimeout) {
2183                                 AsyncTimeout -= elapsed;
2184                         }
2185                         else {
2186                                 AsyncTimeout = TimeSpan.FromTicks(0);
2187                         }
2188                 }
2189
2190                 if (serialTasks != null) {
2191                         List<PageAsyncTask> localSerialTasks = serialTasks;
2192                         serialTasks = null; // Shouldn't execute tasks twice
2193                         foreach (PageAsyncTask serialTask in localSerialTasks) {
2194                                 DateTime startExecution = DateTime.Now;
2195
2196                                 IAsyncResult result = serialTask.BeginHandler (this, EventArgs.Empty, new AsyncCallback (EndAsyncTaskCallback), serialTask);
2197                                 if (result.CompletedSynchronously) {
2198                                         serialTask.EndHandler (result);
2199                                 }
2200                                 else {
2201                                         bool done = result.AsyncWaitHandle.WaitOne (AsyncTimeout, false);
2202                                         if (!done && !result.IsCompleted) {
2203                                                 serialTask.TimeoutHandler (result);
2204                                         }
2205                                 }
2206                                 DateTime endWait = DateTime.Now;
2207                                 TimeSpan elapsed = endWait - startExecution;
2208                                 if (elapsed <= AsyncTimeout) {
2209                                         AsyncTimeout -= elapsed;
2210                                 }
2211                                 else {
2212                                         AsyncTimeout = TimeSpan.FromTicks (0);
2213                                 }
2214                         }
2215                 }
2216                 AsyncTimeout = TimeSpan.FromSeconds (DefaultAsyncTimeout);
2217         }
2218
2219         void EndAsyncTaskCallback (IAsyncResult result)
2220         {
2221                 PageAsyncTask task = (PageAsyncTask)result.AsyncState;
2222                 task.EndHandler (result);
2223         }
2224
2225         public static HtmlTextWriter CreateHtmlTextWriterFromType (TextWriter tw, Type writerType)
2226         {
2227                 Type htmlTextWriterType = typeof (HtmlTextWriter);
2228
2229                 if (!htmlTextWriterType.IsAssignableFrom (writerType)) {
2230                         throw new HttpException (String.Format ("Type '{0}' cannot be assigned to HtmlTextWriter", writerType.FullName));
2231                 }
2232
2233                 ConstructorInfo constructor = writerType.GetConstructor (new Type [] { typeof (TextWriter) });
2234                 if (constructor == null) {
2235                         throw new HttpException (String.Format ("Type '{0}' does not have a consturctor that takes a TextWriter as parameter", writerType.FullName));
2236                 }
2237
2238                 return (HtmlTextWriter) Activator.CreateInstance(writerType, tw);
2239         }
2240
2241         public ViewStateEncryptionMode ViewStateEncryptionMode {
2242                 get { return viewStateEncryptionMode; }
2243                 set { viewStateEncryptionMode = value; }
2244         }
2245
2246         public void RegisterRequiresViewStateEncryption ()
2247         {
2248                 controlRegisteredForViewStateEncryption = true;
2249         }
2250
2251         private static byte [] AES_IV = null;
2252         private static byte [] TripleDES_IV = null;
2253         private static object locker = new object ();
2254         private static bool isEncryptionInitialized = false;
2255
2256         private static void InitializeEncryption ()
2257         {
2258                 if (isEncryptionInitialized) {
2259                         return;
2260                 }
2261
2262                 lock (locker) {
2263                         if (isEncryptionInitialized) {
2264                                 return;
2265                         }
2266
2267                         string iv_string = "0BA48A9E-736D-40f8-954B-B2F62241F282";
2268                         AES_IV = new byte [16];
2269                         TripleDES_IV = new byte [8];
2270
2271                         int i;
2272                         for (i = 0; i < AES_IV.Length; i++) {
2273                                 AES_IV [i] = (byte) iv_string [i];
2274                         }
2275
2276                         for (i = 0; i < TripleDES_IV.Length; i++) {
2277                                 TripleDES_IV [i] = (byte) iv_string [i];
2278                         }
2279
2280                         isEncryptionInitialized = true;
2281                 }
2282         }
2283
2284         internal ICryptoTransform GetCryptoTransform (CryptoStreamMode cryptoStreamMode)
2285         {
2286                 ICryptoTransform transform = null;
2287                 MachineKeySection config = (MachineKeySection) WebConfigurationManager.GetSection (machineKeyConfigPath);
2288                 byte [] vk = config.ValidationKeyBytes;
2289
2290                 switch (config.Validation) {
2291                 case MachineKeyValidation.SHA1:
2292                         transform = SHA1.Create ();
2293                         break;
2294
2295                 case MachineKeyValidation.MD5:
2296                         transform = MD5.Create ();
2297                         break;
2298
2299                 case MachineKeyValidation.AES:
2300                         if (cryptoStreamMode == CryptoStreamMode.Read){
2301                                 transform = Rijndael.Create().CreateDecryptor(vk, AES_IV);
2302                         } else {
2303                                 transform = Rijndael.Create().CreateEncryptor(vk, AES_IV);
2304                         }
2305                         break;
2306
2307                 case MachineKeyValidation.TripleDES:
2308                         if (cryptoStreamMode == CryptoStreamMode.Read){
2309                                 transform = TripleDES.Create().CreateDecryptor(vk, TripleDES_IV);
2310                         } else {
2311                                 transform = TripleDES.Create().CreateEncryptor(vk, TripleDES_IV);
2312                         }
2313                         break;
2314                 }
2315
2316                 return transform;
2317         }
2318
2319         internal bool NeedViewStateEncryption {
2320                 get {
2321                         return (ViewStateEncryptionMode == ViewStateEncryptionMode.Always ||
2322                                         (ViewStateEncryptionMode == ViewStateEncryptionMode.Auto &&
2323                                          controlRegisteredForViewStateEncryption));
2324
2325                 }
2326         }
2327
2328         void ApplyMasterPage ()
2329         {
2330                 if (masterPageFile != null && masterPageFile.Length > 0) {
2331                         ArrayList appliedMasterPageFiles = new ArrayList ();
2332
2333                         if (Master != null) {
2334                                 MasterPage.ApplyMasterPageRecursive (Master, appliedMasterPageFiles);
2335
2336                                 Master.Page = this;
2337                                 Controls.Clear ();
2338                                 Controls.Add (Master);
2339                         }
2340                 }
2341         }
2342
2343         [DefaultValueAttribute ("")]
2344         public virtual string MasterPageFile {
2345                 get { return masterPageFile; }
2346                 set {
2347                         masterPageFile = value;
2348                         masterPage = null;
2349                 }
2350         }
2351
2352         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
2353         [BrowsableAttribute (false)]
2354         public MasterPage Master {
2355                 get {
2356                         if (Context == null || String.IsNullOrEmpty (masterPageFile))
2357                                 return null;
2358
2359                         if (masterPage == null)
2360                                 masterPage = MasterPage.CreateMasterPage (this, Context, masterPageFile, contentTemplates);
2361
2362                         return masterPage;
2363                 }
2364         }
2365
2366         public void SetFocus (string clientID)
2367         {
2368                 if (String.IsNullOrEmpty (clientID))
2369                         throw new ArgumentNullException ("control");
2370
2371                 if (_lifeCycle > PageLifeCycle.PreRender)
2372                         throw new InvalidOperationException ("SetFocus can only be called before and during PreRender.");
2373
2374                 if(Form==null)
2375                         throw new InvalidOperationException ("A form tag with runat=server must exist on the Page to use SetFocus() or the Focus property.");
2376
2377                 _focusedControlID = clientID;
2378         }
2379
2380         public void SetFocus (Control control)
2381         {
2382                 if (control == null)
2383                         throw new ArgumentNullException ("control");
2384
2385                 SetFocus (control.ClientID);
2386         }
2387
2388         [EditorBrowsable (EditorBrowsableState.Advanced)]
2389         public void RegisterRequiresControlState (Control control)
2390         {
2391                 if (control == null)
2392                         throw new ArgumentNullException ("control");
2393
2394                 if (RequiresControlState (control))
2395                         return;
2396
2397                 if (requireStateControls == null)
2398                         requireStateControls = new ArrayList ();
2399                 int n = requireStateControls.Add (control);
2400
2401                 if (_savedControlState == null || n >= _savedControlState.Length)
2402                         return;
2403
2404                 for (Control parent = control.Parent; parent != null; parent = parent.Parent)
2405                         if (parent.IsChildControlStateCleared)
2406                                 return;
2407
2408                 object state = _savedControlState [n];
2409                 if (state != null)
2410                         control.LoadControlState (state);
2411         }
2412
2413         public bool RequiresControlState (Control control)
2414         {
2415                 if (requireStateControls == null) return false;
2416                 return requireStateControls.Contains (control);
2417         }
2418
2419         [EditorBrowsable (EditorBrowsableState.Advanced)]
2420         public void UnregisterRequiresControlState (Control control)
2421         {
2422                 if (requireStateControls != null)
2423                         requireStateControls.Remove (control);
2424         }
2425
2426         public ValidatorCollection GetValidators (string validationGroup)
2427         {
2428                 string valgr = validationGroup;
2429                 if (valgr == null)
2430                         valgr = String.Empty;
2431
2432                 if (_validatorsByGroup == null) _validatorsByGroup = new Hashtable ();
2433                 ValidatorCollection col = _validatorsByGroup [valgr] as ValidatorCollection;
2434                 if (col == null) {
2435                         col = new ValidatorCollection ();
2436                         _validatorsByGroup [valgr] = col;
2437                 }
2438                 return col;
2439         }
2440
2441         public virtual void Validate (string validationGroup)
2442         {
2443                 is_validated = true;
2444                 if (validationGroup == null)
2445                         ValidateCollection (_validatorsByGroup [String.Empty] as ValidatorCollection);
2446                 else if (_validatorsByGroup != null) {
2447                         ValidateCollection (_validatorsByGroup [validationGroup] as ValidatorCollection);
2448                 }
2449         }
2450
2451         object SavePageControlState ()
2452         {
2453                 if (requireStateControls == null) return null;
2454                 object[] state = new object [requireStateControls.Count];
2455
2456                 bool allNull = true;
2457                 for (int n=0; n<state.Length; n++) {
2458                         state [n] = ((Control) requireStateControls [n]).SaveControlState ();
2459                         if (state [n] != null) allNull = false;
2460                 }
2461                 if (allNull) return null;
2462                 else return state;
2463         }
2464
2465         void LoadPageControlState (object data)
2466         {
2467                 _savedControlState = (object []) data;
2468
2469                 if (requireStateControls == null) return;
2470
2471                 int max = Math.Min (requireStateControls.Count, _savedControlState != null ? _savedControlState.Length : requireStateControls.Count);
2472                 for (int n=0; n < max; n++) {
2473                         Control ctl = (Control) requireStateControls [n];
2474                         ctl.LoadControlState (_savedControlState != null ? _savedControlState [n] : null);
2475                 }
2476         }
2477
2478         void LoadPreviousPageReference ()
2479         {
2480                 if (_requestValueCollection != null) {
2481                         string prevPage = _requestValueCollection [PreviousPageID];
2482                         if (prevPage != null) {
2483                                 previousPage = (Page) PageParser.GetCompiledPageInstance (prevPage, Server.MapPath (prevPage), Context);
2484                                 previousPage.ProcessCrossPagePostBack (_context);
2485                         }
2486                 }
2487         }
2488
2489
2490         Hashtable contentTemplates;
2491         [EditorBrowsable (EditorBrowsableState.Never)]
2492         protected internal void AddContentTemplate (string templateName, ITemplate template)
2493         {
2494                 if (contentTemplates == null)
2495                         contentTemplates = new Hashtable ();
2496                 contentTemplates [templateName] = template;
2497         }
2498
2499         PageTheme _pageTheme;
2500         internal PageTheme PageTheme {
2501                 get { return _pageTheme; }
2502         }
2503
2504         PageTheme _styleSheetPageTheme;
2505         internal PageTheme StyleSheetPageTheme {
2506                 get { return _styleSheetPageTheme; }
2507         }
2508
2509         Stack dataItemCtx;
2510
2511         internal void PushDataItemContext (object o) {
2512                 if (dataItemCtx == null)
2513                         dataItemCtx = new Stack ();
2514
2515                 dataItemCtx.Push (o);
2516         }
2517
2518         internal void PopDataItemContext () {
2519                 if (dataItemCtx == null)
2520                         throw new InvalidOperationException ();
2521
2522                 dataItemCtx.Pop ();
2523         }
2524
2525         public object GetDataItem() {
2526                 if (dataItemCtx == null || dataItemCtx.Count == 0)
2527                         throw new InvalidOperationException ("No data item");
2528
2529                 return dataItemCtx.Peek ();
2530         }
2531
2532         protected internal override void OnInit (EventArgs e)
2533         {
2534                 base.OnInit (e);
2535
2536                 ArrayList themes = new ArrayList();
2537
2538                 if (StyleSheetPageTheme != null && StyleSheetPageTheme.GetStyleSheets () != null)
2539                         themes.AddRange (StyleSheetPageTheme.GetStyleSheets ());
2540                 if (PageTheme != null && PageTheme.GetStyleSheets () != null)
2541                         themes.AddRange (PageTheme.GetStyleSheets ());
2542
2543                 if (themes.Count > 0 && Header == null)
2544                         throw new InvalidOperationException ("Using themed css files requires a header control on the page.");
2545
2546                 foreach (string lss in themes) {
2547                         HtmlLink hl = new HtmlLink ();
2548                         hl.Href = ResolveUrl (lss);
2549                         hl.Attributes["type"] = "text/css";
2550                         hl.Attributes["rel"] = "stylesheet";
2551                         Header.Controls.Add (hl);
2552                 }
2553         }
2554
2555         #endif
2556
2557 #if NET_2_0
2558         [MonoTODO ("Not implemented.  Only used by .net aspx parser")]
2559         protected object GetWrappedFileDependencies (string [] list)
2560         {
2561                 return list;
2562         }
2563
2564         [MonoTODO ("Does nothing.  Used by .net aspx parser")]
2565         protected virtual void InitializeCulture ()
2566         {
2567         }
2568
2569         [MonoTODO ("Does nothing. Used by .net aspx parser")]
2570         protected internal void AddWrappedFileDependencies (object virtualFileDependencies)
2571         {
2572         }
2573 #endif
2574 }
2575 }