mcs/class/referencesource/System.Web/Configuration/HttpCapabilitiesBase.cs

   1 //------------------------------------------------------------------------------
   2 // <copyright file="HttpCapabilitiesBase.cs" company="Microsoft">
   3 //     Copyright (c) Microsoft Corporation.  All rights reserved.
   4 // </copyright>
   5 //------------------------------------------------------------------------------
   6
   7 /*
   8  * Base class for browser capabilities object: just a read-only dictionary
   9  * holder that supports Init()
  10  *
  11  *
  12
  13
  14 */
  15
  16 namespace System.Web.Configuration {
  17
  18     using System.Collections;
  19     using System.Security.Permissions;
  20     using System.Text.RegularExpressions;
  21     using System.Globalization;
  22     using System.Collections.Specialized;
  23     using System.Configuration;
  24     using System.Diagnostics;
  25     using System.IO;
  26     using System.Threading;
  27     using System.Web.Compilation;
  28     using System.Web.UI;
  29     using System.Web.Util;
  30     using System.Web.UI.Adapters;
  31     using Debug=System.Web.Util.Debug;
  32
  33     /*
  34      * Abstract base class for Capabilities
  35      */
  36     public class HttpCapabilitiesBase : IFilterResolutionService {
  37
  38 #if !DONTUSEFACTORYGENERATOR
  39         private static FactoryGenerator _controlAdapterFactoryGenerator;
  40         private static Hashtable _controlAdapterFactoryTable;
  41         private static object _staticLock = new object();
  42 #endif // DONTUSEFACTORYGENERATOR
  43         private static object s_nullAdapterSingleton = new object();
  44         private bool _useOptimizedCacheKey = true;
  45         private static object _emptyHttpCapabilitiesBaseLock = new object();
  46         private static HttpCapabilitiesProvider _browserCapabilitiesProvider = null;
  47
  48         private static HttpCapabilitiesBase _emptyHttpCapabilitiesBase;
  49
  50         internal static HttpCapabilitiesBase EmptyHttpCapabilitiesBase {
  51             get {
  52                 if (_emptyHttpCapabilitiesBase != null) {
  53                     return _emptyHttpCapabilitiesBase;
  54                 }
  55
  56                 lock (_emptyHttpCapabilitiesBaseLock) {
  57                     if (_emptyHttpCapabilitiesBase != null) {
  58                         return _emptyHttpCapabilitiesBase;
  59                     }
  60
  61                     _emptyHttpCapabilitiesBase = new HttpCapabilitiesBase();
  62                 }
  63
  64                 return _emptyHttpCapabilitiesBase;
  65             }
  66         }
  67
  68         public static HttpCapabilitiesProvider BrowserCapabilitiesProvider {
  69             get {
  70                 return _browserCapabilitiesProvider;
  71             }
  72             set {
  73                 _browserCapabilitiesProvider = value;
  74             }
  75         }
  76
  77         public bool UseOptimizedCacheKey {
  78             get {
  79                 return _useOptimizedCacheKey;
  80             }
  81         }
  82
  83         public void DisableOptimizedCacheKey() {
  84             _useOptimizedCacheKey = false;
  85         }
  86
  87         //
  88         // Public API for retrieving capabilities from config.
  89         //
  90         // Note that this API will return an empty HttpCapabilitiesBase
  91         // if capabilties cannot be found.
  92         //
  93         [ConfigurationPermission(SecurityAction.Assert, Unrestricted = true)]
  94         public static HttpCapabilitiesBase GetConfigCapabilities(string configKey, HttpRequest request) {
  95
  96             HttpCapabilitiesBase capabilities = null;
  97
  98             if (configKey == "system.web/browserCaps") {
  99                 // Use cached config for system.web/browserCaps
 100                 capabilities = GetBrowserCapabilities(request);
 101             }
 102             else {
 103                 //
 104                 // Slower code path to get capabilities from any section
 105                 // that implements System.Web.Configuration.HttpCapabilitiesSectionHandler.
 106                 // This code path will hit a demand for ConfigurationPermission.
 107                 //
 108                 HttpCapabilitiesDefaultProvider capsbuilder = (HttpCapabilitiesDefaultProvider) request.Context.GetSection(configKey);
 109                 if (capsbuilder != null) {
 110                     if (BrowserCapabilitiesProvider != null) {
 111                         capsbuilder.BrowserCapabilitiesProvider = BrowserCapabilitiesProvider;
 112                     }
 113                     if (capsbuilder.BrowserCapabilitiesProvider == null) {
 114                         capabilities = capsbuilder.Evaluate(request);
 115                     }
 116                     else {
 117                         capabilities = capsbuilder.BrowserCapabilitiesProvider.GetBrowserCapabilities(request);
 118                     }
 119                 }
 120             }
 121
 122             if (capabilities == null) {
 123                 capabilities = EmptyHttpCapabilitiesBase;
 124             }
 125
 126             return capabilities;
 127         }
 128
 129         //
 130         // Get browser capabilities from config that are stored at "system.web/browserCaps".
 131         //
 132         // This code path will use the cached config object and avoid the demand for ConfigurationPermission
 133         // after the first request for config.
 134         //
 135         // Note: this API will return null if the section isn't found.
 136         //
 137         internal static HttpBrowserCapabilities GetBrowserCapabilities(HttpRequest request) {
 138
 139             HttpCapabilitiesBase capabilities = null;
 140
 141             // Get the config evaluator from the cached config object.
 142             HttpCapabilitiesDefaultProvider capsbuilder = request.Context.IsRuntimeErrorReported ?
 143                 RuntimeConfig.GetLKGConfig(request.Context).BrowserCaps : RuntimeConfig.GetConfig(request.Context).BrowserCaps;
 144             if (capsbuilder != null) {
 145                 if (BrowserCapabilitiesProvider != null) {
 146                     capsbuilder.BrowserCapabilitiesProvider = BrowserCapabilitiesProvider;
 147                 }
 148                 if (capsbuilder.BrowserCapabilitiesProvider == null) {
 149                     capabilities = capsbuilder.Evaluate(request);
 150                 }
 151                 else {
 152                     capabilities = capsbuilder.BrowserCapabilitiesProvider.GetBrowserCapabilities(request);
 153                 }
 154             }
 155
 156             return (HttpBrowserCapabilities) capabilities;
 157         }
 158
 159         /*
 160          * A Capabilities object is just a read-only dictionary
 161          */
 162         /// <devdoc>
 163         ///       <para>Allows access to individual dictionary values.</para>
 164         ///    </devdoc>
 165         public virtual String this[String key] {
 166             get {
 167                 return (String)_items[key];
 168             }
 169         }
 170
 171         public HtmlTextWriter CreateHtmlTextWriter(TextWriter w) {
 172             string mtw = HtmlTextWriter;
 173             if (mtw != null && mtw.Length != 0) {
 174                 HtmlTextWriter writer = null;
 175                 try {
 176                     Type writerType = BuildManager.GetType(mtw, true /* throwOnFail */, false /* ignoreCase */);
 177                     object[] arr = new object[1];
 178                     arr[0] = w;
 179                     writer = (HtmlTextWriter)Activator.CreateInstance(writerType, arr);
 180                     if (writer != null) {
 181                         return writer;
 182                     }
 183                 }
 184                 catch {
 185                     throw new Exception(SR.GetString(SR.Could_not_create_type_instance, mtw));
 186                 }
 187             }
 188             return CreateHtmlTextWriterInternal(w);
 189         }
 190
 191         internal HtmlTextWriter CreateHtmlTextWriterInternal(TextWriter tw) {
 192             Type tagWriter = TagWriter;
 193             if (tagWriter != null) {
 194                 return Page.CreateHtmlTextWriterFromType(tw, tagWriter);
 195             }
 196
 197             // Fall back to Html 3.2
 198             return new Html32TextWriter(tw);
 199         }
 200
 201         /*
 202          * It provides an overridable Init method
 203          */
 204         /// <internalonly/>
 205         /// <devdoc>
 206         /// </devdoc>
 207         protected virtual void Init() {
 208         }
 209
 210         /*
 211          * The actual initializer sets up Item[] before calling Init()
 212          */
 213
 214         internal void InitInternal(HttpBrowserCapabilities browserCaps) {
 215             if (_items != null) {
 216                 throw new ArgumentException(SR.GetString(SR.Caps_cannot_be_inited_twice));
 217             }
 218
 219             _items = browserCaps._items;
 220             _adapters = browserCaps._adapters;
 221             _browsers = browserCaps._browsers;
 222             _htmlTextWriter = browserCaps._htmlTextWriter;
 223             _useOptimizedCacheKey = browserCaps._useOptimizedCacheKey;
 224
 225             Init();
 226         }
 227
 228         internal ControlAdapter GetAdapter(System.Web.UI.Control control) {
 229             if (_adapters == null || _adapters.Count == 0) {
 230                 return null;
 231             }
 232
 233             if (control == null) {
 234                 return null;
 235             }
 236
 237             //see if we have already cached the type;
 238             Type controlType = control.GetType();
 239             object o = AdapterTypes[controlType];
 240
 241             // Common desktop case: simply return null since we already tried to resolve the adapter.
 242             if (object.ReferenceEquals(o, s_nullAdapterSingleton))
 243                 return null;
 244
 245             Type adapterType = (Type)o;
 246             if (adapterType == null) {
 247                 Type tempControlType = controlType;
 248                 string controlTypename = null;
 249                 string adapterTypename = null;
 250
 251                 while (adapterTypename == null && tempControlType != typeof(Control)) {
 252                     controlTypename = tempControlType.AssemblyQualifiedName;
 253                     adapterTypename = (string)Adapters[controlTypename];
 254
 255                     if (adapterTypename == null) {
 256                         controlTypename = tempControlType.FullName;
 257                         adapterTypename = (string)Adapters[controlTypename];
 258                     }
 259
 260                     if (adapterTypename != null) {
 261                         break;
 262                     }
 263
 264                     tempControlType = tempControlType.BaseType;
 265                 }
 266
 267                 // Remember it so that we do not walk the control hierarchy again.
 268                 if (String.IsNullOrEmpty(adapterTypename)) {
 269                     AdapterTypes[controlType] = s_nullAdapterSingleton;
 270                     return null;
 271                 }
 272
 273                 //do not thrownOnFail or ignoreCase
 274                 adapterType = BuildManager.GetType(adapterTypename, false, false);
 275                 if (adapterType == null) {
 276                     throw new Exception(SR.GetString(SR.ControlAdapters_TypeNotFound, adapterTypename));
 277                 }
 278
 279                 AdapterTypes[controlType] = adapterType;
 280             }
 281
 282 #if DONTUSEFACTORYGENERATOR
 283             ControlAdapter adapter = (ControlAdapter) HttpRuntime.CreatePublicInstance(adapterType);
 284 #else
 285             IWebObjectFactory factory = GetAdapterFactory(adapterType);
 286             ControlAdapter adapter = (ControlAdapter)factory.CreateInstance();
 287 #endif // DONTUSEFACTORYGENERATOR
 288             adapter._control = control;
 289
 290             return adapter;
 291         }
 292
 293 #if !DONTUSEFACTORYGENERATOR
 294         private IWebObjectFactory GetAdapterFactory(Type adapterType) {
 295             if (_controlAdapterFactoryGenerator == null) {
 296                 lock (_staticLock) {
 297                     if (_controlAdapterFactoryGenerator == null) {
 298                         _controlAdapterFactoryTable = new Hashtable();
 299                         _controlAdapterFactoryGenerator = new FactoryGenerator();
 300                     }
 301                 }
 302             }
 303
 304             IWebObjectFactory factory = (IWebObjectFactory)_controlAdapterFactoryTable[adapterType];
 305             if (factory == null) {
 306
 307                 lock (_controlAdapterFactoryTable.SyncRoot) {
 308                     factory = (IWebObjectFactory)_controlAdapterFactoryTable[adapterType];
 309
 310                     if (factory == null) {
 311                         try {
 312                             factory = _controlAdapterFactoryGenerator.CreateFactory(adapterType);
 313                         }
 314                         catch {
 315                             throw new Exception(SR.GetString(SR.Could_not_create_type_instance, adapterType.ToString()));
 316                         }
 317
 318                         _controlAdapterFactoryTable[adapterType] = factory;
 319                     }
 320                 }
 321             }
 322
 323             return factory;
 324         }
 325 #endif // DONTUSEFACTORYGENERATOR
 326
 327         public IDictionary Capabilities {
 328             get {
 329                 return _items;
 330             }
 331             set {
 332                 _items = value;
 333             }
 334         }
 335
 336         public IDictionary Adapters {
 337             get {
 338                 if (_adapters == null) {
 339                     lock (_staticLock) {
 340                         if (_adapters == null) {
 341                             _adapters = new Hashtable(StringComparer.OrdinalIgnoreCase);
 342                         }
 343                     }
 344                 }
 345                 return _adapters;
 346             }
 347         }
 348
 349         public string HtmlTextWriter {
 350             get {
 351                 return _htmlTextWriter;
 352             }
 353             set {
 354                 _htmlTextWriter = value;
 355             }
 356         }
 357
 358         private Hashtable AdapterTypes {
 359             get {
 360                 if (_adapterTypes == null) {
 361                     lock (_staticLock) {
 362                         if (_adapterTypes == null) {
 363                             _adapterTypes = Hashtable.Synchronized(new Hashtable());
 364                         }
 365                     }
 366                 }
 367                 return _adapterTypes;
 368             }
 369         }
 370
 371         public string Id {
 372             get {
 373                 if (_browsers != null) {
 374                     return (string)_browsers[_browsers.Count - 1];
 375                 }
 376                 else return String.Empty;
 377             }
 378         }
 379
 380         public ArrayList Browsers {
 381             get {
 382                 return _browsers;
 383             }
 384         }
 385
 386         Hashtable _adapterTypes;
 387         private IDictionary _adapters;
 388         private string _htmlTextWriter;
 389         private IDictionary _items;
 390
 391         public Version ClrVersion {
 392             get {
 393                 Version[] clrVersions = GetClrVersions();
 394                 if (clrVersions != null) {
 395                     return clrVersions[clrVersions.Length - 1];
 396                 }
 397
 398                 return null;
 399             }
 400         }
 401
 402         public Version[] GetClrVersions() {
 403             string ua = HttpCapabilitiesDefaultProvider.GetUserAgent(HttpContext.Current.Request);
 404             if (String.IsNullOrEmpty(ua)) {
 405                 return null;
 406             }
 407
 408             // Adding timeout for Regex in case of malicious UA string causing DoS
 409             Regex regex = RegexUtil.CreateRegex("\\.NET CLR (?'clrVersion'[0-9\\.]*)", RegexOptions.None);
 410             MatchCollection matches = regex.Matches(ua);
 411
 412             if (matches.Count == 0) {
 413                 return new Version[1] { new Version() };
 414             }
 415
 416             ArrayList versionList = new ArrayList();
 417             foreach (Match match in matches) {
 418                 try {
 419                     Version version = new Version(match.Groups["clrVersion"].Value);
 420                     versionList.Add(version);
 421                 }
 422                 catch (System.FormatException) {
 423                     //got imvalid version data
 424                 }
 425             }
 426             versionList.Sort();
 427
 428             return (Version[])versionList.ToArray(typeof(Version));
 429         }
 430
 431         public string Type {
 432             get {
 433                 if (!_havetype) {
 434                     _type = this["type"];
 435                     _havetype = true;
 436                 }
 437                 return _type;
 438             }
 439         }
 440
 441         public string Browser {
 442             get {
 443                 if (!_havebrowser) {
 444                     _browser = this["browser"];
 445                     _havebrowser = true;
 446                 }
 447                 return _browser;
 448             }
 449         }
 450
 451         public string Version {
 452             get {
 453                 if (!_haveversion) {
 454                     _version = this["version"];
 455                     _haveversion = true;
 456                 }
 457                 return _version;
 458             }
 459         }
 460
 461         public int MajorVersion {
 462             get {
 463                 if (!_havemajorversion) {
 464                     try {
 465                         _majorversion = int.Parse(this["majorversion"], CultureInfo.InvariantCulture);
 466                         _havemajorversion = true;
 467                     }
 468                     catch (FormatException e) {
 469                         throw BuildParseError(e, "majorversion");
 470                     }
 471                 }
 472                 return _majorversion;
 473             }
 474         }
 475
 476         Exception BuildParseError(Exception e, string capsKey) {
 477             string message = SR.GetString(SR.Invalid_string_from_browser_caps, e.Message, capsKey, this[capsKey]);
 478
 479             // to show ConfigurationException in stack trace
 480             ConfigurationErrorsException configEx = new ConfigurationErrorsException(message, e);
 481
 482             // I want it to look like an unhandled exception
 483             HttpUnhandledException httpUnhandledEx = new HttpUnhandledException(null, null);
 484
 485             // but show message from outer exception (it normally shows the inner-most)
 486             httpUnhandledEx.SetFormatter(new UseLastUnhandledErrorFormatter(configEx));
 487
 488             return httpUnhandledEx;
 489         }
 490
 491         bool CapsParseBoolDefault(string capsKey, bool defaultValue) {
 492             string value = this[capsKey];
 493             if (value == null) {
 494                 return defaultValue;
 495             }
 496
 497             try {
 498                 return bool.Parse(value);
 499             }
 500             catch (FormatException) {
 501                 return defaultValue;
 502             }
 503         }
 504
 505         bool CapsParseBool(string capsKey) {
 506             try {
 507                 return bool.Parse(this[capsKey]);
 508             }
 509             catch (FormatException e) {
 510                 throw BuildParseError(e, capsKey);
 511             }
 512         }
 513
 514         public string MinorVersionString {
 515             get {
 516                 return this["minorversion"];
 517             }
 518         }
 519
 520         public double MinorVersion {
 521             get {
 522                 if (!_haveminorversion) {
 523                     lock(_staticLock) {
 524                         if (!_haveminorversion)
 525                         {
 526
 527                             try
 528                             {
 529                                 // see ASURT 11176
 530                                 _minorversion = double.Parse(
 531                                     this["minorversion"],
 532                                     NumberStyles.Float | NumberStyles.AllowDecimalPoint,
 533                                     NumberFormatInfo.InvariantInfo);
 534                                 _haveminorversion = true;
 535                             }
 536                             catch (FormatException e)
 537                             {
 538                                 // Check if there's more than one decimal
 539                                 // The only exception case we handle is of form .4.1, it becomes .4
 540                                 string minor = this["minorversion"];
 541                                 int firstDecimal = minor.IndexOf('.');
 542                                 if (firstDecimal != -1)
 543                                 {
 544                                     int nextDecimal = minor.IndexOf('.', firstDecimal + 1);
 545                                     if (nextDecimal != -1)
 546                                     {
 547                                         try
 548                                         {
 549                                             _minorversion = double.Parse(
 550                                                 minor.Substring(0, nextDecimal),
 551                                                 NumberStyles.Float | NumberStyles.AllowDecimalPoint,
 552                                                 NumberFormatInfo.InvariantInfo);
 553                                             Thread.MemoryBarrier();
 554                                             _haveminorversion = true;
 555                                         }
 556                                         catch (FormatException)
 557                                         {
 558                                         }
 559                                     }
 560                                 }
 561                                 if (!_haveminorversion)
 562                                 {
 563                                     throw BuildParseError(e, "minorversion");
 564                                 }
 565                             }
 566                         }
 567                     }
 568                 }
 569                 return _minorversion;
 570             }
 571         }
 572
 573         public string Platform {
 574             get {
 575                 if (!_haveplatform) {
 576                     _platform = this["platform"];
 577                     _haveplatform = true;
 578                 }
 579                 return _platform;
 580             }
 581         }
 582
 583         public Type TagWriter {
 584             get {
 585                 try {
 586                     if (!_havetagwriter) {
 587                         string tagWriter = this["tagwriter"];
 588                         if (String.IsNullOrEmpty(tagWriter)) {
 589                             _tagwriter = null;
 590                         }
 591                         else if (string.Compare(tagWriter, typeof(System.Web.UI.HtmlTextWriter).FullName, StringComparison.Ordinal) == 0) {
 592                             _tagwriter = typeof(System.Web.UI.HtmlTextWriter);
 593                         }
 594                         else {
 595                             _tagwriter = BuildManager.GetType(tagWriter, true /*throwOnError*/);
 596                         }
 597                         _havetagwriter = true;
 598                     }
 599                 }
 600                 catch (Exception e) {
 601                     throw BuildParseError(e, "tagwriter");
 602                 }
 603
 604                 return _tagwriter;
 605             }
 606         }
 607         public Version EcmaScriptVersion {
 608             get {
 609                 if (!_haveecmascriptversion) {
 610                     _ecmascriptversion = new Version(this["ecmascriptversion"]);
 611                     _haveecmascriptversion = true;
 612                 }
 613                 return _ecmascriptversion;
 614             }
 615         }
 616
 617         public Version MSDomVersion {
 618             get {
 619                 if (!_havemsdomversion) {
 620                     _msdomversion = new Version(this["msdomversion"]);
 621                     _havemsdomversion = true;
 622                 }
 623                 return _msdomversion;
 624             }
 625         }
 626
 627         public Version W3CDomVersion {
 628             get {
 629                 if (!_havew3cdomversion) {
 630                     _w3cdomversion = new Version(this["w3cdomversion"]);
 631                     _havew3cdomversion = true;
 632                 }
 633                 return _w3cdomversion;
 634             }
 635         }
 636
 637         public bool Beta {
 638             get {
 639                 if (!_havebeta) {
 640                     _beta = CapsParseBool("beta");
 641                     _havebeta = true;
 642                 }
 643                 return _beta;
 644             }
 645         }
 646
 647         public bool Crawler {
 648             get {
 649                 if (!_havecrawler) {
 650                     _crawler = CapsParseBool("crawler");
 651                     _havecrawler = true;
 652                 }
 653                 return _crawler;
 654             }
 655         }
 656
 657         public bool AOL {
 658             get {
 659                 if (!_haveaol) {
 660                     _aol = CapsParseBool("aol");
 661                     _haveaol = true;
 662                 }
 663                 return _aol;
 664             }
 665         }
 666
 667         public bool Win16 {
 668             get {
 669                 if (!_havewin16) {
 670                     _win16 = CapsParseBool("win16");
 671                     _havewin16 = true;
 672                 }
 673                 return _win16;
 674             }
 675         }
 676
 677         public bool Win32 {
 678             get {
 679                 if (!_havewin32) {
 680                     _win32 = CapsParseBool("win32");
 681                     _havewin32 = true;
 682                 }
 683                 return _win32;
 684             }
 685         }
 686
 687         public bool Frames {
 688             get {
 689                 if (!_haveframes) {
 690                     _frames = CapsParseBool("frames");
 691                     _haveframes = true;
 692                 }
 693                 return _frames;
 694             }
 695         }
 696
 697         public bool RequiresControlStateInSession {
 698             get {
 699                 if (!_haverequiresControlStateInSession) {
 700                     if (this["requiresControlStateInSession"] != null) {
 701                         _requiresControlStateInSession = CapsParseBoolDefault("requiresControlStateInSession", false);
 702                     }
 703                     _haverequiresControlStateInSession = true;
 704                 }
 705                 return _requiresControlStateInSession;
 706             }
 707         }
 708
 709         public bool Tables {
 710             get {
 711                 if (!_havetables) {
 712                     _tables = CapsParseBool("tables");
 713                     _havetables = true;
 714                 }
 715                 return _tables;
 716             }
 717         }
 718
 719         public bool Cookies {
 720             get {
 721                 if (!_havecookies) {
 722                     _cookies = CapsParseBool("cookies");
 723                     _havecookies = true;
 724                 }
 725                 return _cookies;
 726             }
 727         }
 728
 729         public bool VBScript {
 730             get {
 731                 if (!_havevbscript) {
 732                     _vbscript = CapsParseBool("vbscript");
 733                     _havevbscript = true;
 734                 }
 735                 return _vbscript;
 736             }
 737         }
 738
 739         [Obsolete("The recommended alternative is the EcmaScriptVersion property. A Major version value greater than or equal to 1 implies JavaScript support. http://go.microsoft.com/fwlink/?linkid=14202")]
 740         public bool JavaScript {
 741             get {
 742                 if (!_havejavascript) {
 743                     _javascript = CapsParseBool("javascript");
 744                     _havejavascript = true;
 745                 }
 746                 return _javascript;
 747             }
 748         }
 749
 750         public bool JavaApplets {
 751             get {
 752                 if (!_havejavaapplets) {
 753                     _javaapplets = CapsParseBool("javaapplets");
 754                     _havejavaapplets = true;
 755                 }
 756                 return _javaapplets;
 757             }
 758         }
 759
 760         public Version JScriptVersion {
 761             get {
 762                 if (!_havejscriptversion) {
 763                     _jscriptversion = new Version(this["jscriptversion"]);
 764                     _havejscriptversion = true;
 765                 }
 766                 return _jscriptversion;
 767             }
 768         }
 769
 770         public bool ActiveXControls {
 771             get {
 772                 if (!_haveactivexcontrols) {
 773                     _activexcontrols = CapsParseBool("activexcontrols");
 774                     _haveactivexcontrols = true;
 775                 }
 776                 return _activexcontrols;
 777             }
 778         }
 779
 780         public bool BackgroundSounds {
 781             get {
 782                 if (!_havebackgroundsounds) {
 783                     _backgroundsounds = CapsParseBool("backgroundsounds");
 784                     _havebackgroundsounds = true;
 785                 }
 786                 return _backgroundsounds;
 787             }
 788         }
 789
 790         public bool CDF {
 791             get {
 792                 if (!_havecdf) {
 793                     _cdf = CapsParseBool("cdf");
 794                     _havecdf = true;
 795                 }
 796                 return _cdf;
 797             }
 798         }
 799
 800         //previously in System.Web.Mobile
 801         public virtual String MobileDeviceManufacturer {
 802             get {
 803                 if (!_haveMobileDeviceManufacturer) {
 804                     _mobileDeviceManufacturer = this["mobileDeviceManufacturer"];
 805                     _haveMobileDeviceManufacturer = true;
 806                 }
 807                 return _mobileDeviceManufacturer;
 808             }
 809         }
 810
 811
 812         public virtual String MobileDeviceModel {
 813             get {
 814                 if (!_haveMobileDeviceModel) {
 815                     _mobileDeviceModel = this["mobileDeviceModel"];
 816                     _haveMobileDeviceModel = true;
 817                 }
 818                 return _mobileDeviceModel;
 819             }
 820         }
 821
 822
 823         public virtual String GatewayVersion {
 824             get {
 825                 if (!_haveGatewayVersion) {
 826                     _gatewayVersion = this["gatewayVersion"];
 827                     _haveGatewayVersion = true;
 828                 }
 829                 return _gatewayVersion;
 830             }
 831         }
 832
 833
 834         public virtual int GatewayMajorVersion {
 835             get {
 836                 if (!_haveGatewayMajorVersion) {
 837                     _gatewayMajorVersion = Convert.ToInt32(this["gatewayMajorVersion"], CultureInfo.InvariantCulture);
 838                     _haveGatewayMajorVersion = true;
 839                 }
 840                 return _gatewayMajorVersion;
 841             }
 842         }
 843
 844
 845         public virtual double GatewayMinorVersion {
 846             get {
 847                 if (!_haveGatewayMinorVersion) {
 848                     // The conversion below does not use Convert.ToDouble()
 849                     // because it depends on the current locale.  So a german machine it would look for
 850                     // a comma as a seperator "1,5" where all user-agent strings use english
 851                     // decimal points "1.5".  URT11176
 852                     //
 853                     _gatewayMinorVersion = double.Parse(
 854                                         this["gatewayMinorVersion"],
 855                                         NumberStyles.Float | NumberStyles.AllowDecimalPoint,
 856                                         NumberFormatInfo.InvariantInfo);
 857                     _haveGatewayMinorVersion = true;
 858                 }
 859                 return _gatewayMinorVersion;
 860             }
 861         }
 862
 863         public virtual String PreferredRenderingType {
 864             get {
 865                 if (!_havePreferredRenderingType) {
 866                     _preferredRenderingType = this["preferredRenderingType"];
 867                     _havePreferredRenderingType = true;
 868                 }
 869                 return _preferredRenderingType;
 870             }
 871         }
 872
 873
 874         public virtual String PreferredRequestEncoding {
 875             get {
 876                 if (!_havePreferredRequestEncoding) {
 877                     _preferredRequestEncoding = this["preferredRequestEncoding"];
 878                     Thread.MemoryBarrier();
 879                     _havePreferredRequestEncoding = true;
 880                 }
 881                 return _preferredRequestEncoding;
 882             }
 883         }
 884
 885
 886         public virtual String PreferredResponseEncoding {
 887             get {
 888                 if (!_havePreferredResponseEncoding) {
 889                     _preferredResponseEncoding = this["preferredResponseEncoding"];
 890                     _havePreferredResponseEncoding = true;
 891                 }
 892                 return _preferredResponseEncoding;
 893             }
 894         }
 895
 896
 897         public virtual String PreferredRenderingMime {
 898             get {
 899                 if (!_havePreferredRenderingMime) {
 900                     _preferredRenderingMime = this["preferredRenderingMime"];
 901                     _havePreferredRenderingMime = true;
 902                 }
 903                 return _preferredRenderingMime;
 904             }
 905         }
 906
 907
 908         public virtual String PreferredImageMime {
 909             get {
 910                 if (!_havePreferredImageMime) {
 911                     _preferredImageMime = this["preferredImageMime"];
 912                     _havePreferredImageMime = true;
 913                 }
 914                 return _preferredImageMime;
 915             }
 916         }
 917
 918
 919         public virtual int ScreenCharactersWidth {
 920             get {
 921                 if (!_haveScreenCharactersWidth) {
 922                     if (this["screenCharactersWidth"] == null) {
 923                         // calculate from best partial information
 924
 925                         int screenPixelsWidthToUse = 640;
 926                         int characterWidthToUse = 8;
 927
 928                         if (this["screenPixelsWidth"] != null && this["characterWidth"] != null) {
 929                             screenPixelsWidthToUse = Convert.ToInt32(this["screenPixelsWidth"], CultureInfo.InvariantCulture);
 930                             characterWidthToUse = Convert.ToInt32(this["characterWidth"], CultureInfo.InvariantCulture);
 931                         }
 932                         else if (this["screenPixelsWidth"] != null) {
 933                             screenPixelsWidthToUse = Convert.ToInt32(this["screenPixelsWidth"], CultureInfo.InvariantCulture);
 934                             characterWidthToUse = Convert.ToInt32(this["defaultCharacterWidth"], CultureInfo.InvariantCulture);
 935                         }
 936                         else if (this["characterWidth"] != null) {
 937                             screenPixelsWidthToUse = Convert.ToInt32(this["defaultScreenPixelsWidth"], CultureInfo.InvariantCulture);
 938                             characterWidthToUse = Convert.ToInt32(this["characterWidth"], CultureInfo.InvariantCulture);
 939                         }
 940                         else if (this["defaultScreenCharactersWidth"] != null) {
 941                             screenPixelsWidthToUse = Convert.ToInt32(this["defaultScreenCharactersWidth"], CultureInfo.InvariantCulture);
 942                             characterWidthToUse = 1;
 943                         }
 944
 945                         _screenCharactersWidth = screenPixelsWidthToUse / characterWidthToUse;
 946                     }
 947                     else {
 948                         _screenCharactersWidth = Convert.ToInt32(this["screenCharactersWidth"], CultureInfo.InvariantCulture);
 949                     }
 950                     _haveScreenCharactersWidth = true;
 951                 }
 952                 return _screenCharactersWidth;
 953             }
 954         }
 955
 956
 957         public virtual int ScreenCharactersHeight {
 958             get {
 959                 if (!_haveScreenCharactersHeight) {
 960                     if (this["screenCharactersHeight"] == null) {
 961                         // calculate from best partial information
 962
 963                         int screenPixelHeightToUse = 480;
 964                         int characterHeightToUse = 12;
 965
 966                         if (this["screenPixelsHeight"] != null && this["characterHeight"] != null) {
 967                             screenPixelHeightToUse = Convert.ToInt32(this["screenPixelsHeight"], CultureInfo.InvariantCulture);
 968                             characterHeightToUse = Convert.ToInt32(this["characterHeight"], CultureInfo.InvariantCulture);
 969                         }
 970                         else if (this["screenPixelsHeight"] != null) {
 971                             screenPixelHeightToUse = Convert.ToInt32(this["screenPixelsHeight"], CultureInfo.InvariantCulture);
 972                             characterHeightToUse = Convert.ToInt32(this["defaultCharacterHeight"], CultureInfo.InvariantCulture);
 973                         }
 974                         else if (this["characterHeight"] != null) {
 975                             screenPixelHeightToUse = Convert.ToInt32(this["defaultScreenPixelsHeight"], CultureInfo.InvariantCulture);
 976                             characterHeightToUse = Convert.ToInt32(this["characterHeight"], CultureInfo.InvariantCulture);
 977                         }
 978                         else if (this["defaultScreenCharactersHeight"] != null) {
 979                             screenPixelHeightToUse = Convert.ToInt32(this["defaultScreenCharactersHeight"], CultureInfo.InvariantCulture);
 980                             characterHeightToUse = 1;
 981                         }
 982
 983                         _screenCharactersHeight = screenPixelHeightToUse / characterHeightToUse;
 984                     }
 985                     else {
 986                         _screenCharactersHeight = Convert.ToInt32(this["screenCharactersHeight"], CultureInfo.InvariantCulture);
 987                     }
 988                     _haveScreenCharactersHeight = true;
 989                 }
 990                 return _screenCharactersHeight;
 991             }
 992         }
 993
 994
 995         public virtual int ScreenPixelsWidth {
 996             get {
 997                 if (!_haveScreenPixelsWidth) {
 998                     if (this["screenPixelsWidth"] == null) {
 999                         // calculate from best partial information
1000
1001                         int screenCharactersWidthToUse = 80;
1002                         int characterWidthToUse = 8;
1003
1004                         if (this["screenCharactersWidth"] != null && this["characterWidth"] != null) {
1005                             screenCharactersWidthToUse = Convert.ToInt32(this["screenCharactersWidth"], CultureInfo.InvariantCulture);
1006                             characterWidthToUse = Convert.ToInt32(this["characterWidth"], CultureInfo.InvariantCulture);
1007                         }
1008                         else if (this["screenCharactersWidth"] != null) {
1009                             screenCharactersWidthToUse = Convert.ToInt32(this["screenCharactersWidth"], CultureInfo.InvariantCulture);
1010                             characterWidthToUse = Convert.ToInt32(this["defaultCharacterWidth"], CultureInfo.InvariantCulture);
1011                         }
1012                         else if (this["characterWidth"] != null) {
1013                             screenCharactersWidthToUse = Convert.ToInt32(this["defaultScreenCharactersWidth"], CultureInfo.InvariantCulture);
1014                             characterWidthToUse = Convert.ToInt32(this["characterWidth"], CultureInfo.InvariantCulture);
1015                         }
1016                         else if (this["defaultScreenPixelsWidth"] != null) {
1017                             screenCharactersWidthToUse = Convert.ToInt32(this["defaultScreenPixelsWidth"], CultureInfo.InvariantCulture);
1018                             characterWidthToUse = 1;
1019                         }
1020
1021                         _screenPixelsWidth = screenCharactersWidthToUse * characterWidthToUse;
1022                     }
1023                     else {
1024                         _screenPixelsWidth = Convert.ToInt32(this["screenPixelsWidth"], CultureInfo.InvariantCulture);
1025                     }
1026                     _haveScreenPixelsWidth = true;
1027                 }
1028                 return _screenPixelsWidth;
1029             }
1030         }
1031
1032
1033         public virtual int ScreenPixelsHeight {
1034             get {
1035                 if (!_haveScreenPixelsHeight) {
1036                     if (this["screenPixelsHeight"] == null) {
1037                         int screenCharactersHeightToUse = 480 / 12;
1038                         int characterHeightToUse = 12;
1039
1040                         if (this["screenCharactersHeight"] != null && this["characterHeight"] != null) {
1041                             screenCharactersHeightToUse = Convert.ToInt32(this["screenCharactersHeight"], CultureInfo.InvariantCulture);
1042                             characterHeightToUse = Convert.ToInt32(this["characterHeight"], CultureInfo.InvariantCulture);
1043                         }
1044                         else if (this["screenCharactersHeight"] != null) {
1045                             screenCharactersHeightToUse = Convert.ToInt32(this["screenCharactersHeight"], CultureInfo.InvariantCulture);
1046                             characterHeightToUse = Convert.ToInt32(this["defaultCharacterHeight"], CultureInfo.InvariantCulture);
1047                         }
1048                         else if (this["characterHeight"] != null) {
1049                             screenCharactersHeightToUse = Convert.ToInt32(this["defaultScreenCharactersHeight"], CultureInfo.InvariantCulture);
1050                             characterHeightToUse = Convert.ToInt32(this["characterHeight"], CultureInfo.InvariantCulture);
1051                         }
1052                         else if (this["defaultScreenPixelsHeight"] != null) {
1053                             screenCharactersHeightToUse = Convert.ToInt32(this["defaultScreenPixelsHeight"], CultureInfo.InvariantCulture);
1054                             characterHeightToUse = 1;
1055                         }
1056
1057                         _screenPixelsHeight = screenCharactersHeightToUse * characterHeightToUse;
1058                     }
1059                     else {
1060                         _screenPixelsHeight = Convert.ToInt32(this["screenPixelsHeight"], CultureInfo.InvariantCulture);
1061                     }
1062                     _haveScreenPixelsHeight = true;
1063                 }
1064                 return _screenPixelsHeight;
1065             }
1066         }
1067
1068
1069         public virtual int ScreenBitDepth {
1070             get {
1071                 if (!_haveScreenBitDepth) {
1072                     _screenBitDepth = Convert.ToInt32(this["screenBitDepth"], CultureInfo.InvariantCulture);
1073                     _haveScreenBitDepth = true;
1074                 }
1075                 return _screenBitDepth;
1076             }
1077         }
1078
1079
1080         public virtual bool IsColor {
1081             get {
1082                 if (!_haveIsColor) {
1083                     String isColorString = this["isColor"];
1084                     if (isColorString == null) {
1085                         _isColor = false;
1086                     }
1087                     else {
1088                         _isColor = Convert.ToBoolean(this["isColor"], CultureInfo.InvariantCulture);
1089                     }
1090                     _haveIsColor = true;
1091                 }
1092                 return _isColor;
1093             }
1094         }
1095
1096
1097         public virtual String InputType {
1098             get {
1099                 if (!_haveInputType) {
1100                     _inputType = this["inputType"];
1101                     _haveInputType = true;
1102                 }
1103                 return _inputType;
1104             }
1105         }
1106
1107
1108         public virtual int NumberOfSoftkeys {
1109             get {
1110                 if (!_haveNumberOfSoftkeys) {
1111                     _numberOfSoftkeys = Convert.ToInt32(this["numberOfSoftkeys"], CultureInfo.InvariantCulture);
1112                     _haveNumberOfSoftkeys = true;
1113                 }
1114                 return _numberOfSoftkeys;
1115             }
1116         }
1117
1118
1119         public virtual int MaximumSoftkeyLabelLength {
1120             get {
1121                 if (!_haveMaximumSoftkeyLabelLength) {
1122                     _maximumSoftkeyLabelLength = Convert.ToInt32(this["maximumSoftkeyLabelLength"], CultureInfo.InvariantCulture);
1123                     _haveMaximumSoftkeyLabelLength = true;
1124                 }
1125                 return _maximumSoftkeyLabelLength;
1126             }
1127         }
1128
1129
1130         public virtual bool CanInitiateVoiceCall {
1131             get {
1132                 if (!_haveCanInitiateVoiceCall) {
1133                     _canInitiateVoiceCall = CapsParseBoolDefault("canInitiateVoiceCall", false);
1134                     _haveCanInitiateVoiceCall = true;
1135                 }
1136                 return _canInitiateVoiceCall;
1137             }
1138         }
1139
1140
1141         public virtual bool CanSendMail {
1142             get {
1143                 if (!_haveCanSendMail) {
1144                     _canSendMail = CapsParseBoolDefault("canSendMail", true);
1145                     _haveCanSendMail = true;
1146                 }
1147                 return _canSendMail;
1148             }
1149         }
1150
1151         public virtual bool HasBackButton {
1152             get {
1153                 if (!_haveHasBackButton) {
1154                     _hasBackButton = CapsParseBoolDefault("hasBackButton", true);
1155                     _haveHasBackButton = true;
1156                 }
1157                 return _hasBackButton;
1158             }
1159         }
1160
1161         public virtual bool RendersWmlDoAcceptsInline {
1162             get {
1163                 if (!_haveRendersWmlDoAcceptsInline) {
1164                     _rendersWmlDoAcceptsInline = CapsParseBoolDefault("rendersWmlDoAcceptsInline", true);
1165                     _haveRendersWmlDoAcceptsInline = true;
1166                 }
1167                 return _rendersWmlDoAcceptsInline;
1168             }
1169         }
1170
1171         public virtual bool RendersWmlSelectsAsMenuCards {
1172             get {
1173                 if (!_haveRendersWmlSelectsAsMenuCards) {
1174                     _rendersWmlSelectsAsMenuCards = CapsParseBoolDefault("rendersWmlSelectsAsMenuCards", false);
1175                     _haveRendersWmlSelectsAsMenuCards = true;
1176                 }
1177                 return _rendersWmlSelectsAsMenuCards;
1178             }
1179         }
1180
1181         public virtual bool RendersBreaksAfterWmlAnchor {
1182             get {
1183                 if (!_haveRendersBreaksAfterWmlAnchor) {
1184                     _rendersBreaksAfterWmlAnchor = CapsParseBoolDefault("rendersBreaksAfterWmlAnchor", true);
1185                     _haveRendersBreaksAfterWmlAnchor = true;
1186                 }
1187                 return _rendersBreaksAfterWmlAnchor;
1188             }
1189         }
1190
1191         public virtual bool RendersBreaksAfterWmlInput {
1192             get {
1193                 if (!_haveRendersBreaksAfterWmlInput) {
1194                     _rendersBreaksAfterWmlInput = CapsParseBoolDefault("rendersBreaksAfterWmlInput", true);
1195                     _haveRendersBreaksAfterWmlInput = true;
1196                 }
1197                 return _rendersBreaksAfterWmlInput;
1198             }
1199         }
1200
1201         public virtual bool RendersBreakBeforeWmlSelectAndInput {
1202             get {
1203                 if (!_haveRendersBreakBeforeWmlSelectAndInput) {
1204                     _rendersBreakBeforeWmlSelectAndInput = CapsParseBoolDefault("rendersBreakBeforeWmlSelectAndInput", false);
1205                     _haveRendersBreakBeforeWmlSelectAndInput = true;
1206                 }
1207                 return _rendersBreakBeforeWmlSelectAndInput;
1208             }
1209         }
1210
1211         public virtual bool RequiresPhoneNumbersAsPlainText {
1212             get {
1213                 if (!_haveRequiresPhoneNumbersAsPlainText) {
1214                     _requiresPhoneNumbersAsPlainText = CapsParseBoolDefault("requiresPhoneNumbersAsPlainText", false);
1215                     _haveRequiresPhoneNumbersAsPlainText = true;
1216                 }
1217                 return _requiresPhoneNumbersAsPlainText;
1218             }
1219         }
1220
1221         public virtual bool RequiresUrlEncodedPostfieldValues {
1222             get {
1223                 if (!_haveRequiresUrlEncodedPostfieldValues) {
1224                     _requiresUrlEncodedPostfieldValues = CapsParseBoolDefault("requiresUrlEncodedPostfieldValues", true);
1225                     _haveRequiresUrlEncodedPostfieldValues = true;
1226                 }
1227                 return _requiresUrlEncodedPostfieldValues;
1228             }
1229         }
1230
1231         public virtual String RequiredMetaTagNameValue {
1232             get {
1233                 if (!_haveRequiredMetaTagNameValue) {
1234                     String value = this["requiredMetaTagNameValue"];
1235                     if (!String.IsNullOrEmpty(value)) {
1236                         _requiredMetaTagNameValue = value;
1237                     }
1238                     else {
1239                         _requiredMetaTagNameValue = null;
1240                     }
1241                     _haveRequiredMetaTagNameValue = true;
1242                 }
1243                 return _requiredMetaTagNameValue;
1244             }
1245         }
1246
1247         public virtual bool RendersBreaksAfterHtmlLists {
1248             get {
1249                 if (!_haveRendersBreaksAfterHtmlLists) {
1250                     _rendersBreaksAfterHtmlLists = CapsParseBoolDefault("rendersBreaksAfterHtmlLists", true);
1251                     _haveRendersBreaksAfterHtmlLists = true;
1252                 }
1253                 return _rendersBreaksAfterHtmlLists;
1254             }
1255         }
1256
1257         public virtual bool RequiresUniqueHtmlInputNames {
1258             get {
1259                 if (!_haveRequiresUniqueHtmlInputNames) {
1260                     _requiresUniqueHtmlInputNames = CapsParseBoolDefault("requiresUniqueHtmlInputNames", false);
1261                     _haveRequiresUniqueHtmlInputNames = true;
1262                 }
1263                 return _requiresUniqueHtmlInputNames;
1264             }
1265         }
1266
1267         public virtual bool RequiresUniqueHtmlCheckboxNames {
1268             get {
1269                 if (!_haveRequiresUniqueHtmlCheckboxNames) {
1270                     _requiresUniqueHtmlCheckboxNames = CapsParseBoolDefault("requiresUniqueHtmlCheckboxNames", false);
1271                     _haveRequiresUniqueHtmlCheckboxNames = true;
1272                 }
1273                 return _requiresUniqueHtmlCheckboxNames;
1274             }
1275         }
1276
1277         public virtual bool SupportsCss {
1278             get {
1279                 if (!_haveSupportsCss) {
1280                     _supportsCss = CapsParseBoolDefault("supportsCss", false);
1281                     _haveSupportsCss = true;
1282                 }
1283                 return _supportsCss;
1284             }
1285         }
1286
1287         public virtual bool HidesRightAlignedMultiselectScrollbars {
1288             get {
1289                 if (!_haveHidesRightAlignedMultiselectScrollbars) {
1290                     _hidesRightAlignedMultiselectScrollbars = CapsParseBoolDefault("hidesRightAlignedMultiselectScrollbars", false);
1291                     _haveHidesRightAlignedMultiselectScrollbars = true;
1292                 }
1293                 return _hidesRightAlignedMultiselectScrollbars;
1294             }
1295         }
1296
1297         public virtual bool IsMobileDevice {
1298             get {
1299                 if (!_haveIsMobileDevice) {
1300                     _isMobileDevice = CapsParseBoolDefault("isMobileDevice", false);
1301                     _haveIsMobileDevice = true;
1302                 }
1303                 return _isMobileDevice;
1304             }
1305         }
1306
1307         public virtual bool RequiresAttributeColonSubstitution {
1308             get {
1309                 if (!_haveRequiresAttributeColonSubstitution) {
1310                     _requiresAttributeColonSubstitution = CapsParseBoolDefault("requiresAttributeColonSubstitution", false);
1311                     _haveRequiresAttributeColonSubstitution = true;
1312                 }
1313                 return _requiresAttributeColonSubstitution;
1314             }
1315         }
1316
1317         public virtual bool CanRenderOneventAndPrevElementsTogether {
1318             get {
1319                 if (!_haveCanRenderOneventAndPrevElementsTogether) {
1320                     _canRenderOneventAndPrevElementsTogether = CapsParseBoolDefault("canRenderOneventAndPrevElementsTogether", true);
1321                     _haveCanRenderOneventAndPrevElementsTogether = true;
1322                 }
1323                 return _canRenderOneventAndPrevElementsTogether;
1324             }
1325         }
1326
1327         public virtual bool CanRenderInputAndSelectElementsTogether {
1328             get {
1329                 if (!_haveCanRenderInputAndSelectElementsTogether) {
1330                     _canRenderInputAndSelectElementsTogether = CapsParseBoolDefault("canRenderInputAndSelectElementsTogether", true);
1331                     _haveCanRenderInputAndSelectElementsTogether = true;
1332                 }
1333                 return _canRenderInputAndSelectElementsTogether;
1334             }
1335         }
1336
1337         public virtual bool CanRenderAfterInputOrSelectElement {
1338             get {
1339                 if (!_haveCanRenderAfterInputOrSelectElement) {
1340                     _canRenderAfterInputOrSelectElement = CapsParseBoolDefault("canRenderAfterInputOrSelectElement", true);
1341                     _haveCanRenderAfterInputOrSelectElement = true;
1342                 }
1343                 return _canRenderAfterInputOrSelectElement;
1344             }
1345         }
1346
1347         public virtual bool CanRenderPostBackCards {
1348             get {
1349                 if (!_haveCanRenderPostBackCards) {
1350                     _canRenderPostBackCards = CapsParseBoolDefault("canRenderPostBackCards", true);
1351                     _haveCanRenderPostBackCards = true;
1352                 }
1353                 return _canRenderPostBackCards;
1354             }
1355         }
1356
1357         public virtual bool CanRenderMixedSelects {
1358             get {
1359                 if (!_haveCanRenderMixedSelects) {
1360                     _canRenderMixedSelects = CapsParseBoolDefault("canRenderMixedSelects", true);
1361                     _haveCanRenderMixedSelects = true;
1362                 }
1363                 return _canRenderMixedSelects;
1364             }
1365         }
1366
1367         public virtual bool CanCombineFormsInDeck {
1368             get {
1369                 if (!_haveCanCombineFormsInDeck) {
1370                     _canCombineFormsInDeck = CapsParseBoolDefault("canCombineFormsInDeck", true);
1371                     _haveCanCombineFormsInDeck = true;
1372                 }
1373                 return _canCombineFormsInDeck;
1374             }
1375         }
1376
1377         public virtual bool CanRenderSetvarZeroWithMultiSelectionList {
1378             get {
1379                 if (!_haveCanRenderSetvarZeroWithMultiSelectionList) {
1380                     _canRenderSetvarZeroWithMultiSelectionList = CapsParseBoolDefault("canRenderSetvarZeroWithMultiSelectionList", true);
1381                     _haveCanRenderSetvarZeroWithMultiSelectionList = true;
1382                 }
1383                 return _canRenderSetvarZeroWithMultiSelectionList;
1384             }
1385         }
1386
1387         public virtual bool SupportsImageSubmit {
1388             get {
1389                 if (!_haveSupportsImageSubmit) {
1390                     _supportsImageSubmit = CapsParseBoolDefault("supportsImageSubmit", false);
1391                     _haveSupportsImageSubmit = true;
1392                 }
1393                 return _supportsImageSubmit;
1394             }
1395         }
1396
1397         public virtual bool RequiresUniqueFilePathSuffix {
1398             get {
1399                 if (!_haveRequiresUniqueFilePathSuffix) {
1400                     _requiresUniqueFilePathSuffix = CapsParseBoolDefault("requiresUniqueFilePathSuffix", false);
1401                     _haveRequiresUniqueFilePathSuffix = true;
1402                 }
1403                 return _requiresUniqueFilePathSuffix;
1404             }
1405         }
1406
1407         public virtual bool RequiresNoBreakInFormatting {
1408             get {
1409                 if (!_haveRequiresNoBreakInFormatting) {
1410                     _requiresNoBreakInFormatting = CapsParseBoolDefault("requiresNoBreakInFormatting", false);
1411                     _haveRequiresNoBreakInFormatting = true;
1412                 }
1413                 return _requiresNoBreakInFormatting;
1414             }
1415         }
1416
1417         public virtual bool RequiresLeadingPageBreak {
1418             get {
1419                 if (!_haveRequiresLeadingPageBreak) {
1420                     _requiresLeadingPageBreak = CapsParseBoolDefault("requiresLeadingPageBreak", false);
1421                     _haveRequiresLeadingPageBreak = true;
1422                 }
1423                 return _requiresLeadingPageBreak;
1424             }
1425         }
1426
1427         public virtual bool SupportsSelectMultiple {
1428             get {
1429                 if (!_haveSupportsSelectMultiple) {
1430                     _supportsSelectMultiple = CapsParseBoolDefault("supportsSelectMultiple", false);
1431                     _haveSupportsSelectMultiple = true;
1432                 }
1433                 return _supportsSelectMultiple;
1434             }
1435         }
1436
1437         public /*new*/ virtual bool SupportsBold {
1438             get {
1439                 if (!_haveSupportsBold) {
1440                     _supportsBold = CapsParseBoolDefault("supportsBold", true);
1441                     _haveSupportsBold = true;
1442                 }
1443                 return _supportsBold;
1444             }
1445         }
1446
1447         public /*new*/ virtual bool SupportsItalic {
1448             get {
1449                 if (!_haveSupportsItalic) {
1450                     _supportsItalic = CapsParseBoolDefault("supportsItalic", true);
1451                     _haveSupportsItalic = true;
1452                 }
1453                 return _supportsItalic;
1454             }
1455         }
1456
1457         public virtual bool SupportsFontSize {
1458             get {
1459                 if (!_haveSupportsFontSize) {
1460                     _supportsFontSize = CapsParseBoolDefault("supportsFontSize", false);
1461                     _haveSupportsFontSize = true;
1462                 }
1463                 return _supportsFontSize;
1464             }
1465         }
1466
1467         public virtual bool SupportsFontName {
1468             get {
1469                 if (!_haveSupportsFontName) {
1470                     _supportsFontName = CapsParseBoolDefault("supportsFontName", false);
1471                     _haveSupportsFontName = true;
1472                 }
1473                 return _supportsFontName;
1474             }
1475         }
1476
1477         public virtual bool SupportsFontColor {
1478             get {
1479                 if (!_haveSupportsFontColor) {
1480                     _supportsFontColor = CapsParseBoolDefault("supportsFontColor", false);
1481                     _haveSupportsFontColor = true;
1482                 }
1483                 return _supportsFontColor;
1484             }
1485         }
1486
1487         public virtual bool SupportsBodyColor {
1488             get {
1489                 if (!_haveSupportsBodyColor) {
1490                     _supportsBodyColor = CapsParseBoolDefault("supportsBodyColor", false);
1491                     _haveSupportsBodyColor = true;
1492                 }
1493                 return _supportsBodyColor;
1494             }
1495         }
1496
1497         public virtual bool SupportsDivAlign {
1498             get {
1499                 if (!_haveSupportsDivAlign) {
1500                     _supportsDivAlign = CapsParseBoolDefault("supportsDivAlign", false);
1501                     _haveSupportsDivAlign = true;
1502                 }
1503                 return _supportsDivAlign;
1504             }
1505         }
1506
1507         public virtual bool SupportsDivNoWrap {
1508             get {
1509                 if (!_haveSupportsDivNoWrap) {
1510                     _supportsDivNoWrap = CapsParseBoolDefault("supportsDivNoWrap", false);
1511                     _haveSupportsDivNoWrap = true;
1512                 }
1513                 return _supportsDivNoWrap;
1514             }
1515         }
1516
1517         internal bool SupportsMaintainScrollPositionOnPostback {
1518             get {
1519                 if (!_haveSupportsMaintainScrollPositionOnPostback) {
1520                     _supportsMaintainScrollPositionOnPostback = CapsParseBoolDefault("supportsMaintainScrollPositionOnPostback", false);
1521                     _haveSupportsMaintainScrollPositionOnPostback = true;
1522                 }
1523                 return _supportsMaintainScrollPositionOnPostback;
1524             }
1525         }
1526
1527         public virtual bool RequiresContentTypeMetaTag {
1528             get {
1529                 if (!_haveRequiresContentTypeMetaTag) {
1530                     _requiresContentTypeMetaTag = CapsParseBoolDefault("requiresContentTypeMetaTag", false);
1531                     _haveRequiresContentTypeMetaTag = true;
1532                 }
1533                 return _requiresContentTypeMetaTag;
1534             }
1535         }
1536
1537         public virtual bool RequiresDBCSCharacter {
1538             get {
1539                 if (!_haveRequiresDBCSCharacter) {
1540                     _requiresDBCSCharacter = CapsParseBoolDefault("requiresDBCSCharacter", false);
1541                     _haveRequiresDBCSCharacter = true;
1542                 }
1543                 return _requiresDBCSCharacter;
1544             }
1545         }
1546
1547         public virtual bool RequiresHtmlAdaptiveErrorReporting {
1548             get {
1549                 if (!_haveRequiresHtmlAdaptiveErrorReporting) {
1550                     _requiresHtmlAdaptiveErrorReporting = CapsParseBoolDefault("requiresHtmlAdaptiveErrorReporting", false);
1551                     _haveRequiresHtmlAdaptiveErrorReporting = true;
1552                 }
1553                 return _requiresHtmlAdaptiveErrorReporting;
1554             }
1555         }
1556
1557         public virtual bool RequiresOutputOptimization {
1558             get {
1559                 if (!_haveRequiresOutputOptimization) {
1560                     _requiresOutputOptimization = CapsParseBoolDefault("requiresOutputOptimization", false);
1561                     _haveRequiresOutputOptimization = true;
1562                 }
1563                 return _requiresOutputOptimization;
1564             }
1565         }
1566
1567         public virtual bool SupportsAccesskeyAttribute {
1568             get {
1569                 if (!_haveSupportsAccesskeyAttribute) {
1570                     _supportsAccesskeyAttribute = CapsParseBoolDefault("supportsAccesskeyAttribute", false);
1571                     _haveSupportsAccesskeyAttribute = true;
1572                 }
1573                 return _supportsAccesskeyAttribute;
1574             }
1575         }
1576
1577         public virtual bool SupportsInputIStyle {
1578             get {
1579                 if (!_haveSupportsInputIStyle) {
1580                     _supportsInputIStyle = CapsParseBoolDefault("supportsInputIStyle", false);
1581                     _haveSupportsInputIStyle = true;
1582                 }
1583                 return _supportsInputIStyle;
1584             }
1585         }
1586
1587         public virtual bool SupportsInputMode {
1588             get {
1589                 if (!_haveSupportsInputMode) {
1590                     _supportsInputMode = CapsParseBoolDefault("supportsInputMode", false);
1591                     _haveSupportsInputMode = true;
1592                 }
1593                 return _supportsInputMode;
1594             }
1595         }
1596
1597         public virtual bool SupportsIModeSymbols {
1598             get {
1599                 if (!_haveSupportsIModeSymbols) {
1600                     _supportsIModeSymbols = CapsParseBoolDefault("supportsIModeSymbols", false);
1601                     _haveSupportsIModeSymbols = true;
1602                 }
1603                 return _supportsIModeSymbols;
1604             }
1605         }
1606
1607         public virtual bool SupportsJPhoneSymbols {
1608             get {
1609                 if (!_haveSupportsJPhoneSymbols) {
1610                     _supportsJPhoneSymbols = CapsParseBoolDefault("supportsJPhoneSymbols", false);
1611                     _haveSupportsJPhoneSymbols = true;
1612                 }
1613                 return _supportsJPhoneSymbols;
1614             }
1615         }
1616
1617         public virtual bool SupportsJPhoneMultiMediaAttributes {
1618             get {
1619                 if (!_haveSupportsJPhoneMultiMediaAttributes) {
1620                     _supportsJPhoneMultiMediaAttributes = CapsParseBoolDefault("supportsJPhoneMultiMediaAttributes", false);
1621                     _haveSupportsJPhoneMultiMediaAttributes = true;
1622                 }
1623                 return _supportsJPhoneMultiMediaAttributes;
1624             }
1625         }
1626
1627         public virtual int MaximumRenderedPageSize {
1628             get {
1629                 if (!_haveMaximumRenderedPageSize) {
1630                     _maximumRenderedPageSize = Convert.ToInt32(this["maximumRenderedPageSize"], CultureInfo.InvariantCulture);
1631                     _haveMaximumRenderedPageSize = true;
1632                 }
1633                 return _maximumRenderedPageSize;
1634             }
1635         }
1636
1637         public virtual bool RequiresSpecialViewStateEncoding {
1638             get {
1639                 if (!_haveRequiresSpecialViewStateEncoding) {
1640                     _requiresSpecialViewStateEncoding = CapsParseBoolDefault("requiresSpecialViewStateEncoding", false);
1641                     _haveRequiresSpecialViewStateEncoding = true;
1642                 }
1643                 return _requiresSpecialViewStateEncoding;
1644             }
1645         }
1646
1647         public virtual bool SupportsQueryStringInFormAction {
1648             get {
1649                 if (!_haveSupportsQueryStringInFormAction) {
1650                     _supportsQueryStringInFormAction = CapsParseBoolDefault("supportsQueryStringInFormAction", true);
1651                     _haveSupportsQueryStringInFormAction = true;
1652                 }
1653                 return _supportsQueryStringInFormAction;
1654             }
1655         }
1656
1657         public virtual bool SupportsCacheControlMetaTag {
1658             get {
1659                 if (!_haveSupportsCacheControlMetaTag) {
1660                     _supportsCacheControlMetaTag = CapsParseBoolDefault("supportsCacheControlMetaTag", true);
1661                     _haveSupportsCacheControlMetaTag = true;
1662                 }
1663                 return _supportsCacheControlMetaTag;
1664             }
1665         }
1666
1667         public virtual bool SupportsUncheck {
1668             get {
1669                 if (!_haveSupportsUncheck) {
1670                     _supportsUncheck = CapsParseBoolDefault("supportsUncheck", true);
1671                     _haveSupportsUncheck = true;
1672                 }
1673                 return _supportsUncheck;
1674             }
1675         }
1676
1677         public virtual bool CanRenderEmptySelects {
1678             get {
1679                 if (!_haveCanRenderEmptySelects) {
1680                     _canRenderEmptySelects = CapsParseBoolDefault("canRenderEmptySelects", true);
1681                     _haveCanRenderEmptySelects = true;
1682                 }
1683                 return _canRenderEmptySelects;
1684             }
1685         }
1686
1687         public virtual bool SupportsRedirectWithCookie {
1688             get {
1689                 if (!_haveSupportsRedirectWithCookie) {
1690                     _supportsRedirectWithCookie = CapsParseBoolDefault("supportsRedirectWithCookie", true);
1691                     _haveSupportsRedirectWithCookie = true;
1692                 }
1693                 return _supportsRedirectWithCookie;
1694             }
1695         }
1696
1697         public virtual bool SupportsEmptyStringInCookieValue {
1698             get {
1699                 if (!_haveSupportsEmptyStringInCookieValue) {
1700                     _supportsEmptyStringInCookieValue = CapsParseBoolDefault("supportsEmptyStringInCookieValue", true);
1701                     _haveSupportsEmptyStringInCookieValue = true;
1702                 }
1703                 return _supportsEmptyStringInCookieValue;
1704             }
1705         }
1706
1707         public virtual int DefaultSubmitButtonLimit {
1708             get {
1709                 if (!_haveDefaultSubmitButtonLimit) {
1710                     String s = this["defaultSubmitButtonLimit"];
1711                     _defaultSubmitButtonLimit = s != null ? Convert.ToInt32(this["defaultSubmitButtonLimit"], CultureInfo.InvariantCulture) : 1;
1712                     _haveDefaultSubmitButtonLimit = true;
1713                 }
1714                 return _defaultSubmitButtonLimit;
1715             }
1716         }
1717
1718         public virtual bool SupportsXmlHttp {
1719             get {
1720                 if (!_haveSupportsXmlHttp) {
1721                     _supportsXmlHttp = CapsParseBoolDefault("supportsXmlHttp", false);
1722                     _haveSupportsXmlHttp = true;
1723                 }
1724                 return _supportsXmlHttp;
1725             }
1726         }
1727
1728         public virtual bool SupportsCallback {
1729             get {
1730                 if (!_haveSupportsCallback) {
1731                     _supportsCallback = CapsParseBoolDefault("supportsCallback", false);
1732                     _haveSupportsCallback = true;
1733                 }
1734                 return _supportsCallback;
1735             }
1736         }
1737
1738         public virtual int MaximumHrefLength {
1739             get {
1740                 if (!_haveMaximumHrefLength) {
1741                     _maximumHrefLength = Convert.ToInt32(this["maximumHrefLength"], CultureInfo.InvariantCulture);
1742                     _haveMaximumHrefLength = true;
1743                 }
1744                 return _maximumHrefLength;
1745             }
1746         }
1747
1748         public bool IsBrowser(string browserName) {
1749             if (String.IsNullOrEmpty(browserName)) {
1750                 return false;
1751             }
1752
1753             if (_browsers == null) {
1754                 return false;
1755             }
1756
1757             for (int i = 0; i < _browsers.Count; i++) {
1758                 if (String.Equals(browserName, (string)_browsers[i], StringComparison.OrdinalIgnoreCase)) {
1759                     return true;
1760                 }
1761             }
1762
1763             return false;
1764         }
1765
1766         public void AddBrowser(string browserName) {
1767             if (_browsers == null) {
1768                 lock (_staticLock) {
1769                     if (_browsers == null) {
1770                         _browsers = new ArrayList(6);
1771                     }
1772                 }
1773             }
1774             _browsers.Add(browserName.ToLower(CultureInfo.InvariantCulture));
1775         }
1776
1777         private ArrayList _browsers;
1778
1779         volatile private string _type;
1780         volatile private string _browser;
1781         volatile private string _version;
1782         volatile private int _majorversion;
1783         private double _minorversion;
1784         volatile private string _platform;
1785         volatile private Type _tagwriter;
1786         volatile private Version _ecmascriptversion;
1787         volatile private Version _jscriptversion;
1788         volatile private Version _msdomversion;
1789         volatile private Version _w3cdomversion;
1790
1791         volatile private bool _beta;
1792         volatile private bool _crawler;
1793         volatile private bool _aol;
1794         volatile private bool _win16;
1795         volatile private bool _win32;
1796         volatile private bool _requiresControlStateInSession;
1797
1798         volatile private bool _frames;
1799         //private bool _supportsbold;
1800         //private bool _supportsitalic;
1801         volatile private bool _tables;
1802         volatile private bool _cookies;
1803         volatile private bool _vbscript;
1804         volatile private bool _javascript;
1805         volatile private bool _javaapplets;
1806         volatile private bool _activexcontrols;
1807         volatile private bool _backgroundsounds;
1808         volatile private bool _cdf;
1809
1810         volatile private bool _havetype;
1811         volatile private bool _havebrowser;
1812         volatile private bool _haveversion;
1813         volatile private bool _havemajorversion;
1814         volatile private bool _haveminorversion;
1815         volatile private bool _haveplatform;
1816         volatile private bool _havetagwriter;
1817         volatile private bool _haveecmascriptversion;
1818         volatile private bool _havemsdomversion;
1819         volatile private bool _havew3cdomversion;
1820
1821         volatile private bool _havebeta;
1822         volatile private bool _havecrawler;
1823         volatile private bool _haveaol;
1824         volatile private bool _havewin16;
1825         volatile private bool _havewin32;
1826
1827         volatile private bool _haveframes;
1828         volatile private bool _haverequiresControlStateInSession;
1829         //private bool _havesupportsbold;
1830         //private bool _havesupportsitalic;
1831         volatile private bool _havetables;
1832         volatile private bool _havecookies;
1833         volatile private bool _havevbscript;
1834         volatile private bool _havejavascript;
1835         volatile private bool _havejavaapplets;
1836         volatile private bool _haveactivexcontrols;
1837         volatile private bool _havebackgroundsounds;
1838         volatile private bool _havecdf;
1839
1840         //previously in System.Web.Mobile
1841         volatile private String _mobileDeviceManufacturer;
1842         volatile private String _mobileDeviceModel;
1843         volatile private String _gatewayVersion;
1844         volatile private int _gatewayMajorVersion;
1845         private double _gatewayMinorVersion;
1846         volatile private String _preferredRenderingType;     //
1847         volatile private String _preferredRenderingMime;
1848         volatile private String _preferredImageMime;
1849         volatile private String _requiredMetaTagNameValue;
1850         volatile private String _preferredRequestEncoding;
1851         volatile private String _preferredResponseEncoding;
1852         volatile private int _screenCharactersWidth;
1853         volatile private int _screenCharactersHeight;
1854         volatile private int _screenPixelsWidth;
1855         volatile private int _screenPixelsHeight;
1856         volatile private int _screenBitDepth;
1857         volatile private bool _isColor;
1858         volatile private String _inputType;
1859         volatile private int _numberOfSoftkeys;
1860         volatile private int _maximumSoftkeyLabelLength;
1861         volatile private bool _canInitiateVoiceCall;
1862         volatile private bool _canSendMail;
1863         volatile private bool _hasBackButton;
1864
1865         volatile private bool _rendersWmlDoAcceptsInline;
1866         volatile private bool _rendersWmlSelectsAsMenuCards;
1867         volatile private bool _rendersBreaksAfterWmlAnchor;
1868         volatile private bool _rendersBreaksAfterWmlInput;
1869         volatile private bool _rendersBreakBeforeWmlSelectAndInput;
1870         volatile private bool _requiresPhoneNumbersAsPlainText;
1871         volatile private bool _requiresAttributeColonSubstitution;
1872         volatile private bool _requiresUrlEncodedPostfieldValues;
1873         volatile private bool _rendersBreaksAfterHtmlLists;
1874         volatile private bool _requiresUniqueHtmlCheckboxNames;
1875         volatile private bool _requiresUniqueHtmlInputNames;
1876         volatile private bool _supportsCss;
1877         volatile private bool _hidesRightAlignedMultiselectScrollbars;
1878         volatile private bool _isMobileDevice;
1879         volatile private bool _canRenderOneventAndPrevElementsTogether;
1880         volatile private bool _canRenderInputAndSelectElementsTogether;
1881         volatile private bool _canRenderAfterInputOrSelectElement;
1882         volatile private bool _canRenderPostBackCards;
1883         volatile private bool _canRenderMixedSelects;
1884         volatile private bool _canCombineFormsInDeck;
1885         volatile private bool _canRenderSetvarZeroWithMultiSelectionList;
1886         volatile private bool _supportsImageSubmit;
1887         volatile private bool _requiresUniqueFilePathSuffix;
1888         volatile private bool _requiresNoBreakInFormatting;
1889         volatile private bool _requiresLeadingPageBreak;
1890         volatile private bool _supportsSelectMultiple;
1891         volatile private bool _supportsBold;
1892         volatile private bool _supportsItalic;
1893         volatile private bool _supportsFontSize;
1894         volatile private bool _supportsFontName;
1895         volatile private bool _supportsFontColor;
1896         volatile private bool _supportsBodyColor;
1897         volatile private bool _supportsDivAlign;
1898         volatile private bool _supportsDivNoWrap;
1899         volatile private bool _requiresHtmlAdaptiveErrorReporting;
1900         volatile private bool _requiresContentTypeMetaTag;
1901         volatile private bool _requiresDBCSCharacter;
1902         volatile private bool _requiresOutputOptimization;
1903         volatile private bool _supportsAccesskeyAttribute;
1904         volatile private bool _supportsInputIStyle;
1905         volatile private bool _supportsInputMode;
1906         volatile private bool _supportsIModeSymbols;
1907         volatile private bool _supportsJPhoneSymbols;
1908         volatile private bool _supportsJPhoneMultiMediaAttributes;
1909         volatile private int _maximumRenderedPageSize;
1910         volatile private bool _requiresSpecialViewStateEncoding;
1911         volatile private bool _supportsQueryStringInFormAction;
1912         volatile private bool _supportsCacheControlMetaTag;
1913         volatile private bool _supportsUncheck;
1914         volatile private bool _canRenderEmptySelects;
1915         volatile private bool _supportsRedirectWithCookie;
1916         volatile private bool _supportsEmptyStringInCookieValue;
1917         volatile private int _defaultSubmitButtonLimit;
1918         volatile private bool _supportsXmlHttp;
1919         volatile private bool _supportsCallback;
1920         volatile private bool _supportsMaintainScrollPositionOnPostback;
1921         volatile private int _maximumHrefLength;
1922
1923         volatile private bool _haveMobileDeviceManufacturer;
1924         volatile private bool _haveMobileDeviceModel;
1925         volatile private bool _haveGatewayVersion;
1926         volatile private bool _haveGatewayMajorVersion;
1927         volatile private bool _haveGatewayMinorVersion;
1928         volatile private bool _havePreferredRenderingType;
1929         volatile private bool _havePreferredRenderingMime;
1930         volatile private bool _havePreferredImageMime;
1931         volatile private bool _havePreferredRequestEncoding;
1932         volatile private bool _havePreferredResponseEncoding;
1933         volatile private bool _haveScreenCharactersWidth;
1934         volatile private bool _haveScreenCharactersHeight;
1935         volatile private bool _haveScreenPixelsWidth;
1936         volatile private bool _haveScreenPixelsHeight;
1937         volatile private bool _haveScreenBitDepth;
1938         volatile private bool _haveIsColor;
1939         volatile private bool _haveInputType;
1940         volatile private bool _haveNumberOfSoftkeys;
1941         volatile private bool _haveMaximumSoftkeyLabelLength;
1942         volatile private bool _haveCanInitiateVoiceCall;
1943         volatile private bool _haveCanSendMail;
1944         volatile private bool _haveHasBackButton;
1945         volatile private bool _haveRendersWmlDoAcceptsInline;
1946         volatile private bool _haveRendersWmlSelectsAsMenuCards;
1947         volatile private bool _haveRendersBreaksAfterWmlAnchor;
1948         volatile private bool _haveRendersBreaksAfterWmlInput;
1949         volatile private bool _haveRendersBreakBeforeWmlSelectAndInput;
1950         volatile private bool _haveRequiresPhoneNumbersAsPlainText;
1951         volatile private bool _haveRequiresUrlEncodedPostfieldValues;
1952         volatile private bool _haveRequiredMetaTagNameValue;
1953         volatile private bool _haveRendersBreaksAfterHtmlLists;
1954         volatile private bool _haveRequiresUniqueHtmlCheckboxNames;
1955         volatile private bool _haveRequiresUniqueHtmlInputNames;
1956         volatile private bool _haveSupportsCss;
1957         volatile private bool _haveHidesRightAlignedMultiselectScrollbars;
1958         volatile private bool _haveIsMobileDevice;
1959         volatile private bool _haveCanRenderOneventAndPrevElementsTogether;
1960         volatile private bool _haveCanRenderInputAndSelectElementsTogether;
1961         volatile private bool _haveCanRenderAfterInputOrSelectElement;
1962         volatile private bool _haveCanRenderPostBackCards;
1963         volatile private bool _haveCanCombineFormsInDeck;
1964         volatile private bool _haveCanRenderMixedSelects;
1965         volatile private bool _haveCanRenderSetvarZeroWithMultiSelectionList;
1966         volatile private bool _haveSupportsImageSubmit;
1967         volatile private bool _haveRequiresUniqueFilePathSuffix;
1968         volatile private bool _haveRequiresNoBreakInFormatting;
1969         volatile private bool _haveRequiresLeadingPageBreak;
1970         volatile private bool _haveSupportsSelectMultiple;
1971         volatile private bool _haveRequiresAttributeColonSubstitution;
1972         volatile private bool _haveRequiresHtmlAdaptiveErrorReporting;
1973         volatile private bool _haveRequiresContentTypeMetaTag;
1974         volatile private bool _haveRequiresDBCSCharacter;
1975         volatile private bool _haveRequiresOutputOptimization;
1976         volatile private bool _haveSupportsAccesskeyAttribute;
1977         volatile private bool _haveSupportsInputIStyle;
1978         volatile private bool _haveSupportsInputMode;
1979         volatile private bool _haveSupportsIModeSymbols;
1980         volatile private bool _haveSupportsJPhoneSymbols;
1981         volatile private bool _haveSupportsJPhoneMultiMediaAttributes;
1982         volatile private bool _haveSupportsRedirectWithCookie;
1983         volatile private bool _haveSupportsEmptyStringInCookieValue = false;
1984
1985         volatile private bool _haveSupportsBold;
1986         volatile private bool _haveSupportsItalic;
1987         volatile private bool _haveSupportsFontSize;
1988         volatile private bool _haveSupportsFontName;
1989         volatile private bool _haveSupportsFontColor;
1990         volatile private bool _haveSupportsBodyColor;
1991         volatile private bool _haveSupportsDivAlign;
1992         volatile private bool _haveSupportsDivNoWrap;
1993         volatile private bool _haveMaximumRenderedPageSize;
1994         volatile private bool _haveRequiresSpecialViewStateEncoding;
1995         volatile private bool _haveSupportsQueryStringInFormAction;
1996         volatile private bool _haveSupportsCacheControlMetaTag;
1997         volatile private bool _haveSupportsUncheck;
1998         volatile private bool _haveCanRenderEmptySelects;
1999         volatile private bool _haveDefaultSubmitButtonLimit;
2000         volatile private bool _haveSupportsXmlHttp;
2001         volatile private bool _haveSupportsCallback;
2002         volatile private bool _haveSupportsMaintainScrollPositionOnPostback;
2003         volatile private bool _haveMaximumHrefLength;
2004         volatile private bool _havejscriptversion;
2005
2006         #region IFilterResolutionService implementation
2007
2008         /// <internalonly/>
2009         bool IFilterResolutionService.EvaluateFilter(string filterName) {
2010             return IsBrowser(filterName);
2011         }
2012
2013         /// <internalonly/>
2014         int IFilterResolutionService.CompareFilters(string filter1, string filter2) {
2015             return BrowserCapabilitiesCompiler.BrowserCapabilitiesFactory.CompareFilters(filter1, filter2);
2016         }
2017         #endregion
2018
2019     }
2020 }