TRY_CATCH /// Check up pointers if(!var.get() || (NULL == size)) MCException(_T("Invalid pointer.")); /// Init local variables SPCharBuf buf; IStream* stream; HRESULT result = S_OK; ULARGE_INTEGER count; LARGE_INTEGER pos; pos.QuadPart = 0; ULONG read; /// Create stream in the memory result = CreateStreamOnHGlobal(NULL, TRUE, &stream); if(S_OK != result) throw MCException(Format(_T("Failed to CreateStreamOnHGlobal (%X)."), result)); /// Write variant to stream result = var->WriteToStream(stream); if(S_OK != result) throw MCException(Format(_T("Failed to WriteToStream (%X)."), result)); /// Calculate size of data result = stream->Seek(pos, STREAM_SEEK_END, &count); if(S_OK != result) throw MCException(Format(_T("Failed to IStream->Seek (%X)."), result)); /// Check up size if(count.HighPart > 0)
void CEditModeSelectView::OnDraw(CDC* pDC) { CNoteEditingToolDoc* pDoc = GetDocument(); // TODO: 여기에 그리기 코드를 추가합니다. // 더블버퍼링을 위해 CDC memCDC; CBitmap bForMemCDC; CRect rect; // 창 크기를 받아온다. GetClientRect(&rect); bForMemCDC.DeleteObject(); bForMemCDC.CreateCompatibleBitmap(pDC, rect.Width(), rect.Height()); memCDC.CreateCompatibleDC(pDC); memCDC.SelectObject(&bForMemCDC); //Graphics graphics(pDC->m_hDC); Graphics graphics(memCDC.m_hDC); char noteEditingMode = pDoc->getNoteEditingMode(); char noteWriteType = pDoc->getNoteWriteType(); // 각각의 아이콘들을 출력 할 좌표를 저장하는 함수. int positionX = 0; int positionY = 0; // 배경 그리기 HRSRC hResource = FindResource(AfxGetApp()->m_hInstance, MAKEINTRESOURCE(IDB_PNG_BACK), _T("PNG")); if(!hResource) return; DWORD imageSize = SizeofResource(AfxGetApp()->m_hInstance, hResource); HGLOBAL hGlobal = LoadResource(AfxGetApp()->m_hInstance, hResource); LPVOID pData = LockResource(hGlobal); HGLOBAL hBuffer = GlobalAlloc(GMEM_MOVEABLE, imageSize); LPVOID pBuffer = GlobalLock(hBuffer); CopyMemory(pBuffer,pData,imageSize); GlobalUnlock(hBuffer); IStream *pStream; HRESULT hr = CreateStreamOnHGlobal(hBuffer, TRUE, &pStream); Image imagePNG(pStream); pStream->Release(); if (imagePNG.GetLastStatus() != Ok) return; graphics.DrawImage(&imagePNG, 0, 0, imagePNG.GetWidth(), imagePNG.GetHeight()); // 현재 선택중인 위치의 음영 hResource = FindResource(AfxGetApp()->m_hInstance, MAKEINTRESOURCE(IDB_PNG_SEL_OK), _T("PNG")); if(!hResource) return; imageSize = SizeofResource(AfxGetApp()->m_hInstance, hResource); hGlobal = LoadResource(AfxGetApp()->m_hInstance, hResource); pData = LockResource(hGlobal); hBuffer = GlobalAlloc(GMEM_MOVEABLE, imageSize); pBuffer = GlobalLock(hBuffer); CopyMemory(pBuffer,pData,imageSize); GlobalUnlock(hBuffer); hr = CreateStreamOnHGlobal(hBuffer, TRUE, &pStream); Image imagePNGSelOk(pStream); pStream->Release(); if (imagePNGSelOk.GetLastStatus() != Ok) return; // 음영 위치를 상태에 맞게 변화시킨다. if ( calSelectedMenuCursor(noteWriteType, positionX, positionY) < 0 ) { AfxMessageBox(_T("에러!")); } else { graphics.DrawImage(&imagePNGSelOk, positionX, positionY, imagePNGSelOk.GetWidth(), imagePNGSelOk.GetHeight()); } // 현재 선택중인 편집 모드의 음영 hResource = FindResource(AfxGetApp()->m_hInstance, MAKEINTRESOURCE(IDB_PNG_MODE_SEL), _T("PNG")); if(!hResource) return; imageSize = SizeofResource(AfxGetApp()->m_hInstance, hResource); hGlobal = LoadResource(AfxGetApp()->m_hInstance, hResource); pData = LockResource(hGlobal); hBuffer = GlobalAlloc(GMEM_MOVEABLE, imageSize); pBuffer = GlobalLock(hBuffer); CopyMemory(pBuffer,pData,imageSize); GlobalUnlock(hBuffer); hr = CreateStreamOnHGlobal(hBuffer, TRUE, &pStream); Image imagePNGModeSelOk(pStream); pStream->Release(); if (imagePNGModeSelOk.GetLastStatus() != Ok) return; // 음영 위치를 상태에 맞게 변화시킨다. if ( calSelectedModeCursor(noteEditingMode, positionX, positionY) < 0 ) { AfxMessageBox(_T("에러!")); } else { graphics.DrawImage(&imagePNGModeSelOk, positionX, positionY, imagePNGModeSelOk.GetWidth(), imagePNGModeSelOk.GetHeight()); } // 현재 선택중인 재생 모드의 음영 hResource = FindResource(AfxGetApp()->m_hInstance, MAKEINTRESOURCE(IDB_PNG_MODE_SEL), _T("PNG")); if(!hResource) return; imageSize = SizeofResource(AfxGetApp()->m_hInstance, hResource); hGlobal = LoadResource(AfxGetApp()->m_hInstance, hResource); pData = LockResource(hGlobal); hBuffer = GlobalAlloc(GMEM_MOVEABLE, imageSize); pBuffer = GlobalLock(hBuffer); CopyMemory(pBuffer,pData,imageSize); GlobalUnlock(hBuffer); hr = CreateStreamOnHGlobal(hBuffer, TRUE, &pStream); Image imagePNGPlaySelOk(pStream); pStream->Release(); if (imagePNGPlaySelOk.GetLastStatus() != Ok) return; // 음영 위치를 상태에 맞게 변화시킨다. if ( calSelectedPlayCursor(pDoc->getNotePickingViewPtr()->getNowPlayingStatus(), positionX, positionY) < 0 ) { // 그리지 않는다. //AfxMessageBox(_T("에러!")); } else { graphics.DrawImage(&imagePNGPlaySelOk, positionX, positionY, imagePNGPlaySelOk.GetWidth(), imagePNGPlaySelOk.GetHeight()); } // 연필 hResource = FindResource(AfxGetApp()->m_hInstance, MAKEINTRESOURCE(IDB_PNG_PENCIL), _T("PNG")); if(!hResource) return; imageSize = SizeofResource(AfxGetApp()->m_hInstance, hResource); hGlobal = LoadResource(AfxGetApp()->m_hInstance, hResource); pData = LockResource(hGlobal); hBuffer = GlobalAlloc(GMEM_MOVEABLE, imageSize); pBuffer = GlobalLock(hBuffer); CopyMemory(pBuffer,pData,imageSize); GlobalUnlock(hBuffer); hr = CreateStreamOnHGlobal(hBuffer, TRUE, &pStream); Image imagePNGPencil(pStream); pStream->Release(); if (imagePNGPencil.GetLastStatus() != Ok) return; graphics.DrawImage(&imagePNGPencil, V_PENCIL_OFFSET_X, V_PENCIL_OFFSET_Y, imagePNGPencil.GetWidth(), imagePNGPencil.GetHeight()); // 글자 넣기 hResource = FindResource(AfxGetApp()->m_hInstance, MAKEINTRESOURCE(IDB_PNG_TEXT), _T("PNG")); if(!hResource) return; imageSize = SizeofResource(AfxGetApp()->m_hInstance, hResource); hGlobal = LoadResource(AfxGetApp()->m_hInstance, hResource); pData = LockResource(hGlobal); hBuffer = GlobalAlloc(GMEM_MOVEABLE, imageSize); pBuffer = GlobalLock(hBuffer); CopyMemory(pBuffer,pData,imageSize); GlobalUnlock(hBuffer); *pStream; hr = CreateStreamOnHGlobal(hBuffer, TRUE, &pStream); Image imagePNGText(pStream); pStream->Release(); if (imagePNGText.GetLastStatus() != Ok) return; graphics.DrawImage(&imagePNGText, V_TEXT_OFFSET_X, V_TEXT_OFFSET_Y, imagePNGText.GetWidth(), imagePNGText.GetHeight()); // 마지막에 한번에 화면 그리기 pDC->BitBlt(0, 0, rect.Width(), rect.Height(), &memCDC, 0, 0, SRCCOPY); }
static void test_persist_save_data(const char *testname, IHlink *lnk, const unsigned char *expected_data, unsigned int expected_data_size, const unsigned char *expected_data_alt, unsigned int expected_data_alt_size) { HRESULT hr; IStream *stream; IPersistStream *ps; HGLOBAL hglobal; DWORD data_size; const unsigned char *data; DWORD i; BOOL same; unsigned int expected_data_win9x_size = 0; hr = IHlink_QueryInterface(lnk, &IID_IPersistStream, (void **)&ps); ok(hr == S_OK, "IHlink_QueryInterface failed with error 0x%08x\n", hr); hr = CreateStreamOnHGlobal(NULL, TRUE, &stream); ok(hr == S_OK, "CreateStreamOnHGlobal failed with error 0x%08x\n", hr); hr = IPersistStream_Save(ps, stream, TRUE); ok(hr == S_OK, "IPersistStream_Save failed with error 0x%08x\n", hr); hr = GetHGlobalFromStream(stream, &hglobal); ok(hr == S_OK, "GetHGlobalFromStream failed with error 0x%08x\n", hr); data_size = GlobalSize(hglobal); data = GlobalLock(hglobal); if (expected_data_size % 4) expected_data_win9x_size = 4 * ((expected_data_size / 4) + 1); /* first check we have the right amount of data */ ok((data_size == expected_data_size) || (data_size == expected_data_alt_size) || broken(data_size == expected_data_win9x_size), /* Win9x and WinMe */ "%s: Size of saved data differs (expected %d or %d, actual %d)\n", testname, expected_data_size, expected_data_alt_size, data_size); same = TRUE; /* then do a byte-by-byte comparison */ for (i = 0; i < min(data_size, expected_data_size); i++) { if ((expected_data[i] != data[i]) && (((expected_data != expected_hlink_data2) && (expected_data != expected_hlink_data3)) || ((i < 52 || i >= 56) && (i < 80 || i >= 84)))) { same = FALSE; break; } } if (!same && (expected_data_alt != expected_data)) { /* then try the alternate data */ same = TRUE; for (i = 0; i < min(data_size, expected_data_alt_size); i++) { if ((expected_data_alt[i] != data[i]) && (((expected_data_alt != expected_hlink_data2) && (expected_data_alt != expected_hlink_data3)) || ((i < 52 || i >= 56) && (i < 80 || i >= 84)))) { same = FALSE; break; } } } ok(same, "%s: Saved data differs\n", testname); if (!same) { for (i = 0; i < data_size; i++) { if (i % 8 == 0) printf(" "); printf("0x%02x,", data[i]); if (i % 8 == 7) printf("\n"); } printf("\n"); } GlobalUnlock(hglobal); IStream_Release(stream); IPersistStream_Release(ps); }
LRESULT COldVideoRecvTestDlg::OnProceVideo(WPARAM wParam, LPARAM lParam) { if(lParam == NULL) { return E_FAIL; } VIDEO_PACKET_DATA* TmpVideo = (VIDEO_PACKET_DATA*)lParam; switch(TmpVideo->dwVideoType) { case VIDEO_TYPE_H264_NORMAL_I: case VIDEO_TYPE_H264_NORMAL_P: { CString strMsg; strMsg.Format("DataLen = %d, ExtInfo = %s", TmpVideo->dwVideoDataLen, TmpVideo->pszVideoExInfo); HDC TempDC = ::GetDC(GetDlgItem(IDC_STATIC_VIDEO)->GetSafeHwnd()); SetBkMode(TempDC, 3); SetTextColor(TempDC, RGB(0, 128, 0)); Rectangle(TempDC, 10, 20, 700, 80); TextOut(TempDC, 20, 20, "H264CallBack FrameInfo:", 23); int ilen = strMsg.GetLength(); CString str1 = strMsg.Left(60); CString str2 = strMsg.Right(ilen - 60); TextOut(TempDC, 20, 40, str1.GetBuffer(), str1.GetLength()); TextOut(TempDC, 20, 60, str2.GetBuffer(), str2.GetLength()); //TextOut(TempDC, 20, 40, strMsg.GetBuffer(), strMsg.GetLength()); ::ReleaseDC(GetDlgItem(IDC_STATIC_VIDEO)->GetSafeHwnd(), TempDC); } break; case VIDEO_TYPE_H264_HISTORY_I: case VIDEO_TYPE_H264_HISTORY_P: { CString strMsg; strMsg.Format("DataLen = %d, ExtInfo = %s", TmpVideo->dwVideoDataLen, TmpVideo->pszVideoExInfo); HDC TempDC = ::GetDC(GetDlgItem(IDC_STATIC_VIDEO)->GetSafeHwnd()); SetBkMode(TempDC, 3); SetTextColor(TempDC, RGB(0, 128, 0)); Rectangle(TempDC, 10, 20, 700, 100); TextOut(TempDC, 20, 20, "H264CallBack FrameInfo:", 23); int ilen = strMsg.GetLength(); CString str1 = strMsg.Left(60); CString str2 = strMsg.Right(ilen - 60); TextOut(TempDC, 20, 40, str1.GetBuffer(), str1.GetLength()); TextOut(TempDC, 20, 60, str2.GetBuffer(), str2.GetLength()); //TextOut(TempDC, 20, 40, strMsg.GetBuffer(), strMsg.GetLength()); char* pszTime = strstr(TmpVideo->pszVideoExInfo, "FrameTime:"); DWORD64 dw64TimeMS = 0; if(pszTime) { sscanf(pszTime, "FrameTime:%I64u", &dw64TimeMS); CTime cFrameTime(dw64TimeMS/1000); strMsg = cFrameTime.Format("%Y.%m.%d_%H:%M:%S"); TextOut(TempDC, 20, 60, strMsg.GetBuffer(), strMsg.GetLength()); } ::ReleaseDC(GetDlgItem(IDC_STATIC_VIDEO)->GetSafeHwnd(), TempDC); if((dw64TimeMS/1000) >= m_dwEndTime) { ::SendMessage(GetSafeHwnd(), WM_MESSAGE_GETFINISH, 0, 0); } } break; case VIDEO_TYPE_JPEG_HISTORY: { PBYTE pJPEGPos = NULL; DWORD dwJPEGDataLen = 0; int iRedLightCount = 0; int iRedLightBufPosLen = sizeof(RECT) * 20; PBYTE pRedLightPosBuf = new BYTE[iRedLightBufPosLen]; if(HVAPIUTILS_ParseHistoryVideoFrame(TmpVideo->pVideoData, TmpVideo->dwVideoDataLen, iRedLightCount, iRedLightBufPosLen, pRedLightPosBuf, pJPEGPos, dwJPEGDataLen) != S_OK) { return E_FAIL; } if(pJPEGPos == NULL || dwJPEGDataLen <= 0) { return E_FAIL; } int iEnhanceBufLen = 0; PBYTE pEnhanceBuf = NULL; if(m_iRedLightEnhanceFlag == 1) { iEnhanceBufLen = (1024 << 10); pEnhanceBuf = new BYTE[iEnhanceBufLen]; if(pEnhanceBuf) { if(HVAPIUTILS_TrafficLightEnhance(pJPEGPos, dwJPEGDataLen, iRedLightCount, pRedLightPosBuf, pEnhanceBuf, iEnhanceBufLen, m_iBrightness, m_iHueThreshold, m_CompressRate) != S_OK) { delete[] pEnhanceBuf; pEnhanceBuf = NULL; iEnhanceBufLen = 0; } } } IStream* pStm = NULL; CreateStreamOnHGlobal(NULL, TRUE, &pStm); IPicture* picholder; LARGE_INTEGER liTempStar = {0}; pStm->Seek(liTempStar, STREAM_SEEK_SET, NULL); ULONG iWritten = NULL; if(pEnhanceBuf) pStm->Write(pEnhanceBuf, iEnhanceBufLen, &iWritten); else pStm->Write(pJPEGPos, dwJPEGDataLen, &iWritten); pStm->Seek(liTempStar, STREAM_SEEK_SET, NULL); if(pEnhanceBuf) { if(FAILED(OleLoadPicture(pStm, iEnhanceBufLen, TRUE, IID_IPicture, (void**)&picholder))) { pStm->Release(); return E_FAIL; } } else { if(FAILED(OleLoadPicture(pStm, dwJPEGDataLen, TRUE, IID_IPicture, (void**)&picholder))) { pStm->Release(); return E_FAIL; } } HDC TempDC; TempDC = ::GetDC(GetDlgItem(IDC_STATIC_VIDEO)->GetSafeHwnd()); OLE_XSIZE_HIMETRIC hmWidth; OLE_YSIZE_HIMETRIC hmHeight; picholder->get_Width(&hmWidth); picholder->get_Height(&hmHeight); int nWidth =MulDiv(hmWidth, GetDeviceCaps(TempDC, LOGPIXELSX), 2540); int nHeight = MulDiv(hmHeight, GetDeviceCaps(TempDC, LOGPIXELSY), 2540); picholder->Render(TempDC, 0, 0, m_ShowFrameRect.right-m_ShowFrameRect.left, m_ShowFrameRect.bottom-m_ShowFrameRect.top, 0, hmHeight, hmWidth, -hmHeight, NULL); ::ReleaseDC(GetDlgItem(IDC_STATIC_VIDEO)->GetSafeHwnd(), TempDC); picholder->Release(); pStm->Release(); CString strMsg; strMsg.Format("DataLen = %d, ExtInfo = %s", TmpVideo->dwVideoDataLen, TmpVideo->pszVideoExInfo); TempDC = ::GetDC(GetDlgItem(IDC_STATIC_VIDEO)->GetSafeHwnd()); SetBkMode(TempDC, 3); SetTextColor(TempDC, RGB(0, 128, 0)); Rectangle(TempDC, 10, 220, 700, 280); TextOut(TempDC, 20, 220, "HistoryVideoCallback JPEG FrameInfo:", 23); TextOut(TempDC, 20, 240, strMsg.GetBuffer(), strMsg.GetLength()); char* pszTime = strstr(TmpVideo->pszVideoExInfo, "FrameTime:"); DWORD64 dw64TimeMS = 0; if(pszTime) { sscanf(pszTime, "FrameTime:%I64u", &dw64TimeMS); } CTime cFrameTime(dw64TimeMS/1000); strMsg = cFrameTime.Format("%Y.%m.%d_%H:%M:%S"); TextOut(TempDC, 20, 260, strMsg.GetBuffer(), strMsg.GetLength()); ::ReleaseDC(GetDlgItem(IDC_STATIC_VIDEO)->GetSafeHwnd(), TempDC); SetWindowText(strMsg.GetBuffer()); if((dw64TimeMS/1000) >= m_dwEndTime) { ::SendMessage(GetSafeHwnd(), WM_MESSAGE_GETFINISH, 0, 0); } } break; } return S_OK; }
static void test_writestartelement(void) { static const WCHAR valueW[] = {'v','a','l','u','e',0}; static const char *str = "<a><b>value</b>"; static const WCHAR aW[] = {'a',0}; static const WCHAR bW[] = {'b',0}; char *ptr; IXmlWriter *writer; IStream *stream; HGLOBAL hglobal; HRESULT hr; hr = CreateStreamOnHGlobal(NULL, TRUE, &stream); ok(hr == S_OK, "got 0x%08x\n", hr); hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); hr = IXmlWriter_WriteStartElement(writer, NULL, aW, NULL); ok(hr == E_UNEXPECTED, "got 0x%08x\n", hr); hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXmlWriter_WriteStartElement(writer, aW, NULL, NULL); ok(hr == E_INVALIDARG, "got 0x%08x\n", hr); hr = IXmlWriter_WriteStartElement(writer, NULL, NULL, NULL); ok(hr == E_INVALIDARG, "got 0x%08x\n", hr); hr = IXmlWriter_WriteStartElement(writer, NULL, NULL, aW); ok(hr == E_INVALIDARG, "got 0x%08x\n", hr); hr = IXmlWriter_WriteStartElement(writer, NULL, aW, NULL); ok(hr == S_OK, "got 0x%08x\n", hr); hr = GetHGlobalFromStream(stream, &hglobal); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes); ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr); hr = IXmlWriter_Flush(writer); ok(hr == S_OK, "got 0x%08x\n", hr); ptr = GlobalLock(hglobal); ok(!strncmp(ptr, "<a", 2), "got %s\n", ptr); GlobalUnlock(hglobal); hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes); ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr); hr = IXmlWriter_WriteStartElement(writer, NULL, NULL, NULL); ok(hr == E_INVALIDARG, "got 0x%08x\n", hr); hr = IXmlWriter_WriteProcessingInstruction(writer, aW, aW); ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr); IStream_Release(stream); IXmlWriter_Release(writer); /* WriteElementString */ hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); hr = CreateStreamOnHGlobal(NULL, TRUE, &stream); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXmlWriter_WriteElementString(writer, NULL, bW, NULL, valueW); ok(hr == E_UNEXPECTED, "got 0x%08x\n", hr); hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXmlWriter_WriteStartElement(writer, NULL, aW, NULL); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXmlWriter_WriteElementString(writer, NULL, bW, NULL, valueW); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXmlWriter_Flush(writer); ok(hr == S_OK, "got 0x%08x\n", hr); hr = GetHGlobalFromStream(stream, &hglobal); ok(hr == S_OK, "got 0x%08x\n", hr); ptr = GlobalLock(hglobal); ok(!strncmp(ptr, str, strlen(str)), "got %s\n", ptr); GlobalUnlock(hglobal); IStream_Release(stream); IXmlWriter_Release(writer); }
static void test_CreateMessage(void) { HRESULT hr; IMimeMessage *msg; IStream *stream; LARGE_INTEGER pos; LONG ref; HBODY hbody; IMimeBody *body; BODYOFFSETS offsets; ULONG count; FINDBODY find_struct; HCHARSET hcs; char text[] = "text"; HBODY *body_list; PROPVARIANT prop; static const char att_pritype[] = "att:pri-content-type"; hr = MimeOleCreateMessage(NULL, &msg); ok(hr == S_OK, "ret %08x\n", hr); CreateStreamOnHGlobal(NULL, TRUE, &stream); IStream_Write(stream, msg1, sizeof(msg1) - 1, NULL); pos.QuadPart = 0; IStream_Seek(stream, pos, STREAM_SEEK_SET, NULL); hr = IMimeMessage_Load(msg, stream); ok(hr == S_OK, "ret %08x\n", hr); hr = IMimeMessage_CountBodies(msg, HBODY_ROOT, TRUE, &count); ok(hr == S_OK, "ret %08x\n", hr); ok(count == 3, "got %d\n", count); hr = IMimeMessage_CountBodies(msg, HBODY_ROOT, FALSE, &count); ok(hr == S_OK, "ret %08x\n", hr); ok(count == 3, "got %d\n", count); hr = IMimeMessage_BindToObject(msg, HBODY_ROOT, &IID_IMimeBody, (void**)&body); ok(hr == S_OK, "ret %08x\n", hr); hr = IMimeBody_GetOffsets(body, &offsets); ok(hr == S_OK, "ret %08x\n", hr); ok(offsets.cbBoundaryStart == 0, "got %d\n", offsets.cbBoundaryStart); ok(offsets.cbHeaderStart == 0, "got %d\n", offsets.cbHeaderStart); ok(offsets.cbBodyStart == 359, "got %d\n", offsets.cbBodyStart); ok(offsets.cbBodyEnd == 666, "got %d\n", offsets.cbBodyEnd); IMimeBody_Release(body); hr = IMimeMessage_GetBody(msg, IBL_ROOT, NULL, &hbody); ok(hr == S_OK, "ret %08x\n", hr); PropVariantInit(&prop); hr = IMimeMessage_GetBodyProp(msg, hbody, att_pritype, 0, &prop); ok(hr == S_OK, "ret %08x\n", hr); ok(prop.vt == VT_LPSTR, "vt %08x\n", prop.vt); ok(!strcasecmp(prop.u.pszVal, "multipart"), "got %s\n", prop.u.pszVal); PropVariantClear(&prop); hr = IMimeMessage_GetBody(msg, IBL_FIRST, hbody, &hbody); ok(hr == S_OK, "ret %08x\n", hr); hr = IMimeMessage_BindToObject(msg, hbody, &IID_IMimeBody, (void**)&body); ok(hr == S_OK, "ret %08x\n", hr); hr = IMimeBody_GetOffsets(body, &offsets); ok(hr == S_OK, "ret %08x\n", hr); ok(offsets.cbBoundaryStart == 405, "got %d\n", offsets.cbBoundaryStart); ok(offsets.cbHeaderStart == 428, "got %d\n", offsets.cbHeaderStart); ok(offsets.cbBodyStart == 518, "got %d\n", offsets.cbBodyStart); ok(offsets.cbBodyEnd == 523, "got %d\n", offsets.cbBodyEnd); hr = IMimeBody_GetCharset(body, &hcs); ok(hr == S_OK, "ret %08x\n", hr); todo_wine { ok(hcs != NULL, "Expected non-NULL charset\n"); } IMimeBody_Release(body); hr = IMimeMessage_GetBody(msg, IBL_NEXT, hbody, &hbody); ok(hr == S_OK, "ret %08x\n", hr); hr = IMimeMessage_BindToObject(msg, hbody, &IID_IMimeBody, (void**)&body); ok(hr == S_OK, "ret %08x\n", hr); hr = IMimeBody_GetOffsets(body, &offsets); ok(hr == S_OK, "ret %08x\n", hr); ok(offsets.cbBoundaryStart == 525, "got %d\n", offsets.cbBoundaryStart); ok(offsets.cbHeaderStart == 548, "got %d\n", offsets.cbHeaderStart); ok(offsets.cbBodyStart == 629, "got %d\n", offsets.cbBodyStart); ok(offsets.cbBodyEnd == 639, "got %d\n", offsets.cbBodyEnd); IMimeBody_Release(body); find_struct.pszPriType = text; find_struct.pszSubType = NULL; hr = IMimeMessage_FindFirst(msg, &find_struct, &hbody); ok(hr == S_OK, "ret %08x\n", hr); hr = IMimeMessage_FindNext(msg, &find_struct, &hbody); ok(hr == S_OK, "ret %08x\n", hr); hr = IMimeMessage_FindNext(msg, &find_struct, &hbody); ok(hr == MIME_E_NOT_FOUND, "ret %08x\n", hr); hr = IMimeMessage_GetAttachments(msg, &count, &body_list); ok(hr == S_OK, "ret %08x\n", hr); ok(count == 2, "got %d\n", count); CoTaskMemFree(body_list); hr = IMimeBody_GetCharset(body, &hcs); ok(hr == S_OK, "ret %08x\n", hr); todo_wine { ok(hcs != NULL, "Expected non-NULL charset\n"); } IMimeMessage_Release(msg); ref = IStream_AddRef(stream); ok(ref == 2 || broken(ref == 1), /* win95 */ "ref %d\n", ref); IStream_Release(stream); IStream_Release(stream); }
static HRESULT WINAPI XMLView_PersistMoniker_Load(IPersistMoniker *iface, BOOL fFullyAvailable, IMoniker *pimkName, LPBC pibc, DWORD grfMode) { static const WCHAR XSLParametersW[] = {'X','S','L','P','a','r','a','m','e','t','e','r','s',0}; static const WCHAR XMLBufferStreamW[] = {'X','M','L','B','u','f','f','e','r','S','t','r','e','a','m',0}; static const WCHAR DWNBINDINFOW[] = {'_','_','D','W','N','B','I','N','D','I','N','F','O',0}; static const WCHAR HTMLLOADOPTIONSW[] = {'_','_','H','T','M','L','L','O','A','D','O','P','T','I','O','N','S',0}; static const WCHAR BSCBHolderW[] = { '_','B','S','C','B','_','H','o','l','d','e','r','_',0 }; XMLView *This = impl_from_IPersistMoniker(iface); IPersistMoniker *html_persist_mon; IBindStatusCallback *bsc, *bsc_html; IBindCtx *bindctx; IStream *stream; IMoniker *mon; IUnknown *unk; HRESULT hres; TRACE("(%p)->(%x %p %p %x)\n", This, fFullyAvailable, pimkName, pibc, grfMode); hres = IBindCtx_GetObjectParam(pibc, (LPOLESTR)XSLParametersW, &unk); if(SUCCEEDED(hres)) { FIXME("ignoring XSLParameters\n"); IUnknown_Release(unk); } hres = IBindCtx_GetObjectParam(pibc, (LPOLESTR)XMLBufferStreamW, &unk); if(SUCCEEDED(hres)) { FIXME("ignoring XMLBufferStream\n"); IUnknown_Release(unk); } hres = CreateBindCtx(0, &bindctx); if(FAILED(hres)) return hres; hres = IBindCtx_GetObjectParam(pibc, (LPOLESTR)DWNBINDINFOW, &unk); if(SUCCEEDED(hres)) { IBindCtx_RegisterObjectParam(bindctx, (LPOLESTR)DWNBINDINFOW, unk); IUnknown_Release(unk); } hres = IBindCtx_GetObjectParam(pibc, (LPOLESTR)HTMLLOADOPTIONSW, &unk); if(SUCCEEDED(hres)) { IBindCtx_RegisterObjectParam(bindctx, (LPOLESTR)HTMLLOADOPTIONSW, unk); IUnknown_Release(unk); } hres = IBindCtx_GetObjectParam(pibc, (LPOLESTR)SZ_HTML_CLIENTSITE_OBJECTPARAM, &unk); if(SUCCEEDED(hres)) { IBindCtx_RegisterObjectParam(bindctx, (LPOLESTR)SZ_HTML_CLIENTSITE_OBJECTPARAM, unk); IUnknown_Release(unk); } hres = CreateStreamOnHGlobal(NULL, TRUE, &stream); if(FAILED(hres)) { IBindCtx_Release(bindctx); return hres; } if(This->mon) IMoniker_Release(This->mon); This->mon = pimkName; IMoniker_AddRef(This->mon); hres = XMLView_Moniker_Create(This->mon, stream, &mon); if(FAILED(hres)) { IStream_Release(stream); IBindCtx_Release(bindctx); return hres; } hres = IUnknown_QueryInterface(This->html_doc, &IID_IPersistMoniker, (void**)&html_persist_mon); if(FAILED(hres)) { IMoniker_Release(mon); IStream_Release(stream); IBindCtx_Release(bindctx); return hres; } hres = IPersistMoniker_Load(html_persist_mon, FALSE, mon, bindctx, 0); IPersistMoniker_Release(html_persist_mon); IMoniker_Release(mon); if(FAILED(hres)) { IStream_Release(stream); IBindCtx_Release(bindctx); return hres; } hres = IBindCtx_GetObjectParam(bindctx, (LPOLESTR)BSCBHolderW, &unk); IBindCtx_Release(bindctx); if(FAILED(hres)) { IStream_Release(stream); return hres; } hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)&bsc_html); IUnknown_Release(unk); if(FAILED(hres)) { IStream_Release(stream); return hres; } hres = XMLView_BindStatusCallback_Create(bsc_html, This->mon, stream, &bsc); IStream_Release(stream); if(FAILED(hres)) { IBindStatusCallback_OnStopBinding(bsc_html, hres, NULL); IBindStatusCallback_Release(bsc_html); return hres; } hres = RegisterBindStatusCallback(pibc, bsc, NULL, 0); IBindStatusCallback_Release(bsc); if(FAILED(hres)) { IBindStatusCallback_OnStopBinding(bsc_html, hres, NULL); IBindStatusCallback_Release(bsc_html); return hres; } hres = IMoniker_BindToStorage(pimkName, pibc, NULL, &IID_IStream, (void**)&stream); if(FAILED(hres)) { IBindStatusCallback_OnStopBinding(bsc_html, hres, NULL); IBindStatusCallback_Release(bsc_html); return hres; } if(stream) IStream_Release(stream); IBindStatusCallback_Release(bsc_html); return S_OK; }
HRESULT CHttpDownloader::ReadData(_bstr_t &strBuffer) { HRESULT hr = E_FAIL; IStream *pStream = NULL; INTERNET_BUFFERS ib ={0}; ULONG ulWritten; BOOL bResult; DWORD dwErr; TCHAR buf[32]; DWORD dwBufferLength; TCHAR *szNULL = _T("\x0"); // Get file size dwBufferLength = 32*sizeof(TCHAR); if(::HttpQueryInfo(m_hRequest, HTTP_QUERY_CONTENT_LENGTH, buf, &dwBufferLength, NULL)) { m_dwTotalSize = _tcstoul(buf, &szNULL, 10); if(m_hWnd != NULL && m_nMessage != 0) ::PostMessage(m_hWnd, m_nMessage, m_dwDownloaded, m_dwTotalSize); } //Check MD5 hash if(m_request.md5 != NULL && _tcslen(m_request.md5) >= 22) { dwBufferLength = 32*sizeof(TCHAR); if(::HttpQueryInfo(m_hRequest, HTTP_QUERY_CONTENT_MD5, buf, &dwBufferLength, NULL)) { if(0 == _tcsnicmp(m_request.md5, buf, 22)) { if(m_hWnd != NULL && m_nMessage != 0) ::PostMessage(m_hWnd, m_nMessage, m_dwTotalSize, m_dwTotalSize); } return S_OK; } } hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream); if(FAILED(hr)) { return hr; } ib.lpcszHeader = NULL; ib.dwHeadersLength = NULL; ib.lpvBuffer = new TCHAR[COMMAND_BUFF_SIZE_PART]; ib.dwBufferLength = COMMAND_BUFF_SIZE_PART; ib.dwStructSize = sizeof(ib); do { ib.dwBufferLength = COMMAND_BUFF_SIZE_PART; if(m_longAbort > 0) { hr = E_ABORT; break; } m_context.op = HTTP_DOWNLOADER_OP_READ_DATA; bResult = InternetReadFileEx(m_hRequest, &ib, IRF_ASYNC | IRF_USE_CONTEXT, (DWORD)&m_context); dwErr = GetLastError(); if(!bResult && dwErr == 997) // Overlapped I/O operation is in progress. { bResult = WaitForComplete(m_dwTimeout); if(bResult) continue; } if(bResult) { if(ib.dwBufferLength) { hr = pStream->Write(ib.lpvBuffer, ib.dwBufferLength, &ulWritten); if(FAILED(hr)) { strBuffer = _T("Cannot write to stream"); break; } m_dwDownloaded += ib.dwBufferLength; if(m_hWnd != NULL && m_nMessage != 0) ::PostMessage(m_hWnd, m_nMessage, m_dwDownloaded, m_dwTotalSize); } } else { hr = E_FAIL; break; } // Sleep(1); } while(ib.dwBufferLength); if(ib.lpvBuffer) { delete[] ib.lpvBuffer; ib.lpvBuffer = NULL; } if(SUCCEEDED(hr) && pStream) { m_pStream = pStream; return hr; } else { if(pStream) pStream->Release(); pStream = NULL; } return hr; }
STDMETHOD(Assemble)(VARIANT varInput, IStream **ppOutput) { mode = m_dwOptions; if (V_VT(&varInput) == VT_BSTR) { mode |= MODE_NORMAL | MODE_COMMANDLINE; mode &= ~MODE_LIST; if (m_fFirstAssembly) { init_storage(); } CW2CT szInput(V_BSTR(&varInput)); input_contents = strdup(szInput); curr_input_file = strdup("COM Interface"); } else { mode &= ~MODE_COMMANDLINE; mode |= MODE_NORMAL; curr_input_file = strdup(m_bstrInputFile); output_filename = strdup(m_bstrOutputFile); if (!m_fFirstAssembly) { free_storage(); } init_storage(); } // Set up the include directories CComPtr<IUnknown> pEnumUnk; HRESULT hr = m_pDirectories->get__NewEnum(&pEnumUnk); CComQIPtr<IEnumVARIANT> pEnum = pEnumUnk; CComVariant varItem; ULONG ulFetched; while (pEnum->Next(1, &varItem, &ulFetched) == S_OK) { include_dirs = list_prepend(include_dirs, (char *) strdup(_bstr_t(V_BSTR(&varItem)))); } AddDefines(); int error = run_assembly(); list_free(include_dirs, true, NULL); include_dirs = NULL; ClearSPASMErrorSessions(); long assembled_size = out_ptr - output_contents; HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, assembled_size); unsigned char *streambuf = (unsigned char *)GlobalLock(hGlobal); memcpy(streambuf, output_contents, assembled_size); GlobalUnlock(hGlobal); CComPtr<IStream> pStream; hr = CreateStreamOnHGlobal(hGlobal, TRUE, &pStream); ULARGE_INTEGER ul; ul.QuadPart = assembled_size; pStream->SetSize(ul); m_fFirstAssembly = FALSE; if (output_filename != NULL) { free(output_filename); output_filename = NULL; } if (curr_input_file) { free(curr_input_file); curr_input_file = NULL; } if (mode & MODE_COMMANDLINE) { free(input_contents); input_contents = NULL; } m_fLabelsAreValid = FALSE; return pStream->QueryInterface(ppOutput); }
LIB3MFMETHODIMP CCOMModelTexture2D::ReadFromStream(_In_ IStream * pStream) { try { if (pStream == nullptr) throw CNMRException(NMR_ERROR_INVALIDPOINTER); HRESULT hResult; CModelTexture2DResource * pTextureResource = getTexture2D(); __NMRASSERT(pTextureResource); CComPtr<IStream> pMemoryStream = nullptr; hResult = CreateStreamOnHGlobal(nullptr, true, &pMemoryStream); if (hResult != S_OK) throw CNMRException_Windows(NMR_ERROR_COULDNOTCREATESTREAM, hResult); // Seek Stream LARGE_INTEGER nOriginPosition; ULARGE_INTEGER nNewPosition; nOriginPosition.HighPart = 0; nOriginPosition.LowPart = 0; hResult = pStream->Seek(nOriginPosition, STREAM_SEEK_END, &nNewPosition); if (hResult != S_OK) throw CNMRException_Windows(NMR_ERROR_COULDNOTSEEKSTREAM, hResult); nfUint64 cbStreamSize = nNewPosition.QuadPart; hResult = pStream->Seek(nOriginPosition, STREAM_SEEK_SET, &nNewPosition); if (hResult != S_OK) throw CNMRException_Windows(NMR_ERROR_COULDNOTSEEKSTREAM, hResult); std::array<nfByte, NMR_IMPORTSTREAM_COPYBUFFERSIZE> pBuffer; nfUint64 cbBytesLeft = cbStreamSize; while (cbBytesLeft > 0) { nfUint64 cbLength = cbBytesLeft; if (cbLength > NMR_IMPORTSTREAM_COPYBUFFERSIZE) cbLength = NMR_IMPORTSTREAM_COPYBUFFERSIZE; ULONG cbReadBytes = 0; ULONG cbWrittenBytes = 0; hResult = pStream->Read(&pBuffer[0], (nfUint32)cbLength, &cbReadBytes); if (hResult != S_OK) throw CNMRException_Windows(NMR_ERROR_COULDNOTREADSTREAM, hResult); if (cbReadBytes != cbLength) throw CNMRException(NMR_ERROR_COULDNOTREADFULLDATA); hResult = pMemoryStream->Write(&pBuffer[0], (nfUint32)cbLength, &cbWrittenBytes); if (hResult != S_OK) throw CNMRException_Windows(NMR_ERROR_COULDNOTWRITESTREAM, hResult); if (cbWrittenBytes != cbLength) throw CNMRException(NMR_ERROR_COULDNOTWRITEFULLDATA); cbBytesLeft -= cbLength; } PImportStream pImportStream = std::make_shared<CImportStream_COM>(pMemoryStream); CModel * pModel = pTextureResource->getModel(); __NMRASSERT(pModel); pModel->removeTextureStream(pTextureResource->getPath()); pModel->addTextureStream(pTextureResource->getPath(), pImportStream); return handleSuccess(); } catch (CNMRException & Exception) { return handleNMRException(&Exception); } catch (...) { return handleGenericException(); } }
static void test_persiststreaminit(void) { IXMLDocument *doc = NULL; IXMLElement *element = NULL; IPersistStreamInit *psi = NULL; IStream *stream = NULL; STATSTG stat; HRESULT hr; ULARGE_INTEGER size; CHAR path[MAX_PATH]; CLSID id; BSTR str; static const WCHAR testW[] = {'t','e','s','t',0}; hr = CoCreateInstance(&CLSID_XMLDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDocument, (LPVOID*)&doc); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); hr = IXMLDocument_QueryInterface(doc, &IID_IPersistStreamInit, (LPVOID *)&psi); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(psi != NULL, "Expected non-NULL psi\n"); /* null arguments */ hr = IPersistStreamInit_GetSizeMax(psi, NULL); ok(hr == E_NOTIMPL, "Expected E_NOTIMPL, got %08x\n", hr); hr = IPersistStreamInit_Load(psi, NULL); ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr); hr = IPersistStreamInit_Save(psi, NULL, FALSE); todo_wine ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr); hr = IPersistStreamInit_GetClassID(psi, NULL); ok(hr == E_POINTER, "Expected E_POINTER, got %08x\n", hr); hr = IPersistStreamInit_IsDirty(psi); todo_wine ok(hr == S_FALSE, "Expected S_FALSE, got %08x\n", hr); create_xml_file("bank.xml"); GetFullPathNameA("bank.xml", MAX_PATH, path, NULL); create_stream_on_file(&stream, path); /* GetSizeMax not implemented */ size.QuadPart = 0; hr = IPersistStreamInit_GetSizeMax(psi, &size); ok(hr == E_NOTIMPL, "Expected E_NOTIMPL, got %08x\n", hr); ok(size.QuadPart == 0, "Expected 0\n"); hr = IPersistStreamInit_Load(psi, stream); IStream_Release(stream); ok(hr == S_OK || hr == XML_E_INVALIDATROOTLEVEL, "Expected S_OK, got %08x\n", hr); if(hr == XML_E_INVALIDATROOTLEVEL) goto cleanup; hr = IPersistStreamInit_IsDirty(psi); todo_wine ok(hr == S_FALSE, "Expected S_FALSE, got %08x\n", hr); /* try to save document */ stream = NULL; hr = CreateStreamOnHGlobal(NULL, TRUE, &stream); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); hr = IPersistStreamInit_Save(psi, stream, FALSE); todo_wine ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); stat.cbSize.QuadPart = 0; hr = IStream_Stat(stream, &stat, 0); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); todo_wine ok(stat.cbSize.QuadPart > 0, "Expected >0\n"); IStream_Release(stream); str = SysAllocString(testW); hr = IXMLDocument_get_root(doc, &element); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); hr = IXMLElement_put_text(element, str); ok(hr == E_NOTIMPL, "Expected E_NOTIMPL, got %08x\n", hr); IXMLElement_Release(element); SysFreeString(str); hr = IPersistStreamInit_IsDirty(psi); todo_wine ok(hr == S_FALSE, "Expected S_FALSE, got %08x\n", hr); create_stream_on_file(&stream, path); hr = IPersistStreamInit_Load(psi, stream); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); IStream_Release(stream); hr = IPersistStreamInit_IsDirty(psi); todo_wine ok(hr == S_FALSE, "Expected S_FALSE, got %08x\n", hr); /* reset internal stream */ hr = IPersistStreamInit_InitNew(psi); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); hr = IPersistStreamInit_IsDirty(psi); todo_wine ok(hr == S_FALSE, "Expected S_FALSE, got %08x\n", hr); stream = NULL; hr = CreateStreamOnHGlobal(NULL, TRUE, &stream); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); hr = IPersistStreamInit_Save(psi, stream, FALSE); todo_wine ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); stat.cbSize.QuadPart = 0; hr = IStream_Stat(stream, &stat, 0); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); todo_wine ok(stat.cbSize.QuadPart > 0, "Expected >0\n"); IStream_Release(stream); memset(&id, 0, sizeof(id)); hr = IPersistStreamInit_GetClassID(psi, &id); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(IsEqualCLSID(&id, &CLSID_XMLDocument), "Expected CLSID_XMLDocument\n"); cleanup: IPersistStreamInit_Release(psi); IXMLDocument_Release(doc); DeleteFileA("bank.xml"); }
static void test_Invoke(void) { IPictureDisp *picdisp; HRESULT hr; VARIANTARG vararg; DISPPARAMS dispparams; VARIANT varresult; IStream *stream; HGLOBAL hglob; void *data; hglob = GlobalAlloc (0, sizeof(gifimage)); data = GlobalLock(hglob); memcpy(data, gifimage, sizeof(gifimage)); GlobalUnlock(hglob); hr = CreateStreamOnHGlobal (hglob, FALSE, &stream); ok_ole_success(hr, "CreateStreamOnHGlobal"); hr = pOleLoadPicture(stream, sizeof(gifimage), TRUE, &IID_IPictureDisp, (void **)&picdisp); IStream_Release(stream); ok_ole_success(hr, "OleLoadPicture"); V_VT(&vararg) = VT_BOOL; V_BOOL(&vararg) = VARIANT_FALSE; dispparams.cNamedArgs = 0; dispparams.rgdispidNamedArgs = NULL; dispparams.cArgs = 1; dispparams.rgvarg = &vararg; hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_IPictureDisp, 0, DISPATCH_PROPERTYPUT, &dispparams, NULL, NULL, NULL); ok(hr == DISP_E_UNKNOWNNAME, "IPictureDisp_Invoke should have returned DISP_E_UNKNOWNNAME instead of 0x%08x\n", hr); hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_IUnknown, 0, DISPATCH_PROPERTYPUT, &dispparams, NULL, NULL, NULL); ok(hr == DISP_E_UNKNOWNNAME, "IPictureDisp_Invoke should have returned DISP_E_UNKNOWNNAME instead of 0x%08x\n", hr); dispparams.cArgs = 0; dispparams.rgvarg = NULL; hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_PROPERTYPUT, &dispparams, NULL, NULL, NULL); ok(hr == DISP_E_BADPARAMCOUNT, "IPictureDisp_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr); hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_PROPERTYPUT, NULL, NULL, NULL, NULL); ok(hr == DISP_E_PARAMNOTOPTIONAL, "IPictureDisp_Invoke should have returned DISP_E_PARAMNOTOPTIONAL instead of 0x%08x\n", hr); hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_PROPERTYGET, NULL, NULL, NULL, NULL); ok(hr == DISP_E_PARAMNOTOPTIONAL, "IPictureDisp_Invoke should have returned DISP_E_PARAMNOTOPTIONAL instead of 0x%08x\n", hr); hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_PROPERTYGET, NULL, &varresult, NULL, NULL); ok(hr == DISP_E_PARAMNOTOPTIONAL, "IPictureDisp_Invoke should have returned DISP_E_PARAMNOTOPTIONAL instead of 0x%08x\n", hr); hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &varresult, NULL, NULL); ok_ole_success(hr, "IPictureDisp_Invoke"); ok(V_VT(&varresult) == VT_I4, "V_VT(&varresult) should have been VT_UINT instead of %d\n", V_VT(&varresult)); hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &varresult, NULL, NULL); ok(hr == DISP_E_MEMBERNOTFOUND, "IPictureDisp_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr); hr = IPictureDisp_Invoke(picdisp, 0xdeadbeef, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &varresult, NULL, NULL); ok(hr == DISP_E_MEMBERNOTFOUND, "IPictureDisp_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr); dispparams.cArgs = 1; dispparams.rgvarg = &vararg; hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &varresult, NULL, NULL); ok(hr == DISP_E_BADPARAMCOUNT, "IPictureDisp_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr); dispparams.cArgs = 1; dispparams.rgvarg = &vararg; hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &varresult, NULL, NULL); ok(hr == DISP_E_BADPARAMCOUNT, "IPictureDisp_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr); IPictureDisp_Release(picdisp); }
static void test_pic(const unsigned char *imgdata, unsigned int imgsize) { LPSTREAM stream; HGLOBAL hglob; LPBYTE data; HRESULT hres; LARGE_INTEGER seekto; ULARGE_INTEGER newpos1; DWORD * header; unsigned int i,j; /* Let the fun begin */ hglob = GlobalAlloc (0, imgsize); data = GlobalLock (hglob); memcpy(data, imgdata, imgsize); GlobalUnlock(hglob); data = NULL; hres = CreateStreamOnHGlobal (hglob, FALSE, &stream); ok (hres == S_OK, "createstreamonhglobal failed? doubt it... hres 0x%08x\n", hres); memset(&seekto,0,sizeof(seekto)); hres = IStream_Seek(stream,seekto,SEEK_CUR,&newpos1); ok (hres == S_OK, "istream seek failed? doubt it... hres 0x%08x\n", hres); test_pic_with_stream(stream, imgsize); IStream_Release(stream); /* again with Non Statable and Non Seekable stream */ stream = (LPSTREAM)NoStatStreamImpl_Construct(hglob); hglob = 0; /* Non-statable impl always deletes on release */ test_pic_with_stream(stream, 0); IStream_Release(stream); for (i = 1; i <= 8; i++) { /* more fun!!! */ hglob = GlobalAlloc (0, imgsize + i * (2 * sizeof(DWORD))); data = GlobalLock (hglob); header = (DWORD *)data; /* multiple copies of header */ memcpy(data,"lt\0\0",4); header[1] = imgsize; for (j = 2; j <= i; j++) { memcpy(&(header[2 * (j - 1)]), header, 2 * sizeof(DWORD)); } memcpy(data + i * (2 * sizeof(DWORD)), imgdata, imgsize); GlobalUnlock(hglob); data = NULL; hres = CreateStreamOnHGlobal (hglob, FALSE, &stream); ok (hres == S_OK, "createstreamonhglobal failed? doubt it... hres 0x%08x\n", hres); memset(&seekto,0,sizeof(seekto)); hres = IStream_Seek(stream,seekto,SEEK_CUR,&newpos1); ok (hres == S_OK, "istream seek failed? doubt it... hres 0x%08x\n", hres); test_pic_with_stream(stream, imgsize); IStream_Release(stream); /* again with Non Statable and Non Seekable stream */ stream = (LPSTREAM)NoStatStreamImpl_Construct(hglob); hglob = 0; /* Non-statable impl always deletes on release */ test_pic_with_stream(stream, 0); IStream_Release(stream); } }
BOOL CPictureWnd::ShowPicture(char *pBuf, int nBufLen) { if (pBuf == NULL) { return FALSE; } if (m_hImageMemory != NULL) { GlobalFree(m_hImageMemory); m_hImageMemory = NULL; } BOOL bLock = m_csIPictrue.Lock(); if (bLock == TRUE && m_pIPicture != NULL) { m_pIPicture->Release(); m_pIPicture = NULL; } m_csIPictrue.Unlock(); // 给图片分配全局内存 m_hImageMemory = GlobalAlloc(GMEM_MOVEABLE, nBufLen); if (m_hImageMemory == NULL) { return FALSE; } void *pImageMemory = GlobalLock(m_hImageMemory); // 锁定内存 memcpy(pImageMemory, pBuf, nBufLen); GlobalUnlock(m_hImageMemory); // 解锁内存 // 创建一个IStream接口指针,用来保存图片流 LPSTREAM pIStream = NULL; HRESULT hr = CreateStreamOnHGlobal(m_hImageMemory, TRUE, &pIStream); // 用全局内存初使化IStream接口指针 _ASSERTE(SUCCEEDED(hr) && pIStream); // 创建一个IPicture接口指针,表示图片对象 try { bLock = m_csIPictrue.Lock(); if (bLock) { hr = OleLoadPicture(pIStream, nBufLen, FALSE, IID_IPicture, (LPVOID*)&(m_pIPicture)); // 用OleLoadPicture获得IPicture接口指针 } m_csIPictrue.Unlock(); } catch (CMemoryException* e) { MessageBox(ConvertString("Bad bmp file"),ConvertString("Prompt")); return FALSE; } catch (CFileException* e) { MessageBox(ConvertString("Bad bmp file"),ConvertString("Prompt")); return FALSE; } catch (CException* e) { MessageBox(ConvertString("Bad bmp file"),ConvertString("Prompt")); return FALSE; } _ASSERTE(SUCCEEDED(hr) && m_pIPicture); pIStream->Release(); m_nScale = 100; memset (&m_siVert, '\0', sizeof (SCROLLINFO)); memset (&m_siHorz, '\0', sizeof (SCROLLINFO)); m_siVert.cbSize = sizeof (SCROLLINFO); m_siHorz.cbSize = sizeof (SCROLLINFO); Invalidate(); return TRUE; }
HRESULT WINAPI ObjectFromLresult( LRESULT result, REFIID riid, WPARAM wParam, void **ppObject ) { WCHAR atom_str[sizeof(lresult_atom_prefix)/sizeof(WCHAR)+3*8+3]; HANDLE server_proc, server_mapping, mapping; DWORD proc_id, size; IStream *stream; HGLOBAL data; void *view; HRESULT hr; WCHAR *p; TRACE("%ld %s %ld %p\n", result, debugstr_guid(riid), wParam, ppObject ); if(wParam) FIXME("unsupported wParam = %lx\n", wParam); if(!ppObject) return E_INVALIDARG; *ppObject = NULL; if(result != (ATOM)result) return E_FAIL; if(!GlobalGetAtomNameW(result, atom_str, sizeof(atom_str)/sizeof(WCHAR))) return E_FAIL; if(memcmp(atom_str, lresult_atom_prefix, sizeof(lresult_atom_prefix))) return E_FAIL; p = atom_str + sizeof(lresult_atom_prefix)/sizeof(WCHAR); proc_id = strtoulW(p, &p, 16); if(*p != ':') return E_FAIL; server_mapping = ULongToHandle( strtoulW(p+1, &p, 16) ); if(*p != ':') return E_FAIL; size = strtoulW(p+1, &p, 16); if(*p != 0) return E_FAIL; server_proc = OpenProcess(PROCESS_DUP_HANDLE, FALSE, proc_id); if(!server_proc) return E_FAIL; if(!DuplicateHandle(server_proc, server_mapping, GetCurrentProcess(), &mapping, 0, FALSE, DUPLICATE_CLOSE_SOURCE|DUPLICATE_SAME_ACCESS)) return E_FAIL; CloseHandle(server_proc); GlobalDeleteAtom(result); view = MapViewOfFile(mapping, FILE_MAP_READ, 0, 0, 0); CloseHandle(mapping); if(!view) return E_FAIL; data = GlobalAlloc(GMEM_FIXED, size); if(!data) return E_OUTOFMEMORY; memcpy(data, view, size); UnmapViewOfFile(view); hr = CreateStreamOnHGlobal(data, TRUE, &stream); if(FAILED(hr)) { GlobalFree(data); return hr; } hr = CoUnmarshalInterface(stream, riid, ppObject); IStream_Release(stream); return hr; }
static void marshal_WdtpInterfacePointer(DWORD umcb_ctx, DWORD ctx) { USER_MARSHAL_CB umcb; MIDL_STUB_MESSAGE stub_msg; RPC_MESSAGE rpc_msg; unsigned char *buffer, *buffer_end; ULONG size; IUnknown *unk; IUnknown *unk2; unsigned char *wireip; HGLOBAL h = GlobalAlloc(GMEM_MOVEABLE, 0); IStream *stm; void *marshal_data; LARGE_INTEGER zero; ULARGE_INTEGER pos; DWORD marshal_size; /* shows that the WdtpInterfacePointer functions don't marshal anything for * NULL pointers, so code using these functions must handle that case * itself */ unk = NULL; init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, umcb_ctx); size = WdtpInterfacePointer_UserSize(&umcb.Flags, ctx, 0, unk, &IID_IUnknown); ok(size == 0, "size should be 0 bytes, not %d\n", size); buffer = HeapAlloc(GetProcessHeap(), 0, size); buffer_end = WdtpInterfacePointer_UserMarshal(&umcb.Flags, ctx, buffer, unk, &IID_IUnknown); wireip = buffer; HeapFree(GetProcessHeap(), 0, buffer); /* Now for a non-NULL pointer. The marshalled data are two size DWORDS and then the result of CoMarshalInterface called with the LOWORD of the ctx */ unk = &Test_Unknown; CreateStreamOnHGlobal(h, TRUE, &stm); CoMarshalInterface(stm, &IID_IUnknown, unk, LOWORD(ctx), NULL, MSHLFLAGS_NORMAL); zero.QuadPart = 0; IStream_Seek(stm, zero, STREAM_SEEK_CUR, &pos); marshal_size = pos.u.LowPart; marshal_data = GlobalLock(h); trace("marshal_size %x\n", marshal_size); init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, umcb_ctx); size = WdtpInterfacePointer_UserSize(&umcb.Flags, ctx, 0, unk, &IID_IUnknown); ok(size >= marshal_size + 2 * sizeof(DWORD), "marshal size %x got %x\n", marshal_size, size); trace("WdtpInterfacePointer_UserSize returned %x\n", size); buffer = HeapAlloc(GetProcessHeap(), 0, size); init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, umcb_ctx); buffer_end = WdtpInterfacePointer_UserMarshal(&umcb.Flags, ctx, buffer, unk, &IID_IUnknown); wireip = buffer; ok(buffer_end == buffer + marshal_size + 2 * sizeof(DWORD), "buffer_end %p buffer %p\n", buffer_end, buffer); ok(*(DWORD *)wireip == marshal_size, "wireip + 0x0 should be %x instead of %x\n", marshal_size, *(DWORD *)wireip); wireip += sizeof(DWORD); ok(*(DWORD *)wireip == marshal_size, "wireip + 0x4 should be %x instead of %x\n", marshal_size, *(DWORD *)wireip); wireip += sizeof(DWORD); ok(!memcmp(marshal_data, wireip, marshal_size), "buffer mismatch\n"); GlobalUnlock(h); zero.QuadPart = 0; IStream_Seek(stm, zero, STREAM_SEEK_SET, NULL); CoReleaseMarshalData(stm); IStream_Release(stm); unk2 = NULL; init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, umcb_ctx); WdtpInterfacePointer_UserUnmarshal(&umcb.Flags, buffer, &unk2, &IID_IUnknown); ok(unk2 != NULL, "IUnknown object didn't unmarshal properly\n"); HeapFree(GetProcessHeap(), 0, buffer); init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_INPROC); WdtpInterfacePointer_UserFree(unk2); }
LRESULT WINAPI LresultFromObject( REFIID riid, WPARAM wParam, LPUNKNOWN pAcc ) { static const WCHAR atom_fmt[] = {'%','0','8','x',':','%','0','8','x',':','%','0','8','x',0}; static const LARGE_INTEGER seek_zero = {{0}}; WCHAR atom_str[sizeof(lresult_atom_prefix)/sizeof(WCHAR)+3*8+3]; IStream *stream; HANDLE mapping; STATSTG stat; HRESULT hr; ATOM atom; void *view; TRACE("%s %ld %p\n", debugstr_guid(riid), wParam, pAcc); if(wParam) FIXME("unsupported wParam = %lx\n", wParam); if(!pAcc) return E_INVALIDARG; hr = CreateStreamOnHGlobal(NULL, TRUE, &stream); if(FAILED(hr)) return hr; hr = CoMarshalInterface(stream, riid, pAcc, MSHCTX_LOCAL, NULL, MSHLFLAGS_NORMAL); if(FAILED(hr)) { IStream_Release(stream); return hr; } hr = IStream_Seek(stream, seek_zero, STREAM_SEEK_SET, NULL); if(FAILED(hr)) { IStream_Release(stream); return hr; } hr = IStream_Stat(stream, &stat, STATFLAG_NONAME); if(FAILED(hr)) { CoReleaseMarshalData(stream); IStream_Release(stream); return hr; }else if(stat.cbSize.u.HighPart) { FIXME("stream size to big\n"); CoReleaseMarshalData(stream); IStream_Release(stream); return E_NOTIMPL; } mapping = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, stat.cbSize.u.HighPart, stat.cbSize.u.LowPart, NULL); if(!mapping) { CoReleaseMarshalData(stream); IStream_Release(stream); return hr; } view = MapViewOfFile(mapping, FILE_MAP_WRITE, 0, 0, 0); if(!view) { CloseHandle(mapping); CoReleaseMarshalData(stream); IStream_Release(stream); return E_FAIL; } hr = IStream_Read(stream, view, stat.cbSize.u.LowPart, NULL); UnmapViewOfFile(view); if(FAILED(hr)) { CloseHandle(mapping); hr = IStream_Seek(stream, seek_zero, STREAM_SEEK_SET, NULL); if(SUCCEEDED(hr)) CoReleaseMarshalData(stream); IStream_Release(stream); return hr; } memcpy(atom_str, lresult_atom_prefix, sizeof(lresult_atom_prefix)); sprintfW(atom_str+sizeof(lresult_atom_prefix)/sizeof(WCHAR), atom_fmt, GetCurrentProcessId(), HandleToUlong(mapping), stat.cbSize.u.LowPart); atom = GlobalAddAtomW(atom_str); if(!atom) { CloseHandle(mapping); hr = IStream_Seek(stream, seek_zero, STREAM_SEEK_SET, NULL); if(SUCCEEDED(hr)) CoReleaseMarshalData(stream); IStream_Release(stream); return E_FAIL; } IStream_Release(stream); return atom; }
/*********************************************************************** * HlinkClone (HLINK.@) */ HRESULT WINAPI HlinkClone(IHlink *hlink, REFIID riid, IHlinkSite *hls, DWORD site_data, void **obj) { IMoniker *mk, *clone_mk = NULL; WCHAR *loc, *name = NULL; HRESULT hres; if(!hlink || !riid || !obj) return E_INVALIDARG; *obj = NULL; hres = IHlink_GetMonikerReference(hlink, HLINKGETREF_DEFAULT, &mk, &loc); if(FAILED(hres)) return hres; if(mk) { IStream *strm; LARGE_INTEGER lgint; hres = CreateStreamOnHGlobal(NULL, TRUE, &strm); if(FAILED(hres)) { IMoniker_Release(mk); goto cleanup; } hres = OleSaveToStream((IPersistStream*)mk, strm); if(FAILED(hres)) { IStream_Release(strm); IMoniker_Release(mk); goto cleanup; } IMoniker_Release(mk); lgint.QuadPart = 0; hres = IStream_Seek(strm, lgint, STREAM_SEEK_SET, NULL); if(FAILED(hres)) { IStream_Release(strm); goto cleanup; } hres = OleLoadFromStream(strm, &IID_IMoniker, (void**)&clone_mk); IStream_Release(strm); if(FAILED(hres)) goto cleanup; } hres = IHlink_GetFriendlyName(hlink, HLFNAMEF_DEFAULT, &name); if(FAILED(hres)) goto cleanup; hres = HlinkCreateFromMoniker(clone_mk, loc, name, hls, site_data, NULL, &IID_IHlink, obj); cleanup: if(clone_mk) IMoniker_Release(clone_mk); CoTaskMemFree(loc); CoTaskMemFree(name); return hres; }
static void test_CreateBody(void) { HRESULT hr; IMimeBody *body; HBODY handle = (void *)0xdeadbeef; IStream *in; LARGE_INTEGER off; ULARGE_INTEGER pos; ENCODINGTYPE enc; ULONG count, found_param, i; MIMEPARAMINFO *param_info; IMimeAllocator *alloc; BODYOFFSETS offsets; hr = CoCreateInstance(&CLSID_IMimeBody, NULL, CLSCTX_INPROC_SERVER, &IID_IMimeBody, (void**)&body); ok(hr == S_OK, "ret %08x\n", hr); hr = IMimeBody_GetHandle(body, &handle); ok(hr == MIME_E_NO_DATA, "ret %08x\n", hr); ok(handle == NULL, "handle %p\n", handle); hr = CreateStreamOnHGlobal(NULL, TRUE, &in); ok(hr == S_OK, "ret %08x\n", hr); IStream_Write(in, msg1, sizeof(msg1) - 1, NULL); off.QuadPart = 0; IStream_Seek(in, off, STREAM_SEEK_SET, NULL); /* Need to call InitNew before Load otherwise Load crashes with native inetcomm */ hr = IMimeBody_InitNew(body); ok(hr == S_OK, "ret %08x\n", hr); hr = IMimeBody_GetCurrentEncoding(body, &enc); ok(hr == S_OK, "ret %08x\n", hr); ok(enc == IET_7BIT, "encoding %d\n", enc); hr = IMimeBody_Load(body, in); ok(hr == S_OK, "ret %08x\n", hr); off.QuadPart = 0; IStream_Seek(in, off, STREAM_SEEK_CUR, &pos); ok(pos.u.LowPart == 359, "pos %u\n", pos.u.LowPart); hr = IMimeBody_IsContentType(body, "multipart", "mixed"); ok(hr == S_OK, "ret %08x\n", hr); hr = IMimeBody_IsContentType(body, "text", "plain"); ok(hr == S_FALSE, "ret %08x\n", hr); hr = IMimeBody_IsContentType(body, NULL, "mixed"); ok(hr == S_OK, "ret %08x\n", hr); hr = IMimeBody_IsType(body, IBT_EMPTY); ok(hr == S_OK, "got %08x\n", hr); hr = IMimeBody_SetData(body, IET_8BIT, "text", "plain", &IID_IStream, in); ok(hr == S_OK, "ret %08x\n", hr); hr = IMimeBody_IsContentType(body, "text", "plain"); todo_wine ok(hr == S_OK, "ret %08x\n", hr); hr = IMimeBody_GetCurrentEncoding(body, &enc); ok(hr == S_OK, "ret %08x\n", hr); ok(enc == IET_8BIT, "encoding %d\n", enc); memset(&offsets, 0xcc, sizeof(offsets)); hr = IMimeBody_GetOffsets(body, &offsets); ok(hr == MIME_E_NO_DATA, "ret %08x\n", hr); ok(offsets.cbBoundaryStart == 0, "got %d\n", offsets.cbBoundaryStart); ok(offsets.cbHeaderStart == 0, "got %d\n", offsets.cbHeaderStart); ok(offsets.cbBodyStart == 0, "got %d\n", offsets.cbBodyStart); ok(offsets.cbBodyEnd == 0, "got %d\n", offsets.cbBodyEnd); hr = IMimeBody_IsType(body, IBT_EMPTY); ok(hr == S_FALSE, "got %08x\n", hr); hr = MimeOleGetAllocator(&alloc); ok(hr == S_OK, "ret %08x\n", hr); hr = IMimeBody_GetParameters(body, "nothere", &count, ¶m_info); ok(hr == MIME_E_NOT_FOUND, "ret %08x\n", hr); ok(count == 0, "got %d\n", count); ok(!param_info, "got %p\n", param_info); hr = IMimeBody_GetParameters(body, "bar", &count, ¶m_info); ok(hr == S_OK, "ret %08x\n", hr); ok(count == 0, "got %d\n", count); ok(!param_info, "got %p\n", param_info); hr = IMimeBody_GetParameters(body, "Content-Type", &count, ¶m_info); ok(hr == S_OK, "ret %08x\n", hr); todo_wine /* native adds a charset parameter */ ok(count == 4, "got %d\n", count); ok(param_info != NULL, "got %p\n", param_info); found_param = 0; for(i = 0; i < count; i++) { if(!strcmp(param_info[i].pszName, "morestuff")) { found_param++; ok(!strcmp(param_info[i].pszData, "so\\me\"thing\""), "got %s\n", param_info[i].pszData); } else if(!strcmp(param_info[i].pszName, "stuff")) { found_param++; ok(!strcmp(param_info[i].pszData, "du;nno"), "got %s\n", param_info[i].pszData); } } ok(found_param == 2, "matched %d params\n", found_param); hr = IMimeAllocator_FreeParamInfoArray(alloc, count, param_info, TRUE); ok(hr == S_OK, "ret %08x\n", hr); IMimeAllocator_Release(alloc); IStream_Release(in); IMimeBody_Release(body); }
unsigned int __stdcall CreateBrokerThreadEntry(void *data) { TRY_CATCH CoInitialize(0); SBrokerThreadEntryData* inData = reinterpret_cast<SBrokerThreadEntryData*>(data); SStartBroker *startBroker = reinterpret_cast<SStartBroker*>(inData->buf); if (NULL == startBroker->buf || 0 == startBroker->bufSize) throw MCException("NULL == startBroker->buf || 0 == startBroker->bufSize"); CComPtr<IDispatch> broker; HRESULT hr; if((hr=broker.CoCreateInstance(L"Broker.CoBroker",NULL,CLSCTX_LOCAL_SERVER))!=S_OK) throw CExceptionBase(__LINE__,_T(__FILE__),_T(__DATE__),tstring(_T("CoBroker creation failed")),hr); CScopedTracker<HGLOBAL> globalMem; globalMem.reset(GlobalAlloc(GMEM_MOVEABLE, startBroker->bufSize), GlobalFree); if (NULL == globalMem) throw MCException_Win("Failed to GlobalAlloc"); CComPtr<IStream> stream; hr = CreateStreamOnHGlobal(globalMem, FALSE, &stream); if (S_OK != hr) throw MCException_Win(Format(_T("Failed to GlobalAlloc; result = %X"),hr)); ULARGE_INTEGER size; size.QuadPart = startBroker->bufSize; hr = stream->SetSize(size); if (S_OK != hr) throw MCException_Win(Format(_T("Failed to stream->SetSize; result = %X"),hr)); hr = CoMarshalInterface(stream, IID_IDispatch, broker, MSHCTX_LOCAL, NULL, MSHLFLAGS_NORMAL); if (S_OK != hr) throw MCException_Win(Format(_T("Failed to CoMarshalInterface; result = %X"),hr)); ULARGE_INTEGER uLi; LARGE_INTEGER li; li.QuadPart = 0; /// Writing stream to client process memory stream->Seek(li, STREAM_SEEK_SET, NULL); boost::scoped_array<char> localBuf; ULONG readCount; localBuf.reset(new char[startBroker->bufSize]); hr = stream->Read(localBuf.get(), startBroker->bufSize, &readCount); if (S_OK != hr) throw MCException_Win(Format(_T("stream->Read; result = %X"),hr)); /// Writing stream date into client process memory ULONG writtenCount; if (FALSE == WriteProcessMemory(inData->clientProcess, startBroker->buf, localBuf.get(), readCount, &writtenCount)) throw MCException_Win("Failed to WriteProcessMemory "); CoUninitialize(); Log.Add(_MESSAGE_,_T("Broker created and marshaled to BrokerProxy process")); return TRUE; CATCH_LOG() CoUninitialize(); return FALSE; }
HBITMAP g_load_png_gdiplus_throw(HDC dc, const char * fn, unsigned target_cx, unsigned target_cy) { //FIXME m_gdiplus_initialised = (Gdiplus::Ok == Gdiplus::GdiplusStartup(&m_gdiplus_instance, &Gdiplus::GdiplusStartupInput(), NULL)); pfc::string8 canPath; HBITMAP bm = 0; abort_callback_dummy p_abort; file::ptr p_file; filesystem::g_get_canonical_path(fn, canPath); filesystem::g_open_read(p_file, canPath, p_abort); t_size fsize = pfc::downcast_guarded<t_size>(p_file->get_size_ex(p_abort)); pfc::array_staticsize_t<t_uint8> buffer(fsize); p_file->read(buffer.get_ptr(), fsize, p_abort); p_file.release(); IStream *pStream = NULL; HGLOBAL gd = GlobalAlloc(GMEM_FIXED | GMEM_MOVEABLE, buffer.get_size()); if (gd == NULL) throw exception_win32(GetLastError()); void * p_data = GlobalLock(gd); if (p_data == NULL) { GlobalFree(gd); throw exception_win32(GetLastError()); } memcpy(p_data, buffer.get_ptr(), buffer.get_size()); GlobalUnlock(gd); HRESULT hr = CreateStreamOnHGlobal(gd, TRUE, &pStream); if (FAILED(hr)) { GlobalFree(gd); throw exception_win32(hr); } Gdiplus::Bitmap pImage(pStream); CheckGdiplusStatus() << pImage.GetLastStatus(); { Gdiplus::BitmapData bitmapData; //Gdiplus::Bitmap * ppImage = &pImage; if (target_cx != pfc_infinite || target_cy != pfc_infinite) { Gdiplus::Bitmap pBitmapResized(target_cx == pfc_infinite ? pImage.GetWidth() : target_cx, target_cy == pfc_infinite ? pImage.GetHeight() : target_cy, PixelFormat32bppARGB); CheckGdiplusStatus() << pBitmapResized.GetLastStatus(); Gdiplus::Graphics pGraphics(&pBitmapResized); CheckGdiplusStatus() << pGraphics.GetLastStatus(); CheckGdiplusStatus() << pGraphics.SetPixelOffsetMode(Gdiplus::PixelOffsetModeHighQuality); CheckGdiplusStatus() << pGraphics.SetInterpolationMode(Gdiplus::InterpolationModeBicubic); Gdiplus::ImageAttributes imageAttributes; CheckGdiplusStatus() << imageAttributes.SetWrapMode(Gdiplus::WrapModeTileFlipXY); CheckGdiplusStatus() << pGraphics.DrawImage(&pImage, Gdiplus::Rect(0, 0, pBitmapResized.GetWidth(), pBitmapResized.GetHeight()), 0, 0, pImage.GetWidth(), pImage.GetHeight(), Gdiplus::UnitPixel, &imageAttributes); CheckGdiplusStatus() << pBitmapResized.LockBits(&Gdiplus::Rect(0, 0, pBitmapResized.GetWidth(), pBitmapResized.GetHeight()), Gdiplus::ImageLockModeRead, PixelFormat32bppARGB, &bitmapData); bm = g_CreateHbitmapFromGdiplusBitmapData32bpp(bitmapData); CheckGdiplusStatus() << pBitmapResized.UnlockBits(&bitmapData); } else { CheckGdiplusStatus() << pImage.LockBits(&Gdiplus::Rect(0, 0, pImage.GetWidth(), pImage.GetHeight()), Gdiplus::ImageLockModeRead, PixelFormat32bppARGB, &bitmapData); //assert bitmapData.Stride == bitmapData.Width bm = g_CreateHbitmapFromGdiplusBitmapData32bpp(bitmapData); CheckGdiplusStatus() << pImage.UnlockBits(&bitmapData); } } return bm; }
HRESULT CCeeGen::emitMetaData(IMetaDataEmit *emitter, CeeSection* section, DWORD offset, BYTE* buffer, unsigned buffLen) { HRESULT hr = S_OK; ReleaseHolder<IStream> metaStream(NULL); IfFailRet((HRESULT)CreateStreamOnHGlobal(NULL, TRUE, &metaStream)); if (! m_fTokenMapSupported) { IUnknown *pMapTokenIface; IfFailGoto(getMapTokenIface(&pMapTokenIface, emitter), Exit); // Set a callback for token remap and save the tokens which change. IfFailGoto(emitter->SetHandler(pMapTokenIface), Exit); } // generate the metadata IfFailGoto(emitter->SaveToStream(metaStream, 0), Exit); // get size of stream and get sufficient storage for it if (section == 0) { section = &getMetaSection(); STATSTG statStg; IfFailGoto((HRESULT)(metaStream->Stat(&statStg, STATFLAG_NONAME)), Exit); buffLen = statStg.cbSize.u.LowPart; if(m_objSwitch) { CeeSection* pSect; DWORD flags = IMAGE_SCN_LNK_INFO | IMAGE_SCN_LNK_REMOVE | IMAGE_SCN_ALIGN_1BYTES; // 0x00100A00 IfFailGoto(getSectionCreate(".cormeta",flags,&pSect,&m_metaIdx), Exit); } buffer = (BYTE *)section->getBlock(buffLen, sizeof(DWORD)); IfNullGoto(buffer, Exit); offset = getMetaSection().dataLen() - buffLen; } else { _ASSERTE(buffer[buffLen-1] || true); // Dereference 'buffer' _ASSERTE(section->computeOffset(PCHAR(buffer)) == offset); } // reset seek pointer and read from stream { LARGE_INTEGER disp = { {0, 0} }; IfFailGoto((HRESULT)metaStream->Seek(disp, STREAM_SEEK_SET, NULL), Exit); } ULONG metaDataLen; IfFailGoto((HRESULT)metaStream->Read(buffer, buffLen+1, &metaDataLen), Exit); _ASSERTE(metaDataLen <= buffLen); #ifdef ENC_DELTA_HACK { extern int __cdecl fclose(FILE *); WCHAR szFileName[256]; DWORD len = GetEnvironmentVariable(W("COMP_ENC_EMIT"), szFileName, ARRAYSIZE(szFileName)); _ASSERTE(len < (ARRAYSIZE(szFileName) + 6)); // +6 for the .dmeta if (len > 0 && len < (ARRAYSIZE(szFileName) + 6)) { wcscat_s(szFileName, ARRAYSIZE(szFileName), W(".dmeta")); FILE *pDelta; int ec = _wfopen_s(&pDelta, szFileName, W("wb")); if (FAILED(ec)) { return HRESULT_FROM_WIN32(ERROR_OPEN_FAILED); } fwrite(buffer, 1, metaDataLen, pDelta); fclose(pDelta); } } #endif // Set meta virtual address to offset of metadata within .meta, and // and add a reloc for this offset, which will get turned // into an rva when the pewriter writes out the file. m_corHeader->MetaData.VirtualAddress = VAL32(offset); getCorHeaderSection().addSectReloc(m_corHeaderOffset + offsetof(IMAGE_COR20_HEADER, MetaData), *section, srRelocAbsolute); m_corHeader->MetaData.Size = VAL32(metaDataLen); Exit: if (! m_fTokenMapSupported) { // Remove the handler that we set hr = emitter->SetHandler(NULL); } #ifdef _DEBUG if (FAILED(hr) && hr != E_OUTOFMEMORY) _ASSERTE(!"Unexpected Failure"); #endif return hr; }
// This function creates a font resource for the given font name with the // embedding type set appropriately for the licensing intent of the font. HRESULT CreateFontResourceForFont( IXpsOMObjectFactory* xpsFactory, LPCWSTR fontName, IXpsOMFontResource **fontResource ) { HRESULT hr = S_OK; HDC hDC = NULL; LOGFONT logFont = {}; HGDIOBJ hFont = NULL; ULONG privStatus = 0; LONG ttStatus; XPS_FONT_EMBEDDING embedding = XPS_FONT_EMBEDDING_NORMAL; DWORD fontDataLen = GDI_ERROR; HGLOBAL hGlobal = NULL; LPVOID ptr = NULL; IStream *fontStream = NULL; GUID fontObfuscationGuid = {}; IOpcPartUri* partUri = NULL; wchar_t fontPartName[60]; hDC = CreateDC(L"DISPLAY", NULL, NULL, NULL); if (!hDC) { fwprintf(stderr, L"ERROR: Could not create device context\n"); hr = E_UNEXPECTED; } if (SUCCEEDED(hr)) { if (wcscpy_s(logFont.lfFaceName, fontName) != 0) { fwprintf(stderr, L"ERROR: Could not copy font name into LOGFONT structure\n"); hr = E_UNEXPECTED; } } if (SUCCEEDED(hr)) { hFont = CreateFontIndirect(&logFont); if (!hFont) { fwprintf(stderr, L"ERROR: Could not create font\n"); hr = E_UNEXPECTED; } } if (SUCCEEDED(hr)) { if (!SelectObject(hDC, hFont)) { fwprintf(stderr, L"ERROR: Could not select object\n"); hr = E_UNEXPECTED; } } if (SUCCEEDED(hr)) { if ((ttStatus = TTGetEmbeddingType(hDC, &privStatus)) != E_NONE) { if (ttStatus == E_NOTATRUETYPEFONT) { fwprintf(stderr, L"ERROR: %s is not a TrueType font\n", fontName); } else { fwprintf(stderr, L"ERROR: Could not get embedding type: %08X\n", ttStatus); } hr = E_UNEXPECTED; } } if (SUCCEEDED(hr)) { switch (privStatus) { case EMBED_PREVIEWPRINT: // Restricted font embedding = XPS_FONT_EMBEDDING_RESTRICTED; break; case EMBED_EDITABLE: // Editable font - MUST obfuscate embedding = XPS_FONT_EMBEDDING_OBFUSCATED; break; case EMBED_INSTALLABLE: // Installable font - SHOULD obfuscate embedding = XPS_FONT_EMBEDDING_OBFUSCATED; break; case EMBED_NOEMBEDDING: fwprintf(stderr, L"ERROR: %s may not be embedded\n", fontName); hr = E_UNEXPECTED; break; default: fwprintf(stderr, L"ERROR: Unrecognized embedding privileges: %08X\n", privStatus); hr = E_UNEXPECTED; break; } } if (SUCCEEDED(hr)) { fontDataLen = GetFontData(hDC, 0, 0, NULL, 0); if (fontDataLen == GDI_ERROR) { fwprintf(stderr, L"ERROR: Could not get length of font data\n"); hr = E_UNEXPECTED; } } if (SUCCEEDED(hr)) { hGlobal = GlobalAlloc(GMEM_MOVEABLE, fontDataLen); if (!hGlobal) { fwprintf(stderr, L"ERROR: Could not allocate memory with GlobalAlloc\n"); hr = E_OUTOFMEMORY; } } if (SUCCEEDED(hr)) { ptr = GlobalLock(hGlobal); if (!ptr) { hr = HRESULT_FROM_WIN32(GetLastError()); fwprintf(stderr, L"ERROR: Could not lock global memory object: %08X\n", hr); } else { if (GetFontData(hDC, 0, 0, ptr, fontDataLen) == GDI_ERROR) { fwprintf(stderr, L"ERROR: Could not get font data\n"); hr = E_UNEXPECTED; } GlobalUnlock(hGlobal); } } // Could perform font subsetting with CreateFontPackage here. if (SUCCEEDED(hr)) { if (FAILED(hr = CreateStreamOnHGlobal(hGlobal, TRUE, &fontStream))) { fwprintf(stderr, L"ERROR: Could not create font stream: %08X\n", hr); } else { // If CreateStreamOnHGlobal succeeded, the stream now controls the lifetime of the // HGLOBAL. hGlobal = NULL; } } if (SUCCEEDED(hr)) { if (FAILED(hr = CoCreateGuid(&fontObfuscationGuid))) { fwprintf(stderr, L"ERROR: Could not create GUID for obfuscation: %08X\n", hr); } } if (SUCCEEDED(hr)) { if (swprintf_s( fontPartName, sizeof(fontPartName)/sizeof(wchar_t), L"/Resources/Fonts/%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X.odttf", fontObfuscationGuid.Data1, fontObfuscationGuid.Data2, fontObfuscationGuid.Data3, fontObfuscationGuid.Data4[0], fontObfuscationGuid.Data4[1], fontObfuscationGuid.Data4[2], fontObfuscationGuid.Data4[3], fontObfuscationGuid.Data4[4], fontObfuscationGuid.Data4[5], fontObfuscationGuid.Data4[6], fontObfuscationGuid.Data4[7] ) == -1) { fwprintf(stderr, L"ERROR: Could not format GUID into part name\n"); hr = E_UNEXPECTED; } } if (SUCCEEDED(hr)) { if (FAILED(hr = xpsFactory->CreatePartUri( fontPartName, &partUri))) { fwprintf(stderr, L"ERROR: Could not create part URI: %08X\n", hr); } } if (SUCCEEDED(hr)) { if (FAILED(hr = xpsFactory->CreateFontResource( fontStream, embedding, partUri, FALSE, fontResource ))) { fwprintf(stderr, L"ERROR: Could not create font resource: %08X\n", hr); } } if (fontStream) { fontStream->Release(); fontStream = NULL; } if (partUri) { partUri->Release(); partUri = NULL; } if (hGlobal) { GlobalFree(hGlobal); } if (hFont) { DeleteObject(hFont); } if (hDC) { DeleteDC(hDC); } return hr; }
/// @brief ÉèÖÃGIF¶¯»Í¼Æ¬,´ÓZIPѹËõ°üÖмÓÔØͼƬ. /// @param hEle ÔªËؾä±ú. /// @param pZipFileName ѹËõ°üÎļþ. /// @param pImageName GIFͼƬÃû. /// @param pPassword ѹËõ°üÃÜÂë. void WINAPI XGif_SetImageZip(HELE hEle,wchar_t *pZipFileName,wchar_t *pImageName,wchar_t *pPassword) { IsGifDebug(hEle,__FUNCTION__); gif_ *pObject=(gif_*)hEle; if(pObject->pGif) { delete pObject->pGif; pObject->pGif=NULL; } if(NULL==pZipFileName || NULL==pImageName) { return ; } IsImageTypeDebug(_T(__FUNCTION__),pImageName); char zipfilename[MAX_PATH]={0}; WideCharToMultiByte(CP_ACP,NULL,pZipFileName,wcslen(pZipFileName),zipfilename,MAX_PATH,NULL,NULL); char filename_to_extract[MAX_PATH]={0}; WideCharToMultiByte(CP_ACP,NULL,pImageName,wcslen(pImageName),filename_to_extract,MAX_PATH,NULL,NULL); char password[MAX_PATH]={0}; if(pPassword) WideCharToMultiByte(CP_ACP,NULL,pPassword,wcslen(pPassword),password,MAX_PATH,NULL,NULL); //const char *password=NULL; //char *zipfilename="C:\\Users\\mengfei\\Desktop\\myzip.zip"; //ѹËõ°ü //char *filename_to_extract="dirtt/123.txt"; //ÌáÈ¡ÎļþÃû //char *filename_to_extract="btn.bmp"; //ÌáÈ¡ÎļþÃû unzFile zipFile=NULL; zipFile = unzOpen64(zipfilename); //´ò¿ªÑ¹Ëõ°ü if (zipFile==NULL) { XTRACE("´ò¿ªZIPѹËõ°üʧ°Ü"); return ; } int outSize=0; void *data =NULL; if(pPassword) data=do_extract_onefile(zipFile, filename_to_extract,password,outSize); else data=do_extract_onefile(zipFile, filename_to_extract,NULL,outSize); unzClose(zipFile); if(data) { HGLOBAL hJPG = ::GlobalAlloc(GMEM_MOVEABLE, outSize); LPVOID lpJGP = ::GlobalLock(hJPG); memcpy(lpJGP, data, outSize); ::GlobalUnlock(hJPG); LPSTREAM pstm =NULL; HRESULT hr =CreateStreamOnHGlobal(hJPG, TRUE, &pstm); assert(SUCCEEDED(hr) && pstm); //Image *pImg=Image::FromStream(pstm); pObject->pGif=new ImageEx(pstm); pstm->Release(); free(data); if(Gdiplus::Ok != (pObject->pGif->GetLastStatus())) { delete pObject->pGif; pObject->pGif=NULL; } if(pObject->pGif->InitAnimation(0,0)) SetTimer(XEle_GetHWnd(hEle),(int)hEle,100,Gif_TimerProc); } }
static void test_multi_encoder(const struct bitmap_data **srcs, const CLSID* clsid_encoder, const struct bitmap_data **dsts, const CLSID *clsid_decoder, const char *name) { HRESULT hr; IWICBitmapEncoder *encoder; BitmapTestSrc *src_obj; HGLOBAL hglobal; IStream *stream; IWICBitmapFrameEncode *frameencode; IPropertyBag2 *options=NULL; IWICBitmapDecoder *decoder; IWICBitmapFrameDecode *framedecode; WICPixelFormatGUID pixelformat; int i; hr = CoCreateInstance(clsid_encoder, NULL, CLSCTX_INPROC_SERVER, &IID_IWICBitmapEncoder, (void**)&encoder); ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr); if (SUCCEEDED(hr)) { hglobal = GlobalAlloc(GMEM_MOVEABLE, 0); ok(hglobal != NULL, "GlobalAlloc failed\n"); if (hglobal) { hr = CreateStreamOnHGlobal(hglobal, TRUE, &stream); ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%x\n", hr); } if (hglobal && SUCCEEDED(hr)) { hr = IWICBitmapEncoder_Initialize(encoder, stream, WICBitmapEncoderNoCache); ok(SUCCEEDED(hr), "Initialize failed, hr=%x\n", hr); i=0; while (SUCCEEDED(hr) && srcs[i]) { CreateTestBitmap(srcs[i], &src_obj); hr = IWICBitmapEncoder_CreateNewFrame(encoder, &frameencode, &options); ok(SUCCEEDED(hr), "CreateFrame failed, hr=%x\n", hr); if (SUCCEEDED(hr)) { ok(options != NULL, "Encoder initialization has not created an property bag\n"); if(options) test_encoder_properties(clsid_encoder, options); hr = IWICBitmapFrameEncode_Initialize(frameencode, options); ok(SUCCEEDED(hr), "Initialize failed, hr=%x\n", hr); memcpy(&pixelformat, srcs[i]->format, sizeof(GUID)); hr = IWICBitmapFrameEncode_SetPixelFormat(frameencode, &pixelformat); ok(SUCCEEDED(hr), "SetPixelFormat failed, hr=%x\n", hr); ok(IsEqualGUID(&pixelformat, srcs[i]->format), "SetPixelFormat changed the format\n"); hr = IWICBitmapFrameEncode_SetSize(frameencode, srcs[i]->width, srcs[i]->height); ok(SUCCEEDED(hr), "SetSize failed, hr=%x\n", hr); hr = IWICBitmapFrameEncode_WriteSource(frameencode, &src_obj->IWICBitmapSource_iface, NULL); ok(SUCCEEDED(hr), "WriteSource failed, hr=%x\n", hr); hr = IWICBitmapFrameEncode_Commit(frameencode); ok(SUCCEEDED(hr), "Commit failed, hr=%x\n", hr); IWICBitmapFrameEncode_Release(frameencode); IPropertyBag2_Release(options); } DeleteTestBitmap(src_obj); i++; } if (SUCCEEDED(hr)) { hr = IWICBitmapEncoder_Commit(encoder); ok(SUCCEEDED(hr), "Commit failed, hr=%x\n", hr); } if (SUCCEEDED(hr)) { hr = CoCreateInstance(clsid_decoder, NULL, CLSCTX_INPROC_SERVER, &IID_IWICBitmapDecoder, (void**)&decoder); ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr); } if (SUCCEEDED(hr)) { hr = IWICBitmapDecoder_Initialize(decoder, stream, WICDecodeMetadataCacheOnDemand); ok(SUCCEEDED(hr), "Initialize failed, hr=%x\n", hr); i=0; while (SUCCEEDED(hr) && dsts[i]) { hr = IWICBitmapDecoder_GetFrame(decoder, i, &framedecode); ok(SUCCEEDED(hr), "GetFrame failed, hr=%x\n", hr); if (SUCCEEDED(hr)) { compare_bitmap_data(dsts[i], (IWICBitmapSource*)framedecode, name); IWICBitmapFrameDecode_Release(framedecode); } i++; } IWICBitmapDecoder_Release(decoder); } IStream_Release(stream); } IWICBitmapEncoder_Release(encoder); } }
void Explorerplusplus::OnAddressBarBeginDrag(void) { IDragSourceHelper *pDragSourceHelper = NULL; IDropSource *pDropSource = NULL; HRESULT hr; hr = CoCreateInstance(CLSID_DragDropHelper,NULL,CLSCTX_ALL, IID_IDragSourceHelper,(LPVOID *)&pDragSourceHelper); if(SUCCEEDED(hr)) { hr = CreateDropSource(&pDropSource,DRAG_TYPE_LEFTCLICK); if(SUCCEEDED(hr)) { LPITEMIDLIST pidlDirectory = m_pActiveShellBrowser->QueryCurrentDirectoryIdl(); FORMATETC ftc[2]; STGMEDIUM stg[2]; SetFORMATETC(&ftc[0],(CLIPFORMAT)RegisterClipboardFormat(CFSTR_FILEDESCRIPTOR), NULL,DVASPECT_CONTENT,-1,TYMED_HGLOBAL); HGLOBAL hglb = GlobalAlloc(GMEM_MOVEABLE,1000); FILEGROUPDESCRIPTOR *pfgd = static_cast<FILEGROUPDESCRIPTOR *>(GlobalLock(hglb)); pfgd->cItems = 1; FILEDESCRIPTOR *pfd = (FILEDESCRIPTOR *)((LPBYTE)pfgd + sizeof(UINT)); /* File information (name, size, date created, etc). */ pfd[0].dwFlags = FD_ATTRIBUTES|FD_FILESIZE; pfd[0].dwFileAttributes = FILE_ATTRIBUTE_NORMAL; pfd[0].nFileSizeLow = 16384; pfd[0].nFileSizeHigh = 0; /* The name of the file will be the folder name, followed by .lnk. */ TCHAR szDisplayName[MAX_PATH]; GetDisplayName(pidlDirectory,szDisplayName,SHGDN_INFOLDER); StringCchCat(szDisplayName,SIZEOF_ARRAY(szDisplayName),_T(".lnk")); StringCchCopy(pfd[0].cFileName,SIZEOF_ARRAY(pfd[0].cFileName),szDisplayName); GlobalUnlock(hglb); stg[0].pUnkForRelease = 0; stg[0].hGlobal = hglb; stg[0].tymed = TYMED_HGLOBAL; /* File contents. */ SetFORMATETC(&ftc[1],(CLIPFORMAT)RegisterClipboardFormat(CFSTR_FILECONTENTS), NULL,DVASPECT_CONTENT,-1,TYMED_HGLOBAL); hglb = GlobalAlloc(GMEM_MOVEABLE,16384); IShellLink *pShellLink = NULL; IPersistStream *pPersistStream = NULL; HRESULT hr; hr = CoCreateInstance(CLSID_ShellLink,NULL,CLSCTX_INPROC_SERVER, IID_IShellLink,(LPVOID*)&pShellLink); if(SUCCEEDED(hr)) { TCHAR szPath[MAX_PATH]; GetDisplayName(pidlDirectory,szPath,SHGDN_FORPARSING); pShellLink->SetPath(szPath); hr = pShellLink->QueryInterface(IID_IPersistStream,(LPVOID*)&pPersistStream); if(SUCCEEDED(hr)) { IStream *pStream = NULL; CreateStreamOnHGlobal(hglb,FALSE,&pStream); hr = pPersistStream->Save(pStream,TRUE); } } GlobalUnlock(hglb); stg[1].pUnkForRelease = 0; stg[1].hGlobal = hglb; stg[1].tymed = TYMED_HGLOBAL; IDataObject *pDataObject = NULL; POINT pt = {0,0}; hr = CreateDataObject(ftc,stg,&pDataObject,2); pDragSourceHelper->InitializeFromWindow(m_hAddressBar,&pt,pDataObject); DWORD dwEffect; DoDragDrop(pDataObject,pDropSource,DROPEFFECT_LINK,&dwEffect); CoTaskMemFree(pidlDirectory); pDataObject->Release(); pDropSource->Release(); } pDragSourceHelper->Release(); } }
static void test_bom(void) { static const WCHAR versionW[] = {'v','e','r','s','i','o','n','=','"','1','.','0','"',0}; static const WCHAR utf16W[] = {'u','t','f','-','1','6',0}; static const WCHAR xmlW[] = {'x','m','l',0}; static const WCHAR aW[] = {'a',0}; IXmlWriterOutput *output; unsigned char *ptr; IXmlWriter *writer; IStream *stream; HGLOBAL hglobal; HRESULT hr; hr = CreateStreamOnHGlobal(NULL, TRUE, &stream); ok(hr == S_OK, "got 0x%08x\n", hr); hr = CreateXmlWriterOutputWithEncodingName((IUnknown*)stream, NULL, utf16W, &output); ok(hr == S_OK, "got %08x\n", hr); hr = CreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); hr = IXmlWriter_SetProperty(writer, XmlWriterProperty_OmitXmlDeclaration, TRUE); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXmlWriter_SetOutput(writer, output); ok(hr == S_OK, "got 0x%08x\n", hr); /* BOM is on by default */ hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXmlWriter_Flush(writer); ok(hr == S_OK, "got 0x%08x\n", hr); hr = GetHGlobalFromStream(stream, &hglobal); ok(hr == S_OK, "got 0x%08x\n", hr); ptr = GlobalLock(hglobal); ok(ptr[0] == 0xff && ptr[1] == 0xfe, "got %x,%x\n", ptr[0], ptr[1]); GlobalUnlock(hglobal); IStream_Release(stream); IUnknown_Release(output); /* start with PI */ hr = CreateStreamOnHGlobal(NULL, TRUE, &stream); ok(hr == S_OK, "got 0x%08x\n", hr); hr = CreateXmlWriterOutputWithEncodingName((IUnknown*)stream, NULL, utf16W, &output); ok(hr == S_OK, "got %08x\n", hr); hr = IXmlWriter_SetOutput(writer, output); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXmlWriter_WriteProcessingInstruction(writer, xmlW, versionW); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXmlWriter_Flush(writer); ok(hr == S_OK, "got 0x%08x\n", hr); hr = GetHGlobalFromStream(stream, &hglobal); ok(hr == S_OK, "got 0x%08x\n", hr); ptr = GlobalLock(hglobal); ok(ptr[0] == 0xff && ptr[1] == 0xfe, "got %x,%x\n", ptr[0], ptr[1]); GlobalUnlock(hglobal); IUnknown_Release(output); IStream_Release(stream); /* start with element */ hr = CreateStreamOnHGlobal(NULL, TRUE, &stream); ok(hr == S_OK, "got 0x%08x\n", hr); hr = CreateXmlWriterOutputWithEncodingName((IUnknown*)stream, NULL, utf16W, &output); ok(hr == S_OK, "got %08x\n", hr); hr = IXmlWriter_SetOutput(writer, output); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXmlWriter_WriteStartElement(writer, NULL, aW, NULL); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXmlWriter_Flush(writer); ok(hr == S_OK, "got 0x%08x\n", hr); hr = GetHGlobalFromStream(stream, &hglobal); ok(hr == S_OK, "got 0x%08x\n", hr); ptr = GlobalLock(hglobal); ok(ptr[0] == 0xff && ptr[1] == 0xfe, "got %x,%x\n", ptr[0], ptr[1]); GlobalUnlock(hglobal); IUnknown_Release(output); IStream_Release(stream); /* WriteElementString */ hr = CreateStreamOnHGlobal(NULL, TRUE, &stream); ok(hr == S_OK, "got 0x%08x\n", hr); hr = CreateXmlWriterOutputWithEncodingName((IUnknown*)stream, NULL, utf16W, &output); ok(hr == S_OK, "got %08x\n", hr); hr = IXmlWriter_SetOutput(writer, output); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXmlWriter_WriteElementString(writer, NULL, aW, NULL, NULL); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXmlWriter_Flush(writer); ok(hr == S_OK, "got 0x%08x\n", hr); hr = GetHGlobalFromStream(stream, &hglobal); ok(hr == S_OK, "got 0x%08x\n", hr); ptr = GlobalLock(hglobal); ok(ptr[0] == 0xff && ptr[1] == 0xfe, "got %x,%x\n", ptr[0], ptr[1]); GlobalUnlock(hglobal); IUnknown_Release(output); IStream_Release(stream); IXmlWriter_Release(writer); }
static HRESULT WINAPI CFStub_Invoke( LPRPCSTUBBUFFER iface,RPCOLEMESSAGE* msg,IRpcChannelBuffer* chanbuf ) { CFStub *This = (CFStub *)iface; HRESULT hres; if (msg->iMethod == 3) { /* CreateInstance */ IID iid; IClassFactory *classfac; IUnknown *ppv; IStream *pStm; STATSTG ststg; ULARGE_INTEGER newpos; LARGE_INTEGER seekto; ULONG res; if (msg->cbBuffer < sizeof(IID)) { FIXME("Not enough bytes in buffer (%ld)?\n",msg->cbBuffer); return E_FAIL; } memcpy(&iid,msg->Buffer,sizeof(iid)); TRACE("->CreateInstance(%s)\n",debugstr_guid(&iid)); hres = IUnknown_QueryInterface(This->pUnkServer,&IID_IClassFactory,(LPVOID*)&classfac); if (hres) { FIXME("Ole server does not provide an IClassFactory?\n"); return hres; } hres = IClassFactory_CreateInstance(classfac,NULL,&iid,(LPVOID*)&ppv); IClassFactory_Release(classfac); if (hres) { msg->cbBuffer = 0; FIXME("Failed to create an instance of %s\n",debugstr_guid(&iid)); return hres; } hres = CreateStreamOnHGlobal(0,TRUE,&pStm); if (hres) { FIXME("Failed to create stream on hglobal\n"); return hres; } hres = CoMarshalInterface(pStm,&iid,ppv,0,NULL,0); IUnknown_Release((IUnknown*)ppv); if (hres) { FIXME("CoMarshalInterface failed, %lx!\n",hres); msg->cbBuffer = 0; return hres; } hres = IStream_Stat(pStm,&ststg,0); if (hres) { FIXME("Stat failed.\n"); return hres; } msg->cbBuffer = ststg.cbSize.u.LowPart; I_RpcGetBuffer((RPC_MESSAGE *)msg); if (hres) return hres; seekto.u.LowPart = 0;seekto.u.HighPart = 0; hres = IStream_Seek(pStm,seekto,SEEK_SET,&newpos); if (hres) { FIXME("IStream_Seek failed, %lx\n",hres); return hres; } hres = IStream_Read(pStm,msg->Buffer,msg->cbBuffer,&res); if (hres) { FIXME("Stream Read failed, %lx\n",hres); return hres; } IStream_Release(pStm); return S_OK; } FIXME("(%p,%p), stub!\n",msg,chanbuf); FIXME("iMethod is %ld\n",msg->iMethod); FIXME("cbBuffer is %ld\n",msg->cbBuffer); return E_FAIL; }
static void test_omitxmldeclaration(void) { static const char prologversion[] = "<?xml version=\"1.0\"?>"; static const WCHAR versionW[] = {'v','e','r','s','i','o','n','=','"','1','.','0','"',0}; static const WCHAR xmlW[] = {'x','m','l',0}; IXmlWriter *writer; HGLOBAL hglobal; IStream *stream; HRESULT hr; char *ptr; hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); hr = CreateStreamOnHGlobal(NULL, TRUE, &stream); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXmlWriter_SetProperty(writer, XmlWriterProperty_OmitXmlDeclaration, TRUE); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXmlWriter_Flush(writer); ok(hr == S_OK, "got 0x%08x\n", hr); hr = GetHGlobalFromStream(stream, &hglobal); ok(hr == S_OK, "got 0x%08x\n", hr); ptr = GlobalLock(hglobal); ok(!ptr, "got %p\n", ptr); GlobalUnlock(hglobal); /* one more time */ hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes); ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr); IStream_Release(stream); /* now add PI manually, and try to start a document */ hr = CreateStreamOnHGlobal(NULL, TRUE, &stream); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXmlWriter_WriteProcessingInstruction(writer, xmlW, versionW); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXmlWriter_Flush(writer); ok(hr == S_OK, "got 0x%08x\n", hr); hr = GetHGlobalFromStream(stream, &hglobal); ok(hr == S_OK, "got 0x%08x\n", hr); ptr = GlobalLock(hglobal); ok(!strncmp(ptr, prologversion, strlen(prologversion)), "got %s\n", ptr); GlobalUnlock(hglobal); hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXmlWriter_Flush(writer); ok(hr == S_OK, "got 0x%08x\n", hr); ptr = GlobalLock(hglobal); ok(!strncmp(ptr, prologversion, strlen(prologversion)), "got %s\n", ptr); GlobalUnlock(hglobal); hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes); ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr); hr = IXmlWriter_Flush(writer); ok(hr == S_OK, "got 0x%08x\n", hr); ptr = GlobalLock(hglobal); ok(!strncmp(ptr, prologversion, strlen(prologversion)), "got %s\n", ptr); GlobalUnlock(hglobal); /* another attempt to add 'xml' PI */ hr = IXmlWriter_WriteProcessingInstruction(writer, xmlW, versionW); ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr); hr = IXmlWriter_Flush(writer); ok(hr == S_OK, "got 0x%08x\n", hr); IStream_Release(stream); IXmlWriter_Release(writer); }
LRESULT BlobMgmt::ShowImage() { #ifndef VC6 HDC hdc; RECT rectwin; wyInt32 renderwidth, renderheight; PAINTSTRUCT ps; LPSTREAM stream = NULL; HGLOBAL glbmem; void *glbbuffer; wyWChar tempfilename[MAX_PATH+1] = {0}, path[MAX_PATH + 1] = {0}; wyString tempstr; HANDLE hfile = INVALID_HANDLE_VALUE; DWORD byteswritten = 0; if(!m_piub->m_data || m_piub->m_datasize == 0) { VERIFY(hdc = BeginPaint(m_hwndimage, &ps)); VERIFY(EndPaint(m_hwndimage, &ps)); return 0; } /* allocate global memory and copy image data in it*/ VERIFY(glbmem = GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD, m_piub->m_datasize)); if(!glbmem) return 0; /* lock the global memory and get a pointer */ glbbuffer = GlobalLock(glbmem); /* copy the memory to buffer */ CopyMemory(glbbuffer, m_piub->m_data, m_piub->m_datasize); /* unlock it */ VERIFY(GlobalUnlock(glbmem)== NO_ERROR); /* create the stream */ VERIFY(CreateStreamOnHGlobal(glbmem, FALSE, &stream)== S_OK); /* prepare window for painting */ VERIFY(hdc = BeginPaint(m_hwndimage, &ps)); /* clear the window */ PrepareScreen(ps.hdc); if(pGlobals->m_configdirpath.GetLength() || SUCCEEDED(SHGetFolderPath(NULL, CSIDL_APPDATA, NULL, 0, (LPWSTR)path))) { if(pGlobals->m_configdirpath.GetLength()) { //wcscpy(path, pGlobals->m_configdirpath.GetAsWideChar()); wcsncpy(path, pGlobals->m_configdirpath.GetAsWideChar(), MAX_PATH); path[MAX_PATH] = '\0'; } else { wcscat(path, L"\\"); wcscat(path, L"SQLyog"); } VERIFY(GetTempFileName(path, L"img", 0, tempfilename)); hfile = CreateFile(tempfilename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, NULL, NULL); VERIFY(hfile != INVALID_HANDLE_VALUE); VERIFY(WriteFile(hfile, m_piub->m_data, m_piub->m_datasize, &byteswritten, NULL)); VERIFY(CloseHandle(hfile)); } tempstr.SetAs(tempfilename); WCHAR *wpath = GetWideString(tempstr.GetString()); Gdiplus::Graphics graphics(hdc); Gdiplus::Image *image = new Gdiplus::Image(wpath); HeapFree(GetProcessHeap(), 0, wpath); /* in win95 image will be null so we exit */ if(!image) goto ExitPara; /* the binary data might not be image so image.getlastatus will not return Ok */ if(image->GetLastStatus()!= Gdiplus::Ok) { delete image; goto ExitPara; } /* get the window width and calculate the correct render stats */ VERIFY(GetClientRect(m_hwndimage, &rectwin)); renderheight =(((LONG)image->GetHeight())> rectwin.bottom)?(rectwin.bottom):(image->GetHeight()); renderwidth =(((LONG)image->GetWidth())> rectwin.right)?(rectwin.right):(image->GetWidth()); graphics.DrawImage(image, 0, 0, renderwidth, renderheight); delete image; EndPaint(m_hwndimage, &ps); ExitPara: /* free up stuff */ VERIFY(DeleteFile(tempfilename)); if(stream) stream->Release(); VERIFY(GlobalFree(glbmem)== NULL); #endif return 0; }