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