3147 lines
105 KiB
Plaintext
3147 lines
105 KiB
Plaintext
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992-1998.
|
|
//
|
|
// File: msxml.idl
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
cpp_quote("//+-------------------------------------------------------------------------")
|
|
cpp_quote("//")
|
|
cpp_quote("// Microsoft Windows")
|
|
cpp_quote("// Copyright (C) Microsoft Corporation, 1997-1998.")
|
|
cpp_quote("//")
|
|
cpp_quote("//--------------------------------------------------------------------------")
|
|
|
|
#include "msxml2did.h"
|
|
#include <idispids.h>
|
|
|
|
#ifndef DO_NO_IMPORTS
|
|
import "unknwn.idl";
|
|
import "wtypes.idl";
|
|
import "objidl.idl";
|
|
import "oaidl.idl";
|
|
#endif
|
|
|
|
// DOMDocument has a different guid in IE5. In msxml3, it is a version independent guid. To avoid
|
|
// compile errors define it to be DOMDocment2
|
|
|
|
cpp_quote("#define DOMDocument DOMDocument2")
|
|
cpp_quote("#define CLSID_DOMDocument CLSID_DOMDocument2")
|
|
cpp_quote("")
|
|
cpp_quote("#ifdef __USE_MSXML2_NAMESPACE__")
|
|
cpp_quote("namespace MSXML2 {")
|
|
cpp_quote("#endif")
|
|
|
|
cpp_quote("#ifndef __msxml_h__")
|
|
|
|
#ifndef IMPORTED_MSXML
|
|
typedef struct _xml_error {
|
|
unsigned _nLine; // line number
|
|
BSTR _pchBuf; // current input buffer
|
|
unsigned _cchBuf; // number of chars in buffer
|
|
unsigned _ich; // index of the char when error occurred
|
|
BSTR _pszFound; // token found
|
|
BSTR _pszExpected; // token expected
|
|
DWORD _reserved1; // reserved
|
|
DWORD _reserved2; // reserved
|
|
} XML_ERROR;
|
|
// If, when importing this file into another idl file you receive duplicate definition
|
|
// errors, define IMPORTED_MSXML on the command line to the MIDL compiler.
|
|
#endif
|
|
cpp_quote("#endif")
|
|
|
|
// msxml2 shares the same library as msxml3. To make sure all of msxml3 is defined check for the SAX interfaces.
|
|
// If they are not there then undefine the library so that msxml3 definitions are included.
|
|
|
|
cpp_quote("#ifndef __ISAXXMLReader_INTERFACE_DEFINED__")
|
|
cpp_quote("#undef __MSXML2_LIBRARY_DEFINED__")
|
|
cpp_quote("#endif")
|
|
|
|
[
|
|
uuid(f5078f18-c551-11d3-89b9-0000f81fe221),
|
|
version(3.0),
|
|
helpstring("Microsoft XML, v3.0"),
|
|
lcid(0x0000)
|
|
]
|
|
|
|
library MSXML2
|
|
{
|
|
|
|
importlib("stdole32.tlb");
|
|
importlib("stdole2.tlb");
|
|
|
|
// XMLDOM
|
|
interface IXMLDOMImplementation;
|
|
interface IXMLDOMNode;
|
|
interface IXMLDOMDocumentFragment;
|
|
interface IXMLDOMDocument;
|
|
interface IXMLDOMSchemaCollection;
|
|
interface IXMLDOMDocument2;
|
|
interface IXMLDOMNodeList;
|
|
interface IXMLDOMNamedNodeMap;
|
|
interface IXMLDOMCharacterData;
|
|
interface IXMLDOMAttribute;
|
|
interface IXMLDOMElement;
|
|
interface IXMLDOMText;
|
|
interface IXMLDOMComment;
|
|
interface IXMLDOMProcessingInstruction;
|
|
interface IXMLDOMCDATASection;
|
|
interface IXMLDOMDocumentType;
|
|
interface IXMLDOMNotation;
|
|
interface IXMLDOMEntity;
|
|
interface IXMLDOMEntityReference;
|
|
interface IXMLDOMParseError;
|
|
interface IXTLRuntime;
|
|
interface IXSLTemplate;
|
|
interface IXSLProcessor;
|
|
|
|
|
|
// SAX
|
|
interface ISAXXMLReader;
|
|
interface ISAXXMLFilter;
|
|
interface ISAXLocator;
|
|
interface ISAXEntityResolver;
|
|
interface ISAXContentHandler;
|
|
interface ISAXDTDHandler;
|
|
interface ISAXErrorHandler;
|
|
interface ISAXLexicalHandler;
|
|
interface ISAXDeclHandler;
|
|
interface ISAXAttributes;
|
|
|
|
interface IVBSAXXMLReader;
|
|
interface IVBSAXXMLFilter;
|
|
interface IVBSAXLocator;
|
|
interface IVBSAXEntityResolver;
|
|
interface IVBSAXContentHandler;
|
|
interface IVBSAXDTDHandler;
|
|
interface IVBSAXErrorHandler;
|
|
interface IVBSAXLexicalHandler;
|
|
interface IVBSAXDeclHandler;
|
|
interface IVBSAXAttributes;
|
|
|
|
interface IMXWriter;
|
|
interface IMXAttributes;
|
|
interface IMXReaderControl;
|
|
|
|
|
|
// IE4 ObjectModel
|
|
interface IXMLElementCollection;
|
|
interface IXMLDocument;
|
|
interface IXMLDocument2;
|
|
interface IXMLElement;
|
|
interface IXMLElement2;
|
|
interface IXMLAttribute;
|
|
interface IXMLError;
|
|
interface IXMLElementNotificationSink;
|
|
|
|
|
|
/// This is needed to avoid having the (SAX) ParseURL method
|
|
/// become the ParseURLA method.
|
|
cpp_quote("#undef ParseURL")
|
|
|
|
|
|
cpp_quote("#if !defined(__msxml_h__)")
|
|
#ifndef IMPORTED_MSXML
|
|
typedef [
|
|
helpstring("Constants that define types for IXMLElement.")
|
|
] enum tagXMLEMEM_TYPE
|
|
{
|
|
XMLELEMTYPE_ELEMENT,
|
|
XMLELEMTYPE_TEXT,
|
|
XMLELEMTYPE_COMMENT,
|
|
XMLELEMTYPE_DOCUMENT,
|
|
XMLELEMTYPE_DTD,
|
|
XMLELEMTYPE_PI,
|
|
XMLELEMTYPE_OTHER
|
|
} XMLELEM_TYPE;
|
|
#endif
|
|
cpp_quote("#endif")
|
|
|
|
// IE4 msxml.h also defines __msxml_h__. The only way to tell the difference between IE4 msxml.h and IE5 msxml.h is the
|
|
// via the obsolete interface __IXMLElementNotificationSink_INTERFACE_DEFINED__ defined by IE4
|
|
cpp_quote("#if !defined(__msxml_h__) || defined(__IXMLElementNotificationSink_INTERFACE_DEFINED__)")
|
|
|
|
typedef [
|
|
helpstring("Constants that define a node's type")
|
|
] enum tagDOMNodeType
|
|
{
|
|
NODE_INVALID, // = 0
|
|
NODE_ELEMENT, // = 1
|
|
NODE_ATTRIBUTE, // = 2
|
|
NODE_TEXT, // = 3
|
|
NODE_CDATA_SECTION, // = 4
|
|
NODE_ENTITY_REFERENCE, // = 5
|
|
NODE_ENTITY, // = 6
|
|
NODE_PROCESSING_INSTRUCTION, // = 7
|
|
NODE_COMMENT, // = 8
|
|
NODE_DOCUMENT, // = 9
|
|
NODE_DOCUMENT_TYPE, // = 10
|
|
NODE_DOCUMENT_FRAGMENT, // = 11
|
|
NODE_NOTATION // = 12
|
|
} DOMNodeType;
|
|
|
|
cpp_quote("#endif")
|
|
|
|
[
|
|
local, object,
|
|
uuid(2933BF80-7B36-11d2-B20E-00C04F983E60), // IID_INode
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
helpstring("Core DOM node interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IXMLDOMNode : IDispatch
|
|
{
|
|
// readonly attribute wstring nodeName;
|
|
[propget, id(DISPID_DOM_NODE_NODENAME),
|
|
helpstring("name of the node")]
|
|
HRESULT nodeName(
|
|
[out, retval] BSTR * name);
|
|
|
|
// attribute wstring nodeValue;
|
|
[propget, id(DISPID_DOM_NODE_NODEVALUE),
|
|
helpstring("value stored in the node")]
|
|
HRESULT nodeValue(
|
|
[out, retval] VARIANT * value);
|
|
|
|
[propput, id(DISPID_DOM_NODE_NODEVALUE),
|
|
helpstring("value stored in the node")]
|
|
HRESULT nodeValue(
|
|
[in] VARIANT value);
|
|
|
|
// readonly attribute unsigned short nodeType;
|
|
[propget, id(DISPID_DOM_NODE_NODETYPE),
|
|
helpstring("the node's type")]
|
|
HRESULT nodeType(
|
|
[out, retval] DOMNodeType * type);
|
|
|
|
// readonly attribute Node parentNode;
|
|
[propget, id(DISPID_DOM_NODE_PARENTNODE),
|
|
helpstring("parent of the node")]
|
|
HRESULT parentNode(
|
|
[out, retval] IXMLDOMNode ** parent);
|
|
|
|
// readonly attribute NodeList childNodes;
|
|
[propget, id(DISPID_DOM_NODE_CHILDNODES),
|
|
helpstring("the collection of the node's children")]
|
|
HRESULT childNodes(
|
|
[out, retval] IXMLDOMNodeList ** childList);
|
|
|
|
// readonly attribute Node firstChild;
|
|
[propget,id(DISPID_DOM_NODE_FIRSTCHILD),
|
|
helpstring("first child of the node")]
|
|
HRESULT firstChild(
|
|
[out, retval] IXMLDOMNode ** firstChild);
|
|
|
|
// readonly attribute Node lastChild;
|
|
[propget,id(DISPID_DOM_NODE_LASTCHILD),
|
|
helpstring("last child of the node")]
|
|
HRESULT lastChild(
|
|
[out, retval] IXMLDOMNode ** lastChild);
|
|
|
|
// readonly attribute Node previousSibling;
|
|
[propget,id(DISPID_DOM_NODE_PREVIOUSSIBLING),
|
|
helpstring("left sibling of the node")]
|
|
HRESULT previousSibling(
|
|
[out, retval] IXMLDOMNode ** previousSibling);
|
|
|
|
// readonly attribute Node nextSibling;
|
|
[propget,id(DISPID_DOM_NODE_NEXTSIBLING),
|
|
helpstring("right sibling of the node")]
|
|
HRESULT nextSibling(
|
|
[out, retval] IXMLDOMNode ** nextSibling);
|
|
|
|
// readonly attribute NamedNodeMap attributes;
|
|
[propget, id(DISPID_DOM_NODE_ATTRIBUTES),
|
|
helpstring("the collection of the node's attributes")]
|
|
HRESULT attributes(
|
|
[out, retval] IXMLDOMNamedNodeMap ** attributeMap);
|
|
|
|
|
|
// Node insertBefore(in Node newChild,
|
|
// in Node refChild)
|
|
// raises(DOMException);
|
|
[id(DISPID_DOM_NODE_INSERTBEFORE),
|
|
helpstring("insert a child node")]
|
|
HRESULT insertBefore(
|
|
[in] IXMLDOMNode * newChild,
|
|
[in] VARIANT refChild,
|
|
[out, retval] IXMLDOMNode ** outNewChild);
|
|
|
|
// Node replaceChild(in Node newChild,
|
|
// in Node oldChild)
|
|
// raises(DOMException);
|
|
[id(DISPID_DOM_NODE_REPLACECHILD),
|
|
helpstring("replace a child node")]
|
|
HRESULT replaceChild(
|
|
[in] IXMLDOMNode * newChild,
|
|
[in] IXMLDOMNode * oldChild,
|
|
[out, retval] IXMLDOMNode ** outOldChild);
|
|
|
|
// Node removeChild(in Node childNode)
|
|
// raises(DOMException);
|
|
[id(DISPID_DOM_NODE_REMOVECHILD),
|
|
helpstring("remove a child node")]
|
|
HRESULT removeChild(
|
|
[in] IXMLDOMNode * childNode,
|
|
[out, retval] IXMLDOMNode ** oldChild);
|
|
|
|
// Node appendChild(in Node newChild);
|
|
[id(DISPID_DOM_NODE_APPENDCHILD),
|
|
helpstring("append a child node")]
|
|
HRESULT appendChild(
|
|
[in] IXMLDOMNode * newChild,
|
|
[out, retval] IXMLDOMNode ** outNewChild);
|
|
|
|
// boolean hasChildNodes();
|
|
[id(DISPID_DOM_NODE_HASCHILDNODES),
|
|
helpstring("")]
|
|
HRESULT hasChildNodes(
|
|
[out, retval] VARIANT_BOOL * hasChild);
|
|
|
|
// readonly attribute Node ownerDocument;
|
|
[propget, id(DISPID_DOM_NODE_OWNERDOC),
|
|
helpstring("document that contains the node")]
|
|
HRESULT ownerDocument(
|
|
[out, retval] IXMLDOMDocument ** DOMDocument);
|
|
|
|
// Node cloneNode(in boolean deep);
|
|
[id(DISPID_DOM_NODE_CLONENODE),
|
|
helpstring("")]
|
|
HRESULT cloneNode(
|
|
[in] VARIANT_BOOL deep,
|
|
[out, retval] IXMLDOMNode ** cloneRoot);
|
|
|
|
[propget, id(DISPID_XMLDOM_NODE_STRINGTYPE),
|
|
helpstring("the type of node in string form")]
|
|
HRESULT nodeTypeString(
|
|
[retval, out] BSTR * nodeType);
|
|
|
|
[propget, id(DISPID_XMLDOM_NODE_TEXT),
|
|
helpstring("text content of the node and subtree")]
|
|
HRESULT text(
|
|
[retval, out] BSTR * text);
|
|
|
|
[propput, id(DISPID_XMLDOM_NODE_TEXT),
|
|
helpstring("text content of the node and subtree")]
|
|
HRESULT text(
|
|
[in] BSTR text);
|
|
|
|
[propget, id(DISPID_XMLDOM_NODE_SPECIFIED),
|
|
helpstring("indicates whether node is a default value")]
|
|
HRESULT specified(
|
|
[out, retval] VARIANT_BOOL * isSpecified);
|
|
|
|
// DTD Navigation.
|
|
[propget, id(DISPID_XMLDOM_NODE_DEFINITION),
|
|
helpstring("pointer to the definition of the node in the DTD or schema")]
|
|
HRESULT definition(
|
|
[retval,out] IXMLDOMNode ** definitionNode);
|
|
|
|
[propget, id(DISPID_XMLDOM_NODE_NODETYPEDVALUE),
|
|
helpstring("get the strongly typed value of the node")]
|
|
HRESULT nodeTypedValue(
|
|
[retval, out] VARIANT * typedValue);
|
|
|
|
[propput, id(DISPID_XMLDOM_NODE_NODETYPEDVALUE),
|
|
helpstring("get the strongly typed value of the node")]
|
|
HRESULT nodeTypedValue(
|
|
[in] VARIANT typedValue);
|
|
|
|
[propget, id(DISPID_XMLDOM_NODE_DATATYPE),
|
|
helpstring("the data type of the node")]
|
|
HRESULT dataType(
|
|
[retval, out] VARIANT * dataTypeName); // BSTR or VT_NULL
|
|
|
|
[propput, id(DISPID_XMLDOM_NODE_DATATYPE),
|
|
helpstring("the data type of the node")]
|
|
HRESULT dataType(
|
|
[in] BSTR dataTypeName);
|
|
|
|
[propget, id(DISPID_XMLDOM_NODE_XML),
|
|
helpstring("return the XML source for the node and each of its descendants")]
|
|
HRESULT xml(
|
|
[retval, out] BSTR * xmlString);
|
|
|
|
[id(DISPID_XMLDOM_NODE_TRANSFORMNODE),
|
|
helpstring("apply the stylesheet to the subtree")]
|
|
HRESULT transformNode(
|
|
[in] IXMLDOMNode * stylesheet,
|
|
[retval, out] BSTR * xmlString);
|
|
|
|
[id(DISPID_XMLDOM_NODE_SELECTNODES),
|
|
helpstring("execute query on the subtree")]
|
|
HRESULT selectNodes(
|
|
[in] BSTR queryString,
|
|
[retval, out] IXMLDOMNodeList** resultList);
|
|
|
|
[id(DISPID_XMLDOM_NODE_SELECTSINGLENODE),
|
|
helpstring("execute query on the subtree")]
|
|
HRESULT selectSingleNode(
|
|
[in] BSTR queryString,
|
|
[retval, out] IXMLDOMNode** resultNode);
|
|
|
|
[propget,id(DISPID_XMLDOM_NODE_PARSED),
|
|
helpstring("has sub-tree been completely parsed")]
|
|
HRESULT parsed(
|
|
[retval, out] VARIANT_BOOL * isParsed);
|
|
|
|
[propget, id(DISPID_XMLDOM_NODE_NAMESPACE),
|
|
helpstring("the URI for the namespace applying to the node")]
|
|
HRESULT namespaceURI(
|
|
[retval, out] BSTR * namespaceURI);
|
|
|
|
[propget, id(DISPID_XMLDOM_NODE_PREFIX),
|
|
helpstring("the prefix for the namespace applying to the node")]
|
|
HRESULT prefix(
|
|
[retval, out] BSTR * prefixString);
|
|
|
|
[propget, id(DISPID_XMLDOM_NODE_BASENAME),
|
|
helpstring("the base name of the node (nodename with the prefix stripped off)")]
|
|
HRESULT baseName(
|
|
[retval, out] BSTR * nameString);
|
|
|
|
[id(DISPID_XMLDOM_NODE_TRANSFORMNODETOOBJECT),
|
|
helpstring("apply the stylesheet to the subtree, returning the result through a document or a stream")]
|
|
HRESULT transformNodeToObject(
|
|
[in] IXMLDOMNode * stylesheet,
|
|
[in] VARIANT outputObject);
|
|
|
|
};
|
|
|
|
[
|
|
local, object,
|
|
uuid(2933BF81-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMDocument
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
pointer_default(unique),
|
|
hidden
|
|
]
|
|
interface IXMLDOMDocument : IXMLDOMNode
|
|
{
|
|
// readonly attribute DocumentType doctype;
|
|
[propget, id(DISPID_DOM_DOCUMENT_DOCTYPE),
|
|
helpstring("node corresponding to the DOCTYPE")]
|
|
HRESULT doctype(
|
|
[out, retval] IXMLDOMDocumentType ** documentType);
|
|
|
|
// readonly attribute DOMImplementation implementation;
|
|
[propget, id(DISPID_DOM_DOCUMENT_IMPLEMENTATION),
|
|
helpstring("info on this DOM implementation")]
|
|
HRESULT implementation(
|
|
[out, retval] IXMLDOMImplementation ** impl);
|
|
|
|
// attribute Element documentElement;
|
|
[propget, id(DISPID_DOM_DOCUMENT_DOCUMENTELEMENT),
|
|
helpstring("the root of the tree")]
|
|
HRESULT documentElement(
|
|
[out, retval] IXMLDOMElement ** DOMElement);
|
|
|
|
[propputref, id(DISPID_DOM_DOCUMENT_DOCUMENTELEMENT),
|
|
helpstring("the root of the tree")]
|
|
HRESULT documentElement(
|
|
[in] IXMLDOMElement * DOMElement);
|
|
|
|
// Element createElement(in wstring tagName);
|
|
[id(DISPID_DOM_DOCUMENT_CREATEELEMENT),
|
|
helpstring("create an Element node")]
|
|
HRESULT createElement(
|
|
[in] BSTR tagName,
|
|
[out, retval] IXMLDOMElement ** element);
|
|
|
|
// DocumentFragment createDocumentFragment();
|
|
[id(DISPID_DOM_DOCUMENT_CREATEDOCUMENTFRAGMENT),
|
|
helpstring("create a DocumentFragment node")]
|
|
HRESULT createDocumentFragment(
|
|
[out, retval] IXMLDOMDocumentFragment ** docFrag );
|
|
|
|
// Text createTextNode(in wstring data);
|
|
[id(DISPID_DOM_DOCUMENT_CREATETEXTNODE),
|
|
helpstring("create a text node")]
|
|
HRESULT createTextNode(
|
|
[in] BSTR data,
|
|
[out, retval] IXMLDOMText ** text);
|
|
|
|
// Comment createComment(in wstring data);
|
|
[id(DISPID_DOM_DOCUMENT_CREATECOMMENT),
|
|
helpstring("create a comment node")]
|
|
HRESULT createComment(
|
|
[in] BSTR data,
|
|
[out, retval] IXMLDOMComment ** comment);
|
|
|
|
// CDATASection createCDATASection(in wstring data);
|
|
[id(DISPID_DOM_DOCUMENT_CREATECDATASECTION),
|
|
helpstring("create a CDATA section node")]
|
|
HRESULT createCDATASection(
|
|
[in] BSTR data,
|
|
[out, retval] IXMLDOMCDATASection ** cdata);
|
|
|
|
// ProcessingInstruction createProcessingInstruction(in wstring target,
|
|
// in wstring data);
|
|
[id(DISPID_DOM_DOCUMENT_CREATEPROCESSINGINSTRUCTION),
|
|
helpstring("create a processing instruction node")]
|
|
HRESULT createProcessingInstruction(
|
|
[in] BSTR target,
|
|
[in] BSTR data,
|
|
[out, retval] IXMLDOMProcessingInstruction ** pi);
|
|
|
|
// Attribute createAttribute(in wstring name);
|
|
[id(DISPID_DOM_DOCUMENT_CREATEATTRIBUTE),
|
|
helpstring("create an attribute node")]
|
|
HRESULT createAttribute(
|
|
[in] BSTR name,
|
|
[out, retval] IXMLDOMAttribute ** attribute);
|
|
|
|
// EntityReference createEntityReference(in wstring name);
|
|
[id(DISPID_DOM_DOCUMENT_CREATEENTITYREFERENCE),
|
|
helpstring("create an entity reference node")]
|
|
HRESULT createEntityReference(
|
|
[in] BSTR name,
|
|
[out, retval] IXMLDOMEntityReference ** entityRef);
|
|
|
|
// NodeList getElementsByTagName(in wstring tagname);
|
|
[id(DISPID_DOM_DOCUMENT_GETELEMENTSBYTAGNAME),
|
|
helpstring("build a list of elements by name")]
|
|
HRESULT getElementsByTagName(
|
|
[in] BSTR tagName,
|
|
[out, retval] IXMLDOMNodeList ** resultList);
|
|
|
|
[id(DISPID_XMLDOM_DOCUMENT_CREATENODE),
|
|
helpstring("create a node of the specified node type and name")]
|
|
HRESULT createNode(
|
|
[in] VARIANT Type,
|
|
[in] BSTR name,
|
|
[in] BSTR namespaceURI,
|
|
[retval, out] IXMLDOMNode ** node);
|
|
|
|
[id(DISPID_XMLDOM_DOCUMENT_NODEFROMID),
|
|
helpstring("retrieve node from it's ID")]
|
|
HRESULT nodeFromID(
|
|
[in] BSTR idString,
|
|
[retval, out] IXMLDOMNode ** node);
|
|
|
|
[id(DISPID_XMLDOM_DOCUMENT_LOAD),
|
|
helpstring("load document from the specified XML source")]
|
|
HRESULT load(
|
|
[in] VARIANT xmlSource,
|
|
[out, retval] VARIANT_BOOL * isSuccessful);
|
|
|
|
[propget, id(DISPID_READYSTATE),
|
|
helpstring("get the state of the XML document")]
|
|
HRESULT readyState(
|
|
[retval, out] long * value);
|
|
|
|
[propget, id(DISPID_XMLDOM_DOCUMENT_PARSEERROR),
|
|
helpstring("get the last parser error")]
|
|
HRESULT parseError(
|
|
[retval, out] IXMLDOMParseError ** errorObj);
|
|
|
|
[propget, id(DISPID_XMLDOM_DOCUMENT_URL),
|
|
helpstring("get the URL for the loaded XML document")]
|
|
HRESULT url(
|
|
[retval, out] BSTR * urlString);
|
|
|
|
[propget, id(DISPID_XMLDOM_DOCUMENT_ASYNC),
|
|
helpstring("flag for asynchronous download")]
|
|
HRESULT async(
|
|
[retval, out] VARIANT_BOOL * isAsync);
|
|
|
|
[propput, id(DISPID_XMLDOM_DOCUMENT_ASYNC),
|
|
helpstring("flag for asynchronous download")]
|
|
HRESULT async(
|
|
[in] VARIANT_BOOL isAsync);
|
|
|
|
[id(DISPID_XMLDOM_DOCUMENT_ABORT),
|
|
helpstring("abort an asynchronous download")]
|
|
HRESULT abort();
|
|
|
|
[id(DISPID_XMLDOM_DOCUMENT_LOADXML),
|
|
helpstring("load the document from a string")]
|
|
HRESULT loadXML(
|
|
[in] BSTR bstrXML,
|
|
[out, retval] VARIANT_BOOL * isSuccessful);
|
|
|
|
[id(DISPID_XMLDOM_DOCUMENT_SAVE),
|
|
helpstring("save the document to a specified destination")]
|
|
HRESULT save(
|
|
[in] VARIANT destination);
|
|
|
|
[propget, id(DISPID_XMLDOM_DOCUMENT_VALIDATE),
|
|
helpstring("indicates whether the parser performs validation")]
|
|
HRESULT validateOnParse(
|
|
[retval, out] VARIANT_BOOL * isValidating);
|
|
|
|
[propput, id(DISPID_XMLDOM_DOCUMENT_VALIDATE),
|
|
helpstring("indicates whether the parser performs validation")]
|
|
HRESULT validateOnParse(
|
|
[in] VARIANT_BOOL isValidating);
|
|
|
|
[propget, id(DISPID_XMLDOM_DOCUMENT_RESOLVENAMESPACE),
|
|
helpstring("indicates whether the parser resolves references to external DTD/Entities/Schema")]
|
|
HRESULT resolveExternals(
|
|
[retval,out] VARIANT_BOOL * isResolving);
|
|
|
|
[propput, id(DISPID_XMLDOM_DOCUMENT_RESOLVENAMESPACE),
|
|
helpstring("indicates whether the parser resolves references to external DTD/Entities/Schema")]
|
|
HRESULT resolveExternals(
|
|
[in] VARIANT_BOOL isResolving);
|
|
|
|
[propget, id(DISPID_XMLDOM_DOCUMENT_PRESERVEWHITESPACE),
|
|
helpstring("indicates whether the parser preserves whitespace")]
|
|
HRESULT preserveWhiteSpace(
|
|
[retval,out] VARIANT_BOOL * isPreserving);
|
|
|
|
[propput, id(DISPID_XMLDOM_DOCUMENT_PRESERVEWHITESPACE),
|
|
helpstring("indicates whether the parser preserves whitespace")]
|
|
HRESULT preserveWhiteSpace(
|
|
[in] VARIANT_BOOL isPreserving);
|
|
|
|
[propput, id(DISPID_XMLDOM_DOCUMENT_ONREADYSTATECHANGE),
|
|
helpstring("register a readystatechange event handler")]
|
|
HRESULT onreadystatechange(
|
|
[in] VARIANT readystatechangeSink);
|
|
|
|
[propput, id(DISPID_XMLDOM_DOCUMENT_ONDATAAVAILABLE),
|
|
helpstring("register an ondataavailable event handler")]
|
|
HRESULT ondataavailable(
|
|
[in] VARIANT ondataavailableSink);
|
|
|
|
[propput, id(DISPID_XMLDOM_DOCUMENT_ONTRANSFORMNODE),
|
|
helpstring("register an ontransformnode event handler")]
|
|
HRESULT ontransformnode(
|
|
[in] VARIANT ontransformnodeSink);
|
|
};
|
|
|
|
|
|
[
|
|
local, object,
|
|
uuid(373984c8-b845-449b-91e7-45ac83036ade),
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
helpstring("XML Schemas Collection"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IXMLDOMSchemaCollection : IDispatch
|
|
{
|
|
[id(DISPID_XMLDOM_SCHEMACOLLECTION_ADD),
|
|
helpstring("add a new schema")]
|
|
HRESULT add(
|
|
[in] BSTR namespaceURI,
|
|
[in] VARIANT var);
|
|
|
|
[id(DISPID_XMLDOM_SCHEMACOLLECTION_GET),
|
|
helpstring("lookup schema by namespaceURI")]
|
|
HRESULT get(
|
|
[in] BSTR namespaceURI,
|
|
[out,retval] IXMLDOMNode ** schemaNode);
|
|
|
|
[id(DISPID_XMLDOM_SCHEMACOLLECTION_REMOVE),
|
|
helpstring("remove schema by namespaceURI")]
|
|
HRESULT remove(
|
|
[in] BSTR namespaceURI);
|
|
|
|
[id(DISPID_XMLDOM_SCHEMACOLLECTION_LENGTH),
|
|
helpstring("number of schema in collection"), propget]
|
|
HRESULT length(
|
|
[out, retval] long * length);
|
|
|
|
[propget, id(DISPID_VALUE),
|
|
helpstring("Get namespaceURI for schema by index")]
|
|
HRESULT namespaceURI(
|
|
[in] long index,
|
|
[out, retval] BSTR * length);
|
|
|
|
[id(DISPID_XMLDOM_SCHEMACOLLECTION_ADDCOLLECTION),
|
|
helpstring("copye & merge other collection into this one")]
|
|
HRESULT addCollection(
|
|
[in] IXMLDOMSchemaCollection * otherCollection);
|
|
|
|
[propget, restricted, hidden,
|
|
id(DISPID_NEWENUM)]
|
|
HRESULT _newEnum(
|
|
[retval, out] IUnknown ** ppUnk);
|
|
};
|
|
|
|
|
|
[
|
|
local, object,
|
|
uuid(2933BF95-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMDocument2
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
pointer_default(unique)
|
|
]
|
|
interface IXMLDOMDocument2 : IXMLDOMDocument
|
|
{
|
|
[propget, id(DISPID_XMLDOM_DOCUMENT2_NAMESPACES),
|
|
helpstring("A collection of all namespaces for this document")]
|
|
HRESULT namespaces(
|
|
[out,retval] IXMLDOMSchemaCollection ** namespaceCollection);
|
|
|
|
[propget, id(DISPID_XMLDOM_DOCUMENT2_SCHEMAS),
|
|
helpstring("The associated schema cache")]
|
|
HRESULT schemas(
|
|
[out,retval] VARIANT * otherCollection);
|
|
|
|
[propputref, id(DISPID_XMLDOM_DOCUMENT2_SCHEMAS),
|
|
helpstring("The associated schema cache")]
|
|
HRESULT schemas(
|
|
[in] VARIANT otherCollection);
|
|
|
|
[id(DISPID_XMLDOM_DOCUMENT2_VALIDATE),
|
|
helpstring("perform runtime validation on the currently loaded XML document")]
|
|
HRESULT validate(
|
|
[retval, out] IXMLDOMParseError ** errorObj);
|
|
|
|
[id(DISPID_XMLDOM_DOCUMENT2_SETPROPERTY),
|
|
helpstring("set the value of the named property")]
|
|
HRESULT setProperty(
|
|
[in] BSTR name,
|
|
[in] VARIANT value);
|
|
|
|
[id(DISPID_XMLDOM_DOCUMENT2_GETPROPERTY),
|
|
helpstring("get the value of the named property")]
|
|
HRESULT getProperty(
|
|
[in] BSTR name,
|
|
[out,retval] VARIANT * value);
|
|
};
|
|
|
|
|
|
[
|
|
local, object,
|
|
uuid(2933BF82-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMNodeList
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
pointer_default(unique)
|
|
]
|
|
interface IXMLDOMNodeList : IDispatch
|
|
{
|
|
// Node item(in unsigned long index);
|
|
[propget, id(DISPID_VALUE),
|
|
helpstring("collection of nodes")]
|
|
HRESULT item(
|
|
[in] long index,
|
|
[out, retval] IXMLDOMNode ** listItem);
|
|
|
|
// readonly attribute unsigned long length;
|
|
[propget, id(DISPID_DOM_NODELIST_LENGTH),
|
|
helpstring("number of nodes in the collection")]
|
|
HRESULT length(
|
|
[out, retval] long * listLength);
|
|
|
|
[id(DISPID_XMLDOM_NODELIST_NEXTNODE),
|
|
helpstring("get next node from iterator")]
|
|
HRESULT nextNode(
|
|
[out, retval] IXMLDOMNode ** nextItem);
|
|
|
|
[id(DISPID_XMLDOM_NODELIST_RESET),
|
|
helpstring("reset the position of iterator")]
|
|
HRESULT reset();
|
|
|
|
[propget, restricted, hidden,
|
|
id(DISPID_NEWENUM)]
|
|
HRESULT _newEnum(
|
|
[retval, out] IUnknown ** ppUnk);
|
|
};
|
|
|
|
|
|
[
|
|
local, object,
|
|
uuid(AA634FC7-5888-44a7-A257-3A47150D3A0E), // IID_IXMLDOMSelection
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
pointer_default(unique)
|
|
]
|
|
interface IXMLDOMSelection : IXMLDOMNodeList
|
|
{
|
|
[propget, id(DISPID_XMLDOM_SELECTION_EXPR),
|
|
helpstring("selection expression")]
|
|
HRESULT expr(
|
|
[out, retval] BSTR * expression);
|
|
|
|
[propput, id(DISPID_XMLDOM_SELECTION_EXPR),
|
|
helpstring("selection expression")]
|
|
HRESULT expr(
|
|
[in] BSTR expression);
|
|
|
|
[propget, id(DISPID_XMLDOM_SELECTION_CONTEXT),
|
|
helpstring("nodes to apply selection expression to")]
|
|
HRESULT context(
|
|
[out, retval] IXMLDOMNode ** ppNode);
|
|
|
|
[propputref, id(DISPID_XMLDOM_SELECTION_CONTEXT),
|
|
helpstring("nodes to apply selection expression to")]
|
|
HRESULT context(
|
|
[in] IXMLDOMNode * pNode);
|
|
|
|
[id(DISPID_XMLDOM_SELECTION_PEEKNODE),
|
|
helpstring("gets the next node without advancing the list position")]
|
|
HRESULT peekNode(
|
|
[out, retval] IXMLDOMNode ** ppNode);
|
|
|
|
[id(DISPID_XMLDOM_SELECTION_MATCHES),
|
|
helpstring("checks to see if the node matches the pattern")]
|
|
HRESULT matches(
|
|
[in] IXMLDOMNode * pNode,
|
|
[out, retval] IXMLDOMNode ** ppNode);
|
|
|
|
[id(DISPID_XMLDOM_SELECTION_REMOVENEXT),
|
|
helpstring("removes the next node")]
|
|
HRESULT removeNext(
|
|
[out, retval] IXMLDOMNode ** ppNode);
|
|
|
|
[id(DISPID_XMLDOM_SELECTION_REMOVEALL),
|
|
helpstring("removes all the nodes that match the selection")]
|
|
HRESULT removeAll();
|
|
|
|
[id(DISPID_XMLDOM_SELECTION_CLONE),
|
|
helpstring("clone this object with the same position and context")]
|
|
HRESULT clone(
|
|
[out, retval] IXMLDOMSelection ** ppNode);
|
|
|
|
[id(DISPID_XMLDOM_SELECTION_GETPROPERTY),
|
|
helpstring("get the value of the named property")]
|
|
HRESULT getProperty(
|
|
[in] BSTR name,
|
|
[out,retval] VARIANT * value);
|
|
|
|
[id(DISPID_XMLDOM_SELECTION_SETPROPERTY),
|
|
helpstring("set the value of the named property")]
|
|
HRESULT setProperty(
|
|
[in] BSTR name,
|
|
[in] VARIANT value);
|
|
};
|
|
|
|
|
|
[
|
|
local, object,
|
|
uuid(2933BF83-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMNamedNodeMap
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
pointer_default(unique)
|
|
]
|
|
interface IXMLDOMNamedNodeMap : IDispatch
|
|
{
|
|
// Node getNamedItem(in wstring name);
|
|
[id(DISPID_DOM_NAMEDNODEMAP_GETNAMEDITEM),
|
|
helpstring("lookup item by name")]
|
|
HRESULT getNamedItem(
|
|
[in] BSTR name,
|
|
[out, retval] IXMLDOMNode ** namedItem);
|
|
|
|
// void setNamedItem(in Node arg);
|
|
[id(DISPID_DOM_NAMEDNODEMAP_SETNAMEDITEM),
|
|
helpstring("set item by name")]
|
|
HRESULT setNamedItem(
|
|
[in] IXMLDOMNode * newItem,
|
|
[out, retval] IXMLDOMNode ** nameItem);
|
|
|
|
// Node removeNamedItem(in wstring name);
|
|
[id(DISPID_DOM_NAMEDNODEMAP_REMOVENAMEDITEM),
|
|
helpstring("remove item by name")]
|
|
HRESULT removeNamedItem(
|
|
[in] BSTR name,
|
|
[out, retval] IXMLDOMNode ** namedItem);
|
|
|
|
// Node item(in unsigned long index);
|
|
[propget, id(DISPID_VALUE),
|
|
helpstring("collection of nodes")]
|
|
HRESULT item(
|
|
[in] long index,
|
|
[out, retval] IXMLDOMNode ** listItem);
|
|
|
|
// readonly attribute unsigned long length;
|
|
[propget, id(DISPID_DOM_NODELIST_LENGTH),
|
|
helpstring("number of nodes in the collection")]
|
|
HRESULT length(
|
|
[out, retval] long * listLength);
|
|
|
|
// Node getQualifiedItem(in wstring name,in Node namespace);
|
|
[id(DISPID_XMLDOM_NAMEDNODEMAP_GETQUALIFIEDITEM),
|
|
helpstring("lookup the item by name and namespace")]
|
|
HRESULT getQualifiedItem(
|
|
[in] BSTR baseName,
|
|
[in] BSTR namespaceURI,
|
|
[out, retval] IXMLDOMNode ** qualifiedItem);
|
|
|
|
// Node removeQualifiedItem(in wstring name,in Node namespace);
|
|
[id(DISPID_XMLDOM_NAMEDNODEMAP_REMOVEQUALIFIEDITEM),
|
|
helpstring("remove the item by name and namespace")]
|
|
HRESULT removeQualifiedItem(
|
|
[in] BSTR baseName,
|
|
[in] BSTR namespaceURI,
|
|
[out, retval] IXMLDOMNode ** qualifiedItem);
|
|
|
|
[id(DISPID_XMLDOM_NAMEDNODEMAP_NEXTNODE),
|
|
helpstring("get next node from iterator")]
|
|
HRESULT nextNode(
|
|
[out, retval] IXMLDOMNode ** nextItem);
|
|
|
|
[id(DISPID_XMLDOM_NAMEDNODEMAP_RESET),
|
|
helpstring("reset the position of iterator")]
|
|
HRESULT reset();
|
|
|
|
[propget, restricted, hidden,
|
|
id(DISPID_NEWENUM)]
|
|
HRESULT _newEnum(
|
|
[retval, out] IUnknown ** ppUnk);
|
|
};
|
|
|
|
|
|
[
|
|
local, object,
|
|
uuid(3efaa413-272f-11d2-836f-0000f87a7782), // IID_IXMLDOMDocumentFragment
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
pointer_default(unique)
|
|
]
|
|
interface IXMLDOMDocumentFragment : IXMLDOMNode
|
|
{
|
|
};
|
|
|
|
|
|
[
|
|
local, object,
|
|
uuid(2933BF84-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMCharacterData
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
pointer_default(unique)
|
|
]
|
|
interface IXMLDOMCharacterData : IXMLDOMNode
|
|
{
|
|
// attribute wstring data;
|
|
[propget, id(DISPID_DOM_DATA_DATA),
|
|
helpstring("value of the node")]
|
|
HRESULT data(
|
|
[out, retval] BSTR * data);
|
|
|
|
[propput, id(DISPID_DOM_DATA_DATA),
|
|
helpstring("value of the node")]
|
|
HRESULT data(
|
|
[in] BSTR data);
|
|
|
|
// readonly attribute unsigned long length;
|
|
[propget, id(DISPID_DOM_DATA_LENGTH),
|
|
helpstring("number of characters in value")]
|
|
HRESULT length(
|
|
[out, retval] long * dataLength);
|
|
|
|
// wstring substring(in unsigned long offset,
|
|
// in unsigned long count)
|
|
// raises(DOMException);
|
|
[id(DISPID_DOM_DATA_SUBSTRING),
|
|
helpstring("retrieve substring of value")]
|
|
HRESULT substringData(
|
|
[in] long offset,
|
|
[in] long count,
|
|
[out, retval] BSTR * data);
|
|
|
|
// void append(in wstring arg);
|
|
[id(DISPID_DOM_DATA_APPEND),
|
|
helpstring("append string to value")]
|
|
HRESULT appendData(
|
|
[in] BSTR data);
|
|
|
|
// void insert(in unsigned long offset,
|
|
// in wstring arg)
|
|
// raises(DOMException);
|
|
[id(DISPID_DOM_DATA_INSERT),
|
|
helpstring("insert string into value")]
|
|
HRESULT insertData(
|
|
[in] long offset,
|
|
[in] BSTR data);
|
|
|
|
// void delete(in unsigned long offset,
|
|
// in unsigned long count)
|
|
// raises(DOMException);
|
|
[id(DISPID_DOM_DATA_DELETE),
|
|
helpstring("delete string within the value")]
|
|
HRESULT deleteData(
|
|
[in] long offset,
|
|
[in] long count);
|
|
|
|
// void replace(in unsigned long offset,
|
|
// in unsigned long count,
|
|
// in wstring arg)
|
|
// raises(DOMException);
|
|
[id(DISPID_DOM_DATA_REPLACE),
|
|
helpstring("replace string within the value")]
|
|
HRESULT replaceData(
|
|
[in] long offset,
|
|
[in] long count,
|
|
[in] BSTR data);
|
|
};
|
|
|
|
|
|
[
|
|
local, object,
|
|
uuid(2933BF85-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMAttribute
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
pointer_default(unique)
|
|
]
|
|
interface IXMLDOMAttribute : IXMLDOMNode
|
|
{
|
|
// wstring name;
|
|
[propget, id(DISPID_DOM_ATTRIBUTE_GETNAME),
|
|
helpstring("get name of the attribute")]
|
|
HRESULT name(
|
|
[out, retval] BSTR * attributeName);
|
|
|
|
// attribute boolean specified;
|
|
// ! This is defined as an extended property on IXMLDOMNode
|
|
|
|
// attribute wstring value;
|
|
[propget, id(DISPID_DOM_ATTRIBUTE_VALUE),
|
|
helpstring("string value of the attribute")]
|
|
HRESULT value(
|
|
[out, retval] VARIANT * attributeValue);
|
|
|
|
[propput, id(DISPID_DOM_ATTRIBUTE_VALUE),
|
|
helpstring("string value of the attribute")]
|
|
HRESULT value(
|
|
[in] VARIANT attributeValue);
|
|
};
|
|
|
|
|
|
[
|
|
local, object,
|
|
uuid(2933BF86-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMElement
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
pointer_default(unique)
|
|
]
|
|
interface IXMLDOMElement : IXMLDOMNode
|
|
{
|
|
// readonly attribute wstring tagName;
|
|
[propget, id(DISPID_DOM_ELEMENT_GETTAGNAME),
|
|
helpstring("get the tagName of the element")]
|
|
HRESULT tagName(
|
|
[out, retval] BSTR * tagName);
|
|
|
|
// wstring getAttribute(in wstring name);
|
|
[id(DISPID_DOM_ELEMENT_GETATTRIBUTE),
|
|
helpstring("look up the string value of an attribute by name")]
|
|
HRESULT getAttribute(
|
|
[in] BSTR name,
|
|
[out, retval] VARIANT * value);
|
|
|
|
// void setAttribute(in string name,
|
|
// in string value);
|
|
[id(DISPID_DOM_ELEMENT_SETATTRIBUTE),
|
|
helpstring("set the string value of an attribute by name")]
|
|
HRESULT setAttribute(
|
|
[in] BSTR name,
|
|
[in] VARIANT value);
|
|
|
|
// void removeAttribute(in wstring name);
|
|
[id(DISPID_DOM_ELEMENT_REMOVEATTRIBUTE),
|
|
helpstring("remove an attribute by name")]
|
|
HRESULT removeAttribute(
|
|
[in] BSTR name);
|
|
|
|
// Attribute getAttributeNode(in wstring name);
|
|
[id(DISPID_DOM_ELEMENT_GETATTRIBUTENODE),
|
|
helpstring("look up the attribute node by name")]
|
|
HRESULT getAttributeNode(
|
|
[in] BSTR name,
|
|
[out, retval] IXMLDOMAttribute ** attributeNode);
|
|
|
|
// void setAttributeNode(in Attribute newAttr);
|
|
[id(DISPID_DOM_ELEMENT_SETATTRIBUTENODE),
|
|
helpstring("set the specified attribute on the element")]
|
|
HRESULT setAttributeNode(
|
|
[in] IXMLDOMAttribute * DOMAttribute,
|
|
[out, retval] IXMLDOMAttribute ** attributeNode);
|
|
|
|
// void removeAttributeNode(in Attribute oldAttr);
|
|
[id(DISPID_DOM_ELEMENT_REMOVEATTRIBUTENODE),
|
|
helpstring("remove the specified attribute")]
|
|
HRESULT removeAttributeNode(
|
|
[in] IXMLDOMAttribute * DOMAttribute,
|
|
[out, retval] IXMLDOMAttribute ** attributeNode);
|
|
|
|
// NodeList getElementsByTagName(in wstring tagname);
|
|
[id(DISPID_DOM_ELEMENT_GETELEMENTSBYTAGNAME),
|
|
helpstring("build a list of elements by name")]
|
|
HRESULT getElementsByTagName(
|
|
[in] BSTR tagName,
|
|
[out, retval] IXMLDOMNodeList ** resultList);
|
|
|
|
// void normalize();
|
|
[id(DISPID_DOM_ELEMENT_NORMALIZE),
|
|
helpstring("collapse all adjacent text nodes in sub-tree")]
|
|
HRESULT normalize();
|
|
};
|
|
|
|
|
|
[
|
|
local, object,
|
|
uuid(2933BF87-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMText
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
pointer_default(unique)
|
|
]
|
|
interface IXMLDOMText : IXMLDOMCharacterData
|
|
{
|
|
// Text splitText(in unsigned long offset);
|
|
[id(DISPID_DOM_TEXT_SPLITTEXT),
|
|
helpstring("split the text node into two text nodes at the position specified")]
|
|
HRESULT splitText(
|
|
[in] long offset,
|
|
[out, retval] IXMLDOMText ** rightHandTextNode);
|
|
};
|
|
|
|
|
|
[
|
|
local, object,
|
|
uuid(2933BF88-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMComment
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
pointer_default(unique)
|
|
]
|
|
interface IXMLDOMComment : IXMLDOMCharacterData
|
|
{
|
|
};
|
|
|
|
|
|
[
|
|
local, object,
|
|
uuid(2933BF89-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMProcessingInstruction
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
pointer_default(unique)
|
|
]
|
|
interface IXMLDOMProcessingInstruction : IXMLDOMNode
|
|
{
|
|
// read-only attribute wstring target;
|
|
[propget, id(DISPID_DOM_PI_TARGET),
|
|
helpstring("the target")]
|
|
HRESULT target(
|
|
[out, retval] BSTR * name);
|
|
|
|
// attribute wstring data;
|
|
[propget, id(DISPID_DOM_PI_DATA),
|
|
helpstring("the data")]
|
|
HRESULT data(
|
|
[out, retval] BSTR * value);
|
|
|
|
[propput, id(DISPID_DOM_PI_DATA),
|
|
helpstring("the data")]
|
|
HRESULT data(
|
|
[in] BSTR value);
|
|
};
|
|
|
|
|
|
[
|
|
local, object,
|
|
uuid(2933BF8A-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMCDATASection
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
pointer_default(unique)
|
|
]
|
|
interface IXMLDOMCDATASection : IXMLDOMText
|
|
{
|
|
};
|
|
|
|
|
|
[
|
|
local, object,
|
|
uuid(2933BF8B-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMDocumentType
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
pointer_default(unique)
|
|
]
|
|
interface IXMLDOMDocumentType : IXMLDOMNode
|
|
{
|
|
// readonly attribute wstring name;
|
|
[propget, id(DISPID_DOM_DOCUMENTTYPE_NAME),
|
|
helpstring("name of the document type (root of the tree)")]
|
|
HRESULT name(
|
|
[out, retval] BSTR * rootName);
|
|
|
|
// readonly attribute NamedNodeMap entities;
|
|
[propget, id(DISPID_DOM_DOCUMENTTYPE_ENTITIES),
|
|
helpstring("a list of entities in the document")]
|
|
HRESULT entities(
|
|
[out, retval] IXMLDOMNamedNodeMap ** entityMap);
|
|
|
|
// readonly attribute NamedNodeMap notations;
|
|
[propget, id(DISPID_DOM_DOCUMENTTYPE_NOTATIONS),
|
|
helpstring("a list of notations in the document")]
|
|
HRESULT notations(
|
|
[out, retval] IXMLDOMNamedNodeMap ** notationMap);
|
|
};
|
|
|
|
|
|
[
|
|
local, object,
|
|
uuid(2933BF8C-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMNotation
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
pointer_default(unique)
|
|
]
|
|
interface IXMLDOMNotation : IXMLDOMNode
|
|
{
|
|
// attribute wstring publicId;
|
|
[propget, id(DISPID_DOM_NOTATION_PUBLICID),
|
|
helpstring("the public ID")]
|
|
HRESULT publicId(
|
|
[out, retval] VARIANT * publicID);
|
|
|
|
// attribute wstring systemId;
|
|
[propget, id(DISPID_DOM_NOTATION_SYSTEMID),
|
|
helpstring("the system ID")]
|
|
HRESULT systemId(
|
|
[out, retval] VARIANT * systemID);
|
|
};
|
|
|
|
|
|
[
|
|
local, object,
|
|
uuid(2933BF8D-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMEntity
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
pointer_default(unique)
|
|
]
|
|
interface IXMLDOMEntity : IXMLDOMNode
|
|
{
|
|
// attribute wstring publicId;
|
|
[propget, id(DISPID_DOM_ENTITY_PUBLICID),
|
|
helpstring("the public ID")]
|
|
HRESULT publicId(
|
|
[out, retval] VARIANT * publicID);
|
|
|
|
// attribute wstring systemId;
|
|
[propget, id(DISPID_DOM_ENTITY_SYSTEMID),
|
|
helpstring("the system ID")]
|
|
HRESULT systemId(
|
|
[out, retval] VARIANT * systemID);
|
|
|
|
// attribute wstring notationName;
|
|
[propget, id(DISPID_DOM_ENTITY_NOTATIONNAME),
|
|
helpstring("the name of the notation")]
|
|
HRESULT notationName(
|
|
[out, retval] BSTR * name);
|
|
};
|
|
|
|
|
|
[
|
|
local, object,
|
|
uuid(2933BF8E-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMEntityReference
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
pointer_default(unique)
|
|
]
|
|
interface IXMLDOMEntityReference : IXMLDOMNode
|
|
{
|
|
};
|
|
|
|
[
|
|
local, object,
|
|
nonextensible,
|
|
pointer_default(unique),
|
|
odl,
|
|
oleautomation,
|
|
dual,
|
|
uuid(2933BF8F-7B36-11d2-B20E-00C04F983E60) // IID_IXMLDOMImplementation
|
|
]
|
|
interface IXMLDOMImplementation : IDispatch
|
|
{
|
|
// boolean hasFeature(in wstring feature,
|
|
// in wstring version);
|
|
[id(DISPID_DOM_IMPLEMENTATION_HASFEATURE)]
|
|
HRESULT hasFeature(
|
|
[in] BSTR feature,
|
|
[in] BSTR version,
|
|
[out, retval] VARIANT_BOOL * hasFeature);
|
|
};
|
|
|
|
|
|
[
|
|
local, object,
|
|
uuid(3efaa425-272f-11d2-836f-0000f87a7782), // IID_IXTLRuntime
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
helpstring("XTL runtime object"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IXTLRuntime : IXMLDOMNode
|
|
{
|
|
[id(DISPID_XTLRUNTIME_UNIQUEID),
|
|
helpstring("")]
|
|
HRESULT uniqueID(
|
|
[in]IXMLDOMNode *pNode,
|
|
[out,retval]long *pID);
|
|
|
|
[id(DISPID_XTLRUNTIME_DEPTH),
|
|
helpstring("")]
|
|
HRESULT depth(
|
|
[in] IXMLDOMNode *pNode,
|
|
[out,retval]long * pDepth);
|
|
|
|
[id(DISPID_XTLRUNTIME_CHILDNUMBER),
|
|
helpstring("")]
|
|
HRESULT childNumber(
|
|
[in]IXMLDOMNode *pNode,
|
|
[out,retval] long *pNumber);
|
|
|
|
[id(DISPID_XTLRUNTIME_ANCESTORCHILDNUMBER),
|
|
helpstring("")]
|
|
HRESULT ancestorChildNumber(
|
|
[in]BSTR bstrNodeName,
|
|
[in]IXMLDOMNode *pNode,
|
|
[out,retval]long *pNumber);
|
|
|
|
[id(DISPID_XTLRUNTIME_ABSOLUTECHILDNUMBER),
|
|
helpstring("")]
|
|
HRESULT absoluteChildNumber(
|
|
[in]IXMLDOMNode *pNode,
|
|
[out,retval]long *pNumber);
|
|
|
|
[id(DISPID_XTLRUNTIME_FORMATINDEX),
|
|
helpstring("")]
|
|
HRESULT formatIndex(
|
|
[in] long lIndex,
|
|
[in] BSTR bstrFormat,
|
|
[out, retval]BSTR *pbstrFormattedString);
|
|
|
|
[id(DISPID_XTLRUNTIME_FORMATNUMBER),
|
|
helpstring("")]
|
|
HRESULT formatNumber(
|
|
[in] double dblNumber,
|
|
[in] BSTR bstrFormat,
|
|
[out, retval]BSTR *pbstrFormattedString);
|
|
|
|
[id(DISPID_XTLRUNTIME_FORMATDATE),
|
|
helpstring("")]
|
|
HRESULT formatDate(
|
|
[in] VARIANT varDate,
|
|
[in] BSTR bstrFormat,
|
|
[in,optional] VARIANT varDestLocale,
|
|
[out, retval]BSTR *pbstrFormattedString);
|
|
|
|
[id(DISPID_XTLRUNTIME_FORMATTIME),
|
|
helpstring("")]
|
|
HRESULT formatTime(
|
|
[in] VARIANT varTime,
|
|
[in] BSTR bstrFormat,
|
|
[in,optional] VARIANT varDestLocale,
|
|
[out, retval]BSTR *pbstrFormattedString);
|
|
};
|
|
|
|
[
|
|
local, object,
|
|
uuid(3efaa426-272f-11d2-836f-0000f87a7782), // IID_IXMLDOMParseError
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
helpstring("structure for reporting parser errors"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IXMLDOMParseError : IDispatch
|
|
{
|
|
[propget, id(DISPID_VALUE),
|
|
helpstring("the error code")]
|
|
HRESULT errorCode(
|
|
[retval, out] long * errorCode);
|
|
|
|
[propget, id(DISPID_DOM_ERROR_URL),
|
|
helpstring("the URL of the XML document containing the error")]
|
|
HRESULT url(
|
|
[retval, out] BSTR * urlString);
|
|
|
|
[propget, id(DISPID_DOM_ERROR_REASON),
|
|
helpstring("the cause of the error")]
|
|
HRESULT reason(
|
|
[retval, out] BSTR * reasonString);
|
|
|
|
[propget, id(DISPID_DOM_ERROR_SRCTEXT),
|
|
helpstring("the data where the error occurred")]
|
|
HRESULT srcText(
|
|
[retval, out] BSTR * sourceString);
|
|
|
|
[propget, id(DISPID_DOM_ERROR_LINE),
|
|
helpstring("the line number in the XML document where the error occurred")]
|
|
HRESULT line(
|
|
[retval, out] long * lineNumber);
|
|
|
|
[propget, id(DISPID_DOM_ERROR_LINEPOS),
|
|
helpstring("the character position in the line containing the error")]
|
|
HRESULT linepos(
|
|
[retval, out] long * linePosition);
|
|
|
|
[propget, id(DISPID_DOM_ERROR_FILEPOS),
|
|
helpstring("the absolute file position in the XML document containing the error")]
|
|
HRESULT filepos(
|
|
[retval, out] long * filePosition);
|
|
};
|
|
|
|
// DOM event interface
|
|
[
|
|
hidden,
|
|
uuid(3efaa427-272f-11d2-836f-0000f87a7782) // IID_IXMLDOMEvent
|
|
]
|
|
dispinterface XMLDOMDocumentEvents
|
|
{
|
|
properties:
|
|
methods:
|
|
[id (DISPID_XMLDOMEVENT_ONDATAAVAILABLE)]
|
|
HRESULT ondataavailable(void);
|
|
|
|
[id (DISPID_XMLDOMEVENT_ONREADYSTATECHANGE)]
|
|
HRESULT onreadystatechange(void);
|
|
};
|
|
|
|
|
|
[
|
|
local, object,
|
|
uuid(2933BF92-7B36-11d2-B20E-00C04F983E60), // IXSLProcessor
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
helpstring("IXSLProcessor Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IXSLProcessor : IDispatch
|
|
{
|
|
[propput, id(DISPID_XMLDOM_PROCESSOR_INPUT), helpstring("XML input tree to transform")]
|
|
HRESULT input([in] VARIANT var);
|
|
|
|
[propget, id(DISPID_XMLDOM_PROCESSOR_INPUT), helpstring("XML input tree to transform")]
|
|
HRESULT input([out,retval] VARIANT * pVar);
|
|
|
|
[propget, id(DISPID_XMLDOM_PROCESSOR_XSLTEMPLATE), helpstring("template object used to create this processor object")]
|
|
HRESULT ownerTemplate([out,retval] IXSLTemplate** ppTemplate);
|
|
|
|
[id(DISPID_XMLDOM_PROCESSOR_SETSTARTMODE), helpstring("set XSL mode and it's namespace")]
|
|
HRESULT setStartMode([in] BSTR mode,
|
|
[in, defaultvalue("")] BSTR namespaceURI);
|
|
|
|
[propget, id(DISPID_XMLDOM_PROCESSOR_STARTMODE), helpstring("starting XSL mode")]
|
|
HRESULT startMode([out, retval] BSTR * mode);
|
|
|
|
[propget, id(DISPID_XMLDOM_PROCESSOR_STARTMODEURI), helpstring("namespace of starting XSL mode")]
|
|
HRESULT startModeURI([out, retval] BSTR * namespaceURI);
|
|
|
|
[propput, id(DISPID_XMLDOM_PROCESSOR_OUTPUT), helpstring("custom stream object for transform output")]
|
|
HRESULT output([in] VARIANT output);
|
|
|
|
[propget, id(DISPID_XMLDOM_PROCESSOR_OUTPUT), helpstring("transform output")]
|
|
HRESULT output([out, retval] VARIANT* pOutput);
|
|
|
|
[id(DISPID_XMLDOM_PROCESSOR_TRANSFORM), helpstring("start/resume the XSL transformation process")]
|
|
HRESULT transform([out,retval] VARIANT_BOOL* pDone);
|
|
|
|
[id(DISPID_XMLDOM_PROCESSOR_RESET), helpstring("reset state of processor and abort current transform")]
|
|
HRESULT reset();
|
|
|
|
[propget, id(DISPID_XMLDOM_PROCESSOR_READYSTATE), helpstring("current state of the processor")]
|
|
HRESULT readyState([out, retval] long* pReadyState);
|
|
|
|
[id(DISPID_XMLDOM_PROCESSOR_ADDPARAMETER), helpstring("set <xsl:param> values")]
|
|
HRESULT addParameter([in] BSTR baseName,
|
|
[in] VARIANT parameter,
|
|
[in, defaultvalue("")] BSTR namespaceURI);
|
|
|
|
[id(DISPID_XMLDOM_PROCESSOR_ADDOBJECT), helpstring("pass object to stylesheet")]
|
|
HRESULT addObject([in] IDispatch* obj,
|
|
[in] BSTR namespaceURI);
|
|
|
|
[propget, id(DISPID_XMLDOM_PROCESSOR_STYLESHEET), helpstring("current stylesheet being used")]
|
|
HRESULT stylesheet([out,retval] IXMLDOMNode** stylesheet);
|
|
};
|
|
|
|
|
|
[
|
|
local, object,
|
|
uuid(2933BF93-7B36-11d2-B20E-00C04F983E60), // IID_IXSLTemplate
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
helpstring("IXSLTemplate Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IXSLTemplate : IDispatch
|
|
{
|
|
[propputref, id(DISPID_XMLDOM_TEMPLATE_STYLESHEET), helpstring("stylesheet to use with processors")]
|
|
HRESULT stylesheet([in] IXMLDOMNode* stylesheet);
|
|
|
|
[propget, id(DISPID_XMLDOM_TEMPLATE_STYLESHEET), helpstring("stylesheet to use with processors")]
|
|
HRESULT stylesheet([out, retval] IXMLDOMNode** stylesheet);
|
|
|
|
[id(DISPID_XMLDOM_TEMPLATE_CREATEPROCESSOR), helpstring("create a new processor object")]
|
|
HRESULT createProcessor([out, retval] IXSLProcessor** ppProcessor);
|
|
};
|
|
|
|
|
|
[
|
|
local, object,
|
|
uuid(310afa62-0575-11d2-9ca9-0060b0ec3d39),
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
hidden, // Because that this is the default interface of coclass DSOControl
|
|
helpstring("DSO Control"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IDSOControl : IDispatch
|
|
{
|
|
[propget,id(DISPID_XMLDSO_DOCUMENT)]
|
|
HRESULT XMLDocument([out, retval] IXMLDOMDocument** ppDoc);
|
|
[propput,id(DISPID_XMLDSO_DOCUMENT)]
|
|
HRESULT XMLDocument([in] IXMLDOMDocument* ppDoc);
|
|
|
|
[propget,id(DISPID_XMLDSO_JAVADSOCOMPATIBLE)]
|
|
HRESULT JavaDSOCompatible([out, retval] BOOL* fJavaDSOCompatible);
|
|
[propput,id(DISPID_XMLDSO_JAVADSOCOMPATIBLE)]
|
|
HRESULT JavaDSOCompatible([in] BOOL fJavaDSOCompatible);
|
|
|
|
[propget, id(DISPID_READYSTATE)]
|
|
HRESULT readyState([out, retval] long *state);
|
|
};
|
|
|
|
|
|
[
|
|
object,
|
|
uuid(ED8C108D-4349-11D2-91A4-00C04F7969E8),
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
helpstring("IXMLHTTPRequest Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IXMLHTTPRequest : IDispatch
|
|
{
|
|
[id(1), helpstring("Open HTTP connection")] HRESULT open([in] BSTR bstrMethod, [in] BSTR bstrUrl, [in,optional] VARIANT varAsync, [in,optional] VARIANT bstrUser, [in,optional] VARIANT bstrPassword);
|
|
[id(2), helpstring("Add HTTP request header")] HRESULT setRequestHeader([in] BSTR bstrHeader, [in] BSTR bstrValue);
|
|
[id(3), helpstring("Get HTTP response header")] HRESULT getResponseHeader([in] BSTR bstrHeader, [out, retval] BSTR * pbstrValue);
|
|
[id(4), helpstring("Get all HTTP response headers")] HRESULT getAllResponseHeaders([out, retval] BSTR * pbstrHeaders);
|
|
[id(5), helpstring("Send HTTP request")] HRESULT send([in, optional] VARIANT varBody);
|
|
[id(6), helpstring("Abort HTTP request")] HRESULT abort();
|
|
[propget, id(7), helpstring("Get HTTP status code")] HRESULT status([out, retval] long * plStatus);
|
|
[propget, id(8), helpstring("Get HTTP status text")] HRESULT statusText([out, retval] BSTR * pbstrStatus);
|
|
[propget, id(9), helpstring("Get response body")] HRESULT responseXML([out, retval] IDispatch ** ppBody);
|
|
[propget, id(10), helpstring("Get response body")] HRESULT responseText([out, retval] BSTR * pbstrBody);
|
|
[propget, id(11), helpstring("Get response body")] HRESULT responseBody([out, retval] VARIANT * pvarBody);
|
|
[propget, id(12), helpstring("Get response body")] HRESULT responseStream([out, retval] VARIANT * pvarBody);
|
|
[propget, id(13), helpstring("Get ready state")] HRESULT readyState([out, retval] long * plState);
|
|
[propput, id(14), helpstring("Register a complete event handler")] HRESULT onreadystatechange([in] IDispatch * pReadyStateSink);
|
|
};
|
|
|
|
|
|
typedef [
|
|
helpstring("Options for ServerXMLHTTPRequest Option property")
|
|
]
|
|
enum _SERVERXMLHTTP_OPTION
|
|
{
|
|
SXH_OPTION_URL_CODEPAGE,
|
|
SXH_OPTION_ESCAPE_PERCENT_IN_URL,
|
|
SXH_OPTION_IGNORE_SERVER_SSL_CERT_ERROR_FLAGS,
|
|
SXH_OPTION_SELECT_CLIENT_SSL_CERT
|
|
} SERVERXMLHTTP_OPTION;
|
|
|
|
|
|
typedef [
|
|
helpstring("Flags for SXH_OPTION_IGNORE_SERVER_SSL_CERT_ERROR_FLAGS option")
|
|
]
|
|
enum _SXH_SERVER_CERT_OPTION
|
|
{
|
|
SXH_SERVER_CERT_IGNORE_UNKNOWN_CA = 0x00000100,
|
|
SXH_SERVER_CERT_IGNORE_WRONG_USAGE = 0x00000200,
|
|
SXH_SERVER_CERT_IGNORE_CERT_CN_INVALID = 0x00001000,
|
|
SXH_SERVER_CERT_IGNORE_CERT_DATE_INVALID = 0x00002000,
|
|
SXH_SERVER_CERT_IGNORE_ALL_SERVER_ERRORS = (SXH_SERVER_CERT_IGNORE_UNKNOWN_CA
|
|
+ SXH_SERVER_CERT_IGNORE_WRONG_USAGE
|
|
+ SXH_SERVER_CERT_IGNORE_CERT_CN_INVALID
|
|
+ SXH_SERVER_CERT_IGNORE_CERT_DATE_INVALID)
|
|
} SXH_SERVER_CERT_OPTION;
|
|
|
|
|
|
|
|
[
|
|
object,
|
|
uuid(2e9196bf-13ba-4dd4-91ca-6c571f281495),
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
helpstring("IServerXMLHTTPRequest Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IServerXMLHTTPRequest : IXMLHTTPRequest
|
|
{
|
|
[id(15), helpstring("Specify timeout settings (in milliseconds)")]
|
|
HRESULT setTimeouts([in] long resolveTimeout, [in] long connectTimeout, [in] long sendTimeout, [in] long receiveTimeout);
|
|
|
|
[id(16), helpstring("Wait for asynchronous send to complete, with optional timeout (in seconds)")]
|
|
HRESULT waitForResponse([in, optional] VARIANT timeoutInSeconds, [out, retval] VARIANT_BOOL * isSuccessful);
|
|
|
|
[id(17), helpstring("Get an option value")]
|
|
HRESULT getOption([in] SERVERXMLHTTP_OPTION option, [out, retval] VARIANT * value);
|
|
|
|
[id(18), helpstring("Set an option value")]
|
|
HRESULT setOption([in] SERVERXMLHTTP_OPTION option, [in] VARIANT value);
|
|
};
|
|
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// SAX Non-Automatable Interfaces
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
[
|
|
hidden,
|
|
object,
|
|
local,
|
|
uuid(a4f96ed0-f829-476e-81c0-cdc7bd2a0802), // IID_ISAXXMLReader
|
|
helpstring("ISAXXMLReader interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface ISAXXMLReader : IUnknown
|
|
{
|
|
HRESULT getFeature(
|
|
[in] const wchar_t * pwchName,
|
|
[out, retval] VARIANT_BOOL * pvfValue);
|
|
HRESULT putFeature(
|
|
[in] const wchar_t * pwchName,
|
|
[in] VARIANT_BOOL vfValue);
|
|
|
|
HRESULT getProperty(
|
|
[in] const wchar_t * pwchName,
|
|
[out, retval] VARIANT * pvarValue);
|
|
HRESULT putProperty(
|
|
[in] const wchar_t * pwchName,
|
|
[in] VARIANT varValue);
|
|
|
|
HRESULT getEntityResolver(
|
|
[out, retval] ISAXEntityResolver ** ppResolver);
|
|
HRESULT putEntityResolver(
|
|
[in] ISAXEntityResolver * pResolver);
|
|
|
|
HRESULT getContentHandler(
|
|
[out, retval] ISAXContentHandler ** ppHandler);
|
|
HRESULT putContentHandler(
|
|
[in] ISAXContentHandler * pHandler);
|
|
|
|
HRESULT getDTDHandler(
|
|
[out, retval] ISAXDTDHandler ** ppHandler);
|
|
HRESULT putDTDHandler(
|
|
[in] ISAXDTDHandler * pHandler);
|
|
|
|
HRESULT getErrorHandler(
|
|
[out, retval] ISAXErrorHandler ** ppHandler);
|
|
HRESULT putErrorHandler(
|
|
[in] ISAXErrorHandler * pHandler);
|
|
|
|
HRESULT getBaseURL(
|
|
[out, retval] const wchar_t ** ppwchBaseUrl);
|
|
HRESULT putBaseURL(
|
|
[in] const wchar_t * pwchBaseUrl);
|
|
|
|
HRESULT getSecureBaseURL(
|
|
[out, retval] const wchar_t ** ppwchSecureBaseUrl);
|
|
HRESULT putSecureBaseURL(
|
|
[in] const wchar_t * pwchSecureBaseUrl);
|
|
|
|
HRESULT parse(
|
|
[in] VARIANT varInput);
|
|
HRESULT parseURL(
|
|
[in] const wchar_t * pwchUrl);
|
|
};
|
|
|
|
[
|
|
hidden,
|
|
object,
|
|
local,
|
|
uuid(70409222-ca09-4475-acb8-40312fe8d145), // IID_ISAXXMLFilter
|
|
helpstring("ISAXXMLFilter interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface ISAXXMLFilter : ISAXXMLReader
|
|
{
|
|
HRESULT getParent(
|
|
[out, retval] ISAXXMLReader ** ppReader);
|
|
HRESULT putParent(
|
|
[in] ISAXXMLReader * pReader);
|
|
};
|
|
|
|
[
|
|
hidden,
|
|
object,
|
|
local,
|
|
uuid(9b7e472a-0de4-4640-bff3-84d38a051c31), // IID_ISAXLocator
|
|
helpstring("ISAXLocator interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface ISAXLocator : IUnknown
|
|
{
|
|
HRESULT getColumnNumber(
|
|
[out, retval] int * pnColumn);
|
|
|
|
HRESULT getLineNumber(
|
|
[out, retval] int * pnLine);
|
|
|
|
HRESULT getPublicId(
|
|
[out, retval] const wchar_t ** ppwchPublicId);
|
|
|
|
HRESULT getSystemId(
|
|
[out, retval] const wchar_t ** ppwchSystemId);
|
|
};
|
|
|
|
[
|
|
hidden,
|
|
object,
|
|
local,
|
|
uuid(99bca7bd-e8c4-4d5f-a0cf-6d907901ff07), // IID_ISAXEntityResolver
|
|
helpstring("ISAXEntityResolver interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface ISAXEntityResolver : IUnknown
|
|
{
|
|
HRESULT resolveEntity(
|
|
[in] const wchar_t * pwchPublicId,
|
|
[in] const wchar_t * pwchSystemId,
|
|
[out, retval] VARIANT * pvarInput);
|
|
};
|
|
|
|
[
|
|
hidden,
|
|
object,
|
|
local,
|
|
uuid(1545cdfa-9e4e-4497-a8a4-2bf7d0112c44), // IID_ISAXContentHandler
|
|
helpstring("ISAXContentHandler interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface ISAXContentHandler : IUnknown
|
|
{
|
|
HRESULT putDocumentLocator(
|
|
[in] ISAXLocator * pLocator);
|
|
|
|
HRESULT startDocument();
|
|
|
|
HRESULT endDocument();
|
|
|
|
HRESULT startPrefixMapping(
|
|
[in] const wchar_t * pwchPrefix,
|
|
[in] int cchPrefix,
|
|
[in] const wchar_t * pwchUri,
|
|
[in] int cchUri);
|
|
|
|
HRESULT endPrefixMapping(
|
|
[in] const wchar_t * pwchPrefix,
|
|
[in] int cchPrefix);
|
|
|
|
HRESULT startElement(
|
|
[in] const wchar_t * pwchNamespaceUri,
|
|
[in] int cchNamespaceUri,
|
|
[in] const wchar_t * pwchLocalName,
|
|
[in] int cchLocalName,
|
|
[in] const wchar_t * pwchQName,
|
|
[in] int cchQName,
|
|
[in] ISAXAttributes * pAttributes);
|
|
|
|
HRESULT endElement(
|
|
[in] const wchar_t * pwchNamespaceUri,
|
|
[in] int cchNamespaceUri,
|
|
[in] const wchar_t * pwchLocalName,
|
|
[in] int cchLocalName,
|
|
[in] const wchar_t * pwchQName,
|
|
[in] int cchQName);
|
|
|
|
HRESULT characters(
|
|
[in] const wchar_t * pwchChars,
|
|
[in] int cchChars);
|
|
|
|
HRESULT ignorableWhitespace(
|
|
[in] const wchar_t * pwchChars,
|
|
[in] int cchChars);
|
|
|
|
HRESULT processingInstruction(
|
|
[in] const wchar_t * pwchTarget,
|
|
[in] int cchTarget,
|
|
[in] const wchar_t * pwchData,
|
|
[in] int cchData);
|
|
|
|
HRESULT skippedEntity(
|
|
[in] const wchar_t * pwchName,
|
|
[in] int cchName);
|
|
};
|
|
|
|
[
|
|
hidden,
|
|
object,
|
|
local,
|
|
uuid(e15c1baf-afb3-4d60-8c36-19a8c45defed), // IID_ISAXDTDHandler
|
|
helpstring("ISAXDTDHandler interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface ISAXDTDHandler : IUnknown
|
|
{
|
|
HRESULT notationDecl(
|
|
[in] const wchar_t * pwchName,
|
|
[in] int cchName,
|
|
[in] const wchar_t * pwchPublicId,
|
|
[in] int cchPublicId,
|
|
[in] const wchar_t * pwchSystemId,
|
|
[in] int cchSystemId);
|
|
|
|
HRESULT unparsedEntityDecl(
|
|
[in] const wchar_t * pwchName,
|
|
[in] int cchName,
|
|
[in] const wchar_t * pwchPublicId,
|
|
[in] int cchPublicId,
|
|
[in] const wchar_t * pwchSystemId,
|
|
[in] int cchSystemId,
|
|
[in] const wchar_t * pwchNotationName,
|
|
[in] int cchNotationName);
|
|
};
|
|
|
|
[
|
|
hidden,
|
|
object,
|
|
local,
|
|
uuid(a60511c4-ccf5-479e-98a3-dc8dc545b7d0), // IID_ISAXErrorHandler
|
|
helpstring("ISAXErrorHandler interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface ISAXErrorHandler : IUnknown
|
|
{
|
|
HRESULT error(
|
|
[in] ISAXLocator * pLocator,
|
|
[in] const wchar_t * pwchErrorMessage,
|
|
[in] HRESULT hrErrorCode);
|
|
|
|
HRESULT fatalError(
|
|
[in] ISAXLocator * pLocator,
|
|
[in] const wchar_t * pwchErrorMessage,
|
|
[in] HRESULT hrErrorCode);
|
|
|
|
HRESULT ignorableWarning(
|
|
[in] ISAXLocator * pLocator,
|
|
[in] const wchar_t * pwchErrorMessage,
|
|
[in] HRESULT hrErrorCode);
|
|
};
|
|
|
|
[
|
|
hidden,
|
|
object,
|
|
local,
|
|
uuid(7f85d5f5-47a8-4497-bda5-84ba04819ea6), // IID_ISAXLexicalHandler
|
|
helpstring("ISAXLexicalHandler interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface ISAXLexicalHandler : IUnknown
|
|
{
|
|
HRESULT startDTD(
|
|
[in] const wchar_t * pwchName,
|
|
[in] int cchName,
|
|
[in] const wchar_t * pwchPublicId,
|
|
[in] int cchPublicId,
|
|
[in] const wchar_t * pwchSystemId,
|
|
[in] int cchSystemId);
|
|
|
|
HRESULT endDTD();
|
|
|
|
HRESULT startEntity(
|
|
[in] const wchar_t * pwchName,
|
|
[in] int cchName);
|
|
|
|
HRESULT endEntity(
|
|
[in] const wchar_t * pwchName,
|
|
[in] int cchName);
|
|
|
|
HRESULT startCDATA();
|
|
|
|
HRESULT endCDATA();
|
|
|
|
HRESULT comment(
|
|
[in] const wchar_t * pwchChars,
|
|
[in] int cchChars);
|
|
};
|
|
|
|
[
|
|
hidden,
|
|
object,
|
|
local,
|
|
uuid(862629ac-771a-47b2-8337-4e6843c1be90), // IID_ISAXDeclHandler
|
|
helpstring("ISAXDeclHandler interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface ISAXDeclHandler : IUnknown
|
|
{
|
|
HRESULT elementDecl(
|
|
[in] const wchar_t * pwchName,
|
|
[in] int cchName,
|
|
[in] const wchar_t * pwchModel,
|
|
[in] int cchModel);
|
|
|
|
HRESULT attributeDecl(
|
|
[in] const wchar_t * pwchElementName,
|
|
[in] int cchElementName,
|
|
[in] const wchar_t * pwchAttributeName,
|
|
[in] int cchAttributeName,
|
|
[in] const wchar_t * pwchType,
|
|
[in] int cchType,
|
|
[in] const wchar_t * pwchValueDefault,
|
|
[in] int cchValueDefault,
|
|
[in] const wchar_t * pwchValue,
|
|
[in] int cchValue);
|
|
|
|
HRESULT internalEntityDecl(
|
|
[in] const wchar_t * pwchName,
|
|
[in] int cchName,
|
|
[in] const wchar_t * pwchValue,
|
|
[in] int cchValue);
|
|
|
|
HRESULT externalEntityDecl(
|
|
[in] const wchar_t * pwchName,
|
|
[in] int cchName,
|
|
[in] const wchar_t * pwchPublicId,
|
|
[in] int cchPublicId,
|
|
[in] const wchar_t * pwchSystemId,
|
|
[in] int cchSystemId);
|
|
};
|
|
|
|
[
|
|
hidden,
|
|
object,
|
|
local,
|
|
uuid(f078abe1-45d2-4832-91ea-4466ce2f25c9), // IID_ISAXAttributes
|
|
helpstring("ISAXAttributes interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface ISAXAttributes : IUnknown
|
|
{
|
|
HRESULT getLength(
|
|
[out, retval] int * pnLength);
|
|
|
|
HRESULT getURI(
|
|
[in] int nIndex,
|
|
[out] const wchar_t ** ppwchUri,
|
|
[out] int * pcchUri);
|
|
|
|
HRESULT getLocalName(
|
|
[in] int nIndex,
|
|
[out] const wchar_t ** ppwchLocalName,
|
|
[out] int * pcchLocalName);
|
|
|
|
HRESULT getQName(
|
|
[in] int nIndex,
|
|
[out] const wchar_t ** ppwchQName,
|
|
[out] int * pcchQName);
|
|
|
|
HRESULT getName(
|
|
[in] int nIndex,
|
|
[out] const wchar_t ** ppwchUri,
|
|
[out] int * pcchUri,
|
|
[out] const wchar_t ** ppwchLocalName,
|
|
[out] int * pcchLocalName,
|
|
[out] const wchar_t ** ppwchQName,
|
|
[out] int * pcchQName);
|
|
|
|
HRESULT getIndexFromName(
|
|
[in] const wchar_t * pwchUri,
|
|
[in] int cchUri,
|
|
[in] const wchar_t * pwchLocalName,
|
|
[in] int cchLocalName,
|
|
[out, retval] int * pnIndex);
|
|
|
|
HRESULT getIndexFromQName(
|
|
[in] const wchar_t * pwchQName,
|
|
[in] int cchQName,
|
|
[out, retval] int * pnIndex);
|
|
|
|
HRESULT getType(
|
|
[in] int nIndex,
|
|
[out] const wchar_t ** ppwchType,
|
|
[out] int * pcchType);
|
|
|
|
HRESULT getTypeFromName(
|
|
[in] const wchar_t * pwchUri,
|
|
[in] int cchUri,
|
|
[in] const wchar_t * pwchLocalName,
|
|
[in] int cchLocalName,
|
|
[out] const wchar_t ** ppwchType,
|
|
[out] int * pcchType);
|
|
|
|
HRESULT getTypeFromQName(
|
|
[in] const wchar_t * pwchQName,
|
|
[in] int cchQName,
|
|
[out] const wchar_t ** ppwchType,
|
|
[out] int * pcchType);
|
|
|
|
HRESULT getValue(
|
|
[in] int nIndex,
|
|
[out] const wchar_t ** ppwchValue,
|
|
[out] int * pcchValue);
|
|
|
|
HRESULT getValueFromName(
|
|
[in] const wchar_t * pwchUri,
|
|
[in] int cchUri,
|
|
[in] const wchar_t * pwchLocalName,
|
|
[in] int cchLocalName,
|
|
[out] const wchar_t ** ppwchValue,
|
|
[out] int * pcchValue);
|
|
|
|
HRESULT getValueFromQName(
|
|
[in] const wchar_t * pwchQName,
|
|
[in] int cchQName,
|
|
[out] const wchar_t ** ppwchValue,
|
|
[out] int * pcchValue);
|
|
};
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// SAX Automatable Interfaces
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
[
|
|
object,
|
|
local,
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
uuid(8c033caa-6cd6-4f73-b728-4531af74945f), // IID_IVBSAXXMLReader
|
|
helpstring("IVBSAXXMLReader interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVBSAXXMLReader : IDispatch
|
|
{
|
|
[id(DISPID_SAX_XMLREADER_GETFEATURE), helpstring("Look up the value of a feature.")]
|
|
HRESULT getFeature(
|
|
[in] BSTR strName,
|
|
[out, retval] VARIANT_BOOL * fValue);
|
|
[id(DISPID_SAX_XMLREADER_PUTFEATURE), helpstring("Set the state of a feature.")]
|
|
HRESULT putFeature(
|
|
[in] BSTR strName,
|
|
[in] VARIANT_BOOL fValue);
|
|
|
|
[id(DISPID_SAX_XMLREADER_GETPROPERTY), helpstring("Look up the value of a property.")]
|
|
HRESULT getProperty(
|
|
[in] BSTR strName,
|
|
[out, retval] VARIANT * varValue);
|
|
[id(DISPID_SAX_XMLREADER_PUTPROPERTY), helpstring("Set the value of a property.")]
|
|
HRESULT putProperty(
|
|
[in] BSTR strName,
|
|
[in] VARIANT varValue);
|
|
|
|
[propget, id(DISPID_SAX_XMLREADER_ENTITYRESOLVER), helpstring("Allow an application to register an entity resolver or look up the current entity resolver.")]
|
|
HRESULT entityResolver(
|
|
[out, retval] IVBSAXEntityResolver ** oResolver);
|
|
[propputref, id(DISPID_SAX_XMLREADER_ENTITYRESOLVER), helpstring("Allow an application to register an entity resolver or look up the current entity resolver.")]
|
|
HRESULT entityResolver(
|
|
[in] IVBSAXEntityResolver * oResolver);
|
|
|
|
[propget, id(DISPID_SAX_XMLREADER_CONTENTHANDLER), helpstring("Allow an application to register a content event handler or look up the current content event handler.")]
|
|
HRESULT contentHandler(
|
|
[out, retval] IVBSAXContentHandler ** oHandler);
|
|
[propputref, id(DISPID_SAX_XMLREADER_CONTENTHANDLER), helpstring("Allow an application to register a content event handler or look up the current content event handler")]
|
|
HRESULT contentHandler(
|
|
[in] IVBSAXContentHandler * oHandler);
|
|
|
|
[propget, id(DISPID_SAX_XMLREADER_DTDHANDLER), helpstring("Allow an application to register a DTD event handler or look up the current DTD event handler.")]
|
|
HRESULT dtdHandler(
|
|
[out, retval] IVBSAXDTDHandler ** oHandler);
|
|
[propputref, id(DISPID_SAX_XMLREADER_DTDHANDLER), helpstring("Allow an application to register a DTD event handler or look up the current DTD event handler.")]
|
|
HRESULT dtdHandler(
|
|
[in] IVBSAXDTDHandler * oHandler);
|
|
|
|
[propget, id(DISPID_SAX_XMLREADER_ERRORHANDLER), helpstring("Allow an application to register an error event handler or look up the current error event handler.")]
|
|
HRESULT errorHandler(
|
|
[out, retval] IVBSAXErrorHandler ** oHandler);
|
|
[propputref, id(DISPID_SAX_XMLREADER_ERRORHANDLER), helpstring("Allow an application to register an error event handler or look up the current error event handler.")]
|
|
HRESULT errorHandler(
|
|
[in] IVBSAXErrorHandler * oHandler);
|
|
|
|
[propget, id(DISPID_SAX_XMLREADER_BASEURL), helpstring("Set or get the base URL for the document.")]
|
|
HRESULT baseURL(
|
|
[out, retval] BSTR * strBaseURL);
|
|
[propput, id(DISPID_SAX_XMLREADER_BASEURL), helpstring("Set or get the base URL for the document.")]
|
|
HRESULT baseURL(
|
|
[in] BSTR strBaseURL);
|
|
|
|
[propget, id(DISPID_SAX_XMLREADER_SECUREBASEURL), helpstring("Set or get the secure base URL for the document.")]
|
|
HRESULT secureBaseURL(
|
|
[out, retval] BSTR * strSecureBaseURL);
|
|
[propput, id(DISPID_SAX_XMLREADER_SECUREBASEURL), helpstring("Set or get the secure base URL for the document.")]
|
|
HRESULT secureBaseURL(
|
|
[in] BSTR strSecureBaseURL);
|
|
|
|
[id(DISPID_SAX_XMLREADER_PARSE), helpstring("Parse an XML document.")]
|
|
HRESULT parse(
|
|
[in] VARIANT varInput);
|
|
[id(DISPID_SAX_XMLREADER_PARSEURL), helpstring("Parse an XML document from a system identifier (URI).")]
|
|
HRESULT parseURL(
|
|
[in] BSTR strURL);
|
|
};
|
|
|
|
[
|
|
object,
|
|
local,
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
uuid(1299eb1b-5b88-433e-82de-82ca75ad4e04), // IID_IVBSAXXMLFilter
|
|
helpstring("IVBSAXXMLFilter interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVBSAXXMLFilter : IDispatch
|
|
{
|
|
[propget, id(DISPID_SAX_XMLFILTER_PARENT), helpstring("Set or get the parent reader")]
|
|
HRESULT parent(
|
|
[out, retval] IVBSAXXMLReader ** oReader);
|
|
[propputref, id(DISPID_SAX_XMLFILTER_PARENT), helpstring("Set or get the parent reader")]
|
|
HRESULT parent(
|
|
[in] IVBSAXXMLReader * oReader);
|
|
|
|
};
|
|
|
|
[
|
|
object,
|
|
local,
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
uuid(796e7ac5-5aa2-4eff-acad-3faaf01a3288), // IID_IVBSAXLocator
|
|
helpstring("IVBSAXLocator interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVBSAXLocator : IDispatch
|
|
{
|
|
[propget, id(DISPID_SAX_LOCATOR_COLUMNNUMBER), helpstring("Get the column number where the current document event ends.")]
|
|
HRESULT columnNumber(
|
|
[out, retval] int * nColumn);
|
|
|
|
[propget, id(DISPID_SAX_LOCATOR_LINENUMBER), helpstring("Get the line number where the current document event ends.")]
|
|
HRESULT lineNumber(
|
|
[out, retval] int * nLine);
|
|
|
|
[propget, id(DISPID_SAX_LOCATOR_PUBLICID), helpstring("Get the public identifier for the current document event.")]
|
|
HRESULT publicId(
|
|
[out, retval] BSTR * strPublicId);
|
|
|
|
[propget, id(DISPID_SAX_LOCATOR_SYSTEMID), helpstring("Get the system identifier for the current document event.")]
|
|
HRESULT systemId(
|
|
[out, retval] BSTR * strSystemId);
|
|
};
|
|
|
|
[
|
|
object,
|
|
local,
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
uuid(0c05d096-f45b-4aca-ad1a-aa0bc25518dc), // IID_IVBSAXEntityResolver
|
|
helpstring("IVBSAXEntityResolver interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVBSAXEntityResolver : IDispatch
|
|
{
|
|
[id(DISPID_SAX_ENTITYRESOLVER_RESOLVEENTITY), helpstring("Allow the application to resolve external entities.")]
|
|
HRESULT resolveEntity(
|
|
[in, out] BSTR * strPublicId,
|
|
[in, out] BSTR * strSystemId,
|
|
[out, retval] VARIANT * varInput);
|
|
};
|
|
|
|
[
|
|
object,
|
|
local,
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
uuid(2ed7290a-4dd5-4b46-bb26-4e4155e77faa), // IID_IVBSAXContentHandler
|
|
helpstring("IVBSAXContentHandler interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVBSAXContentHandler : IDispatch
|
|
{
|
|
[propputref, id(DISPID_SAX_CONTENTHANDLER_DOCUMENTLOCATOR), helpstring("Receive an object for locating the origin of SAX document events.")]
|
|
HRESULT documentLocator(
|
|
[in] IVBSAXLocator * oLocator);
|
|
|
|
[id(DISPID_SAX_CONTENTHANDLER_STARTDOCUMENT), helpstring("Receive notification of the beginning of a document.")]
|
|
HRESULT startDocument();
|
|
|
|
[id(DISPID_SAX_CONTENTHANDLER_ENDDOCUMENT), helpstring("Receive notification of the end of a document.")]
|
|
HRESULT endDocument();
|
|
|
|
[id(DISPID_SAX_CONTENTHANDLER_STARTPREFIXMAPPING), helpstring("Begin the scope of a prefix-URI Namespace mapping.")]
|
|
HRESULT startPrefixMapping(
|
|
[in, out] BSTR * strPrefix,
|
|
[in, out] BSTR * strURI);
|
|
|
|
[id(DISPID_SAX_CONTENTHANDLER_ENDPREFIXMAPPING), helpstring("End the scope of a prefix-URI mapping.")]
|
|
HRESULT endPrefixMapping(
|
|
[in, out] BSTR * strPrefix);
|
|
|
|
[id(DISPID_SAX_CONTENTHANDLER_STARTELEMENT), helpstring("Receive notification of the beginning of an element.")]
|
|
HRESULT startElement(
|
|
[in, out] BSTR * strNamespaceURI,
|
|
[in, out] BSTR * strLocalName,
|
|
[in, out] BSTR * strQName,
|
|
[in] IVBSAXAttributes * oAttributes);
|
|
|
|
[id(DISPID_SAX_CONTENTHANDLER_ENDELEMENT), helpstring("Receive notification of the end of an element.")]
|
|
HRESULT endElement(
|
|
[in, out] BSTR * strNamespaceURI,
|
|
[in, out] BSTR * strLocalName,
|
|
[in, out] BSTR * strQName);
|
|
|
|
[id(DISPID_SAX_CONTENTHANDLER_CHARACTERS), helpstring("Receive notification of character data.")]
|
|
HRESULT characters(
|
|
[in, out] BSTR * strChars);
|
|
|
|
[id(DISPID_SAX_CONTENTHANDLER_IGNORABLEWHITESPACE), helpstring("Receive notification of ignorable whitespace in element content.")]
|
|
HRESULT ignorableWhitespace(
|
|
[in, out] BSTR * strChars);
|
|
|
|
[id(DISPID_SAX_CONTENTHANDLER_PROCESSINGINSTRUCTION), helpstring("Receive notification of a processing instruction.")]
|
|
HRESULT processingInstruction(
|
|
[in, out] BSTR * strTarget,
|
|
[in, out] BSTR * strData);
|
|
|
|
[id(DISPID_SAX_CONTENTHANDLER_SKIPPEDENTITY), helpstring("Receive notification of a skipped entity.")]
|
|
HRESULT skippedEntity(
|
|
[in, out] BSTR * strName);
|
|
};
|
|
|
|
[
|
|
object,
|
|
local,
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
uuid(24fb3297-302d-4620-ba39-3a732d850558), // IID_IVBSAXDTDHandler
|
|
helpstring("IVBSAXDTDHandler interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVBSAXDTDHandler : IDispatch
|
|
{
|
|
[id(DISPID_SAX_DTDHANDLER_NOTATIONDECL), helpstring("Receive notification of a notation declaration event.")]
|
|
HRESULT notationDecl(
|
|
[in, out] BSTR * strName,
|
|
[in, out] BSTR * strPublicId,
|
|
[in, out] BSTR * strSystemId);
|
|
|
|
[id(DISPID_SAX_DTDHANDLER_UNPARSEDENTITYDECL), helpstring("Receive notification of an unparsed entity declaration event.")]
|
|
HRESULT unparsedEntityDecl(
|
|
[in, out] BSTR * strName,
|
|
[in, out] BSTR * strPublicId,
|
|
[in, out] BSTR * strSystemId,
|
|
[in, out] BSTR * strNotationName);
|
|
};
|
|
|
|
[
|
|
object,
|
|
local,
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
uuid(d963d3fe-173c-4862-9095-b92f66995f52), // IID_IVBSAXErrorHandler
|
|
helpstring("IVBSAXErrorHandler interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVBSAXErrorHandler : IDispatch
|
|
{
|
|
[id(DISPID_SAX_ERRORHANDLER_ERROR), helpstring("Receive notification of a recoverable error.")]
|
|
HRESULT error(
|
|
[in] IVBSAXLocator * oLocator,
|
|
[in, out] BSTR * strErrorMessage,
|
|
[in] long nErrorCode);
|
|
|
|
[id(DISPID_SAX_ERRORHANDLER_FATALERROR), helpstring("Receive notification of a non-recoverable error.")]
|
|
HRESULT fatalError(
|
|
[in] IVBSAXLocator * oLocator,
|
|
[in, out] BSTR * strErrorMessage,
|
|
[in] long nErrorCode);
|
|
|
|
[id(DISPID_SAX_ERRORHANDLER_IGNORABLEWARNING), helpstring("Receive notification of an ignorable warning.")]
|
|
HRESULT ignorableWarning(
|
|
[in] IVBSAXLocator * oLocator,
|
|
[in, out] BSTR * strErrorMessage,
|
|
[in] long nErrorCode);
|
|
};
|
|
|
|
[
|
|
object,
|
|
local,
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
uuid(032aac35-8c0e-4d9d-979f-e3b702935576), // IID_IVBSAXLexicalHandler
|
|
helpstring("IVBSAXLexicalHandler interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVBSAXLexicalHandler : IDispatch
|
|
{
|
|
[id(DISPID_SAX_LEXICALHANDLER_STARTDTD), helpstring("Report the start of DTD declarations, if any.")]
|
|
HRESULT startDTD(
|
|
[in, out] BSTR * strName,
|
|
[in, out] BSTR * strPublicId,
|
|
[in, out] BSTR * strSystemId);
|
|
[id(DISPID_SAX_LEXICALHANDLER_ENDDTD), helpstring("Report the end of DTD declarations.")]
|
|
HRESULT endDTD();
|
|
|
|
[id(DISPID_SAX_LEXICALHANDLER_STARTENTITY), helpstring("Report the beginning of some internal and external XML entities.")]
|
|
HRESULT startEntity(
|
|
[in, out] BSTR * strName);
|
|
[id(DISPID_SAX_LEXICALHANDLER_ENDENTITY), helpstring("Report the end of an entity.")]
|
|
HRESULT endEntity(
|
|
[in, out] BSTR * strName);
|
|
|
|
[id(DISPID_SAX_LEXICALHANDLER_STARTCDATA), helpstring("Report the start of a CDATA section.")]
|
|
HRESULT startCDATA();
|
|
[id(DISPID_SAX_LEXICALHANDLER_ENDCDATA), helpstring("Report the end of a CDATA section.")]
|
|
HRESULT endCDATA();
|
|
|
|
[id(DISPID_SAX_LEXICALHANDLER_COMMENT), helpstring("Report an XML comment anywhere in the document.")]
|
|
HRESULT comment(
|
|
[in, out] BSTR * strChars);
|
|
};
|
|
|
|
[
|
|
object,
|
|
local,
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
uuid(e8917260-7579-4be1-b5dd-7afbfa6f077b), // IID_IVBSAXDeclHandler
|
|
helpstring("IVBSAXDeclHandler interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVBSAXDeclHandler : IDispatch
|
|
{
|
|
[id(DISPID_SAX_DECLHANDLER_ELEMENTDECL), helpstring("Report an element type declaration.")]
|
|
HRESULT elementDecl(
|
|
[in, out] BSTR * strName,
|
|
[in, out] BSTR * strModel);
|
|
|
|
[id(DISPID_SAX_DECLHANDLER_ATTRIBUTEDECL), helpstring("Report an attribute type declaration.")]
|
|
HRESULT attributeDecl(
|
|
[in, out] BSTR * strElementName,
|
|
[in, out] BSTR * strAttributeName,
|
|
[in, out] BSTR * strType,
|
|
[in, out] BSTR * strValueDefault,
|
|
[in, out] BSTR * strValue);
|
|
|
|
[id(DISPID_SAX_DECLHANDLER_INTERNALENTITYDECL), helpstring("Report an internal entity declaration.")]
|
|
HRESULT internalEntityDecl(
|
|
[in, out] BSTR * strName,
|
|
[in, out] BSTR * strValue);
|
|
|
|
[id(DISPID_SAX_DECLHANDLER_EXTERNALENTITYDECL), helpstring("Report a parsed external entity declaration.")]
|
|
HRESULT externalEntityDecl(
|
|
[in, out] BSTR * strName,
|
|
[in, out] BSTR * strPublicId,
|
|
[in, out] BSTR * strSystemId);
|
|
};
|
|
|
|
[
|
|
object,
|
|
local,
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
uuid(10dc0586-132b-4cac-8bb3-db00ac8b7ee0), // IID_IVBSAXAttributes
|
|
helpstring("IVBSAXAttributes interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVBSAXAttributes : IDispatch
|
|
{
|
|
[propget, id(DISPID_SAX_ATTRIBUTES_LENGTH), helpstring("Get the number of attributes in the list.")]
|
|
HRESULT length(
|
|
[out, retval] int * nLength);
|
|
|
|
[id(DISPID_SAX_ATTRIBUTES_GETURI), helpstring("Look up an attribute's Namespace URI by index.")]
|
|
HRESULT getURI(
|
|
[in] int nIndex,
|
|
[out, retval] BSTR * strURI);
|
|
|
|
[id(DISPID_SAX_ATTRIBUTES_GETLOCALNAME), helpstring("Look up an attribute's local name by index.")]
|
|
HRESULT getLocalName(
|
|
[in] int nIndex,
|
|
[out, retval] BSTR * strLocalName);
|
|
|
|
[id(DISPID_SAX_ATTRIBUTES_GETQNAME), helpstring("Look up an attribute's XML 1.0 qualified name by index.")]
|
|
HRESULT getQName(
|
|
[in] int nIndex,
|
|
[out, retval] BSTR * strQName);
|
|
|
|
[id(DISPID_SAX_ATTRIBUTES_GETINDEXFROMNAME), helpstring("Look up the index of an attribute by Namespace name.")]
|
|
HRESULT getIndexFromName(
|
|
[in] BSTR strURI,
|
|
[in] BSTR strLocalName,
|
|
[out, retval] int * nIndex);
|
|
|
|
[id(DISPID_SAX_ATTRIBUTES_GETINDEXFROMQNAME), helpstring("Look up the index of an attribute by XML 1.0 qualified name.")]
|
|
HRESULT getIndexFromQName(
|
|
[in] BSTR strQName,
|
|
[out, retval] int * nIndex);
|
|
|
|
[id(DISPID_SAX_ATTRIBUTES_GETTYPE), helpstring("Look up an attribute's type by index.")]
|
|
HRESULT getType(
|
|
[in] int nIndex,
|
|
[out, retval] BSTR * strType);
|
|
|
|
[id(DISPID_SAX_ATTRIBUTES_GETTYPEFROMNAME), helpstring("Look up an attribute's type by Namespace name.")]
|
|
HRESULT getTypeFromName(
|
|
[in] BSTR strURI,
|
|
[in] BSTR strLocalName,
|
|
[out, retval] BSTR * strType);
|
|
|
|
[id(DISPID_SAX_ATTRIBUTES_GETTYPEFROMQNAME), helpstring("Look up an attribute's type by XML 1.0 qualified name.")]
|
|
HRESULT getTypeFromQName(
|
|
[in] BSTR strQName,
|
|
[out, retval] BSTR * strType);
|
|
|
|
[id(DISPID_SAX_ATTRIBUTES_GETVALUE), helpstring("Look up an attribute's value by index.")]
|
|
HRESULT getValue(
|
|
[in] int nIndex,
|
|
[out, retval] BSTR * strValue);
|
|
|
|
[id(DISPID_SAX_ATTRIBUTES_GETVALUEFROMNAME), helpstring("Look up an attribute's value by Namespace name.")]
|
|
HRESULT getValueFromName(
|
|
[in] BSTR strURI,
|
|
[in] BSTR strLocalName,
|
|
[out, retval] BSTR * strValue);
|
|
|
|
[id(DISPID_SAX_ATTRIBUTES_GETVALUEFROMQNAME), helpstring("Look up an attribute's value by XML 1.0 qualified name.")]
|
|
HRESULT getValueFromQName(
|
|
[in] BSTR strQName,
|
|
[out, retval] BSTR * strValue);
|
|
};
|
|
|
|
[
|
|
object,
|
|
local,
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
uuid(4d7ff4ba-1565-4ea8-94e1-6e724a46f98d), // IID_IMXWriter
|
|
helpstring("IMXWriter interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IMXWriter : IDispatch
|
|
{
|
|
[propput, id(DISPID_MX_WRITER_OUTPUT), helpstring("Set or get the output.")]
|
|
HRESULT output (
|
|
[in] VARIANT varDestination);
|
|
[propget, id(DISPID_MX_WRITER_OUTPUT), helpstring("Set or get the output.")]
|
|
HRESULT output (
|
|
[out, retval] VARIANT * varDestination);
|
|
|
|
[propput, id(DISPID_MX_WRITER_ENCODING), helpstring("Set or get the output encoding.")]
|
|
HRESULT encoding (
|
|
[in] BSTR strEncoding);
|
|
[propget, id(DISPID_MX_WRITER_ENCODING), helpstring("Set or get the output encoding.")]
|
|
HRESULT encoding (
|
|
[out, retval] BSTR * strEncoding);
|
|
|
|
[propput, id(DISPID_MX_WRITER_BYTEORDERMARK), helpstring("Determine whether or not to write the byte order mark")]
|
|
HRESULT byteOrderMark (
|
|
[in] VARIANT_BOOL fWriteByteOrderMark);
|
|
[propget, id(DISPID_MX_WRITER_BYTEORDERMARK), helpstring("Determine whether or not to write the byte order mark")]
|
|
HRESULT byteOrderMark (
|
|
[out, retval] VARIANT_BOOL * fWriteByteOrderMark);
|
|
|
|
[propput, id(DISPID_MX_WRITER_INDENT), helpstring("Enable or disable auto indent mode.")]
|
|
HRESULT indent (
|
|
[in] VARIANT_BOOL fIndentMode);
|
|
[propget, id(DISPID_MX_WRITER_INDENT), helpstring("Enable or disable auto indent mode.")]
|
|
HRESULT indent (
|
|
[out, retval] VARIANT_BOOL * fIndentMode);
|
|
|
|
[propput, id(DISPID_MX_WRITER_STANDALONE), helpstring("Set or get the standalone document declaration.")]
|
|
HRESULT standalone (
|
|
[in] VARIANT_BOOL fValue);
|
|
[propget, id(DISPID_MX_WRITER_STANDALONE), helpstring("Set or get the standalone document declaration.")]
|
|
HRESULT standalone (
|
|
[out, retval] VARIANT_BOOL * fValue);
|
|
|
|
[propput, id(DISPID_MX_WRITER_OMITXMLDECLARATION), helpstring("Determine whether or not to omit the XML declaration.")]
|
|
HRESULT omitXMLDeclaration (
|
|
[in] VARIANT_BOOL fValue);
|
|
[propget, id(DISPID_MX_WRITER_OMITXMLDECLARATION), helpstring("Determine whether or not to omit the XML declaration.")]
|
|
HRESULT omitXMLDeclaration (
|
|
[out, retval] VARIANT_BOOL * fValue);
|
|
|
|
[propput, id(DISPID_MX_WRITER_VERSION), helpstring("Set or get the xml version info.")]
|
|
HRESULT version (
|
|
[in] BSTR strVersion);
|
|
[propget, id(DISPID_MX_WRITER_VERSION), helpstring("Set or get the xml version info.")]
|
|
HRESULT version (
|
|
[out, retval] BSTR * strVersion);
|
|
|
|
[propput, id(DISPID_MX_WRITER_DISABLEOUTPUTESCAPING), helpstring("When enabled, the writer no longer escapes out its input when writing it out.")]
|
|
HRESULT disableOutputEscaping(
|
|
[in] VARIANT_BOOL fValue);
|
|
[propget, id(DISPID_MX_WRITER_DISABLEOUTPUTESCAPING), helpstring("When enabled, the writer no longer escapes out its input when writing it out.")]
|
|
HRESULT disableOutputEscaping(
|
|
[out, retval] VARIANT_BOOL * fValue);
|
|
|
|
[id(DISPID_MX_WRITER_FLUSH), helpstring("Flushes all writer buffers forcing the writer to write to the underlying output object")]
|
|
HRESULT flush();
|
|
};
|
|
|
|
[
|
|
object,
|
|
local,
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
uuid(f10d27cc-3ec0-415c-8ed8-77ab1c5e7262), // IID_IMXAttributes
|
|
helpstring("IMXAttributes interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IMXAttributes : IDispatch
|
|
{
|
|
[id(DISPID_MX_ATTRIBUTES_ADDATTRIBUTE), helpstring("Add an attribute to the end of the list.")]
|
|
HRESULT addAttribute(
|
|
[in] BSTR strURI,
|
|
[in] BSTR strLocalName,
|
|
[in] BSTR strQName,
|
|
[in] BSTR strType,
|
|
[in] BSTR strValue);
|
|
|
|
[id(DISPID_MX_ATTRIBUTES_ADDATTRIBUTEFROMINDEX), helpstring("Add an attribute, whose value is equal to the indexed attribute in the input attributes object, to the end of the list.")]
|
|
HRESULT addAttributeFromIndex(
|
|
[in] VARIANT varAtts,
|
|
[in] int nIndex);
|
|
|
|
[id(DISPID_MX_ATTRIBUTES_CLEAR), helpstring("Clear the attribute list for reuse.")]
|
|
HRESULT clear();
|
|
|
|
[id(DISPID_MX_ATTRIBUTES_REMOVEATTRIBUTE), helpstring("Remove an attribute from the list.")]
|
|
HRESULT removeAttribute(
|
|
[in] int nIndex);
|
|
|
|
[id(DISPID_MX_ATTRIBUTES_SETATTRIBUTE), helpstring("Set an attribute in the list.")]
|
|
HRESULT setAttribute(
|
|
[in] int nIndex,
|
|
[in] BSTR strURI,
|
|
[in] BSTR strLocalName,
|
|
[in] BSTR strQName,
|
|
[in] BSTR strType,
|
|
[in] BSTR strValue);
|
|
|
|
[id(DISPID_MX_ATTRIBUTES_SETATTRIBUTES), helpstring("Copy an entire Attributes object.")]
|
|
HRESULT setAttributes(
|
|
[in] VARIANT varAtts);
|
|
|
|
[id(DISPID_MX_ATTRIBUTES_SETLOCALNAME), helpstring("Set the local name of a specific attribute.")]
|
|
HRESULT setLocalName(
|
|
[in] int nIndex,
|
|
[in] BSTR strLocalName);
|
|
|
|
[id(DISPID_MX_ATTRIBUTES_SETQNAME), helpstring("Set the qualified name of a specific attribute.")]
|
|
HRESULT setQName(
|
|
[in] int nIndex,
|
|
[in] BSTR strQName);
|
|
|
|
[id(DISPID_MX_ATTRIBUTES_SETTYPE), helpstring("Set the type of a specific attribute.")]
|
|
HRESULT setType(
|
|
[in] int nIndex,
|
|
[in] BSTR strType);
|
|
|
|
[id(DISPID_MX_ATTRIBUTES_SETURI), helpstring("Set the Namespace URI of a specific attribute.")]
|
|
HRESULT setURI(
|
|
[in] int nIndex,
|
|
[in] BSTR strURI);
|
|
|
|
[id(DISPID_MX_ATTRIBUTES_SETVALUE), helpstring("Set the value of a specific attribute.")]
|
|
HRESULT setValue(
|
|
[in] int nIndex,
|
|
[in] BSTR strValue);
|
|
};
|
|
|
|
[
|
|
object,
|
|
local,
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
nonextensible,
|
|
uuid(808f4e35-8d5a-4fbe-8466-33a41279ed30), // IID_IMXReaderControl
|
|
helpstring("IMXReaderControl interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IMXReaderControl : IDispatch
|
|
{
|
|
[id(DISPID_MX_READER_CONTROL_ABORT), helpstring("Abort the reader")]
|
|
HRESULT abort();
|
|
|
|
[id(DISPID_MX_READER_CONTROL_RESUME), helpstring("Resume the reader")]
|
|
HRESULT resume();
|
|
|
|
[id(DISPID_MX_READER_CONTROL_SUSPEND), helpstring("Suspend the reader")]
|
|
HRESULT suspend();
|
|
};
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// IE4 Interfaces
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
#ifndef IMPORTED_MSXML
|
|
[
|
|
local, object,
|
|
uuid(65725580-9B5D-11d0-9BFE-00C04FC99C8E), // IID_IXMLElementCollection
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
hidden, // replaced by IDOMNodeList
|
|
helpstring("IXMLElementCollection helps to enumerate through a XML document tree.")
|
|
]
|
|
interface IXMLElementCollection : IDispatch
|
|
{
|
|
[propput, restricted, hidden, id(DISPID_XMLELEMENTCOLLECTION_LENGTH)] HRESULT length([in] long v);
|
|
[propget, id(DISPID_XMLELEMENTCOLLECTION_LENGTH), helpstring("get number of elements in this IXMLElementCollection.")] HRESULT length([retval, out] long * p);
|
|
[propget, restricted, hidden, id(DISPID_XMLELEMENTCOLLECTION_NEWENUM)] HRESULT _newEnum([retval, out] IUnknown ** ppUnk);
|
|
[id(DISPID_XMLELEMENTCOLLECTION_ITEM), helpstring("get current item, or (optional) by index and name.")] HRESULT item([optional, in] VARIANT var1,[optional, in] VARIANT var2,[retval, out] IDispatch ** ppDisp);
|
|
};
|
|
|
|
[
|
|
local, object,
|
|
uuid(F52E2B61-18A1-11d1-B105-00805F49916B), // IID_IXMLDocument
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
hidden, // replaced by IDOMDocument
|
|
helpstring("IXMLDocument loads and saves XML document. This is obsolete. You should use IDOMDocument or IXMLDOMDocument.")
|
|
]
|
|
interface IXMLDocument : IDispatch
|
|
{
|
|
[propget, id(DISPID_XMLDOCUMENT_ROOT), helpstring("get root IXMLElement of the XML document.")] HRESULT root ([retval, out] IXMLElement * * p);
|
|
[propget, restricted, hidden, id(DISPID_XMLDOCUMENT_FILESIZE)] HRESULT fileSize([retval, out] BSTR * p);
|
|
[propget, restricted, hidden, id(DISPID_XMLDOCUMENT_FILEMODIFIEDDATE)] HRESULT fileModifiedDate([retval, out] BSTR * p);
|
|
[propget, restricted, hidden, id(DISPID_XMLDOCUMENT_FILEUPDATEDDATE)] HRESULT fileUpdatedDate([retval, out] BSTR * p);
|
|
[propget, id(DISPID_XMLDOCUMENT_URL), helpstring("set URL to load an XML document from the URL.")] HRESULT URL([retval, out] BSTR * p);
|
|
[propput, id(DISPID_XMLDOCUMENT_URL), helpstring("get url.")] HRESULT URL([in] BSTR p);
|
|
[propget, restricted, hidden, id(DISPID_XMLDOCUMENT_MIMETYPE)] HRESULT mimeType([retval, out] BSTR * p);
|
|
[propget, id(DISPID_XMLDOCUMENT_READYSTATE), helpstring("get ready state.")] HRESULT readyState([retval, out]long *pl);
|
|
[propget, id(DISPID_XMLDOCUMENT_CHARSET), helpstring("get encoding.")] HRESULT charset([retval, out]BSTR *p);
|
|
[propput, id(DISPID_XMLDOCUMENT_CHARSET), helpstring("set encoding.")] HRESULT charset([in]BSTR p);
|
|
[propget, id(DISPID_XMLDOCUMENT_VERSION), helpstring("get XML version number.")] HRESULT version([retval, out]BSTR *p);
|
|
[propget, id(DISPID_XMLDOCUMENT_DOCTYPE), helpstring("get document type.")] HRESULT doctype([retval, out]BSTR *p);
|
|
[propget, restricted, hidden, id(DISPID_XMLDOCUMENT_DTDURL)] HRESULT dtdURL([retval, out]BSTR *p);
|
|
[id(DISPID_XMLDOCUMENT_CREATEELEMENT), helpstring("create different types of IXMLElements.")] HRESULT createElement([in] VARIANT vType, [optional, in] VARIANT var1, [retval, out] IXMLElement * * ppElem);
|
|
};
|
|
#endif
|
|
|
|
[
|
|
local, object,
|
|
uuid(2B8DE2FE-8D2D-11d1-B2FC-00C04FD915A9), // IID_IXMLDocument2
|
|
hidden // Because that this interface is the default interface of coclass XMLDocument
|
|
]
|
|
interface IXMLDocument2 : IDispatch
|
|
{
|
|
[propget, id(DISPID_XMLDOCUMENT_ROOT), helpstring("get root IXMLElement of the XML document.")] HRESULT root ([retval, out] IXMLElement2 * * p);
|
|
[propget, restricted, hidden, id(DISPID_XMLDOCUMENT_FILESIZE)] HRESULT fileSize([retval, out] BSTR * p);
|
|
[propget, restricted, hidden, id(DISPID_XMLDOCUMENT_FILEMODIFIEDDATE)] HRESULT fileModifiedDate([retval, out] BSTR * p);
|
|
[propget, restricted, hidden, id(DISPID_XMLDOCUMENT_FILEUPDATEDDATE)] HRESULT fileUpdatedDate([retval, out] BSTR * p);
|
|
[propget, id(DISPID_XMLDOCUMENT_URL), helpstring("set URL to load an XML document from the URL.")] HRESULT URL([retval, out] BSTR * p);
|
|
[propput, id(DISPID_XMLDOCUMENT_URL), helpstring("get url.")] HRESULT URL([in] BSTR p);
|
|
[propget, restricted, hidden, id(DISPID_XMLDOCUMENT_MIMETYPE)] HRESULT mimeType([retval, out] BSTR * p);
|
|
[propget, id(DISPID_XMLDOCUMENT_READYSTATE), helpstring("get ready state.")] HRESULT readyState([retval, out]long *pl);
|
|
[propget, id(DISPID_XMLDOCUMENT_CHARSET), helpstring("get encoding.")] HRESULT charset([retval, out]BSTR *p);
|
|
[propput, id(DISPID_XMLDOCUMENT_CHARSET), helpstring("set encoding.")] HRESULT charset([in]BSTR p);
|
|
[propget, id(DISPID_XMLDOCUMENT_VERSION), helpstring("get XML version number.")] HRESULT version([retval, out]BSTR *p);
|
|
[propget, id(DISPID_XMLDOCUMENT_DOCTYPE), helpstring("get document type.")] HRESULT doctype([retval, out]BSTR *p);
|
|
[propget, restricted, hidden, id(DISPID_XMLDOCUMENT_DTDURL)] HRESULT dtdURL([retval, out]BSTR *p);
|
|
[id(DISPID_XMLDOCUMENT_CREATEELEMENT), helpstring("create different types of IXMLElements.")] HRESULT createElement([in] VARIANT vType, [optional, in] VARIANT var1, [retval, out] IXMLElement2 * * ppElem);
|
|
[propget, id(DISPID_XMLDOCUMENT_ASYNC), helpstring("get asynchronous loading flag.")] HRESULT async([retval, out] VARIANT_BOOL * pf);
|
|
[propput, id(DISPID_XMLDOCUMENT_ASYNC), helpstring("set flag to turn on/off asynchronous loading.")] HRESULT async([in] VARIANT_BOOL f);
|
|
};
|
|
|
|
#ifndef IMPORTED_MSXML
|
|
[
|
|
local, object,
|
|
uuid(3F7F31AC-E15F-11d0-9C25-00C04FC99C8E), // IID_IXMLElement
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
hidden, // replaced by IDOMNode
|
|
helpstring("IXMLElement represents an element in the XML document tree.")
|
|
]
|
|
interface IXMLElement : IDispatch
|
|
{
|
|
[propget, id(DISPID_XMLELEMENT_TAGNAME), helpstring("get tag name.")] HRESULT tagName([retval, out] BSTR * p);
|
|
[propput, id(DISPID_XMLELEMENT_TAGNAME), helpstring("set tag name.")] HRESULT tagName([in] BSTR p);
|
|
[propget, id(DISPID_XMLELEMENT_PARENT), helpstring("get parent IXMLElement.")] HRESULT parent([retval, out]IXMLElement **ppParent);
|
|
[id(DISPID_XMLELEMENT_SETATTRIBUTE), helpstring("set attribute.")] HRESULT setAttribute([in] BSTR strPropertyName,[in] VARIANT PropertyValue);
|
|
[id(DISPID_XMLELEMENT_GETATTRIBUTE), helpstring("get attribute.")] HRESULT getAttribute([in] BSTR strPropertyName,[retval, out] VARIANT* PropertyValue);
|
|
[id(DISPID_XMLELEMENT_REMOVEATTRIBUTE), helpstring("remove attribute.")] HRESULT removeAttribute([in] BSTR strPropertyName);
|
|
[propget, id(DISPID_XMLELEMENT_CHILDREN), helpstring("get a IXMLElementCollection of children.")] HRESULT children([retval, out] IXMLElementCollection * * pp);
|
|
[propget, id(DISPID_XMLELEMENT_TYPE), helpstring("get type of this IXMLElement.")] HRESULT type([retval, out] long *plType);
|
|
[propget, id(DISPID_XMLELEMENT_TEXT), helpstring("get text.")] HRESULT text([retval, out] BSTR *p);
|
|
[propput, id(DISPID_XMLELEMENT_TEXT), helpstring("set text.")] HRESULT text([in] BSTR p);
|
|
[id(DISPID_XMLELEMENT_ADDCHILD), helpstring("add a child.")] HRESULT addChild([in] IXMLElement *pChildElem, long lIndex, long lReserved); // lReserved must be -1
|
|
[id(DISPID_XMLELEMENT_REMOVECHILD), helpstring("remove a child.")] HRESULT removeChild([in]IXMLElement *pChildElem);
|
|
}
|
|
#endif
|
|
|
|
[
|
|
local, object,
|
|
uuid(2B8DE2FF-8D2D-11d1-B2FC-00C04FD915A9), // IID_IXMLElement2
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
hidden, // replaced by IDOMNode
|
|
helpstring("IXMLElement2 extends IXMLElement.")
|
|
]
|
|
interface IXMLElement2 : IDispatch
|
|
{
|
|
[propget, id(DISPID_XMLELEMENT_TAGNAME), helpstring("get tag name.")] HRESULT tagName([retval, out] BSTR * p);
|
|
[propput, id(DISPID_XMLELEMENT_TAGNAME), helpstring("set tag name.")] HRESULT tagName([in] BSTR p);
|
|
[propget, id(DISPID_XMLELEMENT_PARENT), helpstring("get parent IXMLElement.")] HRESULT parent([retval, out]IXMLElement2 **ppParent);
|
|
[id(DISPID_XMLELEMENT_SETATTRIBUTE), helpstring("set attribute.")] HRESULT setAttribute([in] BSTR strPropertyName,[in] VARIANT PropertyValue);
|
|
[id(DISPID_XMLELEMENT_GETATTRIBUTE), helpstring("get attribute.")] HRESULT getAttribute([in] BSTR strPropertyName,[retval, out] VARIANT* PropertyValue);
|
|
[id(DISPID_XMLELEMENT_REMOVEATTRIBUTE), helpstring("remove attribute.")] HRESULT removeAttribute([in] BSTR strPropertyName);
|
|
[propget, id(DISPID_XMLELEMENT_CHILDREN), helpstring("get a IXMLElementCollection of all children.")] HRESULT children([retval, out] IXMLElementCollection * * pp);
|
|
[propget, id(DISPID_XMLELEMENT_TYPE), helpstring("get type of this IXMLElement.")] HRESULT type([retval, out] long *plType);
|
|
[propget, id(DISPID_XMLELEMENT_TEXT), helpstring("get text.")] HRESULT text([retval, out] BSTR *p);
|
|
[propput, id(DISPID_XMLELEMENT_TEXT), helpstring("set text.")] HRESULT text([in] BSTR p);
|
|
[id(DISPID_XMLELEMENT_ADDCHILD), helpstring("add a child.")] HRESULT addChild([in] IXMLElement2 *pChildElem, long lIndex, long lReserved); // lReserved must be -1
|
|
[id(DISPID_XMLELEMENT_REMOVECHILD), helpstring("remove a child.")] HRESULT removeChild([in]IXMLElement2 *pChildElem);
|
|
[propget, id(DISPID_XMLELEMENT_ATTRIBUTES), helpstring("get a IXMLElementCollection of all attributes.")] HRESULT attributes([retval, out] IXMLElementCollection ** pp);
|
|
}
|
|
|
|
[
|
|
local, object,
|
|
uuid(D4D4A0FC-3B73-11d1-B2B4-00C04FB92596), // IID_IXMLAttribute
|
|
odl,
|
|
dual,
|
|
oleautomation,
|
|
hidden, // replaced by IDOMNode
|
|
helpstring("IXMLAttribute allows to get attributes of an IXMLElement.")
|
|
]
|
|
interface IXMLAttribute : IDispatch
|
|
{
|
|
[propget, id(DISPID_XMLATTRIBUTE_NAME), helpstring("get attribute name.")] HRESULT name([retval, out] BSTR* n);
|
|
[propget, id(DISPID_XMLATTRIBUTE_VALUE), helpstring("get attribute value.")] HRESULT value([retval, out] BSTR* v);
|
|
};
|
|
|
|
#ifndef IMPORTED_MSXML
|
|
[
|
|
local, object,
|
|
uuid(948C5AD3-C58D-11d0-9C0B-00C04FC99C8E), // IID_IXMLError
|
|
odl,
|
|
hidden, // this is not scriptable.
|
|
helpstring("Gets error info.")
|
|
]
|
|
interface IXMLError : IUnknown
|
|
{
|
|
HRESULT GetErrorInfo(XML_ERROR *pErrorReturn);
|
|
}
|
|
#endif
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// CoClasses
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
// DOM Document rental-model co-Class, version independent
|
|
[
|
|
uuid(F6D90F11-9C73-11D3-B32E-00C04F990BB4), // CLSID_DOMDocument
|
|
helpstring("W3C-DOM XML Document (Apartment)")
|
|
]
|
|
coclass DOMDocument
|
|
{
|
|
[default] interface IXMLDOMDocument2;
|
|
[default, source] dispinterface XMLDOMDocumentEvents;
|
|
};
|
|
|
|
// DOM Document rental-model co-Class, 2.6 version dependent
|
|
[
|
|
uuid(f5078f1b-c551-11d3-89b9-0000f81fe221), // CLSID_DOMDocument26
|
|
helpstring("W3C-DOM XML Document (Apartment)")
|
|
]
|
|
coclass DOMDocument26
|
|
{
|
|
[default] interface IXMLDOMDocument2;
|
|
[default, source] dispinterface XMLDOMDocumentEvents;
|
|
};
|
|
|
|
// DOM Document rental-model co-Class, 3.0 version dependent
|
|
[
|
|
uuid(f5078f32-c551-11d3-89b9-0000f81fe221), // CLSID_DOMDocument30
|
|
helpstring("W3C-DOM XML Document (Apartment)")
|
|
]
|
|
coclass DOMDocument30
|
|
{
|
|
[default] interface IXMLDOMDocument2;
|
|
[default, source] dispinterface XMLDOMDocumentEvents;
|
|
};
|
|
|
|
|
|
// DOM Document free-threaded co-Class, version independent
|
|
[
|
|
uuid(F6D90F12-9C73-11D3-B32E-00C04F990BB4), // CLSID_FreeThreadedDOMDocument
|
|
helpstring("W3C-DOM XML Document (Free threaded)")
|
|
]
|
|
coclass FreeThreadedDOMDocument
|
|
{
|
|
[default] interface IXMLDOMDocument2;
|
|
[default, source] dispinterface XMLDOMDocumentEvents;
|
|
};
|
|
|
|
// DOM Document free-threaded co-Class, 2.6 version dependent
|
|
[
|
|
uuid(f5078f1c-c551-11d3-89b9-0000f81fe221), // CLSID_FreeThreadedDOMDocument26
|
|
helpstring("W3C-DOM XML Document (Free threaded)")
|
|
]
|
|
coclass FreeThreadedDOMDocument26
|
|
{
|
|
[default] interface IXMLDOMDocument2;
|
|
[default, source] dispinterface XMLDOMDocumentEvents;
|
|
};
|
|
|
|
// DOM Document free-threaded co-Class, 3.0 version dependent
|
|
[
|
|
uuid(f5078f33-c551-11d3-89b9-0000f81fe221), // CLSID_FreeThreadedDOMDocument30
|
|
helpstring("W3C-DOM XML Document (Free threaded)")
|
|
]
|
|
coclass FreeThreadedDOMDocument30
|
|
{
|
|
[default] interface IXMLDOMDocument2;
|
|
[default, source] dispinterface XMLDOMDocumentEvents;
|
|
};
|
|
|
|
|
|
// XML Schema Cache, version independent
|
|
[
|
|
uuid(373984c9-b845-449b-91e7-45ac83036ade),
|
|
helpstring("object for caching schemas")
|
|
]
|
|
coclass XMLSchemaCache
|
|
{
|
|
[default] interface IXMLDOMSchemaCollection;
|
|
};
|
|
|
|
// XML Schema Cache, version 2.6 dependent
|
|
[
|
|
uuid(f5078f1d-c551-11d3-89b9-0000f81fe221),
|
|
helpstring("object for caching schemas")
|
|
]
|
|
coclass XMLSchemaCache26
|
|
{
|
|
[default] interface IXMLDOMSchemaCollection;
|
|
};
|
|
|
|
// XML Schema Cache, version 3.0 dependent
|
|
[
|
|
uuid(f5078f34-c551-11d3-89b9-0000f81fe221),
|
|
helpstring("object for caching schemas")
|
|
]
|
|
coclass XMLSchemaCache30
|
|
{
|
|
[default] interface IXMLDOMSchemaCollection;
|
|
};
|
|
|
|
|
|
// XSLTemplate, version independent
|
|
[
|
|
uuid(2933BF94-7B36-11d2-B20E-00C04F983E60), // CLSID_XMLDOMXSLTemplate (Progid=Msxml2.XMLDOMXSLTemplate)
|
|
helpstring("object for caching compiled XSL stylesheets")
|
|
]
|
|
coclass XSLTemplate
|
|
{
|
|
[default] interface IXSLTemplate;
|
|
};
|
|
|
|
// XSLTemplate, 2.6 version dependent
|
|
[
|
|
uuid(f5078f21-c551-11d3-89b9-0000f81fe221), // CLSID_XMLDOMXSLTemplate (Progid=Microsoft.XMLDOMXSLTemplate)
|
|
helpstring("object for caching compiled XSL stylesheets")
|
|
]
|
|
coclass XSLTemplate26
|
|
{
|
|
[default] interface IXSLTemplate;
|
|
};
|
|
|
|
// XSLTemplate, 3.0 version dependent
|
|
[
|
|
uuid(f5078f36-c551-11d3-89b9-0000f81fe221), // CLSID_XMLDOMXSLTemplate30 (Progid=Msxml2.XMLDOMXSLTemplate.3.0)
|
|
helpstring("object for caching compiled XSL stylesheets")
|
|
]
|
|
coclass XSLTemplate30
|
|
{
|
|
[default] interface IXSLTemplate;
|
|
};
|
|
|
|
|
|
// XMLDSO, version independent
|
|
[
|
|
uuid(F6D90F14-9C73-11D3-B32E-00C04F990BB4),
|
|
helpstring("XML Data Source Object")
|
|
]
|
|
coclass DSOControl
|
|
{
|
|
[default] interface IDSOControl;
|
|
};
|
|
|
|
// DSOControl, 2.6 version dependent
|
|
[
|
|
uuid(f5078f1f-c551-11d3-89b9-0000f81fe221),
|
|
helpstring("XML Data Source Object")
|
|
]
|
|
coclass DSOControl26
|
|
{
|
|
[default] interface IDSOControl;
|
|
};
|
|
|
|
// DSOControl, 3.0 version dependent
|
|
[
|
|
uuid(f5078f39-c551-11d3-89b9-0000f81fe221),
|
|
helpstring("XML Data Source Object")
|
|
]
|
|
coclass DSOControl30
|
|
{
|
|
[default] interface IDSOControl;
|
|
};
|
|
|
|
|
|
// XML HTTP Request Class, version independent
|
|
[
|
|
uuid(F6D90F16-9C73-11D3-B32E-00C04F990BB4), // CLSID_XMLHTTP
|
|
helpstring("XML HTTP Request class.")
|
|
]
|
|
coclass XMLHTTP
|
|
{
|
|
[default] interface IXMLHTTPRequest;
|
|
};
|
|
|
|
// XML HTTP Request Class, 2.6, version dependent
|
|
[
|
|
uuid(f5078f1e-c551-11d3-89b9-0000f81fe221), // CLSID_XMLHTTP26
|
|
helpstring("XML HTTP Request class.")
|
|
]
|
|
coclass XMLHTTP26
|
|
{
|
|
[default] interface IXMLHTTPRequest;
|
|
};
|
|
|
|
// XML HTTP Request Class, 3.0, version dependent
|
|
[
|
|
uuid(f5078f35-c551-11d3-89b9-0000f81fe221), // CLSID_XMLHTTP30
|
|
helpstring("XML HTTP Request class.")
|
|
]
|
|
coclass XMLHTTP30
|
|
{
|
|
[default] interface IXMLHTTPRequest;
|
|
};
|
|
|
|
|
|
// Server XML HTTP Request Class, version independent
|
|
[
|
|
uuid(afba6b42-5692-48ea-8141-dc517dcf0ef1), // CLSID_ServerXMLHTTP
|
|
helpstring("Server XML HTTP Request class.")
|
|
]
|
|
coclass ServerXMLHTTP
|
|
{
|
|
[default] interface IServerXMLHTTPRequest;
|
|
}
|
|
|
|
// Server XML HTTP Request Class, 3.0, version dependent
|
|
[
|
|
uuid(afb40ffd-b609-40a3-9828-f88bbe11e4e3), // CLSID_ServerXMLHTTP30
|
|
helpstring("Server XML HTTP Request class.")
|
|
]
|
|
coclass ServerXMLHTTP30
|
|
{
|
|
[default] interface IServerXMLHTTPRequest;
|
|
}
|
|
|
|
|
|
// SAXXMLReader co-class, version independent
|
|
[
|
|
uuid(079aa557-4a18-424a-8eee-e39f0a8d41b9), // CLSID_SAXXMLReader
|
|
helpstring("SAX XML Reader (version independent) coclass")
|
|
]
|
|
coclass SAXXMLReader
|
|
{
|
|
[default] interface IVBSAXXMLReader;
|
|
interface ISAXXMLReader;
|
|
interface IMXReaderControl;
|
|
};
|
|
|
|
// SAXXMLReader co-class, 3.0 version dependent
|
|
[
|
|
uuid(3124c396-fb13-4836-a6ad-1317f1713688), // CLSID_SAXXMLReader30
|
|
helpstring("SAX XML Reader 3.0 coclass")
|
|
]
|
|
coclass SAXXMLReader30
|
|
{
|
|
[default] interface IVBSAXXMLReader;
|
|
interface ISAXXMLReader;
|
|
interface IMXReaderControl;
|
|
};
|
|
|
|
|
|
// MXXMLWriter co-class, version independent
|
|
[
|
|
uuid(fc220ad8-a72a-4ee8-926e-0b7ad152a020), // CLSID_MXXMLWriter
|
|
helpstring("Microsoft XML Writer (version independent) coclass")
|
|
]
|
|
coclass MXXMLWriter
|
|
{
|
|
[default] interface IMXWriter;
|
|
|
|
interface ISAXContentHandler;
|
|
interface ISAXErrorHandler;
|
|
interface ISAXDTDHandler;
|
|
interface ISAXLexicalHandler;
|
|
interface ISAXDeclHandler;
|
|
|
|
interface IVBSAXContentHandler;
|
|
interface IVBSAXDeclHandler;
|
|
interface IVBSAXDTDHandler;
|
|
interface IVBSAXErrorHandler;
|
|
interface IVBSAXLexicalHandler;
|
|
};
|
|
|
|
// MXXMLWriter co-class, 3.0 version dependent
|
|
[
|
|
uuid(3d813dfe-6c91-4a4e-8f41-04346a841d9c), // CLSID_MXXMLWriter30
|
|
helpstring("Microsoft XML Writer 3.0 coclass")
|
|
]
|
|
coclass MXXMLWriter30
|
|
{
|
|
[default] interface IMXWriter;
|
|
|
|
interface ISAXContentHandler;
|
|
interface ISAXDeclHandler;
|
|
interface ISAXDTDHandler;
|
|
interface ISAXErrorHandler;
|
|
interface ISAXLexicalHandler;
|
|
|
|
interface IVBSAXContentHandler;
|
|
interface IVBSAXDeclHandler;
|
|
interface IVBSAXDTDHandler;
|
|
interface IVBSAXErrorHandler;
|
|
interface IVBSAXLexicalHandler;
|
|
};
|
|
|
|
|
|
// SAXAttributes co-class, version independent
|
|
[
|
|
uuid(4dd441ad-526d-4a77-9f1b-9841ed802fb0), // CLSID_SAXAttributes
|
|
helpstring("SAX Attributes (version independent) coclass")
|
|
]
|
|
coclass SAXAttributes
|
|
{
|
|
[default] interface IMXAttributes;
|
|
interface IVBSAXAttributes;
|
|
interface ISAXAttributes;
|
|
};
|
|
|
|
// SAXAttributes co-class, 3.0 version dependent
|
|
[
|
|
uuid(3e784a01-f3ae-4dc0-9354-9526b9370eba), // CLSID_SAXAttributes30
|
|
helpstring("SAX Attributes 3.0 coclass")
|
|
]
|
|
coclass SAXAttributes30
|
|
{
|
|
[default] interface IMXAttributes;
|
|
interface IVBSAXAttributes;
|
|
interface ISAXAttributes;
|
|
};
|
|
|
|
|
|
#ifndef IMPORTED_MSXML
|
|
// XML Document Class, IE4 version
|
|
[
|
|
uuid(CFC399AF-D876-11d0-9C10-00C04FC99C8E), // CLSID_XMLDocument
|
|
helpstring("XMLDocument extends IXML Document. It is obsolete. You should use DOMDocument. This object should not be confused with the XMLDocument property on the XML data island."),
|
|
hidden // replaced by DOMDocument
|
|
]
|
|
coclass XMLDocument
|
|
{
|
|
[default] interface IXMLDocument2;
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
cpp_quote("//----------------------------")
|
|
cpp_quote("// MSXML SPECIFIC ERROR CODES ")
|
|
cpp_quote("//----------------------------")
|
|
cpp_quote("#define E_XML_NOTWF 0xC00CE223L // Validate failed because the document is not well formed.")
|
|
cpp_quote("#define E_XML_NODTD 0xC00CE224L // Validate failed because a DTD/Schema was not specified in the document.")
|
|
cpp_quote("#define E_XML_INVALID 0xC00CE225L // Validate failed because of a DTD/Schema violation.")
|
|
|
|
|
|
cpp_quote("#ifdef __USE_MSXML2_NAMESPACE__")
|
|
cpp_quote("}")
|
|
cpp_quote("#endif")
|
|
|