git.oblomov.eu Git - wine/blob - dlls/oleaut32/tests/olepicture.c

   1 /*
   2  * OLEPICTURE test program
   3  *
   4  * Copyright 2005 Marcus Meissner
   5  *
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23 #include <stdio.h>
  24 #include <math.h>
  25 #include <float.h>
  26
  27 #define COBJMACROS
  28 #define NONAMELESSUNION
  29
  30 #include "wine/test.h"
  31 #include <windef.h>
  32 #include <winbase.h>
  33 #include <winuser.h>
  34 #include <wingdi.h>
  35 #include <winnls.h>
  36 #include <winerror.h>
  37 #include <winnt.h>
  38
  39 #include <wtypes.h>
  40 #include <olectl.h>
  41 #include <objidl.h>
  42
  43 #define expect_eq(expr, value, type, format) { type ret = (expr); ok((value) == ret, #expr " expected " format " got " format "\n", value, ret); }
  44
  45 #define ole_expect(expr, expect) { \
  46     HRESULT r = expr; \
  47     ok(r == (expect), #expr " returned %x, expected %s (%x)\n", r, #expect, expect); \
  48 }
  49
  50 #define ole_check(expr) ole_expect(expr, S_OK);
  51
  52 static HMODULE hOleaut32;
  53
  54 static HRESULT (WINAPI *pOleLoadPicture)(LPSTREAM,LONG,BOOL,REFIID,LPVOID*);
  55 static HRESULT (WINAPI *pOleCreatePictureIndirect)(PICTDESC*,REFIID,BOOL,LPVOID*);
  56
  57 #define ok_ole_success(hr, func) ok(hr == S_OK, func " failed with error 0x%08x\n", hr)
  58
  59 /* 1x1 pixel gif */
  60 static const unsigned char gifimage[35] = {
  61 0x47,0x49,0x46,0x38,0x37,0x61,0x01,0x00,0x01,0x00,0x80,0x00,0x00,0xff,0xff,0xff,
  62 0xff,0xff,0xff,0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x02,0x02,0x44,
  63 0x01,0x00,0x3b
  64 };
  65
  66 /* 1x1 pixel jpg */
  67 static const unsigned char jpgimage[285] = {
  68 0xff,0xd8,0xff,0xe0,0x00,0x10,0x4a,0x46,0x49,0x46,0x00,0x01,0x01,0x01,0x01,0x2c,
  69 0x01,0x2c,0x00,0x00,0xff,0xdb,0x00,0x43,0x00,0x05,0x03,0x04,0x04,0x04,0x03,0x05,
  70 0x04,0x04,0x04,0x05,0x05,0x05,0x06,0x07,0x0c,0x08,0x07,0x07,0x07,0x07,0x0f,0x0b,
  71 0x0b,0x09,0x0c,0x11,0x0f,0x12,0x12,0x11,0x0f,0x11,0x11,0x13,0x16,0x1c,0x17,0x13,
  72 0x14,0x1a,0x15,0x11,0x11,0x18,0x21,0x18,0x1a,0x1d,0x1d,0x1f,0x1f,0x1f,0x13,0x17,
  73 0x22,0x24,0x22,0x1e,0x24,0x1c,0x1e,0x1f,0x1e,0xff,0xdb,0x00,0x43,0x01,0x05,0x05,
  74 0x05,0x07,0x06,0x07,0x0e,0x08,0x08,0x0e,0x1e,0x14,0x11,0x14,0x1e,0x1e,0x1e,0x1e,
  75 0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,
  76 0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,
  77 0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0xff,0xc0,
  78 0x00,0x11,0x08,0x00,0x01,0x00,0x01,0x03,0x01,0x22,0x00,0x02,0x11,0x01,0x03,0x11,
  79 0x01,0xff,0xc4,0x00,0x15,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  80 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0xff,0xc4,0x00,0x14,0x10,0x01,0x00,0x00,
  81 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xc4,
  82 0x00,0x14,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  83 0x00,0x00,0x00,0x00,0xff,0xc4,0x00,0x14,0x11,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
  84 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xda,0x00,0x0c,0x03,0x01,
  85 0x00,0x02,0x11,0x03,0x11,0x00,0x3f,0x00,0xb2,0xc0,0x07,0xff,0xd9
  86 };
  87
  88 /* 1x1 pixel png */
  89 static const unsigned char pngimage[285] = {
  90 0x89,0x50,0x4e,0x47,0x0d,0x0a,0x1a,0x0a,0x00,0x00,0x00,0x0d,0x49,0x48,0x44,0x52,
  91 0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x08,0x02,0x00,0x00,0x00,0x90,0x77,0x53,
  92 0xde,0x00,0x00,0x00,0x09,0x70,0x48,0x59,0x73,0x00,0x00,0x0b,0x13,0x00,0x00,0x0b,
  93 0x13,0x01,0x00,0x9a,0x9c,0x18,0x00,0x00,0x00,0x07,0x74,0x49,0x4d,0x45,0x07,0xd5,
  94 0x06,0x03,0x0f,0x07,0x2d,0x12,0x10,0xf0,0xfd,0x00,0x00,0x00,0x0c,0x49,0x44,0x41,
  95 0x54,0x08,0xd7,0x63,0xf8,0xff,0xff,0x3f,0x00,0x05,0xfe,0x02,0xfe,0xdc,0xcc,0x59,
  96 0xe7,0x00,0x00,0x00,0x00,0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82
  97 };
  98
  99 /* 1x1 pixel bmp */
 100 static const unsigned char bmpimage[66] = {
 101 0x42,0x4d,0x42,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3e,0x00,0x00,0x00,0x28,0x00,
 102 0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x00,
 103 0x00,0x00,0x04,0x00,0x00,0x00,0x12,0x0b,0x00,0x00,0x12,0x0b,0x00,0x00,0x02,0x00,
 104 0x00,0x00,0x02,0x00,0x00,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x00,0x00,
 105 0x00,0x00
 106 };
 107
 108 /* 2x2 pixel gif */
 109 static const unsigned char gif4pixel[42] = {
 110 0x47,0x49,0x46,0x38,0x37,0x61,0x02,0x00,0x02,0x00,0xa1,0x00,0x00,0x00,0x00,0x00,
 111 0x39,0x62,0xfc,0xff,0x1a,0xe5,0xff,0xff,0xff,0x2c,0x00,0x00,0x00,0x00,0x02,0x00,
 112 0x02,0x00,0x00,0x02,0x03,0x14,0x16,0x05,0x00,0x3b
 113 };
 114
 115 /* APM with an empty metafile with some padding zeros - looks like under Window the
 116  * metafile data should be at least 20 bytes */
 117 static const unsigned char apmdata[] = {
 118 0xd7,0xcd,0xc6,0x9a, 0x00,0x00,0x00,0x00, 0x00,0x00,0xee,0x02, 0xb1,0x03,0xa0,0x05,
 119 0x00,0x00,0x00,0x00, 0xee,0x53,0x01,0x00, 0x09,0x00,0x00,0x03, 0x13,0x00,0x00,0x00,
 120 0x01,0x00,0x05,0x00, 0x00,0x00,0x00,0x00, 0x03,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
 121 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00
 122 };
 123
 124 /* MF_TEXTOUT_ON_PATH_BITS from gdi32/tests/metafile.c */
 125 static const unsigned char metafile[] = {
 126     0x01, 0x00, 0x09, 0x00, 0x00, 0x03, 0x19, 0x00,
 127     0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00,
 128     0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x32, 0x0a,
 129     0x16, 0x00, 0x0b, 0x00, 0x04, 0x00, 0x00, 0x00,
 130     0x54, 0x65, 0x73, 0x74, 0x03, 0x00, 0x05, 0x00,
 131     0x08, 0x00, 0x0c, 0x00, 0x03, 0x00, 0x00, 0x00,
 132     0x00, 0x00
 133 };
 134
 135 /* EMF_TEXTOUT_ON_PATH_BITS from gdi32/tests/metafile.c */
 136 static const unsigned char enhmetafile[] = {
 137     0x01, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00,
 138     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 139     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 140     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 141     0xe7, 0xff, 0xff, 0xff, 0xe9, 0xff, 0xff, 0xff,
 142     0x20, 0x45, 0x4d, 0x46, 0x00, 0x00, 0x01, 0x00,
 143     0xf4, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
 144     0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 145     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 146     0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
 147     0x40, 0x01, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00,
 148     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 149     0x00, 0x00, 0x00, 0x00, 0x00, 0xe2, 0x04, 0x00,
 150     0x80, 0xa9, 0x03, 0x00, 0x3b, 0x00, 0x00, 0x00,
 151     0x08, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00,
 152     0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 153     0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 154     0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00,
 155     0x00, 0x00, 0xc8, 0x41, 0x00, 0x80, 0xbb, 0x41,
 156     0x0b, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
 157     0x04, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00,
 158     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 159     0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 160     0xff, 0xff, 0xff, 0xff, 0x54, 0x00, 0x00, 0x00,
 161     0x54, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00,
 162     0x03, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
 163     0x08, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
 164     0x3c, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
 165     0x0e, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
 166     0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
 167     0x14, 0x00, 0x00, 0x00
 168 };
 169
 170
 171 struct NoStatStreamImpl
 172 {
 173         const IStreamVtbl       *lpVtbl;
 174         LONG                    ref;
 175
 176         HGLOBAL                 supportHandle;
 177         ULARGE_INTEGER          streamSize;
 178         ULARGE_INTEGER          currentPosition;
 179 };
 180 typedef struct NoStatStreamImpl NoStatStreamImpl;
 181 static NoStatStreamImpl* NoStatStreamImpl_Construct(HGLOBAL hGlobal);
 182
 183 static void
 184 test_pic_with_stream(LPSTREAM stream, unsigned int imgsize)
 185 {
 186         IPicture*       pic = NULL;
 187         HRESULT         hres;
 188         LPVOID          pvObj = NULL;
 189         OLE_HANDLE      handle, hPal;
 190         OLE_XSIZE_HIMETRIC      width;
 191         OLE_YSIZE_HIMETRIC      height;
 192         short           type;
 193         DWORD           attr;
 194         ULONG           res;
 195
 196         pvObj = NULL;
 197         hres = pOleLoadPicture(stream, imgsize, TRUE, &IID_IPicture, &pvObj);
 198         pic = pvObj;
 199
 200         ok(hres == S_OK,"OLP (NULL,..) does not return 0, but 0x%08x\n",hres);
 201         ok(pic != NULL,"OLP (NULL,..) returns NULL, instead of !NULL\n");
 202         if (pic == NULL)
 203                 return;
 204
 205         pvObj = NULL;
 206         hres = IPicture_QueryInterface (pic, &IID_IPicture, &pvObj);
 207
 208         ok(hres == S_OK,"IPicture_QI does not return S_OK, but 0x%08x\n", hres);
 209         ok(pvObj != NULL,"IPicture_QI does return NULL, instead of a ptr\n");
 210
 211         IPicture_Release ((IPicture*)pvObj);
 212
 213         handle = 0;
 214         hres = IPicture_get_Handle (pic, &handle);
 215         ok(hres == S_OK,"IPicture_get_Handle does not return S_OK, but 0x%08x\n", hres);
 216         ok(handle != 0, "IPicture_get_Handle returns a NULL handle, but it should be non NULL\n");
 217
 218         width = 0;
 219         hres = IPicture_get_Width (pic, &width);
 220         ok(hres == S_OK,"IPicture_get_Width does not return S_OK, but 0x%08x\n", hres);
 221         ok(width != 0, "IPicture_get_Width returns 0, but it should not be 0.\n");
 222
 223         height = 0;
 224         hres = IPicture_get_Height (pic, &height);
 225         ok(hres == S_OK,"IPicture_get_Height does not return S_OK, but 0x%08x\n", hres);
 226         ok(height != 0, "IPicture_get_Height returns 0, but it should not be 0.\n");
 227
 228         type = 0;
 229         hres = IPicture_get_Type (pic, &type);
 230         ok(hres == S_OK,"IPicture_get_Type does not return S_OK, but 0x%08x\n", hres);
 231         ok(type == PICTYPE_BITMAP, "IPicture_get_Type returns %d, but it should be PICTYPE_BITMAP(%d).\n", type, PICTYPE_BITMAP);
 232
 233         attr = 0;
 234         hres = IPicture_get_Attributes (pic, &attr);
 235         ok(hres == S_OK,"IPicture_get_Attributes does not return S_OK, but 0x%08x\n", hres);
 236         ok(attr == 0, "IPicture_get_Attributes returns %d, but it should be 0.\n", attr);
 237
 238         hPal = 0;
 239         hres = IPicture_get_hPal (pic, &hPal);
 240         ok(hres == S_OK,"IPicture_get_hPal does not return S_OK, but 0x%08x\n", hres);
 241         /* a single pixel b/w image has no palette */
 242         ok(hPal == 0, "IPicture_get_hPal returns %d, but it should be 0.\n", hPal);
 243
 244         res = IPicture_Release (pic);
 245         ok (res == 0, "refcount after release is %d, but should be 0?\n", res);
 246 }
 247
 248 static void
 249 test_pic(const unsigned char *imgdata, unsigned int imgsize)
 250 {
 251         LPSTREAM        stream;
 252         HGLOBAL         hglob;
 253         LPBYTE          data;
 254         HRESULT         hres;
 255         LARGE_INTEGER   seekto;
 256         ULARGE_INTEGER  newpos1;
 257         DWORD *         header;
 258         unsigned int    i,j;
 259
 260         /* Let the fun begin */
 261         hglob = GlobalAlloc (0, imgsize);
 262         data = GlobalLock (hglob);
 263         memcpy(data, imgdata, imgsize);
 264         GlobalUnlock(hglob); data = NULL;
 265
 266         hres = CreateStreamOnHGlobal (hglob, FALSE, &stream);
 267         ok (hres == S_OK, "createstreamonhglobal failed? doubt it... hres 0x%08x\n", hres);
 268
 269         memset(&seekto,0,sizeof(seekto));
 270         hres = IStream_Seek(stream,seekto,SEEK_CUR,&newpos1);
 271         ok (hres == S_OK, "istream seek failed? doubt it... hres 0x%08x\n", hres);
 272         test_pic_with_stream(stream, imgsize);
 273
 274         IStream_Release(stream);
 275
 276         /* again with Non Statable and Non Seekable stream */
 277         stream = (LPSTREAM)NoStatStreamImpl_Construct(hglob);
 278         hglob = 0;  /* Non-statable impl always deletes on release */
 279         test_pic_with_stream(stream, 0);
 280
 281         IStream_Release(stream);
 282         for (i = 1; i <= 8; i++) {
 283                 /* more fun!!! */
 284                 hglob = GlobalAlloc (0, imgsize + i * (2 * sizeof(DWORD)));
 285                 data = GlobalLock (hglob);
 286                 header = (DWORD *)data;
 287
 288                 /* multiple copies of header */
 289                 memcpy(data,"lt\0\0",4);
 290                 header[1] = imgsize;
 291                 for (j = 2; j <= i; j++) {
 292                         memcpy(&(header[2 * (j - 1)]), header, 2 * sizeof(DWORD));
 293                 }
 294                 memcpy(data + i * (2 * sizeof(DWORD)), imgdata, imgsize);
 295                 GlobalUnlock(hglob); data = NULL;
 296
 297                 hres = CreateStreamOnHGlobal (hglob, FALSE, &stream);
 298                 ok (hres == S_OK, "createstreamonhglobal failed? doubt it... hres 0x%08x\n", hres);
 299
 300                 memset(&seekto,0,sizeof(seekto));
 301                 hres = IStream_Seek(stream,seekto,SEEK_CUR,&newpos1);
 302                 ok (hres == S_OK, "istream seek failed? doubt it... hres 0x%08x\n", hres);
 303                 test_pic_with_stream(stream, imgsize);
 304
 305                 IStream_Release(stream);
 306
 307                 /* again with Non Statable and Non Seekable stream */
 308                 stream = (LPSTREAM)NoStatStreamImpl_Construct(hglob);
 309                 hglob = 0;  /* Non-statable impl always deletes on release */
 310                 test_pic_with_stream(stream, 0);
 311
 312                 IStream_Release(stream);
 313         }
 314 }
 315
 316 static void test_empty_image(void) {
 317         LPBYTE          data;
 318         LPSTREAM        stream;
 319         IPicture*       pic = NULL;
 320         HRESULT         hres;
 321         LPVOID          pvObj = NULL;
 322         HGLOBAL         hglob;
 323         OLE_HANDLE      handle;
 324         ULARGE_INTEGER  newpos1;
 325         LARGE_INTEGER   seekto;
 326         short           type;
 327         DWORD           attr;
 328
 329         /* Empty image. Happens occasionally in VB programs. */
 330         hglob = GlobalAlloc (0, 8);
 331         data = GlobalLock (hglob);
 332         memcpy(data,"lt\0\0",4);
 333         ((DWORD*)data)[1] = 0;
 334         hres = CreateStreamOnHGlobal (hglob, TRUE, &stream);
 335         ok (hres == S_OK, "CreatestreamOnHGlobal failed? doubt it... hres 0x%08x\n", hres);
 336
 337         memset(&seekto,0,sizeof(seekto));
 338         hres = IStream_Seek(stream,seekto,SEEK_CUR,&newpos1);
 339         ok (hres == S_OK, "istream seek failed? doubt it... hres 0x%08x\n", hres);
 340
 341         pvObj = NULL;
 342         hres = pOleLoadPicture(stream, 8, TRUE, &IID_IPicture, &pvObj);
 343         pic = pvObj;
 344         ok(hres == S_OK,"empty picture not loaded, hres 0x%08x\n", hres);
 345         ok(pic != NULL,"empty picture not loaded, pic is NULL\n");
 346
 347         hres = IPicture_get_Type (pic, &type);
 348         ok (hres == S_OK,"empty picture get type failed with hres 0x%08x\n", hres);
 349         ok (type == PICTYPE_NONE,"type is %d, but should be PICTYPE_NONE(0)\n", type);
 350
 351         attr = 0xdeadbeef;
 352         hres = IPicture_get_Attributes (pic, &attr);
 353         ok (hres == S_OK,"empty picture get attributes failed with hres 0x%08x\n", hres);
 354         ok (attr == 0,"attr is %d, but should be 0\n", attr);
 355
 356         hres = IPicture_get_Handle (pic, &handle);
 357         ok (hres == S_OK,"empty picture get handle failed with hres 0x%08x\n", hres);
 358         ok (handle == 0, "empty picture get handle did not return 0, but 0x%08x\n", handle);
 359         IPicture_Release (pic);
 360 }
 361
 362 static void test_empty_image_2(void) {
 363         LPBYTE          data;
 364         LPSTREAM        stream;
 365         IPicture*       pic = NULL;
 366         HRESULT         hres;
 367         LPVOID          pvObj = NULL;
 368         HGLOBAL         hglob;
 369         ULARGE_INTEGER  newpos1;
 370         LARGE_INTEGER   seekto;
 371         short           type;
 372
 373         /* Empty image at random stream position. */
 374         hglob = GlobalAlloc (0, 200);
 375         data = GlobalLock (hglob);
 376         data += 42;
 377         memcpy(data,"lt\0\0",4);
 378         ((DWORD*)data)[1] = 0;
 379         hres = CreateStreamOnHGlobal (hglob, TRUE, &stream);
 380         ok (hres == S_OK, "CreatestreamOnHGlobal failed? doubt it... hres 0x%08x\n", hres);
 381
 382         memset(&seekto,0,sizeof(seekto));
 383         seekto.u.LowPart = 42;
 384         hres = IStream_Seek(stream,seekto,SEEK_CUR,&newpos1);
 385         ok (hres == S_OK, "istream seek failed? doubt it... hres 0x%08x\n", hres);
 386
 387         pvObj = NULL;
 388         hres = pOleLoadPicture(stream, 8, TRUE, &IID_IPicture, &pvObj);
 389         pic = pvObj;
 390         ok(hres == S_OK,"empty picture not loaded, hres 0x%08x\n", hres);
 391         ok(pic != NULL,"empty picture not loaded, pic is NULL\n");
 392
 393         hres = IPicture_get_Type (pic, &type);
 394         ok (hres == S_OK,"empty picture get type failed with hres 0x%08x\n", hres);
 395         ok (type == PICTYPE_NONE,"type is %d, but should be PICTYPE_NONE(0)\n", type);
 396
 397         IPicture_Release (pic);
 398 }
 399
 400 static void test_Invoke(void)
 401 {
 402     IPictureDisp *picdisp;
 403     HRESULT hr;
 404     VARIANTARG vararg;
 405     DISPPARAMS dispparams;
 406     VARIANT varresult;
 407     IStream *stream;
 408     HGLOBAL hglob;
 409     void *data;
 410
 411         hglob = GlobalAlloc (0, sizeof(gifimage));
 412         data = GlobalLock(hglob);
 413         memcpy(data, gifimage, sizeof(gifimage));
 414     GlobalUnlock(hglob);
 415
 416         hr = CreateStreamOnHGlobal (hglob, FALSE, &stream);
 417     ok_ole_success(hr, "CreateStreamOnHGlobal");
 418
 419         hr = pOleLoadPicture(stream, sizeof(gifimage), TRUE, &IID_IPictureDisp, (void **)&picdisp);
 420     IStream_Release(stream);
 421     ok_ole_success(hr, "OleLoadPicture");
 422
 423     V_VT(&vararg) = VT_BOOL;
 424     V_BOOL(&vararg) = VARIANT_FALSE;
 425     dispparams.cNamedArgs = 0;
 426     dispparams.rgdispidNamedArgs = NULL;
 427     dispparams.cArgs = 1;
 428     dispparams.rgvarg = &vararg;
 429     hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_IPictureDisp, 0, DISPATCH_PROPERTYPUT, &dispparams, NULL, NULL, NULL);
 430     ok(hr == DISP_E_UNKNOWNNAME, "IPictureDisp_Invoke should have returned DISP_E_UNKNOWNNAME instead of 0x%08x\n", hr);
 431     hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_IUnknown, 0, DISPATCH_PROPERTYPUT, &dispparams, NULL, NULL, NULL);
 432     ok(hr == DISP_E_UNKNOWNNAME, "IPictureDisp_Invoke should have returned DISP_E_UNKNOWNNAME instead of 0x%08x\n", hr);
 433
 434     dispparams.cArgs = 0;
 435     dispparams.rgvarg = NULL;
 436     hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_PROPERTYPUT, &dispparams, NULL, NULL, NULL);
 437     ok(hr == DISP_E_BADPARAMCOUNT, "IPictureDisp_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr);
 438
 439     hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_PROPERTYPUT, NULL, NULL, NULL, NULL);
 440     ok(hr == DISP_E_PARAMNOTOPTIONAL, "IPictureDisp_Invoke should have returned DISP_E_PARAMNOTOPTIONAL instead of 0x%08x\n", hr);
 441
 442     hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_PROPERTYGET, NULL, NULL, NULL, NULL);
 443     ok(hr == DISP_E_PARAMNOTOPTIONAL, "IPictureDisp_Invoke should have returned DISP_E_PARAMNOTOPTIONAL instead of 0x%08x\n", hr);
 444
 445     hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_PROPERTYGET, NULL, &varresult, NULL, NULL);
 446     ok(hr == DISP_E_PARAMNOTOPTIONAL, "IPictureDisp_Invoke should have returned DISP_E_PARAMNOTOPTIONAL instead of 0x%08x\n", hr);
 447
 448     hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &varresult, NULL, NULL);
 449     ok_ole_success(hr, "IPictureDisp_Invoke");
 450     ok(V_VT(&varresult) == VT_I4, "V_VT(&varresult) should have been VT_UINT instead of %d\n", V_VT(&varresult));
 451
 452     hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &varresult, NULL, NULL);
 453     ok(hr == DISP_E_MEMBERNOTFOUND, "IPictureDisp_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
 454
 455     hr = IPictureDisp_Invoke(picdisp, 0xdeadbeef, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &varresult, NULL, NULL);
 456     ok(hr == DISP_E_MEMBERNOTFOUND, "IPictureDisp_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
 457
 458     dispparams.cArgs = 1;
 459     dispparams.rgvarg = &vararg;
 460     hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &varresult, NULL, NULL);
 461     ok(hr == DISP_E_BADPARAMCOUNT, "IPictureDisp_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr);
 462
 463     dispparams.cArgs = 1;
 464     dispparams.rgvarg = &vararg;
 465     hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &varresult, NULL, NULL);
 466     ok(hr == DISP_E_BADPARAMCOUNT, "IPictureDisp_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr);
 467
 468     IPictureDisp_Release(picdisp);
 469 }
 470
 471 static void test_OleCreatePictureIndirect(void)
 472 {
 473     IPicture *pict;
 474     HRESULT hr;
 475     short type;
 476     OLE_HANDLE handle;
 477
 478     if(!pOleCreatePictureIndirect)
 479     {
 480         win_skip("Skipping OleCreatePictureIndirect tests\n");
 481         return;
 482     }
 483
 484     hr = pOleCreatePictureIndirect(NULL, &IID_IPicture, TRUE, (void**)&pict);
 485     ok(hr == S_OK, "hr %08x\n", hr);
 486
 487     hr = IPicture_get_Type(pict, &type);
 488     ok(hr == S_OK, "hr %08x\n", hr);
 489     ok(type == PICTYPE_UNINITIALIZED, "type %d\n", type);
 490
 491     hr = IPicture_get_Handle(pict, &handle);
 492     ok(hr == S_OK, "hr %08x\n", hr);
 493     ok(handle == 0, "handle %08x\n", handle);
 494
 495     IPicture_Release(pict);
 496 }
 497
 498 static void test_apm(void)
 499 {
 500     OLE_HANDLE handle;
 501     LPSTREAM stream;
 502     IPicture *pict;
 503     HGLOBAL hglob;
 504     LPBYTE *data;
 505     LONG cxy;
 506     BOOL keep;
 507     short type;
 508
 509     hglob = GlobalAlloc (0, sizeof(apmdata));
 510     data = GlobalLock(hglob);
 511     memcpy(data, apmdata, sizeof(apmdata));
 512
 513     ole_check(CreateStreamOnHGlobal(hglob, TRUE, &stream));
 514     ole_check(OleLoadPictureEx(stream, sizeof(apmdata), TRUE, &IID_IPicture, 100, 100, 0, (LPVOID *)&pict));
 515
 516     ole_check(IPicture_get_Handle(pict, &handle));
 517     ok(handle != 0, "handle is null\n");
 518
 519     ole_check(IPicture_get_Type(pict, &type));
 520     expect_eq(type, PICTYPE_METAFILE, short, "%d");
 521
 522     ole_check(IPicture_get_Height(pict, &cxy));
 523     expect_eq(cxy,  1667, LONG, "%d");
 524
 525     ole_check(IPicture_get_Width(pict, &cxy));
 526     expect_eq(cxy,  1323, LONG, "%d");
 527
 528     ole_check(IPicture_get_KeepOriginalFormat(pict, &keep));
 529     todo_wine expect_eq(keep, FALSE, LONG, "%d");
 530
 531     ole_expect(IPicture_get_hPal(pict, &handle), E_FAIL);
 532     IPicture_Release(pict);
 533     IStream_Release(stream);
 534 }
 535
 536 static void test_metafile(void)
 537 {
 538     LPSTREAM stream;
 539     IPicture *pict;
 540     HGLOBAL hglob;
 541     LPBYTE *data;
 542
 543     hglob = GlobalAlloc (0, sizeof(metafile));
 544     data = GlobalLock(hglob);
 545     memcpy(data, metafile, sizeof(metafile));
 546
 547     ole_check(CreateStreamOnHGlobal(hglob, TRUE, &stream));
 548     /* Windows does not load simple metafiles */
 549     ole_expect(OleLoadPictureEx(stream, sizeof(metafile), TRUE, &IID_IPicture, 100, 100, 0, (LPVOID *)&pict), E_FAIL);
 550
 551     IStream_Release(stream);
 552 }
 553
 554 static void test_enhmetafile(void)
 555 {
 556     OLE_HANDLE handle;
 557     LPSTREAM stream;
 558     IPicture *pict;
 559     HGLOBAL hglob;
 560     LPBYTE *data;
 561     LONG cxy;
 562     BOOL keep;
 563     short type;
 564
 565     hglob = GlobalAlloc (0, sizeof(enhmetafile));
 566     data = GlobalLock(hglob);
 567     memcpy(data, enhmetafile, sizeof(enhmetafile));
 568
 569     ole_check(CreateStreamOnHGlobal(hglob, TRUE, &stream));
 570     ole_check(OleLoadPictureEx(stream, sizeof(enhmetafile), TRUE, &IID_IPicture, 10, 10, 0, (LPVOID *)&pict));
 571
 572     ole_check(IPicture_get_Handle(pict, &handle));
 573     ok(handle != 0, "handle is null\n");
 574
 575     ole_check(IPicture_get_Type(pict, &type));
 576     expect_eq(type, PICTYPE_ENHMETAFILE, short, "%d");
 577
 578     ole_check(IPicture_get_Height(pict, &cxy));
 579     expect_eq(cxy, -23, LONG, "%d");
 580
 581     ole_check(IPicture_get_Width(pict, &cxy));
 582     expect_eq(cxy, -25, LONG, "%d");
 583
 584     ole_check(IPicture_get_KeepOriginalFormat(pict, &keep));
 585     todo_wine expect_eq(keep, FALSE, LONG, "%d");
 586
 587     IPicture_Release(pict);
 588     IStream_Release(stream);
 589 }
 590
 591 static void test_Render(void)
 592 {
 593     IPicture *pic;
 594     HRESULT hres;
 595     short type;
 596     PICTDESC desc;
 597     HDC hdc = GetDC(0);
 598
 599     /* test IPicture::Render return code on uninitialized picture */
 600     OleCreatePictureIndirect(NULL, &IID_IPicture, TRUE, (VOID**)&pic);
 601     hres = IPicture_get_Type(pic, &type);
 602     ok(hres == S_OK, "IPicture_get_Type does not return S_OK, but 0x%08x\n", hres);
 603     ok(type == PICTYPE_UNINITIALIZED, "Expected type = PICTYPE_UNINITIALIZED, got = %d\n", type);
 604     /* zero dimensions */
 605     hres = IPicture_Render(pic, hdc, 0, 0, 0, 0, 0, 0, 0, 0, NULL);
 606     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 607     hres = IPicture_Render(pic, hdc, 0, 0, 10, 10, 0, 0, 10, 0, NULL);
 608     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 609     hres = IPicture_Render(pic, hdc, 0, 0, 10, 10, 0, 0, 0, 10, NULL);
 610     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 611     hres = IPicture_Render(pic, hdc, 0, 0, 10, 10, 0, 0, 0, 0, NULL);
 612     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 613     hres = IPicture_Render(pic, hdc, 0, 0, 0, 10, 0, 0, 10, 10, NULL);
 614     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 615     hres = IPicture_Render(pic, hdc, 0, 0, 10, 0, 0, 0, 10, 10, NULL);
 616     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 617     hres = IPicture_Render(pic, hdc, 0, 0, 0, 0, 0, 0, 10, 10, NULL);
 618     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 619     /* nonzero dimensions, PICTYPE_UNINITIALIZED */
 620     hres = IPicture_Render(pic, hdc, 0, 0, 10, 10, 0, 0, 10, 10, NULL);
 621     ole_expect(hres, S_OK);
 622     IPicture_Release(pic);
 623
 624     desc.cbSizeofstruct = sizeof(PICTDESC);
 625     desc.picType = PICTYPE_ICON;
 626     desc.u.icon.hicon = LoadIcon(NULL, IDI_APPLICATION);
 627     if(!desc.u.icon.hicon){
 628         win_skip("LoadIcon failed. Skipping...\n");
 629         ReleaseDC(NULL, hdc);
 630         return;
 631     }
 632
 633     OleCreatePictureIndirect(&desc, &IID_IPicture, TRUE, (VOID**)&pic);
 634     /* zero dimensions, PICTYPE_ICON */
 635     hres = IPicture_Render(pic, hdc, 0, 0, 0, 0, 0, 0, 0, 0, NULL);
 636     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 637     hres = IPicture_Render(pic, hdc, 0, 0, 10, 10, 0, 0, 10, 0, NULL);
 638     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 639     hres = IPicture_Render(pic, hdc, 0, 0, 10, 10, 0, 0, 0, 10, NULL);
 640     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 641     hres = IPicture_Render(pic, hdc, 0, 0, 10, 10, 0, 0, 0, 0, NULL);
 642     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 643     hres = IPicture_Render(pic, hdc, 0, 0, 0, 10, 0, 0, 10, 10, NULL);
 644     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 645     hres = IPicture_Render(pic, hdc, 0, 0, 10, 0, 0, 0, 10, 10, NULL);
 646     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 647     hres = IPicture_Render(pic, hdc, 0, 0, 0, 0, 0, 0, 10, 10, NULL);
 648     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 649     IPicture_Release(pic);
 650
 651     ReleaseDC(NULL, hdc);
 652 }
 653
 654 static void test_get_Attributes(void)
 655 {
 656     IPicture *pic;
 657     HRESULT hres;
 658     short type;
 659     DWORD attr;
 660
 661     OleCreatePictureIndirect(NULL, &IID_IPicture, TRUE, (VOID**)&pic);
 662     hres = IPicture_get_Type(pic, &type);
 663     ok(hres == S_OK, "IPicture_get_Type does not return S_OK, but 0x%08x\n", hres);
 664     ok(type == PICTYPE_UNINITIALIZED, "Expected type = PICTYPE_UNINITIALIZED, got = %d\n", type);
 665
 666     hres = IPicture_get_Attributes(pic, NULL);
 667     ole_expect(hres, E_POINTER);
 668
 669     attr = 0xdeadbeef;
 670     hres = IPicture_get_Attributes(pic, &attr);
 671     ole_expect(hres, S_OK);
 672     ok(attr == 0, "IPicture_get_Attributes does not reset attr to zero, got %d\n", attr);
 673
 674     IPicture_Release(pic);
 675 }
 676
 677 static void test_get_Handle(void)
 678 {
 679     IPicture *pic;
 680     HRESULT hres;
 681
 682     OleCreatePictureIndirect(NULL, &IID_IPicture, TRUE, (VOID**)&pic);
 683
 684     hres = IPicture_get_Handle(pic, NULL);
 685     ole_expect(hres, E_POINTER);
 686
 687     IPicture_Release(pic);
 688 }
 689
 690 static void test_get_Type(void)
 691 {
 692     IPicture *pic;
 693     HRESULT hres;
 694
 695     OleCreatePictureIndirect(NULL, &IID_IPicture, TRUE, (VOID**)&pic);
 696
 697     hres = IPicture_get_Type(pic, NULL);
 698     ole_expect(hres, E_POINTER);
 699
 700     IPicture_Release(pic);
 701 }
 702
 703 START_TEST(olepicture)
 704 {
 705         hOleaut32 = GetModuleHandleA("oleaut32.dll");
 706         pOleLoadPicture = (void*)GetProcAddress(hOleaut32, "OleLoadPicture");
 707         pOleCreatePictureIndirect = (void*)GetProcAddress(hOleaut32, "OleCreatePictureIndirect");
 708         if (!pOleLoadPicture)
 709         {
 710             win_skip("OleLoadPicture is not available\n");
 711             return;
 712         }
 713
 714         /* Test regular 1x1 pixel images of gif, jpg, bmp type */
 715         test_pic(gifimage, sizeof(gifimage));
 716         test_pic(jpgimage, sizeof(jpgimage));
 717         test_pic(bmpimage, sizeof(bmpimage));
 718         test_pic(gif4pixel, sizeof(gif4pixel));
 719         /* FIXME: No PNG support yet in Wine or in older Windows... */
 720         if (0) test_pic(pngimage, sizeof(pngimage));
 721         test_empty_image();
 722         test_empty_image_2();
 723         test_apm();
 724         test_metafile();
 725         test_enhmetafile();
 726
 727         test_Invoke();
 728         test_OleCreatePictureIndirect();
 729         test_Render();
 730         test_get_Attributes();
 731         test_get_Handle();
 732         test_get_Type();
 733 }
 734
 735
 736 /* Helper functions only ... */
 737
 738
 739 static void NoStatStreamImpl_Destroy(NoStatStreamImpl* This)
 740 {
 741   GlobalFree(This->supportHandle);
 742   This->supportHandle=0;
 743   HeapFree(GetProcessHeap(), 0, This);
 744 }
 745
 746 static ULONG WINAPI NoStatStreamImpl_AddRef(
 747                 IStream* iface)
 748 {
 749   NoStatStreamImpl* const This=(NoStatStreamImpl*)iface;
 750   return InterlockedIncrement(&This->ref);
 751 }
 752
 753 static HRESULT WINAPI NoStatStreamImpl_QueryInterface(
 754                   IStream*     iface,
 755                   REFIID         riid,        /* [in] */
 756                   void**         ppvObject)   /* [iid_is][out] */
 757 {
 758   NoStatStreamImpl* const This=(NoStatStreamImpl*)iface;
 759   if (ppvObject==0) return E_INVALIDARG;
 760   *ppvObject = 0;
 761   if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0)
 762   {
 763     *ppvObject = This;
 764   }
 765   else if (memcmp(&IID_IStream, riid, sizeof(IID_IStream)) == 0)
 766   {
 767     *ppvObject = This;
 768   }
 769
 770   if ((*ppvObject)==0)
 771     return E_NOINTERFACE;
 772   NoStatStreamImpl_AddRef(iface);
 773   return S_OK;
 774 }
 775
 776 static ULONG WINAPI NoStatStreamImpl_Release(
 777                 IStream* iface)
 778 {
 779   NoStatStreamImpl* const This=(NoStatStreamImpl*)iface;
 780   ULONG newRef = InterlockedDecrement(&This->ref);
 781   if (newRef==0)
 782     NoStatStreamImpl_Destroy(This);
 783   return newRef;
 784 }
 785
 786 static HRESULT WINAPI NoStatStreamImpl_Read(
 787                   IStream*     iface,
 788                   void*          pv,        /* [length_is][size_is][out] */
 789                   ULONG          cb,        /* [in] */
 790                   ULONG*         pcbRead)   /* [out] */
 791 {
 792   NoStatStreamImpl* const This=(NoStatStreamImpl*)iface;
 793   void* supportBuffer;
 794   ULONG bytesReadBuffer;
 795   ULONG bytesToReadFromBuffer;
 796
 797   if (pcbRead==0)
 798     pcbRead = &bytesReadBuffer;
 799   bytesToReadFromBuffer = min( This->streamSize.u.LowPart - This->currentPosition.u.LowPart, cb);
 800   supportBuffer = GlobalLock(This->supportHandle);
 801   memcpy(pv, (char *) supportBuffer+This->currentPosition.u.LowPart, bytesToReadFromBuffer);
 802   This->currentPosition.u.LowPart+=bytesToReadFromBuffer;
 803   *pcbRead = bytesToReadFromBuffer;
 804   GlobalUnlock(This->supportHandle);
 805   if(*pcbRead == cb)
 806     return S_OK;
 807   return S_FALSE;
 808 }
 809
 810 static HRESULT WINAPI NoStatStreamImpl_Write(
 811                   IStream*     iface,
 812                   const void*    pv,          /* [size_is][in] */
 813                   ULONG          cb,          /* [in] */
 814                   ULONG*         pcbWritten)  /* [out] */
 815 {
 816   NoStatStreamImpl* const This=(NoStatStreamImpl*)iface;
 817   void*          supportBuffer;
 818   ULARGE_INTEGER newSize;
 819   ULONG          bytesWritten = 0;
 820
 821   if (pcbWritten == 0)
 822     pcbWritten = &bytesWritten;
 823   if (cb == 0)
 824     return S_OK;
 825   newSize.u.HighPart = 0;
 826   newSize.u.LowPart = This->currentPosition.u.LowPart + cb;
 827   if (newSize.u.LowPart > This->streamSize.u.LowPart)
 828    IStream_SetSize(iface, newSize);
 829
 830   supportBuffer = GlobalLock(This->supportHandle);
 831   memcpy((char *) supportBuffer+This->currentPosition.u.LowPart, pv, cb);
 832   This->currentPosition.u.LowPart+=cb;
 833   *pcbWritten = cb;
 834   GlobalUnlock(This->supportHandle);
 835   return S_OK;
 836 }
 837
 838 static HRESULT WINAPI NoStatStreamImpl_Seek(
 839                   IStream*      iface,
 840                   LARGE_INTEGER   dlibMove,         /* [in] */
 841                   DWORD           dwOrigin,         /* [in] */
 842                   ULARGE_INTEGER* plibNewPosition) /* [out] */
 843 {
 844   NoStatStreamImpl* const This=(NoStatStreamImpl*)iface;
 845   ULARGE_INTEGER newPosition;
 846   switch (dwOrigin)
 847   {
 848     case STREAM_SEEK_SET:
 849       newPosition.u.HighPart = 0;
 850       newPosition.u.LowPart = 0;
 851       break;
 852     case STREAM_SEEK_CUR:
 853       newPosition = This->currentPosition;
 854       break;
 855     case STREAM_SEEK_END:
 856       newPosition = This->streamSize;
 857       break;
 858     default:
 859       return STG_E_INVALIDFUNCTION;
 860   }
 861   if (dlibMove.QuadPart < 0 && newPosition.QuadPart < -dlibMove.QuadPart)
 862       return STG_E_INVALIDFUNCTION;
 863   newPosition.QuadPart += dlibMove.QuadPart;
 864   if (plibNewPosition) *plibNewPosition = newPosition;
 865   This->currentPosition = newPosition;
 866   return S_OK;
 867 }
 868
 869 static HRESULT WINAPI NoStatStreamImpl_SetSize(
 870                                      IStream*      iface,
 871                                      ULARGE_INTEGER  libNewSize)   /* [in] */
 872 {
 873   NoStatStreamImpl* const This=(NoStatStreamImpl*)iface;
 874   HGLOBAL supportHandle;
 875   if (libNewSize.u.HighPart != 0)
 876     return STG_E_INVALIDFUNCTION;
 877   if (This->streamSize.u.LowPart == libNewSize.u.LowPart)
 878     return S_OK;
 879   supportHandle = GlobalReAlloc(This->supportHandle, libNewSize.u.LowPart, 0);
 880   if (supportHandle == 0)
 881     return STG_E_MEDIUMFULL;
 882   This->supportHandle = supportHandle;
 883   This->streamSize.u.LowPart = libNewSize.u.LowPart;
 884   return S_OK;
 885 }
 886
 887 static HRESULT WINAPI NoStatStreamImpl_CopyTo(
 888                                     IStream*      iface,
 889                                     IStream*      pstm,         /* [unique][in] */
 890                                     ULARGE_INTEGER  cb,           /* [in] */
 891                                     ULARGE_INTEGER* pcbRead,      /* [out] */
 892                                     ULARGE_INTEGER* pcbWritten)   /* [out] */
 893 {
 894   HRESULT        hr = S_OK;
 895   BYTE           tmpBuffer[128];
 896   ULONG          bytesRead, bytesWritten, copySize;
 897   ULARGE_INTEGER totalBytesRead;
 898   ULARGE_INTEGER totalBytesWritten;
 899
 900   if ( pstm == 0 )
 901     return STG_E_INVALIDPOINTER;
 902   totalBytesRead.u.LowPart = totalBytesRead.u.HighPart = 0;
 903   totalBytesWritten.u.LowPart = totalBytesWritten.u.HighPart = 0;
 904
 905   while ( cb.u.LowPart > 0 )
 906   {
 907     if ( cb.u.LowPart >= 128 )
 908       copySize = 128;
 909     else
 910       copySize = cb.u.LowPart;
 911     IStream_Read(iface, tmpBuffer, copySize, &bytesRead);
 912     totalBytesRead.u.LowPart += bytesRead;
 913     IStream_Write(pstm, tmpBuffer, bytesRead, &bytesWritten);
 914     totalBytesWritten.u.LowPart += bytesWritten;
 915     if (bytesRead != bytesWritten)
 916     {
 917       hr = STG_E_MEDIUMFULL;
 918       break;
 919     }
 920     if (bytesRead!=copySize)
 921       cb.u.LowPart = 0;
 922     else
 923       cb.u.LowPart -= bytesRead;
 924   }
 925   if (pcbRead)
 926   {
 927     pcbRead->u.LowPart = totalBytesRead.u.LowPart;
 928     pcbRead->u.HighPart = totalBytesRead.u.HighPart;
 929   }
 930
 931   if (pcbWritten)
 932   {
 933     pcbWritten->u.LowPart = totalBytesWritten.u.LowPart;
 934     pcbWritten->u.HighPart = totalBytesWritten.u.HighPart;
 935   }
 936   return hr;
 937 }
 938
 939 static HRESULT WINAPI NoStatStreamImpl_Commit(IStream* iface,DWORD grfCommitFlags)
 940 {
 941   return S_OK;
 942 }
 943 static HRESULT WINAPI NoStatStreamImpl_Revert(IStream* iface) { return S_OK; }
 944
 945 static HRESULT WINAPI NoStatStreamImpl_LockRegion(
 946                   IStream*       iface,
 947                   ULARGE_INTEGER libOffset,   /* [in] */
 948                   ULARGE_INTEGER cb,          /* [in] */
 949                   DWORD          dwLockType)  /* [in] */
 950 {
 951   return S_OK;
 952 }
 953
 954 static HRESULT WINAPI NoStatStreamImpl_UnlockRegion(
 955                   IStream*       iface,
 956                   ULARGE_INTEGER libOffset,   /* [in] */
 957                   ULARGE_INTEGER cb,          /* [in] */
 958                   DWORD          dwLockType)  /* [in] */
 959 {
 960   return S_OK;
 961 }
 962
 963 static HRESULT WINAPI NoStatStreamImpl_Stat(
 964                   IStream*     iface,
 965                   STATSTG*     pstatstg,     /* [out] */
 966                   DWORD        grfStatFlag)  /* [in] */
 967 {
 968   return E_NOTIMPL;
 969 }
 970
 971 static HRESULT WINAPI NoStatStreamImpl_Clone(
 972                   IStream*     iface,
 973                   IStream**    ppstm) /* [out] */
 974 {
 975   return E_NOTIMPL;
 976 }
 977 static const IStreamVtbl NoStatStreamImpl_Vtbl;
 978
 979 /*
 980     Build an object that implements IStream, without IStream_Stat capabilities.
 981     Receives a memory handle with data buffer. If memory handle is non-null,
 982     it is assumed to be unlocked, otherwise an internal memory handle is allocated.
 983     In any case the object takes ownership of memory handle and will free it on
 984     object release.
 985  */
 986 static NoStatStreamImpl* NoStatStreamImpl_Construct(HGLOBAL hGlobal)
 987 {
 988   NoStatStreamImpl* newStream;
 989
 990   newStream = HeapAlloc(GetProcessHeap(), 0, sizeof(NoStatStreamImpl));
 991   if (newStream!=0)
 992   {
 993     newStream->lpVtbl = &NoStatStreamImpl_Vtbl;
 994     newStream->ref    = 1;
 995     newStream->supportHandle = hGlobal;
 996
 997     if (!newStream->supportHandle)
 998       newStream->supportHandle = GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD |
 999                                              GMEM_SHARE, 0);
1000     newStream->currentPosition.u.HighPart = 0;
1001     newStream->currentPosition.u.LowPart = 0;
1002     newStream->streamSize.u.HighPart = 0;
1003     newStream->streamSize.u.LowPart  = GlobalSize(newStream->supportHandle);
1004   }
1005   return newStream;
1006 }
1007
1008
1009 static const IStreamVtbl NoStatStreamImpl_Vtbl =
1010 {
1011     NoStatStreamImpl_QueryInterface,
1012     NoStatStreamImpl_AddRef,
1013     NoStatStreamImpl_Release,
1014     NoStatStreamImpl_Read,
1015     NoStatStreamImpl_Write,
1016     NoStatStreamImpl_Seek,
1017     NoStatStreamImpl_SetSize,
1018     NoStatStreamImpl_CopyTo,
1019     NoStatStreamImpl_Commit,
1020     NoStatStreamImpl_Revert,
1021     NoStatStreamImpl_LockRegion,
1022     NoStatStreamImpl_UnlockRegion,
1023     NoStatStreamImpl_Stat,
1024     NoStatStreamImpl_Clone
1025 };