// Helper function to create a DOM instance:
IXMLDOMDocument * DomFromCOM()
{
HRESULT hr;
IXMLDOMDocument *pxmldoc = NULL;
HRCALL( CoCreateInstance(__uuidof(DOMDocument40),
NULL,
CLSCTX_INPROC_SERVER,
__uuidof(IXMLDOMDocument),
(void**)&pxmldoc),
"Create a new DOMDocument");
HRCALL( pxmldoc->put_async(VARIANT_FALSE),
"should never fail");
HRCALL( pxmldoc->put_validateOnParse(VARIANT_FALSE),
"should never fail");
HRCALL( pxmldoc->put_resolveExternals(VARIANT_FALSE),
"should never fail");
return pxmldoc;
clean:
if (pxmldoc)
{
pxmldoc->Release();
}
return NULL;
}
bool SettingsXML::IsXmlAllowed()
{
IXMLDOMDocument* pFile = CreateDomDocument();
if (pFile)
pFile->Release();
return (pFile != NULL);
}
/**
* XML 파일의 형태를 Tab을 이용해서 보기 좋게 정렬한다.
* \param szIndentFileName 정렬에 사용할 스타일 시트 파일명
* return 성공 유무
*/
bool CNtlXMLDoc::SetIndent(WCHAR* szIndentFileName)
{
IXMLDOMDocument* pXSL = NULL;
CoCreateInstance(__uuidof(DOMDocument30), NULL, CLSCTX_INPROC_SERVER, __uuidof(IXMLDOMDocument), (void**)&pXSL);
if(!pXSL)
return false;
VARIANT_BOOL vBool;
pXSL->put_async(VARIANT_FALSE);
pXSL->load((_variant_t)szIndentFileName, &vBool);
VARIANT vObject;
VariantInit(&vObject);
vObject.vt = VT_DISPATCH;
vObject.pdispVal = m_pXMLDocument;
m_pXMLDocument->transformNodeToObject(pXSL, vObject);
if(pXSL)
{
pXSL->Release();
pXSL = NULL;
}
return true;
}
int DicomImageSet::parseFolder(QString folderName)
{
QStringList fileList = getAllFiles(folderName);
HRESULT hr = CoInitialize(NULL);
if (!SUCCEEDED(hr))
{
return NULL;
}
hr = S_OK;
IXMLDOMDocument *pXMLDom = NULL;
IXMLDOMElement *pRoot = NULL;
BSTR bstrXML = NULL;
VARIANT varFileName;
VariantInit(&varFileName);
QProgressDialog progress (QString("Parsing all files in %1").arg(folderName), QString("Cancel"), 0, fileList.count());
CHK_HR(CreateAndInitDOM(&pXMLDom));
// Create a processing instruction element.
CHK_HR(CreateAndAddPINode(pXMLDom, L"xml", L"version='1.0'"));
// Create the root element.
CHK_HR(CreateElement(pXMLDom, L"root", &pRoot));
// Create an attribute for the <root> element, with name "created" and value "using dom".
CHK_HR(CreateAndAddAttributeNode(pXMLDom, L"path", folderName.toStdWString().c_str(), pRoot));
// Add NEWLINE for identation before </root>.
CHK_HR(CreateAndAddTextNode(pXMLDom, L"\n", pRoot));
// add <root> to document
CHK_HR(AppendChildToParent(pRoot, pXMLDom));
progress.show();
for (int i=0; i<fileList.count(); ++i)
{
insertFileItem(pXMLDom, pRoot, folderName, fileList[i]);
progress.setValue(i);
}
CHK_HR(VariantFromString(QDir(folderName).filePath(DATASET_FILE_NAME).toStdWString().c_str(), varFileName));
CHK_HR(pXMLDom->save(varFileName));
CleanUp:
SAFE_RELEASE(pRoot);
SysFreeString(bstrXML);
VariantClear(&varFileName);
CoUninitialize();
if (FAILED(hr))
{
SAFE_RELEASE(pXMLDom);
return 0;
}
return 1;
}
IXMLDOMDocument *XmlParser::_openFile(const LPWSTR file, XMLERRORDATA *error)
{
if(error)
{
error->errorCode = -1;
error->line = -1;
error->reason = NULL;
}
bool ok = false;
IXMLDOMDocument *x = createAndConfigureInterface();
if(x)
{
VARIANT_BOOL bl;
VARIANT str;
//Выделяем строку.
CWA(oleaut32, VariantInit)(&str);
str.vt = VT_BSTR;
str.bstrVal = CWA(oleaut32, SysAllocString)(file);
if(str.bstrVal != NULL)
{
//Загружаем файл.
if(x->load(str, &bl) == S_OK && bl == VARIANT_TRUE)ok = true;
//Получаем ошибку.
else if(error)
{
IXMLDOMParseError *ierror;
if(x->get_parseError(&ierror) == S_OK)
{
long l;
BSTR reason = NULL;
//Заполняем структуру.
if(ierror->get_errorCode(&l) == S_OK)error->errorCode = l;
if(ierror->get_line(&l) == S_OK)error->line = l;
if(ierror->get_reason(&reason) == S_OK)error->reason = reason;
ierror->Release();
}
}
CWA(oleaut32, VariantClear)(&str);
}
//Объект не создан, освобождаем интерфейс.
if(ok == false)
{
x->Release();
x = NULL;
}
}
return x;
}
IXMLDOMDocument *XmlParser::_openFile(const LPWSTR file, XMLERRORDATA *error)
{
if(error)
{
error->errorCode = -1;
error->line = -1;
error->reason = NULL;
}
bool ok = false;
IXMLDOMDocument *x = createAndConfigureInterface();
if(x)
{
VARIANT_BOOL bl;
VARIANT str;
//Select the line.
CWA(oleaut32, VariantInit)(&str);
str.vt = VT_BSTR;
str.bstrVal = CWA(oleaut32, SysAllocString)(file);
if(str.bstrVal != NULL)
{
//Load the file.
if(x->load(str, &bl) == S_OK && bl == VARIANT_TRUE)ok = true;
//Get an error.
else if(error)
{
IXMLDOMParseError *ierror;
if(x->get_parseError(&ierror) == S_OK)
{
long l;
BSTR reason = NULL;
//Fill in the structure.
if(ierror->get_errorCode(&l) == S_OK)error->errorCode = l;
if(ierror->get_line(&l) == S_OK)error->line = l;
if(ierror->get_reason(&reason) == S_OK)error->reason = reason;
ierror->Release();
}
}
CWA(oleaut32, VariantClear)(&str);
}
//The object is not created, we release interface.
if(ok == false)
{
x->Release();
x = NULL;
}
}
return x;
}
static IXMLDOMDocument *createAndConfigureInterface(void)
{
IXMLDOMDocument *xmlDoc = (IXMLDOMDocument *)ComLibrary::_createInterface(CLSID_DOMDocument30, IID_IXMLDOMDocument);
if(xmlDoc != NULL)
{
xmlDoc->put_async(VARIANT_FALSE);
xmlDoc->put_preserveWhiteSpace(VARIANT_FALSE);
xmlDoc->put_resolveExternals(VARIANT_FALSE);
xmlDoc->put_validateOnParse(VARIANT_TRUE);
}
return xmlDoc;
}
int DicomImageSet::insertDTIFileItem(const QString &datasetFolderName, const QString &queryString, const QString &dtiFileName)
{
HRESULT hr = CoInitialize(NULL);
if (!SUCCEEDED(hr))
{
return 0;
}
QString datasetFileName = datasetFolderName+DATASET_FILE_NAME;
IXMLDOMDocument *pXMLDom = NULL;
IXMLDOMElement *pNode = NULL, *pParent = NULL;
BSTR bstrQuery = NULL;
VARIANT varFileName;
VARIANT_BOOL varStatus;
QString queryDTIFile;
CHK_HR(CreateAndInitDOM(&pXMLDom));
CHK_HR(VariantFromString(datasetFileName.toStdWString().c_str(), varFileName));
CHK_HR(pXMLDom->load(varFileName, &varStatus));
/*queryDTIFile = queryString+QString("/DTI[@file_name = '%1']").arg(dtiFileName);
bstrQuery = SysAllocString(queryString.toStdWString().c_str());
CHK_ALLOC(bstrQuery);
CHK_HR(pXMLDom->selectSingleNode(bstrQuery, (IXMLDOMNode**)&pNode));
SysFreeString(bstrQuery);
if (pNode)
{
return 1;
}*/
bstrQuery = SysAllocString(queryString.toStdWString().c_str());
CHK_ALLOC(bstrQuery);
CHK_HR(pXMLDom->selectSingleNode(bstrQuery, (IXMLDOMNode**)&pParent));
SysFreeString(bstrQuery);
if (pParent)
{
CHK_HR(CreateElement(pXMLDom, L"DTI", &pNode));
CHK_HR(CreateAndAddAttributeNode(pXMLDom, L"file_name", dtiFileName.toStdWString().c_str(), pNode));
CHK_HR(CreateAndAddTextNode(pXMLDom, L"\n", pParent));
CHK_HR(AppendChildToParent(pNode, pParent));
CHK_HR(pXMLDom->save(varFileName));
return 1;
}
CleanUp:
SAFE_RELEASE(pXMLDom);
SAFE_RELEASE(pNode);
return 0;
}
CGT_CXMLEdp(IXMLDOMNode* pNode)
{
IXMLDOMDocument* pdoc;
BSTR bstr;
pNode->get_ownerDocument(&pdoc);
pdoc->get_url(&bstr);
xmlFile.load(bstr);
FC_RELEASE_PTR(pdoc);
FC_FREESYSTRING(bstr);
xmlFile.stripBeginI(_T("file:"));
while(xmlFile.stripBeginI("/"))
;
CG_InitSTEdipos(&m_edp, xmlFile, 1);//TODO impossible to get (line,col), use line 1...??
}
QStringList DicomImageSet::getOrderedDcmFiles(const QString &datasetFileName, const QString & queryString)
{
HRESULT hr = S_OK;
IXMLDOMDocument *pXMLDom = NULL;
IXMLDOMNodeList *pFileNodes = NULL;
VARIANT_BOOL varStatus;
VARIANT varFileName;
BSTR bstrQuery;
QStringList fileList;
CHK_HR(CreateAndInitDOM(&pXMLDom));
CHK_HR(VariantFromString(datasetFileName.toStdWString().c_str(), varFileName));
CHK_HR(pXMLDom->load(varFileName, &varStatus));
if (varStatus != VARIANT_TRUE)
{
CHK_HR(ReportParseError(pXMLDom, "Failed to load DOM from stocks.xml."));
}
bstrQuery = SysAllocString(queryString.toStdWString().c_str());
CHK_ALLOC(bstrQuery);
CHK_HR(pXMLDom->selectNodes(bstrQuery, &pFileNodes));
if (pFileNodes)
{
long nFiles;
CHK_HR(pFileNodes->get_length(&nFiles));
for (long i=0; i<nFiles; ++i)
{
VARIANT varValue;
IXMLDOMNode * pFile = NULL;
CHK_HR(pFileNodes->get_item(i, &pFile));
CHK_HR(GetAttributeFromNode(pFile, L"path", &varValue));
fileList <<QString::fromWCharArray(_bstr_t(varValue));
SAFE_RELEASE(pFile);
}
}
CleanUp:
SAFE_RELEASE(pXMLDom);
SAFE_RELEASE(pFileNodes);
return fileList;
}
int do_CheckXML(lua_State* L)
{
CString strXml = luaL_checkstring(L,1);
HRESULT hr;
IXMLDOMDocument * pXMLDoc;
//...
hr = CoInitialize(NULL);
// Check the return value, hr...
hr = CoCreateInstance(CLSID_DOMDocument30, NULL, CLSCTX_INPROC_SERVER,
IID_IXMLDOMDocument, (void**)&pXMLDoc);
// Check the return value, hr...
VARIANT_BOOL bSuccessful;
pXMLDoc->loadXML(strXml.AllocSysString(),&bSuccessful);
int irez = 0;
if(!bSuccessful)
{
IXMLDOMParseError *pIParseError = NULL;
pXMLDoc->get_parseError(&pIParseError);
long lineNum;
pIParseError->get_line(&lineNum);
long linePos;
pIParseError->get_linepos(&linePos);
BSTR reason;
pIParseError->get_reason(&reason);
lua_pushinteger(L, lineNum);
lua_pushinteger(L, linePos);
lua_pushstring(L, CString(reason));
pIParseError->Release();
pIParseError = NULL;
irez = 3;
}
pXMLDoc->Release();
return irez;
}
static IXMLDOMNode* XMLLoadFile(const TCHAR* pszFile)
{
HRESULT hr;
IXMLDOMElement* pRoot;
IXMLDOMDocument* pXMLDoc;
hr = CoCreateInstance(CLSID_DOMDocument,
NULL,
CLSCTX_INPROC_SERVER,
IID_IXMLDOMDocument,
(void**)&pXMLDoc);
if(FAILED(hr))
return NULL;
_variant_t vSrc(pszFile);
VARIANT_BOOL vBool = VARIANT_FALSE;
hr = pXMLDoc->load(vSrc, &vBool);
if(FAILED(hr))
{
FC_RELEASE_PTR(pXMLDoc);
return NULL;
}
if(vBool!=VARIANT_TRUE)
{
FC_RELEASE_PTR(pXMLDoc);
return NULL;
}
pRoot = NULL;
hr = pXMLDoc->get_documentElement(&pRoot);
FC_RELEASE_PTR(pXMLDoc);
if(FAILED(hr) || !pRoot)
return NULL;
return pRoot;
}
QString DicomImageSet::getDTIFileName(const QString &datasetFolderName, const QString &queryString)
{
QString datasetFileName = datasetFolderName+DATASET_FILE_NAME;
HRESULT hr = S_OK;
IXMLDOMDocument *pXMLDom = NULL;
IXMLDOMNode *pFileNode = NULL;
VARIANT_BOOL varStatus;
VARIANT varFileName;
BSTR bstrQuery;
QStringList fileList;
CHK_HR(CreateAndInitDOM(&pXMLDom));
CHK_HR(VariantFromString(datasetFileName.toStdWString().c_str(), varFileName));
CHK_HR(pXMLDom->load(varFileName, &varStatus));
if (varStatus != VARIANT_TRUE)
{
CHK_HR(ReportParseError(pXMLDom, "Failed to load DOM from stocks.xml."));
}
bstrQuery = SysAllocString(QString(queryString+"/DTI").toStdWString().c_str());
CHK_ALLOC(bstrQuery);
CHK_HR(pXMLDom->selectSingleNode(bstrQuery, &pFileNode));
if (pFileNode)
{
VARIANT varValue;
CHK_HR(GetAttributeFromNode(pFileNode, L"file_name", &varValue));
return QString::fromWCharArray(_bstr_t(varValue));
}
CleanUp:
SAFE_RELEASE(pXMLDom);
SAFE_RELEASE(pFileNode);
return QString();
}
///////////////////////////////////////////////////////////////
// 功能: 扫描参数结构转换成 XML 文档
// 参数: sp [in] 扫描参数结构
// sXMLDocText [out] XML文档的文本
// 返回: true - 成功, false - 失败
bool ScanParamXML::ScanParamToXML( const ScanParameter &sp, string &sXMLDocText )
{
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;
}
IXMLDOMNode *pNode;
IXMLDOMNode *pNodeOut;
IXMLDOMNode *pRootNode;
_variant_t varNodeType = NODE_ELEMENT;
_variant_t varNodeVal;
_bstr_t bstrName;
_bstr_t bstrDataType = NODE_CDATA_SECTION ;
// 创建根结点
bstrName = _T("TopDiscoverParas");
hr = pXmlDoc->createNode( varNodeType , bstrName, 0, &pNode );
pXmlDoc->appendChild( pNode, &pRootNode );
// 创建Depth结点
varNodeVal = sp.nDepth;
AddChildNodeWithValue( pRootNode, pXmlDoc, "Depth", varNodeVal );
// 创建Tineout结点
varNodeVal = sp.nTimeout;
AddChildNodeWithValue( pRootNode, pXmlDoc, "Timeout", varNodeVal );
// 创建TryTimes结点
varNodeVal = sp.nTryTimes;
AddChildNodeWithValue( pRootNode, pXmlDoc, "TryTimes", varNodeVal );
// 创建SubScan结点
varNodeVal = sp.bSubScan ? XML_TRUE : XML_FALSE;
AddChildNodeWithValue( pRootNode, pXmlDoc, "SubScan", varNodeVal );
// 创建MaxTreadCount结点
varNodeVal = sp.nMaxTreadCount;
AddChildNodeWithValue( pRootNode, pXmlDoc, "MaxTreadCount", varNodeVal );
// 创建DefaultCommunityGet结点
varNodeVal = sp.sDefaultCommunityOfGet.c_str();
AddChildNodeWithValue( pRootNode, pXmlDoc, "DefaultCommunityGet", varNodeVal );
// 创建DefaultCommunitySet结点
varNodeVal = sp.sDefaultCommunityOfSet.c_str();
AddChildNodeWithValue( pRootNode, pXmlDoc, "DefaultCommunitySet", varNodeVal );
// CommunityList 向量操作
if( sp.vcCommunityList.size() > 0 )
{
VectorOfCommunity &vComm = const_cast< VectorOfCommunity & >( sp.vcCommunityList );
pNodeOut = AddChildElem( pRootNode, pXmlDoc, "Communitys" );
for( VectorOfCommunity::iterator it = vComm.begin();
pNodeOut != NULL && it != vComm.end(); it++ )
{
IXMLDOMNode *pNodeCommunity = AddChildElem( pNodeOut, pXmlDoc, "Community" );
_variant_t varNodeVal = it->sStartIp.c_str();
AddChildNodeWithValue( pNodeCommunity, pXmlDoc, "StartIp", varNodeVal );
varNodeVal = it->sEndIp.c_str();
AddChildNodeWithValue( pNodeCommunity, pXmlDoc, "EndIp", varNodeVal );
varNodeVal = it->sGet.c_str();
AddChildNodeWithValue( pNodeCommunity, pXmlDoc, "Get", varNodeVal );
varNodeVal = it->sSet.c_str();
AddChildNodeWithValue( pNodeCommunity, pXmlDoc, "Set", varNodeVal );
}
}
// IpScopeList 向量操作
if( sp.viIpScopeList.size() > 0 )
{
VectorOfIpScope &vIpScope = const_cast< VectorOfIpScope & >( sp.viIpScopeList );
pNodeOut = AddChildElem( pRootNode, pXmlDoc, "AddStartEnds" );
for( VectorOfIpScope::iterator it = vIpScope.begin();
pNodeOut != NULL && it != vIpScope.end(); it++ )
{
IXMLDOMNode *pNodeIpScope = AddChildElem( pNodeOut, pXmlDoc, "AddStartEnd" );
_variant_t varNodeVal = it->sIpBegin.c_str();
AddChildNodeWithValue( pNodeIpScope, pXmlDoc, "StartIp", varNodeVal );
varNodeVal = it->sIpEnd.c_str();
AddChildNodeWithValue( pNodeIpScope, pXmlDoc, "EndIp", varNodeVal );
}
}
// FilterStartEndList 向量操作
if( sp.viFilterStartEndList.size() > 0 )
{
VectorOfIpScope &vIpScope = const_cast< VectorOfIpScope & >( sp.viFilterStartEndList );
pNodeOut = AddChildElem( pRootNode, pXmlDoc, "FilterStartEnds" );
for( VectorOfIpScope::iterator it = vIpScope.begin();
pNodeOut != NULL && it != vIpScope.end(); it++ )
{
IXMLDOMNode *pNodeIpScope = AddChildElem( pNodeOut, pXmlDoc, "FilterStartEnd" );
_variant_t varNodeVal = it->sIpBegin.c_str();
AddChildNodeWithValue( pNodeIpScope, pXmlDoc, "StartIp", varNodeVal );
varNodeVal = it->sIpEnd.c_str();
AddChildNodeWithValue( pNodeIpScope, pXmlDoc, "EndIp", varNodeVal );
}
}
// SubnetList 向量操作
if( sp.viSubnetList.size() > 0 )
{
VectorOfIpScope &vIpScope = const_cast< VectorOfIpScope & >( sp.viSubnetList );
pNodeOut = AddChildElem( pRootNode, pXmlDoc, "SubnetList" );
for( VectorOfIpScope::iterator it = vIpScope.begin();
pNodeOut != NULL && it != vIpScope.end(); it++ )
{
IXMLDOMNode *pNodeIpScope = AddChildElem( pNodeOut, pXmlDoc, "Subnet" );
_variant_t varNodeVal = it->sIpBegin.c_str();
AddChildNodeWithValue( pNodeIpScope, pXmlDoc, "StartIp", varNodeVal );
varNodeVal = it->sIpEnd.c_str();
AddChildNodeWithValue( pNodeIpScope, pXmlDoc, "EndIp", varNodeVal );
}
}
// SeedIpList 向量操作
if( sp.vsSeedIpList.size() > 0 )
{
VectorOfString &vIpSeed = const_cast< VectorOfString & >( sp.vsSeedIpList );
pNodeOut = AddChildElem( pRootNode, pXmlDoc, "SeedIpList" );
for( VectorOfString::iterator it = vIpSeed.begin();
pNodeOut != NULL && it != vIpSeed.end(); it++ )
{
_variant_t varNodeVal = (*it).c_str();
AddChildNodeWithValue( pNodeOut, pXmlDoc, "Seed", varNodeVal );
}
}
// 处理输出参数
BSTR bstrXml;
pXmlDoc->get_xml( &bstrXml );
bstrName = bstrXml;
sXMLDocText = bstrName.operator char *();
SysFreeString( bstrXml );
// 保存到文件(用于测试)
// _variant_t varString = _T("C:\\sample.xml");
// pXmlDoc->save( varString );
}
catch(...)
{
return false;
}
return true;
}
int DicomImageSet::readDatasetFile(const QString &datasetFileName, QTreeWidget *treeWidget)
{
HRESULT hr = S_OK;
IXMLDOMDocument *pXMLDom = NULL;
IXMLDOMNodeList *pPatients = NULL;
IXMLDOMNode *pPatient = NULL;
DOMNodeType nodeType;
VARIANT_BOOL varStatus;
VARIANT varFileName;
VARIANT varValue;
BSTR bstrQuery;
VariantInit(&varFileName);
VariantInit(&varValue);
QString queryPatient, queryDate, queryProtocol, queryCollection;
CHK_HR(CreateAndInitDOM(&pXMLDom));
CHK_HR(VariantFromString(datasetFileName.toStdWString().c_str(), varFileName));
CHK_HR(pXMLDom->load(varFileName, &varStatus));
if (varStatus != VARIANT_TRUE)
{
CHK_HR(ReportParseError(pXMLDom, "Failed to load DOM from stocks.xml."));
}
treeWidget->clear();
treeWidget->setColumnCount(1);
CHK_HR(pXMLDom->getElementsByTagName(L"Patient", &pPatients));
if (pPatients)
{
long nPatients;
CHK_HR(pPatients->get_length(&nPatients));
for (long i=0; i<nPatients; ++i)
{
CHK_HR(pPatients->get_item(i, &pPatient));
CHK_HR(GetAttributeFromNode(pPatient, L"patients_name", &varValue));
queryPatient = QString::fromWCharArray(_bstr_t(varValue));
QTreeWidgetItem * patientItem = new QTreeWidgetItem(treeWidget, QStringList(queryPatient));
patientItem->setExpanded(true);
IXMLDOMNodeList * pDates = NULL;
CHK_HR(pPatient->get_childNodes(&pDates));
long nDates;
CHK_HR(pDates->get_length(&nDates));
for (long j=0; j<nDates; ++j)
{
IXMLDOMNode * pDate = NULL;
CHK_HR(pDates->get_item(j, &pDate));
CHK_HR(pDate->get_nodeType(&nodeType));
if(nodeType!=NODE_ELEMENT)
{
continue;
}
CHK_HR(GetAttributeFromNode(pDate, L"acquisition_date", &varValue));
queryDate = QString::fromWCharArray(_bstr_t(varValue));
int intDate = queryDate.toInt();
QDate date = (QDate::fromString("1900-01-01", "yyyy-MM-dd")).addDays(intDate-693962);
QTreeWidgetItem * dateItem = new QTreeWidgetItem(patientItem, QStringList(date.toString("yyyy-MM-dd")));
dateItem->setExpanded(true);
IXMLDOMNodeList * pProtocols = NULL;
CHK_HR(pDate->get_childNodes(&pProtocols));
long nProtocols;
CHK_HR(pProtocols->get_length(&nProtocols));
for (long j=0; j<nProtocols; ++j)
{
IXMLDOMNode * pProtocol = NULL;
CHK_HR(pProtocols->get_item(j, &pProtocol));
CHK_HR(pProtocol->get_nodeType(&nodeType));
if(nodeType!=NODE_ELEMENT)
{
continue;
}
CHK_HR(GetAttributeFromNode(pProtocol, L"protocol_name", &varValue));
queryProtocol = QString::fromWCharArray(_bstr_t(varValue));
QTreeWidgetItem * protocolItem = new QTreeWidgetItem(dateItem, QStringList(queryProtocol));
protocolItem->setExpanded(true);
IXMLDOMNodeList * pCollections = NULL;
CHK_HR(pProtocol->get_childNodes(&pCollections));
long nCollections;
CHK_HR(pCollections->get_length(&nCollections));
for (long j=0; j<nCollections; ++j)
{
IXMLDOMNode * pCollection = NULL;
CHK_HR(pCollections->get_item(j, &pCollection));
CHK_HR(pCollection->get_nodeType(&nodeType));
if(nodeType!=NODE_ELEMENT)
{
continue;
}
CHK_HR(GetAttributeFromNode(pCollection, L"acquisition_number", &varValue));
queryCollection = QString::fromWCharArray(_bstr_t(varValue));
QTreeWidgetItem * collectionItem = new QTreeWidgetItem(protocolItem);
QString queryStr = QString("root/Patient[@patients_name = '%1']/Date[@acquisition_date = '%2']/Protocol[@protocol_name = '%3']/Collection[@acquisition_number = '%4']")
.arg(queryPatient).arg(queryDate).arg(queryProtocol).arg(queryCollection);
IXMLDOMElement * pDtiNode = NULL;
bstrQuery = SysAllocString(QString(queryStr+"/DTI").toStdWString().c_str());
CHK_ALLOC(bstrQuery);
CHK_HR(pXMLDom->selectSingleNode(bstrQuery, (IXMLDOMNode**)&pDtiNode));
SysFreeString(bstrQuery);
if (pDtiNode)
{
collectionItem->setText(0,queryCollection+"*");
} else
{
collectionItem->setText(0, queryCollection);
}
collectionItem->setData(0, Qt::UserRole, queryStr);
collectionItem->setExpanded(true);
protocolItem->addChild(collectionItem);
SAFE_RELEASE(pCollection);
}
dateItem->addChild(protocolItem);
SAFE_RELEASE(pProtocol);
}
patientItem->addChild(dateItem);
SAFE_RELEASE(pDate);
}
treeWidget->insertTopLevelItem(i, patientItem);
SAFE_RELEASE(pPatient);
}
}
CleanUp:
SAFE_RELEASE(pXMLDom);
SAFE_RELEASE(pPatients);
SAFE_RELEASE(pPatient);
VariantClear(&varFileName);
return SUCCEEDED(hr);
}
/********************************************************************
XmlLoadDocumentEx -
*********************************************************************/
extern "C" HRESULT DAPI XmlLoadDocumentEx(
__in_z LPCWSTR wzDocument,
__in DWORD dwAttributes,
__out IXMLDOMDocument** ppixdDocument
)
{
HRESULT hr = S_OK;
VARIANT_BOOL vbSuccess = 0;
// RELEASEME
IXMLDOMDocument* pixd = NULL;
IXMLDOMParseError* pixpe = NULL;
BSTR bstrLoad = NULL;
if (!wzDocument || !*wzDocument)
{
hr = E_UNEXPECTED;
ExitOnFailure(hr, "string must be non-null");
}
hr = XmlCreateDocument(NULL, &pixd);
if (hr == S_FALSE)
{
hr = E_FAIL;
}
ExitOnFailure(hr, "failed XmlCreateDocument");
if (dwAttributes & XML_LOAD_PRESERVE_WHITESPACE)
{
hr = pixd->put_preserveWhiteSpace(VARIANT_TRUE);
ExitOnFailure(hr, "failed put_preserveWhiteSpace");
}
// Security issue. Avoid triggering anything external.
hr = pixd->put_validateOnParse(VARIANT_FALSE);
ExitOnFailure(hr, "failed put_validateOnParse");
hr = pixd->put_resolveExternals(VARIANT_FALSE);
ExitOnFailure(hr, "failed put_resolveExternals");
bstrLoad = ::SysAllocString(wzDocument);
ExitOnNull(bstrLoad, hr, E_OUTOFMEMORY, "failed to allocate bstr for Load in XmlLoadDocumentEx");
hr = pixd->loadXML(bstrLoad, &vbSuccess);
if (S_FALSE == hr)
{
hr = HRESULT_FROM_WIN32(ERROR_OPEN_FAILED);
}
if (FAILED(hr) && S_OK == pixd->get_parseError(&pixpe))
{
XmlReportParseError(pixpe);
}
ExitOnFailure(hr, "failed loadXML");
hr = S_OK;
LExit:
if (ppixdDocument)
{
*ppixdDocument = pixd;
pixd = NULL;
}
ReleaseBSTR(bstrLoad);
ReleaseObject(pixd);
ReleaseObject(pixpe);
return hr;
}
/*******************************************************************
XmlLoadDocumentFromFileEx
********************************************************************/
extern "C" HRESULT DAPI XmlLoadDocumentFromFileEx(
__in_z LPCWSTR wzPath,
__in DWORD dwAttributes,
__out IXMLDOMDocument** ppixdDocument
)
{
HRESULT hr = S_OK;
VARIANT varPath;
VARIANT_BOOL vbSuccess = 0;
IXMLDOMDocument* pixd = NULL;
IXMLDOMParseError* pixpe = NULL;
::VariantInit(&varPath);
varPath.vt = VT_BSTR;
varPath.bstrVal = ::SysAllocString(wzPath);
ExitOnNull(varPath.bstrVal, hr, E_OUTOFMEMORY, "failed to allocate bstr for Path in XmlLoadDocumentFromFileEx");
hr = XmlCreateDocument(NULL, &pixd);
if (hr == S_FALSE)
{
hr = E_FAIL;
}
ExitOnFailure(hr, "failed XmlCreateDocument");
if (dwAttributes & XML_LOAD_PRESERVE_WHITESPACE)
{
hr = pixd->put_preserveWhiteSpace(VARIANT_TRUE);
ExitOnFailure(hr, "failed put_preserveWhiteSpace");
}
// Avoid triggering anything external.
hr = pixd->put_validateOnParse(VARIANT_FALSE);
ExitOnFailure(hr, "failed put_validateOnParse");
hr = pixd->put_resolveExternals(VARIANT_FALSE);
ExitOnFailure(hr, "failed put_resolveExternals");
pixd->put_async(VARIANT_FALSE);
hr = pixd->load(varPath, &vbSuccess);
if (S_FALSE == hr)
{
hr = HRESULT_FROM_WIN32(ERROR_OPEN_FAILED);
}
if (FAILED(hr) && S_OK == pixd->get_parseError(&pixpe))
{
XmlReportParseError(pixpe);
}
ExitOnFailure1(hr, "failed to load XML from: %ls", wzPath);
if (ppixdDocument)
{
*ppixdDocument = pixd;
pixd = NULL;
}
hr = S_OK;
LExit:
ReleaseVariant(varPath);
ReleaseObject(pixd);
ReleaseObject(pixpe);
return hr;
}
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);
}
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;
}
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;
}
/**
* InitTree
* initialize the instance tree for the first time: get all necessary
* information from the kad and construct root and classes group nodes
*
* @return TRUE: on success
* FALSE: else
* @exception -
* @see
*/
BOOL CInstanceTree::InitTree()
{
GetStaticInfos();
// create project node
CXMLNode docRoot;
CXMLNode projectNode;
PROJ_MAN_ASSERT(m_pProjectManager);
CString strProjNodeId;
strProjNodeId = m_pProjectManager->GetProjectName()+_T(".")+ID_PATH_INSTANCEVIEW;
CString strVersion;
strVersion.Format(_T("%i"), PRODUCT_BUILD);
if ( (!m_domDocument.GetDocNode(docRoot))
||(!m_domDocument.CreateNode(projectNode, CE_XMLTAG_NODE))
||(!docRoot.AppendChild(projectNode))
||(!projectNode.SetAttribute(CE_XMLATTR_TEXT, m_pProjectManager->GetProjectName()))
||(!projectNode.SetAttribute(CE_XMLATTR_ID, strProjNodeId))
||(!projectNode.SetAttribute(CE_XMLATTR_PARSERSOURCE, m_pProjectManager->GetProjectFileName()))
||(!projectNode.SetAttribute(CE_XMLATTR_TYPE, m_strInstancesType))
||(!projectNode.SetAttribute(PRJMAN_VERSION, strVersion)) )
{
return FALSE;
}
Reparse4CPAttributes(&projectNode);
// add project file to source file list
TSourceFileInfo* pProjFileInfo;
CString strProjFileName = m_pProjectManager->GetProjectFileName();
pProjFileInfo = CreateSourceFileInfo(strProjFileName,
projectNode, _T(""));
PROJ_MAN_ASSERT(pProjFileInfo);
pProjFileInfo->strIdPath = CE_XML_IDPATH_SEP + strProjNodeId;
SetSourceTime(pProjFileInfo, m_pProjectManager->GetProjectFileNameWithPath());
SourceFileMap_SetAt(strProjFileName, pProjFileInfo, m_mapSourceFiles);
// update targets
UpdateTargets();
Reparse(FALSE);
ExpandFromViewData();
IXMLDOMDocument *pXMLDoc;
m_domDocument.GetIXMLDocument(&pXMLDoc);
m_pProjectManager->Fire_InitInstanceTree((IUnknown*)pXMLDoc);
pXMLDoc->Release();
m_bInit = FALSE;
POSITION pos = m_mapInstanceTargets.GetStartPosition();
while(pos)
{
CString strId;
TInstanceTargetInfo* pInfo;
m_mapInstanceTargets.GetNextAssoc(pos, strId, pInfo);
if (pInfo)
{
CComBSTR sId = pInfo->strTargetId;
CComBSTR sIdPath = pInfo->strIdPath;
m_pProjectManager->Fire_TargetInstanceAdded(sId, sIdPath);
}
}
return TRUE;
}
///////////////////////////////////////////////////////////////
// 功能: 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;
}
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;
}
HRESULT
CIhvProfileBase::LoadXml
(
IN BSTR bstrProfileData
)
{
HRESULT hr = S_OK;
IXMLDOMDocument* pDOMDoc = NULL;
IXMLDOMElement* pDocElem = NULL;
BSTR bstrIhvProfile = NULL;
VARIANT_BOOL vfSuccess;
if ( !bstrProfileData )
{
hr = GetDefaultXml( &bstrIhvProfile );
BAIL_ON_FAILURE( hr );
}
else
{
bstrIhvProfile = bstrProfileData;
}
if ( m_pRootNode )
{
hr = E_UNEXPECTED;
BAIL_ON_FAILURE( hr );
}
hr =
CoCreateInstance
(
CLSID_DOMDocument,
NULL,
CLSCTX_ALL,
IID_IXMLDOMDocument,
(LPVOID *) &pDOMDoc
);
BAIL_ON_FAILURE( hr );
hr =
pDOMDoc->loadXML
(
bstrIhvProfile,
&vfSuccess
);
BAIL_ON_FAILURE( hr );
if ( VARIANT_TRUE != vfSuccess )
{
hr = E_UNEXPECTED;
BAIL_ON_FAILURE( hr );
}
hr =
pDOMDoc->get_documentElement
(
&pDocElem
);
BAIL_ON_FAILURE( hr );
// Caching the pointer to the document element
// in a member variable.
m_pRootNode = pDocElem;
pDocElem = NULL;
error:
if ( !bstrProfileData )
{
SYS_FREE_STRING( bstrIhvProfile );
}
RELEASE_INTERFACE( pDOMDoc );
RELEASE_INTERFACE( pDocElem );
return hr;
}
/******************************************************************
ExecXmlConfig - entry point for XmlConfig Custom Action
*******************************************************************/
extern "C" UINT __stdcall ExecXmlConfig(
__in MSIHANDLE hInstall
)
{
//AssertSz(FALSE, "debug ExecXmlConfig");
HRESULT hr = S_OK;
HRESULT hrOpenFailure = S_OK;
UINT er = ERROR_SUCCESS;
BOOL fIsWow64Process = FALSE;
BOOL fIsFSRedirectDisabled = FALSE;
BOOL fPreserveDate = FALSE;
LPWSTR pwzCustomActionData = NULL;
LPWSTR pwzData = NULL;
LPWSTR pwzFile = NULL;
LPWSTR pwzElementPath = NULL;
LPWSTR pwzVerifyPath = NULL;
LPWSTR pwzName = NULL;
LPWSTR pwzValue = NULL;
LPWSTR pwz = NULL;
int cAdditionalChanges = 0;
IXMLDOMDocument* pixd = NULL;
IXMLDOMNode* pixn = NULL;
IXMLDOMNode* pixnVerify = NULL;
IXMLDOMNode* pixnNewNode = NULL;
IXMLDOMNode* pixnRemovedChild = NULL;
IXMLDOMDocument* pixdNew = NULL;
IXMLDOMElement* pixeNew = NULL;
FILETIME ft;
int id = IDRETRY;
eXmlAction xa;
eXmlPreserveDate xd;
// initialize
hr = WcaInitialize(hInstall, "ExecXmlConfig");
ExitOnFailure(hr, "failed to initialize");
hr = XmlInitialize();
ExitOnFailure(hr, "failed to initialize xml utilities");
hr = WcaGetProperty( L"CustomActionData", &pwzCustomActionData);
ExitOnFailure(hr, "failed to get CustomActionData");
WcaLog(LOGMSG_TRACEONLY, "CustomActionData: %ls", pwzCustomActionData);
pwz = pwzCustomActionData;
hr = WcaReadIntegerFromCaData(&pwz, (int*) &xa);
ExitOnFailure(hr, "failed to process CustomActionData");
// Initialize the Wow64 API - store the result in fWow64APIPresent
// If it fails, this doesn't warrant an error yet, because we only need the Wow64 API in some cases
WcaInitializeWow64();
fIsWow64Process = WcaIsWow64Process();
if (xaOpenFile != xa && xaOpenFilex64 != xa)
{
ExitOnFailure(hr = E_INVALIDARG, "invalid custom action data");
}
// loop through all the passed in data
while (pwz && *pwz)
{
hr = WcaReadStringFromCaData(&pwz, &pwzFile);
ExitOnFailure(hr, "failed to read file name from custom action data");
// Default to not preserve date, preserve it if any modifications require us to
fPreserveDate = FALSE;
// Open the file
ReleaseNullObject(pixd);
if (xaOpenFilex64 == xa)
{
if (!fIsWow64Process)
{
hr = E_NOTIMPL;
ExitOnFailure(hr, "Custom action was told to act on a 64-bit component, but the custom action process is not running in WOW.");
}
hr = WcaDisableWow64FSRedirection();
ExitOnFailure(hr, "Custom action was told to act on a 64-bit component, but was unable to disable filesystem redirection through the Wow64 API.");
fIsFSRedirectDisabled = TRUE;
}
hr = XmlLoadDocumentFromFileEx(pwzFile, XML_LOAD_PRESERVE_WHITESPACE, &pixd);
if (FAILED(hr))
{
// Ignore the return code for now. If they try to add something, we'll fail the install. If all they do is remove stuff then it doesn't matter.
hrOpenFailure = hr;
hr = S_OK;
}
else
{
hrOpenFailure = S_OK;
}
WcaLog(LOGMSG_VERBOSE, "Configuring Xml File: %ls", pwzFile);
while (pwz && *pwz)
{
// If we skip past an element that has additional changes we need to strip them off the stream before
// moving on to the next element. Do that now and then restart the outer loop.
if (cAdditionalChanges > 0)
{
while (cAdditionalChanges > 0)
{
hr = WcaReadStringFromCaData(&pwz, &pwzName);
ExitOnFailure(hr, "failed to process CustomActionData");
hr = WcaReadStringFromCaData(&pwz, &pwzValue);
ExitOnFailure(hr, "failed to process CustomActionData");
cAdditionalChanges--;
}
continue;
}
hr = WcaReadIntegerFromCaData(&pwz, (int*) &xa);
ExitOnFailure(hr, "failed to process CustomActionData");
// Break if we need to move on to a different file
if (xaOpenFile == xa || xaOpenFilex64 == xa)
{
break;
}
hr = WcaReadIntegerFromCaData(&pwz, (int*) &xd);
ExitOnFailure(hr, "failed to process CustomActionData");
if (xdPreserve == xd)
{
fPreserveDate = TRUE;
}
// Get path, name, and value to be written
hr = WcaReadStringFromCaData(&pwz, &pwzElementPath);
ExitOnFailure(hr, "failed to process CustomActionData");
hr = WcaReadStringFromCaData(&pwz, &pwzVerifyPath);
ExitOnFailure(hr, "failed to process CustomActionData");
hr = WcaReadStringFromCaData(&pwz, &pwzName);
ExitOnFailure(hr, "failed to process CustomActionData");
hr = WcaReadStringFromCaData(&pwz, &pwzValue);
ExitOnFailure(hr, "failed to process CustomActionData");
hr = WcaReadIntegerFromCaData(&pwz, &cAdditionalChanges);
ExitOnFailure(hr, "failed to process CustomActionData");
// If we failed to open the file and we're adding something to the file, we've got a problem. Otherwise, just continue on since the file's already gone.
if (FAILED(hrOpenFailure))
{
if (xaCreateElement == xa || xaWriteValue == xa || xaWriteDocument == xa)
{
MessageExitOnFailure1(hr = hrOpenFailure, msierrXmlConfigFailedOpen, "failed to load XML file: %ls", pwzFile);
}
else
{
continue;
}
}
// Select the node we're about to modify
ReleaseNullObject(pixn);
hr = XmlSelectSingleNode(pixd, pwzElementPath, &pixn);
// If we failed to find the node that we are going to add to, we've got a problem. Otherwise, just continue since the node's already gone.
if (S_FALSE == hr)
{
if (xaCreateElement == xa || xaWriteValue == xa || xaWriteDocument == xa)
{
hr = HRESULT_FROM_WIN32(ERROR_OBJECT_NOT_FOUND);
}
else
{
hr = S_OK;
continue;
}
}
MessageExitOnFailure2(hr, msierrXmlConfigFailedSelect, "failed to find node: %ls in XML file: %ls", pwzElementPath, pwzFile);
// Make the modification
switch (xa)
{
case xaWriteValue:
if (pwzName && *pwzName)
{
// We're setting an attribute
hr = XmlSetAttribute(pixn, pwzName, pwzValue);
ExitOnFailure2(hr, "failed to set attribute: %ls to value %ls", pwzName, pwzValue);
}
else
{
// We're setting the text of the node
hr = XmlSetText(pixn, pwzValue);
ExitOnFailure2(hr, "failed to set text to: %ls for element %ls. Make sure that XPath points to an element.", pwzValue, pwzElementPath);
}
break;
case xaWriteDocument:
if (NULL != pwzVerifyPath && 0 != pwzVerifyPath[0])
{
hr = XmlSelectSingleNode(pixn, pwzVerifyPath, &pixnVerify);
if (S_OK == hr)
{
// We found the verify path which means we have no further work to do
continue;
}
ExitOnFailure1(hr, "failed to query verify path: %ls", pwzVerifyPath);
}
hr = XmlLoadDocumentEx(pwzValue, XML_LOAD_PRESERVE_WHITESPACE, &pixdNew);
ExitOnFailure(hr, "Failed to load value as document.");
hr = pixdNew->get_documentElement(&pixeNew);
ExitOnFailure(hr, "Failed to get document element.");
hr = pixn->appendChild(pixeNew, NULL);
ExitOnFailure(hr, "Failed to append document element on to parent element.");
ReleaseNullObject(pixeNew);
ReleaseNullObject(pixdNew);
break;
case xaCreateElement:
if (NULL != pwzVerifyPath && 0 != pwzVerifyPath[0])
{
hr = XmlSelectSingleNode(pixn, pwzVerifyPath, &pixnVerify);
if (S_OK == hr)
{
// We found the verify path which means we have no further work to do
continue;
}
ExitOnFailure1(hr, "failed to query verify path: %ls", pwzVerifyPath);
}
hr = XmlCreateChild(pixn, pwzName, &pixnNewNode);
ExitOnFailure1(hr, "failed to create child element: %ls", pwzName);
if (pwzValue && *pwzValue)
{
hr = XmlSetText(pixnNewNode, pwzValue);
ExitOnFailure2(hr, "failed to set text to: %ls for node: %ls", pwzValue, pwzName);
}
while (cAdditionalChanges > 0)
{
hr = WcaReadStringFromCaData(&pwz, &pwzName);
ExitOnFailure(hr, "failed to process CustomActionData");
hr = WcaReadStringFromCaData(&pwz, &pwzValue);
ExitOnFailure(hr, "failed to process CustomActionData");
// Set the additional attribute
hr = XmlSetAttribute(pixnNewNode, pwzName, pwzValue);
ExitOnFailure2(hr, "failed to set attribute: %ls to value %ls", pwzName, pwzValue);
cAdditionalChanges--;
}
ReleaseNullObject(pixnNewNode);
break;
case xaDeleteValue:
if (pwzName && *pwzName)
{
// Delete the attribute
hr = XmlRemoveAttribute(pixn, pwzName);
ExitOnFailure1(hr, "failed to remove attribute: %ls", pwzName);
}
else
{
// Clear the text value for the node
hr = XmlSetText(pixn, L"");
ExitOnFailure(hr, "failed to clear text value");
}
break;
case xaDeleteElement:
if (NULL != pwzVerifyPath && 0 != pwzVerifyPath[0])
{
hr = XmlSelectSingleNode(pixn, pwzVerifyPath, &pixnVerify);
if (S_OK == hr)
{
hr = pixn->removeChild(pixnVerify, &pixnRemovedChild);
ExitOnFailure(hr, "failed to remove created child element");
ReleaseNullObject(pixnRemovedChild);
}
else
{
WcaLog(LOGMSG_VERBOSE, "Failed to select path %ls for deleting. Skipping...", pwzVerifyPath);
hr = S_OK;
}
}
else
{
// TODO: This requires a VerifyPath to delete an element. Should we support not having one?
WcaLog(LOGMSG_VERBOSE, "No VerifyPath specified for delete element of ID: %ls", pwzElementPath);
}
break;
default:
ExitOnFailure(hr = E_UNEXPECTED, "Invalid modification specified in custom action data");
break;
}
}
// Now that we've made all of the changes to this file, save it and move on to the next
if (S_OK == hrOpenFailure)
{
if (fPreserveDate)
{
hr = FileGetTime(pwzFile, NULL, NULL, &ft);
ExitOnFailure1(hr, "failed to get modified time of file : %ls", pwzFile);
}
int iSaveAttempt = 0;
do
{
hr = XmlSaveDocument(pixd, pwzFile);
if (FAILED(hr))
{
id = WcaErrorMessage(msierrXmlConfigFailedSave, hr, INSTALLMESSAGE_ERROR | MB_ABORTRETRYIGNORE, 1, pwzFile);
switch (id)
{
case IDABORT:
ExitOnFailure1(hr, "Failed to save changes to XML file: %ls", pwzFile);
case IDRETRY:
hr = S_FALSE; // hit me, baby, one more time
break;
case IDIGNORE:
hr = S_OK; // pretend everything is okay and bail
break;
case 0: // No UI case, MsiProcessMessage returns 0
if (STIERR_SHARING_VIOLATION == hr)
{
// Only in case of sharing violation do we retry 30 times, once a second.
if (iSaveAttempt < 30)
{
hr = S_FALSE;
++iSaveAttempt;
WcaLog(LOGMSG_VERBOSE, "Unable to save changes to XML file: %ls, retry attempt: %x", pwzFile, iSaveAttempt);
Sleep(1000);
}
else
{
ExitOnFailure1(hr, "Failed to save changes to XML file: %ls", pwzFile);
}
}
break;
default: // Unknown error
ExitOnFailure1(hr, "Failed to save changes to XML file: %ls", pwzFile);
}
}
} while (S_FALSE == hr);
if (fPreserveDate)
{
hr = FileSetTime(pwzFile, NULL, NULL, &ft);
ExitOnFailure1(hr, "failed to set modified time of file : %ls", pwzFile);
}
if (fIsFSRedirectDisabled)
{
fIsFSRedirectDisabled = FALSE;
WcaRevertWow64FSRedirection();
}
}
}
LExit:
// Make sure we revert FS Redirection if necessary before exiting
if (fIsFSRedirectDisabled)
{
fIsFSRedirectDisabled = FALSE;
WcaRevertWow64FSRedirection();
}
WcaFinalizeWow64();
ReleaseStr(pwzCustomActionData);
ReleaseStr(pwzData);
ReleaseStr(pwzFile);
ReleaseStr(pwzElementPath);
ReleaseStr(pwzVerifyPath);
ReleaseStr(pwzName);
ReleaseStr(pwzValue);
ReleaseObject(pixeNew);
ReleaseObject(pixdNew);
ReleaseObject(pixn);
ReleaseObject(pixd);
ReleaseObject(pixnNewNode);
ReleaseObject(pixnRemovedChild);
XmlUninitialize();
if (FAILED(hr))
{
er = ERROR_INSTALL_FAILURE;
}
return WcaFinalize(er);
}
//--------------------------------------------------------------------------------------
HRESULT CRatingsDB::LoadDB()
{
// Find resource will pick the right ID_GDF_XML_STR based on the current language
HRSRC hrsrc = FindResource( nullptr, MAKEINTRESOURCE(ID_RATINGS_XML), L"DATA" );
if( hrsrc )
{
HGLOBAL hgResource = LoadResource( nullptr, hrsrc );
if( hgResource )
{
BYTE* pResourceBuffer = (BYTE*)LockResource( hgResource );
if( pResourceBuffer )
{
DWORD dwGDFXMLSize = SizeofResource( nullptr, hrsrc );
if( dwGDFXMLSize )
{
// HGLOBAL from LoadResource() needs to be copied for CreateStreamOnHGlobal() to work
HGLOBAL hgResourceCopy = GlobalAlloc( GMEM_MOVEABLE, dwGDFXMLSize );
if( hgResourceCopy )
{
LPVOID pCopy = GlobalLock( hgResourceCopy );
if( pCopy )
{
CopyMemory( pCopy, pResourceBuffer, dwGDFXMLSize );
GlobalUnlock( hgResource );
IStream* piStream = nullptr;
HRESULT hr = CreateStreamOnHGlobal( hgResourceCopy, TRUE, &piStream );
if( SUCCEEDED(hr) && piStream )
{
IXMLDOMDocument *pDoc = nullptr;
// Load the XML into a IXMLDOMDocument object
hr = CoCreateInstance( CLSID_DOMDocument, nullptr, CLSCTX_INPROC_SERVER,
IID_IXMLDOMDocument, (void**)&pDoc );
if( SUCCEEDED(hr) )
{
IPersistStreamInit* pPersistStreamInit = nullptr;
hr = pDoc->QueryInterface( IID_IPersistStreamInit, (void**) &pPersistStreamInit );
if( SUCCEEDED(hr) )
{
hr = pPersistStreamInit->Load( piStream );
if( SUCCEEDED(hr) )
{
// Get the root node to the XML doc and store it
pDoc->QueryInterface( IID_IXMLDOMNode, (void**)&m_pRootNode );
}
SAFE_RELEASE( pPersistStreamInit );
}
SAFE_RELEASE( pDoc );
}
SAFE_RELEASE( piStream );
}
}
GlobalFree( hgResourceCopy );
}
}
}
}
}
if( m_pRootNode )
return S_OK;
else
return E_FAIL;
}
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 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 dynamDOM()
{
HRESULT hr = S_OK;
IXMLDOMDocument *pXMLDom = NULL;
IXMLDOMElement *pRoot = NULL;
IXMLDOMElement *pNode = NULL;
IXMLDOMElement *pSubNode = NULL;
IXMLDOMDocumentFragment *pDF = NULL;
BSTR bstrXML = NULL;
VARIANT varFileName;
VariantInit(&varFileName);
CHK_HR(CreateAndInitDOM(&pXMLDom));
// Create a processing instruction element.
CHK_HR(CreateAndAddPINode(pXMLDom, L"xml", L"version='1.0'"));
// Create a comment element.
CHK_HR(CreateAndAddCommentNode(pXMLDom, L"sample xml file created using XML DOM object."));
// Create the root element.
CHK_HR(CreateElement(pXMLDom, L"root", &pRoot));
// Create an attribute for the <root> element, with name "created" and value "using dom".
CHK_HR(CreateAndAddAttributeNode(pXMLDom, L"created", L"using dom", pRoot));
// Next, we will create and add three nodes to the <root> element.
// Create a <node1> to hold text content.
CHK_HR(CreateAndAddElementNode(pXMLDom, L"node1", L"\n\t", pRoot, &pNode));
CHK_HR(CreateAndAddTextNode(pXMLDom, L"some character data", pNode));
SAFE_RELEASE(pNode);
// Create a <node2> to hold a CDATA section.
CHK_HR(CreateAndAddElementNode(pXMLDom, L"node2", L"\n\t", pRoot, &pNode));
CHK_HR(CreateAndAddCDATANode(pXMLDom, L"<some mark-up text>", pNode));
SAFE_RELEASE(pNode);
// Create <node3> to hold a doc fragment with three sub-elements.
CHK_HR(CreateAndAddElementNode(pXMLDom, L"node3", L"\n\t", pRoot, &pNode));
// Create a document fragment to hold three sub-elements.
CHK_HR(pXMLDom->createDocumentFragment(&pDF));
// Create 3 subnodes.
CHK_HR(CreateAndAddElementNode(pXMLDom, L"subNode1", L"\n\t\t", pDF));
CHK_HR(CreateAndAddElementNode(pXMLDom, L"subNode2", L"\n\t\t", pDF));
CHK_HR(CreateAndAddElementNode(pXMLDom, L"subNode3", L"\n\t\t", pDF));
CHK_HR(CreateAndAddTextNode(pXMLDom, L"\n\t", pDF));
// Append pDF to <node3>.
CHK_HR(AppendChildToParent(pDF, pNode));
SAFE_RELEASE(pNode);
// Add NEWLINE for identation before </root>.
CHK_HR(CreateAndAddTextNode(pXMLDom, L"\n", pRoot));
// add <root> to document
CHK_HR(AppendChildToParent(pRoot, pXMLDom));
CHK_HR(pXMLDom->get_xml(&bstrXML));
wprintf(L"Dynamically created DOM:\n%s\n", bstrXML);
CHK_HR(VariantFromString(L"dynamDOM.xml", varFileName));
CHK_HR(pXMLDom->save(varFileName));
wprintf(L"DOM saved to dynamDOM.xml\n");
CleanUp:
SAFE_RELEASE(pXMLDom);
SAFE_RELEASE(pRoot);
SAFE_RELEASE(pNode);
SAFE_RELEASE(pDF);
SAFE_RELEASE(pSubNode);
SysFreeString(bstrXML);
VariantClear(&varFileName);
}
