PageRenderTime 11ms CodeModel.GetById 38ms RepoModel.GetById 0ms app.codeStats 0ms

/Skybound.Gecko/Generated/nsISAXContentHandler.cs

https://bitbucket.org/geckofx/geckofx-2.0/
C# | 256 lines | 32 code | 11 blank | 213 comment | 0 complexity | d9403d1cffb88ed7e46352a0c64d4c47 MD5 | raw file
  1. // --------------------------------------------------------------------------------------------
  2. // Version: MPL 1.1/GPL 2.0/LGPL 2.1
  3. //
  4. // The contents of this file are subject to the Mozilla Public License Version
  5. // 1.1 (the "License"); you may not use this file except in compliance with
  6. // the License. You may obtain a copy of the License at
  7. // http://www.mozilla.org/MPL/
  8. //
  9. // Software distributed under the License is distributed on an "AS IS" basis,
  10. // WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11. // for the specific language governing rights and limitations under the
  12. // License.
  13. //
  14. // <remarks>
  15. // Generated by IDLImporter from file nsISAXContentHandler.idl
  16. //
  17. // You should use these interfaces when you access the COM objects defined in the mentioned
  18. // IDL/IDH file.
  19. // </remarks>
  20. // --------------------------------------------------------------------------------------------
  21. namespace Skybound.Gecko
  22. {
  23. using System;
  24. using System.Runtime.InteropServices;
  25. using System.Runtime.InteropServices.ComTypes;
  26. using System.Runtime.CompilerServices;
  27. using System.Windows.Forms;
  28. /// <summary>
  29. /// Receive notification of the logical content of a document.
  30. ///
  31. /// This is the main interface that most SAX applications implement: if
  32. /// the application needs to be informed of basic parsing events, it
  33. /// implements this interface and registers an instance with the SAX
  34. /// parser. The parser uses the instance to report basic
  35. /// document-related events like the start and end of elements and
  36. /// character data.
  37. ///
  38. /// The order of events in this interface is very important, and
  39. /// mirrors the order of information in the document itself. For
  40. /// example, all of an element's content (character data, processing
  41. /// instructions, and/or subelements) will appear, in order, between
  42. /// the startElement event and the corresponding endElement event.
  43. /// </summary>
  44. [ComImport()]
  45. [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
  46. [Guid("2a99c757-dfee-4806-bff3-f721440412e0")]
  47. public interface nsISAXContentHandler
  48. {
  49. /// <summary>
  50. /// Receive notification of the beginning of a document.
  51. ///
  52. /// The SAX parser will invoke this method only once, before any
  53. /// other event callbacks.
  54. /// </summary>
  55. [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
  56. void StartDocument();
  57. /// <summary>
  58. /// Receive notification of the end of a document.
  59. ///
  60. /// There is an apparent contradiction between the documentation for
  61. /// this method and the documentation for ErrorHandler.fatalError().
  62. /// Until this ambiguity is resolved in a future major release,
  63. /// clients should make no assumptions about whether endDocument()
  64. /// will or will not be invoked when the parser has reported a
  65. /// fatalError() or thrown an exception.
  66. ///
  67. /// The SAX parser will invoke this method only once, and it will be
  68. /// the last method invoked during the parse. The parser shall not
  69. /// invoke this method until it has either abandoned parsing (because
  70. /// of an unrecoverable error) or reached the end of input.
  71. /// </summary>
  72. [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
  73. void EndDocument();
  74. /// <summary>
  75. /// Receive notification of the beginning of an element.
  76. ///
  77. /// The Parser will invoke this method at the beginning of every
  78. /// element in the XML document; there will be a corresponding
  79. /// endElement event for every startElement event (even when the
  80. /// element is empty). All of the element's content will be reported,
  81. /// in order, before the corresponding endElement event.
  82. ///
  83. /// This event allows up to three name components for each element:
  84. ///
  85. /// 1.) the Namespace URI;
  86. /// 2.) the local name; and
  87. /// 3.) the qualified (prefixed) name.
  88. ///
  89. /// Any or all of these may be provided, depending on the values of
  90. /// the http://xml.org/sax/features/namespaces and the
  91. /// http://xml.org/sax/features/namespace-prefixes properties:
  92. ///
  93. /// The Namespace URI and local name are required when the namespaces
  94. /// property is true (the default), and are optional when the
  95. /// namespaces property is false (if one is specified, both must be);
  96. ///
  97. /// The qualified name is required when the namespace-prefixes
  98. /// property is true, and is optional when the namespace-prefixes
  99. /// property is false (the default).
  100. ///
  101. /// Note that the attribute list provided will contain only
  102. /// attributes with explicit values (specified or defaulted):
  103. /// #IMPLIED attributes will be omitted. The attribute list will
  104. /// contain attributes used for Namespace declarations (xmlns*
  105. /// attributes) only if the
  106. /// http://xml.org/sax/features/namespace-prefixes property is true
  107. /// (it is false by default, and support for a true value is
  108. /// optional).
  109. ///
  110. /// @param uri the Namespace URI, or the empty string if the
  111. /// element has no Namespace URI or if Namespace
  112. /// processing is not being performed
  113. /// @param localName the local name (without prefix), or the
  114. /// empty string if Namespace processing is not being
  115. /// performed
  116. /// @param qName the qualified name (with prefix), or the
  117. /// empty string if qualified names are not available
  118. /// @param atts the attributes attached to the element. If
  119. /// there are no attributes, it shall be an empty
  120. /// SAXAttributes object. The value of this object after
  121. /// startElement returns is undefined
  122. /// </summary>
  123. [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
  124. void StartElement([MarshalAs(UnmanagedType.LPStruct)] nsAString uri, [MarshalAs(UnmanagedType.LPStruct)] nsAString localName, [MarshalAs(UnmanagedType.LPStruct)] nsAString qName, [MarshalAs(UnmanagedType.Interface)] nsISAXAttributes attributes);
  125. /// <summary>
  126. /// Receive notification of the end of an element.
  127. ///
  128. /// The SAX parser will invoke this method at the end of every
  129. /// element in the XML document; there will be a corresponding
  130. /// startElement event for every endElement event (even when the
  131. /// element is empty).
  132. ///
  133. /// For information on the names, see startElement.
  134. ///
  135. /// @param uri the Namespace URI, or the empty string if the
  136. /// element has no Namespace URI or if Namespace
  137. /// processing is not being performed
  138. /// @param localName the local name (without prefix), or the
  139. /// empty string if Namespace processing is not being
  140. /// performed
  141. /// @param qName the qualified XML name (with prefix), or the
  142. /// empty string if qualified names are not available
  143. /// </summary>
  144. [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
  145. void EndElement([MarshalAs(UnmanagedType.LPStruct)] nsAString uri, [MarshalAs(UnmanagedType.LPStruct)] nsAString localName, [MarshalAs(UnmanagedType.LPStruct)] nsAString qName);
  146. /// <summary>
  147. /// Receive notification of character data.
  148. ///
  149. /// The Parser will call this method to report each chunk of
  150. /// character data. SAX parsers may return all contiguous character
  151. /// data in a single chunk, or they may split it into several chunks;
  152. /// however, all of the characters in any single event must come from
  153. /// the same external entity so that the Locator provides useful
  154. /// information.
  155. ///
  156. /// Note that some parsers will report whitespace in element
  157. /// content using the ignorableWhitespace method rather than this one
  158. /// (validating parsers must do so).
  159. ///
  160. /// @param value the characters from the XML document
  161. /// </summary>
  162. [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
  163. void Characters([MarshalAs(UnmanagedType.LPStruct)] nsAString value);
  164. /// <summary>
  165. /// Receive notification of a processing instruction.
  166. ///
  167. /// The Parser will invoke this method once for each processing
  168. /// instruction found: note that processing instructions may occur
  169. /// before or after the main document element.
  170. ///
  171. /// A SAX parser must never report an XML declaration (XML 1.0,
  172. /// section 2.8) or a text declaration (XML 1.0, section 4.3.1) using
  173. /// this method.
  174. ///
  175. /// @param target the processing instruction target
  176. /// @param data the processing instruction data, or null if
  177. /// none was supplied. The data does not include any
  178. /// whitespace separating it from the target
  179. /// </summary>
  180. [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
  181. void ProcessingInstruction([MarshalAs(UnmanagedType.LPStruct)] nsAString target, [MarshalAs(UnmanagedType.LPStruct)] nsAString data);
  182. /// <summary>
  183. /// Receive notification of ignorable whitespace in element content.
  184. ///
  185. /// Validating Parsers must use this method to report each chunk of
  186. /// whitespace in element content (see the W3C XML 1.0
  187. /// recommendation, section 2.10): non-validating parsers may also
  188. /// use this method if they are capable of parsing and using content
  189. /// models.
  190. ///
  191. /// SAX parsers may return all contiguous whitespace in a single
  192. /// chunk, or they may split it into several chunks; however, all of
  193. /// the characters in any single event must come from the same
  194. /// external entity, so that the Locator provides useful information.
  195. ///
  196. /// @param whitespace the characters from the XML document
  197. /// </summary>
  198. [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
  199. void IgnorableWhitespace([MarshalAs(UnmanagedType.LPStruct)] nsAString whitespace);
  200. /// <summary>
  201. /// Begin the scope of a prefix-URI Namespace mapping.
  202. ///
  203. /// The information from this event is not necessary for normal
  204. /// Namespace processing: the SAX XML reader will automatically
  205. /// replace prefixes for element and attribute names when the
  206. /// http://xml.org/sax/features/namespaces feature is
  207. /// true (the default).
  208. ///
  209. /// There are cases, however, when applications need to use prefixes
  210. /// in character data or in attribute values, where they cannot
  211. /// safely be expanded automatically; the start/endPrefixMapping
  212. /// event supplies the information to the application to expand
  213. /// prefixes in those contexts itself, if necessary.
  214. ///
  215. /// Note that start/endPrefixMapping events are not guaranteed to be
  216. /// properly nested relative to each other: all startPrefixMapping
  217. /// events will occur immediately before the corresponding
  218. /// startElement event, and all endPrefixMapping events will occur
  219. /// immediately after the corresponding endElement event, but their
  220. /// order is not otherwise guaranteed.
  221. ///
  222. /// There should never be start/endPrefixMapping events for the
  223. /// "xml" prefix, since it is predeclared and immutable.
  224. ///
  225. /// @param prefix The Namespace prefix being declared. An empty
  226. /// string is used for the default element namespace,
  227. /// which has no prefix.
  228. /// @param uri The Namespace URI the prefix is mapped to.
  229. /// </summary>
  230. [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
  231. void StartPrefixMapping([MarshalAs(UnmanagedType.LPStruct)] nsAString prefix, [MarshalAs(UnmanagedType.LPStruct)] nsAString uri);
  232. /// <summary>
  233. /// End the scope of a prefix-URI mapping.
  234. ///
  235. /// See startPrefixMapping for details. These events will always
  236. /// occur immediately after the corresponding endElement event, but
  237. /// the order of endPrefixMapping events is not otherwise guaranteed.
  238. ///
  239. /// @param prefix The prefix that was being mapped. This is the empty
  240. /// string when a default mapping scope ends.
  241. /// </summary>
  242. [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
  243. void EndPrefixMapping([MarshalAs(UnmanagedType.LPStruct)] nsAString prefix);
  244. }
  245. }