void Explorerplusplus::SaveDialogStatesToXML(IXMLDOMDocument *pXMLDom, IXMLDOMElement *pRoot) { IXMLDOMElement *pe = NULL; BSTR bstr = NULL; BSTR bstr_wsnt = SysAllocString(L"\n\t"); NXMLSettings::AddWhiteSpaceToNode(pXMLDom,bstr_wsnt,pRoot); bstr = SysAllocString(DIALOGS_XML_KEY); pXMLDom->createElement(bstr,&pe); SysFreeString(bstr); bstr = NULL; for(CDialogSettings *ds : DIALOG_SETTINGS) { ds->SaveXMLSettings(pXMLDom, pe); } NXMLSettings::AddWhiteSpaceToNode(pXMLDom,bstr_wsnt,pe); NXMLSettings::AppendChildToParent(pe,pRoot); pe->Release(); pe = NULL; }
// GetRoot COpcXmlElement COpcXmlDocument::GetRoot() const { COpcXmlElement cElement; // check if document exists. if (m_ipDocument == NULL) { return cElement; } IXMLDOMElement* ipRoot = NULL; HRESULT hResult = m_ipDocument->get_documentElement(&ipRoot); if (FAILED(hResult)) { return cElement; } cElement = ipRoot; if (ipRoot != NULL) { ipRoot->Release(); } return cElement; }
//helper function to append a sub node child to a documentfragment with given name and value: HRESULT AddSubNodeToDocumentFragment( IXMLDOMDocument* pDOM, const wchar_t* wszSubNodeName, const wchar_t* wszSubNodeValue, IXMLDOMDocumentFragment* pdf // Release is completed outside ) { BSTR bstr = NULL; IXMLDOMElement* peSub = NULL; HRESULT hr = S_OK; do { bstr = SysAllocString(wszSubNodeName); HR_SUCCESSCALL( pDOM->createElement(bstr, &peSub), hr ); SAFE_BSTR_RELEASE(bstr); bstr=SysAllocString(wszSubNodeValue); HR_SUCCESSCALL( peSub->put_text(bstr), hr ); HR_SUCCESSCALL( AppendChildToParent(peSub, pdf), hr ); }while(0); //release the com object SAFE_COM_RELEASE(peSub); //release the bstr SAFE_BSTR_RELEASE(bstr); return hr; }
/////////////////////////////////////////////////////// // RADEventsXML::ConstructEventNode // // Creates an XMLEvent node from a RADEvent object // // An example XML node as text: // <Event num="0057" // starttime="0000020010826175602000" endtime="0000020010826175827000" // maxtime="0000020010826175702000" // sum="10941.0" maxvalue="84" // starttimedisplay="2001.08.26 - 17:56:02" // endtimedisplay="2001.08.26 - 17:58:27" // maxtimedisplay="2001.08.26 - 17:57:02" // etype="Channel" // stationname="GRAND 2" /> // // Note: the text attribute values are created from the strings // on the RADEvent object. // // Input: // pEvent - the RADEvent instance // // Returns: // IXMLDOMElement: the constructed Event node, // or a NULL pointer if processing failed. // /////////////////////////////////////////////////////// IXMLDOMElement* RADEventsXML::ConstructEventNode(RADEvent* pEvent) { IXMLDOMElement *pEventElement = NULL; _variant_t var1; _bstr_t bstr1; HRESULT hr; IXMLDOMAttribute *pAttNode=NULL; IXMLDOMNode *pIXMLDOMNode=NULL; IXMLDOMNamedNodeMap* pAttMap = NULL; int j; // construct <Event> bstr1 = "Event"; HRCALL(m_pXMLDom->createElement(bstr1,&pEventElement),"create <Event> "); HRCALL(pEventElement->get_attributes(&pAttMap), "get_attributes: "); for (j = 0; j < eRADAttMax; j++) { var1 = pEvent->values[j]; HRCALL(m_pXMLDom->createAttribute(atts[j], &pAttNode), "create attribute"); HRCALL(pAttNode->put_nodeValue(var1), "node value"); HRCALL(pAttMap->setNamedItem(pAttNode, &pIXMLDOMNode), "set named item"); if (pIXMLDOMNode) pIXMLDOMNode->Release(); } clean: if (pAttMap) pAttMap->Release(); if (pAttNode) pAttNode->Release(); return pEventElement; }
// FindElement COpcXmlElement COpcXmlDocument::FindElement(const COpcString& cXPath) { COpcXmlElement cElement; // check if document exists. if (m_ipDocument == NULL) { return cElement; } // serach for single node. IXMLDOMElement* ipElement = NULL; BSTR bstrQuery = SysAllocString(cXPath); HRESULT hResult = m_ipDocument->selectSingleNode(bstrQuery, (IXMLDOMNode**)&ipElement); SysFreeString(bstrQuery); if (FAILED(hResult)) { return cElement; } // return result. cElement = ipElement; if (ipElement != NULL) { ipElement->Release(); } return cElement; }
CXmlElement* CXmlElement::AddElement(LPWSTR pwszName) { HRESULT hr = S_OK; CXmlElement *pElement = NULL; IXMLDOMElement *pIElement = NULL; BSTR bstrName = ::SysAllocString(pwszName); if (NULL != m_pIDoc) { hr = m_pIDoc->createElement(bstrName, &pIElement); if (SUCCEEDED(hr)) { IXMLDOMNode *pNewNode = NULL; hr = m_pIElement->appendChild(pIElement, &pNewNode); if (SUCCEEDED(hr)) { pElement = new CXmlElement(m_pIDoc, pIElement); pNewNode->Release(); pNewNode = NULL; } pIElement->Release(); pIElement = NULL; } } ::SysFreeString(bstrName); return pElement; }
STDMETHODIMP CTangramNode::put_Attribute(BSTR bstrKey, BSTR bstrVal) { IXMLDOMElement* ele = NULL; m_ObjItem.elem.QueryInterface<IXMLDOMElement>(&ele); if (ele != NULL) { ele->setAttribute(bstrKey,CComVariant(bstrVal)); ele->Release(); } return S_OK; }
STDMETHODIMP CTangramNode::get_OuterXml(BSTR* pVal) { IXMLDOMElement* pElement = NULL; m_TangramDocNode.elem.QueryInterface<IXMLDOMElement>(&pElement); if (pElement != NULL) { pElement->get_xml(pVal); pElement->Release(); } return S_OK; }
STDMETHODIMP CTangramNode::get_XML(BSTR* pVal) { IXMLDOMElement* ele = NULL; m_ObjItem.elem.QueryInterface<IXMLDOMElement>(&ele); if (ele != NULL) { ele->get_xml(pVal); ele->Release(); } return S_OK; }
HRESULT PlotWindowOpened::AppendXmlProperty(IXMLDOMDocument *pDom, IXMLDOMElement *pParent) { auto SThis = dynamic_pointer_cast<PlotWindowOpened, AsyncObject>(shared_from_this()); this->DoNow([SThis, pDom, pParent](){ IXMLDOMElement *pElement = NULL; CreateAndAddElementNode(pDom, L"WndName", L"\n\t\t", pParent, &pElement); pElement->put_text((_bstr_t)SThis->_name.c_str()); CreateAndAddElementNode(pDom, L"WndType", L"\n\t\t", pParent, &pElement); pElement->put_text(_bstr_t(typeid(*SThis).name())); CreateAndAddElementNode(pDom, L"WndNameIsSet", L"\n\t\t", pParent, &pElement); pElement->put_text((_bstr_t)SThis->_bNameIsSet); CreateAndAddElementNode(pDom, L"WndRectTLX", L"\n\t\t", pParent, &pElement); pElement->put_text((_bstr_t)SThis->_rect.TopLeft().x); CreateAndAddElementNode(pDom, L"WndRectTLY", L"\n\t\t", pParent, &pElement); pElement->put_text((_bstr_t)SThis->_rect.TopLeft().y); CreateAndAddElementNode(pDom, L"WndRectBRX", L"\n\t\t", pParent, &pElement); pElement->put_text((_bstr_t)SThis->_rect.BottomRight().x); CreateAndAddElementNode(pDom, L"WndRectBRY", L"\n\t\t", pParent, &pElement); pElement->put_text((_bstr_t)SThis->_rect.BottomRight().y); }); return S_OK; }
void CPageEvents::OnDeleteItemEventsList(NMHDR* pNMHDR, LRESULT* pResult) { // Typecast the specified notification structure NM_LISTVIEW* pLV = reinterpret_cast<NM_LISTVIEW*>(pNMHDR); // Typecast the item's param as an XML element pointer IXMLDOMElement* pElement = reinterpret_cast<IXMLDOMElement*>(pLV->lParam); // Release the XML element pointer associated with the item if (pElement) pElement->Release(); // Clear the result *pResult = 0; }
ParameterBlock &ParameterBlock::operator=(const ParameterBlock &other) { IXMLDOMElement *e = other.e_; if (e_ == e) { return *this; } if (e != NULL) { e->AddRef(); } if (e_ != NULL) { e_->Release(); } e_ = e; return *this; }
STDMETHODIMP CTangramNode::get_Attribute(BSTR bstrKey, BSTR* pVal) { IXMLDOMElement* ele = NULL; m_ObjItem.elem.QueryInterface<IXMLDOMElement>(&ele); if (ele != NULL) { VARIANT var; ele->getAttribute(bstrKey,&var); ele->Release(); if (var.vt == VT_BSTR) { *pVal = var.bstrVal; } } return S_OK; }
// The original Events list was created to exchange data from RAD with // other tools, such as INCC. A columnar text file was defined, where the // first row in the file representing the columns and titles. // The RADEventsXML class maintains an array of strings, indexed by the // type RADEventField, declaring the same column titles. These titles // are represented in the XML document processed by the class. // // Returns: // IXMLDOMElement: the constructed Columns node, // or a NULL pointer if processing failed. // /////////////////////////////////////////////////////// IXMLDOMElement* RADEventsXML::ConstructColumnsNode() { IXMLDOMElement *pColumns = NULL; IXMLDOMElement *pTitle = NULL; IXMLDOMNode *pIXMLDOMNode = NULL; _bstr_t bstr1; _bstr_t bstr2; HRESULT hr = 0; try { // create <Columns> bstr1 = "Columns"; hr = m_pXMLDom->createElement(bstr1,&pColumns); TESTHR(hr); AddWhiteSpaceToNode(bstr_wsnt, pColumns); // for each title element // create <Title>value</Title> bstr2 = "Title"; for (int i = 0; i < eRADAttMax; i++) { pTitle = NULL; // create <Title>value</Title> hr = m_pXMLDom->createElement(bstr2,&pTitle); TESTHR(hr); bstr1 = RADEventsList::Titles[i]; hr = pTitle->put_text(bstr1); TESTHR(hr); // append it as a child to <Columns> hr = pColumns->appendChild(pTitle, &pIXMLDOMNode); TESTHR(hr); AddWhiteSpaceToNode(bstr_wsnt, pColumns); } } catch(...) { dprintf( "%s:%d HRCALL Failed: %s\n 0x%.8x = %s\n", __FILE__, __LINE__, "ConstructColumnsNode Exception" , hr); } return pColumns; }
// base function to obtain text from // node described by XPATH. HRESULT CIhvProfileBase::GetTextFromNode ( IN LPCWSTR pszQuery, OUT BSTR* pbstrText ) { HRESULT hr = S_OK; BSTR bstrQuery = NULL; IXMLDOMNode* pQueryNode = NULL; ASSERT( pszQuery ); ASSERT( pbstrText ); // if node is NULL, return empty string. if ( !m_pRootNode ) { hr = Wstr2Bstr ( L"", pbstrText ); BAIL( ); } hr = Wstr2Bstr ( pszQuery, &bstrQuery ); BAIL_ON_FAILURE( hr ); hr = m_pRootNode->selectSingleNode( bstrQuery, &pQueryNode ); BAIL_ON_FAILURE( hr ); if (!pQueryNode) { hr = E_UNEXPECTED; BAIL_ON_FAILURE( hr ); } hr = pQueryNode->get_text( pbstrText ); BAIL_ON_FAILURE( hr ); if ( !(*pbstrText) ) { hr = E_UNEXPECTED; BAIL_ON_FAILURE( hr ); } error: RELEASE_INTERFACE( pQueryNode ); SYS_FREE_STRING( bstrQuery ); return hr; }
HRESULT COFSNcDlg2::GetNodeAttribute(IXMLDOMNode *pNode, BSTR bsAttrName, CComBSTR &strAttrValue) { HRESULT hr = S_OK; IXMLDOMElement *pEle = NULL; if(pNode == NULL) return E_INVALIDARG; hr = pNode->QueryInterface(IID_IXMLDOMElement, (void**)&pEle); if(pEle) { CComVariant var; hr = pEle->getAttribute(bsAttrName, &var); strAttrValue = var.bstrVal; pEle->Release(); } return hr; }
STDMETHODIMP CTangramNode::put_Caption(BSTR bstrCaption) { CString str(bstrCaption); m_strCaption = str; if (m_pParentObj != NULL && m_pParentObj->m_pHostWnd != NULL) { m_pParentObj->m_pHostWnd->SendMessage(WM_TGM_SET_CAPTION,m_nCol,(LPARAM)str.GetBuffer()); } IXMLDOMElement* ele = NULL; m_ObjItem.elem.QueryInterface<IXMLDOMElement>(&ele); if (ele != NULL) { ele->setAttribute(L"caption",CComVariant(str)); ele->Release(); } return S_OK; }
/////////////////////////////////////////////////////// // RADEventsXML::ConstructEventParentNodeTree // // Creates an XMLEvent node for the root of the XML document. // The root node is named "IR", // the Events container node is a child of "IR": // <?xml version="1.0" ?> // <IR> // <Events> // </Events> // <IR> // // // Returns: // IXMLDOMElement: the constructed IR/Eevents node, // or a NULL pointer if processing failed. // /////////////////////////////////////////////////////// IXMLDOMElement* RADEventsXML::ConstructEventParentNodeTree() { IXMLDOMNode *pIXMLDOMNode = NULL; IXMLDOMElement *pIR = NULL; IXMLDOMElement *pEvents = NULL; IXMLDOMProcessingInstruction *pi=NULL; _bstr_t bstr1; _bstr_t bstr2; HRESULT hr; // Create a processing instruction element. <?xml version="1.0" ?> bstr1 = "xml"; bstr2 = "version='1.0'"; HRCALL(m_pXMLDom->createProcessingInstruction( bstr1,bstr2, &pi), "createProcessingInstruction:"); m_pXMLDom->appendChild(pi, &pIXMLDOMNode); // put it first // construct <IR><Events></Events></IR> bstr1 = "Events"; HRCALL(m_pXMLDom->createElement(bstr1,&pEvents),"create <Events> "); bstr1 = "IR"; HRCALL(m_pXMLDom->createElement(bstr1,&pIR),"create <IR>"); HRCALL(pIR->appendChild(pEvents, &pIXMLDOMNode), ""); AddWhiteSpaceToNode(bstr_wsnt, pIR); m_pXMLDom->appendChild(pIR, &pIXMLDOMNode); // attach to DOM clean: if (pi) pi->Release(); if (pIR) pIR->Release(); return pEvents; }
HRESULT CPageEvents::UpdateNodeFromItem(LPARAM lNode) { // Typecast the tree item's param as an XML element pointer IXMLDOMElement* pElement = reinterpret_cast<IXMLDOMElement*>(lNode); if (!pElement) return S_FALSE; // Determine if the node is a group element or an event CComBSTR bstrTagName; VERIFY(SUCCEEDED(pElement->get_tagName(&bstrTagName))); bool bIsEvent = 0 == wcscmp(bstrTagName, m_bstrEvent); bool bIsGroup = !bIsEvent && 0 == wcscmp(bstrTagName, m_bstrEventGroup); ASSERT(bIsEvent || bIsGroup); if (bIsEvent) { // Set the LogAsNTEvent attribute if (GetDlgItem(IDC_LOG2NT)->IsWindowEnabled()) { CComVariant varLog2NT(!!IsDlgButtonChecked(IDC_LOG2NT)); pElement->setAttribute(m_bstrLogAsNTEvent, varLog2NT); } // Set the LogAsDBEvent attribute if (GetDlgItem(IDC_LOG2DB)->IsWindowEnabled()) { CComVariant varLog2DB(!!IsDlgButtonChecked(IDC_LOG2DB)); pElement->setAttribute(m_bstrLogAsDBEvent, varLog2DB); } } else { // TODO: Work-out how to best support indeterminate checkbox state } // Indicate success return S_OK; }
HRESULT CKADmerge::GetRootElement(IXMLDOMDocument * pXMLDoc, IXMLDOMNode ** pXMLNode) { IXMLDOMElement * pXMLElem = NULL; HRESULT hRes = 0; if(!pXMLDoc) { hRes = S_FALSE; } else { hRes = pXMLDoc->get_documentElement(&pXMLElem); if(pXMLElem) { hRes = pXMLElem->QueryInterface(IID_IXMLDOMNode, (void**)pXMLNode); } } if(pXMLElem) pXMLElem->Release(); return hRes; }
bool COpenGL::SetShadersGLSL(const TCHAR *glslFileName) { char *fragment=NULL, *vertex=NULL; IXMLDOMDocument * pXMLDoc = NULL; IXMLDOMElement * pXDE = NULL; IXMLDOMNode * pXDN = NULL; HRESULT hr; BSTR queryString, nodeContent; TCHAR errorMsg[MAX_PATH + 50]; if(fragmentShader) { glDetachShader(shaderProgram,fragmentShader); glDeleteShader(fragmentShader); fragmentShader = 0; } if(vertexShader) { glDetachShader(shaderProgram,vertexShader); glDeleteShader(vertexShader); vertexShader = 0; } if(shaderProgram) { glUseProgram(0); glDeleteProgram(shaderProgram); shaderProgram = 0; } if(glslFileName==NULL || *glslFileName==TEXT('\0')) return true; if(!LoadShaderFunctions()) { MessageBox(NULL, TEXT("Unable to load OpenGL shader functions"), TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION); return false; } hr = CoCreateInstance(CLSID_DOMDocument,NULL,CLSCTX_INPROC_SERVER,IID_PPV_ARGS(&pXMLDoc)); if(FAILED(hr)) { MessageBox(NULL, TEXT("Error creating XML Parser"), TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION); return false; } VARIANT fileName; VARIANT_BOOL ret; fileName.vt = VT_BSTR; #ifdef UNICODE fileName.bstrVal = SysAllocString(glslFileName); #else wchar_t tempfilename[MAX_PATH]; MultiByteToWideChar(CP_UTF8,0,glslFileName,-1,tempfilename,MAX_PATH); fileName.bstrVal = SysAllocString(tempfilename); #endif hr = pXMLDoc->load(fileName,&ret); SysFreeString(fileName.bstrVal); if(FAILED(hr) || hr==S_FALSE) { _stprintf(errorMsg,TEXT("Error loading GLSL shader file:\n%s"),glslFileName); MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION); pXMLDoc->Release(); return false; } VARIANT attributeValue; BSTR attributeName; hr = pXMLDoc->get_documentElement(&pXDE); if(FAILED(hr) || hr==S_FALSE) { _stprintf(errorMsg,TEXT("Error loading root element from file:\n%s"),glslFileName); MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION); pXMLDoc->Release(); return false; } attributeName=SysAllocString(L"language"); pXDE->getAttribute(attributeName,&attributeValue); SysFreeString(attributeName); pXDE->Release(); if(attributeValue.vt!=VT_BSTR || lstrcmpiW(attributeValue.bstrVal,L"glsl")) { _stprintf(errorMsg,TEXT("Shader language is <%s>, expected <GLSL> in file:\n%s"),attributeValue.bstrVal,glslFileName); MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION); if(attributeValue.vt==VT_BSTR) SysFreeString(attributeValue.bstrVal); pXMLDoc->Release(); return false; } if(attributeValue.vt==VT_BSTR) SysFreeString(attributeValue.bstrVal); queryString=SysAllocString(L"/shader/fragment"); hr = pXMLDoc->selectSingleNode(queryString,&pXDN); SysFreeString(queryString); if(hr == S_OK) { hr = pXDN->get_text(&nodeContent); if(hr == S_OK) { int requiredChars = WideCharToMultiByte(CP_ACP,0,nodeContent,-1,fragment,0,NULL,NULL); fragment = new char[requiredChars]; WideCharToMultiByte(CP_UTF8,0,nodeContent,-1,fragment,requiredChars,NULL,NULL); } SysFreeString(nodeContent); pXDN->Release(); pXDN = NULL; } queryString=SysAllocString(L"/shader/vertex"); hr = pXMLDoc->selectSingleNode(queryString,&pXDN); SysFreeString(queryString); if(hr == S_OK) { hr = pXDN->get_text(&nodeContent); if(hr == S_OK) { int requiredChars = WideCharToMultiByte(CP_ACP,0,nodeContent,-1,vertex,0,NULL,NULL); vertex = new char[requiredChars]; WideCharToMultiByte(CP_UTF8,0,nodeContent,-1,vertex,requiredChars,NULL,NULL); } SysFreeString(nodeContent); pXDN->Release(); pXDN = NULL; } pXMLDoc->Release(); if(!fragment && !vertex) { _stprintf(errorMsg,TEXT("No vertex or fragment program in file:\n%s"),glslFileName); MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION); return false; } shaderProgram = glCreateProgram (); if(vertex) { vertexShader = glCreateShader (GL_VERTEX_SHADER); glShaderSource(vertexShader, 1, (const GLchar **)&vertex, NULL); glCompileShader(vertexShader); glAttachShader(shaderProgram, vertexShader); delete[] vertex; } if(fragment) { fragmentShader = glCreateShader (GL_FRAGMENT_SHADER); glShaderSource(fragmentShader, 1, (const GLchar **)&fragment, NULL); glCompileShader(fragmentShader); glAttachShader(shaderProgram, fragmentShader); delete[] fragment; } glLinkProgram(shaderProgram); glUseProgram(shaderProgram); shader_type = OGL_SHADER_GLSL; return true; }
// New bool COpcXmlDocument::New(const COpcString& cRoot, const COpcString& cDefaultNamespace) { HRESULT hResult = S_OK; IXMLDOMElement* ipRoot = NULL; IXMLDOMNode* ipResult = NULL; BSTR bstrRoot = SysAllocString((LPCWSTR)cRoot); TRY { // create new document instance. if (!New()) { THROW_(hResult, E_FAIL); } // create root element. VARIANT vNodeType; vNodeType.vt = VT_I4; vNodeType.lVal = NODE_ELEMENT; BSTR bstrNamespace = SysAllocString(cDefaultNamespace); hResult = m_ipDocument->createNode(vNodeType, bstrRoot, bstrNamespace, (IXMLDOMNode**)&ipRoot); SysFreeString(bstrNamespace); if (FAILED(hResult)) { THROW(); } // add root element to document. hResult = m_ipDocument->appendChild(ipRoot, &ipResult); if (FAILED(hResult)) { THROW(); } if (ipResult != NULL) { ipResult->Release(); ipResult = NULL; } // declare element as the document element. hResult = m_ipDocument->putref_documentElement(ipRoot); if (FAILED(hResult)) { THROW(); } // add predefined namespaces AddNamespace(TAG_XSD, OPCXML_NS_SCHEMA); AddNamespace(TAG_XSI, OPCXML_NS_SCHEMA_INSTANCE); } CATCH { Clear(); } FINALLY { // release memory. if (ipRoot != NULL) ipRoot->Release(); if (ipResult != NULL) ipResult->Release(); SysFreeString(bstrRoot); } return SUCCEEDED(hResult); }
// New bool COpcXmlDocument::New(IXMLDOMElement* ipElement) { HRESULT hResult = S_OK; IXMLDOMElement* ipClone = NULL; IXMLDOMNode* ipParent = NULL; IXMLDOMNode* ipResult = NULL; TRY { // create new document instance. if (!New()) { THROW_(hResult, E_FAIL); } // clone the element. hResult = ipElement->cloneNode(VARIANT_TRUE, (IXMLDOMNode**)&ipClone); if (FAILED(hResult)) { THROW(); } // remove clone from parent. hResult = ipClone->get_parentNode(&ipParent); if (FAILED(hResult)) { THROW(); } if (ipParent != NULL) { hResult = ipParent->removeChild(ipClone, &ipResult); if (FAILED(hResult)) { THROW(); } if (ipResult != NULL) { ipResult->Release(); ipResult = NULL; } } // add root element to document. hResult = m_ipDocument->appendChild(ipClone, &ipResult); if (FAILED(hResult)) { THROW(); } if (ipResult != NULL) { ipResult->Release(); ipResult = NULL; } // declare element as the document element. hResult = m_ipDocument->putref_documentElement(ipClone); if (FAILED(hResult)) { THROW(); } // add predefined namespaces AddNamespace(TAG_XSD, OPCXML_NS_SCHEMA); AddNamespace(TAG_XSI, OPCXML_NS_SCHEMA_INSTANCE); } CATCH { Clear(); } FINALLY { // release memory. if (ipClone != NULL) ipClone->Release(); if (ipParent != NULL) ipParent->Release(); if (ipResult != NULL) ipResult->Release(); } return SUCCEEDED(hResult); }
bool CDirect3D::SetShaderHLSL(const TCHAR *file) { //MUDLORD: the guts //Compiles a shader from files on disc //Sets LUT textures to texture files in PNG format. TCHAR folder[MAX_PATH]; TCHAR rubyLUTfileName[MAX_PATH]; TCHAR *slash; char *shaderText = NULL; TCHAR errorMsg[MAX_PATH + 50]; IXMLDOMDocument * pXMLDoc = NULL; IXMLDOMElement * pXDE = NULL; IXMLDOMNode * pXDN = NULL; BSTR queryString, nodeContent; HRESULT hr; shaderTimer = 1.0f; shaderTimeStart = 0; shaderTimeElapsed = 0; if(effect) { effect->Release(); effect = NULL; } for(int i = 0; i < MAX_SHADER_TEXTURES; i++) { if (rubyLUT[i] != NULL) { rubyLUT[i]->Release(); rubyLUT[i] = NULL; } } if (file == NULL || *file==TEXT('\0')) return true; hr = CoCreateInstance(CLSID_DOMDocument,NULL,CLSCTX_INPROC_SERVER,IID_PPV_ARGS(&pXMLDoc)); if(FAILED(hr)) { MessageBox(NULL, TEXT("Error creating XML Parser"), TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION); return false; } VARIANT fileName; VARIANT_BOOL ret; fileName.vt = VT_BSTR; #ifdef UNICODE fileName.bstrVal = SysAllocString(file); #else wchar_t tempfilename[MAX_PATH]; MultiByteToWideChar(CP_UTF8,0,file,-1,tempfilename,MAX_PATH); fileName.bstrVal = SysAllocString(tempfilename); #endif hr = pXMLDoc->load(fileName,&ret); SysFreeString(fileName.bstrVal); if(FAILED(hr) || hr==S_FALSE) { _stprintf(errorMsg,TEXT("Error loading HLSL shader file:\n%s"),file); MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION); pXMLDoc->Release(); return false; } VARIANT attributeValue; BSTR attributeName; hr = pXMLDoc->get_documentElement(&pXDE); if(FAILED(hr) || hr==S_FALSE) { _stprintf(errorMsg,TEXT("Error loading root element from file:\n%s"),file); MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION); pXMLDoc->Release(); return false; } attributeName=SysAllocString(L"language"); pXDE->getAttribute(attributeName,&attributeValue); SysFreeString(attributeName); pXDE->Release(); if(attributeValue.vt!=VT_BSTR || lstrcmpiW(attributeValue.bstrVal,L"hlsl")) { _stprintf(errorMsg,TEXT("Shader language is <%s>, expected <HLSL> in file:\n%s"),attributeValue.bstrVal,file); MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION); if(attributeValue.vt==VT_BSTR) SysFreeString(attributeValue.bstrVal); pXMLDoc->Release(); return false; } if(attributeValue.vt==VT_BSTR) SysFreeString(attributeValue.bstrVal); queryString=SysAllocString(L"/shader/source"); hr = pXMLDoc->selectSingleNode(queryString,&pXDN); SysFreeString(queryString); if(hr == S_OK) { hr = pXDN->get_text(&nodeContent); if(hr == S_OK) { int requiredChars = WideCharToMultiByte(CP_ACP,0,nodeContent,-1,shaderText,0,NULL,NULL); shaderText = new char[requiredChars]; WideCharToMultiByte(CP_UTF8,0,nodeContent,-1,shaderText,requiredChars,NULL,NULL); } SysFreeString(nodeContent); pXDN->Release(); pXDN = NULL; } pXMLDoc->Release(); if(!shaderText) { _stprintf(errorMsg,TEXT("No HLSL shader program in file:\n%s"),file); MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION); return false; } LPD3DXBUFFER pBufferErrors = NULL; hr = D3DXCreateEffect( pDevice,shaderText,strlen(shaderText),NULL, NULL, D3DXSHADER_ENABLE_BACKWARDS_COMPATIBILITY, NULL, &effect, &pBufferErrors ); delete[] shaderText; if( FAILED(hr) ) { _stprintf(errorMsg,TEXT("Error parsing HLSL shader file:\n%s"),file); MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION); if(pBufferErrors) { LPVOID pCompilErrors = pBufferErrors->GetBufferPointer(); MessageBox(NULL, (const TCHAR*)pCompilErrors, TEXT("FX Compile Error"), MB_OK|MB_ICONEXCLAMATION); } return false; } lstrcpy(folder,file); slash = _tcsrchr(folder,TEXT('\\')); if(slash) *(slash+1)=TEXT('\0'); else *folder=TEXT('\0'); SetCurrentDirectory(S9xGetDirectoryT(DEFAULT_DIR)); for(int i = 0; i < MAX_SHADER_TEXTURES; i++) { _stprintf(rubyLUTfileName, TEXT("%srubyLUT%d.png"), folder, i); hr = D3DXCreateTextureFromFile(pDevice,rubyLUTfileName,&rubyLUT[i]); if FAILED(hr){ rubyLUT[i] = NULL; } } D3DXHANDLE hTech; effect->FindNextValidTechnique(NULL,&hTech); effect->SetTechnique( hTech ); shader_type = D3D_SHADER_HLSL; return true; }
HRESULT CKADmerge::Merge(string sAddOnFileName, BOOL bOverwrite, string sLogFile) { HRESULT hRes = 0; IXMLDOMDocument * pXMLAddOn = NULL; if(sLogFile != "") { // open log file OpenLog(sLogFile, sDescription + " " + m_sFileName + " with " + sAddOnFileName); } try { // load AddOn file hRes = LoadXMLFile(sAddOnFileName, &pXMLAddOn); IXMLDOMElement * pKadRoot = NULL; hRes = GetRootElement(m_pXMLKad, &pKadRoot); if(hRes == S_FALSE) { // create root element hRes = GetRootElement(pXMLAddOn, &pKadRoot); if(hRes == S_FALSE) { throw string("ERROR: could not get addon kad root element: " + sAddOnFileName); } _bstr_t bTagName(GetName(pKadRoot).c_str()); hRes = m_pXMLKad->createElement(bTagName, &pKadRoot); hRes = m_pXMLKad->putref_documentElement(pKadRoot); // log changes Log("Create Root-Element: " + GetName(pKadRoot) ); m_bIsDirty = TRUE; } if(pKadRoot) pKadRoot->Release(); IXMLDOMNode * pXMLKadNode = NULL; IXMLDOMNode * pXMLAddOnNode = NULL; hRes = GetRootElement(m_pXMLKad, &pXMLKadNode); hRes = GetRootElement(pXMLAddOn, &pXMLAddOnNode); // copy nodes hRes = CopyNode(&pXMLKadNode, &pXMLAddOnNode, bOverwrite, ""); if(pXMLKadNode != NULL) pXMLKadNode->Release(); if(pXMLAddOnNode != NULL) pXMLAddOnNode->Release(); if(m_bIsDirty) { hRes = SaveXMLFile(m_sFileName, m_pXMLKad); m_bIsDirty = FALSE; } } catch(string str) { Log(str); hRes = S_FALSE; } if(pXMLAddOn != NULL) pXMLAddOn->Release(); // close log file CloseLog(); return hRes; }
//add Id array to a document fragment node HRESULT AddIdsNode( IXMLDOMDocument* pDOM, BSTR indentBstr, const wchar_t* wszIdsNodeName, const wchar_t* wszIdsNodeAttribute, const wchar_t* wszIdNode, const std::vector<int>& ids, IXMLDOMDocumentFragment* pdf // Release is completed outside ) { VARIANT var; BSTR bstr = NULL; BSTR bstr_wst = SysAllocString(L"\t"); IXMLDOMElement* pe = NULL; IXMLDOMDocumentFragment* pdfSub = NULL; IXMLDOMAttribute *pa = NULL; IXMLDOMAttribute *pa1 = NULL; HRESULT hr = S_OK; do { //create a Node to hold ids. bstr = SysAllocString(wszIdsNodeName); HR_SUCCESSCALL( pDOM->createElement(bstr, &pe), hr ); SAFE_BSTR_RELEASE(bstr); //create a attribute for the <wszIdsNodeName> element, and //assign the element num as the attribute value. //get ids num string size_t idsNum = ids.size(); const int radix = 10; const size_t sizeOfstr = 30; wchar_t wszIdsNumString[sizeOfstr] = {0}; _ultow_s(static_cast<unsigned long>(idsNum), wszIdsNumString, sizeOfstr, radix); //put num string into attribute bstr = SysAllocString(wszIdsNodeAttribute); VariantInit(&var); V_BSTR(&var) = SysAllocString(wszIdsNumString); V_VT(&var) = VT_BSTR; HR_SUCCESSCALL( pDOM->createAttribute(bstr, &pa), hr ); HR_SUCCESSCALL( pa->put_value(var), hr ); HR_SUCCESSCALL( pe->setAttributeNode(pa, &pa1), hr ); //create a document fragment to hold ids sub-elements. HR_SUCCESSCALL( pDOM->createDocumentFragment(&pdfSub), hr ); //add ids to pdfSub for( size_t i=0; i < idsNum; ++i ) { int id = ids[i]; WCHAR wszIdString[sizeOfstr] = {0}; _itow_s(id, wszIdString, sizeOfstr, radix); //add white space before <id> HR_SUCCESSCALL( AddWhiteSpaceToNode(pDOM, indentBstr, pdfSub), hr ); HR_SUCCESSCALL( AddWhiteSpaceToNode(pDOM, bstr_wst, pdfSub), hr ); HR_SUCCESSCALL( AddSubNodeToDocumentFragment(pDOM, wszIdNode, wszIdString, pdfSub), hr ); } //test whether it is successful in "add ids to pdfSub" HR_SUCCESSCALL( hr, hr ); //add ids array to document fragment node HR_SUCCESSCALL( AppendChildToParent(pdfSub, pe), hr ); HR_SUCCESSCALL( AddWhiteSpaceToNode(pDOM, indentBstr, pe), hr ); HR_SUCCESSCALL( AppendChildToParent(pe, pdf), hr ); }while(0); //release the com objects SAFE_COM_RELEASE(pa1); SAFE_COM_RELEASE(pa); SAFE_COM_RELEASE(pdfSub); SAFE_COM_RELEASE(pe); //release the bstr and variant SAFE_BSTR_RELEASE(bstr); SAFE_BSTR_RELEASE(bstr_wst); VariantClear(&var); return hr; }
HRESULT CPageEvents::UpdateItemFromNode(LPARAM lNode) { USES_CONVERSION; // Typecast the tree item's param as an XML element pointer IXMLDOMElement* pElement = reinterpret_cast<IXMLDOMElement*>(lNode); if (!pElement) return S_FALSE; // Use to enable/disable the check boxes bool bEnableLog2NT = false; bool bEnableLog2DB = false; // Determine if the node is a group element or an event CComBSTR bstrTagName; VERIFY(SUCCEEDED(pElement->get_tagName(&bstrTagName))); bool bIsEvent = 0 == wcscmp(bstrTagName, m_bstrEvent); bool bIsGroup = !bIsEvent && 0 == wcscmp(bstrTagName, m_bstrEventGroup); ASSERT(bIsEvent || bIsGroup); if (bIsEvent) { // Get the Severity attribute CComVariant varSeverity; pElement->getAttribute(m_bstrSeverity, &varSeverity); VERIFY(SUCCEEDED(varSeverity.ChangeType(VT_BSTR))); SetDlgItemText(IDC_EVENT_TYPE, TypeFromSeverity(V_BSTR(&varSeverity))); // Get the event id attribute CComVariant varEventID; pElement->getAttribute(m_bstrID, &varEventID); VERIFY(SUCCEEDED(varEventID.ChangeType(VT_I4))); SetDlgItemInt(IDC_EVENT_ID, V_I4(&varEventID)); // Get the CanChangeLogAsNTEvent attribute IXMLDOMAttributePtr spAttrNT; if (S_OK == pElement->getAttributeNode(m_bstrCanChangeLogAsNTEvent, &spAttrNT)) { CComVariant varCanChange; spAttrNT->get_value(&varCanChange); VERIFY(SUCCEEDED(varCanChange.ChangeType(VT_BOOL))); bEnableLog2NT = !!V_BOOL(&varCanChange); } else { // When not specified, the default is true bEnableLog2NT = true; } // Get the LogAsNTEvent attribute CComVariant varLog2NT; pElement->getAttribute(m_bstrLogAsNTEvent, &varLog2NT); VERIFY(SUCCEEDED(varLog2NT.ChangeType(VT_BOOL))); CheckDlgButton(IDC_LOG2NT, V_BOOL(&varLog2NT)); // Get the CanChangeLogAsDBEvent attribute IXMLDOMAttributePtr spAttrDB; if (S_OK == pElement->getAttributeNode(m_bstrCanChangeLogAsDBEvent, &spAttrDB)) { CComVariant varCanChange; spAttrDB->get_value(&varCanChange); VERIFY(SUCCEEDED(varCanChange.ChangeType(VT_BOOL))); bEnableLog2DB = !!V_BOOL(&varCanChange); } else { // When not specified, the default is true bEnableLog2DB = true; } // Get the LogAsDBEvent attribute CComVariant varLog2DB; pElement->getAttribute(m_bstrLogAsDBEvent, &varLog2DB); VERIFY(SUCCEEDED(varLog2DB.ChangeType(VT_BOOL))); CheckDlgButton(IDC_LOG2DB, V_BOOL(&varLog2DB)); } else { // Always show the type as "Group" CString strGroup; strGroup.LoadString(IDS_TYPE_GROUP); SetDlgItemText(IDC_EVENT_TYPE, strGroup); // Get the group LowerBound attribute CComVariant varLowerBound; pElement->getAttribute(m_bstrLowerBound, &varLowerBound); VERIFY(SUCCEEDED(varLowerBound.ChangeType(VT_UI4))); // Get the group UpperBound attribute CComVariant varUpperBound; pElement->getAttribute(m_bstrUpperBound, &varUpperBound); VERIFY(SUCCEEDED(varUpperBound.ChangeType(VT_UI4))); // Format the group's range into a string TCHAR szID[_MAX_PATH]; wsprintf(szID, TEXT("%u - %u"), V_UI4(&varLowerBound), V_UI4(&varUpperBound)); SetDlgItemText(IDC_EVENT_ID, szID); // TODO: Work-out how to best support indeterminate checkbox state CheckDlgButton(IDC_LOG2NT, false); CheckDlgButton(IDC_LOG2DB, false); } // Get the event/group Description attribute CComVariant varDescription; pElement->getAttribute(m_bstrDescription, &varDescription); VERIFY(SUCCEEDED(varDescription.ChangeType(VT_BSTR))); SetDlgItemText(IDC_DESCRIPTION, OLE2CT(V_BSTR(&varDescription))); // Enable/disable checkboxes GetDlgItem(IDC_LOG2NT)->EnableWindow(bEnableLog2NT); GetDlgItem(IDC_LOG2DB)->EnableWindow(bEnableLog2DB); // Uncheck checkboxes that are disabled if (!bEnableLog2NT) CheckDlgButton(IDC_LOG2NT, false); if (!bEnableLog2DB) CheckDlgButton(IDC_LOG2DB, false); // Indicate success return S_OK; }
/////////////////////////////////////////////////////////////// // 功能: XML 文档文本转换成扫描参数结构 // 参数: sXMLDocText [in] XML文档的文本 // sp [out] 扫描参数结构 // 返回: true - 成功, false - 失败 bool ScanParamXML::XMLToScanParam( const string &sXMLDocText, ScanParameter &sp ) { try { IXMLDOMDocument *pXmlDoc = NULL; IXMLDOMNode *pXmlDomNode = NULL; // 得到关于IXMLDOMDocument 接口的指针 pXMLDOC HRESULT hr = ::CoCreateInstance( CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, IID_IXMLDOMDocument, ( void ** )&pXmlDoc ); if( S_OK != hr ) { return false; } //得到关于IXMLDOMNode接口的指针pXDN hr = pXmlDoc->QueryInterface( IID_IXMLDOMNode, ( void ** )&pXmlDomNode ); if( S_OK != hr ) { return false; } VARIANT_BOOL bOk; _variant_t varSrc = sXMLDocText.c_str(); IXMLDOMElement *pRootNode; // 根结点 IXMLDOMNode *pNode; IXMLDOMNode *pNodeOut; pXmlDoc->loadXML( varSrc.bstrVal, &bOk ); // 从字符串建立XML文档 // 取得根结点 pXmlDoc->get_documentElement( &pRootNode ); pRootNode->get_nodeName( &varSrc.bstrVal ); // 遍历根结点的子结点 for( pRootNode->get_firstChild( &pNode ); pNode != NULL; pNode->get_nextSibling( &pNode ) ) { pNode->get_nodeName( &varSrc.bstrVal ); // cout << "Node name: " << varSrc.operator _bstr_t().operator char *() << endl; string sNodeName = _bstr_t( varSrc.bstrVal ).operator char *(); if( sNodeName == string( "Depth" ) ) { // 发现 Depth 结点 varSrc = ReadNodeText( pNode ); sp.nDepth = atoi( _bstr_t( varSrc.bstrVal ).operator char *() ); //cout << "Depth value: " << sp.nDepth << endl; } else if( sNodeName == string( "TryTimes" ) ) { // 发现 TryTimes 结点 varSrc = ReadNodeText( pNode ); sp.nTryTimes = atoi( _bstr_t( varSrc.bstrVal ).operator char *() ); //cout << "TryTimes value: " << sp.nTryTimes << endl; } else if( sNodeName == string( "Timeout" ) ) { // 发现 Timeout 结点 varSrc = ReadNodeText( pNode ); sp.nTimeout = atoi( _bstr_t( varSrc.bstrVal ).operator char *() ); //cout << "Timeout value: " << sp.nTimeout << endl; } else if( sNodeName == string( "MaxTreadCount" ) ) { // 发现 MaxTreadCount 结点 varSrc = ReadNodeText( pNode ); sp.nMaxTreadCount = atoi( _bstr_t( varSrc.bstrVal ).operator char *() ); //cout << "MaxTreadCount value: " << sp.nMaxTreadCount << endl; } else if( sNodeName == string( "SubScan" ) ) { // 发现 SubScan 结点 varSrc = ReadNodeText( pNode ); sp.bSubScan = ( string( _bstr_t( varSrc.bstrVal ).operator char *() ) == XML_TRUE ) ; //cout << "SubScan value: " << sp.bSubScan << endl; } else if( sNodeName == string( "DefaultCommunityGet" ) ) { // 发现 DefaultCommunityGet 结点 varSrc = ReadNodeText( pNode ); sp.sDefaultCommunityOfGet = _bstr_t( varSrc.bstrVal ).operator char *(); //cout << "DefaultCommunityGet value: " << sp.sDefaultCommunityOfGet << endl; } else if( sNodeName == string( "DefaultCommunitySet" ) ) { // 发现 DefaultCommunitySet 结点 varSrc = ReadNodeText( pNode ); sp.sDefaultCommunityOfSet = _bstr_t( varSrc.bstrVal ).operator char *(); //cout << "DefaultCommunityOfSet value: " << sp.sDefaultCommunityOfSet << endl; } else if( sNodeName == string( "Communitys" ) ) { // 发现 Communitys 结点 ReadCommunityListNode( pNode, sp.vcCommunityList ); } else if( sNodeName == string( "AddStartEnds" ) ) { // 发现 AddStartEnds 结点 ReadIpScopeListNode( pNode, sp.viIpScopeList ); // 读IpScopeList结点 } else if( sNodeName == string( "FilterStartEnds" ) ) { // 发现 FilterStartEnds 结点 ReadIpScopeListNode( pNode, sp.viFilterStartEndList ); // 读IpScopeList结点 } else if( sNodeName == string( "SubnetList" ) ) { // 发现 SubnetList 结点 ReadIpScopeListNode( pNode, sp.viSubnetList ); // 读IpScopeList结点 } else if( sNodeName == string( "SeedIpList" ) ) { // 发现 SeedIp 结点 ReadStringListNode( pNode, sp.vsSeedIpList ); } } // cout << "XMLToScanParam done successfully!" << endl; } catch(...) { return false; } return true; }
HRESULT CPageEvents::AddXMLNodeToTree(IXMLDOMNode* pNode, HTREEITEM hParent) { // Get the list of child nodes IXMLDOMNodeListPtr spChildren; RETURN_FAILED(pNode->get_childNodes(&spChildren)); // Process each child node IXMLDOMNodePtr spChild; do { // Get the next node of the child list RETURN_FAILED(spChildren->nextNode(&spChild)); if (NULL != spChild) { // Get the child node's tagname int iImage; CString strType; CString strID; bool bIsGroup, bIsEvent; CComBSTR bstrText; IXMLDOMElementPtr spElement(spChild); if (NULL != spElement) { CComBSTR bstrTagName; RETURN_FAILED(spElement->get_tagName(&bstrTagName)); if (bstrTagName.Length()) { // Accept the Event and EventGroup tag names if (0 == wcscmp(bstrTagName, m_bstrEvent)) { bIsGroup = false; bIsEvent = true; } else if (0 == wcscmp(bstrTagName, m_bstrEventGroup)) { bIsGroup = true; bIsEvent = false; } // Get the display attributes if this is a group or event node if (bIsGroup || bIsEvent) { // Get the type of the element CComBSTR bstrSeverity; GetElementSeverity(spElement, &bstrSeverity); iImage = ImageFromSeverity(bstrSeverity); strType = TypeFromSeverity(bstrSeverity); // Get the id of the element CComBSTR bstrID; GetElementID(spElement, &bstrID); strID = bstrID; // Get the name of the element RETURN_FAILED(GetElementDisplayName(spElement, &bstrText)); } } } // Add the node to the tree and list controls if (bstrText.Length()) { // Typecast the element pointer as an LPARAM IXMLDOMElement* pElement = spElement.Detach(); LPARAM lParam = reinterpret_cast<LPARAM>(pElement); // Insert the element into the tree USES_CONVERSION; LPCTSTR pszText = OLE2CT(bstrText); UINT mask = TVIF_PARAM | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE; HTREEITEM hItem = m_tree.InsertItem(mask, pszText, iImage, iImage, 0, 0, lParam, hParent, TVI_LAST); // Insert the element into the list, if its not an <EventGroup> if (!bIsGroup) { int iItem = m_listEvents.GetItemCount(); iItem = m_listEvents.InsertItem(LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM, iItem, strType, 0, 0, iImage, lParam); if (-1 != iItem) { // Keep a reference on the element pointer in the LPARAM pElement->AddRef(); // Keep track of maximum widths int cx = m_listEvents.GetStringWidth(strType + " "); m_cxMaxType = max(m_cxMaxType, cx); cx = m_listEvents.GetStringWidth(strID + " "); m_cxMaxID = max(m_cxMaxID, cx); // Set the subitems m_listEvents.SetItem(iItem, 1, LVIF_TEXT, strID, 0, 0, 0, 0); m_listEvents.SetItem(iItem, 2, LVIF_TEXT, pszText, 0, 0, 0, 0); } } // Recurse into node, if it's a group if (bIsGroup) { RETURN_FAILED(AddXMLNodeToTree(spChild, hItem)); } } } } while (NULL != spChild); // Indicate success return S_OK; }
IXMLDOMNode * DicomImageSet::findParentNode(IXMLDOMDocument *pXMLDom, IXMLDOMNode * pRoot, const char * patientsName, const char * patientsId, int acquisitionDate, const char * protocol, int acquisitionNumber) { if (!pXMLDom) { return NULL; } HRESULT hr = S_OK; IXMLDOMElement *pPatient = NULL, *pDate = NULL, *pProtocol = NULL, *pCollection = NULL; BSTR bstrQuery = NULL; QString strQuery; bool nodeExist = false; //look for the patient node strQuery = QString("root/Patient[@patients_name = '%1' and @patient_id = '%2']").arg(patientsName).arg(patientsId); bstrQuery = SysAllocString(strQuery.toStdWString().c_str()); CHK_ALLOC(bstrQuery); CHK_HR(pXMLDom->selectSingleNode(bstrQuery, (IXMLDOMNode**)&pPatient)); SysFreeString(bstrQuery); nodeExist = pPatient; if (!nodeExist) { //create the patient node CHK_HR(CreateElement(pXMLDom, L"Patient", &pPatient)); CHK_HR(CreateAndAddAttributeNode(pXMLDom, L"patients_name", QString(patientsName).toStdWString().c_str(), pPatient)); CHK_HR(CreateAndAddAttributeNode(pXMLDom, L"patient_id", QString(patientsId).toStdWString().c_str(), pPatient)); CHK_HR(CreateAndAddTextNode(pXMLDom, L"\n", pRoot)); CHK_HR(AppendChildToParent(pPatient, pRoot)); } if (nodeExist) { //look for the date node strQuery = QString("Date[@acquisition_date = '%1']").arg(acquisitionDate); bstrQuery = SysAllocString(strQuery.toStdWString().c_str()); CHK_ALLOC(bstrQuery); CHK_HR(pPatient->selectSingleNode(bstrQuery, (IXMLDOMNode**)&pDate)); SysFreeString(bstrQuery); nodeExist = pDate; } if (!nodeExist) { CHK_HR(CreateElement(pXMLDom, L"Date", &pDate)); CHK_HR(CreateAndAddAttributeNode(pXMLDom, L"acquisition_date", QString::number(acquisitionDate).toStdWString().c_str(), pDate)); CHK_HR(CreateAndAddTextNode(pXMLDom, L"\n", pPatient)); CHK_HR(AppendChildToParent(pDate, pPatient)); } if (nodeExist) { //look for the protocol node strQuery = QString("Protocol[@protocol_name = '%1']").arg(protocol); bstrQuery = SysAllocString(strQuery.toStdWString().c_str()); CHK_ALLOC(bstrQuery); CHK_HR(pDate->selectSingleNode(bstrQuery, (IXMLDOMNode**)&pProtocol)); SysFreeString(bstrQuery); nodeExist = pProtocol; } if (!nodeExist) { CHK_HR(CreateElement(pXMLDom, L"Protocol", &pProtocol)); CHK_HR(CreateAndAddAttributeNode(pXMLDom, L"protocol_name", QString(protocol).toStdWString().c_str(), pProtocol)); CHK_HR(CreateAndAddTextNode(pXMLDom, L"\n", pDate)); CHK_HR(AppendChildToParent(pProtocol, pDate)); } if (nodeExist) { //look for the collection node strQuery = QString("Collection[@acquisition_number = '%1']").arg(acquisitionNumber); bstrQuery = SysAllocString(strQuery.toStdWString().c_str()); CHK_ALLOC(bstrQuery); CHK_HR(pProtocol->selectSingleNode(bstrQuery, (IXMLDOMNode**)&pCollection)); SysFreeString(bstrQuery); nodeExist = pCollection; } if (!nodeExist) { CHK_HR(CreateElement(pXMLDom, L"Collection", &pCollection)); CHK_HR(CreateAndAddAttributeNode(pXMLDom, L"acquisition_number", QString::number(acquisitionNumber).toStdWString().c_str(), pCollection)); CHK_HR(CreateAndAddTextNode(pXMLDom, L"\n", pProtocol)); CHK_HR(AppendChildToParent(pCollection, pProtocol)); } CleanUp: SAFE_RELEASE(pPatient); SAFE_RELEASE(pDate); SAFE_RELEASE(pProtocol); if(SUCCEEDED(hr)) { return pCollection; } SAFE_RELEASE(pCollection); return NULL; }