std::wstring CXmlNode::GetAttribute(LPCTSTR lpAttributeName)
{
IXMLDOMNamedNodeMap* lpNamedNodeMap;
IXMLDOMNode* lpXMLNode;
BSTR bstrValue;
std::wstring strValue;
HRESULT hr;
if (NULL == lpAttributeName || NULL == m_pXMLNode)
return _T("");
lpNamedNodeMap = NULL;
hr = m_pXMLNode->get_attributes(&lpNamedNodeMap);
if (hr == S_OK)
{
lpXMLNode = NULL;
hr = lpNamedNodeMap->getNamedItem((WCHAR *)lpAttributeName, &lpXMLNode);
if (hr == S_OK)
{
hr = lpXMLNode->get_text(&bstrValue);
if (hr == S_OK)
{
strValue = (WCHAR *)bstrValue;
::SysFreeString(bstrValue);
}
lpXMLNode->Release();
}
lpNamedNodeMap->Release();
}
return strValue;
}
bool CNtlXMLDoc::GetDataWithXPath(WCHAR* pwszXPath, WCHAR* pwszResultData, int nBufferSizeInWChars)
{
if (NULL == pwszXPath || NULL == pwszResultData || 0 >= nBufferSizeInWChars)
return false;
IXMLDOMNode* pNode = NULL;
m_pXMLDocument->selectSingleNode(pwszXPath, &pNode);
if(!pNode)
return false;
BSTR bstr = NULL;
if (FAILED(pNode->get_text(&bstr)))
{
::SysFreeString(bstr);
pNode->Release();
return false;
}
wcscpy_s(pwszResultData, nBufferSizeInWChars, bstr);
::SysFreeString(bstr);
pNode->Release();
return true;
}
// return "" if no value at path
std::string lvDCOMInterface::doXPATH(const std::string& xpath)
{
if (m_pxmldom == NULL)
{
throw std::runtime_error("m_pxmldom is NULL");
}
epicsGuard<epicsMutex> _lock(m_lock);
std::map<std::string,std::string>::const_iterator it = m_xpath_map.find(xpath);
if (it != m_xpath_map.end())
{
return it->second;
}
IXMLDOMNode *pNode = NULL;
std::string S_res;
BSTR bstrValue = NULL;
HRESULT hr = m_pxmldom->selectSingleNode(_bstr_t(xpath.c_str()), &pNode);
if (SUCCEEDED(hr) && pNode != NULL)
{
hr=pNode->get_text(&bstrValue);
if (SUCCEEDED(hr))
{
S_res = envExpand(CW2CT(bstrValue));
SysFreeString(bstrValue);
}
pNode->Release();
}
// else
// {
// throw std::runtime_error("doXPATH: cannot find " + xpath);
// }
m_xpath_map[xpath] = S_res;
return S_res;
}
// 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;
}
bool lvDCOMInterface::doXPATHbool(const std::string& xpath)
{
if (m_pxmldom == NULL)
{
throw std::runtime_error("m_pxmldom is NULL");
}
epicsGuard<epicsMutex> _lock(m_lock);
std::map<std::string,bool>::const_iterator it = m_xpath_bool_map.find(xpath);
if (it != m_xpath_bool_map.end())
{
return it->second;
}
IXMLDOMNode *pNode = NULL;
bool res = false;
BSTR bstrValue = NULL;
std::string bool_str;
HRESULT hr = m_pxmldom->selectSingleNode(_bstr_t(xpath.c_str()), &pNode);
if (SUCCEEDED(hr) && pNode != NULL)
{
hr=pNode->get_text(&bstrValue);
if (SUCCEEDED(hr))
{
bool_str = envExpand(CW2CT(bstrValue));
if (bool_str.size() == 0)
{
res = false;
}
// allow true / yes / non_zero_number
// note: atol() returns 0 for non numeric strings, so OK in a test for "true"
else if ( (bool_str[0] == 't') || (bool_str[0] == 'T') || (bool_str[0] == 'y') || (bool_str[0] == 'Y') || (atol(bool_str.c_str()) != 0) )
{
res = true;
}
else
{
res = false;
}
SysFreeString(bstrValue);
}
pNode->Release();
}
// else
// {
// throw std::runtime_error("doXPATHbool: cannot find " + xpath);
// }
m_xpath_bool_map[xpath] = res;
return res;
}
BSTR SettingsXML::GetAttr(IXMLDOMNode* apNode, IXMLDOMNamedNodeMap* apAttrs, const wchar_t* asName)
{
HRESULT hr = S_OK;
IXMLDOMNode *pValue = NULL;
BSTR bsText = NULL;
bsText = ::SysAllocString(asName);
hr = apAttrs->getNamedItem(bsText, &pValue);
::SysFreeString(bsText); bsText = NULL;
if (SUCCEEDED(hr) && pValue)
{
hr = pValue->get_text(&bsText);
pValue->Release(); pValue = NULL;
}
return bsText;
}
/*
Function name : CXML::GetNodeText
Description : This function will give node text.
: searching for the node starts either from the current node
: or it may start from the Root Node depending on the value of
: bool bCurrentNodeAsBase .
Return type : bool
Argument : CString csPathToNode
Argument : CString &rcsValue
Tested : Ok
*/
bool CXML::GetNodeText(CString csPathToNode,CString &rcsValue,bool bCurrentNodeAsBase )
{
IXMLDOMNode *pINodeData = NULL;
if(!GetNode(&pINodeData,csPathToNode,NULL,NULL,bCurrentNodeAsBase))
return false;
BSTR bstrNodeText;
m_hr = pINodeData->get_text(&bstrNodeText);
pINodeData->Release();
if (!SUCCEEDED(m_hr) || !bstrNodeText)
return false;
rcsValue = bstrNodeText;
SysFreeString(bstrNodeText);
return true;
}
HRESULT COFSNcDlg2::SelectChildNode(IXMLDOMNode *pNodeParent, BSTR bsSelect, IXMLDOMNode **ppNodeChild, BSTR *pbsNodeText)
{
HRESULT hr;
IXMLDOMNodeList *pNodeList = NULL;
IXMLDOMNode *pNodeChild = NULL;
if(pNodeParent == NULL || (ppNodeChild == NULL && pbsNodeText == NULL))
return E_INVALIDARG;
if(ppNodeChild != NULL)
*ppNodeChild = NULL;
DOMNodeType nt;
hr = pNodeParent->get_nodeType(&nt);
hr = pNodeParent->selectNodes(bsSelect, &pNodeList);
if(pNodeList)
{
hr = pNodeList->get_item(0, &pNodeChild);
if(pNodeChild != NULL)
{
if(pbsNodeText != NULL)
{
BSTR bs;
hr = pNodeChild->get_text(&bs);
*pbsNodeText = bs;
}
if(ppNodeChild == NULL)
{
pNodeChild->Release();
pNodeChild = NULL;
}
else
*ppNodeChild = pNodeChild;
}
pNodeList->Release();
pNodeList = NULL;
}
return hr;
}
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;
}
void Explorerplusplus::LoadDialogStatesFromXML(IXMLDOMDocument *pXMLDom)
{
IXMLDOMNodeList *pNodes = NULL;
IXMLDOMNode *pNode = NULL;
IXMLDOMNamedNodeMap *am = NULL;
IXMLDOMNode *pChildNode = NULL;
BSTR bstrName;
BSTR bstrValue;
BSTR bstr = NULL;
HRESULT hr;
long length;
long lChildNodes;
if(pXMLDom == NULL)
goto clean;
TCHAR tempNodeSelector[64];
StringCchPrintf(tempNodeSelector, SIZEOF_ARRAY(tempNodeSelector),
_T("//%s/*"), DIALOGS_XML_KEY);
bstr = SysAllocString(tempNodeSelector);
pXMLDom->selectNodes(bstr,&pNodes);
if(!pNodes)
{
goto clean;
}
else
{
pNodes->get_length(&length);
for(long i = 0;i < length;i++)
{
/* This should never fail, as the number
of nodes has already been counted (so
they must exist). */
hr = pNodes->get_item(i,&pNode);
if(SUCCEEDED(hr))
{
hr = pNode->get_attributes(&am);
if(SUCCEEDED(hr))
{
/* Retrieve the total number of attributes
attached to this node. */
am->get_length(&lChildNodes);
if(lChildNodes >= 1)
{
am->get_item(0,&pChildNode);
pChildNode->get_nodeName(&bstrName);
pChildNode->get_text(&bstrValue);
for(CDialogSettings *ds : DIALOG_SETTINGS)
{
TCHAR settingsKey[64];
bool success = ds->GetSettingsKey(settingsKey, SIZEOF_ARRAY(settingsKey));
assert(success);
if(!success)
{
continue;
}
if(lstrcmpi(bstrValue, settingsKey) == 0)
{
ds->LoadXMLSettings(am, lChildNodes);
}
}
}
}
}
pNode->Release();
pNode = NULL;
}
}
clean:
if (bstr) SysFreeString(bstr);
if (pNodes) pNodes->Release();
if (pNode) pNode->Release();
}
bool TextTable::InitializeFromXmlDoc(XMLDoc* pXmlDoc, WCHAR* pwszFileName, bool bReload)
{
if (NULL == pXmlDoc)
{
return false;
}
BSTR rowXPathFormat;
rowXPathFormat = ::SysAllocString(L"/dataroot/%s/F%d");
WCHAR wszXPath[MAX_UNICODE_XPATH_LENGTH + 1];
DWORD dwSheetIndex = 0;
WCHAR** ppwszSheetList = GetSheetListInWChar();
BSTR bstr = NULL;
while (ppwszSheetList[dwSheetIndex])
{
swprintf_s<_countof(wszXPath)>(wszXPath, rowXPathFormat, ppwszSheetList[dwSheetIndex], m_nField);
IXMLDOMNodeList* pIndexNodeList = NULL;
pIndexNodeList = pXmlDoc->SelectNodeList(wszXPath);
if (!pIndexNodeList)
{
::SysFreeString(rowXPathFormat);
return false;
}
LONG nIndexLength = 0;
if (FAILED(pIndexNodeList->get_length(&nIndexLength)))
{
pIndexNodeList->Release();
::SysFreeString(rowXPathFormat);
return false;
}
swprintf_s<_countof(wszXPath)>(wszXPath, rowXPathFormat, ppwszSheetList[dwSheetIndex], m_nField + 1);
IXMLDOMNodeList* pTextNodeList = NULL;
pTextNodeList = pXmlDoc->SelectNodeList(wszXPath);
if (!pTextNodeList)
{
pIndexNodeList->Release();
::SysFreeString(rowXPathFormat);
return false;
}
LONG nTextLength = 0;
if (FAILED(pTextNodeList->get_length(&nTextLength)))
{
pIndexNodeList->Release();
pTextNodeList->Release();
::SysFreeString(rowXPathFormat);
return false;
}
if (nTextLength != nIndexLength)
{
pIndexNodeList->Release();
pTextNodeList->Release();
::SysFreeString(rowXPathFormat);
return false;
}
// 제목은 버린다.
for (INT j = 1; j < nIndexLength; ++j)
{
VOID* pvTable = AllocNewTable(ppwszSheetList[dwSheetIndex], m_dwCodePage);
if (!pvTable)
{
pIndexNodeList->Release();
pTextNodeList->Release();
::SysFreeString(rowXPathFormat);
return false;
}
IXMLDOMNode* pCellNode = NULL;
IXMLDOMNode* pDataNode = NULL;
if (FAILED(pIndexNodeList->get_item(j, &pCellNode)))
{
pIndexNodeList->Release();
pTextNodeList->Release();
DeallocNewTable(pvTable, ppwszSheetList[dwSheetIndex]);
::SysFreeString(rowXPathFormat);
return false;
}
if (!pCellNode)
{
DeallocNewTable(pvTable, ppwszSheetList[dwSheetIndex]);
break;
}
if (FAILED(pCellNode->get_firstChild(&pDataNode)))
{
pCellNode->Release();
pIndexNodeList->Release();
pTextNodeList->Release();
DeallocNewTable(pvTable, ppwszSheetList[dwSheetIndex]);
::SysFreeString(rowXPathFormat);
return false;
}
if (!pDataNode)
{
pCellNode->Release();
DeallocNewTable(pvTable, ppwszSheetList[dwSheetIndex]);
break;
}
if (FAILED(pDataNode->get_text(&bstr)))
{
::SysFreeString(bstr);
pDataNode->Release();
pCellNode->Release();
pIndexNodeList->Release();
pTextNodeList->Release();
DeallocNewTable(pvTable, ppwszSheetList[dwSheetIndex]);
::SysFreeString(rowXPathFormat);
return false;
}
SetTableData(pvTable, ppwszSheetList[dwSheetIndex], INDEX, bstr);
::SysFreeString(bstr);
pCellNode->Release();
pDataNode->Release();
pCellNode = NULL;
pDataNode = NULL;
if (FAILED(pTextNodeList->get_item(j, &pCellNode)))
{
pIndexNodeList->Release();
pTextNodeList->Release();
DeallocNewTable(pvTable, ppwszSheetList[dwSheetIndex]);
::SysFreeString(rowXPathFormat);
return false;
}
if (!pCellNode)
{
DeallocNewTable(pvTable, ppwszSheetList[dwSheetIndex]);
break;
}
if (FAILED(pCellNode->get_firstChild(&pDataNode)))
{
//- yoshiki : TODO!(Get the field name)
Table::CallErrorCallbackFunction("[File] : %S\n[Error] : Table data is null.(Row Index : %d, Field Name = %S)", pwszFileName, j - 1, L"FIELD_NAME!");
pCellNode->Release();
pIndexNodeList->Release();
pTextNodeList->Release();
DeallocNewTable(pvTable, ppwszSheetList[dwSheetIndex]);
::SysFreeString(rowXPathFormat);
return false;
}
if (!pDataNode)
{
//- yoshiki : TODO!(Get the field name)
Table::CallErrorCallbackFunction("[File] : %S\n[Error] : Table data is null.(Row Index : %d, Field Name = %S)", pwszFileName, j - 1, L"FIELD_NAME!");
pCellNode->Release();
DeallocNewTable(pvTable, ppwszSheetList[dwSheetIndex]);
_ASSERT(0); // Index는 있고 Data는 공란인경우.
break;
}
if (FAILED(pDataNode->get_text(&bstr)))
{
::SysFreeString(bstr);
pDataNode->Release();
pCellNode->Release();
pIndexNodeList->Release();
pTextNodeList->Release();
DeallocNewTable(pvTable, ppwszSheetList[dwSheetIndex]);
::SysFreeString(rowXPathFormat);
return false;
}
SetTableData(pvTable, ppwszSheetList[dwSheetIndex], TEXT, bstr);
::SysFreeString(bstr);
pCellNode->Release();
pDataNode->Release();
if (!AddTable(pvTable, bReload))
{
DeallocNewTable(pvTable, ppwszSheetList[dwSheetIndex]);
}
}
pIndexNodeList->Release();
pTextNodeList->Release();
++dwSheetIndex;
}
::SysFreeString(rowXPathFormat);
return true;
}
LRESULT CAddVideoHtmlDlg::OnLoadCatalog(WPARAM wParam, LPARAM lParam)
{
if(wParam == NULL)
{
MessageBox(TEXT("获取视频分类数据失败，请检查您的网络情况。"), TEXT("错误"), MB_OK|MB_ICONERROR);
return 0;
}
try
{
TSTLSTRING strCatalogHtml;
int iSelectedIndex = -1;
IXMLDOMDocument* pDOM = NULL;
HRESULT hr = CoCreateInstance(CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, IID_IXMLDOMDocument, (void**)&pDOM);
if(hr != S_OK)
{
throw Exception(TEXT("解析视频分类数据失败。"));
}
VARIANT_BOOL loaded = VARIANT_FALSE;
hr = pDOM->loadXML(CComBSTR((LPCOLESTR)wParam), &loaded);
if(hr != S_OK || loaded == VARIANT_FALSE)
{
pDOM->Release();
throw Exception(TEXT("解析视频分类数据失败。"));
}
IXMLDOMNodeList* pNodeList = NULL;
hr = pDOM->get_childNodes(&pNodeList);
if(hr != S_OK)
{
pDOM->Release();
throw Exception(TEXT("解析视频分类数据失败。"));
}
IXMLDOMNode* pRoot = NULL;
hr = pNodeList->get_item(1, &pRoot);
if(hr != S_OK)
{
pNodeList->Release();
pDOM->Release();
throw Exception(TEXT("解析视频分类数据失败。"));
}
IXMLDOMNodeList* pRootChildren = NULL;
hr = pRoot->get_childNodes(&pRootChildren);
if(hr != S_OK)
{
pRoot->Release();
pNodeList->Release();
pDOM->Release();
throw Exception(TEXT("解析视频分类数据失败。"));
}
IXMLDOMNode* pResultNote = NULL;
hr = pRootChildren->get_item(0, &pResultNote);
if(hr != S_OK)
{
pRootChildren->Release();
pRoot->Release();
pNodeList->Release();
pDOM->Release();
throw Exception(TEXT("解析视频分类数据失败。"));
}
IXMLDOMNodeList* pResultChildren = NULL;
hr = pResultNote->get_childNodes(&pResultChildren);
if(hr != S_OK)
{
pResultNote->Release();
pRootChildren->Release();
pRoot->Release();
pNodeList->Release();
pDOM->Release();
throw Exception(TEXT("解析视频分类数据失败。"));
}
IXMLDOMNode* pResultStatusNote = NULL;
hr = pRootChildren->get_item(0, &pResultStatusNote);
if(hr != S_OK)
{
pResultChildren->Release();
pResultNote->Release();
pRootChildren->Release();
pRoot->Release();
pNodeList->Release();
pDOM->Release();
throw Exception(TEXT("解析视频分类数据失败。"));
}
CComBSTR bstrResultStatus;
hr = pResultStatusNote->get_text(&bstrResultStatus);
if(hr != S_OK)
{
pResultStatusNote->Release();
pResultChildren->Release();
pResultNote->Release();
pRootChildren->Release();
pRoot->Release();
pNodeList->Release();
pDOM->Release();
throw Exception(TEXT("解析视频分类数据失败。"));
}
pResultStatusNote->Release();
if(bstrResultStatus != TEXT("o"))
{
IXMLDOMNode* pResultMessageNote = NULL;
hr = pRootChildren->get_item(1, &pResultMessageNote);
if(hr != S_OK)
{
pResultChildren->Release();
pResultNote->Release();
pRootChildren->Release();
pRoot->Release();
pNodeList->Release();
pDOM->Release();
throw Exception(TEXT("解析视频分类数据失败。"));
}
CComBSTR bstrResultMessage;
hr = pResultMessageNote->get_text(&bstrResultMessage);
if(hr != S_OK)
{
pResultMessageNote->Release();
pResultChildren->Release();
pResultNote->Release();
pRootChildren->Release();
pRoot->Release();
pNodeList->Release();
pDOM->Release();
throw Exception(TEXT("解析视频分类数据失败。"));
}
pResultMessageNote->Release();
pResultChildren->Release();
pResultNote->Release();
pRootChildren->Release();
pRoot->Release();
pNodeList->Release();
pDOM->Release();
throw Exception(bstrResultMessage.m_str);
}
pResultChildren->Release();
pResultNote->Release();
IXMLDOMNode* pItemNote = NULL;
hr = pRootChildren->get_item(1, &pItemNote);
if(hr != S_OK)
{
pRootChildren->Release();
pRoot->Release();
pNodeList->Release();
pDOM->Release();
throw Exception(TEXT("解析视频分类数据失败。"));
}
IXMLDOMNodeList* pItemChildren = NULL;
hr = pItemNote->get_childNodes(&pItemChildren);
if(hr != S_OK)
{
pItemNote->Release();
pRootChildren->Release();
pRoot->Release();
pNodeList->Release();
pDOM->Release();
throw Exception(TEXT("解析视频分类数据失败。"));
}
long ItemCount = 0;
pItemChildren->get_length(&ItemCount);
if(hr != S_OK)
{
pItemChildren->Release();
pItemNote->Release();
pRootChildren->Release();
pRoot->Release();
pNodeList->Release();
pDOM->Release();
throw Exception(TEXT("解析视频分类数据失败。"));
}
for(int i=0; i<ItemCount; ++i)
{
IXMLDOMNode* pCatalogItemNote = NULL;
hr = pItemChildren->get_item(i, &pCatalogItemNote);
if(hr != S_OK)
{
pItemChildren->Release();
pItemNote->Release();
pRootChildren->Release();
pRoot->Release();
pNodeList->Release();
pDOM->Release();
throw Exception(TEXT("解析视频分类数据失败。"));
}
IXMLDOMNodeList* pCatalogItemChildren = NULL;
hr = pCatalogItemNote->get_childNodes(&pCatalogItemChildren);
if(hr != S_OK)
{
pCatalogItemNote->Release();
pItemChildren->Release();
pItemNote->Release();
pRootChildren->Release();
pRoot->Release();
pNodeList->Release();
pDOM->Release();
throw Exception(TEXT("解析视频分类数据失败。"));
}
IXMLDOMNode* pCatalogIdNote = NULL;
hr = pCatalogItemChildren->get_item(0, &pCatalogIdNote);
if(hr != S_OK)
{
pCatalogItemChildren->Release();
pCatalogItemNote->Release();
pItemChildren->Release();
pItemNote->Release();
pRootChildren->Release();
pRoot->Release();
pNodeList->Release();
pDOM->Release();
throw Exception(TEXT("解析视频分类数据失败。"));
}
CComBSTR bstrCatalogId;
hr = pCatalogIdNote->get_text(&bstrCatalogId);
if(hr != S_OK)
{
pCatalogIdNote->Release();
pCatalogItemChildren->Release();
pCatalogItemNote->Release();
pItemChildren->Release();
pItemNote->Release();
pRootChildren->Release();
pRoot->Release();
pNodeList->Release();
pDOM->Release();
throw Exception(TEXT("解析视频分类数据失败。"));
}
pCatalogIdNote->Release();
IXMLDOMNode* pCatalogNameNote = NULL;
hr = pCatalogItemChildren->get_item(1, &pCatalogNameNote);
if(hr != S_OK)
{
pCatalogItemChildren->Release();
pCatalogItemNote->Release();
pItemChildren->Release();
pItemNote->Release();
pRootChildren->Release();
pRoot->Release();
pNodeList->Release();
pDOM->Release();
throw Exception(TEXT("解析视频分类数据失败。"));
}
CComBSTR bstrCatalogName;
hr = pCatalogNameNote->get_text(&bstrCatalogName);
if(hr != S_OK)
{
pCatalogNameNote->Release();
pCatalogItemChildren->Release();
pCatalogItemNote->Release();
pItemChildren->Release();
pItemNote->Release();
pRootChildren->Release();
pRoot->Release();
pNodeList->Release();
pDOM->Release();
throw Exception(TEXT("解析视频分类数据失败。"));
}
pCatalogNameNote->Release();
pCatalogItemChildren->Release();
pCatalogItemNote->Release();
TSTLSTRING strCurrID = TSTLSTRING(COLE2T(bstrCatalogId));
TSTLSTRING strLastCatalog = ConfigureManager::GetInstance().GetLastCatalog();
TSTLSTRING strCurrName = TSTLSTRING(COLE2T(bstrCatalogName));
bool IsSelected = ((strLastCatalog.empty() && strCurrName == TEXT("其他")) ||
(!strLastCatalog.empty() && strLastCatalog.compare(strCurrID) == 0));
strCatalogHtml.append(TEXT("<div class=\"ComboxListItem\" onmouseover=\"this.className='ComboxListItemSelected';\" onclick=\"OnCatalogComboxClick();\" onmouseout=\"this.className='ComboxListItem';\" Value=\""));
strCatalogHtml.append(strCurrID);
strCatalogHtml.append(TEXT("\">"));
strCatalogHtml.append(strCurrName);
strCatalogHtml.append(TEXT("</div>"));
if(IsSelected)
iSelectedIndex = i;
}
pItemChildren->Release();
pItemNote->Release();
pRootChildren->Release();
pRoot->Release();
pNodeList->Release();
pDOM->Release();
DISPPARAMS dp;
memset(&dp, 0, sizeof(DISPPARAMS));
dp.cArgs = 2;
dp.cNamedArgs = 0;
VARIANTARG arg[2];
memset(arg, 0, sizeof(VARIANTARG) * 2);
dp.rgvarg = arg;
CComBSTR bstr(strCatalogHtml.c_str());
arg[0].vt = VT_BSTR;
bstr.CopyTo(&arg[0].bstrVal);
arg[1].vt = VT_INT;
arg[1].intVal = iSelectedIndex;
m_lpCatalogInvoke->Invoke(
0,
IID_NULL,
LOCALE_SYSTEM_DEFAULT,
DISPATCH_METHOD,
&dp,
NULL, NULL, NULL);
}
catch(Exception& error)
{
MessageBox(error.GetMessage().c_str(), TEXT("错误"), MB_OK|MB_ICONERROR);
}
return 0;
}
bool SettingsXML::SetAttr(IXMLDOMNode* apNode, IXMLDOMNamedNodeMap* apAttrs, const wchar_t* asName, const wchar_t* asValue)
{
bool lbRc = false;
HRESULT hr = S_OK;
IXMLDOMNode *pValue = NULL;
IXMLDOMAttribute *pIXMLDOMAttribute = NULL;
BSTR bsText = NULL;
BSTR bsCurValue = NULL;
bsText = ::SysAllocString(asName);
hr = apAttrs->getNamedItem(bsText, &pValue);
BSTR bsValue = ::SysAllocString(asValue);
wchar_t* pszEsc = wcschr(bsValue, (wchar_t)27);
if (pszEsc != NULL)
{
_ASSERTE(wcschr(bsValue, (wchar_t)27) == NULL); // У DOM сносит крышу, если писать "ESC" в значение
while ((pszEsc = wcschr(bsValue, (wchar_t)27)) != NULL)
{
*pszEsc = L'?';
}
}
if (FAILED(hr) || !pValue)
{
hr = mp_File->createAttribute(bsText, &pIXMLDOMAttribute);
_ASSERTE(hr == S_OK);
if (SUCCEEDED(hr) && pIXMLDOMAttribute)
{
VARIANT vtValue; vtValue.vt = VT_BSTR; vtValue.bstrVal = bsValue;
hr = pIXMLDOMAttribute->put_nodeValue(vtValue);
_ASSERTE(hr == S_OK);
hr = apAttrs->setNamedItem(pIXMLDOMAttribute, &pValue); //-V519
_ASSERTE(hr == S_OK);
lbRc = SUCCEEDED(hr);
SetDataChanged();
}
}
else if (SUCCEEDED(hr) && pValue)
{
// Для проверки mb_DataChanged
hr = pValue->get_text(&bsCurValue);
if (SUCCEEDED(hr) && bsCurValue && bsValue
&& (wcscmp(bsValue, bsCurValue) == 0))
{
// Not changed
lbRc = true;
}
else
{
// Change the value
hr = pValue->put_text(bsValue);
_ASSERTE(hr == S_OK);
lbRc = SUCCEEDED(hr);
SetDataChanged();
}
}
::SysFreeString(bsText); bsText = NULL;
::SysFreeString(bsValue); bsValue = NULL;
if (bsCurValue) { ::SysFreeString(bsCurValue); bsCurValue = NULL; }
if (pValue) { pValue->Release(); pValue = NULL; }
if (pIXMLDOMAttribute) { pIXMLDOMAttribute->Release(); pIXMLDOMAttribute = NULL; }
return lbRc;
}
IXMLDOMNode* SettingsXML::FindItem(IXMLDOMNode* apFrom, const wchar_t* asType, const wchar_t* asName, bool abAllowCreate)
{
HRESULT hr = S_OK;
IXMLDOMNodeList* pList = NULL;
IXMLDOMNode* pChild = NULL;
IXMLDOMNamedNodeMap* pAttrs = NULL;
IXMLDOMAttribute *pIXMLDOMAttribute = NULL;
IXMLDOMNode *pIXMLDOMNode = NULL;
IXMLDOMNode *pName = NULL;
BSTR bsText = NULL;
BSTR bsCheck = NULL;
DOMNodeType nodeTypeCheck = NODE_INVALID;
BOOL lbEmpty = TRUE;
int iLastIndent = 1;
// Получить все дочерние элементы нужного типа
if (apFrom == NULL)
{
hr = S_FALSE;
}
else
{
long lFound = 0;
// key[@name="abc"], but it is case-sensitive, and may fails in theory
bsText = lstrmerge(asType, L"[@name=\"", asName, L"\"]");
hr = apFrom->selectNodes(bsText, &pList);
if (SUCCEEDED(hr) && pList)
{
hr = pList->get_length(&lFound);
if (FAILED(hr) || (lFound < 1))
{
SafeRelease(pList);
}
}
SafeFree(bsText);
// May be case-insensitive search will be succeeded?
// However, it is very slow
if (!pList)
{
bsText = ::SysAllocString(asType);
hr = apFrom->selectNodes(bsText, &pList);
::SysFreeString(bsText); bsText = NULL;
}
}
if (SUCCEEDED(hr) && pList)
{
hr = pList->reset();
while ((hr = pList->nextNode(&pIXMLDOMNode)) == S_OK && pIXMLDOMNode)
{
lbEmpty = FALSE;
hr = pIXMLDOMNode->get_attributes(&pAttrs);
if (SUCCEEDED(hr) && pAttrs)
{
bsText = GetAttr(pIXMLDOMNode, pAttrs, L"name");
if (bsText)
{
if (lstrcmpi(bsText, asName) == 0)
{
::SysFreeString(bsText); bsText = NULL;
pChild = pIXMLDOMNode; pIXMLDOMNode = NULL;
break;
}
::SysFreeString(bsText); bsText = NULL;
}
}
pIXMLDOMNode->Release(); pIXMLDOMNode = NULL;
}
pList->Release();
//pList = NULL; -- для отладки
}
if (lbEmpty && abAllowCreate && (asType[0] == L'k'))
{
bsText = ::SysAllocString(L"value");
hr = apFrom->selectNodes(bsText, &pList);
::SysFreeString(bsText); bsText = NULL;
if (SUCCEEDED(hr) && pList)
{
hr = pList->reset();
if ((hr = pList->nextNode(&pIXMLDOMNode)) == S_OK && pIXMLDOMNode)
{
lbEmpty = FALSE;
pIXMLDOMNode->Release(); pIXMLDOMNode = NULL;
}
pList->Release();
//pList = NULL; -- для отладки
}
}
if (!pChild && abAllowCreate)
{
if (asType[0] == L'k')
{
hr = apFrom->get_lastChild(&pChild);
if (SUCCEEDED(hr) && pChild)
{
hr = pChild->get_nodeType(&nodeTypeCheck);
if (SUCCEEDED(hr) && (nodeTypeCheck == NODE_TEXT))
{
hr = pChild->get_text(&bsCheck);
if (SUCCEEDED(hr) && bsCheck)
{
iLastIndent = 0;
LPCWSTR pszTabs = bsCheck;
while (*pszTabs)
{
if (*(pszTabs++) == L'\t')
iLastIndent++;
}
::SysFreeString(bsCheck); bsCheck = NULL;
}
}
}
SafeRelease(pChild);
}
VARIANT vtType; vtType.vt = VT_I4;
vtType.lVal = NODE_ELEMENT;
bsText = ::SysAllocString(asType);
hr = mp_File->createNode(vtType, bsText, L"", &pChild);
::SysFreeString(bsText); bsText = NULL;
if (SUCCEEDED(hr) && pChild)
{
if (SetAttr(pChild, L"name", asName))
{
if (asType[0] == L'k')
{
AppendNewLine(pChild);
mb_KeyEmpty = true;
TouchKey(pChild);
}
if (asType[0] == L'k')
{
//if (mb_KeyEmpty)
//AppendIndent(apFrom, lbEmpty ? (mi_Level-1) : mi_Level);
AppendIndent(apFrom, (mi_Level-iLastIndent));
}
else if (mb_KeyEmpty)
{
AppendIndent(apFrom, !lbEmpty ? (mi_Level-1) : mi_Level);
}
else
{
AppendIndent(apFrom, 1);
}
hr = apFrom->appendChild(pChild, &pIXMLDOMNode);
pChild->Release(); pChild = NULL;
if (FAILED(hr))
{
pAttrs->Release(); pAttrs = NULL;
}
else
{
pChild = pIXMLDOMNode;
pIXMLDOMNode = NULL;
}
AppendNewLine(apFrom);
AppendIndent(apFrom, mi_Level-1);
if ((asType[0] != L'k') && mb_KeyEmpty)
mb_KeyEmpty = false;
}
else
{
pChild->Release(); pChild = NULL;
}
}
}
return pChild;
}
HRESULT
CIhvProfileBase::PutTextInNode
(
IN LPCWSTR pszQuery,
IN BSTR bstrText
)
{
HRESULT hr = S_OK;
BSTR bstrQuery = NULL;
BSTR bstrOrig = NULL;
BOOL bPut = TRUE;
IXMLDOMNode* pQueryNode = NULL;
if ( !m_pRootNode )
{
hr = E_UNEXPECTED;
BAIL_ON_FAILURE( hr );
}
if ( (!pszQuery) || (!bstrText) )
{
hr = E_INVALIDARG;
BAIL_ON_FAILURE( hr );
}
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( &bstrOrig );
BAIL_ON_FAILURE( hr );
if ( bstrOrig && ( 0 == wcscmp( bstrOrig, bstrText ) ) )
{
bPut = FALSE;
}
if ( bPut )
{
hr = pQueryNode->put_text( bstrText );
BAIL_ON_FAILURE( hr );
SetModified( );
}
error:
RELEASE_INTERFACE( pQueryNode );
SYS_FREE_STRING( bstrQuery );
SYS_FREE_STRING( bstrOrig );
return hr;
}
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;
}
//void SettingsXML::Save(const wchar_t *regName, const wchar_t *value)
//{
// if (!value) value = L""; // сюда мог придти и NULL
//
// Save(regName, (LPCBYTE)value, REG_SZ, (_tcslen(value)+1)*sizeof(wchar_t));
//}
void SettingsXML::Save(const wchar_t *regName, LPCBYTE value, DWORD nType, DWORD nSize)
{
HRESULT hr = S_OK;
IXMLDOMNamedNodeMap* pAttrs = NULL;
IXMLDOMNodeList* pList = NULL;
IXMLDOMAttribute *pIXMLDOMAttribute = NULL;
IXMLDOMNode *pNode = NULL;
IXMLDOMNode* pChild = NULL;
IXMLDOMNode *pNodeRmv = NULL;
BSTR bsValue = NULL;
BSTR bsType = NULL;
bool bNeedSetType = false;
// nType:
// REG_DWORD: сохранение числа в 16-ричном или 10-чном формате, в зависимости от того, что сейчас указано в xml ("dword"/"ulong"/"long")
// REG_BINARY: строго в hex (FF,FF,...)
// REG_SZ: ASCIIZ строка, можно проконтролировать, чтобы nSize/2 не был меньше длины строки
// REG_MULTI_SZ: ASCIIZZ. При формировании <list...> нужно убедиться, что мы не вылезли за пределы nSize
pChild = FindItem(mp_Key, L"value", regName, true); // создать, если его еще нету
if (!pChild)
goto wrap;
hr = pChild->get_attributes(&pAttrs);
if (FAILED(hr) || !pAttrs)
goto wrap;
bsType = GetAttr(pChild, pAttrs, L"type");
switch(nType)
{
case REG_DWORD:
{
wchar_t szValue[32];
if (bsType && (bsType[0] == L'u' || bsType[0] == L'U'))
{
_wsprintf(szValue, SKIPLEN(countof(szValue)) L"%u", *(LPDWORD)value);
}
else if (bsType && (bsType[0] == L'l' || bsType[0] == L'L'))
{
_wsprintf(szValue, SKIPLEN(countof(szValue)) L"%i", *(int*)value);
}
else
{
_wsprintf(szValue, SKIPLEN(countof(szValue)) L"%08x", *(LPDWORD)value);
if (bsType) ::SysFreeString(bsType);
// нужно добавить/установить тип
bsType = ::SysAllocString(L"dword"); bNeedSetType = true;
}
bsValue = ::SysAllocString(szValue);
} break;
case REG_BINARY:
{
if (nSize == 1 && bsType && (bsType[0] == L'u' || bsType[0] == L'U'))
{
wchar_t szValue[4];
BYTE bt = *value;
_wsprintf(szValue, SKIPLEN(countof(szValue)) L"%u", (DWORD)bt);
bsValue = ::SysAllocString(szValue);
}
else if (nSize == 1 && bsType && (bsType[0] == L'l' || bsType[0] == L'L'))
{
wchar_t szValue[4];
char bt = *value;
_wsprintf(szValue, SKIPLEN(countof(szValue)) L"%i", (int)bt);
bsValue = ::SysAllocString(szValue);
}
else
{
DWORD nLen = nSize*2 + (nSize-1); // по 2 символа на байт + ',' между ними
bsValue = ::SysAllocStringLen(NULL, nLen);
nLen ++; // Чтобы далее не добавлять WCHAR на '\0'
wchar_t* psz = (wchar_t*)bsValue;
LPCBYTE ptr = value;
while(nSize)
{
_wsprintf(psz, SKIPLEN(nLen-(psz-bsValue)) L"%02x", (DWORD)*ptr);
ptr++; nSize--; psz+=2;
if (nSize)
*(psz++) = L',';
}
if (bsType && lstrcmp(bsType, L"hex"))
{
// Допустим только "hex"
::SysFreeString(bsType); bsType = NULL;
}
if (!bsType)
{
// нужно добавить/установить тип
bsType = ::SysAllocString(L"hex"); bNeedSetType = true;
}
}
} break;
case REG_SZ:
{
wchar_t* psz = (wchar_t*)value;
bsValue = ::SysAllocString(psz);
if (bsType && lstrcmp(bsType, L"string"))
{
// Допустим только "string"
::SysFreeString(bsType); bsType = NULL;
}
if (!bsType)
{
// нужно добавить/установить тип
bsType = ::SysAllocString(L"string"); bNeedSetType = true;
}
} break;
case REG_MULTI_SZ:
{
if (bsType && lstrcmp(bsType, L"multi"))
{
// Допустим только "multi"
::SysFreeString(bsType); bsType = NULL;
}
if (!bsType)
{
// нужно добавить/установить тип
bsType = ::SysAllocString(L"multi"); bNeedSetType = true;
}
} break;
default:
goto wrap; // не поддерживается
}
if (bNeedSetType)
{
_ASSERTE(bsType!=NULL);
SetAttr(pChild, pAttrs, L"type", bsType);
::SysFreeString(bsType); bsType = NULL;
}
// Теперь собственно значение
if (nType != REG_MULTI_SZ)
{
_ASSERTE(bsValue != NULL);
SetAttr(pChild, pAttrs, L"data", bsValue);
::SysFreeString(bsValue); bsValue = NULL;
}
else // Тут нужно формировать список элементов <list>
{
VARIANT_BOOL bHasChild = VARIANT_FALSE;
DOMNodeType nodeType = NODE_INVALID;
// Если ранее был параметр "data" - удалить его из списка атрибутов
hr = pAttrs->getNamedItem(L"data", &pNode);
if (SUCCEEDED(hr) && pNode)
{
hr = pChild->removeChild(pNode, &pNodeRmv);
pNode->Release(); pNode = NULL;
if (pNodeRmv) { pNodeRmv->Release(); pNodeRmv = NULL; }
}
//TODO: может оставить перевод строки?
// Сначала почистим
#ifdef _DEBUG
hr = pChild->get_nodeType(&nodeType);
#endif
hr = pChild->hasChildNodes(&bHasChild);
if (bHasChild)
{
while((hr = pChild->get_firstChild(&pNode)) == S_OK && pNode)
{
hr = pNode->get_nodeType(&nodeType);
#ifdef _DEBUG
BSTR bsDebug = NULL;
pNode->get_text(&bsDebug);
if (bsDebug) ::SysFreeString(bsDebug); bsDebug = NULL;
#endif
hr = pChild->removeChild(pNode, &pNodeRmv);
if (pNodeRmv) { pNodeRmv->Release(); pNodeRmv = NULL; }
pNode->Release(); pNode = NULL;
}
}
// Теперь - добавляем список
wchar_t* psz = (wchar_t*)value;
BSTR bsNodeType = ::SysAllocString(L"line");
VARIANT vtType; vtType.vt = VT_I4; vtType.lVal = NODE_ELEMENT;
long nAllLen = nSize/2; // длина в wchar_t
long nLen = 0;
while(psz && *psz && nAllLen > 0)
{
hr = mp_File->createNode(vtType, bsNodeType, L"", &pNode);
if (FAILED(hr) || !pNode)
break;
if (!SetAttr(pNode, L"data", psz))
break;
hr = pChild->appendChild(pNode, &pNodeRmv);
pNode->Release(); pNode = NULL;
if (pNodeRmv) { pNodeRmv->Release(); pNodeRmv = NULL; }
if (FAILED(hr))
break;
nLen = _tcslen(psz)+1;
psz += nLen;
nAllLen -= nLen;
}
_ASSERTE(nAllLen <= 1);
}
mb_Modified = true;
wrap:
if (pIXMLDOMAttribute) { pIXMLDOMAttribute->Release(); pIXMLDOMAttribute = NULL; }
if (pNode) { pNode->Release(); pNode = NULL; }
if (pNodeRmv) { pNodeRmv->Release(); pNodeRmv = NULL; }
if (pChild) { pChild->Release(); pChild = NULL; }
if (pAttrs) { pAttrs->Release(); pAttrs = NULL; }
if (bsValue) { ::SysFreeString(bsValue); bsValue = NULL; }
if (bsType) { ::SysFreeString(bsType); bsType = NULL; }
}
