开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > xml/soap/webservice > 查看源码
XMLDOMDocument.cpp
资源名称：xerces-c-src1_6_0.tar.gz　[点击查看]
上传用户：huihehuasu
上传日期：2007-01-10
资源大小：6948k
文件大小：35k
源码类别：

xml/soap/webservice

开发平台：

C/C++

XMLDOMDocument.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 1999-2001 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 1999, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  57. /*
  58.  * $Id: XMLDOMDocument.cpp,v 1.9 2001/10/24 19:11:39 tng Exp $
  59.  */
  61. #include "stdafx.h"
  63. #include <parsers/DOMParser.hpp>
  64. #include <sax/SAXParseException.hpp>
  65. #include <framework/MemBufInputSource.hpp>
  67. #include "xml4com.h"
  68. #include "XMLDOMDocument.h"
  69. #include "XMLDOMUtil.h"
  70. #include "XMLDOMNodeList.h"
  71. #include "XMLDOMNamedNodeMap.h"
  72. #include "XMLDOMDocumentType.h"
  73. #include "XMLDOMImplementation.h"
  74. #include "XMLDOMElement.h"
  75. #include "XMLDOMDocumentFragment.h"
  76. #include "XMLDOMText.h"
  77. #include "XMLDOMComment.h"
  78. #include "XMLDOMCDATASection.h"
  79. #include "XMLDOMProcessingInstruction.h"
  80. #include "XMLDOMAttribute.h"
  81. #include "XMLDOMEntityReference.h"
  82. #include "BindStatusCallback.h"
  83. #include <dom/DocumentImpl.hpp>
  85. // I need to make sure the file is registered with long filenames
  86. HRESULT WINAPI CXMLDOMDocument::UpdateRegistry(BOOL bRegister)
  87. {
  88. USES_CONVERSION;
  90. TCHAR file[MAX_PATH];
  91. if (::GetModuleFileName(_Module.m_hInst, file, MAX_PATH)) {
  92. WIN32_FIND_DATA d;
  93. memset(&d,0,sizeof(WIN32_FIND_DATA));
  94. HANDLE h = FindFirstFile(file,&d);
  95. if (h != INVALID_HANDLE_VALUE) {
  96. TCHAR  *name = _tcsrchr(file,_T('\'));
  97. TCHAR newFile[MAX_PATH] = _T("");
  98. _tcsncpy(newFile,file,name-file);
  99. _tcscat(newFile,_T("\"));
  100. _tcscat(newFile,d.cFileName);
  101. FindClose(h);
  103. _ATL_REGMAP_ENTRY regmap[2] = {{NULL,NULL},{NULL,NULL}};
  104. regmap[0].szKey  = OLESTR("XMLMODULE");
  105. regmap[0].szData = T2OLE(newFile);
  106. return _Module.UpdateRegistryFromResource((UINT) IDR_XMLDOCUMENT, bRegister,regmap);
  107. }
  108. }
  109. return E_FAIL;
  110. }
  112. CXMLDOMDocument::CXMLDOMDocument()
  113. :m_Document ()
  114. ,m_bValidate (false)
  115. ,m_lReadyState (0)
  116. ,m_url (_T(""))
  117. ,m_pParseError (NULL)
  118. ,m_bAsync (false)
  119. ,m_bAbort (false)
  120. ,m_hParseThread (NULL)
  121. ,m_pOnReadyStateChange (NULL)
  122. ,m_pOnDataAvailable (NULL)
  123. ,m_pOnTransformNode (NULL)
  124. ,m_FileName (_T(""))
  125. ,m_xml (_T(""))
  126. ,m_bParseError (false)
  127. ,m_bThreadValidate (false)
  128. ,m_bPreserveWhiteSpace      (false)
  129. {
  130. }
  132. HRESULT CXMLDOMDocument::FinalConstruct()
  133. {
  134. // create monitor window
  135. RECT rc;
  136.     memset(&rc,0,sizeof(RECT));
  137. if (NULL == Create(NULL, rc, _T("XML Parse Monitor Window"), 0))
  138. return E_FAIL;
  140. HRESULT hr = CXMLDOMParseErrorObj::CreateInstance(&m_pParseError);
  141. if (S_OK != hr)
  142. return hr;
  144. m_pParseError->AddRef();
  145. m_pIXMLDOMDocument = this;
  147. m_Document = DOM_Document::createDocument();
  149. return hr;
  150. }
  152. void CXMLDOMDocument::FinalRelease()
  153. {
  154. if (NULL != m_hParseThread) {
  155. m_bAbort = true;
  156. ::WaitForSingleObject(m_hParseThread, INFINITE);
  157. ::CloseHandle(m_hParseThread);
  158. m_hParseThread = NULL;
  159. }
  161. if (m_pParseError != NULL) {
  162. m_pParseError->Release();
  163. m_pParseError = NULL;
  164. }
  165. if (m_pOnReadyStateChange != NULL) {
  166. m_pOnReadyStateChange->Release();
  167. m_pOnReadyStateChange = NULL;
  168. }
  169. if (m_pOnDataAvailable != NULL) {
  170. m_pOnDataAvailable->Release();
  171. m_pOnDataAvailable = NULL;
  172. }
  173. if (m_pOnTransformNode != NULL) {
  174. m_pOnTransformNode->Release();
  175. m_pOnTransformNode = NULL;
  176. }
  178. DestroyWindow();
  179. }
  181. void CXMLDOMDocument::warning(const SAXParseException& exception)
  182. {
  183. // ignore warnings
  184. }
  186. void CXMLDOMDocument::error(const SAXParseException& exception)
  187. {
  188. m_pParseError->SetData(1,
  189.    exception.getSystemId(),
  190.    exception.getMessage(),
  191.    _T(""),
  192.    exception.getLineNumber(),
  193.    exception.getColumnNumber(),
  194.    0);
  195. m_bParseError = true;
  196. }
  198. void CXMLDOMDocument::fatalError(const SAXParseException& exception)
  199. {
  200. m_pParseError->SetData(1,
  201.    exception.getSystemId(),
  202.    exception.getMessage(),
  203.    _T(""),
  204.    exception.getLineNumber(),
  205.    exception.getColumnNumber(),
  206.    0);
  207. m_bParseError = true;
  208. }
  210. LRESULT CXMLDOMDocument::OnReadyStateChange(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
  211. {
  212. ATLTRACE(_T("CXMLDOMDocument::OnReadyStateChangen"));
  214. bHandled = TRUE;
  216. m_lReadyState = wParam;
  217. Fire_onreadystatechange();
  218. if (NULL != m_pOnReadyStateChange) {
  219. CComVariant varResult;
  220. DISPPARAMS disp = { NULL, NULL, 0, 0 };
  221. m_pOnReadyStateChange->Invoke(DISPID_VALUE, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
  222. }
  223. if (m_lReadyState != 4)
  224. return 1L;
  226. m_Document = m_TmpDocument;
  227. m_TmpDocument = 0;
  229. m_url = m_FileName;
  231. if (!m_bParseError) {
  232. Fire_ondataavailable();
  233. if (NULL != m_pOnDataAvailable) {
  234. CComVariant varResult;
  235. DISPPARAMS disp = { NULL, NULL, 0, 0 };
  236. m_pOnDataAvailable->Invoke(DISPID_VALUE, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
  237. }
  238. }
  240. return 1L;
  241. }
  243. STDMETHODIMP CXMLDOMDocument::InterfaceSupportsErrorInfo(REFIID riid)
  244. {
  245. if (IsEqualGUID(IID_IXMLDOMDocument,riid))
  246. return S_OK;
  247. return S_FALSE;
  248. }
  250. STDMETHODIMP CXMLDOMDocument::get_doctype(IXMLDOMDocumentType  **pVal)
  251. {
  252. ATLTRACE(_T("CXMLDOMDocument::get_doctypen"));
  254. if (NULL == pVal)
  255. return E_POINTER;
  257. *pVal = NULL;
  258. DOM_DocumentType doctype = m_Document.getDoctype();
  260. //
  261. //   if the document had no doctype then return a null object
  262. //
  263. if(doctype.isNull())
  264. return S_OK;
  266. CXMLDOMDocumentTypeObj *pObj = NULL;
  267. HRESULT hr = CXMLDOMDocumentTypeObj::CreateInstance(&pObj);
  268. if (S_OK != hr)
  269. return hr;
  271. pObj->AddRef();
  272. pObj->SetOwnerDoc(this);
  274. try
  275. {
  276. pObj->documentType = doctype;
  277. }
  278. catch(...)
  279. {
  280. pObj->Release();
  281. return E_FAIL;
  282. }
  284. hr = pObj->QueryInterface(IID_IXMLDOMDocumentType, reinterpret_cast<LPVOID*> (pVal));
  285. if (S_OK != hr)
  286. *pVal = NULL;
  288. pObj->Release();
  289. return hr;
  290. }
  292. STDMETHODIMP CXMLDOMDocument::get_implementation(IXMLDOMImplementation  **pVal)
  293. {
  294. ATLTRACE(_T("CXMLDOMDocument::get_implementationn"));
  296. if (NULL == pVal)
  297. return E_POINTER;
  299. *pVal = NULL;
  301. CXMLDOMImplementationObj *pObj = NULL;
  302. HRESULT hr = CXMLDOMImplementationObj::CreateInstance(&pObj);
  303. if (S_OK != hr)
  304. return hr;
  306. pObj->AddRef();
  308. hr = pObj->QueryInterface(IID_IXMLDOMImplementation, reinterpret_cast<LPVOID*> (pVal));
  309. if (S_OK != hr)
  310. *pVal = NULL;
  312. pObj->Release();
  313. return hr;
  314. }
  316. STDMETHODIMP CXMLDOMDocument::get_documentElement(IXMLDOMElement  * *pVal)
  317. {
  318. ATLTRACE(_T("CXMLDOMDocument::get_documentElementn"));
  320. if (NULL == pVal)
  321. return E_POINTER;
  323. *pVal = NULL;
  325. CXMLDOMElementObj *pObj = NULL;
  326. HRESULT hr = CXMLDOMElementObj::CreateInstance(&pObj);
  327. if (S_OK != hr)
  328. return S_OK;
  330. pObj->AddRef();
  331. pObj->SetOwnerDoc(this);
  333. try
  334. {
  335. pObj->element = m_Document.getDocumentElement();
  336. }
  337. catch(DOM_DOMException& ex)
  338. {
  339. pObj->Release();
  340. return MakeHRESULT(ex);
  341. }
  342. catch(...)
  343. {
  344. pObj->Release();
  345. return S_OK;
  346. }
  348. hr = pObj->QueryInterface(IID_IXMLDOMElement, reinterpret_cast<LPVOID*> (pVal));
  349. if (S_OK != hr)
  350. *pVal = NULL;
  352. pObj->Release();
  353. return S_OK;
  354. }
  356. STDMETHODIMP CXMLDOMDocument::putref_documentElement(IXMLDOMElement  *newVal)
  357. {
  358. ATLTRACE(_T("CXMLDOMDocument::putref_documentElementn"));
  360. DOM_Element elem;
  362. try
  363. {
  364. elem = m_Document.getDocumentElement();
  365. if (NULL == newVal && !elem.isNull()) {
  366. m_Document.removeChild(elem);
  367. return S_OK;
  368. }
  369. }
  370. catch(DOM_DOMException& ex)
  371. {
  372. return MakeHRESULT(ex);
  373. }
  374. catch(...)
  375. {
  376. return E_FAIL;
  377. }
  379. CComQIPtr<IIBMXMLDOMNodeIdentity,&IID_IIBMXMLDOMNodeIdentity> pNewVal(newVal);
  380. if (!pNewVal)
  381. return E_NOINTERFACE;
  383. long id = 0;
  384. HRESULT hr = pNewVal->get_NodeId(&id);
  385. if (S_OK != hr)
  386. return hr;
  388. DOM_Node *pNewValNode = reinterpret_cast<DOM_Node*> (id);
  389. if (NULL == pNewValNode)
  390. return E_INVALIDARG;
  392. try
  393. {
  394. if(elem.isNull())
  395. m_Document.appendChild(*pNewValNode);
  396. else
  397. m_Document.replaceChild(*pNewValNode, elem);
  398. }
  399. catch(DOM_DOMException& ex)
  400. {
  401. return MakeHRESULT(ex);
  402. }
  403. catch(...)
  404. {
  405. return E_FAIL;
  406. }
  408. return S_OK;
  409. }
  411. STDMETHODIMP CXMLDOMDocument::createElement(BSTR tagName, IXMLDOMElement  **pVal)
  412. {
  413. ATLTRACE(_T("CXMLDOMDocument::createElementn"));
  415. if (NULL == pVal)
  416. return E_POINTER;
  418. *pVal = NULL;
  420. CXMLDOMElementObj *pObj = NULL;
  421. HRESULT hr = CXMLDOMElementObj::CreateInstance(&pObj);
  422. if (S_OK != hr)
  423. return hr;
  425. pObj->AddRef();
  426. pObj->SetOwnerDoc(this);
  428. try
  429. {
  430. pObj->element = m_Document.createElement(tagName);
  431. }
  432. catch(DOM_DOMException& ex)
  433. {
  434. pObj->Release();
  435. return MakeHRESULT(ex);
  436. }
  437. catch(...)
  438. {
  439. pObj->Release();
  440. return E_FAIL;
  441. }
  443. hr = pObj->QueryInterface(IID_IXMLDOMElement, reinterpret_cast<LPVOID*> (pVal));
  444. if (S_OK != hr)
  445. *pVal = NULL;
  447. pObj->Release();
  448. return hr;
  449. }
  451. STDMETHODIMP CXMLDOMDocument::createDocumentFragment(IXMLDOMDocumentFragment  **docFrag)
  452. {
  453. ATLTRACE(_T("CXMLDOMDocument::createDocumentFragmentn"));
  455. if (NULL == docFrag)
  456. return E_POINTER;
  458. *docFrag = NULL;
  460. CXMLDOMDocumentFragmentObj *pObj = NULL;
  461. HRESULT hr = CXMLDOMDocumentFragmentObj::CreateInstance(&pObj);
  462. if (S_OK != hr)
  463. return hr;
  465. pObj->AddRef();
  466. pObj->SetOwnerDoc(this);
  468. try
  469. {
  470. pObj->documentFragment = m_Document.createDocumentFragment();
  471. }
  472. catch(DOM_DOMException& ex)
  473. {
  474. pObj->Release();
  475. return MakeHRESULT(ex);
  476. }
  477. catch(...)
  478. {
  479. pObj->Release();
  480. return E_FAIL;
  481. }
  483. hr = pObj->QueryInterface(IID_IXMLDOMDocumentFragment, reinterpret_cast<LPVOID*> (docFrag));
  484. if (S_OK != hr)
  485. *docFrag = NULL;
  487. pObj->Release();
  488. return hr;
  489. }
  491. STDMETHODIMP CXMLDOMDocument::createTextNode(BSTR data, IXMLDOMText  **pVal)
  492. {
  493. ATLTRACE(_T("CXMLDOMDocument::createTextNoden"));
  495. if (NULL == pVal)
  496. return E_POINTER;
  498. *pVal = NULL;
  500. CXMLDOMTextObj *pObj = NULL;
  501. HRESULT hr = CXMLDOMTextObj::CreateInstance(&pObj);
  502. if (S_OK != hr)
  503. return hr;
  505. pObj->AddRef();
  506. pObj->SetOwnerDoc(this);
  508. try
  509. {
  510. pObj->text = m_Document.createTextNode(data);
  511. }
  512. catch(DOM_DOMException& ex)
  513. {
  514. pObj->Release();
  515. return MakeHRESULT(ex);
  516. }
  517. catch(...)
  518. {
  519. pObj->Release();
  520. return E_FAIL;
  521. }
  523. hr = pObj->QueryInterface(IID_IXMLDOMText, reinterpret_cast<LPVOID*> (pVal));
  524. if (S_OK != hr)
  525. *pVal = NULL;
  527. pObj->Release();
  528. return hr;
  529. }
  531. STDMETHODIMP CXMLDOMDocument::createComment(BSTR data, IXMLDOMComment  **comment)
  532. {
  533. ATLTRACE(_T("CXMLDOMDocument::createCommentn"));
  535. if (NULL == comment)
  536. return E_POINTER;
  538. *comment = NULL;
  540. CXMLDOMCommentObj *pObj = NULL;
  541. HRESULT hr = CXMLDOMCommentObj::CreateInstance(&pObj);
  542. if (S_OK != hr)
  543. return hr;
  545. pObj->AddRef();
  546. pObj->SetOwnerDoc(this);
  548. try
  549. {
  550. pObj->comment = m_Document.createComment(data);
  551. }
  552. catch(DOM_DOMException& ex)
  553. {
  554. pObj->Release();
  555. return MakeHRESULT(ex);
  556. }
  557. catch(...)
  558. {
  559. pObj->Release();
  560. return E_FAIL;
  561. }
  563. hr = pObj->QueryInterface(IID_IXMLDOMComment, reinterpret_cast<LPVOID*> (comment));
  564. if (S_OK != hr)
  565. *comment = NULL;
  567. pObj->Release();
  568. return hr;
  569. }
  571. STDMETHODIMP CXMLDOMDocument::createCDATASection(BSTR data, IXMLDOMCDATASection  **cdata)
  572. {
  573. ATLTRACE(_T("CXMLDOMDocument::createCDATASectionn"));
  575. if (NULL == cdata)
  576. return E_POINTER;
  578. *cdata = NULL;
  580. CXMLDOMCDATASectionObj *pObj = NULL;
  581. HRESULT hr = CXMLDOMCDATASectionObj::CreateInstance(&pObj);
  582. if (S_OK != hr)
  583. return hr;
  585. pObj->AddRef();
  586. pObj->SetOwnerDoc(this);
  588. try
  589. {
  590. pObj->cdataSection = m_Document.createCDATASection(data);
  591. }
  592. catch(DOM_DOMException& ex)
  593. {
  594. pObj->Release();
  595. return MakeHRESULT(ex);
  596. }
  597. catch(...)
  598. {
  599. pObj->Release();
  600. return E_FAIL;
  601. }
  603. hr = pObj->QueryInterface(IID_IXMLDOMCDATASection, reinterpret_cast<LPVOID*> (cdata));
  604. if (S_OK != hr)
  605. *cdata = NULL;
  607. pObj->Release();
  608. return hr;
  609. }
  611. STDMETHODIMP CXMLDOMDocument::createProcessingInstruction(BSTR target, BSTR data, IXMLDOMProcessingInstruction  **pVal)
  612. {
  613. ATLTRACE(_T("CXMLDOMDocument::createProcessingInstructionn"));
  615. if (NULL == pVal)
  616. return E_POINTER;
  618. *pVal = NULL;
  620. CXMLDOMProcessingInstructionObj *pObj = NULL;
  621. HRESULT hr = CXMLDOMProcessingInstructionObj::CreateInstance(&pObj);
  622. if (S_OK != hr)
  623. return hr;
  625. pObj->AddRef();
  626. pObj->SetOwnerDoc(this);
  628. try
  629. {
  630. pObj->processingInstruction = m_Document.createProcessingInstruction(target, data);
  631. }
  632. catch(DOM_DOMException& ex)
  633. {
  634. pObj->Release();
  635. return MakeHRESULT(ex);
  636. }
  637. catch(...)
  638. {
  639. pObj->Release();
  640. return E_FAIL;
  641. }
  643. hr = pObj->QueryInterface(IID_IXMLDOMProcessingInstruction, reinterpret_cast<LPVOID*> (pVal));
  644. if (S_OK != hr)
  645. *pVal = NULL;
  647. pObj->Release();
  648. return hr;
  649. }
  651. STDMETHODIMP CXMLDOMDocument::createAttribute(BSTR name, IXMLDOMAttribute  **attr)
  652. {
  653. ATLTRACE(_T("CXMLDOMDocument::createAttributen"));
  655. if (NULL == attr)
  656. return E_POINTER;
  658. *attr = NULL;
  660. CXMLDOMAttributeObj *pObj = NULL;
  661. HRESULT hr = CXMLDOMAttributeObj::CreateInstance(&pObj);
  662. if (S_OK != hr)
  663. return hr;
  665. pObj->AddRef();
  666. pObj->SetOwnerDoc(this);
  668. try
  669. {
  670. pObj->attr = m_Document.createAttribute(name);
  671. }
  672. catch(DOM_DOMException& ex)
  673. {
  674. pObj->Release();
  675. return MakeHRESULT(ex);
  676. }
  677. catch(...)
  678. {
  679. pObj->Release();
  680. return E_FAIL;
  681. }
  683. hr = pObj->QueryInterface(IID_IXMLDOMAttribute, reinterpret_cast<LPVOID*> (attr));
  684. if (S_OK != hr)
  685. *attr = NULL;
  687. pObj->Release();
  688. return hr;
  689. }
  691. STDMETHODIMP CXMLDOMDocument::createEntityReference(BSTR name, IXMLDOMEntityReference  **entityRef)
  692. {
  693. ATLTRACE(_T("CXMLDOMDocument::createEntityReferencen"));
  695. if (NULL == entityRef)
  696. return E_POINTER;
  698. *entityRef = NULL;
  700. CXMLDOMEntityReferenceObj *pObj = NULL;
  701. HRESULT hr = CXMLDOMEntityReferenceObj::CreateInstance(&pObj);
  702. if (S_OK != hr)
  703. return hr;
  705. pObj->AddRef();
  706. pObj->SetOwnerDoc(this);
  708. try
  709. {
  710. pObj->entityReference = m_Document.createEntityReference(name);
  711. }
  712. catch(DOM_DOMException& ex)
  713. {
  714. pObj->Release();
  715. return MakeHRESULT(ex);
  716. }
  717. catch(...)
  718. {
  719. pObj->Release();
  720. return E_FAIL;
  721. }
  723. hr = pObj->QueryInterface(IID_IXMLDOMEntityReference, reinterpret_cast<LPVOID*> (entityRef));
  724. if (S_OK != hr)
  725. *entityRef = NULL;
  727. pObj->Release();
  728. return hr;
  729. }
  731. STDMETHODIMP CXMLDOMDocument::getElementsByTagName(BSTR tagName, IXMLDOMNodeList  **pVal)
  732. {
  733. ATLTRACE(_T("CXMLDOMDocument::getElementsByTagNamen"));
  735. if (NULL == pVal)
  736. return E_POINTER;
  738. *pVal = NULL;
  740. CXMLDOMNodeListObj *pObj = NULL;
  741. HRESULT hr = CXMLDOMNodeListObj::CreateInstance(&pObj);
  742. if (S_OK != hr)
  743. return hr;
  745. pObj->AddRef();
  746. pObj->SetOwnerDoc(m_pIXMLDOMDocument);
  748. try
  749. {
  750. pObj->m_container = m_Document.getElementsByTagName(tagName);
  751. }
  752. catch(DOM_DOMException& ex)
  753. {
  754. pObj->Release();
  755. return MakeHRESULT(ex);
  756. }
  757. catch(...)
  758. {
  759. pObj->Release();
  760. return E_FAIL;
  761. }
  763. hr = pObj->QueryInterface(IID_IXMLDOMNodeList, reinterpret_cast<LPVOID*> (pVal));
  764. if (S_OK != hr)
  765. *pVal = NULL;
  767. pObj->Release();
  768. return hr;
  769. }
  771. STDMETHODIMP CXMLDOMDocument::createNode(VARIANT TYPE, BSTR name, BSTR namespaceURI, IXMLDOMNode  **pVal)
  772. {
  773. ATLTRACE(_T("CXMLDOMDocument::createNoden"));
  775. HRESULT hr = S_OK;
  776. if (NULL == pVal)
  777. return E_POINTER;
  779. *pVal = NULL;
  781. VARIANT type;
  782. ::VariantInit(&type);
  783. if (V_VT(&TYPE) != VT_I4 && V_VT(&TYPE) != VT_BSTR)
  784. hr = ::VariantChangeType(&type,&TYPE,0,VT_I4); 
  785. else
  786. hr = ::VariantCopy(&type,&TYPE);
  788. if (S_OK != hr)
  789. return hr;
  791. DOMNodeType nodeType = NODE_INVALID;
  792. if (VT_I4 == V_VT(&type))
  793. nodeType = static_cast<DOMNodeType> (V_I4(&type));
  794. else {
  795. OLECHAR* str = V_BSTR(&type);
  796. for (int i = 0; i < g_DomNodeNameSize; ++i) {
  797. if (0 == _wcsicmp(str,g_DomNodeName[i])) {
  798. nodeType = static_cast<DOMNodeType> (i);
  799. break;
  800. }
  801. }
  802. }
  804. ::VariantClear(&type);
  806. if (NODE_INVALID == nodeType ||
  807. NODE_DOCUMENT == nodeType ||
  808. NODE_DOCUMENT_TYPE == nodeType ||
  809. NODE_ENTITY == nodeType ||
  810. NODE_NOTATION == nodeType)
  811. return E_FAIL;
  813. try
  814. {
  815. switch(nodeType) {
  816. case NODE_ELEMENT:
  817. {
  818. DOM_Element node;
  819. if (SysStringLen(namespaceURI) > 0)
  820. node = m_Document.createElementNS(namespaceURI,name);
  821. else
  822. node = m_Document.createElement(name);
  824. hr = wrapNode(m_pIXMLDOMDocument,node,IID_IXMLDOMNode,reinterpret_cast<LPVOID *> (pVal));
  825. break;
  826. }
  827. case NODE_ATTRIBUTE:
  828. {
  829. DOM_Attr node;
  830. if (SysStringLen(namespaceURI) > 0)
  831. node = m_Document.createAttributeNS(namespaceURI,name);
  832. else
  833. node = m_Document.createAttribute(name);
  835. hr = wrapNode(m_pIXMLDOMDocument,node,IID_IXMLDOMNode,reinterpret_cast<LPVOID *> (pVal));
  836. break;
  837. }
  838. case NODE_TEXT:
  839. {
  840. DOM_Text node = m_Document.createTextNode(OLESTR(""));
  841. hr = wrapNode(m_pIXMLDOMDocument,node,IID_IXMLDOMNode,reinterpret_cast<LPVOID *> (pVal));
  842. break;
  843. }
  844. case NODE_CDATA_SECTION:
  845. {
  846. DOM_CDATASection node = m_Document.createCDATASection(OLESTR(""));
  847. hr = wrapNode(m_pIXMLDOMDocument,node,IID_IXMLDOMNode,reinterpret_cast<LPVOID *> (pVal));
  848. break;
  849. }
  850. case NODE_ENTITY_REFERENCE:
  851. {
  852. DOM_EntityReference node = m_Document.createEntityReference(name);
  853. hr = wrapNode(m_pIXMLDOMDocument,node,IID_IXMLDOMNode,reinterpret_cast<LPVOID *> (pVal));
  854. break;
  855. }
  856. case NODE_PROCESSING_INSTRUCTION:
  857. {
  858. DOM_ProcessingInstruction node = m_Document.createProcessingInstruction(name,OLESTR(""));
  859. hr = wrapNode(m_pIXMLDOMDocument,node,IID_IXMLDOMNode,reinterpret_cast<LPVOID *> (pVal));
  860. break;
  861. }
  862. case NODE_COMMENT:
  863. {
  864. DOM_Comment node = m_Document.createComment(OLESTR(""));
  865. hr = wrapNode(m_pIXMLDOMDocument,node,IID_IXMLDOMNode,reinterpret_cast<LPVOID *> (pVal));
  866. break;
  867. }
  868. case NODE_DOCUMENT_FRAGMENT:
  869. {
  870. DOM_DocumentFragment node = m_Document.createDocumentFragment();
  871. hr = wrapNode(m_pIXMLDOMDocument,node,IID_IXMLDOMNode,reinterpret_cast<LPVOID *> (pVal));
  872. break;
  873. }
  874. default:
  875. hr = E_FAIL;
  876. break;
  877. }
  878. }
  879. catch(DOM_DOMException& ex)
  880. {
  881. hr = MakeHRESULT(ex);
  882. }
  883. catch (...)
  884. {
  885. hr = E_FAIL;
  886. }
  888. return hr;
  889. }
  891. STDMETHODIMP CXMLDOMDocument::nodeFromID(BSTR idString, IXMLDOMNode  **pVal)
  892. {
  893. ATLTRACE(_T("CXMLDOMDocument::nodeFromIDn"));
  895. if (NULL == pVal)
  896. return E_POINTER;
  898. *pVal = NULL;
  899. HRESULT hr = S_OK;
  901. try
  902. {
  903. hr = wrapNode(m_pIXMLDOMDocument, m_Document.getElementById(idString),IID_IXMLDOMNode,reinterpret_cast<LPVOID *> (pVal));
  904. }
  905. catch(DOM_DOMException& ex)
  906. {
  907. return MakeHRESULT(ex);
  908. }
  909. catch(...)
  910. {
  911. return E_FAIL;
  912. }
  914. return hr;
  915. }
  917. STDMETHODIMP CXMLDOMDocument::load(VARIANT xmlSource, VARIANT_BOOL  *isSuccessful)
  918. {
  919. ATLTRACE(_T("CXMLDOMDocument::loadn"));
  921. if (NULL == isSuccessful)
  922. return E_POINTER;
  924. *isSuccessful = VARIANT_FALSE;
  926. if (V_VT(&xmlSource) != VT_BSTR &&
  927. V_VT(&xmlSource) != VT_DISPATCH &&
  928. V_VT(&xmlSource) != (VT_ARRAY | VT_VARIANT) &&
  929. V_VT(&xmlSource) != (VT_ARRAY | VT_UI1) &&
  930. V_VT(&xmlSource) != VT_UNKNOWN)
  931. return E_INVALIDARG;
  933. // do not start another thread if there is another active
  934. if (NULL != m_hParseThread) {
  935. DWORD exitCode = 0;
  936. BOOL rc = ::GetExitCodeThread(m_hParseThread, &exitCode);
  937. if (!rc || STILL_ACTIVE == exitCode)
  938. return S_OK;
  940. ::CloseHandle(m_hParseThread);
  941. m_hParseThread = NULL;
  942. }
  944. HRESULT hr = S_OK;
  945. m_bAbort = false;
  947. m_FileName = _T("");
  948. m_xml = _T("");
  949. m_TmpDocument = 0;
  950. m_bThreadValidate = m_bValidate;
  952. if (V_VT(&xmlSource) == VT_BSTR) {
  953. m_FileName = V_BSTR(&xmlSource);
  954. if (0 == m_FileName.length())
  955. return E_INVALIDARG;
  957. // see if the file is relative path
  958. if (!PathIsURL(m_FileName) && PathIsRelative(m_FileName)) {
  959. // try appending baseurl if exists
  960. _bstr_t baseURL;
  961. if (S_OK == GetBaseURL(baseURL)) {
  962. // change any backslashes to slashes
  963. LPTSTR loc = _tcschr(m_FileName,_T('\'));
  964. while (loc != NULL) {
  965. *loc = _T('/');
  966. loc = _tcschr(m_FileName,_T('\'));
  967. }
  968. m_FileName = baseURL + _T("/") + m_FileName;
  969. }
  970. }
  971. }
  972. else
  973. if (V_VT(&xmlSource) == VT_UNKNOWN) {
  974. CComQIPtr<IStream,&IID_IStream> pS(V_UNKNOWN(&xmlSource));
  975. if (!pS)
  976. return E_INVALIDARG;
  978. CComBSTR b;
  979. hr = b.ReadFromStream(pS);
  980. if (S_OK != hr)
  981. return hr;
  983. m_xml = b;
  984. if (0 == m_xml.length())
  985. return E_INVALIDARG;
  986. }
  987. else
  988. if (V_VT(&xmlSource) == VT_DISPATCH) {
  989. CComQIPtr<IXMLDOMDocument,&IID_IXMLDOMDocument> pDoc(V_DISPATCH(&xmlSource));
  990. if (!pDoc)
  991. return E_INVALIDARG;
  993. BSTR b = NULL;
  994. hr = pDoc->get_xml(&b);
  995. if (S_OK != hr)
  996. return hr;
  998. m_xml = b;
  999. ::SysFreeString(b);
  1001. if (0 == m_xml.length())
  1002. return E_INVALIDARG;
  1003. }
  1004. else
  1005. if (V_VT(&xmlSource) == (VT_ARRAY | VT_VARIANT)) {
  1006. SAFEARRAY *pArray = reinterpret_cast<SAFEARRAY *> (xmlSource.byref);
  1007. if (NULL == pArray)
  1008. return E_INVALIDARG;
  1010. long lLBoundVar = 0;
  1011. long lUBoundVar = 0;
  1013. UINT dims = ::SafeArrayGetDim(pArray);
  1014. if (dims == 0)
  1015. return E_INVALIDARG;
  1017. hr = ::SafeArrayGetLBound(pArray, dims, &lLBoundVar);
  1018. if (S_OK != hr)
  1019. return hr;
  1021. hr = ::SafeArrayGetUBound(pArray, dims, &lUBoundVar);
  1022. if (S_OK != hr)
  1023. return hr;
  1025. if (lUBoundVar >= lLBoundVar) {
  1026. VARIANT *pIndex = NULL;
  1027. hr = ::SafeArrayAccessData(pArray, reinterpret_cast<void **> (&pIndex));
  1028. if (S_OK != hr)
  1029. return hr;
  1031. int length = lUBoundVar-lLBoundVar+2;
  1032. BYTE *body = new BYTE[length];
  1033. for (long i = 0; i <= lUBoundVar-lLBoundVar; ++i) {
  1034. VARIANT var = pIndex[i];
  1035. if (V_VT(&var) != VT_UI1) {
  1036. hr = E_INVALIDARG;
  1037. break;
  1038. }
  1039. body[i] = V_UI1(&var);
  1040. }
  1041. body[length-1] = 0;
  1043. ::SafeArrayUnaccessData(pArray);
  1044. if (S_OK != hr) {
  1045. delete [] body;
  1046. return hr;
  1047. }
  1048. m_xml = reinterpret_cast<char*> (body);
  1049. delete [] body;
  1050. if (0 == m_xml.length())
  1051. return E_INVALIDARG;
  1052. }
  1053. }
  1054. else
  1055. if (V_VT(&xmlSource) == (VT_ARRAY | VT_UI1)) {
  1056. SAFEARRAY *pArray = reinterpret_cast<SAFEARRAY *> (xmlSource.byref);
  1057. if (NULL == pArray)
  1058. return E_INVALIDARG;
  1060. long lLBoundVar = 0;
  1061. long lUBoundVar = 0;
  1063. UINT dims = ::SafeArrayGetDim(pArray);
  1064. if (dims == 0)
  1065. return E_INVALIDARG;
  1067. hr = ::SafeArrayGetLBound(pArray, dims, &lLBoundVar);
  1068. if (S_OK != hr)
  1069. return hr;
  1071. hr = ::SafeArrayGetUBound(pArray, dims, &lUBoundVar);
  1072. if (S_OK != hr)
  1073. return hr;
  1075. if (lUBoundVar >= lLBoundVar) {
  1076. BYTE *pIndex = NULL;
  1077. hr = ::SafeArrayAccessData(pArray, reinterpret_cast<void **> (&pIndex));
  1078. if (S_OK != hr)
  1079. return hr;
  1081. int length = lUBoundVar-lLBoundVar+2;
  1082. BYTE *body = new BYTE[length];
  1083. for (long i = 0; i <= lUBoundVar-lLBoundVar; ++i)
  1084. body[i] = pIndex[i];
  1086. body[length-1] = 0;
  1087. ::SafeArrayUnaccessData(pArray);
  1088. m_xml = reinterpret_cast<char*> (body);
  1089. delete [] body;
  1090. if (0 == m_xml.length())
  1091. return E_INVALIDARG;
  1092. }
  1093. }
  1095. UINT nthreadID = 0;
  1096. m_hParseThread = reinterpret_cast<HANDLE> (_beginthreadex(NULL,
  1097.  0,
  1098.      CXMLDOMDocument::ParseThread,
  1099.  (void *) this,
  1100.  0,
  1101.  &nthreadID));
  1102. if (NULL == m_hParseThread)
  1103. return S_OK;
  1105. if (m_bAsync) {
  1106. *isSuccessful = VARIANT_TRUE;
  1107. return S_OK;
  1108. }
  1110. bool bWait = true;
  1111. while (bWait) {
  1112. DWORD dwEvt = MsgWaitForMultipleObjects(1,&m_hParseThread,FALSE,INFINITE,QS_ALLINPUT);
  1113. switch(dwEvt) {
  1114. case WAIT_OBJECT_0:
  1115. bWait = false;
  1116. break;
  1117. case WAIT_OBJECT_0 + 1:
  1118. {
  1119. MSG msg;
  1120. while(::PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
  1121. if (WM_CLOSE == msg.message || WM_QUIT == msg.message) {
  1122.  bWait = false;
  1123.  m_bAbort = true;
  1124.  break;
  1125. }
  1126. else {
  1127. PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
  1128. TranslateMessage(&msg);
  1129. DispatchMessage(&msg);
  1130. }
  1131. }
  1132. break;
  1133. }
  1134. default:
  1135. m_bAbort = true;
  1136. bWait = false;
  1137. break;
  1138. }
  1139. }
  1141. if (m_bAbort)
  1142. return S_OK;
  1144. if (m_bParseError)
  1145. return hr;
  1147. m_Document = m_TmpDocument;
  1148. m_TmpDocument = 0;
  1150. m_url = m_FileName;
  1151. *isSuccessful = VARIANT_TRUE;
  1153. return hr;
  1154. }
  1156. HRESULT CXMLDOMDocument::GetBaseURL(_bstr_t &baseURL)
  1157. {
  1158. baseURL = _T("");
  1159. CComPtr<IServiceProvider> pSP;
  1160. HRESULT hr = GetSite(IID_IServiceProvider, reinterpret_cast<LPVOID *> (&pSP));
  1161.     if (S_OK != hr)
  1162. return hr;
  1164. CComPtr<IWebBrowser2> pWB;
  1165.     hr = pSP->QueryService(SID_SWebBrowserApp,IID_IWebBrowser2,
  1166.                                  reinterpret_cast<LPVOID *> (&pWB));
  1167. if (S_OK != hr)
  1168. return hr;
  1170. BSTR b = NULL;
  1171. hr = pWB->get_LocationURL(&b);
  1172. if (S_OK != hr)
  1173. return hr;
  1175. TCHAR url[MAX_PATH] = _T("");
  1176. lstrcat(url,_bstr_t(b));
  1178. // look for last slash and remove the filename after it
  1179. LPTSTR loc = _tcsrchr(url, _T('/'));
  1180. if (loc != NULL) {
  1181. TCHAR str[MAX_PATH] = _T("");
  1182. _tcsncpy(str, url, loc - url);
  1183. lstrcpy(url,str);
  1184. }
  1186. baseURL = url;
  1187. return hr;
  1188. }
  1190. STDMETHODIMP CXMLDOMDocument::get_readyState(long  *pVal)
  1191. {
  1192. ATLTRACE(_T("CXMLDOMDocument::get_readyStaten"));
  1194. if (NULL == pVal)
  1195. return E_POINTER;
  1197. *pVal = m_lReadyState;
  1199. return S_OK;
  1200. }
  1202. STDMETHODIMP CXMLDOMDocument::get_parseError(IXMLDOMParseError  **pVal)
  1203. {
  1204. ATLTRACE(_T("CXMLDOMDocument::get_parseErrorn"));
  1206. if (NULL == pVal)
  1207. return E_POINTER;
  1209. return m_pParseError->QueryInterface(IID_IXMLDOMParseError, reinterpret_cast<LPVOID*> (pVal));
  1210. }
  1212. STDMETHODIMP CXMLDOMDocument::get_url(BSTR  *pVal)
  1213. {
  1214. ATLTRACE(_T("CXMLDOMDocument::get_urln"));
  1216. if (NULL == pVal)
  1217. return E_POINTER;
  1219. *pVal = m_url.copy();
  1220. return S_OK;
  1221. }
  1223. STDMETHODIMP CXMLDOMDocument::get_async(VARIANT_BOOL  *pVal)
  1224. {
  1225. ATLTRACE(_T("CXMLDOMDocument::get_asyncn"));
  1227. if (NULL == pVal)
  1228. return E_POINTER;
  1230. *pVal = m_bAsync ? VARIANT_TRUE : VARIANT_FALSE;
  1232. return S_OK;
  1233. }
  1235. STDMETHODIMP CXMLDOMDocument::put_async(VARIANT_BOOL newVal)
  1236. {
  1237. ATLTRACE(_T("CXMLDOMDocument::put_asyncn"));
  1239. m_bAsync = (VARIANT_TRUE == newVal) ? true : false;
  1241. return S_OK;
  1242. }
  1244. STDMETHODIMP CXMLDOMDocument::abort(void)
  1245. {
  1246. ATLTRACE(_T("CXMLDOMDocument::abortn"));
  1247. m_bAbort = true;
  1248. return S_OK;
  1249. }
  1251. STDMETHODIMP CXMLDOMDocument::loadXML(BSTR bstrXML, VARIANT_BOOL  *isSuccessful)
  1252. {
  1253. ATLTRACE(_T("CXMLDOMDocument::loadXMLn"));
  1255. if (NULL == isSuccessful)
  1256. return E_POINTER;
  1258. *isSuccessful = VARIANT_FALSE;
  1260. // do not start another thread if there is another active
  1261. if (NULL != m_hParseThread) {
  1262. DWORD exitCode = 0;
  1263. BOOL rc = ::GetExitCodeThread(m_hParseThread, &exitCode);
  1264. if (!rc || STILL_ACTIVE == exitCode)
  1265. return S_OK;
  1267. ::CloseHandle(m_hParseThread);
  1268. m_hParseThread = NULL;
  1269. }
  1271. HRESULT hr = S_OK;
  1272. m_bAbort = false;
  1274. m_FileName = _T("");
  1275. m_TmpDocument = 0;
  1276. m_bThreadValidate = m_bValidate;
  1278. m_xml = bstrXML;
  1279. if (0 == m_xml.length())
  1280. return E_INVALIDARG;
  1282. UINT nthreadID = 0;
  1283. m_hParseThread = reinterpret_cast<HANDLE> (_beginthreadex(NULL,
  1284.  0,
  1285.      CXMLDOMDocument::ParseThread,
  1286.  (void *) this,
  1287.  0,
  1288.  &nthreadID));
  1289. if (NULL == m_hParseThread)
  1290. return S_OK;
  1292. if (m_bAsync) {
  1293. *isSuccessful = VARIANT_TRUE;
  1294. return S_OK;
  1295. }
  1297. bool bWait = true;
  1298. while (bWait) {
  1299. DWORD dwEvt = MsgWaitForMultipleObjects(1,&m_hParseThread,FALSE,INFINITE,QS_ALLINPUT);
  1300. switch(dwEvt) {
  1301. case WAIT_OBJECT_0:
  1302. bWait = false;
  1303. break;
  1304. case WAIT_OBJECT_0 + 1:
  1305. {
  1306. MSG msg;
  1307. while(::PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
  1308. if (WM_CLOSE == msg.message || WM_QUIT == msg.message) {
  1309.  bWait = false;
  1310.  m_bAbort = true;
  1311.  break;
  1312. }
  1313. else {
  1314. PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
  1315. TranslateMessage(&msg);
  1316. DispatchMessage(&msg);
  1317. }
  1318. }
  1319. break;
  1320. }
  1321. default:
  1322. m_bAbort = true;
  1323. bWait = false;
  1324. break;
  1325. }
  1326. }
  1328. if (m_bAbort)
  1329. return S_OK;
  1331. if (m_bParseError)
  1332. return hr;
  1334. m_Document = m_TmpDocument;
  1335. m_TmpDocument = 0;
  1337. m_url = m_FileName;
  1338. *isSuccessful = VARIANT_TRUE;
  1340. return hr;
  1341. }
  1343. UINT APIENTRY CXMLDOMDocument::ParseThread(void *pParm)
  1344. {
  1345. ATLTRACE(_T("CXMLDOMDocument::ParseThreadn"));
  1347. CXMLDOMDocument *pThis = reinterpret_cast<CXMLDOMDocument *> (pParm);
  1348. if (NULL == pThis)
  1349. return 0;
  1351. if (!pThis->m_bAbort && pThis->m_FileName.length() > 0) {
  1352. CBindStatCallbackObj *pCallbackObj = NULL;
  1353. HRESULT hr = CBindStatCallbackObj::CreateInstance(&pCallbackObj);
  1354. if (S_OK != hr)
  1355. pCallbackObj = NULL;
  1357. if (pCallbackObj != NULL) {
  1358. pCallbackObj->AddRef();
  1359. pCallbackObj->m_pDoc = pThis;
  1360. }
  1361. TCHAR name[MAX_PATH] = _T("");
  1362. if (pThis->m_bAsync)
  1363. pThis->PostMessage(MSG_READY_STATE_CHANGE,1);
  1365. hr = URLDownloadToCacheFile(NULL,pThis->m_FileName,name,URLOSTRM_GETNEWESTVERSION,0,pCallbackObj);
  1366. if (pCallbackObj != NULL)
  1367. pCallbackObj->Release();
  1369. if (E_ABORT == hr)
  1370. pThis->m_bAbort = true;
  1371. else {
  1372. if (S_OK != hr) {
  1373. _bstr_t error = _T("Failed to download ") + pThis->m_FileName + _T(": ");
  1374. _com_error comError(hr);
  1375. error += comError.ErrorMessage();
  1376. pThis->m_pParseError->SetData(1,pThis->m_FileName,error,_T(""),0,0,0);
  1377. pThis->m_bParseError = true;
  1378. }
  1379. }
  1381. if (S_OK == hr) {
  1382. pThis->m_FileName = name;
  1383. if (pThis->m_bAsync)
  1384. pThis->PostMessage(MSG_READY_STATE_CHANGE,2);
  1385. }
  1386. }
  1388. DOMParser parser;
  1390. //
  1391. //   If set to true then an node supporting IXMLDOMProcessingInstruction
  1392. //     is added for the XML declaration.
  1393. //
  1394. //   Setting to true in a custom DLL will better mimic
  1395. //      MSXML.DLL but at a cost of conformance errors
  1396. //      using David Brownell's suite
  1397. parser.setToCreateXMLDeclTypeNode(false);
  1399. parser.setIncludeIgnorableWhitespace(pThis->m_bPreserveWhiteSpace);
  1403. if (!pThis->m_bParseError && !pThis->m_bAbort) {
  1404. parser.setDoValidation(pThis->m_bThreadValidate);
  1405. //
  1406. //   this brings the COM component into better mimicry to MSXML
  1407. //      by not throwing a validation error when there is no DOCTYPE
  1408. //
  1409. parser.setValidationScheme(pThis->m_bThreadValidate ? DOMParser::Val_Auto : DOMParser::Val_Never);
  1410. }
  1412. if (!pThis->m_bParseError && !pThis->m_bAbort)
  1413. parser.setErrorHandler(pThis);
  1415. if (!pThis->m_bParseError && !pThis->m_bAbort)
  1416. pThis->m_pParseError->Reset();
  1418. if (!pThis->m_bParseError && !pThis->m_bAbort)
  1419. pThis->m_bParseError = false;
  1421. try
  1422. {
  1423. if (!pThis->m_bParseError && !pThis->m_bAbort) {
  1424. if (pThis->m_FileName.length() > 0)
  1425. parser.parse(static_cast<LPCTSTR> (pThis->m_FileName));
  1426. else {
  1427. XMLByte *pXMLByte =  reinterpret_cast<XMLByte*> (static_cast<XMLCh*>(pThis->m_xml));
  1428. MemBufInputSource memBufIS(pXMLByte,pThis->m_xml.length()*sizeof(XMLCh),OLESTR("IBMXMLParser"),false);
  1429. memBufIS.setEncoding(OLESTR("UTF-16LE"));
  1430. if (!pThis->m_bParseError && !pThis->m_bAbort)
  1431. parser.parse(memBufIS);
  1432. }
  1433. }
  1435. }
  1436. catch(...)
  1437. {
  1438. pThis->m_bParseError = true;
  1439. return 0;
  1440. }
  1442. if (!pThis->m_bParseError && !pThis->m_bAbort)
  1443. pThis->m_TmpDocument = parser.getDocument();
  1445. if (!pThis->m_bParseError && !pThis->m_bAbort && pThis->m_bAsync)
  1446. pThis->PostMessage(MSG_READY_STATE_CHANGE,4);
  1447.   
  1448. return 0;
  1449. }
  1451. STDMETHODIMP CXMLDOMDocument::save(VARIANT location)
  1452. {
  1453. ATLTRACE(_T("CXMLDOMDocument::saven"));
  1455. if (V_VT(&location) != VT_BSTR)
  1456. return E_INVALIDARG;
  1458. _bstr_t file(V_BSTR(&location));
  1459. if (0 == file.length())
  1460. return E_INVALIDARG;
  1462. _bstr_t text;
  1464. try {
  1465. DOM_NodeList childs = m_Document.getChildNodes();
  1466. int length = childs.getLength();
  1467. for (int i=0; i < length; ++i) {
  1468. DOM_Node child = childs.item(i);
  1469. GetXML(child,text);
  1470. }
  1471. }
  1472. catch(DOM_DOMException& ex)
  1473. {
  1474. return MakeHRESULT(ex);
  1475. }
  1476. catch(...)
  1477. {
  1478. return E_FAIL;
  1479. }
  1481. FILE* fp;
  1482. if ((fp = _tfopen(file, "wt")) == NULL) {
  1483. return E_FAIL;
  1484. }
  1486. _ftprintf(fp, text);
  1488. fclose(fp);
  1490. return S_OK;
  1491. }
  1493. STDMETHODIMP CXMLDOMDocument::get_validateOnParse(VARIANT_BOOL  *pVal)
  1494. {
  1495. ATLTRACE(_T("CXMLDOMDocument::get_validateOnParsen"));
  1497. if (NULL == pVal)
  1498. return E_POINTER;
  1500. *pVal = (m_bValidate) ? VARIANT_TRUE : VARIANT_FALSE;
  1501. return S_OK;
  1502. }
  1504. STDMETHODIMP CXMLDOMDocument::put_validateOnParse(VARIANT_BOOL newVal)
  1505. {
  1506. ATLTRACE(_T("CXMLDOMDocument::put_validateOnParsen"));
  1507. m_bValidate = (VARIANT_TRUE == newVal) ? true : false;
  1508. return S_OK;
  1509. }
  1511. STDMETHODIMP CXMLDOMDocument::get_resolveExternals(VARIANT_BOOL  *pVal)
  1512. {
  1513. ATLTRACE(_T("CXMLDOMDocument::get_resolveExternalsn"));
  1515. if (NULL == pVal)
  1516. return E_POINTER;
  1518. return E_NOTIMPL;
  1519. }
  1521. STDMETHODIMP CXMLDOMDocument::put_resolveExternals(VARIANT_BOOL newVal)
  1522. {
  1523. ATLTRACE(_T("CXMLDOMDocument::put_resolveExternalsn"));
  1524. return E_NOTIMPL;
  1525. }
  1527. STDMETHODIMP CXMLDOMDocument::get_preserveWhiteSpace(VARIANT_BOOL  *pVal)
  1528. {
  1529. ATLTRACE(_T("CXMLDOMDocument::get_preserveWhiteSpacen"));
  1530. if (NULL == pVal)
  1531. return E_POINTER;
  1533. *pVal = (m_bPreserveWhiteSpace) ? VARIANT_TRUE : VARIANT_FALSE;
  1535. return S_OK;
  1536. }
  1538. STDMETHODIMP CXMLDOMDocument::put_preserveWhiteSpace(VARIANT_BOOL newVal)
  1539. {
  1540. ATLTRACE(_T("CXMLDOMDocument::put_preserveWhiteSpacen"));
  1541. m_bPreserveWhiteSpace = (VARIANT_TRUE == newVal) ? true : false;
  1542. return S_OK;
  1544. }
  1546. STDMETHODIMP CXMLDOMDocument::put_onreadystatechange(VARIANT newVal)
  1547. {
  1548. ATLTRACE(_T("CXMLDOMDocument::put_onreadystatechangen"));
  1550. if (VT_DISPATCH != V_VT(&newVal) &&
  1551. VT_NULL != V_VT(&newVal))
  1552. return E_INVALIDARG;
  1554. LPDISPATCH pDisp = NULL;
  1555. if (VT_DISPATCH == V_VT(&newVal))
  1556. pDisp = V_DISPATCH(&newVal);
  1558. if (m_pOnReadyStateChange != NULL) {
  1559. m_pOnReadyStateChange->Release();
  1560. m_pOnReadyStateChange = NULL;
  1561. }
  1562. m_pOnReadyStateChange = pDisp;
  1563. if (m_pOnReadyStateChange != NULL)
  1564. m_pOnReadyStateChange->AddRef();
  1566. return S_OK;
  1567. }
  1569. STDMETHODIMP CXMLDOMDocument::put_ondataavailable(VARIANT newVal)
  1570. {
  1571. ATLTRACE(_T("CXMLDOMDocument::put_ondataavailablen"));
  1573. if (VT_DISPATCH != V_VT(&newVal) &&
  1574. VT_NULL != V_VT(&newVal))
  1575. return E_INVALIDARG;
  1577. LPDISPATCH pDisp = NULL;
  1578. if (VT_DISPATCH == V_VT(&newVal))
  1579. pDisp = V_DISPATCH(&newVal);
  1581. if (m_pOnDataAvailable != NULL) {
  1582. m_pOnDataAvailable->Release();
  1583. m_pOnDataAvailable = NULL;
  1584. }
  1585. m_pOnDataAvailable = pDisp;
  1586. if (m_pOnDataAvailable != NULL)
  1587. m_pOnDataAvailable->AddRef();
  1589. return S_OK;
  1590. }
  1592. STDMETHODIMP CXMLDOMDocument::put_ontransformnode(VARIANT newVal)
  1593. {
  1594. ATLTRACE(_T("CXMLDOMDocument::put_ontransformnoden"));
  1596. if (VT_DISPATCH != V_VT(&newVal) &&
  1597. VT_NULL != V_VT(&newVal))
  1598. return E_INVALIDARG;
  1600. LPDISPATCH pDisp = NULL;
  1601. if (VT_DISPATCH == V_VT(&newVal))
  1602. pDisp = V_DISPATCH(&newVal);
  1604. if (m_pOnTransformNode != NULL) {
  1605. m_pOnTransformNode->Release();
  1606. m_pOnTransformNode = NULL;
  1607. }
  1608. m_pOnTransformNode = pDisp;
  1609. if (m_pOnTransformNode != NULL)
  1610. m_pOnTransformNode->AddRef();
  1612. return S_OK;
  1613. }