bool WPL_PlaylistParser::Parse(std::string p_sContent) { CXMLDocument* pDoc = new CXMLDocument(); if(!pDoc->LoadFromString(p_sContent)) { delete pDoc; return false; } // Parse <head> data CXMLNode* pHead; pHead = pDoc->RootNode()->FindNodeByName("head"); if (!pHead) { delete pDoc; return false; } // parse <body> data CXMLNode* pSeq; pSeq = pDoc->RootNode()->FindNodeByName("body"); if (!pSeq) pSeq = pSeq->FindNodeByName("seq"); if (!pSeq) { delete pDoc; return false; } int children = pSeq->ChildCount(); CXMLNode* child; PlaylistEntry_t* pEntry; for (int i = 0; i < children; ++i) { child = pSeq->ChildNode(i); if(child->Name().compare("media") != 0) { continue; } pEntry = new PlaylistEntry_t(); if(IsURL(child->Value())) { pEntry->sFileName = child->Value(); pEntry->bIsLocalFile = false; } else { pEntry->sFileName = FormatFileName(child->Value()); pEntry->bIsLocalFile = true; } m_lEntries.push_back(pEntry); } if(!m_lEntries.empty()) { m_bEof = false; m_lEntriesIterator = m_lEntries.begin(); } delete pDoc; return true; }
int wmain() { //const TCHAR * pFileName = _T( "AttributeLoad.xml" ); const TCHAR * pFileName = _T( "ElementLoad.xml" ); //const TCHAR * pFileName = _T( "expat_test.vcproj" ); //const TCHAR * pFileName = _T( "vcproj.xml" ); CXMLDocument * pDoc = NULL; { CXMLReader clReader; pDoc = clReader.Load( pFileName ); if( pDoc == NULL ) { ::wprintf( L"Parse error at file: %s, line %lu:\n%s\n", pFileName, clReader.GetErrorLine(), clReader.GetErrorString() ); return 0; } } DumpAllXMLElement( CXMLDocument::GetElement( pDoc->GetRoot(), _T( "Root" ) ) ); { CXMLElement * pElement = CXMLDocument::GetElement( pDoc->GetRoot(), _T( "/Root/Monster" ) ); DumpAllXMLElement( pElement ); CXMLElement * pNotFound = CXMLDocument::GetElement( pDoc->GetRoot(), _T( "/Rootadf/Monster" ) ); if( pNotFound != NULL ) { wprintf( L"Found! Name: %s\n", pNotFound->GetName() ); } const TCHAR * pText = CXMLDocument::GetText( pElement, _T( "Name/" ) ); if( pText != NULL ) { wprintf( L"Name Text: %s\n", pText ); } const TCHAR * pValue = CXMLDocument::GetAttr( pElement, _T( "/Name" ), _T( "Attr" ) ); if( pValue != NULL ) { wprintf( L"Name Attr: %s\n", pValue ); } } return 0; }
CWSDLBinding * CWSDLPort::GetBinding() { if (m_pBinding != NULL) { return m_pBinding; } CXMLDocument *pDoc = GetParentDocument(); if (pDoc != NULL) { CStringW strUri; if (SUCCEEDED(GetNamespaceUri(m_binding.GetPrefix(), strUri))) { if (strUri == pDoc->GetTargetNamespace()) { if (pDoc->GetDocumentType() == WSDLDOC) { CWSDLDocument *pWSDLDoc = static_cast<CWSDLDocument *>(pDoc); m_pBinding = pWSDLDoc->GetBinding(m_binding.GetName()); if (m_pBinding == NULL) { EmitFileError(IDS_SDL_UNRESOLVED_ELEM2, const_cast<CWSDLPort *>(this), 0, "binding", strUri, m_binding.GetName()); } } } else { EmitFileError(IDS_SDL_UNRESOLVED_ELEM2, const_cast<CWSDLPort *>(this), 0, "binding", strUri, m_binding.GetName()); } } else { EmitFileError(IDS_SDL_UNRESOLVED_NAMESPACE, const_cast<CWSDLPort *>(this), 0, m_binding.GetPrefix()); } } return m_pBinding; }
void CXMLDlg::OnLoad() { CWaitCursor Wait; UpdateData(); HRESULT hr = S_OK; HTREEITEM hFirstItem = m_treeOutput.GetChildItem(TVI_ROOT); if (hFirstItem) m_treeOutput.Expand(hFirstItem, TVE_COLLAPSE); m_treeOutput.DeleteAllItems(); CoInitialize(NULL); // Create an empty XML document CXMLDocument* pXMLDoc = new CXMLDocument; hr = pXMLDoc->RegisterCallback(&MyXMLCallback, (LPARAM)this); if (m_strFileName.IsEmpty()) { hr = pXMLDoc->Build(); // load a document from in-memory string. } else { if (m_bStream) hr = pXMLDoc->LoadStream(m_strFileName); else hr = pXMLDoc->Load(m_strFileName, !!m_bAsync); } // Now walk the loaded XML document dumping the name-value pairs pXMLDoc->WalkTree(CString("")); //j // Test persistence of encoded XML doc in memory //j PBYTE pData = NULL; //j ULONG ulLen; //j hr = pXMLDoc->PersistToMemory(&pData, &ulLen); //j hr = pXMLDoc->LoadFromMemory(pData, ulLen); //j delete pData; delete pXMLDoc; CoUninitialize(); }
void CMaterialResource::Load() { m_IsLoaded = true; CXMLDocument document; document.Load( m_FilePath.c_str() ); CXMLNode rootNode = document.GetRootNode(); //Read out shaders CXMLNode childNode = rootNode.GetChildNode( "Shader" ); CXMLAttribute attribute = childNode.GetAttribute( "File" ); std::string shaderPath; shaderPath += "../Content/"; shaderPath += attribute.GetValue(); //Read out defines childNode = rootNode.GetChildNode( "ShaderDefine" ); while ( childNode.IsEmpty() == false ) { attribute = childNode.GetAttribute( "Name" ); const Char* name = attribute.GetValue( "" ); if ( strcmp( name, "" ) != 0 ) { m_ShaderDefines.push_back( name ); } childNode = childNode.GetNextSibling(); } //Build hash Uint hash = HashString( shaderPath.c_str() ); hash += m_ShaderDefines.size(); for ( Uint i = 0; i < m_ShaderDefines.size(); ++i ) { hash += HashString( m_ShaderDefines[i].c_str() ); } CResource* shaderResource; if ( ( shaderResource = CResourceManager::GetInstance()->GetResourceByHash( hash ) ) == NULL ) { shaderResource = CResourceManager::GetInstance()->AddShaderResource( shaderPath.c_str(), hash, m_ShaderDefines ); } m_ShaderResource = (CShaderResource*)shaderResource; m_Shader = m_ShaderResource->GetShader(); //Read terms childNode = rootNode.GetChildNode( "Terms" ); //Emmisive CXMLNode termNode = childNode.GetChildNode( "Emissive" ); attribute = termNode.GetAttribute( "R" ); m_EmissiveTerm.X = (Float)atof( attribute.GetValue() ); attribute = termNode.GetAttribute( "G" ); m_EmissiveTerm.Y = (Float)atof( attribute.GetValue() ); attribute = termNode.GetAttribute( "B" ); m_EmissiveTerm.Z = (Float)atof( attribute.GetValue() ); //Diffuse termNode = childNode.GetChildNode( "Diffuse" ); attribute = termNode.GetAttribute( "R" ); m_DiffuseTerm.X = (Float)atof( attribute.GetValue() ); attribute = termNode.GetAttribute( "G" ); m_DiffuseTerm.Y = (Float)atof( attribute.GetValue() ); attribute = termNode.GetAttribute( "B" ); m_DiffuseTerm.Z = (Float)atof( attribute.GetValue() ); //Specular termNode = childNode.GetChildNode( "Specular" ); attribute = termNode.GetAttribute( "R" ); m_SpecularTerm.X = (Float)atof( attribute.GetValue() ); attribute = termNode.GetAttribute( "G" ); m_SpecularTerm.Y = (Float)atof( attribute.GetValue() ); attribute = termNode.GetAttribute( "B" ); m_SpecularTerm.Z = (Float)atof( attribute.GetValue() ); //Ambient termNode = childNode.GetChildNode( "Ambient" ); attribute = termNode.GetAttribute( "R" ); m_AmbientTerm.X = (Float)atof( attribute.GetValue() ); attribute = termNode.GetAttribute( "G" ); m_AmbientTerm.Y = (Float)atof( attribute.GetValue() ); attribute = termNode.GetAttribute( "B" ); m_AmbientTerm.Z = (Float)atof( attribute.GetValue() ); //Specular power termNode = childNode.GetChildNode( "SpecularPower" ); if ( termNode.IsEmpty() == false ) { attribute = termNode.GetAttribute( "Value" ); m_SpecularPower = (Float)atof( attribute.GetValue( "1.0f" ) ); } termNode = childNode.GetChildNode( "Reflection" ); if ( termNode.IsEmpty() == false ) { attribute = termNode.GetAttribute( "Value" ); m_Reflection = (Float)atof( attribute.GetValue( "0.0f" ) ); } termNode = childNode.GetChildNode( "Refraction" ); if ( termNode.IsEmpty() == false ) { attribute = termNode.GetAttribute( "Value" ); m_Refraction = (Float)atof( attribute.GetValue( "0.0f" ) ); } termNode = childNode.GetChildNode( "Transmittance" ); if ( termNode.IsEmpty() == false ) { attribute = termNode.GetAttribute( "Value" ); m_Transmittance = (Float)atof( attribute.GetValue( "0.0f" ) ); } termNode = childNode.GetChildNode( "FresnelPower" ); if ( termNode.IsEmpty() == false ) { attribute = termNode.GetAttribute( "Value" ); m_FresnelValues.X = (Float)atof( attribute.GetValue( "1.0f" ) ); } termNode = childNode.GetChildNode( "FresnelScale" ); if ( termNode.IsEmpty() == false ) { attribute = termNode.GetAttribute( "Value" ); m_FresnelValues.Y = (Float)atof( attribute.GetValue( "1.0f" ) ); } termNode = childNode.GetChildNode( "FresnelBias" ); if ( termNode.IsEmpty() == false ) { attribute = termNode.GetAttribute( "Value" ); m_FresnelValues.Z = (Float)atof( attribute.GetValue( "0.0f" ) ); } termNode = childNode.GetChildNode( "TextureWeight" ); if ( termNode.IsEmpty() == false ) { attribute = termNode.GetAttribute( "Value" ); m_TextureWeight = (Float)atof( attribute.GetValue( "0.0f" ) ); } termNode = childNode.GetChildNode( "ParallaxScale" ); if ( termNode.IsEmpty() == false ) { attribute = termNode.GetAttribute( "Value" ); m_ParallaxScale = (Float)atof( attribute.GetValue( "0.0f" ) ); } termNode = childNode.GetChildNode( "ParallaxBias" ); if ( termNode.IsEmpty() == false ) { attribute = termNode.GetAttribute( "Value" ); m_ParallaxBias = (Float)atof( attribute.GetValue( "0.0f" ) ); } termNode = childNode.GetChildNode( "RefractiveIndices" ); if ( termNode.IsEmpty() == false ) { attribute = termNode.GetAttribute( "R" ); m_RefractiveIndices.X = (Float)atof( attribute.GetValue( "1.0f" ) ); attribute = termNode.GetAttribute( "G" ); m_RefractiveIndices.Y = (Float)atof( attribute.GetValue( "1.0f" ) ); attribute = termNode.GetAttribute( "B" ); m_RefractiveIndices.Z = (Float)atof( attribute.GetValue( "1.0f" ) ); } //Read out textures childNode = rootNode.GetChildNode( "Texture2D" ); while ( childNode.IsEmpty() == false ) { attribute = childNode.GetAttribute( "Name" ); const Char* name = attribute.GetValue(); attribute = childNode.GetAttribute( "Hash" ); const Uint hash = (Uint)strtoul( attribute.GetValue(), NULL, 0 ); //Check if the resource already exists and is loaded CResource* resource = m_DependentResources.find( hash )->second; Uint textureID = 0; if ( resource != NULL ) { CTextureResource* textureResource = (CTextureResource*)resource; if ( textureResource->IsLoaded() ) { textureID = textureResource->GetTextureID(); } } attribute = childNode.GetAttribute( "Type" ); const Char* type = attribute.GetValue(); attribute = childNode.GetAttribute( "UVChannel" ); const Uint uvChannel = atoi( attribute.GetValue() ); attribute = childNode.GetAttribute( "Mapping" ); const Char* mapping = attribute.GetValue(); CXMLNode mapNode = childNode.GetChildNode( "MapMode" ); attribute = mapNode.GetAttribute( "X" ); const Char* mapModeX = attribute.GetValue(); attribute = mapNode.GetAttribute( "Y" ); const Char* mapModeY = attribute.GetValue(); TextureMapMode mapModes[2]; mapModes[0] = (TextureMapMode)ConvertMapMode( mapModeX ); mapModes[1] = (TextureMapMode)ConvertMapMode( mapModeY ); CTexture2D* texture = new CTexture2D( name, hash, (TextureMapping)ConvertMapping( mapping ), mapModes, (TextureMapType)ConvertTextureType( type ), uvChannel, textureID ); m_2DTextures.push_back( texture ); childNode = childNode.GetNextSibling(); } childNode = rootNode.GetChildNode( "TextureCube" ); while ( childNode.IsEmpty() == false ) { attribute = childNode.GetAttribute( "FileBase" ); const Char* fileBase = attribute.GetValue(); attribute = childNode.GetAttribute( "UniformName" ); const Char* uniformName = attribute.GetValue(); attribute = childNode.GetAttribute( "Extension" ); const Char* extension = attribute.GetValue(); CTextureCube* texture = new CTextureCube( fileBase, uniformName, extension ); m_3DTextures.push_back( texture ); childNode = childNode.GetNextSibling(); } }
BOOL CInstanceTree::UpdateTargets() { // only do update if something has changed in the target view if (!(m_pProjectManager->GetTargetTree())->m_bTargetTreeChanged) { return TRUE; } BOOL ret; CXMLDocument tTargetDoc; TStringList listNewTargets; CXMLNode nodeTargetRoot; CXMLNode nodeInstanceRoot; // update lists TStringList listUpdateChanged; TStringList listUpdateNew; TStringList listUpdateDeleted; (m_pProjectManager->GetTargetTree())->m_bTargetTreeChanged = FALSE; // get instance tree root node if (!m_domDocument.GetRootNode(nodeInstanceRoot)) { return FALSE; } // get root node of target view IUnknown* pTmp = NULL; HRESULT hr = m_pProjectManager->GetTargetViewDOM(&pTmp); if(hr != S_OK) { return FALSE; } tTargetDoc.SetIXMLDocument(pTmp); pTmp->Release(); // add target nodes as children if(!tTargetDoc.GetRootNode(nodeTargetRoot)) { return FALSE; } // get new targets from target view if (!GetTargetsFromTargetTree(listNewTargets)) { return FALSE; } // empty xml tree nodeInstanceRoot.RemoveAllChilds(); // mark all nodes not used: POSITION posH = m_mapInstanceTargets.GetStartPosition(); while(posH) { CString strId; TInstanceTargetInfo* pInfo; m_mapInstanceTargets.GetNextAssoc(posH, strId, pInfo); if (pInfo) { pInfo->bUsed = FALSE; } } // look at all new targets, hang targets into the tree: // test if target is a new target or the attributes have changed or it is the same // in the last two cases, take the old node and only change attributes if necessary POSITION posNewTargets = listNewTargets.GetHeadPosition(); while(posNewTargets) { CXMLNode nodeTarget; CXMLNode nodeInstance; CXMLNode nodeLink; // attributes of the target node CString strTText; // node text CString strTId; // node id CString strTType; // node type (KAD type) CString strTAddress; // connect info CString strTUserAddress; // user connect info CString strTConsoleAddress; // console address CString strTAssignedResource; // assigned resource CString strTSource; // source file for add on action CString strParseSource; // parser source help var CString strParseSourceNew; // parser source CString strInstType; // type of the instance node CString strIdPathTarg; // id path of target node in target tree CString strIdPathInst; // id path of target instance in instance tree CString strTargetId; CString strWaitForTarget; strIdPathTarg = listNewTargets.GetNext(posNewTargets); strTargetId = strIdPathTarg; int iFind = strTargetId.ReverseFind(CE_XML_IDPATH_SEP_CHAR); ASSERT(iFind>0); if (iFind>0) { strTargetId = strTargetId.Mid(iFind+1); } // get target node ret = nodeTargetRoot.GetNodeFromIdPath(strIdPathTarg, nodeTarget); ASSERT(ret); if (!ret) { continue; } // get attributes of the target node nodeTarget.GetAttribute(CE_XMLATTR_TEXT, strTText); nodeTarget.GetAttribute(CE_XMLATTR_ID, strTId); nodeTarget.GetAttribute(CE_XMLATTR_TYPE, strTType); nodeTarget.GetAttribute(CE_XMLATTR_ADDR, strTAddress); nodeTarget.GetAttribute(CE_XMLATTR_USERADDR, strTUserAddress); nodeTarget.GetAttribute(CE_XMLATTR_CONSOLE_ADDR, strTConsoleAddress); nodeTarget.GetAttribute(CE_XMLATTR_RESOURCE, strTAssignedResource); nodeTarget.GetAttribute(CE_XMLATTR_SOURCE, strTSource); nodeTarget.GetAttribute(CE_XMLATTR_WAIT_TARGET_CONN , strWaitForTarget); strInstType = strTType + CE_XML_INST_ADD; strParseSource = strTId + _T(".") + CE_INSTANCE_EXT; strParseSourceNew = CString(CE_GEN_PATH) + _T("\\") + strTId + _T("\\") + strParseSource; // does node already exist in instance tree: TInstanceTargetInfo* pInstTargetInfo = NULL; CString strLowerId = strTargetId; strLowerId.MakeLower(); if (m_mapInstanceTargets.Lookup(strLowerId, pInstTargetInfo)) { // *** existing node *** ASSERT(pInstTargetInfo); pInstTargetInfo->bUsed = TRUE; nodeInstance = pInstTargetInfo->xmlNode; ret = nodeInstanceRoot.AppendChild(nodeInstance, TRUE); ASSERT(ret); // check if attributes have changed // get instance node attributes CString strInstText; CString strInstId; //CString strInstType; CString strInstAddress; CString strInstUserAddress; CString strInstConsoleAddress; CString strInstAssignedResource; CString strInstSource; nodeInstance.GetAttribute(CE_XMLATTR_TEXT, strInstText); nodeInstance.GetAttribute(CE_XMLATTR_ID, strInstId); //nodeInstance.GetAttribute(CE_XMLATTR_TYPE, strInstType); // type can't change nodeInstance.GetAttribute(CE_XMLATTR_ADDR, strInstAddress); nodeInstance.GetAttribute(CE_XMLATTR_USERADDR, strInstUserAddress); nodeInstance.GetAttribute(CE_XMLATTR_CONSOLE_ADDR, strInstConsoleAddress); nodeInstance.GetAttribute(CE_XMLATTR_RESOURCE, strInstAssignedResource); nodeInstance.GetAttribute(CE_XMLATTR_SOURCE, strInstSource); if ((strInstText.CompareNoCase(strTText)!=0) || (strInstId.CompareNoCase(strTId)!=0) //|| (strInstType.CompareNoCase(strType)!=0) || (strInstAddress.CompareNoCase(strTAddress)!=0) || (strInstConsoleAddress.CompareNoCase(strTConsoleAddress)!=0) || (strInstAssignedResource.CompareNoCase(strTAssignedResource)!=0) || (strInstSource.CompareNoCase(strTSource) != 0)) { // node has changed -> update nodes nodeInstance.SetAttribute(CE_XMLATTR_TEXT, strTText); nodeInstance.SetAttribute(CE_XMLATTR_ID, strTId); //nodeInstance.SetAttribute(CE_XMLATTR_TYPE, strType); nodeInstance.SetAttribute(CE_XMLATTR_ADDR, strTAddress); nodeInstance.SetAttribute(CE_XMLATTR_USERADDR, strTUserAddress); nodeInstance.SetAttribute(CE_XMLATTR_CONSOLE_ADDR, strTConsoleAddress); nodeInstance.SetAttribute(CE_XMLATTR_RESOURCE, strTAssignedResource); nodeInstance.SetAttribute(CE_XMLATTR_SOURCE, strTSource); listUpdateChanged.AddTail(pInstTargetInfo->strIdPath); } } else // *** new node *** { if(!m_domDocument.CreateNode(nodeInstance, CE_XMLTAG_NODE)) { continue; } // set attributes of target instance node nodeInstance.SetAttribute(CE_XMLATTR_TEXT, strTText); nodeInstance.SetAttribute(CE_XMLATTR_ID, strTId); nodeInstance.SetAttribute(CE_XMLATTR_ADDR, strTAddress); nodeInstance.SetAttribute(CE_XMLATTR_USERADDR, strTUserAddress); nodeInstance.SetAttribute(CE_XMLATTR_CONSOLE_ADDR, strTConsoleAddress); nodeInstance.SetAttribute(CE_XMLATTR_RESOURCE, strTAssignedResource); nodeInstance.SetAttribute(CE_XMLATTR_TARGET_TYPE, strTType); nodeInstance.SetAttribute(CE_XMLATTR_SOURCE, strTSource); nodeInstance.SetAttribute(CE_XMLATTR_TYPE, strInstType); if (!strWaitForTarget.IsEmpty()) { nodeInstance.SetAttribute(CE_XMLATTR_WAIT_TARGET_CONN, strWaitForTarget); } // create new instance info struct ASSERT(pInstTargetInfo==NULL); pInstTargetInfo = new TInstanceTargetInfo; ASSERT(pInstTargetInfo); if (!pInstTargetInfo) { continue; } ret = nodeInstanceRoot.AppendChild(nodeInstance, TRUE); ASSERT(ret); nodeInstance.GetIdPath(strIdPathInst); pInstTargetInfo->strIdPath = strIdPathInst; pInstTargetInfo->strTargetId = strTId; pInstTargetInfo->xmlNode = nodeInstance; pInstTargetInfo->bUsed = TRUE; strLowerId = strTId; strLowerId.MakeLower(); m_mapInstanceTargets.SetAt(strLowerId, pInstTargetInfo); // add to update list (new node) listUpdateNew.AddTail(strIdPathInst); // now create target link node: the link that will be replaced by compiler outpu if((!m_domDocument.CreateNode(nodeLink, CE_XMLTAG_LINK)) ||(!nodeInstance.AppendChild(nodeLink)) ) { continue; } nodeLink.SetAttribute(CE_XMLATTR_PARSERSOURCE, strParseSourceNew); nodeLink.SetAttribute(CE_XMLATTR_ID, strTId); TSourceFileInfo* pFileInfo; pFileInfo = CreateSourceFileInfo(strParseSourceNew, nodeLink, ""); SourceFileMap_SetAt(strParseSourceNew, pFileInfo, m_mapSourceFiles); AddSourceFileToReparse(strParseSourceNew); } } // find deleted nodes: posH = m_mapInstanceTargets.GetStartPosition(); while(posH) { CString strId; TInstanceTargetInfo* pInfo; m_mapInstanceTargets.GetNextAssoc(posH, strId, pInfo); if (pInfo) { if (pInfo->bUsed == FALSE) { listUpdateDeleted.AddTail(pInfo->strIdPath); delete pInfo; m_mapInstanceTargets.RemoveKey(strId); } } } if (m_bInit) { return TRUE; } // send update messages POSITION lPos; lPos = listUpdateDeleted.GetHeadPosition(); while(lPos) { CString strIdPath = listUpdateDeleted.GetNext(lPos); if (!strIdPath.IsEmpty()) { FireUpdateTree(strIdPath, eUpdateDelete); CString strId = strIdPath; int iFind = strId.ReverseFind(CE_XML_IDPATH_SEP_CHAR); ASSERT(iFind>0); if (iFind>0) { strId = strId.Mid(iFind+1); } CComBSTR sId = strId; m_pProjectManager->Fire_TargetInstanceRemoved(sId); } } lPos = listUpdateChanged.GetHeadPosition(); while(lPos) { CString strIdPath = listUpdateChanged.GetNext(lPos); if (!strIdPath.IsEmpty()) { FireUpdateTree(strIdPath, eUpdateAttributes); CString strId = strIdPath; int iFind = strId.ReverseFind(CE_XML_IDPATH_SEP_CHAR); ASSERT(iFind>0); if (iFind>0) { strId = strId.Mid(iFind+1); } CComBSTR sId = strId; CComBSTR sIdPath = strIdPath; m_pProjectManager->Fire_TargetInstanceAdded(sId, sIdPath); } } lPos = listUpdateNew.GetHeadPosition(); while(lPos) { CString strIdPath = listUpdateNew.GetNext(lPos); if (!strIdPath.IsEmpty()) { FireUpdateTree(strIdPath, eUpdateInsert); CString strId = strIdPath; int iFind = strId.ReverseFind(CE_XML_IDPATH_SEP_CHAR); ASSERT(iFind>0); if (iFind>0) { strId = strId.Mid(iFind+1); } CComBSTR sId = strId; CComBSTR sIdPath = strIdPath; m_pProjectManager->Fire_TargetInstanceAdded(sId, sIdPath); } } Reparse(FALSE); return TRUE; }
// 15.12.05 SIS >> // added parameter crstrIndex // to save index range bool CCeWatchElement::SaveToNode(CXMLNode& rtNode, CXMLDocument& rtDocument, const CString& crstrIndexRange) // 15.12.05 SIS << { bool bReturn = true; // don't forget to increment the version string if you change anything here CString str; if(m_bInitExpanded) { rtNode.SetAttribute(CEWATCH_XMLATTR_EXPANDED, _T("1")); } CString strExpression = m_Name; if(!crstrIndexRange.IsEmpty()) { strExpression.Format(_T("%s, %s"), m_Name, crstrIndexRange); } rtNode.SetAttribute(CEWATCH_XMLATTR_EXPRESSION, strExpression); if (m_Type.GetName().GetLength() > 0) { str.Format("%s;%d", m_Type.GetName(), (int)m_Type.GetVarKind()); rtNode.SetAttribute(CEWATCH_XMLATTR_TYPE, str); } rtNode.SetAttribute(CEWATCH_XMLATTR_VALUE, m_strValue); if (m_strFormat.GetLength() > 0) { rtNode.SetAttribute(CEWATCH_XMLATTR_FORMAT, m_strFormat); } // #2149 10.10.06 SIS >> // only save visible array elements int iNumChildren = GetChildrenCount(); int iChildStart = 0; int iChildStop = iNumChildren-1; if(m_Type.IsArray()) { VERIFY(ExtractArrayIndices(crstrIndexRange, iChildStart, iChildStop)); iChildStart = max(iChildStart - m_Type.GetArrayLowerBound(), 0); iChildStop = min(iChildStop - m_Type.GetArrayLowerBound(), iNumChildren-1); } CCeWatchElement* pElem = NULL; for (int iChild = iChildStart; iChild <= iChildStop; iChild++) // #2149 10.10.06 SIS << { CXMLNode tNodeChild; if(rtDocument.CreateNode(tNodeChild, CEWATCH_XMLTAG_VARNODE)) { pElem = GetChild(iChild); if(!pElem) { break; } bReturn &= pElem->SaveToNode(tNodeChild, rtDocument, _T("")); if(!bReturn) { break; } rtNode.AppendChild(tNodeChild); } } return bReturn; }
void CMapReader::Generate(CGenInfo *pInfo) { m_OverallBenchmark.Unpause(); // create folders char aGeneratedFolder[256]; sprintf(aGeneratedFolder, "%sgenerated/%s", pInfo->m_aCurrentDir, pInfo->m_aMap); char aGeneratedMapresFolder[256]; sprintf(aGeneratedMapresFolder, "%s/mapres", aGeneratedFolder); MakeDir(aGeneratedFolder); MakeDir(aGeneratedMapresFolder); // check map version CMapItemVersion *pVersion = (CMapItemVersion *)m_Reader.FindItem(MAPITEMTYPE_VERSION, 0); if(!pVersion || pVersion->m_Version != 1) return; // create generating file char aGenerating[256]; sprintf(aGenerating, "%s/generating", aGeneratedFolder); FILE *pGeneratingFile = fopen(aGenerating, "wb"); if(pGeneratingFile) fclose(pGeneratingFile); // load images m_ImagesBenchmark.Unpause(); int ImagesStart; int ImagesNum; m_Reader.GetType(MAPITEMTYPE_IMAGE, &ImagesStart, &ImagesNum); CMapItemImage *pImages = NULL; if(ImagesNum > 0) { pImages = new CMapItemImage[ImagesNum]; for(int i = ImagesStart; i < ImagesStart+ImagesNum; i++) { CMapItemImage *pImage = (CMapItemImage *)m_Reader.GetItem(i, NULL, NULL); if(!pImage->m_External && pInfo->m_DumpEmbedded) { const char *pName = (char *)m_Reader.GetData(pImage->m_ImageName); unsigned char *pData = (unsigned char *)m_Reader.GetData(pImage->m_ImageData); char aImageFilename[512]; sprintf(aImageFilename, "%s/%s.png", aGeneratedMapresFolder, pName); CImageWrite Image; Image.Open(aImageFilename, pImage->m_Width, pImage->m_Height); Image.SetPixels(pData); Image.Save(); } pImages[i-ImagesStart] = *pImage; } } m_ImagesBenchmark.Pause(); // load groups and layers int GroupsStart; int GroupsNum; m_Reader.GetType(MAPITEMTYPE_GROUP, &GroupsStart, &GroupsNum); int LayersStart; int LayersNum; m_Reader.GetType(MAPITEMTYPE_LAYER, &LayersStart, &LayersNum); for(int g = GroupsStart; g < GroupsStart+GroupsNum; g++) { CMapItemGroup *pGroup = (CMapItemGroup *)m_Reader.GetItem(g, NULL, NULL); if(pGroup->m_Version < 1 || pGroup->m_Version > 2) continue; for(int l = LayersStart + pGroup->m_StartLayer; l < LayersStart + pGroup->m_StartLayer+pGroup->m_NumLayers; l++) { if(l >= LayersStart+LayersNum) break; CMapItemLayer *pLayer = (CMapItemLayer *)m_Reader.GetItem(l, NULL, NULL); if(pLayer->m_Type == LAYERTYPE_TILES) { m_TilemapsBenchmark.Unpause(); CMapItemLayerTilemap *pTilesLayer = (CMapItemLayerTilemap *)pLayer; bool GameLayer = (pTilesLayer->m_Flags & TILESLAYERFLAG_GAME) ? true : false; if((GameLayer && !pInfo->m_DumpGameTilemap) || (!GameLayer && !pInfo->m_DumpTilemaps)) continue; if(!GameLayer && pTilesLayer->m_Image < 0) continue; CMapItemImage *pImage = NULL; if(!GameLayer) pImage = &pImages[pTilesLayer->m_Image]; const char *pTilesetName; if(GameLayer) pTilesetName = pInfo->m_aEntities; else pTilesetName = (char *)m_Reader.GetData(pImage->m_ImageName); CTileset Src; if(GameLayer || pImage->m_External) { char aTilesetFilename[512]; sprintf(aTilesetFilename, "%smapres/%s.png", pInfo->m_aCurrentDir, pTilesetName); bool Success = Src.Open(aTilesetFilename); if(!Success) continue; } else { bool Success = Src.OpenFromBuffer((unsigned char *)m_Reader.GetData(pImage->m_ImageData), pImage->m_Width, pImage->m_Height); if(!Success) continue; } char aTilemapFilename[512]; if(GameLayer) sprintf(aTilemapFilename, "%s/tiles_game_%d.png", aGeneratedFolder, pTilesLayer->m_Data); else sprintf(aTilemapFilename, "%s/tiles_%d.png", aGeneratedFolder, pTilesLayer->m_Data); CTilemap Dest; bool Success = Dest.Open(aTilemapFilename, pTilesLayer->m_Width, pTilesLayer->m_Height, &Src, pInfo->m_TileSize); if(!Success) continue; CTile *pTilesData = (CTile *)m_Reader.GetData(pTilesLayer->m_Data); for(int x = 0; x < pTilesLayer->m_Width; x++) { for(int y = 0; y < pTilesLayer->m_Height; y++) { CTile *pTile = &pTilesData[y*pTilesLayer->m_Width + x]; if(pTile->m_Index == 0) continue; Dest.SetTile(x, y, pTile->m_Index, pTile->m_Flags); } } Dest.Colorize(&pTilesLayer->m_Color); Dest.Save(); Src.Close(); m_TilemapsBenchmark.Pause(); } else if(pLayer->m_Type == LAYERTYPE_QUADS) { m_QuadsBenchmark.Unpause(); CMapItemLayerQuads *pQuadsLayer = (CMapItemLayerQuads *)pLayer; if(!pInfo->m_DumpQuads) continue; CImageRead Src; CMapItemImage *pImage = NULL; if(pQuadsLayer->m_Image >= 0) pImage = &pImages[pQuadsLayer->m_Image]; if(pQuadsLayer->m_Image >= 0) { const char *pImageName = (char *)m_Reader.GetData(pImage->m_ImageName); if(pImage->m_External) { char aImageFilename[512]; sprintf(aImageFilename, "%smapres/%s.png", pInfo->m_aCurrentDir, pImageName); bool Success = Src.Open(aImageFilename); if(!Success) continue; } else { bool Success = Src.OpenFromBuffer((unsigned char *)m_Reader.GetData(pImage->m_ImageData), pImage->m_Width, pImage->m_Height); if(!Success) continue; } } CQuad *pQuadsData = (CQuad *)m_Reader.GetData(pQuadsLayer->m_Data); for(int q = 0; q < pQuadsLayer->m_NumQuads; q++) { CQuad *pQuad = &pQuadsData[q]; int MinX = min(min(min(pQuad->m_aPoints[0].x, pQuad->m_aPoints[1].x), pQuad->m_aPoints[2].x), pQuad->m_aPoints[3].x) / 1024; int MinY = min(min(min(pQuad->m_aPoints[0].y, pQuad->m_aPoints[1].y), pQuad->m_aPoints[2].y), pQuad->m_aPoints[3].y) / 1024; int MaxX = max(max(max(pQuad->m_aPoints[0].x, pQuad->m_aPoints[1].x), pQuad->m_aPoints[2].x), pQuad->m_aPoints[3].x) / 1024; int MaxY = max(max(max(pQuad->m_aPoints[0].y, pQuad->m_aPoints[1].y), pQuad->m_aPoints[2].y), pQuad->m_aPoints[3].y) / 1024; int Width = MaxX-MinX; int Height = MaxY-MinY; if(Width <= 0 || Height <= 0) continue; char aQuadsFilename[512]; sprintf(aQuadsFilename, "%s/quads_%d_%d.png", aGeneratedFolder, pQuadsLayer->m_Data, q); CQuads Dest; bool Success = Dest.Open(aQuadsFilename, Width, Height, pInfo->m_TileSize); if(!Success) continue; if(pQuadsLayer->m_Image < 0) Dest.FillWhite(); else Dest.DrawImage(&Src); Dest.DrawGradient(pQuad->m_aColors); Dest.Save(); } m_QuadsBenchmark.Pause(); } } } // dump metadata if(pInfo->m_DumpMetadata) { m_MetadataBenchmark.Unpause(); CXMLDocument Doc; CXMLItem *pMainItem = Doc.Open("map"); pMainItem->AddAttributeInt("version", pVersion->m_Version); for(int i = 0; i < ImagesNum; i++) { const char *pName = (char *)m_Reader.GetData(pImages[i].m_ImageName); CXMLItem *pImageItem = pMainItem->AddChild("image"); pImageItem->AddAttributeInt("version", pImages[i].m_Version); pImageItem->AddAttributeInt("width", pImages[i].m_Width); pImageItem->AddAttributeInt("height", pImages[i].m_Height); pImageItem->AddAttributeBool("external", pImages[i].m_External); pImageItem->AddAttributeStr("name", pName); } for(int g = GroupsStart; g < GroupsStart+GroupsNum; g++) { CMapItemGroup *pGroup = (CMapItemGroup *)m_Reader.GetItem(g, NULL, NULL); CXMLItem *pGroupItem = pMainItem->AddChild("group"); pGroupItem->AddAttributeInt("version", pGroup->m_Version); pGroupItem->AddAttributeInt("offset_x", pGroup->m_OffsetX); pGroupItem->AddAttributeInt("offset_y", pGroup->m_OffsetY); pGroupItem->AddAttributeInt("parallax_x", pGroup->m_ParallaxX); pGroupItem->AddAttributeInt("parallax_y", pGroup->m_ParallaxY); if(pGroup->m_Version >= 2) { pGroupItem->AddAttributeBool("use_clipping", pGroup->m_UseClipping); pGroupItem->AddAttributeInt("clip_x", pGroup->m_ClipX); pGroupItem->AddAttributeInt("clip_y", pGroup->m_ClipY); pGroupItem->AddAttributeInt("clip_w", pGroup->m_ClipW); pGroupItem->AddAttributeInt("clip_h", pGroup->m_ClipH); } for(int l = LayersStart + pGroup->m_StartLayer; l < LayersStart + pGroup->m_StartLayer+pGroup->m_NumLayers; l++) { if(l >= LayersStart+LayersNum) break; CMapItemLayer *pLayer = (CMapItemLayer *)m_Reader.GetItem(l, NULL, NULL); CXMLItem *pLayerItem = pGroupItem->AddChild("layer"); if(pLayer->m_Type == LAYERTYPE_TILES) pLayerItem->AddAttributeStr("type", "tiles"); else if(pLayer->m_Type == LAYERTYPE_QUADS) pLayerItem->AddAttributeStr("type", "quads"); else pLayerItem->AddAttributeStr("type", "invalid"); pLayerItem->AddAttributeBool("detail", pLayer->m_Flags&TILESLAYERFLAG_GAME); if(pLayer->m_Type == LAYERTYPE_TILES) { CMapItemLayerTilemap *pTilesLayer = (CMapItemLayerTilemap *)pLayer; const char *pImageName = ""; if(pTilesLayer->m_Image >= 0 && pTilesLayer->m_Image < ImagesNum) pImageName = (char *)m_Reader.GetData(pImages[pTilesLayer->m_Image].m_ImageName); pLayerItem->AddAttributeInt("version", pTilesLayer->m_Version); pLayerItem->AddAttributeInt("width", pTilesLayer->m_Width); pLayerItem->AddAttributeInt("height", pTilesLayer->m_Height); pLayerItem->AddAttributeBool("game", pTilesLayer->m_Flags&TILESLAYERFLAG_GAME); pLayerItem->AddAttributeInt("color_env", pTilesLayer->m_ColorEnv); pLayerItem->AddAttributeInt("color_env_offset", pTilesLayer->m_ColorEnvOffset); pLayerItem->AddAttributeStr("image", pImageName); pLayerItem->AddAttributeInt("data", pTilesLayer->m_Data); CXMLItem *pColorItem = pLayerItem->AddChild("color"); pColorItem->AddAttributeInt("r", pTilesLayer->m_Color.r); pColorItem->AddAttributeInt("g", pTilesLayer->m_Color.g); pColorItem->AddAttributeInt("b", pTilesLayer->m_Color.b); pColorItem->AddAttributeInt("a", pTilesLayer->m_Color.a); } else if(pLayer->m_Type == LAYERTYPE_QUADS) { CMapItemLayerQuads *pQuadsLayer = (CMapItemLayerQuads *)pLayer; const char *pImageName = ""; if(pQuadsLayer->m_Image >= 0 && pQuadsLayer->m_Image < ImagesNum) pImageName = (char *)m_Reader.GetData(pImages[pQuadsLayer->m_Image].m_ImageName); pLayerItem->AddAttributeInt("version", pQuadsLayer->m_Version); pLayerItem->AddAttributeStr("image", pImageName); pLayerItem->AddAttributeInt("data", pQuadsLayer->m_Data); CQuad *pQuadsData = (CQuad *)m_Reader.GetData(pQuadsLayer->m_Data); for(int q = 0; q < pQuadsLayer->m_NumQuads; q++) { CQuad *pQuad = &pQuadsData[q]; CXMLItem *pQuadItem = pLayerItem->AddChild("quad"); pQuadItem->AddAttributeInt("pos_env", pQuad->m_PosEnv); pQuadItem->AddAttributeInt("pos_env_offset", pQuad->m_PosEnvOffset); pQuadItem->AddAttributeInt("color_env", pQuad->m_ColorEnv); pQuadItem->AddAttributeInt("color_env_offset", pQuad->m_ColorEnvOffset); pQuadItem->AddAttributeInt("data", q); for(int k = 0; k < 5; k++) { CXMLItem *pPointItem = pQuadItem->AddChild("point"); pPointItem->AddAttributeInt("x", fx2f(pQuad->m_aPoints[k].x)); pPointItem->AddAttributeInt("y", fx2f(pQuad->m_aPoints[k].y)); } for(int k = 0; k < 4; k++) { CXMLItem *pColorItem = pQuadItem->AddChild("color"); pColorItem->AddAttributeInt("r", pQuad->m_aColors[k].r); pColorItem->AddAttributeInt("g", pQuad->m_aColors[k].g); pColorItem->AddAttributeInt("b", pQuad->m_aColors[k].b); pColorItem->AddAttributeInt("a", pQuad->m_aColors[k].a); } for(int k = 0; k < 4; k++) { CXMLItem *pTexcoordItem = pQuadItem->AddChild("texcoord"); pTexcoordItem->AddAttributeInt("x", fx2f(pQuad->m_aTexcoords[k].x)); pTexcoordItem->AddAttributeInt("y", fx2f(pQuad->m_aTexcoords[k].y)); } } } } } int EnvPointsStart; int EnvPointsNum; m_Reader.GetType(MAPITEMTYPE_ENVPOINTS, &EnvPointsStart, &EnvPointsNum); CEnvPoint *pPoints = 0; if(EnvPointsNum) pPoints = (CEnvPoint *)m_Reader.GetItem(EnvPointsStart, NULL, NULL); int EnvStart; int EnvNum; m_Reader.GetType(MAPITEMTYPE_ENVELOPE, &EnvStart, &EnvNum); for(int e = EnvStart; e < EnvStart+EnvNum; e++) { CMapItemEnvelope *pEnv = (CMapItemEnvelope *)m_Reader.GetItem(e, NULL, NULL); CXMLItem *pEnvItem = pMainItem->AddChild("envelope"); pEnvItem->AddAttributeInt("version", pEnv->m_Version); if(pEnv->m_Channels == 3) pEnvItem->AddAttributeStr("type", "pos"); else if(pEnv->m_Channels == 4) pEnvItem->AddAttributeStr("type", "color"); else pEnvItem->AddAttributeStr("type", "invalid"); if(pEnv->m_aName[0] != -1) { char aEnvName[64]; IntsToStr(pEnv->m_aName, sizeof(pEnv->m_aName)/sizeof(int), aEnvName); pEnvItem->AddAttributeStr("name", aEnvName); } for(int p = pEnv->m_StartPoint; p < pEnv->m_StartPoint+pEnv->m_NumPoints; p++) { CXMLItem *pEnvPointItem = pEnvItem->AddChild("envpoint"); pEnvPointItem->AddAttributeInt("time", pPoints[p].m_Time); if(p != pEnv->m_StartPoint+pEnv->m_NumPoints -1) { if(pPoints[p].m_Curvetype == CURVETYPE_STEP) pEnvPointItem->AddAttributeStr("curvetype", "step"); else if(pPoints[p].m_Curvetype == CURVETYPE_LINEAR) pEnvPointItem->AddAttributeStr("curvetype", "linear"); else if(pPoints[p].m_Curvetype == CURVETYPE_SLOW) pEnvPointItem->AddAttributeStr("curvetype", "slow"); else if(pPoints[p].m_Curvetype == CURVETYPE_FAST) pEnvPointItem->AddAttributeStr("curvetype", "fast"); else if(pPoints[p].m_Curvetype == CURVETYPE_SMOOTH) pEnvPointItem->AddAttributeStr("curvetype", "smooth"); else pEnvPointItem->AddAttributeStr("curvetype", "invalid"); } if(pEnv->m_Channels == 3) { pEnvPointItem->AddAttributeInt("x", fx2f(pPoints[p].m_aValues[0])); pEnvPointItem->AddAttributeInt("y", fx2f(pPoints[p].m_aValues[1])); pEnvPointItem->AddAttributeInt("r", fx2f(pPoints[p].m_aValues[2])); } else if(pEnv->m_Channels == 4) { pEnvPointItem->AddAttributeInt("r", fx2f(pPoints[p].m_aValues[0])*255); pEnvPointItem->AddAttributeInt("g", fx2f(pPoints[p].m_aValues[1])*255); pEnvPointItem->AddAttributeInt("b", fx2f(pPoints[p].m_aValues[2])*255); pEnvPointItem->AddAttributeInt("a", fx2f(pPoints[p].m_aValues[3])*255); } } } char aMetadataFilename[512]; sprintf(aMetadataFilename, "%s/metadata.xml", aGeneratedFolder); Doc.Save(aMetadataFilename); Doc.Close(); m_MetadataBenchmark.Pause(); } if(ImagesNum > 0) delete pImages; remove(aGenerating); m_OverallBenchmark.Pause(); if(pInfo->m_ShowBenchmark) { printf("Benchmark results:\n"); printf(" Images dumping:\t%dms\n", m_ImagesBenchmark.GetTime()); printf(" Tilemaps dumping:\t%dms\n", m_TilemapsBenchmark.GetTime()); printf(" Quads dumping:\t%dms\n", m_QuadsBenchmark.GetTime()); printf(" Metadata dumping:\t%dms\n", m_MetadataBenchmark.GetTime()); printf(" Overall:\t\t%dms\n", m_OverallBenchmark.GetTime()); } }
bool RSS_PlaylistParser::Parse(std::string p_sContent) { CXMLDocument* pDoc = new CXMLDocument(); if(!pDoc->LoadFromString(p_sContent)) { // TODO Log the incorrect format delete pDoc; return false; } CXMLNode* pTmp; pTmp = pDoc->RootNode()->FindNodeByName("channel"); if(!pTmp) { // TODO Log the incorrect format delete pDoc; return false; } for(int i = 0; i < pTmp->ChildCount(); i++) { if(pTmp->ChildNode(i)->Name().compare("item") != 0) { // TODO Log the incorrect format continue; } CXMLNode* pEnc = pTmp->ChildNode(i)->FindNodeByName("enclosure"); if(!pEnc) { // TODO Log the incorrect format continue; } PlaylistEntry_t* pEntry = new PlaylistEntry_t(); pEntry->sFileName = pEnc->Attribute("url"); pEntry->nSize = pEnc->AttributeAsUInt("length"); pEntry->sMimeType = pEnc->Attribute("type"); pEntry->bIsLocalFile = false; if(pTmp->ChildNode(i)->FindNodeByName("title")) { pEntry->sTitle = pTmp->ChildNode(i)->FindNodeByName("title")->Value(); } m_lEntries.push_back(pEntry); } /* <channel> <title>Marillion Online Podcast</title> <link>http://www.marillion.com</link> <language>en</language> <copyright>℗ & © 2006 Marillion</copyright> <pubDate>Wed, 13 Dec 2006 15:00:00 GMT</pubDate> <itunes:subtitle>Find a Better Way of Life at marillion.com</itunes:subtitle> <itunes:author>Marillion</itunes:author> <itunes:summary>Official insider information for British rock band Marillion. Whether writing in the studio, recording new material, preparing for a live show, or on the road - get the scoop DIRECT from the band members themselves. Find a Better Way of Life at marillion.com</itunes:summary> <description>Official insider information for British rock band Marillion. Whether writing in the studio, recording new material, preparing for a live show, or on the road - get the scoop DIRECT from the band members themselves. Find a Better Way of Life at marillion.com</description> <item> <title>Album Number 14 Begins</title> <itunes:author>Marillion</itunes:author> <itunes:subtitle>Recording is set to begin on the next studio album</itunes:subtitle> <itunes:summary>26 May 2006. Marillion have been jamming song ideas since the beginning of 2006 and have now come up with a short-list of contenders for the next studio album. Coming to you direct from the live room at the Racket Club studio with Mark Kelly, Ian Mosley, Pete Trewavas, Mike Hunter, and the Racket Records Peanut Gallery.</itunes:summary> <enclosure url="http://media.marillion.com/podcast/20060526.mp3" length="3361560" type="audio/mpeg" /> <guid>http://media.marillion.com/podcast/20060526.mp3</guid> <pubDate>Fri, 26 May 2006 09:00:00 GMT</pubDate> <itunes:duration>4:00</itunes:duration> <itunes:explicit>yes</itunes:explicit> <itunes:keywords>marillion, studio, new, album, recording, update, racket, hogarth, kelly, mosley, trewavas, rothery</itunes:keywords> </item> */ delete pDoc; if(!m_lEntries.empty()) { m_bEof = false; m_lEntriesIterator = m_lEntries.begin(); } return true; }
void CFYSPrintDoc::UnpackFiles() { CString strTemp; CString strSep("\\"); CString strFileName = m_strFYSTempPath + FORYOURSOUL_TXT; FILE* input = NULL; errno_t err = fopen_s(&input, strFileName, "rb"); if (!input || err != 0) { SetError(String("Failed to open %s", strFileName)); return; } HGLOBAL hMemory; BYTE* pMemory; // unpack the mini header hMemory = ::GlobalAlloc(GMEM_MOVEABLE, sizeof(BYTE)); pMemory = (BYTE*)::GlobalLock(hMemory); char xz = ']'; do { fread(pMemory, sizeof(BYTE), 1, input); strTemp += (char)*pMemory; }while((*(char*)pMemory) != xz); ::GlobalUnlock(hMemory); ::GlobalFree(hMemory); // unpack streamheader strTemp = strTemp.Mid(1, strTemp.Find(',', 0)-1); DWORD dwSize = atoi(strTemp); hMemory = ::GlobalAlloc(GMEM_MOVEABLE, dwSize); pMemory = (BYTE*)::GlobalLock(hMemory); fread(pMemory, sizeof(BYTE), dwSize, input); CString strPath = m_strFYSTempPath + XML_PATH + strSep; strTemp.Format("%sXP_%s", strPath, STREAMHDR_XML); FILE* output = NULL; err = fopen_s(&output, strTemp, "wb"); if (!output || err != 0) { SetError(String("Failed to open %s", strTemp)); } else { fwrite(pMemory, sizeof(BYTE), dwSize, output); fclose(output); output = NULL; } ::GlobalUnlock(hMemory); ::GlobalFree(hMemory); // time to read the stream header into a xml class CXMLDocument* pXMLDoc = new CXMLDocument; pXMLDoc->Load(strTemp, false); CString strCount = pXMLDoc->GetStringValue("//FYS_DataStreamHeader//Files", "Count"); int nFileCount = atoi(strCount); for (int i=0, offset=0; i<nFileCount; i++) { CString strSrch = String("//FYS_DataStreamHeader//Files//File[@StartOffset = '%ld']", offset); CString strType = pXMLDoc->GetStringValue(strSrch, "Type"); CString strName = pXMLDoc->GetStringValue(strSrch, "Name"); CString strSize = pXMLDoc->GetStringValue(strSrch, "Size"); DWORD dwSize = atoi(strSize); hMemory = ::GlobalAlloc(GMEM_MOVEABLE, dwSize); pMemory = (BYTE*)::GlobalLock(hMemory); fread(pMemory, sizeof(BYTE), dwSize, input); if (strType == "DataEnvelope") strPath = m_strFYSTempPath + XML_PATH + strSep; if (strType == "Image") strPath = m_strFYSTempPath + IMAGES_PATH + strSep; if (strType == "Font") strPath = m_strFYSTempPath + FONTS_PATH + strSep; strTemp.Format("%sXP_%s", strPath, strName); err = fopen_s(&output, strTemp, "wb"); if (!output || err != 0) { SetError(String("Failed to open %s", strTemp)); } else { fwrite(pMemory, sizeof(BYTE), dwSize, output); fclose(output); output = NULL; } ::GlobalUnlock(hMemory); ::GlobalFree(hMemory); offset += dwSize; } fclose(input); delete pXMLDoc; }
bool CFYSPrintDoc::SendXmlDoc(CString strURL) { CComPtr<IWebBrowser2> pBrowser; HRESULT hr = pBrowser.CoCreateInstance(_bstr_t("InternetExplorer.Application")); if (hr != S_OK) { SetError("Failed to start IE!."); return false; } CString strSendFile = m_strFYSTempPath + FORYOURSOUL_TXT; CHTTPClient *pHttpClient = new CHTTPClient(pBrowser); pHttpClient->AddPostArguments("File1", strSendFile, true); BOOL bRetVal = pHttpClient->Request(strURL, CHTTPClient::RequestPostMethodMultiPartsFormData); //pHttpClient->Request("http://localhost/simpleupload/Receiver.aspx", CHTTPClient::RequestPostMethodMultiPartsFormData); VARIANT_BOOL bBusy = true; int ix = 300; while (bBusy) { ::Sleep(100); pBrowser->get_Busy(&bBusy); if (--ix <= 0) break; } if (!bRetVal) { m_strErrorMsg.Format("Failed to send project to the website."); return false; } CComPtr<IDispatch> spDisp; hr = pBrowser->get_Document(&spDisp); if (FAILED(hr) || !spDisp) { delete pHttpClient; return false; } CComQIPtr<IHTMLDocument2> spDoc(spDisp); if (!spDoc) { m_strErrorMsg.Format("Invalid response from website after sending project successfully."); delete pHttpClient; return false; } CComPtr<IHTMLElement> spElem; hr = spDoc->get_body(&spElem); if (FAILED(hr) || !spDisp) { m_strErrorMsg.Format("Invalid response from website after sending project successfully."); delete pHttpClient; return false; } CString strTxt; CComBSTR bstr; spElem->get_innerHTML(&bstr); strTxt = bstr; #ifdef _DEBUG spElem->get_innerText(&bstr); strTxt = bstr; #endif delete pHttpClient; if (strTxt.Find("<FYS_DATASTREAMACKNOWLEDGMENT") < 0) { m_strErrorMsg.Format("Invalid response from website after sending project successfully."); return false; } strTxt = strTxt.Mid(strTxt.Find("<FYS_DATASTREAMACKNOWLEDGMENT")); CString strSrchPtrn("//FYS_DATASTREAMACKNOWLEDGMENT"); CXMLDocument* pXMLDoc = new CXMLDocument; pXMLDoc->LoadString(strTxt); pXMLDoc->RegisterCallback(MyXMLCallback, (LPARAM)this); if (pXMLDoc->WalkTree(strSrchPtrn) != S_OK) { pXMLDoc->SetFYSError(); m_strErrorMsg = pXMLDoc->GetErrorMsg(); delete pXMLDoc; return false; } delete pXMLDoc; return true; }