0xe7,0x00,0x00,0x00,0x00,0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82
};
-/* 1x1 pixel bmp */
+/* 1bpp BI_RGB 1x1 pixel bmp */
static const unsigned char bmpimage[66] = {
0x42,0x4d,0x42,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3e,0x00,0x00,0x00,0x28,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x00,
0x00,0x00
};
+/* 8bpp BI_RLE8 1x1 pixel bmp */
+static const unsigned char bmpimage_rle8[] = {
+0x42,0x4d,0x42,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3e,0x00,0x00,0x00,0x28,0x00,
+0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x08,0x00,0x01,0x00,
+0x00,0x00,0x04,0x00,0x00,0x00,0x12,0x0b,0x00,0x00,0x12,0x0b,0x00,0x00,0x02,0x00,
+0x00,0x00,0x02,0x00,0x00,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x00,0x01,
+0x00,0x00
+};
+
/* 2x2 pixel gif */
static const unsigned char gif4pixel[42] = {
0x47,0x49,0x46,0x38,0x37,0x61,0x02,0x00,0x02,0x00,0xa1,0x00,0x00,0x00,0x00,0x00,
0x14, 0x00, 0x00, 0x00
};
+static HBITMAP stock_bm;
+
+static HDC create_render_dc( void )
+{
+ HDC dc = CreateCompatibleDC( NULL );
+ BITMAPINFO info = {{sizeof(info.bmiHeader), 100, 100, 1, 32, BI_RGB }};
+ void *bits;
+ HBITMAP dib = CreateDIBSection( NULL, &info, DIB_RGB_COLORS, &bits, NULL, 0 );
+
+ stock_bm = SelectObject( dc, dib );
+ return dc;
+}
+
+static void delete_render_dc( HDC dc )
+{
+ HBITMAP dib = SelectObject( dc, stock_bm );
+ DeleteObject( dib );
+ DeleteDC( dc );
+}
typedef struct NoStatStreamImpl
{
if (handle)
{
BITMAP bmp;
- GetObject(UlongToHandle(handle), sizeof(BITMAP), &bmp);
- todo_wine ok(bmp.bmBits != 0, "not a dib\n");
+ GetObjectA(UlongToHandle(handle), sizeof(BITMAP), &bmp);
+ ok(bmp.bmBits != 0, "not a dib\n");
}
width = 0;
{
IPictureDisp *picdisp;
HRESULT hr;
- VARIANTARG vararg;
+ VARIANTARG vararg, args[10];
DISPPARAMS dispparams;
VARIANT varresult;
IStream *stream;
HGLOBAL hglob;
void *data;
+ HDC hdc;
+ int i;
hglob = GlobalAlloc (0, sizeof(gifimage));
data = GlobalLock(hglob);
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);
+ /* DISPID_PICT_RENDER */
+ hdc = create_render_dc();
+
+ for (i = 0; i < sizeof(args)/sizeof(args[0]); i++)
+ V_VT(&args[i]) = VT_I4;
+
+ V_I4(&args[0]) = 0;
+ V_I4(&args[1]) = 10;
+ V_I4(&args[2]) = 10;
+ V_I4(&args[3]) = 0;
+ V_I4(&args[4]) = 0;
+ V_I4(&args[5]) = 10;
+ V_I4(&args[6]) = 10;
+ V_I4(&args[7]) = 0;
+ V_I4(&args[8]) = 0;
+ V_I4(&args[9]) = HandleToLong(hdc);
+
+ dispparams.rgvarg = args;
+ dispparams.rgdispidNamedArgs = NULL;
+ dispparams.cArgs = 10;
+ dispparams.cNamedArgs = 0;
+
+ V_VT(&varresult) = VT_EMPTY;
+ hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_RENDER, &GUID_NULL, 0, DISPATCH_METHOD, &dispparams, &varresult, NULL, NULL);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ /* Try with one argument set to VT_I2, it'd still work if coerced. */
+ V_VT(&args[3]) = VT_I2;
+ hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_RENDER, &GUID_NULL, 0, DISPATCH_METHOD, &dispparams, &varresult, NULL, NULL);
+ ok(hr == DISP_E_TYPEMISMATCH, "got 0x%08x\n", hr);
+ V_VT(&args[3]) = VT_I4;
+
+ /* Wrong argument count */
+ dispparams.cArgs = 9;
+ hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_RENDER, &GUID_NULL, 0, DISPATCH_METHOD, &dispparams, &varresult, NULL, NULL);
+ ok(hr == DISP_E_BADPARAMCOUNT, "got 0x%08x\n", hr);
+
+ delete_render_dc(hdc);
IPictureDisp_Release(picdisp);
}
BOOL keep;
short type;
- if(!winetest_interactive) {
- skip("ROSTESTS-2: oleaut_winetest:olepicture crashes with Page Fault.\n");
- return;
- }
-
hglob = GlobalAlloc (0, sizeof(apmdata));
data = GlobalLock(hglob);
memcpy(data, apmdata, sizeof(apmdata));
BOOL keep;
short type;
- if(!winetest_interactive) {
- skip("ROSTESTS-2: oleaut_winetest:olepicture crashes with Page Fault.\n");
- return;
- }
-
hglob = GlobalAlloc (0, sizeof(enhmetafile));
data = GlobalLock(hglob);
memcpy(data, enhmetafile, sizeof(enhmetafile));
IStream_Release(stream);
}
+static HRESULT picture_render(IPicture *iface, HDC hdc, LONG x, LONG y, LONG cx, LONG cy,
+ OLE_XPOS_HIMETRIC xSrc,
+ OLE_YPOS_HIMETRIC ySrc,
+ OLE_XSIZE_HIMETRIC cxSrc,
+ OLE_YSIZE_HIMETRIC cySrc,
+ const RECT *bounds)
+{
+ VARIANT ret, args[10];
+ HRESULT hr, hr_disp;
+ DISPPARAMS params;
+ IDispatch *disp;
+ int i;
+
+ hr = IPicture_Render(iface, hdc, x, y, cx, cy, xSrc, ySrc, cxSrc, cySrc, bounds);
+
+ IPicture_QueryInterface(iface, &IID_IDispatch, (void**)&disp);
+
+ /* This is broken on 64 bits - accepted pointer argument type is still VT_I4 */
+ for (i = 0; i < sizeof(args)/sizeof(args[0]); i++)
+ V_VT(&args[i]) = VT_I4;
+
+ /* pack arguments and call */
+ V_INT_PTR(&args[0]) = (INT_PTR)bounds;
+ V_I4(&args[1]) = cySrc;
+ V_I4(&args[2]) = cxSrc;
+ V_I4(&args[3]) = ySrc;
+ V_I4(&args[4]) = xSrc;
+ V_I4(&args[5]) = cy;
+ V_I4(&args[6]) = cx;
+ V_I4(&args[7]) = y;
+ V_I4(&args[8]) = x;
+ V_I4(&args[9]) = HandleToLong(hdc);
+
+ params.rgvarg = args;
+ params.rgdispidNamedArgs = NULL;
+ params.cArgs = 10;
+ params.cNamedArgs = 0;
+
+ V_VT(&ret) = VT_EMPTY;
+ hr_disp = IDispatch_Invoke(disp, DISPID_PICT_RENDER, &GUID_NULL, 0, DISPATCH_METHOD,
+ ¶ms, &ret, NULL, NULL);
+ ok(hr == hr_disp, "DISPID_PICT_RENDER returned wrong code, 0x%08x, expected 0x%08x\n",
+ hr_disp, hr);
+
+ IDispatch_Release(disp);
+
+ return hr;
+}
+
static void test_Render(void)
{
IPicture *pic;
OLE_XSIZE_HIMETRIC pWidth;
OLE_YSIZE_HIMETRIC pHeight;
COLORREF result, expected;
- HDC hdc = GetDC(0);
+ HDC hdc = create_render_dc();
/* test IPicture::Render return code on uninitialized picture */
OleCreatePictureIndirect(NULL, &IID_IPicture, TRUE, (VOID**)&pic);
ok(hres == S_OK, "IPicture_get_Type does not return S_OK, but 0x%08x\n", hres);
ok(type == PICTYPE_UNINITIALIZED, "Expected type = PICTYPE_UNINITIALIZED, got = %d\n", type);
/* zero dimensions */
- hres = IPicture_Render(pic, hdc, 0, 0, 0, 0, 0, 0, 0, 0, NULL);
+ hres = picture_render(pic, hdc, 0, 0, 0, 0, 0, 0, 0, 0, NULL);
ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
- hres = IPicture_Render(pic, hdc, 0, 0, 10, 10, 0, 0, 10, 0, NULL);
+ hres = picture_render(pic, hdc, 0, 0, 10, 10, 0, 0, 10, 0, NULL);
ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
- hres = IPicture_Render(pic, hdc, 0, 0, 10, 10, 0, 0, 0, 10, NULL);
+ hres = picture_render(pic, hdc, 0, 0, 10, 10, 0, 0, 0, 10, NULL);
ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
- hres = IPicture_Render(pic, hdc, 0, 0, 10, 10, 0, 0, 0, 0, NULL);
+ hres = picture_render(pic, hdc, 0, 0, 10, 10, 0, 0, 0, 0, NULL);
ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
- hres = IPicture_Render(pic, hdc, 0, 0, 0, 10, 0, 0, 10, 10, NULL);
+ hres = picture_render(pic, hdc, 0, 0, 0, 10, 0, 0, 10, 10, NULL);
ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
- hres = IPicture_Render(pic, hdc, 0, 0, 10, 0, 0, 0, 10, 10, NULL);
+ hres = picture_render(pic, hdc, 0, 0, 10, 0, 0, 0, 10, 10, NULL);
ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
- hres = IPicture_Render(pic, hdc, 0, 0, 0, 0, 0, 0, 10, 10, NULL);
+ hres = picture_render(pic, hdc, 0, 0, 0, 0, 0, 0, 10, 10, NULL);
ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
/* nonzero dimensions, PICTYPE_UNINITIALIZED */
- hres = IPicture_Render(pic, hdc, 0, 0, 10, 10, 0, 0, 10, 10, NULL);
+ hres = picture_render(pic, hdc, 0, 0, 10, 10, 0, 0, 10, 10, NULL);
ole_expect(hres, S_OK);
IPicture_Release(pic);
desc.cbSizeofstruct = sizeof(PICTDESC);
desc.picType = PICTYPE_ICON;
- desc.u.icon.hicon = LoadIcon(NULL, IDI_APPLICATION);
+ desc.u.icon.hicon = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
if(!desc.u.icon.hicon){
win_skip("LoadIcon failed. Skipping...\n");
- ReleaseDC(NULL, hdc);
+ delete_render_dc(hdc);
return;
}
OleCreatePictureIndirect(&desc, &IID_IPicture, TRUE, (VOID**)&pic);
/* zero dimensions, PICTYPE_ICON */
- hres = IPicture_Render(pic, hdc, 0, 0, 0, 0, 0, 0, 0, 0, NULL);
+ hres = picture_render(pic, hdc, 0, 0, 0, 0, 0, 0, 0, 0, NULL);
ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
- hres = IPicture_Render(pic, hdc, 0, 0, 10, 10, 0, 0, 10, 0, NULL);
+ hres = picture_render(pic, hdc, 0, 0, 10, 10, 0, 0, 10, 0, NULL);
ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
- hres = IPicture_Render(pic, hdc, 0, 0, 10, 10, 0, 0, 0, 10, NULL);
+ hres = picture_render(pic, hdc, 0, 0, 10, 10, 0, 0, 0, 10, NULL);
ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
- hres = IPicture_Render(pic, hdc, 0, 0, 10, 10, 0, 0, 0, 0, NULL);
+ hres = picture_render(pic, hdc, 0, 0, 10, 10, 0, 0, 0, 0, NULL);
ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
- hres = IPicture_Render(pic, hdc, 0, 0, 0, 10, 0, 0, 10, 10, NULL);
+ hres = picture_render(pic, hdc, 0, 0, 0, 10, 0, 0, 10, 10, NULL);
ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
- hres = IPicture_Render(pic, hdc, 0, 0, 10, 0, 0, 0, 10, 10, NULL);
+ hres = picture_render(pic, hdc, 0, 0, 10, 0, 0, 0, 10, 10, NULL);
ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
- hres = IPicture_Render(pic, hdc, 0, 0, 0, 0, 0, 0, 10, 10, NULL);
+ hres = picture_render(pic, hdc, 0, 0, 0, 0, 0, 0, 10, 10, NULL);
ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
/* Check if target size and position is respected */
SetPixelV(hdc, 10, 10, 0x00223344);
expected = GetPixel(hdc, 0, 0);
- hres = IPicture_Render(pic, hdc, 1, 1, 9, 9, 0, 0, pWidth, -pHeight, NULL);
+ hres = picture_render(pic, hdc, 1, 1, 9, 9, 0, 0, pWidth, -pHeight, NULL);
ole_expect(hres, S_OK);
- if(hres != S_OK) {
- IPicture_Release(pic);
- ReleaseDC(NULL, hdc);
- return;
- }
+ if(hres != S_OK) goto done;
/* Evaluate the rendered Icon */
result = GetPixel(hdc, 0, 0);
ok(result == expected,
"Color at 0,0 should be unchanged 0x%06X, but was 0x%06X\n", expected, result);
result = GetPixel(hdc, 5, 5);
- ok(result != expected ||
- broken(result == expected), /* WinNT 4.0 and older may claim they drew */
- /* the icon, even if they didn't. */
+ ok(result != expected,
"Color at 5,5 should have changed, but still was 0x%06X\n", expected);
result = GetPixel(hdc, 10, 10);
ok(result == expected,
"Color at 10,10 should be unchanged 0x%06X, but was 0x%06X\n", expected, result);
+done:
IPicture_Release(pic);
- ReleaseDC(NULL, hdc);
+ delete_render_dc(hdc);
}
static void test_get_Attributes(void)
HANDLE file;
DWORD size;
WCHAR *ptr;
+ VARIANT var;
const struct
{
if (pic)
IPicture_Release(pic);
+ VariantInit(&var);
+ V_VT(&var) = VT_BSTR;
+ V_BSTR(&var) = SysAllocString(temp_fileW + 8);
+ hres = OleLoadPictureFile(var, (IDispatch **)&pic);
+ ok(hres == S_OK, "OleLoadPictureFile error %#x\n", hres);
+ IPicture_Release(pic);
+ VariantClear(&var);
+
/* Try a DOS path with tacked on "file:". */
hres = OleLoadPicturePath(temp_fileW, NULL, 0, 0, &IID_IPicture, (void **)&pic);
ok(hres == S_OK ||
if (pic)
IPicture_Release(pic);
+ VariantInit(&var);
+ V_VT(&var) = VT_BSTR;
+ V_BSTR(&var) = SysAllocString(temp_fileW);
+ hres = OleLoadPictureFile(var, (IDispatch **)&pic);
+ ok(hres == CTL_E_PATHFILEACCESSERROR, "wrong error %#x\n", hres);
+ VariantClear(&var);
+
DeleteFileA(temp_file);
/* Try with a nonexistent file. */
broken(hres == E_FAIL), /*Win2k */
"Expected OleLoadPicturePath to return INET_E_RESOURCE_NOT_FOUND, got 0x%08x\n", hres);
+ VariantInit(&var);
+ V_VT(&var) = VT_BSTR;
+ V_BSTR(&var) = SysAllocString(temp_fileW + 8);
+ hres = OleLoadPictureFile(var, (IDispatch **)&pic);
+ ok(hres == CTL_E_FILENOTFOUND, "wrong error %#x\n", hres);
+ VariantClear(&var);
+
hres = OleLoadPicturePath(temp_fileW, NULL, 0, 0, &IID_IPicture, (void **)&pic);
ok(hres == INET_E_RESOURCE_NOT_FOUND || /* XP+ */
broken(hres == E_UNEXPECTED) || /* NT4 */
broken(hres == E_FAIL), /* Win2k */
"Expected OleLoadPicturePath to return INET_E_RESOURCE_NOT_FOUND, got 0x%08x\n", hres);
+ VariantInit(&var);
+ V_VT(&var) = VT_BSTR;
+ V_BSTR(&var) = SysAllocString(temp_fileW);
+ hres = OleLoadPictureFile(var, (IDispatch **)&pic);
+ ok(hres == CTL_E_PATHFILEACCESSERROR, "wrong error %#x\n", hres);
+ VariantClear(&var);
+
file = CreateFileA(temp_file, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL, NULL);
WriteFile(file, bmpimage, sizeof(bmpimage), &size, NULL);
if (pic)
IPicture_Release(pic);
+ VariantInit(&var);
+ V_VT(&var) = VT_BSTR;
+ V_BSTR(&var) = SysAllocString(temp_fileW);
+ hres = OleLoadPictureFile(var, (IDispatch **)&pic);
+ ok(hres == CTL_E_PATHFILEACCESSERROR, "wrong error %#x\n", hres);
+ VariantClear(&var);
+
DeleteFileA(temp_file);
/* Try with a nonexistent file. */
broken(hres == E_UNEXPECTED) || /* NT4 */
broken(hres == E_FAIL), /* Win2k */
"Expected OleLoadPicturePath to return INET_E_RESOURCE_NOT_FOUND, got 0x%08x\n", hres);
+
+ VariantInit(&var);
+ V_VT(&var) = VT_BSTR;
+ V_BSTR(&var) = SysAllocString(temp_fileW);
+ hres = OleLoadPictureFile(var, (IDispatch **)&pic);
+ ok(hres == CTL_E_PATHFILEACCESSERROR, "wrong error %#x\n", hres);
+ VariantClear(&var);
+
+ VariantInit(&var);
+ V_VT(&var) = VT_INT;
+ V_INT(&var) = 762;
+ hres = OleLoadPictureFile(var, (IDispatch **)&pic);
+ ok(hres == CTL_E_FILENOTFOUND, "wrong error %#x\n", hres);
+
+if (0) /* crashes under Windows */
+ hres = OleLoadPictureFile(var, NULL);
}
static void test_himetric(void)
DWORD *mem;
IPersistStream *src_stream;
IStream *dst_stream;
+ LARGE_INTEGER offset;
HRESULT hr;
+ LONG size;
desc.cbSizeofstruct = sizeof(desc);
desc.picType = PICTYPE_BITMAP;
hr = CreateStreamOnHGlobal(hmem, FALSE, &dst_stream);
ok(hr == S_OK, "createstreamonhglobal error %#x\n", hr);
+ size = -1;
+ hr = IPicture_SaveAsFile(pic, dst_stream, TRUE, &size);
+ ok(hr == S_OK, "IPicture_SaveasFile error %#x\n", hr);
+ ok(size == 66, "expected 66, got %d\n", size);
+ mem = GlobalLock(hmem);
+ ok(!memcmp(&mem[0], "BM", 2), "got wrong bmp header %04x\n", mem[0]);
+ GlobalUnlock(hmem);
+
+ size = -1;
+ hr = IPicture_SaveAsFile(pic, dst_stream, FALSE, &size);
+ ok(hr == E_FAIL, "expected E_FAIL, got %#x\n", hr);
+ ok(size == -1, "expected -1, got %d\n", size);
+
+ offset.QuadPart = 0;
+ hr = IStream_Seek(dst_stream, offset, SEEK_SET, NULL);
+ ok(hr == S_OK, "IStream_Seek %#x\n", hr);
+
hr = IPicture_QueryInterface(pic, &IID_IPersistStream, (void **)&src_stream);
ok(hr == S_OK, "QueryInterface error %#x\n", hr);
DWORD *mem;
IPersistStream *src_stream;
IStream *dst_stream;
+ LARGE_INTEGER offset;
HRESULT hr;
+ LONG size;
desc.cbSizeofstruct = sizeof(desc);
desc.picType = PICTYPE_ICON;
- desc.u.icon.hicon = LoadIcon(0, IDI_APPLICATION);
+ desc.u.icon.hicon = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
hr = OleCreatePictureIndirect(&desc, &IID_IPicture, FALSE, (void**)&pic);
ok(hr == S_OK, "OleCreatePictureIndirect error %#x\n", hr);
hr = CreateStreamOnHGlobal(hmem, FALSE, &dst_stream);
ok(hr == S_OK, "CreateStreamOnHGlobal error %#x\n", hr);
+ size = -1;
+ hr = IPicture_SaveAsFile(pic, dst_stream, TRUE, &size);
+ ok(hr == S_OK, "IPicture_SaveasFile error %#x\n", hr);
+todo_wine
+ ok(size == 766, "expected 766, got %d\n", size);
+ mem = GlobalLock(hmem);
+ ok(mem[0] == 0x00010000, "got wrong icon header %04x\n", mem[0]);
+ GlobalUnlock(hmem);
+
+ size = -1;
+ hr = IPicture_SaveAsFile(pic, dst_stream, FALSE, &size);
+ ok(hr == E_FAIL, "expected E_FAIL, got %#x\n", hr);
+ ok(size == -1, "expected -1, got %d\n", size);
+
+ offset.QuadPart = 0;
+ hr = IStream_Seek(dst_stream, offset, SEEK_SET, NULL);
+ ok(hr == S_OK, "IStream_Seek %#x\n", hr);
+
hr = IPicture_QueryInterface(pic, &IID_IPersistStream, (void **)&src_stream);
ok(hr == S_OK, "QueryInterface error %#x\n", hr);
HGLOBAL hmem;
DWORD *mem;
IPersistStream *src_stream;
- IStream *dst_stream;
+ IStream *dst_stream, *stream;
+ LARGE_INTEGER offset;
HRESULT hr;
+ LONG size;
memset(&pic, 0, sizeof(pic));
desc.cbSizeofstruct = sizeof(desc);
type = -1;
hr = IPicture_get_Type(pic, &type);
- ok(hr == S_OK,"get_Type error %#8x\n", hr);
+ ok(hr == S_OK, "get_Type error %#x\n", hr);
ok(type == PICTYPE_NONE,"expected picture type PICTYPE_NONE, got %d\n", type);
handle = (OLE_HANDLE)0xdeadbeef;
hr = CreateStreamOnHGlobal(hmem, FALSE, &dst_stream);
ok(hr == S_OK, "createstreamonhglobal error %#x\n", hr);
+ size = -1;
+ hr = IPicture_SaveAsFile(pic, dst_stream, TRUE, &size);
+ ok(hr == S_OK, "IPicture_SaveasFile error %#x\n", hr);
+ ok(size == -1, "expected -1, got %d\n", size);
+
+ size = -1;
+ hr = IPicture_SaveAsFile(pic, dst_stream, FALSE, &size);
+ ok(hr == S_OK, "IPicture_SaveasFile error %#x\n", hr);
+ ok(size == -1, "expected -1, got %d\n", size);
+
hr = IPicture_QueryInterface(pic, &IID_IPersistStream, (void **)&src_stream);
ok(hr == S_OK, "QueryInterface error %#x\n", hr);
ok(mem[1] == 0, "expected stream size 0, got %u\n", mem[1]);
GlobalUnlock(hmem);
+ IPersistStream_Release(src_stream);
+ IPicture_Release(pic);
+
+ /* first with statable and seekable stream */
+ offset.QuadPart = 0;
+ hr = IStream_Seek(dst_stream, offset, SEEK_SET, NULL);
+ ok(hr == S_OK, "IStream_Seek %#x\n", hr);
+
+ pic = NULL;
+ hr = pOleLoadPicture(dst_stream, 0, FALSE, &IID_IPicture, (void **)&pic);
+ ok(hr == S_OK, "OleLoadPicture error %#x\n", hr);
+ ok(pic != NULL,"picture should not be not NULL\n");
+ if (pic != NULL)
+ {
+ type = -1;
+ hr = IPicture_get_Type(pic, &type);
+ ok(hr == S_OK,"get_Type error %#8x\n", hr);
+ ok(type == PICTYPE_NONE,"expected picture type PICTYPE_NONE, got %d\n", type);
+
+ handle = (OLE_HANDLE)0xdeadbeef;
+ hr = IPicture_get_Handle(pic, &handle);
+ ok(hr == S_OK,"get_Handle error %#8x\n", hr);
+ ok(!handle, "get_Handle returned wrong handle %#x\n", handle);
+
+ IPicture_Release(pic);
+ }
+ IStream_Release(dst_stream);
+
+ /* again with non-statable and non-seekable stream */
+ stream = NoStatStream_Construct(hmem);
+ ok(stream != NULL, "failed to create empty image stream\n");
+
+ pic = NULL;
+ hr = pOleLoadPicture(stream, 0, FALSE, &IID_IPicture, (void **)&pic);
+ ok(hr == S_OK, "OleLoadPicture error %#x\n", hr);
+ ok(pic != NULL,"picture should not be not NULL\n");
+ if (pic != NULL)
+ {
+ type = -1;
+ hr = IPicture_get_Type(pic, &type);
+ ok(hr == S_OK,"get_Type error %#8x\n", hr);
+ ok(type == PICTYPE_NONE,"expected picture type PICTYPE_NONE, got %d\n", type);
+
+ handle = (OLE_HANDLE)0xdeadbeef;
+ hr = IPicture_get_Handle(pic, &handle);
+ ok(hr == S_OK,"get_Handle error %#8x\n", hr);
+ ok(!handle, "get_Handle returned wrong handle %#x\n", handle);
+
+ IPicture_Release(pic);
+ }
+ /* Non-statable impl always deletes on release */
+ IStream_Release(stream);
+}
+
+static void test_load_save_emf(void)
+{
+ HDC hdc;
+ IPicture *pic;
+ PICTDESC desc;
+ short type;
+ OLE_HANDLE handle;
+ HGLOBAL hmem;
+ DWORD *mem;
+ ENHMETAHEADER *emh;
+ IPersistStream *src_stream;
+ IStream *dst_stream;
+ LARGE_INTEGER offset;
+ HRESULT hr;
+ LONG size;
+
+ hdc = CreateEnhMetaFileA(0, NULL, NULL, NULL);
+ ok(hdc != 0, "CreateEnhMetaFileA failed\n");
+
+ desc.cbSizeofstruct = sizeof(desc);
+ desc.picType = PICTYPE_ENHMETAFILE;
+ desc.u.emf.hemf = CloseEnhMetaFile(hdc);
+ ok(desc.u.emf.hemf != 0, "CloseEnhMetaFile failed\n");
+ hr = OleCreatePictureIndirect(&desc, &IID_IPicture, FALSE, (void**)&pic);
+ ok(hr == S_OK, "OleCreatePictureIndirect error %#x\n", hr);
+
+ type = -1;
+ hr = IPicture_get_Type(pic, &type);
+ ok(hr == S_OK,"get_Type error %#8x\n", hr);
+ ok(type == PICTYPE_ENHMETAFILE,"expected PICTYPE_ENHMETAFILE, got %d\n", type);
+
+ hr = IPicture_get_Handle(pic, &handle);
+ ok(hr == S_OK,"get_Handle error %#8x\n", hr);
+ ok(IntToPtr(handle) == desc.u.emf.hemf, "get_Handle returned wrong handle %#x\n", handle);
+
+ hmem = GlobalAlloc(GMEM_MOVEABLE, 0);
+ hr = CreateStreamOnHGlobal(hmem, FALSE, &dst_stream);
+ ok(hr == S_OK, "createstreamonhglobal error %#x\n", hr);
+
+ size = -1;
+ hr = IPicture_SaveAsFile(pic, dst_stream, TRUE, &size);
+ ok(hr == S_OK, "IPicture_SaveasFile error %#x\n", hr);
+ ok(size == 128, "expected 128, got %d\n", size);
+ emh = GlobalLock(hmem);
+if (size)
+{
+ ok(emh->iType == EMR_HEADER, "wrong iType %04x\n", emh->iType);
+ ok(emh->dSignature == ENHMETA_SIGNATURE, "wrong dSignature %08x\n", emh->dSignature);
+}
+ GlobalUnlock(hmem);
+
+ size = -1;
+ hr = IPicture_SaveAsFile(pic, dst_stream, FALSE, &size);
+ ok(hr == E_FAIL, "expected E_FAIL, got %#x\n", hr);
+ ok(size == -1, "expected -1, got %d\n", size);
+
+ offset.QuadPart = 0;
+ hr = IStream_Seek(dst_stream, offset, SEEK_SET, NULL);
+ ok(hr == S_OK, "IStream_Seek %#x\n", hr);
+
+ hr = IPicture_QueryInterface(pic, &IID_IPersistStream, (void **)&src_stream);
+ ok(hr == S_OK, "QueryInterface error %#x\n", hr);
+
+ hr = IPersistStream_Save(src_stream, dst_stream, TRUE);
+ ok(hr == S_OK, "Save error %#x\n", hr);
+
IPersistStream_Release(src_stream);
IStream_Release(dst_stream);
+ mem = GlobalLock(hmem);
+ ok(!memcmp(mem, "lt\0\0", 4), "got wrong stream header %04x\n", mem[0]);
+ ok(mem[1] == 128, "expected 128, got %u\n", mem[1]);
+ emh = (ENHMETAHEADER *)(mem + 2);
+ ok(emh->iType == EMR_HEADER, "wrong iType %04x\n", emh->iType);
+ ok(emh->dSignature == ENHMETA_SIGNATURE, "wrong dSignature %08x\n", emh->dSignature);
+
+ GlobalUnlock(hmem);
GlobalFree(hmem);
+
+ DeleteEnhMetaFile(desc.u.emf.hemf);
IPicture_Release(pic);
}
test_pic(gifimage, sizeof(gifimage));
test_pic(jpgimage, sizeof(jpgimage));
test_pic(bmpimage, sizeof(bmpimage));
+ test_pic(bmpimage_rle8, sizeof(bmpimage_rle8));
test_pic(gif4pixel, sizeof(gif4pixel));
/* FIXME: No PNG support in Windows... */
if (0) test_pic(pngimage, sizeof(pngimage));
test_load_save_bmp();
test_load_save_icon();
test_load_save_empty_picture();
+ test_load_save_emf();
}
NoStatStreamImpl* const This = impl_from_IStream(iface);
if (ppvObject==0) return E_INVALIDARG;
*ppvObject = 0;
- if (IsEqualIID(&IID_IUnknown, riid))
- {
- *ppvObject = This;
- }
- else if (IsEqualIID(&IID_IStream, riid))
- {
- *ppvObject = This;
- }
+
+ if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IStream, riid))
+ *ppvObject = &This->IStream_iface;
if ((*ppvObject)==0)
return E_NOINTERFACE;