//-------------------------------------------------------------------------------------- HRESULT CRatingsDB::GetAttribFromNode( IXMLDOMNode* pNode, WCHAR* strAttrib, WCHAR* strDest, int cchDest ) { IXMLDOMNamedNodeMap *pIXMLDOMNamedNodeMap = nullptr; BSTR bstrAttributeName = ::SysAllocString( strAttrib ); IXMLDOMNode* pIXMLDOMNode = nullptr; bool bFound = false; HRESULT hr; VARIANT v; hr = pNode->get_attributes( &pIXMLDOMNamedNodeMap ); if(SUCCEEDED(hr) && pIXMLDOMNamedNodeMap) { hr = pIXMLDOMNamedNodeMap->getNamedItem( bstrAttributeName, &pIXMLDOMNode ); if(SUCCEEDED(hr) && pIXMLDOMNode) { pIXMLDOMNode->get_nodeValue(&v); if( SUCCEEDED(hr) && v.vt == VT_BSTR ) { wcscpy_s( strDest, cchDest, v.bstrVal ); bFound = true; } VariantClear(&v); SAFE_RELEASE( pIXMLDOMNode ); } SAFE_RELEASE( pIXMLDOMNamedNodeMap ); } ::SysFreeString(bstrAttributeName); bstrAttributeName = nullptr; if( !bFound ) return E_FAIL; else return S_OK; }
int ZXML::GetAttributeText( IXMLDOMNode* pNode, LPSTR strAttrName, LPSTR strRet ) { wchar_t wstrAttr[128]; IXMLDOMNode* pAttrNode = NULL; IXMLDOMNamedNodeMap* pMap = NULL; VARIANT varValue; try { int n = mbstowcs( wstrAttr, strAttrName, 128 ); pNode->get_attributes( &pMap ); pMap->getNamedItem( wstrAttr, &pAttrNode ); pAttrNode->get_nodeValue( &varValue ); strcpy( strRet,(const char*)_bstr_t(varValue.bstrVal,FALSE) ); // wcstombs( strRet, varValue.bstrVal , 128 ); S_REL( pAttrNode ); S_REL( pMap ); return TRUE; } catch(...) { S_REL( pAttrNode ); S_REL( pMap ); return FALSE; } }
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; }
HRESULT XMLHelper::GetAttributeFromNode(IXMLDOMNode *pNode, BSTR bstrAttrName, VARIANT * varAttrValue) { HRESULT hr = S_OK; IXMLDOMNamedNodeMap *pAttributes = NULL; IXMLDOMNode *pAttrNode = NULL; CHK_HR(pNode->get_attributes(&pAttributes)); if (pAttributes) { CHK_HR(pAttributes->getNamedItem(bstrAttrName, &pAttrNode)); if (pAttrNode) { CHK_HR(pAttrNode->get_nodeValue(varAttrValue)); } } else { hr = S_FALSE; } CleanUp: SAFE_RELEASE(pAttributes); SAFE_RELEASE(pAttrNode); return hr; }
bool CXML::GetNodeAttributeValue(IXMLDOMNode ** ppNode,CString csAttributeName,CString &rcsValue) { IXMLDOMNode *pNodeAttribute = NULL; IXMLDOMNamedNodeMap *pNodeMap = NULL; CString csTemp; if(!ppNode || !(*ppNode)) return false; m_hr = (*ppNode)->get_attributes(&pNodeMap); if (SUCCEEDED(m_hr) == 0 || pNodeMap == NULL) return false; _bstr_t bstrAttributeName(csAttributeName); m_hr = pNodeMap->getNamedItem (bstrAttributeName,&pNodeAttribute); pNodeMap->Release(); if (SUCCEEDED(m_hr) == 0 || (pNodeAttribute == NULL)) return false; _variant_t vtAttributeVal; m_hr = pNodeAttribute->get_nodeValue(&vtAttributeVal); pNodeAttribute->Release(); if (SUCCEEDED(m_hr) == 0) return false; rcsValue = vtAttributeVal.bstrVal; return true; }
/////////////////////////////////////////////////////// // RADEventsXML::XMLToEvent // // Populates a RADEvent object with string and typed values // from the XML Event node attributes. The RADEvent class declares // the string-to-type conversion operations, per field. The XML node // attribute values are placed on the RADEvent as strings, without // modification from the XML. // // Input: // pEvent - the RADEvent instance // /////////////////////////////////////////////////////// RADEvent* RADEventsXML::XMLToEvent(IXMLDOMNode* pEvent) { HRESULT hr; RADEvent* p = NULL; IXMLDOMNode *pAtt=NULL; IXMLDOMNamedNodeMap* pat = NULL; long l; int al; HRCALL(pEvent->get_attributes(&pat), "get_attributes: "); HRCALL(pat->get_length(&l), "get_length: "); ASSERT(l <= (int)eRADAttMax); p = new RADEvent(); for (al = 0; al < l; al++) { HRCALL(pat->getNamedItem(atts[al], &pAtt), "gni"); if (pAtt) { VARIANT varValue; ::VariantInit(&varValue); pAtt->get_nodeValue(&varValue); p->SetREValue((RADEventField)al, varValue.bstrVal); ::VariantClear(&varValue); pAtt->Release(); } } clean: if (pat) pat->Release(); return p; }
int KXML::GetAttributeText(IXMLDOMNode* pNode, LPSTR strAttrName, LPSTR strRet){ wchar_t wstrAttr[128]; IXMLDOMNode* pAttrNode = NULL; IXMLDOMNamedNodeMap* pMap = NULL; VARIANT varValue; try{ //int n = mbstowcs(wstrAttr, strAttrName, 128); //int n = mbstowcs_s(wstrAttr, strAttrName, 128); // TODO : error test size_t convertedSize; int n = mbstowcs_s(&convertedSize, wstrAttr, strlen(strAttrName) + 1, strAttrName, 128); pNode->get_attributes(&pMap); pMap->getNamedItem(wstrAttr, &pAttrNode); pAttrNode->get_nodeValue(&varValue); strcpy_s(strRet, 128, (const char*)_bstr_t(varValue.bstrVal, FALSE)); // wcstombs(strRet, varValue.bstrVal, 128) REL(pAttrNode); REL(pMap); return TRUE; } catch (...){ REL(pAttrNode); REL(pMap); return FALSE; } }
static bool XMLGetAttrTrim( //return true only if an attribute with name pszwAttr found IXMLDOMNode* pNode, //node where to get attribute from const wchar_t* pszwAttr, //Name of attribute to get wchar_t szAttrVal[MAX_PATH] //buffer for result ) { HRESULT hr; VARIANT val; wchar_t* pszWchar; int nLen; IXMLDOMNode* pAttr; IXMLDOMNamedNodeMap* pAList; szAttrVal[0] = 0; pAList = NULL; pAttr = NULL; pNode->get_attributes(&pAList); if(pAList) { pAList->getNamedItem((wchar_t*)pszwAttr, &pAttr); FC_RELEASE_PTR(pAList); } if(!pAttr) return false; VariantInit(&val); hr = pAttr->get_nodeValue(&val); FC_RELEASE_PTR(pAttr); if(FAILED(hr) || val.vt!=VT_BSTR) { VariantClear(&val); return false; } //trim the string: pszWchar = val.bstrVal; while(_istspace(*pszWchar)) pszWchar++; for(nLen=wcslen(pszWchar);nLen>0 && _istspace(pszWchar[nLen-1]);nLen--) pszWchar[nLen-1] = 0; wcsncpy(szAttrVal, pszWchar, MAX_PATH); szAttrVal[MAX_PATH-1] = 0; VariantClear(&val); return true; }
//-------------------------------------------------------------------------------------- BOOL ConfGetNodeAttributeW(IXMLDOMNode *pIDOMNode, PWSTR name, PWSTR *value) { BOOL bRet = FALSE; IXMLDOMNamedNodeMap *pIXMLDOMNamedNodeMap = NULL; // query attributes map HRESULT hr = pIDOMNode->get_attributes(&pIXMLDOMNamedNodeMap); if (SUCCEEDED(hr) && pIXMLDOMNamedNodeMap) { IXMLDOMNode *pIDOMAttrNode = NULL; // query attribute node hr = pIXMLDOMNamedNodeMap->getNamedItem(name, &pIDOMAttrNode); if (SUCCEEDED(hr) && pIDOMAttrNode) { VARIANT varValue; hr = pIDOMAttrNode->get_nodeValue(&varValue); if (FAILED(hr)) { DbgMsg(__FILE__, __LINE__, "pIDOMAttrNode->get_nodeValue() ERROR 0x%.8x\n", hr); goto free; } BSTR val = _bstr_t(varValue); DWORD Len = (wcslen((PWSTR)val) + 1) * sizeof(WCHAR); if (*value = (PWSTR)M_ALLOC(Len)) { ZeroMemory(*value, Len); wcscpy(*value, (PWSTR)val); bRet = TRUE; } else { DbgMsg(__FILE__, __LINE__, "M_ALLOC() ERROR %d\n", GetLastError()); } free: pIDOMAttrNode->Release(); pIDOMAttrNode = NULL; } pIXMLDOMNamedNodeMap->Release(); pIXMLDOMNamedNodeMap = NULL; } return bRet; }
bool CNtlXMLDoc::GetTextWithAttributeName(IXMLDOMNode* pNode, WCHAR* pwszAttributeName, WCHAR* pwszResultText, int nBufferSizeInWChars) { if (NULL == pNode || NULL == pwszAttributeName || NULL == pwszResultText) { // NtlAssertFail("NULL == pNode || NULL == pwszAttributeName || NULL == pwszResultText"); return false; } if (0 >= nBufferSizeInWChars) { // NtlAssertFail("0 >= nBufferSizeInWChars"); return false; } IXMLDOMNamedNodeMap* pMap = NULL; pNode->get_attributes(&pMap); if (NULL == pMap) { // NtlAssertFail("Couldn't get the attribute list from the given IXMLDOMNode."); return false; } IXMLDOMNode* pVirtualNode = NULL; pMap->getNamedItem(pwszAttributeName, &pVirtualNode); if (NULL == pVirtualNode) { // NtlAssertFail("Couldn't find the given attribute name."); return false; } VARIANT var; VariantInit(&var); pVirtualNode->get_nodeValue(&var); if (wcslen(V_BSTR(&var)) >= (size_t)nBufferSizeInWChars) { // NtlAssertFail("The buffer size is not enough to take the whole attribute value."); return false; } wcscpy_s(pwszResultText, nBufferSizeInWChars, V_BSTR(&var)); return true; }
/****************************************************************************** Function Name : vRetrieveConditionSignalValue Input(s) : IXMLDOMNode* pIDOMSChildSignal CSignalCondition& ouSignalCondition Output : void Functionality : Retrieves the Signal Info from the pIDOMSChildSignal Member of : CVerify_MessageEntity Friend of : - Author(s) : Venkatanarayana Makam Date Created : 06/04/2011 Modifications : ******************************************************************************/ void CVerify_MessageEntity::vRetrieveConditionSignalValue(IXMLDOMNode* pIDOMSChildSignal, CSignalCondition& ouSignalCondition) { CComBSTR bstrNodeName = L"name"; CComVariant NodeValue; CString omstrTemp; IXMLDOMNamedNodeMap* pIDOMAttributes; IXMLDOMNode* pIDOMChildNode; pIDOMSChildSignal->get_attributes(&pIDOMAttributes); pIDOMAttributes->getNamedItem(bstrNodeName, &pIDOMChildNode); pIDOMChildNode->get_nodeTypedValue(&NodeValue); ouSignalCondition.m_omSigName = strCopyBSTRToCString(NodeValue); pIDOMChildNode->Release(); pIDOMAttributes->Release(); pIDOMSChildSignal->get_nodeTypedValue(&NodeValue); ouSignalCondition.m_omCondition = strCopyBSTRToCString(NodeValue); ouSignalCondition.m_omCondition.Remove('\"'); }
void lvDCOMInterface::getParams(std::map<std::string,std::string>& res) { res.clear(); char control_name_xpath[MAX_PATH_LEN]; _snprintf(control_name_xpath, sizeof(control_name_xpath), "/lvinput/section[@name='%s']/vi/param", m_configSection.c_str()); IXMLDOMNodeList* pXMLDomNodeList = NULL; HRESULT hr = m_pxmldom->selectNodes(_bstr_t(control_name_xpath), &pXMLDomNodeList); if (FAILED(hr) || pXMLDomNodeList == NULL) { return; } IXMLDOMNode *pNode, *pAttrNode1, *pAttrNode2; long n = 0; pXMLDomNodeList->get_length(&n); for(long i=0; i<n; ++i) { pNode = NULL; hr = pXMLDomNodeList->get_item(i, &pNode); if (SUCCEEDED(hr) && pNode != NULL) { IXMLDOMNamedNodeMap *attributeMap = NULL; pAttrNode1 = pAttrNode2 = NULL; pNode->get_attributes(&attributeMap); hr = attributeMap->getNamedItem(_bstr_t("name"), &pAttrNode1); hr = attributeMap->getNamedItem(_bstr_t("type"), &pAttrNode2); BSTR bstrValue1 = NULL, bstrValue2 = NULL; hr=pAttrNode1->get_text(&bstrValue1); hr=pAttrNode2->get_text(&bstrValue2); res[std::string(COLE2CT(bstrValue1))] = COLE2CT(bstrValue2); SysFreeString(bstrValue1); SysFreeString(bstrValue2); pAttrNode1->Release(); pAttrNode2->Release(); attributeMap->Release(); pNode->Release(); } } pXMLDomNodeList->Release(); }
STDMETHODIMP CStrokeRecognition::put_RecognitionParam(BSTR newVal) { double Segment_Error_Threshold; double Arc_Error_Threshold; double Arc_Min_Length; double Arc_Min_Curve; double Stroke_Min_Length; double Min_Turning_Angle; double Segmentation_Penalty; VARIANT value; BSTR nodeName; long n; IXMLDOMDocument* pDoc; IXMLDOMNodeList* pNodeList; IXMLDOMNode* pNode; IXMLDOMNode* pParamNode; IXMLDOMNode* pAttrNode; IXMLDOMNamedNodeMap* pNodeMap; VARIANT_BOOL bLoaded; GetFittingParam(Segment_Error_Threshold, Arc_Error_Threshold, Arc_Min_Length, Arc_Min_Curve, Stroke_Min_Length, Min_Turning_Angle, Segmentation_Penalty); if (SUCCEEDED(CoCreateInstance(CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, IID_IXMLDOMDocument, (LPVOID*)&pDoc))) { pDoc->put_async(VARIANT_FALSE); pDoc->loadXML(newVal, &bLoaded); if (bLoaded == VARIANT_TRUE) { if (SUCCEEDED(pDoc->get_childNodes(&pNodeList))) { pParamNode = NULL; pNodeList->get_length(&n); for (int i = 0; i < n; i++) { if (SUCCEEDED(pNodeList->get_item(i, &pNode))) { nodeName = NULL; if (SUCCEEDED(pNode->get_nodeName(&nodeName))) { if (CComBSTR(nodeName) == L"param") { pParamNode = pNode; pParamNode->AddRef(); break; } SysFreeString(nodeName); } pNode->Release(); } } pNodeList->Release(); if (pParamNode != NULL) { if (SUCCEEDED(pParamNode->get_attributes(&pNodeMap))) { if (SUCCEEDED(pNodeMap->getNamedItem(L"Segment_Error_Threshold", &pAttrNode))) { pAttrNode->get_nodeValue(&value); Segment_Error_Threshold = _wtof(value.bstrVal); pAttrNode->Release(); } if (SUCCEEDED(pNodeMap->getNamedItem(L"Arc_Error_Threshold", &pAttrNode))) { pAttrNode->get_nodeValue(&value); Arc_Error_Threshold = _wtof(value.bstrVal); pAttrNode->Release(); } if (SUCCEEDED(pNodeMap->getNamedItem(L"Arc_Min_Length", &pAttrNode))) { pAttrNode->get_nodeValue(&value); Arc_Min_Length = _wtof(value.bstrVal); pAttrNode->Release(); } if (SUCCEEDED(pNodeMap->getNamedItem(L"Arc_Min_Curve", &pAttrNode))) { pAttrNode->get_nodeValue(&value); Arc_Min_Curve = _wtof(value.bstrVal); pAttrNode->Release(); } if (SUCCEEDED(pNodeMap->getNamedItem(L"Stroke_Min_Length", &pAttrNode))) { pAttrNode->get_nodeValue(&value); Stroke_Min_Length = _wtof(value.bstrVal); pAttrNode->Release(); } if (SUCCEEDED(pNodeMap->getNamedItem(L"Min_Turning_Angle", &pAttrNode))) { pAttrNode->get_nodeValue(&value); Min_Turning_Angle = _wtof(value.bstrVal); pAttrNode->Release(); } if (SUCCEEDED(pNodeMap->getNamedItem(L"Segmentation_Penalty", &pAttrNode))) { pAttrNode->get_nodeValue(&value); Segmentation_Penalty = _wtof(value.bstrVal); pAttrNode->Release(); } pNodeMap->Release(); } pParamNode->Release(); } } } pDoc->Release(); } SetFittingParam(Segment_Error_Threshold, Arc_Error_Threshold, Arc_Min_Length, Arc_Min_Curve, Stroke_Min_Length, Min_Turning_Angle, Segmentation_Penalty); return S_OK; }
void CStrokeRecognition::DecodePointFromXML(std::vector<POINT> &rgPoints, BSTR strXML) { IXMLDOMDocument* pDoc; IXMLDOMNodeList* pNodeList; IXMLDOMNode* pNode; IXMLDOMNode* pInputNode; IXMLDOMNode* pAttrNode; IXMLDOMNamedNodeMap* pNodeMap; VARIANT_BOOL bLoaded; VARIANT value; BSTR nodeName; POINT pt; long n; if (SUCCEEDED(CoCreateInstance(CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, IID_IXMLDOMDocument, (LPVOID*)&pDoc))) { pDoc->put_async(VARIANT_FALSE); pDoc->loadXML(strXML, &bLoaded); if (bLoaded == VARIANT_TRUE) { if (SUCCEEDED(pDoc->get_childNodes(&pNodeList))) { pInputNode = NULL; pNodeList->get_length(&n); for (int i = 0; i < n; i++) { if (SUCCEEDED(pNodeList->get_item(i, &pNode))) { nodeName = NULL; if (SUCCEEDED(pNode->get_nodeName(&nodeName))) { if (CComBSTR(nodeName) == L"input") { pInputNode = pNode; pInputNode->AddRef(); break; } SysFreeString(nodeName); } pNode->Release(); } } pNodeList->Release(); if (pInputNode != NULL) { if (SUCCEEDED(pInputNode->get_childNodes(&pNodeList))) { pNodeList->get_length(&n); for (int i = 0; i < n; i++) { if (SUCCEEDED(pNodeList->get_item(i, &pNode))) { pt.x = 0; pt.y = 0; if (SUCCEEDED(pNode->get_attributes(&pNodeMap))) { if (SUCCEEDED(pNodeMap->getNamedItem(L"x", &pAttrNode))) { pAttrNode->get_nodeValue(&value); pt.x = _wtoi(value.bstrVal); pAttrNode->Release(); } if (SUCCEEDED(pNodeMap->getNamedItem(L"y", &pAttrNode))) { pAttrNode->get_nodeValue(&value); pt.y = _wtoi(value.bstrVal); pAttrNode->Release(); } pNodeMap->Release(); } rgPoints.push_back(pt); pNode->Release(); } } pNodeList->Release(); } pInputNode->Release(); } } } pDoc->Release(); } }
bool CNtlXMLDoc::GetTextWithAttributeName(IXMLDOMNode* pNode, char* pszAttributeName, char* pszResultText, int nBufferSizeInBytes) { if (NULL == pNode || NULL == pszAttributeName || NULL == pszResultText) { // NtlAssertFail("NULL == pNode || NULL == pszAttributeName || NULL == pszResultText"); return false; } if (0 >= nBufferSizeInBytes) { // NtlAssertFail("0 >= nBufferSizeInBytes"); return false; } int nRequiredBytes = 0; nRequiredBytes = MultiByteToWideChar(GetACP(), 0, pszAttributeName, -1, NULL, 0); if (0 == nRequiredBytes) { // NtlAssertFail("The given attribute name can't be converted into WCHAR type for some reason."); return false; } if (nRequiredBytes > (CNtlXMLDoc::MAX_ATTRIBUTE_NAME_IN_WCHAR + 1)) { // NtlAssertFail("The given attribute name is too long."); return false; } WCHAR pwszAttributeNameInWChar[CNtlXMLDoc::MAX_ATTRIBUTE_NAME_IN_WCHAR + 1]; int nUsedBufferSize = MultiByteToWideChar(GetACP(), 0, pszAttributeName, -1, pwszAttributeNameInWChar, (CNtlXMLDoc::MAX_ATTRIBUTE_NAME_IN_WCHAR + 1)); if (0 == nUsedBufferSize) { // NtlAssertFail("The given attribute name couldn't be converted into WCHAR type for some reason."); return false; } IXMLDOMNamedNodeMap* pMap = NULL; pNode->get_attributes(&pMap); if (NULL == pMap) { // NtlAssertFail("Couldn't get the attribute list from the given IXMLDOMNode."); return false; } IXMLDOMNode* pVirtualNode = NULL; pMap->getNamedItem(pwszAttributeNameInWChar, &pVirtualNode); if (NULL == pVirtualNode) { // NtlAssertFail("Couldn't find the given attribute name."); return false; } VARIANT var; VariantInit(&var); pVirtualNode->get_nodeValue(&var); nRequiredBytes = WideCharToMultiByte(::GetACP(), 0, V_BSTR(&var), -1, pszResultText, 0, NULL, NULL); if (nRequiredBytes > nBufferSizeInBytes) { // NtlAssertFail("The buffer size is not enough to take the whole attribute value."); return false; } WideCharToMultiByte(GetACP(), 0, V_BSTR(&var), -1, pszResultText, nBufferSizeInBytes, NULL, NULL); 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> { // Если ранее был параметр "data" - удалить его из списка атрибутов hr = pAttrs->getNamedItem(L"data", &pNode); if (SUCCEEDED(hr) && pNode) { hr = pChild->removeChild(pNode, &pNodeRmv); pNode->Release(); pNode = NULL; SetDataChanged(); if (pNodeRmv) { pNodeRmv->Release(); pNodeRmv = NULL; } } long nAllLen = nSize/2; // длина в wchar_t wchar_t* psz = (wchar_t*)value; SetMultiLine(pChild, psz, nAllLen); } 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; } }