xpxmldom.pas

Delphi XML & XPATH源代码

unit XPXMLDOM;

{
  Adapter for TurboPower XMLPartner v2.5 for Delphi's XML DOM interfaces.

  Written by Keith Wood ([e-mail])
  Version 1.0 - 21 August 2002.
}

interface

uses
  Windows, SysUtils, Classes, XMLDOM, XpBase, XpDOM, XpvXSLPr, XpvFlXML;

const
  SXMLPartner = 'XML Partner';  { Do not localize }

type

{ IXpNodeRef }

  IXpNodeRef = interface
    ['{84DE09B6-A51A-4244-8F26-A789C04B1BD0}']
    function GetXMLDOMNode: TXpNode;
  end;

{ TXMLPDOMInterface }

  TXMLPDOMInterface = class(TInterfacedObject)
  end;

{ TXMLPDOMImplementation }

  TXMLPDOMImplementation = class(TXMLPDOMInterface, IDOMImplementation)
  private
    FDOMImpl: TXpDOMImplementation;
  protected
    { IDOMImplementation }
    function hasFeature(const feature, version: DOMString): WordBool;
    function createDocumentType(const qualifiedName, publicId,
      systemId: DOMString): IDOMDocumentType; safecall;
    function createDocument(const namespaceURI, qualifiedName: DOMString;
      doctype: IDOMDocumentType): IDOMDocument; safecall;
  public
    constructor Create(DOMImplementation: TXpDomImplementation);
    destructor Destroy; override;
    property DOMImpl: TXpDOMImplementation read FDOMImpl;
  end;

{ TXMLPDOMNode }

  TXMLPDOMNodeClass = class of TXMLPDOMNode;

  TXMLPDOMDocument = class;

  TXMLPDOMNode = class(TXMLPDOMInterface,
    IXpNodeRef, IDOMNode, IDOMNodeEx, IDOMNodeSelect)
  private
    FAttributes: IDOMNamedNodeMap;
    FChildNodes: IDOMNodeList;
    FNode: TXpNode;
    FOwnerDocument: TXMLPDOMDocument;
  protected
    { IXpNodeRef }
    function GetXMLDOMNode: TXpNode;
    { IDOMNode }
    function get_nodeName: DOMString; virtual; safecall;
    function get_nodeValue: DOMString; safecall;
    procedure set_nodeValue(value: DOMString);
    function get_nodeType: DOMNodeType; virtual; safecall;
    function get_parentNode: IDOMNode; safecall;
    function get_childNodes: IDOMNodeList; virtual; safecall;
    function get_firstChild: IDOMNode; safecall;
    function get_lastChild: IDOMNode; safecall;
    function get_previousSibling: IDOMNode; safecall;
    function get_nextSibling: IDOMNode; safecall;
    function get_attributes: IDOMNamedNodeMap; safecall;
    function get_ownerDocument: IDOMDocument; safecall;
    function get_namespaceURI: DOMString; safecall;
    function get_prefix: DOMString; safecall;
    function get_localName: DOMString; safecall;
    function insertBefore(const newChild, refChild: IDOMNode): IDOMNode;
      safecall;
    function replaceChild(const newChild, oldChild: IDOMNode): IDOMNode;
      safecall;
    function removeChild(const childNode: IDOMNode): IDOMNode; safecall;
    function appendChild(const newChild: IDOMNode): IDOMNode; safecall;
    function hasChildNodes: WordBool; virtual; safecall;
    function cloneNode(deep: WordBool): IDOMNode; safecall;
    procedure normalize;
    function supports(const feature, version: DOMString): WordBool;
    { IDOMNodeEx }
    function get_text: DOMString; safecall;
    function get_xml: DOMString; virtual; safecall;
    procedure set_text(const Value: DOMString); safecall;
    procedure transformNode(const stylesheet: IDOMNode; var output: WideString);
      overload;
    procedure transformNode(const stylesheet: IDOMNode;
      const output: IDOMDocument); overload;
    { IDOMNodeSelect }
    function selectNode(const nodePath: WideString): IDOMNode; safecall;
    function selectNodes(const nodePath: WideString): IDOMNodeList; safecall;
  public
    constructor Create(const Node: TXpNode; const Document: TXMLPDOMDocument);
      virtual;
    property Node: TXpNode read FNode;
  end;

{ TXMLPDOMNodeList }

  TXMLPDOMNodeList = class(TXMLPDOMInterface, IDOMNodeList)
  private
    FNodeList: TXpNodeList;
    FOwnerDocument: TXMLPDOMDocument;
  protected
    { IDOMNodeList }
    function get_item(index: Integer): IDOMNode; safecall;
    function get_length: Integer; safecall;
  public
    constructor Create(const NodeList: TXpNodeList;
      const Document: TXMLPDOMDocument);
    property NodeList: TXpNodeList read FNodeList;
  end;

{ TXMLPDOMNamedNodeMap }

  TXMLPDOMNamedNodeMap = class(TXMLPDOMInterface, IDOMNamedNodeMap)
  private
    FNamedNodeMap: TXpNamedNodeMap;
    FOwnerDocument: TXMLPDOMDocument;
  protected
    { IDOMNamedNodeMap }
    function get_item(index: Integer): IDOMNode; safecall;
    function get_length: Integer;
    function getNamedItem(const name: DOMString): IDOMNode; safecall;
    function setNamedItem(const newItem: IDOMNode): IDOMNode; safecall;
    function removeNamedItem(const name: DOMString): IDOMNode; safecall;
    function getNamedItemNS(const namespaceURI, localName: DOMString):
      IDOMNode; safecall;
    function setNamedItemNS(const arg: IDOMNode): IDOMNode; safecall;
    function removeNamedItemNS(const namespaceURI, localName: DOMString):
      IDOMNode; safecall;
  public
    constructor Create(const NamedNodeMap: TXpNamedNodeMap;
      const Document: TXMLPDOMDocument);
    property NamedNodeMap: TXpNamedNodeMap read FNamedNodeMap;
  end;

{ TXMLPDOMCharacterData }

  TXMLPDOMCharacterData = class(TXMLPDOMNode, IDOMCharacterData)
  private
    function GetCharacterData: TXpCharacterData;
  protected
    { IDOMCharacterData }
    function get_data: DOMString;
    procedure set_data(const data: DOMString);
    function get_length: Integer;
    function substringData(offset, count: Integer): DOMString;
    procedure appendData(const data: DOMString);
    procedure insertData(offset: Integer; const data: DOMString);
    procedure deleteData(offset, count: Integer);
    procedure replaceData(offset, count: Integer; const data: DOMString);
  public
    property CharacterData: TXpCharacterData read GetCharacterData;
  end;

{ TXMLPDOMAttr }

  TXMLPDOMAttr = class(TXMLPDOMNode, IDOMAttr)
  private
    function GetAttribute: TXpAttribute;
  protected
    { IDOMAttr }
    function get_name: DOMString;
    function get_specified: WordBool;
    function get_value: DOMString;
    procedure set_value(const attributeValue: DOMString);
    function get_ownerElement: IDOMElement;
  public
    property Attribute: TXpAttribute read GetAttribute;
  end;

{ TXMLPDOMElement }

  TXMLPDOMElement = class(TXMLPDOMNode, IDOMElement)
  private
    function GetElement: TXpElement;
  protected
    { IDOMElement }
    function get_tagName: DOMString; safecall;
    function getAttribute(const name: DOMString): DOMString; safecall;
    procedure setAttribute(const name, value: DOMString);
    procedure removeAttribute(const name: DOMString);
    function getAttributeNode(const name: DOMString): IDOMAttr; safecall;
    function setAttributeNode(const newAttr: IDOMAttr): IDOMAttr; safecall;
    function removeAttributeNode(const oldAttr: IDOMAttr): IDOMAttr; safecall;
    function getElementsByTagName(const name: DOMString): IDOMNodeList; safecall;
    function getAttributeNS(const namespaceURI, localName: DOMString):
      DOMString; safecall;
    procedure setAttributeNS(const namespaceURI, qualifiedName, value: DOMString);
    procedure removeAttributeNS(const namespaceURI, localName: DOMString);
    function getAttributeNodeNS(const namespaceURI, localName: DOMString):
      IDOMAttr; safecall;
    function setAttributeNodeNS(const newAttr: IDOMAttr): IDOMAttr; safecall;
    function getElementsByTagNameNS(const namespaceURI,
      localName: DOMString): IDOMNodeList; safecall;
    function hasAttribute(const name: DOMString): WordBool; safecall;
    function hasAttributeNS(const namespaceURI, localName: DOMString): WordBool;
    procedure normalize;
  public
    property Element: TXpElement read GetElement;
  end;

{ TXMLPDOMText }

  TXMLPDOMText = class(TXMLPDOMCharacterData, IDOMText)
  protected
    function splitText(offset: Integer): IDOMText; safecall;
  end;

{ TXMLPDOMComment }

  TXMLPDOMComment = class(TXMLPDOMCharacterData, IDOMComment)
  end;

{ TXMLPDOMCDATASection }

  TXMLPDOMCDATASection = class(TXMLPDOMText, IDOMCDATASection)
  end;

{ TXMLPDOMDocumentType }

  TXMLPDOMDocumentType = class(TXMLPDOMNode, IDOMDocumentType)
  private
    FChildren: IDOMNodeList;
    FEntities: IDOMNamedNodeMap;
    FNotations: IDOMNamedNodeMap;
    function GetDocumentType: TXpDocumentType;
  protected
    function get_childNodes: IDOMNodeList; override; safecall;
    function hasChildNodes: WordBool; override; safecall;
    { IDOMDocumentType }
    function get_name: DOMString; safecall;
    function get_entities: IDOMNamedNodeMap; safecall;
    function get_notations: IDOMNamedNodeMap; safecall;
    function get_publicId: DOMString; safecall;
    function get_systemId: DOMString; safecall;
    function get_internalSubset: DOMString; safecall;
  public
    constructor Create(const Node: TXpNode; const Document: TXMLPDOMDocument);
      override;
    property DocumentType: TXpDocumentType read GetDocumentType;
  end;

{ TXMLPDOMNotation }

  TXMLPDOMNotation = class(TXMLPDOMNode, IDOMNotation)
  private
    function GetNotation: TXpDTDNotation;
  protected
    function get_nodeType: DOMNodeType; override; safecall;
    { IDOMNotation }
    function get_publicId: DOMString; safecall;
    function get_systemId: DOMString; safecall;
  public
    property Notation: TXpDTDNotation read GetNotation;
  end;

{ TXMLPDOMEntity }

  TXMLPDOMEntity = class(TXMLPDOMNode, IDOMEntity)
  private
    function GetEntity: TXpDTDEntity;
  protected
    function get_nodeType: DOMNodeType; override; safecall;
    { IDOMEntity }
    function get_publicId: DOMString; safecall;
    function get_systemId: DOMString; safecall;
    function get_notationName: DOMString; safecall;
  public
    property Entity: TXpDTDEntity read GetEntity;
  end;

{ TXMLPDOMEntityReference }

  TXMLPDOMEntityReference = class(TXMLPDOMNode, IDOMEntityReference)
  end;

{ TXMLPDOMProcessingInstruction }

  TXMLPDOMProcessingInstruction = class(TXMLPDOMNode, IDOMProcessingInstruction)
  private
    function GetProcessingInstruction: TXpProcessingInstruction;
  protected
    { IDOMProcessingInstruction }
    function get_target: DOMString; safecall;
    function get_data: DOMString; safecall;
    procedure set_data(const value: DOMString);
  public
    property ProcessingInstruction: TXpProcessingInstruction
      read GetProcessingInstruction;
  end;

{ TXMLPDOMDocumentFragment }

  TXMLPDOMDocumentFragment = class(TXMLPDOMNode, IDOMDocumentFragment)
  end;

{ TXMLPDOMDocument }

  TXMLPDOMDocument = class(TXMLPDOMNode, IDOMDocument, IDOMParseOptions,
    IDOMPersist, IDOMParseError, IDOMXMLProlog)
  private
    FEncoding: DOMString;
    FGotProlog: Boolean;
    FStandalone: DOMString;
    FValidate: Boolean;
    FVersion: DOMString;
    FXMLObjModel: TXpObjModel;
    function GetDocument: TXpDocument;
  protected
    procedure GetProlog;
    { IDOMNode }
    function get_nodeName: DOMString; override; safecall;
    { IDOMDocument }
    function get_doctype: IDOMDocumentType; safecall;
    function get_domImplementation: IDOMImplementation; safecall;
    function get_documentElement: IDOMElement; safecall;
    procedure set_documentElement(const IDOMElement: IDOMElement);
    function createElement(const tagName: DOMString): IDOMElement; safecall;
    function createDocumentFragment: IDOMDocumentFragment; safecall;
    function createTextNode(const data: DOMString): IDOMText; safecall;
    function createComment(const data: DOMString): IDOMComment; safecall;
    function createCDATASection(const data: DOMString): IDOMCDATASection; safecall;
    function createProcessingInstruction(const target,
      data: DOMString): IDOMProcessingInstruction; safecall;
    function createAttribute(const name: DOMString): IDOMAttr; safecall;
    function createEntityReference(const name: DOMString): IDOMEntityReference; safecall;
    function getElementsByTagName(const tagName: DOMString): IDOMNodeList; safecall;
    function importNode(importedNode: IDOMNode; deep: WordBool): IDOMNode; safecall;
    function createElementNS(const namespaceURI,
      qualifiedName: DOMString): IDOMElement; safecall;
    function createAttributeNS(const namespaceURI,
      qualifiedName: DOMString): IDOMAttr; safecall;
    function getElementsByTagNameNS(const namespaceURI,
      localName: DOMString): IDOMNodeList; safecall;
    function getElementById(const elementId: DOMString): IDOMElement;
    { IDOMParseOptions }
    function get_async: Boolean;
    function get_preserveWhiteSpace: Boolean;
    function get_resolveExternals: Boolean;
    function get_validate: Boolean;
    procedure set_async(Value: Boolean);
    procedure set_preserveWhiteSpace(Value: Boolean);
    procedure set_resolveExternals(Value: Boolean);
    procedure set_validate(Value: Boolean);
    { IDOMPersist }
    function get_xml: DOMString; override; safecall;
    function asyncLoadState: Integer; safecall;
    function load(source: OleVariant): WordBool; safecall;
    function loadFromStream(const stream: TStream): WordBool; safecall;
    function loadxml(const Value: DOMString): WordBool; safecall;
    procedure save(destination: OleVariant); safecall;
    procedure saveToStream(const stream: TStream); safecall;
    procedure set_OnAsyncLoad(const Sender: TObject;
      EventHandler: TAsyncEventHandler); safecall;
    { IDOMParseError }
    function get_errorCode: Integer;
    function get_url: WideString; safecall;
    function get_reason: WideString; safecall;
    function get_srcText: WideString; safecall;
    function get_line: Integer;
    function get_linepos: Integer;
    function get_filepos: Integer;
    { IDOMXMLProlog }
    function get_Encoding: DOMString; safecall;
    function get_Standalone: DOMString; safecall;
    function get_Version: DOMString; safecall;
    procedure set_Encoding(const Value: DOMString); safecall;
    procedure set_Standalone(const Value: DOMString); safecall;
    procedure set_Version(const Value: DOMString); safecall;
  public
    constructor Create(const Node: TXpNode; const Document: TXMLPDOMDocument);
      override;
    destructor Destroy; override;
    property Document: TXpDocument read GetDocument;
  end;

{ TXMLPDOMImplementationFactory }

  TXMLPDOMImplementationFactory = class(TDOMVendor)
  public
    function DOMImplementation: IDOMImplementation; override;
    function Description: String; override;
  end;

var
  XPXML_DOM: TXMLPDOMImplementationFactory;

implementation

resourcestring
  SNodeExpected = 'Node cannot be null';

{ Utility Functions -----------------------------------------------------------}

function MakeNode(const Node: TXpNode; const Document: TXMLPDOMDocument):
  IDOMNode;
const
  NodeClasses: array [ELEMENT_NODE..NOTATION_NODE] of TXMLPDOMNodeClass =
    (TXMLPDOMElement, TXMLPDOMAttr, TXMLPDOMText, TXMLPDOMCDataSection,
     TXMLPDOMEntityReference, TXMLPDOMEntity, TXMLPDOMProcessingInstruction,
     TXMLPDOMComment, TXMLPDOMDocument, TXMLPDOMDocumentType,
     TXMLPDOMDocumentFragment, TXMLPDOMNotation);
begin
  if Assigned(Node) then
    case Node.nodeType of
      ENTITY_DECL_NODE:   Result := TXMLPDOMEntity.Create(Node, Document);
      NOTATION_DECL_NODE: Result := TXMLPDOMNotation.Create(Node, Document);
      else                Result :=
                            NodeClasses[Node.nodeType].Create(Node, Document);
    end
  else
    Result := nil;
end;