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