HRESULT XMLFile::LoadFromFile(CString fn) { root->Clear(); CComPtr<IXmlReader> reader; CComPtr<IStream> stream; HRESULT hr = NOERROR; do { // create file stream hr = SHCreateStreamOnFile(fn, STGM_READ | STGM_SHARE_DENY_WRITE, &stream); if (FAILED(hr)) break; // reader hr = CreateXmlReader(IID_IXmlReader, (void**)&reader, NULL); if (FAILED(hr)) break; // select input hr = reader->SetInput(stream); if (FAILED(hr)) break; int ret = LoadFromXmlReader(reader); if (ret < 0) { hr = ret; } else { hr = NOERROR; } } while (0); return hr; }
/****************************************************************************** Function Name : FormatDOMDocument Input(s) : MSXML2::IXMLDOMDocumentPtr pDoc CString& omstrFilePath Output : bool Functionality : Formats the pDoc Pointer into File omStrFilePath Member of : CTestSetupEntity Friend of : - Author(s) : Venkatanarayana Makam Date Created : 06/04/2011 Modifications : ******************************************************************************/ BOOL CTestSetupEntity::FormatDOMDocument(MSXML2::IXMLDOMDocumentPtr pDoc, CString& omstrFilePath) { //Referance Taken From Msdn MSXML2::ISAXXMLReaderPtr pSaxXmlReader = NULL; pSaxXmlReader.CreateInstance(L"Msxml2.SAXXMLReader"); CComPtr<IStream> pStream; DWORD grfMode = STGM_WRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE; //W4 Removal if(SHCreateStreamOnFile ((LPCTSTR)omstrFilePath, grfMode, &pStream) == S_OK) { MSXML2::IMXWriterPtr pImxWriter; pImxWriter.CreateInstance (L"Msxml2.MXXMLWriter"); pImxWriter->put_output (CComVariant(pStream)); pSaxXmlReader->putContentHandler((MSXML2::ISAXContentHandlerPtr)pImxWriter); pSaxXmlReader->putErrorHandler((MSXML2::ISAXErrorHandlerPtr)pImxWriter); pSaxXmlReader->putDTDHandler((MSXML2::ISAXDTDHandlerPtr)pImxWriter); pImxWriter->put_byteOrderMark(VARIANT_TRUE); pImxWriter->put_indent(VARIANT_TRUE); //W4 Removal pSaxXmlReader->parse((_variant_t)(pDoc.GetInterfacePtr())); pImxWriter->flush (); return TRUE; } else { return FALSE; } }
HRESULT XMLReader::LoadFromFile(const std::wstring& sFileName) { CComPtr<IStream> pFileStream; m_nError = S_OK; if (!FAILED(m_nError = SHCreateStreamOnFile(sFileName.c_str(), STGM_READ, &pFileStream))) { SetInput(pFileStream); } return m_nError; }
// This function is called by WIA service to get data stream from the application. HRESULT STDMETHODCALLTYPE CWiaTransferCallback::GetNextStream(LONG lFlags, BSTR bstrItemName, BSTR bstrFullItemName, IStream **ppDestination) { _tprintf(TEXT("\nGetNextStream")); HRESULT hr = S_OK; if ( (!ppDestination) || (!bstrItemName) || (!m_bstrDirectoryName) ) { hr = E_INVALIDARG; ReportError(TEXT("GetNextStream() was called with invalid parameters"),hr); return hr; } //Initialize out variables *ppDestination = NULL; if(m_bstrFileExtension) { //For feeder transfer, append the page count to the filename if (m_bFeederTransfer) { StringCchPrintf(m_szFileName, ARRAYSIZE(m_szFileName), TEXT("%ws\\%ws_page%d.%ws"), m_bstrDirectoryName, bstrItemName, ++m_lPageCount, m_bstrFileExtension); } else { StringCchPrintf(m_szFileName, ARRAYSIZE(m_szFileName), TEXT("%ws\\%ws.%ws"), m_bstrDirectoryName, bstrItemName, m_bstrFileExtension); } } else { // Dont append extension if m_bstrFileExtension = NULL. StringCchPrintf(m_szFileName, ARRAYSIZE(m_szFileName), TEXT("%ws\\%ws"), m_bstrDirectoryName, bstrItemName); } hr = SHCreateStreamOnFile(m_szFileName,STGM_CREATE | STGM_READWRITE,ppDestination); if (SUCCEEDED(hr)) { // We're not going to keep the Stream around, so don't AddRef. // The caller will release the stream when done. } else { _tprintf(TEXT("\nFailed to Create a Stream on File %ws"),m_szFileName); *ppDestination = NULL; } return hr; }
bool Utils::xmlopen(IStream **pFileStream, IXmlReader **pReader,WCHAR* filename) { HRESULT hr; if (FAILED(hr = SHCreateStreamOnFile(filename, STGM_READ, &(*pFileStream)))) { wprintf(L"Error creating file reader, error is %08.8lx", hr); return false; } if (FAILED(hr = CreateXmlReader(__uuidof(IXmlReader), (void**) pReader, NULL))) { wprintf(L"Error creating xml reader, error is %08.8lx", hr); return false; } if (FAILED(hr = (*pReader)->SetProperty(XmlReaderProperty_DtdProcessing, DtdProcessing_Prohibit))) { wprintf(L"Error setting XmlReaderProperty_DtdProcessing, error is %08.8lx", hr); return false; } if (FAILED(hr = (*pReader)->SetInput(*pFileStream))) { wprintf(L"Error setting input for reader, error is %08.8lx", hr); return false; } return true; }
static int dshow_open_device(AVFormatContext *avctx, ICreateDevEnum *devenum, enum dshowDeviceType devtype, enum dshowSourceFilterType sourcetype) { struct dshow_ctx *ctx = avctx->priv_data; IBaseFilter *device_filter = NULL; IGraphBuilder *graph = ctx->graph; IPin *device_pin = NULL; libAVPin *capture_pin = NULL; libAVFilter *capture_filter = NULL; ICaptureGraphBuilder2 *graph_builder2 = NULL; int ret = AVERROR(EIO); int r; IStream *ifile_stream = NULL; IStream *ofile_stream = NULL; IPersistStream *pers_stream = NULL; const wchar_t *filter_name[2] = { L"Audio capture filter", L"Video capture filter" }; if ( ((ctx->audio_filter_load_file) && (strlen(ctx->audio_filter_load_file)>0) && (sourcetype == AudioSourceDevice)) || ((ctx->video_filter_load_file) && (strlen(ctx->video_filter_load_file)>0) && (sourcetype == VideoSourceDevice)) ) { HRESULT hr; char *filename = NULL; if (sourcetype == AudioSourceDevice) filename = ctx->audio_filter_load_file; else filename = ctx->video_filter_load_file; hr = SHCreateStreamOnFile ((LPCSTR) filename, STGM_READ, &ifile_stream); if (S_OK != hr) { av_log(avctx, AV_LOG_ERROR, "Could not open capture filter description file.\n"); goto error; } hr = OleLoadFromStream(ifile_stream, &IID_IBaseFilter, (void **) &device_filter); if (hr != S_OK) { av_log(avctx, AV_LOG_ERROR, "Could not load capture filter from file.\n"); goto error; } if (sourcetype == AudioSourceDevice) av_log(avctx, AV_LOG_INFO, "Audio-"); else av_log(avctx, AV_LOG_INFO, "Video-"); av_log(avctx, AV_LOG_INFO, "Capture filter loaded successfully from file \"%s\".\n", filename); } else { if ((r = dshow_cycle_devices(avctx, devenum, devtype, sourcetype, &device_filter)) < 0) { ret = r; goto error; } } ctx->device_filter [devtype] = device_filter; r = IGraphBuilder_AddFilter(graph, device_filter, NULL); if (r != S_OK) { av_log(avctx, AV_LOG_ERROR, "Could not add device filter to graph.\n"); goto error; } if ((r = dshow_cycle_pins(avctx, devtype, sourcetype, device_filter, &device_pin)) < 0) { ret = r; goto error; } ctx->device_pin[devtype] = device_pin; capture_filter = libAVFilter_Create(avctx, callback, devtype); if (!capture_filter) { av_log(avctx, AV_LOG_ERROR, "Could not create grabber filter.\n"); goto error; } ctx->capture_filter[devtype] = capture_filter; if ( ((ctx->audio_filter_save_file) && (strlen(ctx->audio_filter_save_file)>0) && (sourcetype == AudioSourceDevice)) || ((ctx->video_filter_save_file) && (strlen(ctx->video_filter_save_file)>0) && (sourcetype == VideoSourceDevice)) ) { HRESULT hr; char *filename = NULL; if (sourcetype == AudioSourceDevice) filename = ctx->audio_filter_save_file; else filename = ctx->video_filter_save_file; hr = SHCreateStreamOnFile ((LPCSTR) filename, STGM_CREATE | STGM_READWRITE, &ofile_stream); if (S_OK != hr) { av_log(avctx, AV_LOG_ERROR, "Could not create capture filter description file.\n"); goto error; } hr = IBaseFilter_QueryInterface(device_filter, &IID_IPersistStream, (void **) &pers_stream); if (hr != S_OK) { av_log(avctx, AV_LOG_ERROR, "Query for IPersistStream failed.\n"); goto error; } hr = OleSaveToStream(pers_stream, ofile_stream); if (hr != S_OK) { av_log(avctx, AV_LOG_ERROR, "Could not save capture filter \n"); goto error; } hr = IStream_Commit(ofile_stream, STGC_DEFAULT); if (S_OK != hr) { av_log(avctx, AV_LOG_ERROR, "Could not commit capture filter data to file.\n"); goto error; } if (sourcetype == AudioSourceDevice) av_log(avctx, AV_LOG_INFO, "Audio-"); else av_log(avctx, AV_LOG_INFO, "Video-"); av_log(avctx, AV_LOG_INFO, "Capture filter saved successfully to file \"%s\".\n", filename); } r = IGraphBuilder_AddFilter(graph, (IBaseFilter *) capture_filter, filter_name[devtype]); if (r != S_OK) { av_log(avctx, AV_LOG_ERROR, "Could not add capture filter to graph\n"); goto error; } libAVPin_AddRef(capture_filter->pin); capture_pin = capture_filter->pin; ctx->capture_pin[devtype] = capture_pin; r = CoCreateInstance(&CLSID_CaptureGraphBuilder2, NULL, CLSCTX_INPROC_SERVER, &IID_ICaptureGraphBuilder2, (void **) &graph_builder2); if (r != S_OK) { av_log(avctx, AV_LOG_ERROR, "Could not create CaptureGraphBuilder2\n"); goto error; } ICaptureGraphBuilder2_SetFiltergraph(graph_builder2, graph); if (r != S_OK) { av_log(avctx, AV_LOG_ERROR, "Could not set graph for CaptureGraphBuilder2\n"); goto error; } r = ICaptureGraphBuilder2_RenderStream(graph_builder2, NULL, NULL, (IUnknown *) device_pin, NULL /* no intermediate filter */, (IBaseFilter *) capture_filter); /* connect pins, optionally insert intermediate filters like crossbar if necessary */ if (r != S_OK) { av_log(avctx, AV_LOG_ERROR, "Could not RenderStream to connect pins\n"); goto error; } r = dshow_try_setup_crossbar_options(graph_builder2, device_filter, devtype, avctx); if (r != S_OK) { av_log(avctx, AV_LOG_ERROR, "Could not setup CrossBar\n"); goto error; } ret = 0; error: if (graph_builder2 != NULL) ICaptureGraphBuilder2_Release(graph_builder2); if (pers_stream) IPersistStream_Release(pers_stream); if (ifile_stream) IStream_Release(ifile_stream); if (ofile_stream) IStream_Release(ofile_stream); return ret; }
HBITMAP ImageUtil::LoadImage(string path) { size_t pathFileExtDot = path.find_last_of('.'); if (pathFileExtDot == string::npos || pathFileExtDot + 1 >= path.length()) throw INETRException("[imgLoadFailed]"); string ext = path.substr(pathFileExtDot + 1); const GUID *decoderCLSID = nullptr; if (ext == "png") decoderCLSID = &CLSID_WICPngDecoder; else if (ext == "bmp") decoderCLSID = &CLSID_WICBmpDecoder; else if (ext == "gif") decoderCLSID = &CLSID_WICGifDecoder; else if (ext == "jpg" || ext == "jpeg") decoderCLSID = &CLSID_WICJpegDecoder; if (decoderCLSID == nullptr) throw INETRException("[unsupportedImg]: " + ext); IStream *pngFileStream; if (FAILED(SHCreateStreamOnFile(path.c_str(), STGM_READ, &pngFileStream))) throw INETRException("[imgLoadFailed]:\n" + path); IWICBitmapDecoder *bmpDecoder = nullptr; if (FAILED(CoCreateInstance(*decoderCLSID, nullptr, CLSCTX_INPROC_SERVER, __uuidof(bmpDecoder), reinterpret_cast<void**>(&bmpDecoder)))) throw INETRException("[imgDecFailed]"); if (FAILED(bmpDecoder->Initialize(pngFileStream, WICDecodeMetadataCacheOnLoad))) { bmpDecoder->Release(); throw INETRException("[imgDecFailed]"); } UINT bmpFrameCount = 0; if (FAILED(bmpDecoder->GetFrameCount(&bmpFrameCount)) && bmpFrameCount != 1) { bmpDecoder->Release(); throw INETRException("[imgDecFailed]"); } IWICBitmapFrameDecode *bmpFrame = nullptr; if (FAILED(bmpDecoder->GetFrame(0, &bmpFrame))) { bmpDecoder->Release(); throw INETRException("[imgDecFailed]"); } IWICBitmapSource *bmpSource = nullptr; WICConvertBitmapSource(GUID_WICPixelFormat32bppPBGRA, bmpFrame, &bmpSource); bmpFrame->Release(); bmpDecoder->Release(); UINT width = 0, height = 0; if (FAILED(bmpSource->GetSize(&width, &height)) || width == 0 || height == 0) throw INETRException("[imgDecFailed]"); BITMAPINFO bmInfo; ZeroMemory(&bmInfo, sizeof(bmInfo)); bmInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); bmInfo.bmiHeader.biWidth = width; bmInfo.bmiHeader.biHeight = -((LONG)height); bmInfo.bmiHeader.biPlanes = 1; bmInfo.bmiHeader.biBitCount = 32; bmInfo.bmiHeader.biCompression = BI_RGB; HBITMAP hbmp = nullptr; void *imageBits = nullptr; HDC screenDC = GetDC(nullptr); hbmp = CreateDIBSection(screenDC, &bmInfo, DIB_RGB_COLORS, &imageBits, nullptr, 0); ReleaseDC(nullptr, screenDC); if (hbmp == nullptr) throw INETRException("[imgDecFailed]"); const UINT bmpStride = width * 4; const UINT bmpSize = bmpStride * height; if (FAILED(bmpSource->CopyPixels(nullptr, bmpStride, bmpSize, static_cast<BYTE*>(imageBits)))) { DeleteObject(hbmp); hbmp = nullptr; throw INETRException("[imgDecFailed]"); } bmpSource->Release(); return hbmp; }
int Quiz::inputQuiz(int x){ HRESULT hr; CComPtr<IStream> pFileStream; CComPtr<IXmlReader> pReader; XmlNodeType nodeType; //const WCHAR* pwszPrefix; const WCHAR* pwszLocalName; const WCHAR* pwszValue; //UINT cwchPrefix; if (FAILED(hr = SHCreateStreamOnFile(L"file.xml", STGM_READ, &pFileStream))) { wprintf(L"Error creating file reader, error is %08.8lx", hr); getchar(); return -1; } if (FAILED(hr = CreateXmlReader(__uuidof(IXmlReader), (void**) &pReader, NULL))) { wprintf(L"Error creating xml reader, error is %08.8lx", hr); return -1; } if (FAILED(hr = pReader->SetProperty(XmlReaderProperty_DtdProcessing, DtdProcessing_Prohibit))) { wprintf(L"Error setting XmlReaderProperty_DtdProcessing, error is %08.8lx", hr); return -1; } if (FAILED(hr = pReader->SetInput(pFileStream))) { wprintf(L"Error setting input for reader, error is %08.8lx", hr); return -1; } int i = 0; while (S_OK == (hr = pReader->Read(&nodeType))) { if (nodeType == XmlNodeType_Element) { if (FAILED(hr = pReader->GetLocalName(&pwszLocalName, NULL))) { wprintf(L"Error getting local name, error is %08.8lx", hr); return -1; } if (wcscmp(pwszLocalName,L"entry") == 0) i++; // i la` so element trong xml } } LARGE_INTEGER liBeggining = { 0 }; pFileStream->Seek(liBeggining, STREAM_SEEK_SET, NULL); pReader->SetInput(pFileStream); int k=0,j=1;//k la` bien dem'. j bien' de? lay ra phan` tu? thu' j. j = 1 thi` lay' phan` tu? dau` tien while (S_OK == (hr = pReader->Read(&nodeType))) { switch (nodeType) { case XmlNodeType_Element: if (FAILED(hr = pReader->GetLocalName(&pwszLocalName, NULL))) { wprintf(L"Error getting local name, error is %08.8lx", hr); return -1; } if (wcscmp(pwszLocalName,L"entry") == 0) k++; if (FAILED(hr = pReader->MoveToElement())) { wprintf(L"Error moving to the element that owns the current attribute node, error is %08.8lx", hr); return -1; } if (pReader->IsEmptyElement() ) wprintf(L" (empty element)\n"); break; case XmlNodeType_EndElement: if (FAILED(hr = pReader->GetLocalName(&pwszLocalName, NULL))) { wprintf(L"Error getting local name, error is %08.8lx", hr); return -1; } break; case XmlNodeType_Text: case XmlNodeType_CDATA: if (FAILED(hr = pReader->GetValue(&pwszValue, NULL))) { wprintf(L"Error getting value, error is %08.8lx", hr); return -1; } if (wcscmp(pwszLocalName,L"Question") == 0) { setQuestion(strdup(narrow(pwszValue).c_str())); } else if (wcscmp(pwszLocalName,L"Answer") == 0) { setAnswer(strdup(narrow(pwszValue).c_str())); } break; case XmlNodeType_ProcessingInstruction: if (FAILED(hr = pReader->GetLocalName(&pwszLocalName, NULL))) { wprintf(L"Error getting name, error is %08.8lx", hr); return -1; } if (FAILED(hr = pReader->GetValue(&pwszValue, NULL))) { wprintf(L"Error getting value, error is %08.8lx", hr); return -1; } wprintf(L"Processing Instruction name:%S value:%S\n", pwszLocalName, pwszValue); break; case XmlNodeType_Comment: if (FAILED(hr = pReader->GetValue(&pwszValue, NULL))) { wprintf(L"Error getting value, error is %08.8lx", hr); return -1; } wprintf(L"Comment: %s\n", pwszValue); break; case XmlNodeType_DocumentType: wprintf(L"DOCTYPE is not printed\n"); break; } if (k > j) break; } return 0; }
////////////////////////////////////////////////////////////////////////// // IDataObject ////////////////////////////////////////////////////////////////////////// STDMETHODIMP SVNDataObject::GetData(FORMATETC* pformatetcIn, STGMEDIUM* pmedium) { if (pformatetcIn == NULL) return E_INVALIDARG; if (pmedium == NULL) return E_POINTER; pmedium->hGlobal = NULL; if ((pformatetcIn->tymed & TYMED_ISTREAM) && (pformatetcIn->dwAspect == DVASPECT_CONTENT) && (pformatetcIn->cfFormat == CF_FILECONTENTS)) { // supports the IStream format. // The lindex param is the index of the file to return // Note: we don't get called for directories since those are simply created and don't // need to be fetched. // Note2: It would be really nice if we could get a stream from the subversion library // from where we could read the file contents. But the Subversion lib is not implemented // to *read* from a remote stream but so that the library *writes* to a stream we pass. // Since we can't get such a read stream, we have to fetch the file in whole first to // a temp location and then pass the shell an IStream for that temp file. CTSVNPath filepath; IStream * pIStream = NULL; if (m_revision.IsWorking()) { if ((pformatetcIn->lindex >= 0)&&(pformatetcIn->lindex < (LONG)m_allPaths.size())) { filepath = m_allPaths[pformatetcIn->lindex].rootpath; } } else { filepath = CTempFiles::Instance().GetTempFilePath(true); if ((pformatetcIn->lindex >= 0)&&(pformatetcIn->lindex < (LONG)m_allPaths.size())) { if (!m_svn.Cat(CTSVNPath(m_allPaths[pformatetcIn->lindex].infodata.url), m_pegRev, m_revision, filepath)) { DeleteFile(filepath.GetWinPath()); return STG_E_ACCESSDENIED; } } } HRESULT res = SHCreateStreamOnFile(filepath.GetWinPath(), STGM_READ, &pIStream); if (res == S_OK) { pmedium->pstm = pIStream; pmedium->tymed = TYMED_ISTREAM; return S_OK; } return res; } else if ((pformatetcIn->tymed & TYMED_HGLOBAL) && (pformatetcIn->dwAspect == DVASPECT_CONTENT) && (pformatetcIn->cfFormat == CF_FILEDESCRIPTOR)) { // now it is time to get all sub folders for the directories we have SVNInfo svnInfo; // find the common directory of all the paths CTSVNPath commonDir; bool bAllUrls = true; for (int i=0; i<m_svnPaths.GetCount(); ++i) { if (!m_svnPaths[i].IsUrl()) bAllUrls = false; if (commonDir.IsEmpty()) commonDir = m_svnPaths[i].GetContainingDirectory(); if (!commonDir.IsEquivalentTo(m_svnPaths[i].GetContainingDirectory())) { commonDir.Reset(); break; } } if (bAllUrls && (m_svnPaths.GetCount() > 1) && !commonDir.IsEmpty()) { // if all paths are in the same directory, we can fetch the info recursively // from the parent folder to save a lot of time. const SVNInfoData * infodata = svnInfo.GetFirstFileInfo(commonDir, m_pegRev, m_revision, svn_depth_infinity); while (infodata) { // check if the returned item is one in our list for (int i=0; i<m_svnPaths.GetCount(); ++i) { if (m_svnPaths[i].IsAncestorOf(CTSVNPath(infodata->url))) { SVNDataObject::SVNObjectInfoData id = {m_svnPaths[i], *infodata}; m_allPaths.push_back(id); break; } } infodata = svnInfo.GetNextFileInfo(); } } else { for (int i = 0; i < m_svnPaths.GetCount(); ++i) { if (m_svnPaths[i].IsUrl()) { const SVNInfoData * infodata = svnInfo.GetFirstFileInfo(m_svnPaths[i], m_pegRev, m_revision, svn_depth_infinity); while (infodata) { SVNDataObject::SVNObjectInfoData id = {m_svnPaths[i], *infodata}; m_allPaths.push_back(id); infodata = svnInfo.GetNextFileInfo(); } } else { SVNDataObject::SVNObjectInfoData id = {m_svnPaths[i], SVNInfoData()}; m_allPaths.push_back(id); } } } size_t dataSize = sizeof(FILEGROUPDESCRIPTOR) + ((m_allPaths.size() - 1) * sizeof(FILEDESCRIPTOR)); HGLOBAL data = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE | GMEM_ZEROINIT, dataSize); FILEGROUPDESCRIPTOR* files = (FILEGROUPDESCRIPTOR*)GlobalLock(data); files->cItems = static_cast<UINT>(m_allPaths.size()); int index = 0; for (vector<SVNDataObject::SVNObjectInfoData>::const_iterator it = m_allPaths.begin(); it != m_allPaths.end(); ++it) { CString temp; if (it->rootpath.IsUrl()) { temp = CUnicodeUtils::GetUnicode(CPathUtils::PathEscape(CUnicodeUtils::GetUTF8(it->rootpath.GetContainingDirectory().GetSVNPathString()))); temp = it->infodata.url.Mid(temp.GetLength()+1); // we have to unescape the urls since the local file system doesn't need them // escaped and it would only look really ugly (and be wrong). temp = CPathUtils::PathUnescape(temp); } else { temp = it->rootpath.GetUIFileOrDirectoryName(); } _tcscpy_s(files->fgd[index].cFileName, MAX_PATH, (LPCTSTR)temp); files->fgd[index].dwFlags = FD_ATTRIBUTES | FD_PROGRESSUI | FD_FILESIZE | FD_LINKUI; if (it->rootpath.IsUrl()) { files->fgd[index].dwFileAttributes = (it->infodata.kind == svn_node_dir) ? FILE_ATTRIBUTE_DIRECTORY : FILE_ATTRIBUTE_NORMAL; } else { files->fgd[index].dwFileAttributes = it->rootpath.IsDirectory() ? FILE_ATTRIBUTE_DIRECTORY : FILE_ATTRIBUTE_NORMAL; } // Always set the file size to 0 even if we 'know' the file size (infodata.size64). // Because for text files, the file size is too low due to the EOLs getting converted // to CRLF (from LF as stored in the repository). And a too low file size set here // prevents the shell from reading the full file later - it only reads the stream up // to the number of bytes specified here. Which means we would end up with a truncated // text file (binary files are still ok though). files->fgd[index].nFileSizeLow = 0; files->fgd[index].nFileSizeHigh = 0; ++index; } GlobalUnlock(data); pmedium->hGlobal = data; pmedium->tymed = TYMED_HGLOBAL; return S_OK; } // handling CF_PREFERREDDROPEFFECT is necessary to tell the shell that it should *not* ask for the // CF_FILEDESCRIPTOR until the drop actually occurs. If we don't handle CF_PREFERREDDROPEFFECT, the shell // will ask for the file descriptor for every object (file/folder) the mouse pointer hovers over and is // a potential drop target. else if ((pformatetcIn->tymed & TYMED_HGLOBAL) && (pformatetcIn->cfFormat == CF_PREFERREDDROPEFFECT)) { HGLOBAL data = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE | GMEM_ZEROINIT, sizeof(DWORD)); DWORD* effect = (DWORD*) GlobalLock(data); (*effect) = DROPEFFECT_COPY; GlobalUnlock(data); pmedium->hGlobal = data; pmedium->tymed = TYMED_HGLOBAL; return S_OK; } else if ((pformatetcIn->tymed & TYMED_HGLOBAL) && (pformatetcIn->dwAspect == DVASPECT_CONTENT) && (pformatetcIn->cfFormat == CF_TEXT)) { // caller wants text // create the string from the path list CString text; if (m_svnPaths.GetCount()) { // create a single string where the URLs are separated by newlines for (int i=0; i<m_svnPaths.GetCount(); ++i) { if (m_svnPaths[i].IsUrl()) text += m_svnPaths[i].GetSVNPathString(); else text += m_svnPaths[i].GetWinPathString(); text += _T("\r\n"); } } CStringA texta = CUnicodeUtils::GetUTF8(text); pmedium->tymed = TYMED_HGLOBAL; pmedium->hGlobal = GlobalAlloc(GHND, (texta.GetLength()+1)*sizeof(char)); if (pmedium->hGlobal) { char* pMem = (char*)GlobalLock(pmedium->hGlobal); strcpy_s(pMem, texta.GetLength()+1, (LPCSTR)texta); GlobalUnlock(pmedium->hGlobal); } pmedium->pUnkForRelease = NULL; return S_OK; } else if ((pformatetcIn->tymed & TYMED_HGLOBAL) && (pformatetcIn->dwAspect == DVASPECT_CONTENT) && (pformatetcIn->cfFormat == CF_UNICODETEXT)) { // caller wants Unicode text // create the string from the path list CString text; if (m_svnPaths.GetCount()) { // create a single string where the URLs are separated by newlines for (int i=0; i<m_svnPaths.GetCount(); ++i) { if (m_svnPaths[i].IsUrl()) text += m_svnPaths[i].GetSVNPathString(); else text += m_svnPaths[i].GetWinPathString(); text += _T("\r\n"); } } pmedium->tymed = TYMED_HGLOBAL; pmedium->hGlobal = GlobalAlloc(GHND, (text.GetLength()+1)*sizeof(TCHAR)); if (pmedium->hGlobal) { TCHAR* pMem = (TCHAR*)GlobalLock(pmedium->hGlobal); _tcscpy_s(pMem, text.GetLength()+1, (LPCTSTR)text); GlobalUnlock(pmedium->hGlobal); } pmedium->pUnkForRelease = NULL; return S_OK; } else if ((pformatetcIn->tymed & TYMED_HGLOBAL) && (pformatetcIn->dwAspect == DVASPECT_CONTENT) && (pformatetcIn->cfFormat == CF_SVNURL)) { // caller wants the svn url // create the string from the path list CString text; if (m_svnPaths.GetCount()) { // create a single string where the URLs are separated by newlines for (int i=0; i<m_svnPaths.GetCount(); ++i) { if (m_svnPaths[i].IsUrl()) { text += m_svnPaths[i].GetSVNPathString(); text += _T("?"); text += m_revision.ToString(); } else text += m_svnPaths[i].GetWinPathString(); text += _T("\r\n"); } } pmedium->tymed = TYMED_HGLOBAL; pmedium->hGlobal = GlobalAlloc(GHND, (text.GetLength()+1)*sizeof(TCHAR)); if (pmedium->hGlobal) { TCHAR* pMem = (TCHAR*)GlobalLock(pmedium->hGlobal); _tcscpy_s(pMem, text.GetLength()+1, (LPCTSTR)text); GlobalUnlock(pmedium->hGlobal); } pmedium->pUnkForRelease = NULL; return S_OK; } else if ((pformatetcIn->tymed & TYMED_HGLOBAL) && (pformatetcIn->dwAspect == DVASPECT_CONTENT) && (pformatetcIn->cfFormat == CF_HDROP)) { int nLength = 0; for (int i=0;i<m_svnPaths.GetCount();i++) { nLength += m_svnPaths[i].GetWinPathString().GetLength(); nLength += 1; // '\0' separator } int nBufferSize = sizeof(DROPFILES) + (nLength+1)*sizeof(TCHAR); char * pBuffer = new char[nBufferSize]; SecureZeroMemory(pBuffer, nBufferSize); DROPFILES* df = (DROPFILES*)pBuffer; df->pFiles = sizeof(DROPFILES); df->fWide = 1; TCHAR* pFilenames = (TCHAR*)(pBuffer + sizeof(DROPFILES)); TCHAR* pCurrentFilename = pFilenames; for (int i=0;i<m_svnPaths.GetCount();i++) { CString str = m_svnPaths[i].GetWinPathString(); wcscpy_s(pCurrentFilename, str.GetLength()+1, (LPCWSTR)str); pCurrentFilename += str.GetLength(); *pCurrentFilename = '\0'; // separator between file names pCurrentFilename++; } *pCurrentFilename = '\0'; // terminate array pmedium->tymed = TYMED_HGLOBAL; pmedium->hGlobal = GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE|GMEM_DDESHARE, nBufferSize); if (pmedium->hGlobal) { LPVOID pMem = ::GlobalLock(pmedium->hGlobal); if (pMem) memcpy(pMem, pBuffer, nBufferSize); GlobalUnlock(pmedium->hGlobal); } pmedium->pUnkForRelease = NULL; delete [] pBuffer; return S_OK; } for (size_t i=0; i<m_vecFormatEtc.size(); ++i) { if ((pformatetcIn->tymed == m_vecFormatEtc[i]->tymed) && (pformatetcIn->dwAspect == m_vecFormatEtc[i]->dwAspect) && (pformatetcIn->cfFormat == m_vecFormatEtc[i]->cfFormat)) { CopyMedium(pmedium, m_vecStgMedium[i], m_vecFormatEtc[i]); return S_OK; } } return DV_E_FORMATETC; }
/* Modify this to avoid temp file I/O */ bool CXMLParser::extractData( wstring filename) { bool bRet = false; HRESULT hr = S_OK; IXmlReader *pReader = nullptr; IStream *pStream = nullptr; XmlNodeType nodeType; const TCHAR* pwszName; const TCHAR* pwszValue; if (FAILED(hr = SHCreateStreamOnFile(filename.c_str(), STGM_READ, &pStream))) { return bRet; } if (!GetDataContainer()) { if (FAILED(hr = CreateXmlReader(__uuidof(IXmlReader), (void**)&pReader, nullptr))) { return bRet; } if (FAILED(hr = pReader->SetInput(pStream))) { return bRet; } bool inKey = false; wstring csKeyFoundStr; while (!pReader->IsEOF()) { pReader->Read(&nodeType); switch (nodeType) { case XmlNodeType_Element: if (S_OK == pReader->GetLocalName(&pwszName, nullptr)) { if (true == isNodeInKeys(pwszName)) { inKey = true; csKeyFoundStr = pwszName; } } break; case XmlNodeType_CDATA: case XmlNodeType_Text: { if (true == inKey) { if (S_OK == pReader->GetValue(&pwszValue, nullptr)) { GetDataContainer()->setkeyValue(csKeyFoundStr, pwszValue); inKey = false; bRet = true; } } } break; default: break; } } } return bRet; }
int _tmain(int argc, WCHAR* argv[]) { HRESULT hr; CComPtr<IStream> pFileStream; CComPtr<IXmlReader> pReader; XmlNodeType nodeType; const WCHAR* pwszPrefix; const WCHAR* pwszLocalName; const WCHAR* pwszValue; UINT cwchPrefix; if (argc != 2) { wprintf(L"Usage: XmlLiteReader.exe name-of-input-file\n"); return 0; } //Open read-only input stream if (FAILED(hr = SHCreateStreamOnFile(argv[1], STGM_READ, &pFileStream))) { wprintf(L"Error creating file reader, error is %08.8lx", hr); return -1; } if (FAILED(hr = CreateXmlReader(__uuidof(IXmlReader), (void**) &pReader, NULL))) { wprintf(L"Error creating xml reader, error is %08.8lx", hr); return -1; } if (FAILED(hr = pReader->SetProperty(XmlReaderProperty_DtdProcessing, DtdProcessing_Prohibit))) { wprintf(L"Error setting XmlReaderProperty_DtdProcessing, error is %08.8lx", hr); return -1; } if (FAILED(hr = pReader->SetInput(pFileStream))) { wprintf(L"Error setting input for reader, error is %08.8lx", hr); return -1; } //read until there are no more nodes while (S_OK == (hr = pReader->Read(&nodeType))) { switch (nodeType) { case XmlNodeType_XmlDeclaration: wprintf(L"XmlDeclaration\n"); if (FAILED(hr = WriteAttributes(pReader))) { wprintf(L"Error writing attributes, error is %08.8lx", hr); return -1; } break; case XmlNodeType_Element: if (FAILED(hr = pReader->GetPrefix(&pwszPrefix, &cwchPrefix))) { wprintf(L"Error getting prefix, error is %08.8lx", hr); return -1; } if (FAILED(hr = pReader->GetLocalName(&pwszLocalName, NULL))) { wprintf(L"Error getting local name, error is %08.8lx", hr); return -1; } if (cwchPrefix > 0) wprintf(L"Element: %s:%s\n", pwszPrefix, pwszLocalName); else wprintf(L"Element: %s\n", pwszLocalName); if (FAILED(hr = WriteAttributes(pReader))) { wprintf(L"Error writing attributes, error is %08.8lx", hr); return -1; } if (pReader->IsEmptyElement() ) wprintf(L" (empty)"); break; case XmlNodeType_EndElement: if (FAILED(hr = pReader->GetPrefix(&pwszPrefix, &cwchPrefix))) { wprintf(L"Error getting prefix, error is %08.8lx", hr); return -1; } if (FAILED(hr = pReader->GetLocalName(&pwszLocalName, NULL))) { wprintf(L"Error getting local name, error is %08.8lx", hr); return -1; } if (cwchPrefix > 0) wprintf(L"End Element: %s:%s\n", pwszPrefix, pwszLocalName); else wprintf(L"End Element: %s\n", pwszLocalName); break; case XmlNodeType_Text: case XmlNodeType_Whitespace: if (FAILED(hr = pReader->GetValue(&pwszValue, NULL))) { wprintf(L"Error getting value, error is %08.8lx", hr); return -1; } wprintf(L"Text: >%s<\n", pwszValue); break; case XmlNodeType_CDATA: if (FAILED(hr = pReader->GetValue(&pwszValue, NULL))) { wprintf(L"Error getting value, error is %08.8lx", hr); return -1; } wprintf(L"CDATA: %s\n", pwszValue); break; case XmlNodeType_ProcessingInstruction: if (FAILED(hr = pReader->GetLocalName(&pwszLocalName, NULL))) { wprintf(L"Error getting name, error is %08.8lx", hr); return -1; } if (FAILED(hr = pReader->GetValue(&pwszValue, NULL))) { wprintf(L"Error getting value, error is %08.8lx", hr); return -1; } wprintf(L"Processing Instruction name:%S value:%S\n", pwszLocalName, pwszValue); break; case XmlNodeType_Comment: if (FAILED(hr = pReader->GetValue(&pwszValue, NULL))) { wprintf(L"Error getting value, error is %08.8lx", hr); return -1; } wprintf(L"Comment: %s\n", pwszValue); break; case XmlNodeType_DocumentType: wprintf(L"DOCTYPE is not printed\n"); break; } } return 0; }