mcs/class/System.Web/System.Web.Configuration_2.0/HttpCapabilitiesBase.cs

   1 //
   2 // System.Web.Configuration.HttpCapabilitiesBase
   3 //
   4 // Authors:
   5 //      Chris Toshok (toshok@ximian.com)
   6 //
   7 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29 using System.Collections;
  30 using System.Security.Permissions;
  31 using System.IO;
  32 using System.Web.UI;
  33
  34 namespace System.Web.Configuration
  35 {
  36         public partial class HttpCapabilitiesBase: IFilterResolutionService
  37         {
  38                 internal IDictionary capabilities;
  39
  40                 public HttpCapabilitiesBase () { }
  41
  42                 public virtual string this [string key]
  43                 {
  44                         get { return capabilities [key] as string; }
  45                 }
  46
  47                 internal static string GetUserAgentForDetection (HttpRequest request)
  48                 {
  49                         string ua = null;
  50                         if (request.Context.CurrentHandler is System.Web.UI.Page)
  51                                 ua = ((System.Web.UI.Page) request.Context.CurrentHandler).ClientTarget;
  52
  53                         if (String.IsNullOrEmpty (ua)) {
  54                                 ua = request.ClientTarget;
  55
  56                                 if (String.IsNullOrEmpty (ua))
  57                                         ua = request.UserAgent;
  58                         }
  59
  60                         return ua;
  61                 }
  62
  63                 static HttpBrowserCapabilities GetHttpBrowserCapabilitiesFromBrowscapini(string ua)
  64                 {
  65                         HttpBrowserCapabilities bcap = new HttpBrowserCapabilities();
  66                         bcap.capabilities = CapabilitiesLoader.GetCapabilities (ua);
  67                         return bcap;
  68                 }
  69
  70                 public static HttpCapabilitiesBase GetConfigCapabilities (string configKey, HttpRequest request)
  71                 {
  72                         string ua = GetUserAgentForDetection (request);
  73                         HttpBrowserCapabilities bcap = GetHttpBrowserCapabilitiesFromBrowscapini(ua);
  74                         GetConfigCapabilities_called = true;
  75                         if (HttpApplicationFactory.AppBrowsersFiles.Length > 0)
  76                                 bcap = HttpApplicationFactory.CapabilitiesProcessor.Process(request, bcap.Capabilities);
  77                         bcap.useragent = ua;
  78                         bcap.Init ();
  79                         return bcap;
  80                 }
  81
  82                 // Used by unit tests to determine whether GetConfigCapabilities was called.
  83                 static internal bool GetConfigCapabilities_called;
  84
  85                 protected virtual void Init ()
  86                 {
  87                 }
  88
  89                 int IFilterResolutionService.CompareFilters (string filter1, string filter2)
  90                 {
  91                         throw new NotImplementedException ();
  92                 }
  93
  94                 bool IFilterResolutionService.EvaluateFilter (string filterName)
  95                 {
  96                         throw new NotImplementedException ();
  97                 }
  98
  99                 public void AddBrowser (string browserName)
 100                 {
 101                 }
 102
 103                 public HtmlTextWriter CreateHtmlTextWriter (TextWriter w)
 104                 {
 105                         return (HtmlTextWriter) Activator.CreateInstance (TagWriter, new object[] {w});
 106                 }
 107
 108                 public void DisableOptimizedCacheKey ()
 109                 {
 110                         throw new NotImplementedException ();
 111                 }
 112
 113                 IDictionary adapters = null;
 114                 public IDictionary Adapters {
 115                         get {
 116                                 if (!Get (HaveAdapters)) {
 117                                         adapters = GetAdapters();
 118                                         Set (HaveAdapters);
 119                                 }
 120
 121                                 return adapters;
 122                         }
 123                 }
 124
 125                 internal virtual IDictionary GetAdapters ()
 126                 {
 127                         return new Hashtable();
 128                 }
 129
 130                 bool canCombineFormsInDeck;
 131                 public virtual bool CanCombineFormsInDeck {
 132                         get {
 133                                 if (!Get (HaveCanCombineFormsInDeck)) {
 134                                         canCombineFormsInDeck = ReadBoolean ("cancombineformsindeck");
 135                                         Set (HaveCanCombineFormsInDeck);
 136                                 }
 137
 138                                 return canCombineFormsInDeck;
 139                         }
 140                 }
 141
 142                 bool canInitiateVoiceCall;
 143                 public virtual bool CanInitiateVoiceCall {
 144                         get {
 145                                 if (!Get (HaveCanInitiateVoiceCall)) {
 146                                         canInitiateVoiceCall = ReadBoolean ("caninitiatevoicecall");
 147                                         Set (HaveCanInitiateVoiceCall);
 148                                 }
 149
 150                                 return canInitiateVoiceCall;
 151                         }
 152                 }
 153
 154                 bool canRenderAfterInputOrSelectElement;
 155                 public virtual bool CanRenderAfterInputOrSelectElement {
 156                         get {
 157                                 if (!Get (HaveCanRenderAfterInputOrSelectElement)) {
 158                                         canRenderAfterInputOrSelectElement = ReadBoolean ("canrenderafterinputorselectelement");
 159                                         Set (HaveCanRenderAfterInputOrSelectElement);
 160                                 }
 161
 162                                 return canRenderAfterInputOrSelectElement;
 163                         }
 164                 }
 165
 166                 bool canRenderEmptySelects;
 167                 public virtual bool CanRenderEmptySelects {
 168                         get {
 169                                 if (!Get (HaveCanRenderEmptySelects)) {
 170                                         canRenderEmptySelects = ReadBoolean ("canrenderemptyselects");
 171                                         Set (HaveCanRenderEmptySelects);
 172                                 }
 173
 174                                 return canRenderEmptySelects;
 175                         }
 176                 }
 177
 178                 bool canRenderInputAndSelectElementsTogether;
 179                 public virtual bool CanRenderInputAndSelectElementsTogether {
 180                         get {
 181                                 if (!Get (HaveCanRenderInputAndSelectElementsTogether)) {
 182                                         canRenderInputAndSelectElementsTogether = ReadBoolean ("canrenderinputandselectelementstogether");
 183                                         Set (HaveCanRenderInputAndSelectElementsTogether);
 184                                 }
 185
 186                                 return canRenderInputAndSelectElementsTogether;
 187                         }
 188                 }
 189
 190                 bool canRenderMixedSelects;
 191                 public virtual bool CanRenderMixedSelects {
 192                         get {
 193                                 if (!Get (HaveCanRenderMixedSelects)) {
 194                                         canRenderMixedSelects = ReadBoolean ("canrendermixedselects");
 195                                         Set (HaveCanRenderMixedSelects);
 196                                 }
 197
 198                                 return canRenderMixedSelects;
 199                         }
 200                 }
 201
 202                 bool canRenderOneventAndPrevElementsTogether;
 203                 public virtual bool CanRenderOneventAndPrevElementsTogether {
 204                         get {
 205                                 if (!Get (HaveCanRenderOneventAndPrevElementsTogether)) {
 206                                         canRenderOneventAndPrevElementsTogether = ReadBoolean ("canrenderoneventandprevelementstogether");
 207                                         Set (HaveCanRenderOneventAndPrevElementsTogether);
 208                                 }
 209
 210                                 return canRenderOneventAndPrevElementsTogether;
 211                         }
 212                 }
 213
 214                 bool canRenderPostBackCards;
 215                 public virtual bool CanRenderPostBackCards {
 216                         get {
 217                                 if (!Get (HaveCanRenderPostBackCards)) {
 218                                         canRenderPostBackCards = ReadBoolean ("canrenderpostbackcards");
 219                                         Set (HaveCanRenderPostBackCards);
 220                                 }
 221
 222                                 return canRenderPostBackCards;
 223                         }
 224                 }
 225
 226                 bool canRenderSetvarZeroWithMultiSelectionList;
 227                 public virtual bool CanRenderSetvarZeroWithMultiSelectionList {
 228                         get {
 229                                 if (!Get (HaveCanRenderSetvarZeroWithMultiSelectionList)) {
 230                                         canRenderSetvarZeroWithMultiSelectionList = ReadBoolean ("canrendersetvarzerowithmultiselectionlist");
 231                                         Set (HaveCanRenderSetvarZeroWithMultiSelectionList);
 232                                 }
 233
 234                                 return canRenderSetvarZeroWithMultiSelectionList;
 235                         }
 236                 }
 237
 238                 bool canSendMail;
 239                 public virtual bool CanSendMail {
 240                         get {
 241                                 if (!Get (HaveCanSendMail)) {
 242                                         canSendMail = ReadBoolean ("cansendmail");
 243                                         Set (HaveCanSendMail);
 244                                 }
 245
 246                                 return canSendMail;
 247                         }
 248                 }
 249
 250                 public IDictionary Capabilities {
 251                         get { return capabilities; }
 252                         set { capabilities = value; }
 253                 }
 254
 255                 int defaultSubmitButtonLimit;
 256                 public virtual int DefaultSubmitButtonLimit {
 257                         get {
 258                                 if (!Get (HaveDefaultSubmitButtonLimit)) {
 259                                         defaultSubmitButtonLimit = ReadInt32 ("defaultsubmitbuttonlimit");
 260                                         Set (HaveDefaultSubmitButtonLimit);
 261                                 }
 262
 263                                 return defaultSubmitButtonLimit;
 264                         }
 265                 }
 266
 267                 int gatewayMajorVersion;
 268                 public virtual int GatewayMajorVersion {
 269                         get {
 270                                 if (!Get (HaveGatewayMajorVersion)) {
 271                                         gatewayMajorVersion = ReadInt32 ("gatewaymajorversion");
 272                                         Set (HaveGatewayMajorVersion);
 273                                 }
 274
 275                                 return gatewayMajorVersion;
 276                         }
 277                 }
 278
 279                 Double gatewayMinorVersion;
 280                 public virtual Double GatewayMinorVersion {
 281                         get {
 282                                 if (!Get (HaveGatewayMinorVersion)) {
 283                                         gatewayMinorVersion = ReadDouble ("gatewayminorversion");
 284                                         Set (HaveGatewayMinorVersion);
 285                                 }
 286
 287                                 return gatewayMinorVersion;
 288                         }
 289                 }
 290
 291                 string gatewayVersion;
 292                 public virtual string GatewayVersion {
 293                         get {
 294                                 if (!Get (HaveGatewayVersion)) {
 295                                         gatewayVersion = ReadString ("gatewayversion");
 296                                         Set (HaveGatewayVersion);
 297                                 }
 298
 299                                 return gatewayVersion;
 300                         }
 301                 }
 302
 303                 bool hasBackButton;
 304                 public virtual bool HasBackButton {
 305                         get {
 306                                 if (!Get (HaveHasBackButton)) {
 307                                         hasBackButton = ReadBoolean ("hasbackbutton");
 308                                         Set (HaveHasBackButton);
 309                                 }
 310
 311                                 return hasBackButton;
 312                         }
 313                 }
 314
 315                 bool hidesRightAlignedMultiselectScrollbars;
 316                 public virtual bool HidesRightAlignedMultiselectScrollbars {
 317                         get {
 318                                 if (!Get (HaveHidesRightAlignedMultiselectScrollbars)) {
 319                                         hidesRightAlignedMultiselectScrollbars = ReadBoolean ("hidesrightalignedmultiselectscrollbars");
 320                                         Set (HaveHidesRightAlignedMultiselectScrollbars);
 321                                 }
 322
 323                                 return hidesRightAlignedMultiselectScrollbars;
 324                         }
 325                 }
 326
 327                 string htmlTextWriter;
 328                 public string HtmlTextWriter {
 329                         get {
 330                                 if (!Get (HaveHtmlTextWriter)) {
 331                                         htmlTextWriter = ReadString ("htmlTextWriter");
 332                                         Set (HaveHtmlTextWriter);
 333                                 }
 334
 335                                 return htmlTextWriter;
 336                         }
 337                         set {
 338                                 Set (HaveHtmlTextWriter);
 339                                 htmlTextWriter = value;
 340                         }
 341                 }
 342
 343                 public string Id {
 344                         get { return this.Browser; }
 345                 }
 346
 347                 string inputType;
 348                 public virtual string InputType {
 349                         get {
 350                                 if (!Get (HaveInputType)) {
 351                                         inputType = ReadString ("inputtype");
 352                                         Set (HaveInputType);
 353                                 }
 354
 355                                 return inputType;
 356                         }
 357                 }
 358
 359                 bool isColor;
 360                 public virtual bool IsColor {
 361                         get {
 362                                 if (!Get (HaveIsColor)) {
 363                                         isColor = ReadBoolean ("iscolor");
 364                                         Set (HaveIsColor);
 365                                 }
 366
 367                                 return isColor;
 368                         }
 369                 }
 370
 371                 bool isMobileDevice;
 372                 public virtual bool IsMobileDevice {
 373                         get {
 374                                 if (!Get (HaveIsMobileDevice)) {
 375                                         isMobileDevice = ReadBoolean ("ismobiledevice");
 376                                         Set (HaveIsMobileDevice);
 377                                 }
 378
 379                                 return isMobileDevice;
 380                         }
 381                 }
 382
 383                 Version jscriptVersion;
 384                 public Version JScriptVersion {
 385                         get {
 386                                 if (!Get (HaveJScriptVersion)) {
 387                                         jscriptVersion = ReadVersion ("jscriptversion");
 388                                         Set (HaveJScriptVersion);
 389                                 }
 390
 391                                 return jscriptVersion;
 392                         }
 393                 }
 394
 395                 int maximumHrefLength;
 396                 public virtual int MaximumHrefLength {
 397                         get {
 398                                 if (!Get (HaveMaximumHrefLength)) {
 399                                         maximumHrefLength = ReadInt32 ("maximumhreflength");
 400                                         Set (HaveMaximumHrefLength);
 401                                 }
 402
 403                                 return maximumHrefLength;
 404                         }
 405                 }
 406
 407                 int maximumRenderedPageSize;
 408                 public virtual int MaximumRenderedPageSize {
 409                         get {
 410                                 if (!Get (HaveMaximumRenderedPageSize)) {
 411                                         maximumRenderedPageSize = ReadInt32 ("maximumrenderedpagesize");
 412                                         Set (HaveMaximumRenderedPageSize);
 413                                 }
 414
 415                                 return maximumRenderedPageSize;
 416                         }
 417                 }
 418
 419                 int maximumSoftkeyLabelLength;
 420                 public virtual int MaximumSoftkeyLabelLength {
 421                         get {
 422                                 if (!Get (HaveMaximumSoftkeyLabelLength)) {
 423                                         maximumSoftkeyLabelLength = ReadInt32 ("maximumsoftkeylabellength");
 424                                         Set (HaveMaximumSoftkeyLabelLength);
 425                                 }
 426
 427                                 return maximumSoftkeyLabelLength;
 428                         }
 429                 }
 430
 431                 string minorVersionString;
 432                 public string MinorVersionString {
 433                         get {
 434                                 if (!Get (HaveMinorVersionString)) {
 435                                         minorVersionString = ReadString ("minorversionstring");
 436                                         Set (HaveMinorVersionString);
 437                                 }
 438
 439                                 return minorVersionString;
 440                         }
 441                 }
 442
 443                 string mobileDeviceManufacturer;
 444                 public virtual string MobileDeviceManufacturer {
 445                         get {
 446                                 if (!Get (HaveMobileDeviceManufacturer)) {
 447                                         mobileDeviceManufacturer = ReadString ("mobiledevicemanufacturer");
 448                                         Set (HaveMobileDeviceManufacturer);
 449                                 }
 450
 451                                 return mobileDeviceManufacturer;
 452                         }
 453                 }
 454
 455                 string mobileDeviceModel;
 456                 public virtual string MobileDeviceModel {
 457                         get {
 458                                 if (!Get (HaveMobileDeviceModel)) {
 459                                         mobileDeviceModel = ReadString ("mobiledevicemodel");
 460                                         Set (HaveMobileDeviceModel);
 461                                 }
 462
 463                                 return mobileDeviceModel;
 464                         }
 465                 }
 466
 467                 int numberOfSoftkeys;
 468                 public virtual int NumberOfSoftkeys {
 469                         get {
 470                                 if (!Get (HaveNumberOfSoftkeys)) {
 471                                         numberOfSoftkeys = ReadInt32 ("numberofsoftkeys");
 472                                         Set (HaveNumberOfSoftkeys);
 473                                 }
 474
 475                                 return numberOfSoftkeys;
 476                         }
 477                 }
 478
 479                 string preferredImageMime;
 480                 public virtual string PreferredImageMime {
 481                         get {
 482                                 if (!Get (HavePreferredImageMime)) {
 483                                         preferredImageMime = ReadString ("preferredimagemime");
 484                                         Set (HavePreferredImageMime);
 485                                 }
 486
 487                                 return preferredImageMime;
 488                         }
 489                 }
 490
 491                 string preferredRenderingMime;
 492                 public virtual string PreferredRenderingMime {
 493                         get {
 494                                 if (!Get (HavePreferredRenderingMime)) {
 495                                         preferredRenderingMime = ReadString ("preferredrenderingmime");
 496                                         Set (HavePreferredRenderingMime);
 497                                 }
 498
 499                                 return preferredRenderingMime;
 500                         }
 501                 }
 502
 503                 string preferredRenderingType;
 504                 public virtual string PreferredRenderingType {
 505                         get {
 506                                 if (!Get (HavePreferredRenderingType)) {
 507                                         preferredRenderingType = ReadString ("preferredrenderingtype");
 508                                         Set (HavePreferredRenderingType);
 509                                 }
 510
 511                                 return preferredRenderingType;
 512                         }
 513                 }
 514
 515                 string preferredRequestEncoding;
 516                 public virtual string PreferredRequestEncoding {
 517                         get {
 518                                 if (!Get (HavePreferredRequestEncoding)) {
 519                                         preferredRequestEncoding = ReadString ("preferredrequestencoding");
 520                                         Set (HavePreferredRequestEncoding);
 521                                 }
 522
 523                                 return preferredRequestEncoding;
 524                         }
 525                 }
 526
 527                 string preferredResponseEncoding;
 528                 public virtual string PreferredResponseEncoding {
 529                         get {
 530                                 if (!Get (HavePreferredResponseEncoding)) {
 531                                         preferredResponseEncoding = ReadString ("preferredresponseencoding");
 532                                         Set (HavePreferredResponseEncoding);
 533                                 }
 534
 535                                 return preferredResponseEncoding;
 536                         }
 537                 }
 538
 539                 bool rendersBreakBeforeWmlSelectAndInput;
 540                 public virtual bool RendersBreakBeforeWmlSelectAndInput {
 541                         get {
 542                                 if (!Get (HaveRendersBreakBeforeWmlSelectAndInput)) {
 543                                         rendersBreakBeforeWmlSelectAndInput = ReadBoolean ("rendersbreakbeforewmlselectandinput");
 544                                         Set (HaveRendersBreakBeforeWmlSelectAndInput);
 545                                 }
 546
 547                                 return rendersBreakBeforeWmlSelectAndInput;
 548                         }
 549                 }
 550
 551                 bool rendersBreaksAfterHtmlLists;
 552                 public virtual bool RendersBreaksAfterHtmlLists {
 553                         get {
 554                                 if (!Get (HaveRendersBreaksAfterHtmlLists)) {
 555                                         rendersBreaksAfterHtmlLists = ReadBoolean ("rendersbreaksafterhtmllists");
 556                                         Set (HaveRendersBreaksAfterHtmlLists);
 557                                 }
 558
 559                                 return rendersBreaksAfterHtmlLists;
 560                         }
 561                 }
 562
 563                 bool rendersBreaksAfterWmlAnchor;
 564                 public virtual bool RendersBreaksAfterWmlAnchor {
 565                         get {
 566                                 if (!Get (HaveRendersBreaksAfterWmlAnchor)) {
 567                                         rendersBreaksAfterWmlAnchor = ReadBoolean ("rendersbreaksafterwmlanchor");
 568                                         Set (HaveRendersBreaksAfterWmlAnchor);
 569                                 }
 570
 571                                 return rendersBreaksAfterWmlAnchor;
 572                         }
 573                 }
 574
 575                 bool rendersBreaksAfterWmlInput;
 576                 public virtual bool RendersBreaksAfterWmlInput {
 577                         get {
 578                                 if (!Get (HaveRendersBreaksAfterWmlInput)) {
 579                                         rendersBreaksAfterWmlInput = ReadBoolean ("rendersbreaksafterwmlinput");
 580                                         Set (HaveRendersBreaksAfterWmlInput);
 581                                 }
 582
 583                                 return rendersBreaksAfterWmlInput;
 584                         }
 585                 }
 586
 587                 bool rendersWmlDoAcceptsInline;
 588                 public virtual bool RendersWmlDoAcceptsInline {
 589                         get {
 590                                 if (!Get (HaveRendersWmlDoAcceptsInline)) {
 591                                         rendersWmlDoAcceptsInline = ReadBoolean ("renderswmldoacceptsinline");
 592                                         Set (HaveRendersWmlDoAcceptsInline);
 593                                 }
 594
 595                                 return rendersWmlDoAcceptsInline;
 596                         }
 597                 }
 598
 599                 bool rendersWmlSelectsAsMenuCards;
 600                 public virtual bool RendersWmlSelectsAsMenuCards {
 601                         get {
 602                                 if (!Get (HaveRendersWmlSelectsAsMenuCards)) {
 603                                         rendersWmlSelectsAsMenuCards = ReadBoolean ("renderswmlselectsasmenucards");
 604                                         Set (HaveRendersWmlSelectsAsMenuCards);
 605                                 }
 606
 607                                 return rendersWmlSelectsAsMenuCards;
 608                         }
 609                 }
 610
 611                 string requiredMetaTagNameValue;
 612                 public virtual string RequiredMetaTagNameValue {
 613                         get {
 614                                 if (!Get (HaveRequiredMetaTagNameValue)) {
 615                                         requiredMetaTagNameValue = ReadString ("requiredmetatagnamevalue");
 616                                         Set (HaveRequiredMetaTagNameValue);
 617                                 }
 618
 619                                 return requiredMetaTagNameValue;
 620                         }
 621                 }
 622
 623                 bool requiresAttributeColonSubstitution;
 624                 public virtual bool RequiresAttributeColonSubstitution {
 625                         get {
 626                                 if (!Get (HaveRequiresAttributeColonSubstitution)) {
 627                                         requiresAttributeColonSubstitution = ReadBoolean ("requiresattributecolonsubstitution");
 628                                         Set (HaveRequiresAttributeColonSubstitution);
 629                                 }
 630
 631                                 return requiresAttributeColonSubstitution;
 632                         }
 633                 }
 634
 635                 bool requiresContentTypeMetaTag;
 636                 public virtual bool RequiresContentTypeMetaTag {
 637                         get {
 638                                 if (!Get (HaveRequiresContentTypeMetaTag)) {
 639                                         requiresContentTypeMetaTag = ReadBoolean ("requiresContentTypeMetaTag");
 640                                         Set (HaveRequiresContentTypeMetaTag);
 641                                 }
 642
 643                                 return requiresContentTypeMetaTag;
 644                         }
 645                 }
 646
 647                 bool requiresControlStateInSession;
 648                 public bool RequiresControlStateInSession {
 649                         get {
 650                                 if (!Get (HaveRequiresControlStateInSession)) {
 651                                         requiresControlStateInSession = ReadBoolean ("requiresControlStateInSession");
 652                                         Set (HaveRequiresControlStateInSession);
 653                                 }
 654
 655                                 return requiresControlStateInSession;
 656                         }
 657                 }
 658
 659                 bool requiresDBCSCharacter;
 660                 public virtual bool RequiresDBCSCharacter {
 661                         get {
 662                                 if (!Get (HaveRequiresDBCSCharacter)) {
 663                                         requiresDBCSCharacter = ReadBoolean ("requiresdbcscharacter");
 664                                         Set (HaveRequiresDBCSCharacter);
 665                                 }
 666
 667                                 return requiresDBCSCharacter;
 668                         }
 669                 }
 670
 671                 bool requiresHtmlAdaptiveErrorReporting;
 672                 public virtual bool RequiresHtmlAdaptiveErrorReporting {
 673                         get {
 674                                 if (!Get (HaveRequiresHtmlAdaptiveErrorReporting)) {
 675                                         requiresHtmlAdaptiveErrorReporting = ReadBoolean ("requireshtmladaptiveerrorreporting");
 676                                         Set (HaveRequiresHtmlAdaptiveErrorReporting);
 677                                 }
 678
 679                                 return requiresHtmlAdaptiveErrorReporting;
 680                         }
 681                 }
 682
 683                 bool requiresLeadingPageBreak;
 684                 public virtual bool RequiresLeadingPageBreak {
 685                         get {
 686                                 if (!Get (HaveRequiresLeadingPageBreak)) {
 687                                         requiresLeadingPageBreak = ReadBoolean ("requiresleadingpagebreak");
 688                                         Set (HaveRequiresLeadingPageBreak);
 689                                 }
 690
 691                                 return requiresLeadingPageBreak;
 692                         }
 693                 }
 694
 695                 bool requiresNoBreakInFormatting;
 696                 public virtual bool RequiresNoBreakInFormatting {
 697                         get {
 698                                 if (!Get (HaveRequiresNoBreakInFormatting)) {
 699                                         requiresNoBreakInFormatting = ReadBoolean ("requiresnobreakinformatting");
 700                                         Set (HaveRequiresNoBreakInFormatting);
 701                                 }
 702
 703                                 return requiresNoBreakInFormatting;
 704                         }
 705                 }
 706
 707                 bool requiresOutputOptimization;
 708                 public virtual bool RequiresOutputOptimization {
 709                         get {
 710                                 if (!Get (HaveRequiresOutputOptimization)) {
 711                                         requiresOutputOptimization = ReadBoolean ("requiresoutputoptimization");
 712                                         Set (HaveRequiresOutputOptimization);
 713                                 }
 714
 715                                 return requiresOutputOptimization;
 716                         }
 717                 }
 718
 719                 bool requiresPhoneNumbersAsPlainText;
 720                 public virtual bool RequiresPhoneNumbersAsPlainText {
 721                         get {
 722                                 if (!Get (HaveRequiresPhoneNumbersAsPlainText)) {
 723                                         requiresPhoneNumbersAsPlainText = ReadBoolean ("requiresphonenumbersasplaintext");
 724                                         Set (HaveRequiresPhoneNumbersAsPlainText);
 725                                 }
 726
 727                                 return requiresPhoneNumbersAsPlainText;
 728                         }
 729                 }
 730
 731                 bool requiresSpecialViewStateEncoding;
 732                 public virtual bool RequiresSpecialViewStateEncoding {
 733                         get {
 734                                 if (!Get (HaveRequiresSpecialViewStateEncoding)) {
 735                                         requiresSpecialViewStateEncoding = ReadBoolean ("requiresspecialviewstateencoding");
 736                                         Set (HaveRequiresSpecialViewStateEncoding);
 737                                 }
 738
 739                                 return requiresSpecialViewStateEncoding;
 740                         }
 741                 }
 742
 743                 bool requiresUniqueFilePathSuffix;
 744                 public virtual bool RequiresUniqueFilePathSuffix {
 745                         get {
 746                                 if (!Get (HaveRequiresUniqueFilePathSuffix)) {
 747                                         requiresUniqueFilePathSuffix = ReadBoolean ("requiresuniquefilepathsuffix");
 748                                         Set (HaveRequiresUniqueFilePathSuffix);
 749                                 }
 750
 751                                 return requiresUniqueFilePathSuffix;
 752                         }
 753                 }
 754
 755                 bool requiresUniqueHtmlCheckboxNames;
 756                 public virtual bool RequiresUniqueHtmlCheckboxNames {
 757                         get {
 758                                 if (!Get (HaveRequiresUniqueHtmlCheckboxNames)) {
 759                                         requiresUniqueHtmlCheckboxNames = ReadBoolean ("requiresuniquehtmlcheckboxnames");
 760                                         Set (HaveRequiresUniqueHtmlCheckboxNames);
 761                                 }
 762
 763                                 return requiresUniqueHtmlCheckboxNames;
 764                         }
 765                 }
 766
 767                 bool requiresUniqueHtmlInputNames;
 768                 public virtual bool RequiresUniqueHtmlInputNames {
 769                         get {
 770                                 if (!Get (HaveRequiresUniqueHtmlInputNames)) {
 771                                         requiresUniqueHtmlInputNames = ReadBoolean ("requiresuniquehtmlinputnames");
 772                                         Set (HaveRequiresUniqueHtmlInputNames);
 773                                 }
 774
 775                                 return requiresUniqueHtmlInputNames;
 776                         }
 777                 }
 778
 779                 bool requiresUrlEncodedPostfieldValues;
 780                 public virtual bool RequiresUrlEncodedPostfieldValues {
 781                         get {
 782                                 if (!Get (HaveRequiresUrlEncodedPostfieldValues)) {
 783                                         requiresUrlEncodedPostfieldValues = ReadBoolean ("requiresurlencodedpostfieldvalues");
 784                                         Set (HaveRequiresUrlEncodedPostfieldValues);
 785                                 }
 786
 787                                 return requiresUrlEncodedPostfieldValues;
 788                         }
 789                 }
 790
 791                 int screenBitDepth;
 792                 public virtual int ScreenBitDepth {
 793                         get {
 794                                 if (!Get (HaveScreenBitDepth)) {
 795                                         screenBitDepth = ReadInt32 ("screenbitdepth");
 796                                         Set (HaveScreenBitDepth);
 797                                 }
 798
 799                                 return screenBitDepth;
 800                         }
 801                 }
 802
 803                 int screenCharactersHeight;
 804                 public virtual int ScreenCharactersHeight {
 805                         get {
 806                                 if (!Get (HaveScreenCharactersHeight)) {
 807                                         screenCharactersHeight = ReadInt32 ("screencharactersheight");
 808                                         Set (HaveScreenCharactersHeight);
 809                                 }
 810
 811                                 return screenCharactersHeight;
 812                         }
 813                 }
 814
 815                 int screenCharactersWidth;
 816                 public virtual int ScreenCharactersWidth {
 817                         get {
 818                                 if (!Get (HaveScreenCharactersWidth)) {
 819                                         screenCharactersWidth = ReadInt32 ("screencharacterswidth");
 820                                         Set (HaveScreenCharactersWidth);
 821                                 }
 822
 823                                 return screenCharactersWidth;
 824                         }
 825                 }
 826
 827                 int screenPixelsHeight;
 828                 public virtual int ScreenPixelsHeight {
 829                         get {
 830                                 if (!Get (HaveScreenPixelsHeight)) {
 831                                         screenPixelsHeight = ReadInt32 ("screenpixelsheight");
 832                                         Set (HaveScreenPixelsHeight);
 833                                 }
 834
 835                                 return screenPixelsHeight;
 836                         }
 837                 }
 838
 839                 int screenPixelsWidth;
 840                 public virtual int ScreenPixelsWidth {
 841                         get {
 842                                 if (!Get (HaveScreenPixelsWidth)) {
 843                                         screenPixelsWidth = ReadInt32 ("screenpixelswidth");
 844                                         Set (HaveScreenPixelsWidth);
 845                                 }
 846
 847                                 return screenPixelsWidth;
 848                         }
 849                 }
 850
 851                 bool supportsAccesskeyAttribute;
 852                 public virtual bool SupportsAccesskeyAttribute {
 853                         get {
 854                                 if (!Get (HaveSupportsAccesskeyAttribute)) {
 855                                         supportsAccesskeyAttribute = ReadBoolean ("supportsaccesskeyattribute");
 856                                         Set (HaveSupportsAccesskeyAttribute);
 857                                 }
 858
 859                                 return supportsAccesskeyAttribute;
 860                         }
 861                 }
 862
 863                 bool supportsBodyColor;
 864                 public virtual bool SupportsBodyColor {
 865                         get {
 866                                 if (!Get (HaveSupportsBodyColor)) {
 867                                         supportsBodyColor = ReadBoolean ("supportsbodycolor");
 868                                         Set (HaveSupportsBodyColor);
 869                                 }
 870
 871                                 return supportsBodyColor;
 872                         }
 873                 }
 874
 875                 bool supportsBold;
 876                 public virtual bool SupportsBold {
 877                         get {
 878                                 if (!Get (HaveSupportsBold)) {
 879                                         supportsBold = ReadBoolean ("supportsbold");
 880                                         Set (HaveSupportsBold);
 881                                 }
 882
 883                                 return supportsBold;
 884                         }
 885                 }
 886
 887                 bool supportsCacheControlMetaTag;
 888                 public virtual bool SupportsCacheControlMetaTag {
 889                         get {
 890                                 if (!Get (HaveSupportsCacheControlMetaTag)) {
 891                                         supportsCacheControlMetaTag = ReadBoolean ("supportscachecontrolmetatag");
 892                                         Set (HaveSupportsCacheControlMetaTag);
 893                                 }
 894
 895                                 return supportsCacheControlMetaTag;
 896                         }
 897                 }
 898
 899                 bool supportsCallback;
 900                 public virtual bool SupportsCallback {
 901                         get {
 902                                 if (!Get (HaveSupportsCallback)) {
 903                                         supportsCallback = ReadBoolean ("supportscallback");
 904                                         Set (HaveSupportsCallback);
 905                                 }
 906
 907                                 return supportsCallback;
 908                         }
 909                 }
 910
 911                 bool supportsCss;
 912                 public virtual bool SupportsCss {
 913                         get {
 914                                 if (!Get (HaveSupportsCss)) {
 915                                         supportsCss = ReadBoolean ("supportscss");
 916                                         Set (HaveSupportsCss);
 917                                 }
 918
 919                                 return supportsCss;
 920                         }
 921                 }
 922
 923                 bool supportsDivAlign;
 924                 public virtual bool SupportsDivAlign {
 925                         get {
 926                                 if (!Get (HaveSupportsDivAlign)) {
 927                                         supportsDivAlign = ReadBoolean ("supportsdivalign");
 928                                         Set (HaveSupportsDivAlign);
 929                                 }
 930
 931                                 return supportsDivAlign;
 932                         }
 933                 }
 934
 935                 bool supportsDivNoWrap;
 936                 public virtual bool SupportsDivNoWrap {
 937                         get {
 938                                 if (!Get (HaveSupportsDivNoWrap)) {
 939                                         supportsDivNoWrap = ReadBoolean ("supportsdivnowrap");
 940                                         Set (HaveRequiresDBCSCharacter);
 941                                 }
 942
 943                                 return supportsDivNoWrap;
 944                         }
 945                 }
 946
 947                 bool supportsEmptyStringInCookieValue;
 948                 public virtual bool SupportsEmptyStringInCookieValue {
 949                         get {
 950                                 if (!Get (HaveSupportsEmptyStringInCookieValue)) {
 951                                         supportsEmptyStringInCookieValue = ReadBoolean ("supportsemptystringincookievalue");
 952                                         Set (HaveSupportsEmptyStringInCookieValue);
 953                                 }
 954
 955                                 return supportsEmptyStringInCookieValue;
 956                         }
 957                 }
 958
 959                 bool supportsFontColor;
 960                 public virtual bool SupportsFontColor {
 961                         get {
 962                                 if (!Get (HaveSupportsFontColor)) {
 963                                         supportsFontColor = ReadBoolean ("supportsfontcolor");
 964                                         Set (HaveSupportsFontColor);
 965                                 }
 966
 967                                 return supportsFontColor;
 968                         }
 969                 }
 970
 971                 bool supportsFontName;
 972                 public virtual bool SupportsFontName {
 973                         get {
 974                                 if (!Get (HaveSupportsFontName)) {
 975                                         supportsFontName = ReadBoolean ("supportsfontname");
 976                                         Set (HaveSupportsFontName);
 977                                 }
 978
 979                                 return supportsFontName;
 980                         }
 981                 }
 982
 983                 bool supportsFontSize;
 984                 public virtual bool SupportsFontSize {
 985                         get {
 986                                 if (!Get (HaveSupportsFontSize)) {
 987                                         supportsFontSize = ReadBoolean ("supportsfontsize");
 988                                         Set (HaveSupportsFontSize);
 989                                 }
 990
 991                                 return supportsFontSize;
 992                         }
 993                 }
 994
 995                 bool supportsImageSubmit;
 996                 public virtual bool SupportsImageSubmit {
 997                         get {
 998                                 if (!Get (HaveSupportsImageSubmit)) {
 999                                         supportsImageSubmit = ReadBoolean ("supportsimagesubmit");
1000                                         Set (HaveSupportsImageSubmit);
1001                                 }
1002
1003                                 return supportsImageSubmit;
1004                         }
1005                 }
1006
1007                 bool supportsIModeSymbols;
1008                 public virtual bool SupportsIModeSymbols {
1009                         get {
1010                                 if (!Get (HaveSupportsIModeSymbols)) {
1011                                         supportsIModeSymbols = ReadBoolean ("supportsimodesymbols");
1012                                         Set (HaveSupportsIModeSymbols);
1013                                 }
1014
1015                                 return supportsIModeSymbols;
1016                         }
1017                 }
1018
1019                 bool supportsInputIStyle;
1020                 public virtual bool SupportsInputIStyle {
1021                         get {
1022                                 if (!Get (HaveSupportsInputIStyle)) {
1023                                         supportsInputIStyle = ReadBoolean ("supportsinputistyle");
1024                                         Set (HaveSupportsInputIStyle);
1025                                 }
1026
1027                                 return supportsInputIStyle;
1028                         }
1029                 }
1030
1031                 bool supportsInputMode;
1032                 public virtual bool SupportsInputMode {
1033                         get {
1034                                 if (!Get (HaveSupportsInputMode)) {
1035                                         supportsInputMode = ReadBoolean ("supportsinputmode");
1036                                         Set (HaveSupportsInputMode);
1037                                 }
1038
1039                                 return supportsInputMode;
1040                         }
1041                 }
1042
1043                 bool supportsItalic;
1044                 public virtual bool SupportsItalic {
1045                         get {
1046                                 if (!Get (HaveSupportsItalic)) {
1047                                         supportsItalic = ReadBoolean ("supportsitalic");
1048                                         Set (HaveSupportsItalic);
1049                                 }
1050
1051                                 return supportsItalic;
1052                         }
1053                 }
1054
1055                 bool supportsJPhoneMultiMediaAttributes;
1056                 public virtual bool SupportsJPhoneMultiMediaAttributes {
1057                         get {
1058                                 if (!Get (HaveSupportsJPhoneMultiMediaAttributes)) {
1059                                         supportsJPhoneMultiMediaAttributes = ReadBoolean ("supportsjphonemultimediaattributes");
1060                                         Set (HaveSupportsJPhoneMultiMediaAttributes);
1061                                 }
1062
1063                                 return supportsJPhoneMultiMediaAttributes;
1064                         }
1065                 }
1066
1067                 bool supportsJPhoneSymbols;
1068                 public virtual bool SupportsJPhoneSymbols {
1069                         get {
1070                                 if (!Get (HaveSupportsJPhoneSymbols)) {
1071                                         supportsJPhoneSymbols = ReadBoolean ("supportsjphonesymbols");
1072                                         Set (HaveSupportsJPhoneSymbols);
1073                                 }
1074
1075                                 return supportsJPhoneSymbols;
1076                         }
1077                 }
1078
1079                 bool supportsQueryStringInFormAction;
1080                 public virtual bool SupportsQueryStringInFormAction {
1081                         get {
1082                                 if (!Get (HaveSupportsQueryStringInFormAction)) {
1083                                         supportsQueryStringInFormAction = ReadBoolean ("supportsquerystringinformaction");
1084                                         Set (HaveSupportsQueryStringInFormAction);
1085                                 }
1086
1087                                 return supportsQueryStringInFormAction;
1088                         }
1089                 }
1090
1091                 bool supportsRedirectWithCookie;
1092                 public virtual bool SupportsRedirectWithCookie {
1093                         get {
1094                                 if (!Get (HaveSupportsRedirectWithCookie)) {
1095                                         supportsRedirectWithCookie = ReadBoolean ("supportsredirectwithcookie");
1096                                         Set (HaveSupportsRedirectWithCookie);
1097                                 }
1098
1099                                 return supportsRedirectWithCookie;
1100                         }
1101                 }
1102
1103                 bool supportsSelectMultiple;
1104                 public virtual bool SupportsSelectMultiple {
1105                         get {
1106                                 if (!Get (HaveSupportsSelectMultiple)) {
1107                                         supportsSelectMultiple = ReadBoolean ("supportsselectmultiple");
1108                                         Set (HaveSupportsSelectMultiple);
1109                                 }
1110
1111                                 return supportsSelectMultiple;
1112                         }
1113                 }
1114
1115                 bool supportsUncheck;
1116                 public virtual bool SupportsUncheck {
1117                         get {
1118                                 if (!Get (HaveSupportsUncheck)) {
1119                                         supportsUncheck = ReadBoolean ("supportsuncheck");
1120                                         Set (HaveSupportsUncheck);
1121                                 }
1122
1123                                 return supportsUncheck;
1124                         }
1125                 }
1126
1127                 bool supportsXmlHttp;
1128                 public virtual bool SupportsXmlHttp {
1129                         get {
1130                                 if (!Get (HaveSupportsXmlHttp)) {
1131                                         supportsXmlHttp = ReadBoolean ("supportsxmlhttp");
1132                                         Set (HaveSupportsXmlHttp);
1133                                 }
1134
1135                                 return supportsXmlHttp;
1136                         }
1137                 }
1138
1139                 bool useOptimizedCacheKey;
1140                 public bool UseOptimizedCacheKey {
1141                         get {
1142                                 if (!Get (HaveUseOptimizedCacheKey)) {
1143                                         useOptimizedCacheKey = ReadBoolean ("useoptimizedcachekey");
1144                                         Set (HaveUseOptimizedCacheKey);
1145                                 }
1146
1147                                 return useOptimizedCacheKey;
1148                         }
1149                 }
1150         }
1151 }
1152