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;
}
