// 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;
}
/**
* 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;
}
bool SettingsXML::IsXmlAllowed()
{
IXMLDOMDocument* pFile = CreateDomDocument();
if (pFile)
pFile->Release();
return (pFile != NULL);
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
