1208 lines
39 KiB
Plaintext
1208 lines
39 KiB
Plaintext
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1998.
|
|
//
|
|
// File: xmldom.idl
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#ifdef UNIX
|
|
import "ocidl.idl";
|
|
#endif
|
|
|
|
cpp_quote("//+-------------------------------------------------------------------------")
|
|
cpp_quote("//")
|
|
cpp_quote("// Microsoft Windows")
|
|
cpp_quote("// Copyright (C) Microsoft Corporation, 1998.")
|
|
cpp_quote("//")
|
|
cpp_quote("//--------------------------------------------------------------------------")
|
|
|
|
#include "xmldomdid.h"
|
|
#include <idispids.h>
|
|
|
|
interface IXMLDOMImplementation;
|
|
interface IXMLDOMNode;
|
|
interface IXMLDOMDocumentFragment;
|
|
interface IXMLDOMDocument;
|
|
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;
|
|
|
|
|
|
|
|
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;
|
|
|
|
[
|
|
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("first 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)
|
|
]
|
|
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 desination")]
|
|
HRESULT save(
|
|
[in] VARIANT desination);
|
|
|
|
[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(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(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);
|
|
};
|
|
|
|
|
|
// DOM Document rental-model co-Class
|
|
[
|
|
uuid(2933BF90-7B36-11d2-B20E-00C04F983E60), // CLSID_DOMDocument
|
|
helpstring("W3C-DOM XML Document")
|
|
]
|
|
coclass DOMDocument
|
|
{
|
|
[default] interface IXMLDOMDocument;
|
|
[default, source] dispinterface XMLDOMDocumentEvents;
|
|
};
|
|
|
|
// DOM Document free-threaded co-Class
|
|
[
|
|
uuid(2933BF91-7B36-11d2-B20E-00C04F983E60), // CLSID_DOMDocument
|
|
helpstring("W3C-DOM XML Document (Apartment)")
|
|
]
|
|
coclass DOMFreeThreadedDocument
|
|
{
|
|
[default] interface IXMLDOMDocument;
|
|
[default, source] dispinterface XMLDOMDocumentEvents;
|
|
};
|
|
|
|
|
|
[
|
|
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);
|
|
};
|
|
|
|
// XML HTTP Request Class
|
|
[
|
|
uuid(ED8C108E-4349-11D2-91A4-00C04F7969E8), // CLSID_XMLHTTPRequest
|
|
helpstring("XML HTTP Request class.")
|
|
]
|
|
coclass XMLHTTPRequest
|
|
{
|
|
[default] interface IXMLHttpRequest;
|
|
};
|