/**
* получение xml-узла из списка по его имени
* @param NodeName имя искомого узла
* @param pIDOMNodeList дескриптор списка
* @return дескриптор нужного узла, или NULL в случае неудачи
* @see ConfGetNodeByName()
* @see ConfGetNodeText()
* @see ConfGetTextByName()
*/
IXMLDOMNode * ConfGetListNodeByName(BSTR NodeName, IXMLDOMNodeList *pIDOMNodeList)
{
IXMLDOMNode *Ret = NULL;
LONG len = 0;
if (pIDOMNodeList == NULL)
{
return NULL;
}
HRESULT hr = pIDOMNodeList->get_length(&len);
if (SUCCEEDED(hr))
{
pIDOMNodeList->reset();
for (int i = 0; i < len; i++)
{
IXMLDOMNode *pIDOMChildNode = NULL;
hr = pIDOMNodeList->get_item(i, &pIDOMChildNode);
if (SUCCEEDED(hr))
{
BSTR ChildNodeName = NULL;
hr = pIDOMChildNode->get_nodeName(&ChildNodeName);
if (SUCCEEDED(hr))
{
if (!wcscmp(NodeName, ChildNodeName))
{
Ret = pIDOMChildNode;
}
}
if (ChildNodeName)
{
SysFreeString(ChildNodeName);
}
if (Ret)
{
return Ret;
}
pIDOMChildNode->Release();
pIDOMChildNode = NULL;
}
else
{
DbgMsg(__FILE__, __LINE__, "pIDOMNodeList->get_item() ERROR 0x%.8x\n", hr);
}
}
}
else
{
DbgMsg(__FILE__, __LINE__, "pIDOMNodeList->get_length() ERROR 0x%.8x\n", hr);
}
return NULL;
}
BOOL TxSkin::elVBOX::loadXML( IXMLDOMNode* node, LPCWSTR baseurl )
{
BOOL ret = skin_element::loadXML(node, baseurl);
m_adapt = xmlGetAttributeValueBOOL(node, TEXT("adapt"), TRUE);
IXMLDOMNode* child = NULL;
node->get_firstChild(&child);
while(child)
{
BSTR name = NULL;
child->get_nodeName(&name);
if(name)
{
skin_element* el = m_skin->createElement(name, m_skin);
if(el)
{
if(el->loadXML(child, baseurl))
{
addElement(el);
} else
{
delete el;
}
}
SysFreeString(name);
}
IXMLDOMNode* newChild = NULL;
child->get_nextSibling(&newChild);
child->Release();
child = newChild;
}
return ret;
}
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();
}
}
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();
}
/**Read the XML config file. Currently contains keyboard choices.*/
void read_config_file()
{
TrainerConfig *result = new TrainerConfig();
CoInitialize(NULL);
//read XML
MSXML2::IXMLDOMDocumentPtr spXMLDoc;
spXMLDoc.CreateInstance(__uuidof(MSXML2::DOMDocument60));
if (!spXMLDoc->load("ent-config.xml"))
{
write_text_to_log_file("No config found, using defaults");
config = result; //the default config
}
IXMLDOMNodeListPtr nodes = spXMLDoc->selectNodes(L"//ent-config/keys/key");
long length;
nodes->get_length(&length);
for (int i = 0; i < length; i++)
{
IXMLDOMNode *node;
nodes->get_item(i, &node);
IXMLDOMNamedNodeMap *attribs;
node->get_attributes(&attribs);
long length_attribs;
attribs->get_length(&length_attribs);
char *attrib_key_func = NULL;
char *attrib_key_value = NULL;
for (long j = 0; j < length_attribs; j++)
{
IXMLDOMNode *attribNode;
attribs->get_item(j, &attribNode);
attribNode->get_nodeName(&bstr);
if (wcscmp(bstr, L"function") == 0)
{
VARIANT var;
VariantInit(&var);
attribNode->get_nodeValue(&var);
attrib_key_func = _com_util::ConvertBSTRToString(V_BSTR(&var));
}
else if (wcscmp(bstr, L"value") == 0)
{
VARIANT var;
VariantInit(&var);
attribNode->get_nodeValue(&var);
attrib_key_value = _com_util::ConvertBSTRToString(V_BSTR(&var));
}
SysFreeString(bstr);
attribNode->Release();
}
if (attrib_key_func != NULL && attrib_key_value != NULL)
{
result->get_key_config()->set_key(attrib_key_func, attrib_key_value);
}
delete attrib_key_func;
delete attrib_key_value;
attribs->Release();
node->Release();
}
//nodes->Release(); //don't do this, it crashes on exit
spXMLDoc.Release();
CoUninitialize();
config = result;
}
/*
Function name : CXML::GetNodePath
Description : This function will return the full path of the xml file. (Max up to
: 100 Nodes)
Return type : bool
Argument : CString &rcsPath
Tested : Ok
*/
bool CXML::GetNodePath(CString &rcsPath)
{
if(!m_pICurrentNode)
return false;
char * path[100] = {0};
IXMLDOMNode * pCurNode = m_pICurrentNode;
IXMLDOMNode * pParentNode = NULL;
pCurNode->AddRef();
CString csNodeText;
int i = 0;
try
{
do
{
m_hr = pCurNode->get_parentNode(&pParentNode);
if(!SUCCEEDED(m_hr))
{
pCurNode->Release();
throw 1;
}
else if(!pParentNode)
break;
BSTR bstrNodeText;
m_hr = pParentNode->get_nodeName(&bstrNodeText);
pCurNode->Release();
pCurNode = pParentNode;
pCurNode->AddRef();
pParentNode->Release();
if(!SUCCEEDED(m_hr))
{
throw 1;
}
long nLen = wcslen(bstrNodeText)+1;
path[i] = new char[nLen];
WideCharToMultiByte(CP_ACP,0,bstrNodeText,-1,path[i],nLen,NULL,NULL);
SysFreeString(bstrNodeText);
i++;
}
while(true);
delete [] path[--i];
for(--i;i>=0;--i)
{
rcsPath += path[i];
rcsPath +="/";
delete [] path[i];
}
GetCurrentNodeName(csNodeText);
rcsPath +=csNodeText;
return true;
}
catch(...)
{
rcsPath = "";
for(--i;i>=0;--i)
delete [] path[i];
return false;
}
}
///////////////////////////////////////////////////////////////
// 功能: 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;
}
void queryNodes()
{
HRESULT hr = S_OK;
IXMLDOMDocument *pXMLDom = NULL;
IXMLDOMNodeList *pNodes = NULL;
IXMLDOMNode *pNode = NULL;
BSTR bstrQuery1 = NULL;
BSTR bstrQuery2 = NULL;
BSTR bstrNodeName = NULL;
BSTR bstrNodeValue = NULL;
VARIANT_BOOL varStatus;
VARIANT varFileName;
VariantInit(&varFileName);
CHK_HR(CreateAndInitDOM(&pXMLDom));
CHK_HR(VariantFromString(L"stocks.xml", varFileName));
CHK_HR(pXMLDom->load(varFileName, &varStatus));
if (varStatus != VARIANT_TRUE)
{
CHK_HR(ReportParseError(pXMLDom, "Failed to load DOM from stocks.xml."));
}
// Query a single node.
bstrQuery1 = SysAllocString(L"//stock[1]/*");
CHK_ALLOC(bstrQuery1);
CHK_HR(pXMLDom->selectSingleNode(bstrQuery1, &pNode));
if (pNode)
{
printf("Result from selectSingleNode:\n");
CHK_HR(pNode->get_nodeName(&bstrNodeName));
printf("Node, <%S>:\n", bstrNodeName);
SysFreeString(bstrNodeName);
CHK_HR(pNode->get_xml(&bstrNodeValue));
printf("\t%S\n\n", bstrNodeValue);
SysFreeString(bstrNodeValue);
SAFE_RELEASE(pNode);
}
else
{
CHK_HR(ReportParseError(pXMLDom, "Error while calling selectSingleNode."));
}
// Query a node-set.
bstrQuery2 = SysAllocString(L"//stock[1]/*");
CHK_ALLOC(bstrQuery2);
CHK_HR(pXMLDom->selectNodes(bstrQuery2, &pNodes));
if(pNodes)
{
printf("Results from selectNodes:\n");
//get the length of node-set
long length;
CHK_HR(pNodes->get_length(&length));
for (long i = 0; i < length; i++)
{
CHK_HR(pNodes->get_item(i, &pNode));
CHK_HR(pNode->get_nodeName(&bstrNodeName));
/*if(0== wcscmp(bstrNodeValue, L"symbol"))
{
}
*/
printf("Node (%d), <%S>:\n", i, bstrNodeName);
SysFreeString(bstrNodeName);
CHK_HR(pNode->get_xml(&bstrNodeValue));
printf("\t%S\n", bstrNodeValue);
SysFreeString(bstrNodeValue);
SAFE_RELEASE(pNode);
}
}
else
{
CHK_HR(ReportParseError(pXMLDom, "Error while calling selectNodes."));
}
CleanUp:
SAFE_RELEASE(pXMLDom);
SAFE_RELEASE(pNodes);
SAFE_RELEASE(pNode);
SysFreeString(bstrQuery1);
SysFreeString(bstrQuery2);
SysFreeString(bstrNodeName);
SysFreeString(bstrNodeValue);
VariantClear(&varFileName);
}
