The Labs \ Source Viewer \ SSCLI \ System.Xml \ TriState

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XmlWriterSettings.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. using System;
  16. using System.Collections;
  17. using System.Text;
  18. using System.Xml;
  19. using System.Xml.Schema;
  20. namespace System.Xml
  21. {
  22.    
  23.     public enum XmlOutputMethod
  24.     {
  25.         Xml = 0,
  26.         // Use Xml 1.0 rules to serialize
  27.         Html = 1,
  28.         // Use Html rules specified by Xslt specification to serialize
  29.         Text = 2,
  30.         // Only serialize text blocks
  31.         AutoDetect = 3
  32.         // Choose between Xml and Html output methods at runtime (using Xslt rules to do so)
  33.     }
  34.    
  35.     internal enum XmlStandalone
  36.     {
  37.         // Do not change the constants - XmlBinaryWriter depends in it
  38.         Omit = 0,
  39.         Yes = 1,
  40.         No = 2
  41.     }
  42.    
  43.     /// <summary>
  44.     /// Three-state logic enumeration.
  45.     /// </summary>
  46.     internal enum TriState
  47.     {
  48.         Unknown = -1,
  49.         False = 0,
  50.         True = 1
  51.     }
  52.    
  53.    
  54.     // XmlReaderSettings class specifies features of an XmlWriter.
  55.     public sealed class XmlWriterSettings
  56.     {
  57.         //
  58.         // Fields
  59.         //
  60.         // Text settings
  61.         Encoding encoding;
  62.         bool omitXmlDecl;
  63.         NewLineHandling newLineHandling;
  64.         string newLineChars;
  65.         TriState indent;
  66.         string indentChars;
  67.         bool newLineOnAttributes;
  68.         bool closeOutput;
  69.        
  70.         // Conformance settings
  71.         ConformanceLevel conformanceLevel;
  72.         bool checkCharacters;
  73.        
  74.         // Xslt settings
  75.         XmlOutputMethod outputMethod;
  76.         IList cdataSections;
  77.         bool mergeCDataSections;
  78.         string mediaType;
  79.         string docTypeSystem;
  80.         string docTypePublic;
  81.         XmlStandalone standalone;
  82.         bool autoXmlDecl;
  83.        
  84.         // read-only flag
  85.         bool isReadOnly;
  86.        
  87.         //
  88.         // Constructor
  89.         //
  90.         public XmlWriterSettings()
  91.         {
  92.             Reset();
  93.         }
  94.        
  95.         //
  96.         // Properties
  97.         //
  98.         // Text
  99.         public Encoding Encoding {
  100.             get { return encoding; }
  101.             set {
  102.                 CheckReadOnly("Encoding");
  103.                 encoding = value;
  104.             }
  105.         }
  106.        
  107.         // True if an xml declaration should *not* be written.
  108.         public bool OmitXmlDeclaration {
  109.             get { return omitXmlDecl; }
  110.             set {
  111.                 CheckReadOnly("OmitXmlDeclaration");
  112.                 omitXmlDecl = value;
  113.             }
  114.         }
  115.        
  116.         // See NewLineHandling enum for details.
  117.         public NewLineHandling NewLineHandling {
  118.             get { return newLineHandling; }
  119.             set {
  120.                 CheckReadOnly("NewLineHandling");
  121.                
  122.                 if ((uint)value > (uint)NewLineHandling.None) {
  123.                     throw new ArgumentOutOfRangeException("value");
  124.                 }
  125.                 newLineHandling = value;
  126.             }
  127.         }
  128.        
  129.         // Line terminator string. By default, this is a carriage return followed by a line feed ("\r\n").
  130.         public string NewLineChars {
  131.             get { return newLineChars; }
  132.             set {
  133.                 CheckReadOnly("NewLineChars");
  134.                
  135.                 if (value == null) {
  136.                     throw new ArgumentNullException("value");
  137.                 }
  138.                 newLineChars = value;
  139.             }
  140.         }
  141.        
  142.         // True if output should be indented using rules that are appropriate to the output rules (i.e. Xml, Html, etc).
  143.         public bool Indent {
  144.             get { return indent == TriState.True; }
  145.             set {
  146.                 CheckReadOnly("Indent");
  147.                 indent = value ? TriState.True : TriState.False;
  148.             }
  149.         }
  150.        
  151.         // Characters to use when indenting. This is usually tab or some spaces, but can be anything.
  152.         public string IndentChars {
  153.             get { return indentChars; }
  154.             set {
  155.                 CheckReadOnly("IndentChars");
  156.                
  157.                 if (value == null) {
  158.                     throw new ArgumentNullException("value");
  159.                 }
  160.                 indentChars = value;
  161.             }
  162.         }
  163.        
  164.         // Whether or not indent attributes on new lines.
  165.         public bool NewLineOnAttributes {
  166.             get { return newLineOnAttributes; }
  167.             set {
  168.                 CheckReadOnly("NewLineOnAttributes");
  169.                 newLineOnAttributes = value;
  170.             }
  171.         }
  172.        
  173.         // Whether or not the XmlWriter should close the underlying stream or TextWriter when Close is called on the XmlWriter.
  174.         public bool CloseOutput {
  175.             get { return closeOutput; }
  176.             set {
  177.                 CheckReadOnly("CloseOutput");
  178.                 closeOutput = value;
  179.             }
  180.         }
  181.        
  182.        
  183.         // Conformance
  184.         // See ConformanceLevel enum for details.
  185.         public ConformanceLevel ConformanceLevel {
  186.             get { return conformanceLevel; }
  187.             set {
  188.                 CheckReadOnly("ConformanceLevel");
  189.                
  190.                 if ((uint)value > (uint)ConformanceLevel.Document) {
  191.                     throw new ArgumentOutOfRangeException("value");
  192.                 }
  193.                 conformanceLevel = value;
  194.             }
  195.         }
  196.        
  197.         // Whether or not to check content characters that they are valid XML characters.
  198.         public bool CheckCharacters {
  199.             get { return checkCharacters; }
  200.             set {
  201.                 CheckReadOnly("CheckCharacters");
  202.                 checkCharacters = value;
  203.             }
  204.         }
  205.        
  206.         //
  207.         // Public methods
  208.         //
  209.         public void Reset()
  210.         {
  211.             encoding = Encoding.UTF8;
  212.             omitXmlDecl = false;
  213.             newLineHandling = NewLineHandling.Replace;
  214.             newLineChars = "\r\n";
  215.             indent = TriState.Unknown;
  216.             indentChars = " ";
  217.             newLineOnAttributes = false;
  218.             closeOutput = false;
  219.            
  220.             conformanceLevel = ConformanceLevel.Document;
  221.             checkCharacters = true;
  222.            
  223.             outputMethod = XmlOutputMethod.Xml;
  224.             cdataSections = null;
  225.             mergeCDataSections = false;
  226.             mediaType = null;
  227.             docTypeSystem = null;
  228.             docTypePublic = null;
  229.             standalone = XmlStandalone.Omit;
  230.            
  231.             isReadOnly = false;
  232.         }
  233.        
  234.         // Deep clone all settings (except read-only, which is always set to false). The original and new objects
  235.         // can now be set independently of each other.
  236.         public XmlWriterSettings Clone()
  237.         {
  238.             XmlWriterSettings clonedSettings = MemberwiseClone() as XmlWriterSettings;
  239.            
  240.             // Deep clone shared settings that are not immutable
  241.             if (cdataSections != null) {
  242.                 clonedSettings.cdataSections = new ArrayList(cdataSections);
  243.             }
  244.            
  245.             // Read-only setting is always false on clones
  246.             clonedSettings.isReadOnly = false;
  247.            
  248.             return clonedSettings;
  249.         }
  250.        
  251.        
  252.         //
  253.         // Internal and private methods
  254.         //
  255.         internal bool ReadOnly {
  256.             get { return isReadOnly; }
  257.             set { isReadOnly = value; }
  258.         }
  259.        
  260.         // Specifies the method (Html, Xml, etc.) that will be used to serialize the result tree.
  261.         public XmlOutputMethod OutputMethod {
  262.             get { return outputMethod; }
  263.             internal set { outputMethod = value; }
  264.         }
  265.        
  266.         // Set of XmlQualifiedNames that identify any elements that need to have text children wrapped in CData sections.
  267.         internal IList CDataSectionElements {
  268.             get {
  269.                 if (cdataSections == null) {
  270.                     cdataSections = new ArrayList();
  271.                 }
  272.                 return cdataSections;
  273.             }
  274.             set {
  275.                 CheckReadOnly("CDataSectionElements");
  276.                
  277.                 if (value == null) {
  278.                     throw new ArgumentNullException("value");
  279.                 }
  280.                 cdataSections = value;
  281.             }
  282.         }
  283.        
  284.         internal bool MergeCDataSections {
  285.             get { return mergeCDataSections; }
  286.             set {
  287.                 CheckReadOnly("MergeCDataSections");
  288.                 mergeCDataSections = value;
  289.             }
  290.         }
  291.        
  292.         // Used in Html writer when writing Meta element. Null denotes the default media type.
  293.         internal string MediaType {
  294.             get { return mediaType; }
  295.             set {
  296.                 CheckReadOnly("MediaType");
  297.                 mediaType = value;
  298.             }
  299.         }
  300.        
  301.         // System Id in doc-type declaration. Null denotes the absence of the system Id.
  302.         internal string DocTypeSystem {
  303.             get { return docTypeSystem; }
  304.             set {
  305.                 CheckReadOnly("DocTypeSystem");
  306.                 docTypeSystem = value;
  307.             }
  308.         }
  309.        
  310.         // Public Id in doc-type declaration. Null denotes the absence of the public Id.
  311.         internal string DocTypePublic {
  312.             get { return docTypePublic; }
  313.             set {
  314.                 CheckReadOnly("DocTypePublic");
  315.                 docTypePublic = value;
  316.             }
  317.         }
  318.        
  319.         // Yes for standalone="yes", No for standalone="no", and Omit for no standalone.
  320.         internal XmlStandalone Standalone {
  321.             get { return standalone; }
  322.             set {
  323.                 CheckReadOnly("Standalone");
  324.                 standalone = value;
  325.             }
  326.         }
  327.        
  328.         // True if an xml declaration should automatically be output (no need to call WriteStartDocument)
  329.         internal bool AutoXmlDeclaration {
  330.             get { return autoXmlDecl; }
  331.             set {
  332.                 CheckReadOnly("AutoXmlDeclaration");
  333.                 autoXmlDecl = value;
  334.             }
  335.         }
  336.        
  337.         // If TriState.Unknown, then Indent property was not explicitly set. In this case, the AutoDetect output
  338.         // method will default to Indent=true for Html and Indent=false for Xml.
  339.         internal TriState InternalIndent {
  340.             get { return indent; }
  341.         }
  342.        
  343.         internal bool IsQuerySpecific {
  344.             get { return cdataSections != null || docTypePublic != null || docTypeSystem != null || standalone == XmlStandalone.Yes; }
  345.         }
  346.        
  347.         private void CheckReadOnly(string propertyName)
  348.         {
  349.             if (isReadOnly) {
  350.                 throw new XmlException(Res.Xml_ReadOnlyProperty, "XmlWriterSettings." + propertyName);
  351.             }
  352.         }
  353.     }
  354. }

Developer Fusion