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;
}
// 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::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::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_XML(BSTR* pVal)
{
IXMLDOMElement* ele = NULL;
m_ObjItem.elem.QueryInterface<IXMLDOMElement>(&ele);
if (ele != NULL)
{
ele->get_xml(pVal);
ele->Release();
}
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;
}
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;
}
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 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;
}
