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 #if TARGET_J2EE
1347                         if (!IsGetBack)
1348 #endif
1349                         ProcessPostData (_requestValueCollection, false);
1350                         Trace.Write ("aspx.page", "End ProcessPostData");
1351                 }
1352
1353 #if NET_2_0
1354                 OnPreLoad (EventArgs.Empty);
1355                 _lifeCycle = PageLifeCycle.Load;
1356 #endif
1357
1358                 LoadRecursive ();
1359 #if NET_2_0
1360 #if TARGET_J2EE
1361                 if (!IsGetBack)
1362 #endif
1363                 if (IsPostBack || IsCallback) {
1364                         _lifeCycle = PageLifeCycle.ControlEvents;
1365 #else
1366                 if (IsPostBack) {
1367 #endif
1368                         Trace.Write ("aspx.page", "Begin ProcessPostData Second Try");
1369                         ProcessPostData (secondPostData, true);
1370                         Trace.Write ("aspx.page", "End ProcessPostData Second Try");
1371                         Trace.Write ("aspx.page", "Begin Raise ChangedEvents");
1372                         RaiseChangedEvents ();
1373                         Trace.Write ("aspx.page", "End Raise ChangedEvents");
1374                         Trace.Write ("aspx.page", "Begin Raise PostBackEvent");
1375                         RaisePostBackEvents ();
1376                         Trace.Write ("aspx.page", "End Raise PostBackEvent");
1377                 }
1378
1379 #if NET_2_0
1380                 _lifeCycle = PageLifeCycle.LoadComplete;
1381                 OnLoadComplete (EventArgs.Empty);
1382
1383                 if (IsCrossPagePostBack)
1384                         return;
1385
1386                 if (IsCallback) {
1387                         string result = ProcessCallbackData ();
1388                         HtmlTextWriter callbackOutput = new HtmlTextWriter (_context.Response.Output);
1389                         callbackOutput.Write (result);
1390                         callbackOutput.Flush ();
1391                         return;
1392                 }
1393
1394                 _lifeCycle = PageLifeCycle.PreRender;
1395 #endif
1396
1397                 Trace.Write ("aspx.page", "Begin PreRender");
1398                 PreRenderRecursiveInternal ();
1399                 Trace.Write ("aspx.page", "End PreRender");
1400
1401 #if NET_2_0
1402                 ExecuteRegisteredAsyncTasks ();
1403
1404                 _lifeCycle = PageLifeCycle.PreRenderComplete;
1405                 OnPreRenderComplete (EventArgs.Empty);
1406 #endif
1407
1408                 Trace.Write ("aspx.page", "Begin SaveViewState");
1409                 SavePageViewState ();
1410                 Trace.Write ("aspx.page", "End SaveViewState");
1411
1412 #if NET_2_0
1413                 _lifeCycle = PageLifeCycle.SaveStateComplete;
1414                 OnSaveStateComplete (EventArgs.Empty);
1415 #if TARGET_J2EE
1416                 if (OnSaveStateCompleteForPortlet ())
1417                         return;
1418 #endif // TARGET_J2EE
1419 #endif // NET_2_0
1420
1421 #if NET_2_0
1422                 _lifeCycle = PageLifeCycle.Render;
1423                 scriptManager.ResetEventValidationState ();
1424 #endif
1425
1426                 //--
1427                 Trace.Write ("aspx.page", "Begin Render");
1428                 HtmlTextWriter output = new HtmlTextWriter (_context.Response.Output);
1429                 RenderControl (output);
1430                 Trace.Write ("aspx.page", "End Render");
1431         }
1432
1433         private void RenderTrace ()
1434         {
1435                 TraceManager traceManager = HttpRuntime.TraceManager;
1436
1437                 if (Trace.HaveTrace && !Trace.IsEnabled || !Trace.HaveTrace && !traceManager.Enabled)
1438                         return;
1439
1440                 Trace.SaveData ();
1441
1442                 if (!Trace.HaveTrace && traceManager.Enabled && !traceManager.PageOutput)
1443                         return;
1444
1445                 if (!traceManager.LocalOnly || Context.Request.IsLocal) {
1446                         HtmlTextWriter output = new HtmlTextWriter (_context.Response.Output);
1447                         Trace.Render (output);
1448                 }
1449         }
1450
1451 #if NET_2_0
1452         bool CheckForValidationSupport (Control targetControl)
1453         {
1454                 if (targetControl == null)
1455                         return false;
1456                 Type type = targetControl.GetType ();
1457                 object[] attributes = type.GetCustomAttributes (false);
1458                 foreach (object attr in attributes)
1459                         if (attr is SupportsEventValidationAttribute)
1460                                 return true;
1461                 return false;
1462         }
1463 #endif
1464
1465         void RaisePostBackEvents ()
1466         {
1467 #if NET_2_0
1468                 Control targetControl;
1469 #endif
1470                 if (requiresRaiseEvent != null) {
1471                         RaisePostBackEvent (requiresRaiseEvent, null);
1472                         return;
1473                 }
1474
1475                 NameValueCollection postdata = _requestValueCollection;
1476                 if (postdata == null)
1477                         return;
1478
1479                 string eventTarget = postdata [postEventSourceID];
1480                 if (eventTarget == null || eventTarget.Length == 0) {
1481                         Validate ();
1482                         return;
1483                 }
1484
1485 #if NET_2_0
1486                 targetControl = FindControl (eventTarget);
1487                 IPostBackEventHandler target = targetControl as IPostBackEventHandler;
1488 #else
1489                 IPostBackEventHandler target = FindControl (eventTarget) as IPostBackEventHandler;
1490 #endif
1491
1492                 if (target == null)
1493                         return;
1494
1495                 string eventArgument = postdata [postEventArgumentID];
1496                 RaisePostBackEvent (target, eventArgument);
1497         }
1498
1499         internal void RaiseChangedEvents ()
1500         {
1501                 if (requiresPostDataChanged == null)
1502                         return;
1503
1504                 foreach (IPostBackDataHandler ipdh in requiresPostDataChanged)
1505                         ipdh.RaisePostDataChangedEvent ();
1506
1507                 requiresPostDataChanged = null;
1508         }
1509
1510         [EditorBrowsable (EditorBrowsableState.Advanced)]
1511         protected virtual void RaisePostBackEvent (IPostBackEventHandler sourceControl, string eventArgument)
1512         {
1513 #if NET_2_0
1514                 Control targetControl = sourceControl as Control;
1515                 if (targetControl != null && CheckForValidationSupport (targetControl))
1516                         scriptManager.ValidateEvent (targetControl.UniqueID, eventArgument);
1517 #endif
1518                 sourceControl.RaisePostBackEvent (eventArgument);
1519         }
1520
1521 #if NET_2_0
1522         [Obsolete]
1523 #endif
1524         [EditorBrowsable (EditorBrowsableState.Advanced)]
1525         public void RegisterArrayDeclaration (string arrayName, string arrayValue)
1526         {
1527                 scriptManager.RegisterArrayDeclaration (arrayName, arrayValue);
1528         }
1529
1530 #if NET_2_0
1531         [Obsolete]
1532 #endif
1533         [EditorBrowsable (EditorBrowsableState.Advanced)]
1534         public virtual void RegisterClientScriptBlock (string key, string script)
1535         {
1536                 scriptManager.RegisterClientScriptBlock (key, script);
1537         }
1538
1539 #if NET_2_0
1540         [Obsolete]
1541 #endif
1542         [EditorBrowsable (EditorBrowsableState.Advanced)]
1543         public virtual void RegisterHiddenField (string hiddenFieldName, string hiddenFieldInitialValue)
1544         {
1545                 scriptManager.RegisterHiddenField (hiddenFieldName, hiddenFieldInitialValue);
1546         }
1547
1548         [MonoTODO("Not implemented, Used in HtmlForm")]
1549         internal void RegisterClientScriptFile (string a, string b, string c)
1550         {
1551                 throw new NotImplementedException ();
1552         }
1553
1554 #if NET_2_0
1555         [Obsolete]
1556 #endif
1557         [EditorBrowsable (EditorBrowsableState.Advanced)]
1558         public void RegisterOnSubmitStatement (string key, string script)
1559         {
1560                 scriptManager.RegisterOnSubmitStatement (key, script);
1561         }
1562
1563         internal string GetSubmitStatements ()
1564         {
1565                 return scriptManager.WriteSubmitStatements ();
1566         }
1567
1568         [EditorBrowsable (EditorBrowsableState.Advanced)]
1569         public void RegisterRequiresPostBack (Control control)
1570         {
1571 #if NET_2_0
1572                 if (!(control is IPostBackDataHandler))
1573                         throw new HttpException ("The control to register does not implement the IPostBackDataHandler interface.");
1574 #endif
1575
1576                 if (_requiresPostBack == null)
1577                         _requiresPostBack = new ArrayList ();
1578
1579                 if (_requiresPostBack.Contains (control.UniqueID))
1580                         return;
1581
1582                 _requiresPostBack.Add (control.UniqueID);
1583         }
1584
1585         [EditorBrowsable (EditorBrowsableState.Advanced)]
1586         public virtual void RegisterRequiresRaiseEvent (IPostBackEventHandler control)
1587         {
1588                 requiresRaiseEvent = control;
1589         }
1590
1591 #if NET_2_0
1592         [Obsolete]
1593 #endif
1594         [EditorBrowsable (EditorBrowsableState.Advanced)]
1595         public virtual void RegisterStartupScript (string key, string script)
1596         {
1597                 scriptManager.RegisterStartupScript (key, script);
1598         }
1599
1600         [EditorBrowsable (EditorBrowsableState.Advanced)]
1601         public void RegisterViewStateHandler ()
1602         {
1603                 handleViewState = true;
1604         }
1605
1606         [EditorBrowsable (EditorBrowsableState.Advanced)]
1607         protected virtual void SavePageStateToPersistenceMedium (object viewState)
1608         {
1609                 PageStatePersister persister = this.PageStatePersister;
1610                 if (persister == null)
1611                         return;
1612                 Pair pair = viewState as Pair;
1613                 if (pair != null) {
1614                         persister.ViewState = pair.First;
1615                         persister.ControlState = pair.Second;
1616                 } else
1617                         persister.ViewState = viewState;
1618                 persister.Save ();
1619         }
1620
1621         internal string RawViewState {
1622                 get {
1623                         NameValueCollection postdata = _requestValueCollection;
1624                         string view_state;
1625                         if (postdata == null || (view_state = postdata ["__VIEWSTATE"]) == null)
1626                                 return null;
1627
1628                         if (view_state == "")
1629                                 return null;
1630                         return view_state;
1631                 }
1632                 set { _savedViewState = value; }
1633         }
1634
1635 #if NET_2_0
1636         protected virtual
1637 #else
1638         internal
1639 #endif
1640         PageStatePersister PageStatePersister {
1641                 get {
1642                         if (page_state_persister == null)
1643                                 page_state_persister = new HiddenFieldPageStatePersister (this);
1644                         return page_state_persister;
1645                 }
1646         }
1647
1648         [EditorBrowsable (EditorBrowsableState.Advanced)]
1649         protected virtual object LoadPageStateFromPersistenceMedium ()
1650         {
1651                 PageStatePersister persister = this.PageStatePersister;
1652                 if (persister == null)
1653                         return null;
1654                 persister.Load ();
1655                 return new Pair (persister.ViewState, persister.ControlState);
1656         }
1657
1658         internal void LoadPageViewState()
1659         {
1660                 Pair sState = LoadPageStateFromPersistenceMedium () as Pair;
1661                 if (sState != null) {
1662                         if (allow_load) {
1663 #if NET_2_0
1664                                 LoadPageControlState (sState.Second);
1665 #endif
1666                                 Pair vsr = sState.First as Pair;
1667                                 if (vsr != null) {
1668                                         LoadViewStateRecursive (vsr.First);
1669                                         _requiresPostBackCopy = vsr.Second as ArrayList;
1670                                 }
1671                         }
1672                 }
1673         }
1674
1675         internal void SavePageViewState ()
1676         {
1677                 if (!handleViewState)
1678                         return;
1679
1680 #if NET_2_0
1681                 object controlState = SavePageControlState ();
1682 #endif
1683
1684                 object viewState = SaveViewStateRecursive ();
1685                 object reqPostback = (_requiresPostBack != null && _requiresPostBack.Count > 0) ? _requiresPostBack : null;
1686                 Pair vsr = null;
1687
1688                 if (viewState != null || reqPostback != null)
1689                         vsr = new Pair (viewState, reqPostback);
1690                 Pair pair = new Pair ();
1691
1692                 pair.First = vsr;
1693 #if NET_2_0
1694                 pair.Second = controlState;
1695 #else
1696                 pair.Second = null;
1697 #endif
1698                 if (pair.First == null && pair.Second == null)
1699                         SavePageStateToPersistenceMedium (null);
1700                 else
1701                         SavePageStateToPersistenceMedium (pair);
1702
1703         }
1704
1705         public virtual void Validate ()
1706         {
1707                 is_validated = true;
1708                 ValidateCollection (_validators);
1709         }
1710
1711 #if NET_2_0
1712         internal bool AreValidatorsUplevel () {
1713                 return AreValidatorsUplevel (String.Empty);
1714         }
1715
1716         internal bool AreValidatorsUplevel (string valGroup)
1717 #else
1718         internal virtual bool AreValidatorsUplevel ()
1719 #endif
1720         {
1721                 bool uplevel = false;
1722
1723                 foreach (IValidator v in Validators) {
1724                         BaseValidator bv = v as BaseValidator;
1725                         if (bv == null) continue;
1726
1727 #if NET_2_0
1728                         if (valGroup != bv.ValidationGroup)
1729                                 continue;
1730 #endif
1731                         if (bv.GetRenderUplevel()) {
1732                                 uplevel = true;
1733                                 break;
1734                         }
1735                 }
1736
1737                 return uplevel;
1738         }
1739
1740         bool ValidateCollection (ValidatorCollection validators)
1741         {
1742 #if NET_2_0
1743                 if (!_eventValidation)
1744                         return true;
1745 #endif
1746
1747                 if (validators == null || validators.Count == 0)
1748                         return true;
1749
1750                 bool all_valid = true;
1751                 foreach (IValidator v in validators){
1752                         v.Validate ();
1753                         if (v.IsValid == false)
1754                                 all_valid = false;
1755                 }
1756
1757                 return all_valid;
1758         }
1759
1760         [EditorBrowsable (EditorBrowsableState.Advanced)]
1761         public virtual void VerifyRenderingInServerForm (Control control)
1762         {
1763                 if (_context == null)
1764                         return;
1765 #if NET_2_0
1766                 if (IsCallback)
1767                         return;
1768 #endif
1769                 if (!renderingForm)
1770                         throw new HttpException ("Control '" +
1771                                                  control.ClientID +
1772                                                  "' of type '" +
1773                                                  control.GetType ().Name +
1774                                                  "' must be placed inside a form tag with runat=server.");
1775         }
1776
1777         protected override void FrameworkInitialize ()
1778         {
1779                 base.FrameworkInitialize ();
1780 #if NET_2_0
1781                 InitializeStyleSheet ();
1782 #endif
1783         }
1784
1785         #endregion
1786
1787         #if NET_2_0
1788         public
1789         #else
1790         internal
1791         #endif
1792                 ClientScriptManager ClientScript {
1793                 get { return scriptManager; }
1794         }
1795
1796         #if NET_2_0
1797
1798         static readonly object InitCompleteEvent = new object ();
1799         static readonly object LoadCompleteEvent = new object ();
1800         static readonly object PreInitEvent = new object ();
1801         static readonly object PreLoadEvent = new object ();
1802         static readonly object PreRenderCompleteEvent = new object ();
1803         static readonly object SaveStateCompleteEvent = new object ();
1804         int event_mask;
1805         const int initcomplete_mask = 1;
1806         const int loadcomplete_mask = 1 << 1;
1807         const int preinit_mask = 1 << 2;
1808         const int preload_mask = 1 << 3;
1809         const int prerendercomplete_mask = 1 << 4;
1810         const int savestatecomplete_mask = 1 << 5;
1811
1812         [EditorBrowsable (EditorBrowsableState.Advanced)]
1813         public event EventHandler InitComplete {
1814                 add {
1815                         event_mask |= initcomplete_mask;
1816                         Events.AddHandler (InitCompleteEvent, value);
1817                 }
1818                 remove { Events.RemoveHandler (InitCompleteEvent, value); }
1819         }
1820
1821         [EditorBrowsable (EditorBrowsableState.Advanced)]
1822         public event EventHandler LoadComplete {
1823                 add {
1824                         event_mask |= loadcomplete_mask;
1825                         Events.AddHandler (LoadCompleteEvent, value);
1826                 }
1827                 remove { Events.RemoveHandler (LoadCompleteEvent, value); }
1828         }
1829
1830         public event EventHandler PreInit {
1831                 add {
1832                         event_mask |= preinit_mask;
1833                         Events.AddHandler (PreInitEvent, value);
1834                 }
1835                 remove { Events.RemoveHandler (PreInitEvent, value); }
1836         }
1837
1838         [EditorBrowsable (EditorBrowsableState.Advanced)]
1839         public event EventHandler PreLoad {
1840                 add {
1841                         event_mask |= preload_mask;
1842                         Events.AddHandler (PreLoadEvent, value);
1843                 }
1844                 remove { Events.RemoveHandler (PreLoadEvent, value); }
1845         }
1846
1847         [EditorBrowsable (EditorBrowsableState.Advanced)]
1848         public event EventHandler PreRenderComplete {
1849                 add {
1850                         event_mask |= prerendercomplete_mask;
1851                         Events.AddHandler (PreRenderCompleteEvent, value);
1852                 }
1853                 remove { Events.RemoveHandler (PreRenderCompleteEvent, value); }
1854         }
1855
1856         [EditorBrowsable (EditorBrowsableState.Advanced)]
1857         public event EventHandler SaveStateComplete {
1858                 add {
1859                         event_mask |= savestatecomplete_mask;
1860                         Events.AddHandler (SaveStateCompleteEvent, value);
1861                 }
1862                 remove { Events.RemoveHandler (SaveStateCompleteEvent, value); }
1863         }
1864
1865         protected virtual void OnInitComplete (EventArgs e)
1866         {
1867                 if ((event_mask & initcomplete_mask) != 0) {
1868                         EventHandler eh = (EventHandler) (Events [InitCompleteEvent]);
1869                         if (eh != null) eh (this, e);
1870                 }
1871         }
1872
1873         protected virtual void OnLoadComplete (EventArgs e)
1874         {
1875                 if ((event_mask & loadcomplete_mask) != 0) {
1876                         EventHandler eh = (EventHandler) (Events [LoadCompleteEvent]);
1877                         if (eh != null) eh (this, e);
1878                 }
1879         }
1880
1881         protected virtual void OnPreInit (EventArgs e)
1882         {
1883                 if ((event_mask & preinit_mask) != 0) {
1884                         EventHandler eh = (EventHandler) (Events [PreInitEvent]);
1885                         if (eh != null) eh (this, e);
1886                 }
1887         }
1888
1889         protected virtual void OnPreLoad (EventArgs e)
1890         {
1891                 if ((event_mask & preload_mask) != 0) {
1892                         EventHandler eh = (EventHandler) (Events [PreLoadEvent]);
1893                         if (eh != null) eh (this, e);
1894                 }
1895         }
1896
1897         protected virtual void OnPreRenderComplete (EventArgs e)
1898         {
1899                 if ((event_mask & prerendercomplete_mask) != 0) {
1900                         EventHandler eh = (EventHandler) (Events [PreRenderCompleteEvent]);
1901                         if (eh != null) eh (this, e);
1902                 }
1903
1904                 if (Form == null)
1905                         return;
1906                 if (!Form.DetermineRenderUplevel ())
1907                         return;
1908
1909                 /* figure out if we have some control we're going to focus */
1910                 if (String.IsNullOrEmpty (_focusedControlID)) {
1911                         _focusedControlID = Form.DefaultFocus;
1912                         if (String.IsNullOrEmpty (_focusedControlID))
1913                                 _focusedControlID = Form.DefaultButton;
1914                 }
1915
1916                         if (!String.IsNullOrEmpty (_focusedControlID)) {
1917                                 ClientScript.RegisterWebFormClientScript ();
1918                                 ClientScript.RegisterStartupScript ("HtmlForm-DefaultButton-StartupScript",
1919                                                                          String.Format ("<script type=\"text/javascript\">\n" +
1920                                                                                         "<!--\n" +
1921                                                                                         "WebForm_AutoFocus('{0}');// -->\n" +
1922                                                                                         "</script>\n", _focusedControlID));
1923                         }
1924
1925                         if (Form.SubmitDisabledControls && _hasEnabledControlArray) {
1926                                 ClientScript.RegisterWebFormClientScript ();
1927                                 ClientScript.RegisterOnSubmitStatement ("HtmlForm-SubmitDisabledControls-SubmitStatement",
1928                                                                                  "WebForm_ReEnableControls(this);");
1929                         }
1930         }
1931
1932         internal void RegisterEnabledControl (Control control)
1933         {
1934                 if (Form == null || !Page.Form.SubmitDisabledControls || !Page.Form.DetermineRenderUplevel ())
1935                         return;
1936                 _hasEnabledControlArray = true;
1937                 Page.ClientScript.RegisterArrayDeclaration (EnabledControlArrayID, String.Format ("'{0}'", control.ClientID));
1938         }
1939
1940         protected virtual void OnSaveStateComplete (EventArgs e)
1941         {
1942                 if ((event_mask & savestatecomplete_mask) != 0) {
1943                         EventHandler eh = (EventHandler) (Events [SaveStateCompleteEvent]);
1944                         if (eh != null) eh (this, e);
1945                 }
1946         }
1947
1948         public HtmlForm Form {
1949                 get { return _form; }
1950         }
1951
1952         internal void RegisterForm (HtmlForm form)
1953         {
1954                 _form = form;
1955         }
1956
1957         [BrowsableAttribute (false)]
1958         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
1959         public Page PreviousPage {
1960                 get {
1961                         if (_doLoadPreviousPage) {
1962                                 _doLoadPreviousPage = false;
1963                                 LoadPreviousPageReference ();
1964                         }
1965                         return previousPage;
1966                 }
1967         }
1968
1969
1970         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
1971         [BrowsableAttribute (false)]
1972         public bool IsCallback {
1973                 get { return isCallback; }
1974         }
1975
1976         [BrowsableAttribute (false)]
1977         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
1978         public bool IsCrossPagePostBack {
1979                 get { return isCrossPagePostBack; }
1980         }
1981
1982         public new virtual char IdSeparator {
1983                 get {
1984                         //TODO: why override?
1985                         return base.IdSeparator;
1986                 }
1987         }
1988
1989         string ProcessCallbackData ()
1990         {
1991                 string callbackTarget = _requestValueCollection [CallbackSourceID];
1992                 if (callbackTarget == null || callbackTarget.Length == 0)
1993                         throw new HttpException ("Callback target not provided.");
1994
1995                 Control targetControl = FindControl (callbackTarget);
1996                 ICallbackEventHandler target = targetControl as ICallbackEventHandler;
1997                 if (target == null)
1998                         throw new HttpException (string.Format ("Invalid callback target '{0}'.", callbackTarget));
1999
2000                 string callbackEventError = String.Empty;
2001                 string callBackResult;
2002                 string callbackArgument = _requestValueCollection [CallbackArgumentID];
2003
2004                 try {
2005                         target.RaiseCallbackEvent (callbackArgument);
2006                 }
2007                 catch (Exception ex) {
2008                         callbackEventError = String.Format ("e{0}", ex.Message);
2009                 }
2010
2011                 try {
2012                         callBackResult = target.GetCallbackResult ();
2013                 }
2014                 catch (Exception ex) {
2015                         return String.Format ("e{0}", ex.Message);
2016                 }
2017
2018                 string eventValidation = ClientScript.GetEventValidationStateFormatted ();
2019                 return String.Format ("{0}{1}|{2}{3}", callbackEventError, eventValidation == null ? 0 : eventValidation.Length, eventValidation, callBackResult);
2020         }
2021
2022         [BrowsableAttribute (false)]
2023         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
2024         public HtmlHead Header {
2025                 get { return htmlHeader; }
2026         }
2027
2028         internal void SetHeader (HtmlHead header)
2029         {
2030                 htmlHeader = header;
2031                 if (_title != null) {
2032                         htmlHeader.Title = _title;
2033                         _title = null;
2034                 }
2035         }
2036
2037         protected bool AsyncMode {
2038                 get { return asyncMode; }
2039                 set { asyncMode = value; }
2040         }
2041
2042         public TimeSpan AsyncTimeout {
2043                 get { return asyncTimeout; }
2044                 set { asyncTimeout = value; }
2045         }
2046
2047         public bool IsAsync {
2048                 get { return AsyncMode; }
2049         }
2050
2051         [MonoTODO ("Not Implemented")]
2052         protected internal virtual string UniqueFilePathSuffix {
2053                 get {
2054                         throw new NotImplementedException ();
2055                 }
2056         }
2057
2058         [MonoTODO ("Not Implemented")]
2059         public int MaxPageStateFieldLength {
2060                 get {
2061                         throw new NotImplementedException ();
2062                 }
2063                 set {
2064                         throw new NotImplementedException ();
2065                 }
2066         }
2067
2068         public void AddOnPreRenderCompleteAsync (BeginEventHandler beginHandler, EndEventHandler endHandler)
2069         {
2070                 AddOnPreRenderCompleteAsync (beginHandler, endHandler, null);
2071         }
2072
2073         public void AddOnPreRenderCompleteAsync (BeginEventHandler beginHandler, EndEventHandler endHandler, Object state)
2074         {
2075                 if (!IsAsync) {
2076                         throw new InvalidOperationException ("AddOnPreRenderCompleteAsync called and Page.IsAsync == false");
2077                 }
2078
2079                 if (_lifeCycle >= PageLifeCycle.PreRender) {
2080                         throw new InvalidOperationException ("AddOnPreRenderCompleteAsync can only be called before PreRender.");
2081                 }
2082
2083                 if (beginHandler == null) {
2084                         throw new ArgumentNullException ("beginHandler");
2085                 }
2086
2087                 if (endHandler == null) {
2088                         throw new ArgumentNullException ("endHandler");
2089                 }
2090
2091                 RegisterAsyncTask (new PageAsyncTask (beginHandler, endHandler, null, state, false));
2092         }
2093
2094         private List<PageAsyncTask> ParallelTasks {
2095                 get
2096                 {
2097                         if (parallelTasks == null) {
2098                                 parallelTasks = new List<PageAsyncTask>();
2099                         }
2100                         return parallelTasks;
2101                 }
2102         }
2103
2104         private List<PageAsyncTask> SerialTasks {
2105                 get {
2106                         if (serialTasks == null) {
2107                                 serialTasks = new List<PageAsyncTask> ();
2108                         }
2109                         return serialTasks;
2110                 }
2111         }
2112
2113         public void RegisterAsyncTask (PageAsyncTask task)
2114         {
2115                 if (task == null) {
2116                         throw new ArgumentNullException ("task");
2117                 }
2118
2119                 if (task.ExecuteInParallel) {
2120                         ParallelTasks.Add (task);
2121                 }
2122                 else {
2123                         SerialTasks.Add (task);
2124                 }
2125         }
2126
2127         public void ExecuteRegisteredAsyncTasks ()
2128         {
2129                 if ((parallelTasks == null || parallelTasks.Count == 0) &&
2130                         (serialTasks == null || serialTasks.Count == 0)){
2131                         return;
2132                 }
2133
2134                 if (parallelTasks != null) {
2135                         DateTime startExecution = DateTime.Now;
2136                         List<PageAsyncTask> localParallelTasks = parallelTasks;
2137                         parallelTasks = null; // Shouldn't execute tasks twice
2138                         List<IAsyncResult> asyncResults = new List<IAsyncResult>();
2139                         foreach (PageAsyncTask parallelTask in localParallelTasks) {
2140                                 IAsyncResult result = parallelTask.BeginHandler (this, EventArgs.Empty, new AsyncCallback (EndAsyncTaskCallback), parallelTask.State);
2141                                 if (result.CompletedSynchronously) {
2142                                         parallelTask.EndHandler (result);
2143                                 }
2144                                 else {
2145                                         asyncResults.Add (result);
2146                                 }
2147                         }
2148
2149                         if (asyncResults.Count > 0) {
2150 #if TARGET_JVM
2151                                 TimeSpan timeout = AsyncTimeout;
2152                                 long t1 = DateTime.Now.Ticks;
2153                                 bool signalled = true;
2154                                 for (int i = 0; i < asyncResults.Count; i++) {
2155                                         if (asyncResults [i].IsCompleted)
2156                                                 continue;
2157
2158                                         if (signalled)
2159                                                 signalled = asyncResults [i].AsyncWaitHandle.WaitOne (timeout, false);
2160
2161                                         if (signalled) {
2162                                                 long t2 = DateTime.Now.Ticks;
2163                                                 timeout = AsyncTimeout - TimeSpan.FromTicks (t2 - t1);
2164                                                 if (timeout.Ticks <= 0)
2165                                                         signalled = false;
2166                                         }
2167                                         else {
2168                                                 localParallelTasks [i].TimeoutHandler (asyncResults [i]);
2169                                         }
2170                                 }
2171 #else
2172                                 WaitHandle [] waitArray = new WaitHandle [asyncResults.Count];
2173                                 int i = 0;
2174                                 for (i = 0; i < asyncResults.Count; i++) {
2175                                         waitArray [i] = asyncResults [i].AsyncWaitHandle;
2176                                 }
2177                                 bool allSignalled = WaitHandle.WaitAll (waitArray, AsyncTimeout, false);
2178                                 if (!allSignalled) {
2179                                         for (i = 0; i < asyncResults.Count; i++) {
2180                                                 if (!asyncResults [i].IsCompleted) {
2181                                                         localParallelTasks [i].TimeoutHandler (asyncResults [i]);
2182                                                 }
2183                                         }
2184                                 }
2185 #endif
2186                         }
2187                         DateTime endWait = DateTime.Now;
2188                         TimeSpan elapsed = endWait - startExecution;
2189                         if (elapsed <= AsyncTimeout) {
2190                                 AsyncTimeout -= elapsed;
2191                         }
2192                         else {
2193                                 AsyncTimeout = TimeSpan.FromTicks(0);
2194                         }
2195                 }
2196
2197                 if (serialTasks != null) {
2198                         List<PageAsyncTask> localSerialTasks = serialTasks;
2199                         serialTasks = null; // Shouldn't execute tasks twice
2200                         foreach (PageAsyncTask serialTask in localSerialTasks) {
2201                                 DateTime startExecution = DateTime.Now;
2202
2203                                 IAsyncResult result = serialTask.BeginHandler (this, EventArgs.Empty, new AsyncCallback (EndAsyncTaskCallback), serialTask);
2204                                 if (result.CompletedSynchronously) {
2205                                         serialTask.EndHandler (result);
2206                                 }
2207                                 else {
2208                                         bool done = result.AsyncWaitHandle.WaitOne (AsyncTimeout, false);
2209                                         if (!done && !result.IsCompleted) {
2210                                                 serialTask.TimeoutHandler (result);
2211                                         }
2212                                 }
2213                                 DateTime endWait = DateTime.Now;
2214                                 TimeSpan elapsed = endWait - startExecution;
2215                                 if (elapsed <= AsyncTimeout) {
2216                                         AsyncTimeout -= elapsed;
2217                                 }
2218                                 else {
2219                                         AsyncTimeout = TimeSpan.FromTicks (0);
2220                                 }
2221                         }
2222                 }
2223                 AsyncTimeout = TimeSpan.FromSeconds (DefaultAsyncTimeout);
2224         }
2225
2226         void EndAsyncTaskCallback (IAsyncResult result)
2227         {
2228                 PageAsyncTask task = (PageAsyncTask)result.AsyncState;
2229                 task.EndHandler (result);
2230         }
2231
2232         public static HtmlTextWriter CreateHtmlTextWriterFromType (TextWriter tw, Type writerType)
2233         {
2234                 Type htmlTextWriterType = typeof (HtmlTextWriter);
2235
2236                 if (!htmlTextWriterType.IsAssignableFrom (writerType)) {
2237                         throw new HttpException (String.Format ("Type '{0}' cannot be assigned to HtmlTextWriter", writerType.FullName));
2238                 }
2239
2240                 ConstructorInfo constructor = writerType.GetConstructor (new Type [] { typeof (TextWriter) });
2241                 if (constructor == null) {
2242                         throw new HttpException (String.Format ("Type '{0}' does not have a consturctor that takes a TextWriter as parameter", writerType.FullName));
2243                 }
2244
2245                 return (HtmlTextWriter) Activator.CreateInstance(writerType, tw);
2246         }
2247
2248         public ViewStateEncryptionMode ViewStateEncryptionMode {
2249                 get { return viewStateEncryptionMode; }
2250                 set { viewStateEncryptionMode = value; }
2251         }
2252
2253         public void RegisterRequiresViewStateEncryption ()
2254         {
2255                 controlRegisteredForViewStateEncryption = true;
2256         }
2257
2258         private static byte [] AES_IV = null;
2259         private static byte [] TripleDES_IV = null;
2260         private static object locker = new object ();
2261         private static bool isEncryptionInitialized = false;
2262
2263         private static void InitializeEncryption ()
2264         {
2265                 if (isEncryptionInitialized) {
2266                         return;
2267                 }
2268
2269                 lock (locker) {
2270                         if (isEncryptionInitialized) {
2271                                 return;
2272                         }
2273
2274                         string iv_string = "0BA48A9E-736D-40f8-954B-B2F62241F282";
2275                         AES_IV = new byte [16];
2276                         TripleDES_IV = new byte [8];
2277
2278                         int i;
2279                         for (i = 0; i < AES_IV.Length; i++) {
2280                                 AES_IV [i] = (byte) iv_string [i];
2281                         }
2282
2283                         for (i = 0; i < TripleDES_IV.Length; i++) {
2284                                 TripleDES_IV [i] = (byte) iv_string [i];
2285                         }
2286
2287                         isEncryptionInitialized = true;
2288                 }
2289         }
2290
2291         internal ICryptoTransform GetCryptoTransform (CryptoStreamMode cryptoStreamMode)
2292         {
2293                 ICryptoTransform transform = null;
2294                 MachineKeySection config = (MachineKeySection) WebConfigurationManager.GetSection (machineKeyConfigPath);
2295                 byte [] vk = config.ValidationKeyBytes;
2296
2297                 switch (config.Validation) {
2298                 case MachineKeyValidation.SHA1:
2299                         transform = SHA1.Create ();
2300                         break;
2301
2302                 case MachineKeyValidation.MD5:
2303                         transform = MD5.Create ();
2304                         break;
2305
2306                 case MachineKeyValidation.AES:
2307                         if (cryptoStreamMode == CryptoStreamMode.Read){
2308                                 transform = Rijndael.Create().CreateDecryptor(vk, AES_IV);
2309                         } else {
2310                                 transform = Rijndael.Create().CreateEncryptor(vk, AES_IV);
2311                         }
2312                         break;
2313
2314                 case MachineKeyValidation.TripleDES:
2315                         if (cryptoStreamMode == CryptoStreamMode.Read){
2316                                 transform = TripleDES.Create().CreateDecryptor(vk, TripleDES_IV);
2317                         } else {
2318                                 transform = TripleDES.Create().CreateEncryptor(vk, TripleDES_IV);
2319                         }
2320                         break;
2321                 }
2322
2323                 return transform;
2324         }
2325
2326         internal bool NeedViewStateEncryption {
2327                 get {
2328                         return (ViewStateEncryptionMode == ViewStateEncryptionMode.Always ||
2329                                         (ViewStateEncryptionMode == ViewStateEncryptionMode.Auto &&
2330                                          controlRegisteredForViewStateEncryption));
2331
2332                 }
2333         }
2334
2335         void ApplyMasterPage ()
2336         {
2337                 if (masterPageFile != null && masterPageFile.Length > 0) {
2338                         ArrayList appliedMasterPageFiles = new ArrayList ();
2339
2340                         if (Master != null) {
2341                                 MasterPage.ApplyMasterPageRecursive (Master, appliedMasterPageFiles);
2342
2343                                 Master.Page = this;
2344                                 Controls.Clear ();
2345                                 Controls.Add (Master);
2346                         }
2347                 }
2348         }
2349
2350         [DefaultValueAttribute ("")]
2351         public virtual string MasterPageFile {
2352                 get { return masterPageFile; }
2353                 set {
2354                         masterPageFile = value;
2355                         masterPage = null;
2356                 }
2357         }
2358
2359         [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
2360         [BrowsableAttribute (false)]
2361         public MasterPage Master {
2362                 get {
2363                         if (Context == null || String.IsNullOrEmpty (masterPageFile))
2364                                 return null;
2365
2366                         if (masterPage == null)
2367                                 masterPage = MasterPage.CreateMasterPage (this, Context, masterPageFile, contentTemplates);
2368
2369                         return masterPage;
2370                 }
2371         }
2372
2373         public void SetFocus (string clientID)
2374         {
2375                 if (String.IsNullOrEmpty (clientID))
2376                         throw new ArgumentNullException ("control");
2377
2378                 if (_lifeCycle > PageLifeCycle.PreRender)
2379                         throw new InvalidOperationException ("SetFocus can only be called before and during PreRender.");
2380
2381                 if(Form==null)
2382                         throw new InvalidOperationException ("A form tag with runat=server must exist on the Page to use SetFocus() or the Focus property.");
2383
2384                 _focusedControlID = clientID;
2385         }
2386
2387         public void SetFocus (Control control)
2388         {
2389                 if (control == null)
2390                         throw new ArgumentNullException ("control");
2391
2392                 SetFocus (control.ClientID);
2393         }
2394
2395         [EditorBrowsable (EditorBrowsableState.Advanced)]
2396         public void RegisterRequiresControlState (Control control)
2397         {
2398                 if (control == null)
2399                         throw new ArgumentNullException ("control");
2400
2401                 if (RequiresControlState (control))
2402                         return;
2403
2404                 if (requireStateControls == null)
2405                         requireStateControls = new ArrayList ();
2406                 int n = requireStateControls.Add (control);
2407
2408                 if (_savedControlState == null || n >= _savedControlState.Length)
2409                         return;
2410
2411                 for (Control parent = control.Parent; parent != null; parent = parent.Parent)
2412                         if (parent.IsChildControlStateCleared)
2413                                 return;
2414
2415                 object state = _savedControlState [n];
2416                 if (state != null)
2417                         control.LoadControlState (state);
2418         }
2419
2420         public bool RequiresControlState (Control control)
2421         {
2422                 if (requireStateControls == null) return false;
2423                 return requireStateControls.Contains (control);
2424         }
2425
2426         [EditorBrowsable (EditorBrowsableState.Advanced)]
2427         public void UnregisterRequiresControlState (Control control)
2428         {
2429                 if (requireStateControls != null)
2430                         requireStateControls.Remove (control);
2431         }
2432
2433         public ValidatorCollection GetValidators (string validationGroup)
2434         {
2435                 string valgr = validationGroup;
2436                 if (valgr == null)
2437                         valgr = String.Empty;
2438
2439                 if (_validatorsByGroup == null) _validatorsByGroup = new Hashtable ();
2440                 ValidatorCollection col = _validatorsByGroup [valgr] as ValidatorCollection;
2441                 if (col == null) {
2442                         col = new ValidatorCollection ();
2443                         _validatorsByGroup [valgr] = col;
2444                 }
2445                 return col;
2446         }
2447
2448         public virtual void Validate (string validationGroup)
2449         {
2450                 is_validated = true;
2451                 if (validationGroup == null)
2452                         ValidateCollection (_validatorsByGroup [String.Empty] as ValidatorCollection);
2453                 else if (_validatorsByGroup != null) {
2454                         ValidateCollection (_validatorsByGroup [validationGroup] as ValidatorCollection);
2455                 }
2456         }
2457
2458         object SavePageControlState ()
2459         {
2460                 if (requireStateControls == null) return null;
2461                 object[] state = new object [requireStateControls.Count];
2462
2463                 bool allNull = true;
2464                 for (int n=0; n<state.Length; n++) {
2465                         state [n] = ((Control) requireStateControls [n]).SaveControlState ();
2466                         if (state [n] != null) allNull = false;
2467                 }
2468                 if (allNull) return null;
2469                 else return state;
2470         }
2471
2472         void LoadPageControlState (object data)
2473         {
2474                 _savedControlState = (object []) data;
2475
2476                 if (requireStateControls == null) return;
2477
2478                 int max = Math.Min (requireStateControls.Count, _savedControlState != null ? _savedControlState.Length : requireStateControls.Count);
2479                 for (int n=0; n < max; n++) {
2480                         Control ctl = (Control) requireStateControls [n];
2481                         ctl.LoadControlState (_savedControlState != null ? _savedControlState [n] : null);
2482                 }
2483         }
2484
2485         void LoadPreviousPageReference ()
2486         {
2487                 if (_requestValueCollection != null) {
2488                         string prevPage = _requestValueCollection [PreviousPageID];
2489                         if (prevPage != null) {
2490                                 previousPage = (Page) PageParser.GetCompiledPageInstance (prevPage, Server.MapPath (prevPage), Context);
2491                                 previousPage.ProcessCrossPagePostBack (_context);
2492                         }
2493                 }
2494         }
2495
2496
2497         Hashtable contentTemplates;
2498         [EditorBrowsable (EditorBrowsableState.Never)]
2499         protected internal void AddContentTemplate (string templateName, ITemplate template)
2500         {
2501                 if (contentTemplates == null)
2502                         contentTemplates = new Hashtable ();
2503                 contentTemplates [templateName] = template;
2504         }
2505
2506         PageTheme _pageTheme;
2507         internal PageTheme PageTheme {
2508                 get { return _pageTheme; }
2509         }
2510
2511         PageTheme _styleSheetPageTheme;
2512         internal PageTheme StyleSheetPageTheme {
2513                 get { return _styleSheetPageTheme; }
2514         }
2515
2516         Stack dataItemCtx;
2517
2518         internal void PushDataItemContext (object o) {
2519                 if (dataItemCtx == null)
2520                         dataItemCtx = new Stack ();
2521
2522                 dataItemCtx.Push (o);
2523         }
2524
2525         internal void PopDataItemContext () {
2526                 if (dataItemCtx == null)
2527                         throw new InvalidOperationException ();
2528
2529                 dataItemCtx.Pop ();
2530         }
2531
2532         public object GetDataItem() {
2533                 if (dataItemCtx == null || dataItemCtx.Count == 0)
2534                         throw new InvalidOperationException ("No data item");
2535
2536                 return dataItemCtx.Peek ();
2537         }
2538
2539         protected internal override void OnInit (EventArgs e)
2540         {
2541                 base.OnInit (e);
2542
2543                 ArrayList themes = new ArrayList();
2544
2545                 if (StyleSheetPageTheme != null && StyleSheetPageTheme.GetStyleSheets () != null)
2546                         themes.AddRange (StyleSheetPageTheme.GetStyleSheets ());
2547                 if (PageTheme != null && PageTheme.GetStyleSheets () != null)
2548                         themes.AddRange (PageTheme.GetStyleSheets ());
2549
2550                 if (themes.Count > 0 && Header == null)
2551                         throw new InvalidOperationException ("Using themed css files requires a header control on the page.");
2552
2553                 foreach (string lss in themes) {
2554                         HtmlLink hl = new HtmlLink ();
2555                         hl.Href = ResolveUrl (lss);
2556                         hl.Attributes["type"] = "text/css";
2557                         hl.Attributes["rel"] = "stylesheet";
2558                         Header.Controls.Add (hl);
2559                 }
2560         }
2561
2562         #endif
2563
2564 #if NET_2_0
2565         [MonoTODO ("Not implemented.  Only used by .net aspx parser")]
2566         protected object GetWrappedFileDependencies (string [] list)
2567         {
2568                 return list;
2569         }
2570
2571         [MonoTODO ("Does nothing.  Used by .net aspx parser")]
2572         protected virtual void InitializeCulture ()
2573         {
2574         }
2575
2576         [MonoTODO ("Does nothing. Used by .net aspx parser")]
2577         protected internal void AddWrappedFileDependencies (object virtualFileDependencies)
2578         {
2579         }
2580 #endif
2581 }
2582 }