olepicture.c File Reference

#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include "winerror.h"
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "ole2.h"
#include "olectl.h"
#include "oleauto.h"
#include "connpt.h"
#include "urlmon.h"
#include "initguid.h"
#include "wincodec.h"
#include "wine/debug.h"
#include "pshpack1.h"
#include "poppack.h"

Include dependency graph for olepicture.c:

Go to the source code of this file.

Classes
struct	_APM_HEADER
struct	CURSORICONFILEDIRENTRY
struct	CURSORICONFILEDIR
struct	OLEPictureImpl
struct	IClassFactoryImpl

Macros
#define	COBJMACROS
#define	NONAMELESSUNION
#define	BITMAP_FORMAT_BMP   0x4d42 /* "BM" */
#define	BITMAP_FORMAT_JPEG   0xd8ff
#define	BITMAP_FORMAT_GIF   0x4947
#define	BITMAP_FORMAT_PNG   0x5089
#define	BITMAP_FORMAT_APM   0xcdd7

Typedefs
typedef struct _APM_HEADER	APM_HEADER
typedef struct OLEPictureImpl	OLEPictureImpl

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (olepicture)
static OLEPictureImpl *	impl_from_IPicture (IPicture *iface)
static OLEPictureImpl *	impl_from_IDispatch (IDispatch *iface)
static OLEPictureImpl *	impl_from_IPersistStream (IPersistStream *iface)
static OLEPictureImpl *	impl_from_IConnectionPointContainer (IConnectionPointContainer *iface)
static OLE_XSIZE_HIMETRIC	xpixels_to_himetric (INT pixels, HDC hdc)
static OLE_YSIZE_HIMETRIC	ypixels_to_himetric (INT pixels, HDC hdc)
static void	OLEPictureImpl_SetBitmap (OLEPictureImpl *This)
static void	OLEPictureImpl_SetIcon (OLEPictureImpl *This)
static void	OLEPictureImpl_SetEMF (OLEPictureImpl *This)
static HRESULT	OLEPictureImpl_Construct (LPPICTDESC pictDesc, BOOL fOwn, OLEPictureImpl **pict)
static void	OLEPictureImpl_Destroy (OLEPictureImpl *Obj)
static ULONG WINAPI	OLEPictureImpl_AddRef (IPicture *iface)
static ULONG WINAPI	OLEPictureImpl_Release (IPicture *iface)
static HRESULT WINAPI	OLEPictureImpl_QueryInterface (IPicture *iface, REFIID riid, void **ppvObject)
static void	OLEPicture_SendNotify (OLEPictureImpl *this, DISPID dispID)
static HRESULT WINAPI	OLEPictureImpl_get_Handle (IPicture *iface, OLE_HANDLE *phandle)
static HRESULT WINAPI	OLEPictureImpl_get_hPal (IPicture *iface, OLE_HANDLE *phandle)
static HRESULT WINAPI	OLEPictureImpl_get_Type (IPicture *iface, short *ptype)
static HRESULT WINAPI	OLEPictureImpl_get_Width (IPicture *iface, OLE_XSIZE_HIMETRIC *pwidth)
static HRESULT WINAPI	OLEPictureImpl_get_Height (IPicture *iface, OLE_YSIZE_HIMETRIC *pheight)
static void	render_masked_bitmap (OLEPictureImpl *This, 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, HBITMAP hbmMask, HBITMAP hbmXor)
static HRESULT WINAPI	OLEPictureImpl_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, LPCRECT prcWBounds)
static HRESULT WINAPI	OLEPictureImpl_set_hPal (IPicture *iface, OLE_HANDLE hpal)
static HRESULT WINAPI	OLEPictureImpl_get_CurDC (IPicture *iface, HDC *phdc)
static HRESULT WINAPI	OLEPictureImpl_SelectPicture (IPicture *iface, HDC hdcIn, HDC *phdcOut, OLE_HANDLE *phbmpOut)
static HRESULT WINAPI	OLEPictureImpl_get_KeepOriginalFormat (IPicture *iface, BOOL *pfKeep)
static HRESULT WINAPI	OLEPictureImpl_put_KeepOriginalFormat (IPicture *iface, BOOL keep)
static HRESULT WINAPI	OLEPictureImpl_PictureChanged (IPicture *iface)
static HRESULT WINAPI	OLEPictureImpl_get_Attributes (IPicture *iface, DWORD *pdwAttr)
static HRESULT WINAPI	OLEPictureImpl_IConnectionPointContainer_QueryInterface (IConnectionPointContainer *iface, REFIID riid, VOID **ppvoid)
static ULONG WINAPI	OLEPictureImpl_IConnectionPointContainer_AddRef (IConnectionPointContainer *iface)
static ULONG WINAPI	OLEPictureImpl_IConnectionPointContainer_Release (IConnectionPointContainer *iface)
static HRESULT WINAPI	OLEPictureImpl_EnumConnectionPoints (IConnectionPointContainer *iface, IEnumConnectionPoints **ppEnum)
static HRESULT WINAPI	OLEPictureImpl_FindConnectionPoint (IConnectionPointContainer *iface, REFIID riid, IConnectionPoint **ppCP)
static HRESULT WINAPI	OLEPictureImpl_IPersistStream_QueryInterface (IPersistStream *iface, REFIID riid, VOID **ppvoid)
static ULONG WINAPI	OLEPictureImpl_IPersistStream_AddRef (IPersistStream *iface)
static ULONG WINAPI	OLEPictureImpl_IPersistStream_Release (IPersistStream *iface)
static HRESULT WINAPI	OLEPictureImpl_GetClassID (IPersistStream *iface, CLSID *pClassID)
static HRESULT WINAPI	OLEPictureImpl_IsDirty (IPersistStream *iface)
static HRESULT	OLEPictureImpl_LoadWICSource (OLEPictureImpl *This, IWICBitmapSource *src)
static HRESULT	OLEPictureImpl_LoadWICDecoder (OLEPictureImpl *This, REFCLSID decoder_clsid, BYTE *xbuf, ULONG xread)
static HRESULT	OLEPictureImpl_LoadIcon (OLEPictureImpl *This, BYTE *xbuf, ULONG xread)
static HRESULT	OLEPictureImpl_LoadEnhMetafile (OLEPictureImpl *This, const BYTE *data, ULONG size)
static HRESULT	OLEPictureImpl_LoadAPM (OLEPictureImpl *This, const BYTE *data, ULONG size)
static HRESULT WINAPI	OLEPictureImpl_Load (IPersistStream *iface, IStream *pStm)
static BOOL	serializeBMP (HBITMAP hBitmap, void **ppBuffer, unsigned int *pLength)
static BOOL	serializeIcon (HICON hIcon, void **ppBuffer, unsigned int *pLength)
static BOOL	serializeEMF (HENHMETAFILE hemf, void **buf, unsigned *size)
static HRESULT WINAPI	OLEPictureImpl_Save (IPersistStream *iface, IStream *pStm, BOOL fClearDirty)
static HRESULT WINAPI	OLEPictureImpl_GetSizeMax (IPersistStream *iface, ULARGE_INTEGER *pcbSize)
static HRESULT WINAPI	OLEPictureImpl_SaveAsFile (IPicture *iface, IStream *stream, BOOL mem_copy, LONG *size)
static HRESULT WINAPI	OLEPictureImpl_IDispatch_QueryInterface (IDispatch *iface, REFIID riid, VOID **ppvoid)
static ULONG WINAPI	OLEPictureImpl_IDispatch_AddRef (IDispatch *iface)
static ULONG WINAPI	OLEPictureImpl_IDispatch_Release (IDispatch *iface)
static HRESULT WINAPI	OLEPictureImpl_GetTypeInfoCount (IDispatch *iface, unsigned int *pctinfo)
static HRESULT WINAPI	OLEPictureImpl_GetTypeInfo (IDispatch *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	OLEPictureImpl_GetIDsOfNames (IDispatch *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	OLEPictureImpl_Invoke (IDispatch *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExepInfo, UINT *puArgErr)
HRESULT WINAPI	OleCreatePictureIndirect (LPPICTDESC lpPictDesc, REFIID riid, BOOL Own, void **ppvObj)
HRESULT WINAPI	OleLoadPicture (LPSTREAM lpstream, LONG lSize, BOOL fRunmode, REFIID riid, LPVOID *ppvObj)
HRESULT WINAPI	OleLoadPictureEx (LPSTREAM lpstream, LONG lSize, BOOL fRunmode, REFIID riid, DWORD xsiz, DWORD ysiz, DWORD flags, LPVOID *ppvObj)
static HRESULT	create_stream (const WCHAR *filename, IStream **stream)
HRESULT WINAPI	OleLoadPictureFile (VARIANT filename, IDispatch **picture)
HRESULT WINAPI	OleSavePictureFile (IDispatch *picture, BSTR filename)
HRESULT WINAPI	OleLoadPicturePath (LPOLESTR szURLorPath, LPUNKNOWN punkCaller, DWORD dwReserved, OLE_COLOR clrReserved, REFIID riid, LPVOID *ppvRet)
static IClassFactoryImpl *	impl_from_IClassFactory (IClassFactory *iface)
static HRESULT WINAPI	SPCF_QueryInterface (LPCLASSFACTORY iface, REFIID riid, LPVOID *ppobj)
static ULONG WINAPI	SPCF_AddRef (LPCLASSFACTORY iface)
static ULONG WINAPI	SPCF_Release (LPCLASSFACTORY iface)
static HRESULT WINAPI	SPCF_CreateInstance (LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj)
static HRESULT WINAPI	SPCF_LockServer (LPCLASSFACTORY iface, BOOL dolock)
void	_get_STDPIC_CF (LPVOID *ppv)

Variables
static const IPictureVtbl	OLEPictureImpl_VTable
static const IDispatchVtbl	OLEPictureImpl_IDispatch_VTable
static const IPersistStreamVtbl	OLEPictureImpl_IPersistStream_VTable
static const IConnectionPointContainerVtbl	OLEPictureImpl_IConnectionPointContainer_VTable
static const IClassFactoryVtbl	SPCF_Vtbl
static IClassFactoryImpl	STDPIC_CF = {{&SPCF_Vtbl}, 1 }

Macro Definition Documentation

BITMAP_FORMAT_APM

#define BITMAP_FORMAT_APM   0xcdd7

Definition at line 66 of file olepicture.c.

BITMAP_FORMAT_BMP

#define BITMAP_FORMAT_BMP   0x4d42 /* "BM" */

Definition at line 62 of file olepicture.c.

BITMAP_FORMAT_GIF

#define BITMAP_FORMAT_GIF   0x4947

Definition at line 64 of file olepicture.c.

BITMAP_FORMAT_JPEG

#define BITMAP_FORMAT_JPEG   0xd8ff

Definition at line 63 of file olepicture.c.

BITMAP_FORMAT_PNG

#define BITMAP_FORMAT_PNG   0x5089

Definition at line 65 of file olepicture.c.

COBJMACROS

#define COBJMACROS

Definition at line 43 of file olepicture.c.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 44 of file olepicture.c.

Typedef Documentation

APM_HEADER

typedef struct _APM_HEADER APM_HEADER

OLEPictureImpl

typedef struct OLEPictureImpl OLEPictureImpl

Function Documentation

_get_STDPIC_CF()

void _get_STDPIC_CF

(

LPVOID *

ppv

)

Definition at line 2618 of file olepicture.c.

{ *ppv = &STDPIC_CF; }

Referenced by DllGetClassObject().

create_stream()

static HRESULT create_stream ( const WCHAR *  filename, IStream **  stream  )

static

Definition at line 2419 of file olepicture.c.

{
    HANDLE hFile;
    DWORD dwFileSize;
    HGLOBAL hGlobal = NULL;
    DWORD dwBytesRead;
    HRESULT hr = S_OK;
 
    hFile = CreateFileW(filename, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
    if (hFile == INVALID_HANDLE_VALUE)
        return HRESULT_FROM_WIN32(GetLastError());
 
    dwFileSize = GetFileSize(hFile, NULL);
    if (dwFileSize != INVALID_FILE_SIZE)
    {
        hGlobal = GlobalAlloc(GMEM_FIXED, dwFileSize);
        if (!hGlobal)
            hr = E_OUTOFMEMORY;
        else
        {
            if (!ReadFile(hFile, hGlobal, dwFileSize, &dwBytesRead, NULL))
            {
                GlobalFree(hGlobal);
                hr = HRESULT_FROM_WIN32(GetLastError());
            }
        }
    }
 
    CloseHandle(hFile);
 
    if (FAILED(hr)) return hr;
 
    hr = CreateStreamOnHGlobal(hGlobal, TRUE, stream);
    if (FAILED(hr))
        GlobalFree(hGlobal);
 
    return hr;
}

Referenced by OleLoadPictureFile(), and OleLoadPicturePath().

impl_from_IClassFactory()

static IClassFactoryImpl * impl_from_IClassFactory ( IClassFactory *  iface )

inlinestatic

Definition at line 2570 of file olepicture.c.

{
       return CONTAINING_RECORD(iface, IClassFactoryImpl, IClassFactory_iface);
}

Referenced by SPCF_AddRef(), SPCF_LockServer(), SPCF_QueryInterface(), and SPCF_Release().

impl_from_IConnectionPointContainer()

static OLEPictureImpl * impl_from_IConnectionPointContainer ( IConnectionPointContainer *  iface )

inlinestatic

Definition at line 171 of file olepicture.c.

{
    return CONTAINING_RECORD(iface, OLEPictureImpl, IConnectionPointContainer_iface);
}

Referenced by OLEPictureImpl_EnumConnectionPoints(), OLEPictureImpl_FindConnectionPoint(), OLEPictureImpl_IConnectionPointContainer_AddRef(), OLEPictureImpl_IConnectionPointContainer_QueryInterface(), and OLEPictureImpl_IConnectionPointContainer_Release().

impl_from_IDispatch()

static OLEPictureImpl * impl_from_IDispatch ( IDispatch *  iface )

inlinestatic

Definition at line 161 of file olepicture.c.

{
    return CONTAINING_RECORD(iface, OLEPictureImpl, IDispatch_iface);
}

Referenced by OLEPictureImpl_IDispatch_AddRef(), OLEPictureImpl_IDispatch_QueryInterface(), OLEPictureImpl_IDispatch_Release(), and OLEPictureImpl_Invoke().

impl_from_IPersistStream()

static OLEPictureImpl * impl_from_IPersistStream ( IPersistStream *  iface )

inlinestatic

Definition at line 166 of file olepicture.c.

{
    return CONTAINING_RECORD(iface, OLEPictureImpl, IPersistStream_iface);
}

Referenced by OLEPictureImpl_GetSizeMax(), OLEPictureImpl_IPersistStream_AddRef(), OLEPictureImpl_IPersistStream_QueryInterface(), OLEPictureImpl_IPersistStream_Release(), OLEPictureImpl_IsDirty(), OLEPictureImpl_Load(), and OLEPictureImpl_Save().

impl_from_IPicture()

static OLEPictureImpl * impl_from_IPicture ( IPicture *  iface )

inlinestatic

Definition at line 156 of file olepicture.c.

{
    return CONTAINING_RECORD(iface, OLEPictureImpl, IPicture_iface);
}

Referenced by OLEPictureImpl_AddRef(), OLEPictureImpl_get_Attributes(), OLEPictureImpl_get_CurDC(), OLEPictureImpl_get_Handle(), OLEPictureImpl_get_Height(), OLEPictureImpl_get_hPal(), OLEPictureImpl_get_KeepOriginalFormat(), OLEPictureImpl_get_Type(), OLEPictureImpl_get_Width(), OLEPictureImpl_PictureChanged(), OLEPictureImpl_put_KeepOriginalFormat(), OLEPictureImpl_QueryInterface(), OLEPictureImpl_Release(), OLEPictureImpl_Render(), OLEPictureImpl_SaveAsFile(), OLEPictureImpl_SelectPicture(), and OLEPictureImpl_set_hPal().

OleCreatePictureIndirect()

HRESULT WINAPI OleCreatePictureIndirect	(	LPPICTDESC	lpPictDesc,
		REFIID	riid,
		BOOL	Own,
		void **	ppvObj
	)

Definition at line 2313 of file olepicture.c.

{
  OLEPictureImpl* newPict;
  HRESULT hr;
 
  TRACE("(%p,%s,%d,%p)\n", lpPictDesc, debugstr_guid(riid), Own, ppvObj);
 
  *ppvObj = NULL;
 
  hr = OLEPictureImpl_Construct(lpPictDesc, Own, &newPict);
  if (hr != S_OK) return hr;
 
  /*
   * Make sure it supports the interface required by the caller.
   */
  hr = IPicture_QueryInterface(&newPict->IPicture_iface, riid, ppvObj);
 
  /*
   * Release the reference obtained in the constructor. If
   * the QueryInterface was unsuccessful, it will free the class.
   */
  IPicture_Release(&newPict->IPicture_iface);
 
  return hr;
}

Referenced by create_picture(), OleLoadPicture(), OleLoadPictureEx(), SPCF_CreateInstance(), test_get_Attributes(), test_get_Handle(), test_get_Type(), test_himetric(), test_load_save_bmp(), test_load_save_emf(), test_load_save_empty_picture(), test_load_save_icon(), test_OleCreatePictureIndirect(), and test_Render().

OleLoadPicture()

HRESULT WINAPI OleLoadPicture	(	LPSTREAM	lpstream,
		LONG	lSize,
		BOOL	fRunmode,
		REFIID	riid,
		LPVOID *	ppvObj
	)

Definition at line 2344 of file olepicture.c.

{
  LPPERSISTSTREAM ps;
  IPicture  *newpic;
  HRESULT hr;
 
  TRACE("(%p,%d,%d,%s,%p), partially implemented.\n",
    lpstream, lSize, fRunmode, debugstr_guid(riid), ppvObj);
 
  hr = OleCreatePictureIndirect(NULL,riid,!fRunmode,(LPVOID*)&newpic);
  if (hr != S_OK)
    return hr;
  hr = IPicture_QueryInterface(newpic,&IID_IPersistStream, (LPVOID*)&ps);
  if (hr != S_OK) {
      ERR("Could not get IPersistStream iface from Ole Picture?\n");
      IPicture_Release(newpic);
      *ppvObj = NULL;
      return hr;
  }
  hr = IPersistStream_Load(ps,lpstream);
  IPersistStream_Release(ps);
  if (FAILED(hr))
  {
      ERR("IPersistStream_Load failed\n");
      IPicture_Release(newpic);
      *ppvObj = NULL;
      return hr;
  }
  hr = IPicture_QueryInterface(newpic,riid,ppvObj);
  if (hr != S_OK)
      ERR("Failed to get interface %s from IPicture.\n",debugstr_guid(riid));
  IPicture_Release(newpic);
  return hr;
}

Referenced by DoLoadPicture(), load_picture(), OleLoadPictureFile(), and OleLoadPicturePath().

OleLoadPictureEx()

HRESULT WINAPI OleLoadPictureEx	(	LPSTREAM	lpstream,
		LONG	lSize,
		BOOL	fRunmode,
		REFIID	riid,
		DWORD	xsiz,
		DWORD	ysiz,
		DWORD	flags,
		LPVOID *	ppvObj
	)

Definition at line 2383 of file olepicture.c.

{
  LPPERSISTSTREAM ps;
  IPicture  *newpic;
  HRESULT hr;
 
  FIXME("(%p,%d,%d,%s,x=%d,y=%d,f=%x,%p), partially implemented.\n",
    lpstream, lSize, fRunmode, debugstr_guid(riid), xsiz, ysiz, flags, ppvObj);
 
  hr = OleCreatePictureIndirect(NULL,riid,!fRunmode,(LPVOID*)&newpic);
  if (hr != S_OK)
    return hr;
  hr = IPicture_QueryInterface(newpic,&IID_IPersistStream, (LPVOID*)&ps);
  if (hr != S_OK) {
      ERR("Could not get IPersistStream iface from Ole Picture?\n");
      IPicture_Release(newpic);
      *ppvObj = NULL;
      return hr;
  }
  hr = IPersistStream_Load(ps,lpstream);
  IPersistStream_Release(ps);
  if (FAILED(hr))
  {
      ERR("IPersistStream_Load failed\n");
      IPicture_Release(newpic);
      *ppvObj = NULL;
      return hr;
  }
  hr = IPicture_QueryInterface(newpic,riid,ppvObj);
  if (hr != S_OK)
      ERR("Failed to get interface %s from IPicture.\n",debugstr_guid(riid));
  IPicture_Release(newpic);
  return hr;
}

OleLoadPictureFile()

HRESULT WINAPI OleLoadPictureFile	(	VARIANT	filename,
		IDispatch **	picture
	)

Definition at line 2461 of file olepicture.c.

{
    IStream *stream;
    HRESULT hr;
 
    TRACE("(%s,%p)\n", wine_dbgstr_variant(&filename), picture);
 
    if (V_VT(&filename) != VT_BSTR)
        return CTL_E_FILENOTFOUND;
 
    hr = create_stream(V_BSTR(&filename), &stream);
    if (hr != S_OK)
    {
        if (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
            return CTL_E_FILENOTFOUND;
 
        return CTL_E_PATHFILEACCESSERROR;
    }
 
    hr = OleLoadPicture(stream, 0, FALSE, &IID_IDispatch, (void **)picture);
    IStream_Release(stream);
    return hr;
}

Referenced by test_OleLoadPicturePath().

OleLoadPicturePath()

HRESULT WINAPI OleLoadPicturePath	(	LPOLESTR	szURLorPath,
		LPUNKNOWN	punkCaller,
		DWORD	dwReserved,
		OLE_COLOR	clrReserved,
		REFIID	riid,
		LPVOID *	ppvRet
	)

Definition at line 2497 of file olepicture.c.

{
  static const WCHAR file[] = { 'f','i','l','e',':',0 };
  IStream *stream;
  HRESULT hRes;
  WCHAR *file_candidate;
  WCHAR path_buf[MAX_PATH];
 
  TRACE("(%s,%p,%d,%08x,%s,%p): stub\n",
        debugstr_w(szURLorPath), punkCaller, dwReserved, clrReserved,
        debugstr_guid(riid), ppvRet);
 
  if (!szURLorPath || !ppvRet)
      return E_INVALIDARG;
 
  *ppvRet = NULL;
 
  /* Convert file URLs to DOS paths. */
  if (wcsncmp(szURLorPath, file, 5) == 0) {
      DWORD size;
      hRes = CoInternetParseUrl(szURLorPath, PARSE_PATH_FROM_URL, 0, path_buf,
                                ARRAY_SIZE(path_buf), &size, 0);
      if (FAILED(hRes))
          return hRes;
 
      file_candidate = path_buf;
  }
  else
      file_candidate = szURLorPath;
 
  /* Handle candidate DOS paths separately. */
  if (file_candidate[1] == ':') {
      hRes = create_stream(file_candidate, &stream);
      if (FAILED(hRes))
      return INET_E_RESOURCE_NOT_FOUND;
  } else {
      IMoniker *pmnk;
      IBindCtx *pbc;
 
      hRes = CreateBindCtx(0, &pbc);
      if (SUCCEEDED(hRes)) 
      {
      hRes = CreateURLMoniker(NULL, szURLorPath, &pmnk);
      if (SUCCEEDED(hRes))
      {          
          hRes = IMoniker_BindToStorage(pmnk, pbc, NULL, &IID_IStream, (LPVOID*)&stream);
          IMoniker_Release(pmnk);
      }
      IBindCtx_Release(pbc);
      }
      if (FAILED(hRes))
      return hRes;
  }
 
  hRes = OleLoadPicture(stream, 0, FALSE, riid, ppvRet);
 
  IStream_Release(stream);
 
  return hRes;
}

Referenced by test_OleLoadPicturePath().

OLEPicture_SendNotify()

static void OLEPicture_SendNotify ( OLEPictureImpl *  this, DISPID  dispID  )

static

Definition at line 500 of file olepicture.c.

{
  IEnumConnections *pEnum;
  CONNECTDATA CD;
 
  if (IConnectionPoint_EnumConnections(this->pCP, &pEnum) != S_OK)
      return;
  while(IEnumConnections_Next(pEnum, 1, &CD, NULL) == S_OK) {
    IPropertyNotifySink *sink;
 
    IUnknown_QueryInterface(CD.pUnk, &IID_IPropertyNotifySink, (LPVOID)&sink);
    IPropertyNotifySink_OnChanged(sink, dispID);
    IPropertyNotifySink_Release(sink);
    IUnknown_Release(CD.pUnk);
  }
  IEnumConnections_Release(pEnum);
}

Referenced by OLEPictureImpl_Load(), OLEPictureImpl_PictureChanged(), and OLEPictureImpl_set_hPal().

OLEPictureImpl_AddRef()

static ULONG WINAPI OLEPictureImpl_AddRef ( IPicture *  iface )

static

Definition at line 421 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IPicture(iface);
  ULONG refCount = InterlockedIncrement(&This->ref);
 
  TRACE("(%p)->(ref before=%d)\n", This, refCount - 1);
 
  return refCount;
}

OLEPictureImpl_Construct()

static HRESULT OLEPictureImpl_Construct ( LPPICTDESC  pictDesc, BOOL  fOwn, OLEPictureImpl **  pict  )

static

Definition at line 282 of file olepicture.c.

{
  OLEPictureImpl *newObject;
  HRESULT hr;
 
  if (pictDesc)
      TRACE("(%p) type = %d\n", pictDesc, pictDesc->picType);
 
  /*
   * Allocate space for the object.
   */
  newObject = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(OLEPictureImpl));
  if (!newObject)
    return E_OUTOFMEMORY;
 
  /*
   * Initialize the virtual function table.
   */
  newObject->IPicture_iface.lpVtbl = &OLEPictureImpl_VTable;
  newObject->IDispatch_iface.lpVtbl = &OLEPictureImpl_IDispatch_VTable;
  newObject->IPersistStream_iface.lpVtbl = &OLEPictureImpl_IPersistStream_VTable;
  newObject->IConnectionPointContainer_iface.lpVtbl = &OLEPictureImpl_IConnectionPointContainer_VTable;
 
  newObject->pCP = NULL;
  hr = CreateConnectionPoint((IUnknown*)&newObject->IPicture_iface, &IID_IPropertyNotifySink,
                        &newObject->pCP);
  if (hr != S_OK)
  {
    HeapFree(GetProcessHeap(), 0, newObject);
    return hr;
  }
 
  /*
   * Start with one reference count. The caller of this function
   * must release the interface pointer when it is done.
   */
  newObject->ref    = 1;
  newObject->hDCCur = 0;
 
  newObject->fOwn   = fOwn;
 
  /* dunno about original value */
  newObject->keepOrigFormat = TRUE;
 
  newObject->hbmMask = NULL;
  newObject->hbmXor = NULL;
  newObject->loadtime_magic = 0xdeadbeef;
  newObject->loadtime_format = 0;
  newObject->bIsDirty = FALSE;
 
  if (pictDesc) {
      newObject->desc = *pictDesc;
 
      switch(pictDesc->picType) {
      case PICTYPE_BITMAP:
    OLEPictureImpl_SetBitmap(newObject);
    break;
 
      case PICTYPE_METAFILE:
    TRACE("metafile handle %p\n", pictDesc->u.wmf.hmeta);
    newObject->himetricWidth = pictDesc->u.wmf.xExt;
    newObject->himetricHeight = pictDesc->u.wmf.yExt;
    break;
 
      case PICTYPE_NONE:
    /* not sure what to do here */
    newObject->himetricWidth = newObject->himetricHeight = 0;
    break;
 
      case PICTYPE_ICON:
        OLEPictureImpl_SetIcon(newObject);
        break;
 
      case PICTYPE_ENHMETAFILE:
        OLEPictureImpl_SetEMF(newObject);
        break;
 
      default:
        WARN("Unsupported type %d\n", pictDesc->picType);
        IPicture_Release(&newObject->IPicture_iface);
        return E_UNEXPECTED;
      }
  } else {
      newObject->desc.picType = PICTYPE_UNINITIALIZED;
  }
 
  TRACE("returning %p\n", newObject);
  *pict = newObject;
  return S_OK;
}

Referenced by OleCreatePictureIndirect().

OLEPictureImpl_Destroy()

static void OLEPictureImpl_Destroy ( OLEPictureImpl *  Obj )

static

Definition at line 379 of file olepicture.c.

{
  TRACE("(%p)\n", Obj);
 
  if (Obj->pCP)
    IConnectionPoint_Release(Obj->pCP);
 
  if(Obj->fOwn) { /* We need to destroy the picture */
    switch(Obj->desc.picType) {
    case PICTYPE_BITMAP:
      DeleteObject(Obj->desc.u.bmp.hbitmap);
      if (Obj->hbmMask != NULL) DeleteObject(Obj->hbmMask);
      if (Obj->hbmXor != NULL) DeleteObject(Obj->hbmXor);
      break;
    case PICTYPE_METAFILE:
      DeleteMetaFile(Obj->desc.u.wmf.hmeta);
      break;
    case PICTYPE_ICON:
      DestroyIcon(Obj->desc.u.icon.hicon);
      break;
    case PICTYPE_ENHMETAFILE:
      DeleteEnhMetaFile(Obj->desc.u.emf.hemf);
      break;
    case PICTYPE_NONE:
    case PICTYPE_UNINITIALIZED:
      /* Nothing to do */
      break;
    default:
      FIXME("Unsupported type %d - unable to delete\n", Obj->desc.picType);
      break;
    }
  }
  HeapFree(GetProcessHeap(), 0, Obj->data);
  HeapFree(GetProcessHeap(), 0, Obj);
}

Referenced by OLEPictureImpl_Release().

OLEPictureImpl_EnumConnectionPoints()

static HRESULT WINAPI OLEPictureImpl_EnumConnectionPoints ( IConnectionPointContainer *  iface, IEnumConnectionPoints **  ppEnum  )

static

Definition at line 917 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
 
  FIXME("(%p,%p), stub!\n",This,ppEnum);
  return E_NOTIMPL;
}

OLEPictureImpl_FindConnectionPoint()

static HRESULT WINAPI OLEPictureImpl_FindConnectionPoint ( IConnectionPointContainer *  iface, REFIID  riid, IConnectionPoint **  ppCP  )

static

Definition at line 927 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
  TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppCP);
  if (!ppCP)
      return E_POINTER;
  *ppCP = NULL;
  if (IsEqualGUID(riid,&IID_IPropertyNotifySink))
      return IConnectionPoint_QueryInterface(This->pCP, &IID_IConnectionPoint, (void**)ppCP);
  FIXME("no connection point for %s\n",debugstr_guid(riid));
  return CONNECT_E_NOCONNECTION;
}

OLEPictureImpl_get_Attributes()

static HRESULT WINAPI OLEPictureImpl_get_Attributes ( IPicture *  iface, DWORD *  pdwAttr  )

static

Definition at line 865 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IPicture(iface);
  TRACE("(%p)->(%p).\n", This, pdwAttr);
 
  if(!pdwAttr)
    return E_POINTER;
 
  *pdwAttr = 0;
  switch (This->desc.picType) {
  case PICTYPE_UNINITIALIZED:
  case PICTYPE_NONE: break;
  case PICTYPE_BITMAP:  if (This->hbmMask) *pdwAttr = PICTURE_TRANSPARENT; break;   /* not 'truly' scalable, see MSDN. */
  case PICTYPE_ICON: *pdwAttr     = PICTURE_TRANSPARENT;break;
  case PICTYPE_ENHMETAFILE: /* fall through */
  case PICTYPE_METAFILE: *pdwAttr = PICTURE_TRANSPARENT|PICTURE_SCALABLE;break;
  default:FIXME("Unknown pictype %d\n",This->desc.picType);break;
  }
  return S_OK;
}

OLEPictureImpl_get_CurDC()

static HRESULT WINAPI OLEPictureImpl_get_CurDC ( IPicture *  iface, HDC *  phdc  )

static

Definition at line 789 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IPicture(iface);
  TRACE("(%p), returning %p\n", This, This->hDCCur);
  if (phdc) *phdc = This->hDCCur;
  return S_OK;
}

OLEPictureImpl_get_Handle()

static HRESULT WINAPI OLEPictureImpl_get_Handle ( IPicture *  iface, OLE_HANDLE *  phandle  )

static

Definition at line 521 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IPicture(iface);
  TRACE("(%p)->(%p)\n", This, phandle);
 
  if(!phandle)
    return E_POINTER;
 
  switch(This->desc.picType) {
  case PICTYPE_NONE:
  case PICTYPE_UNINITIALIZED:
    *phandle = 0;
    break;
  case PICTYPE_BITMAP:
    *phandle = HandleToUlong(This->desc.u.bmp.hbitmap);
    break;
  case PICTYPE_METAFILE:
    *phandle = HandleToUlong(This->desc.u.wmf.hmeta);
    break;
  case PICTYPE_ICON:
    *phandle = HandleToUlong(This->desc.u.icon.hicon);
    break;
  case PICTYPE_ENHMETAFILE:
    *phandle = HandleToUlong(This->desc.u.emf.hemf);
    break;
  default:
    FIXME("Unimplemented type %d\n", This->desc.picType);
    return E_NOTIMPL;
  }
  TRACE("returning handle %08x\n", *phandle);
  return S_OK;
}

OLEPictureImpl_get_Height()

static HRESULT WINAPI OLEPictureImpl_get_Height ( IPicture *  iface, OLE_YSIZE_HIMETRIC *  pheight  )

static

Definition at line 607 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IPicture(iface);
  TRACE("(%p)->(%p): height is %d\n", This, pheight, This->himetricHeight);
  *pheight = This->himetricHeight;
  return S_OK;
}

OLEPictureImpl_get_hPal()

static HRESULT WINAPI OLEPictureImpl_get_hPal ( IPicture *  iface, OLE_HANDLE *  phandle  )

static

Definition at line 558 of file olepicture.c.

{
    OLEPictureImpl *This = impl_from_IPicture(iface);
 
    TRACE("(%p)->(%p)\n", This, phandle);
 
    if (!phandle) return E_POINTER;
 
    if (This->desc.picType == PICTYPE_BITMAP)
    {
        *phandle = HandleToUlong(This->desc.u.bmp.hpal);
        return S_OK;
    }
 
    return E_FAIL;
}

OLEPictureImpl_get_KeepOriginalFormat()

static HRESULT WINAPI OLEPictureImpl_get_KeepOriginalFormat ( IPicture *  iface, BOOL *  pfKeep  )

static

Definition at line 826 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IPicture(iface);
  TRACE("(%p)->(%p)\n", This, pfKeep);
  if (!pfKeep)
      return E_POINTER;
  *pfKeep = This->keepOrigFormat;
  return S_OK;
}

OLEPictureImpl_get_Type()

static HRESULT WINAPI OLEPictureImpl_get_Type ( IPicture *  iface, short *  ptype  )

static

Definition at line 579 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IPicture(iface);
  TRACE("(%p)->(%p): type is %d\n", This, ptype, This->desc.picType);
 
  if(!ptype)
    return E_POINTER;
 
  *ptype = This->desc.picType;
  return S_OK;
}

Referenced by OLEPictureImpl_Invoke().

OLEPictureImpl_get_Width()

static HRESULT WINAPI OLEPictureImpl_get_Width ( IPicture *  iface, OLE_XSIZE_HIMETRIC *  pwidth  )

static

Definition at line 595 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IPicture(iface);
  TRACE("(%p)->(%p): width is %d\n", This, pwidth, This->himetricWidth);
  *pwidth = This->himetricWidth;
  return S_OK;
}

OLEPictureImpl_GetClassID()

static HRESULT WINAPI OLEPictureImpl_GetClassID ( IPersistStream *  iface, CLSID *  pClassID  )

static

Definition at line 992 of file olepicture.c.

{
  TRACE("(%p)\n", pClassID);
  *pClassID = CLSID_StdPicture;
  return S_OK;
}

OLEPictureImpl_GetIDsOfNames()

static HRESULT WINAPI OLEPictureImpl_GetIDsOfNames ( IDispatch *  iface, REFIID  riid, LPOLESTR *  rgszNames, UINT  cNames, LCID  lcid, DISPID *  rgDispId  )

static

Definition at line 2066 of file olepicture.c.

{
  ITypeInfo * pTInfo;
  HRESULT hres;
 
  TRACE("(%p,%s,%p,cNames=%d,lcid=%04x,%p)\n", iface, debugstr_guid(riid),
        rgszNames, cNames, (int)lcid, rgDispId);
 
  if (cNames == 0)
  {
    return E_INVALIDARG;
  }
  else
  {
    /* retrieve type information */
    hres = OLEPictureImpl_GetTypeInfo(iface, 0, lcid, &pTInfo);
 
    if (FAILED(hres))
    {
      ERR("GetTypeInfo failed.\n");
      return hres;
    }
 
    /* convert names to DISPIDs */
    hres = DispGetIDsOfNames (pTInfo, rgszNames, cNames, rgDispId);
    ITypeInfo_Release(pTInfo);
 
    return hres;
  }
}

OLEPictureImpl_GetSizeMax()

static HRESULT WINAPI OLEPictureImpl_GetSizeMax ( IPersistStream *  iface, ULARGE_INTEGER *  pcbSize  )

static

Definition at line 1865 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IPersistStream(iface);
  FIXME("(%p,%p),stub!\n",This,pcbSize);
  return E_NOTIMPL;
}

OLEPictureImpl_GetTypeInfo()

static HRESULT WINAPI OLEPictureImpl_GetTypeInfo ( IDispatch *  iface, UINT  iTInfo, LCID  lcid, ITypeInfo **  ppTInfo  )

static

Definition at line 2032 of file olepicture.c.

{
  static const WCHAR stdole2tlb[] = {'s','t','d','o','l','e','2','.','t','l','b',0};
  ITypeLib *tl;
  HRESULT hres;
 
  TRACE("(iTInfo=%d, lcid=%04x, %p)\n", iTInfo, (int)lcid, ppTInfo);
 
  if (iTInfo != 0)
    return E_FAIL;
 
  hres = LoadTypeLib(stdole2tlb, &tl);
  if (FAILED(hres))
  {
    ERR("Could not load stdole2.tlb\n");
    return hres;
  }
 
  hres = ITypeLib_GetTypeInfoOfGuid(tl, &IID_IPictureDisp, ppTInfo);
  if (FAILED(hres))
    ERR("Did not get IPictureDisp typeinfo from typelib, hres %x\n", hres);
 
  return hres;
}

Referenced by OLEPictureImpl_GetIDsOfNames().

OLEPictureImpl_GetTypeInfoCount()

static HRESULT WINAPI OLEPictureImpl_GetTypeInfoCount ( IDispatch *  iface, unsigned int *  pctinfo  )

static

Definition at line 2016 of file olepicture.c.

{
  TRACE("(%p)\n", pctinfo);
 
  *pctinfo = 1;
 
  return S_OK;
}

OLEPictureImpl_IConnectionPointContainer_AddRef()

static ULONG WINAPI OLEPictureImpl_IConnectionPointContainer_AddRef ( IConnectionPointContainer *  iface )

static

Definition at line 901 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
 
  return IPicture_AddRef(&This->IPicture_iface);
}

OLEPictureImpl_IConnectionPointContainer_QueryInterface()

static HRESULT WINAPI OLEPictureImpl_IConnectionPointContainer_QueryInterface ( IConnectionPointContainer *  iface, REFIID  riid, VOID **  ppvoid  )

static

Definition at line 891 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
 
  return IPicture_QueryInterface(&This->IPicture_iface,riid,ppvoid);
}

OLEPictureImpl_IConnectionPointContainer_Release()

static ULONG WINAPI OLEPictureImpl_IConnectionPointContainer_Release ( IConnectionPointContainer *  iface )

static

Definition at line 909 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
 
  return IPicture_Release(&This->IPicture_iface);
}

OLEPictureImpl_IDispatch_AddRef()

static ULONG WINAPI OLEPictureImpl_IDispatch_AddRef ( IDispatch *  iface )

static

Definition at line 1990 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IDispatch(iface);
 
  return IPicture_AddRef(&This->IPicture_iface);
}

OLEPictureImpl_IDispatch_QueryInterface()

static HRESULT WINAPI OLEPictureImpl_IDispatch_QueryInterface ( IDispatch *  iface, REFIID  riid, VOID **  ppvoid  )

static

Definition at line 1975 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IDispatch(iface);
 
  return IPicture_QueryInterface(&This->IPicture_iface, riid, ppvoid);
}

OLEPictureImpl_IDispatch_Release()

static ULONG WINAPI OLEPictureImpl_IDispatch_Release ( IDispatch *  iface )

static

Definition at line 2003 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IDispatch(iface);
 
  return IPicture_Release(&This->IPicture_iface);
}

OLEPictureImpl_Invoke()

static HRESULT WINAPI OLEPictureImpl_Invoke ( IDispatch *  iface, DISPID  dispIdMember, REFIID  riid, LCID  lcid, WORD  wFlags, DISPPARAMS *  pDispParams, VARIANT *  pVarResult, EXCEPINFO *  pExepInfo, UINT *  puArgErr  )

static

Definition at line 2108 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IDispatch(iface);
  HRESULT hr;
 
  /* validate parameters */
 
  if (!IsEqualIID(riid, &IID_NULL))
  {
    ERR("riid was %s instead of IID_NULL\n", debugstr_guid(riid));
    return DISP_E_UNKNOWNNAME;
  }
 
  if (!pDispParams)
  {
    ERR("null pDispParams not allowed\n");
    return DISP_E_PARAMNOTOPTIONAL;
  }
 
  if (wFlags & DISPATCH_PROPERTYGET)
  {
    if (pDispParams->cArgs != 0)
    {
      ERR("param count for DISPATCH_PROPERTYGET was %d instead of 0\n", pDispParams->cArgs);
      return DISP_E_BADPARAMCOUNT;
    }
    if (!pVarResult)
    {
      ERR("null pVarResult not allowed when DISPATCH_PROPERTYGET specified\n");
      return DISP_E_PARAMNOTOPTIONAL;
    }
  }
  else if (wFlags & DISPATCH_PROPERTYPUT)
  {
    if (pDispParams->cArgs != 1)
    {
      ERR("param count for DISPATCH_PROPERTYPUT was %d instead of 1\n", pDispParams->cArgs);
      return DISP_E_BADPARAMCOUNT;
    }
  }
 
  switch (dispIdMember)
  {
  case DISPID_PICT_HANDLE:
    if (wFlags & DISPATCH_PROPERTYGET)
    {
      TRACE("DISPID_PICT_HANDLE\n");
      V_VT(pVarResult) = VT_I4;
      return IPicture_get_Handle(&This->IPicture_iface, &V_UINT(pVarResult));
    }
    break;
  case DISPID_PICT_HPAL:
    if (wFlags & DISPATCH_PROPERTYGET)
    {
      TRACE("DISPID_PICT_HPAL\n");
      V_VT(pVarResult) = VT_I4;
      return IPicture_get_hPal(&This->IPicture_iface, &V_UINT(pVarResult));
    }
    else if (wFlags & DISPATCH_PROPERTYPUT)
    {
      VARIANTARG vararg;
 
      TRACE("DISPID_PICT_HPAL\n");
 
      VariantInit(&vararg);
      hr = VariantChangeTypeEx(&vararg, &pDispParams->rgvarg[0], lcid, 0, VT_I4);
      if (FAILED(hr))
        return hr;
 
      hr = IPicture_set_hPal(&This->IPicture_iface, V_I4(&vararg));
 
      VariantClear(&vararg);
      return hr;
    }
    break;
  case DISPID_PICT_TYPE:
    if (wFlags & DISPATCH_PROPERTYGET)
    {
      TRACE("DISPID_PICT_TYPE\n");
      V_VT(pVarResult) = VT_I2;
      return OLEPictureImpl_get_Type(&This->IPicture_iface, &V_I2(pVarResult));
    }
    break;
  case DISPID_PICT_WIDTH:
    if (wFlags & DISPATCH_PROPERTYGET)
    {
      TRACE("DISPID_PICT_WIDTH\n");
      V_VT(pVarResult) = VT_I4;
      return IPicture_get_Width(&This->IPicture_iface, &V_I4(pVarResult));
    }
    break;
  case DISPID_PICT_HEIGHT:
    if (wFlags & DISPATCH_PROPERTYGET)
    {
      TRACE("DISPID_PICT_HEIGHT\n");
      V_VT(pVarResult) = VT_I4;
      return IPicture_get_Height(&This->IPicture_iface, &V_I4(pVarResult));
    }
    break;
  case DISPID_PICT_RENDER:
    if (wFlags & DISPATCH_METHOD)
    {
      VARIANTARG *args = pDispParams->rgvarg;
      int i;
 
      TRACE("DISPID_PICT_RENDER\n");
 
      if (pDispParams->cArgs != 10)
        return DISP_E_BADPARAMCOUNT;
 
      /* All parameters are supposed to be VT_I4 (on 64 bits too). */
      for (i = 0; i < pDispParams->cArgs; i++)
        if (V_VT(&args[i]) != VT_I4)
        {
          ERR("DISPID_PICT_RENDER: wrong argument type %d:%d\n", i, V_VT(&args[i]));
          return DISP_E_TYPEMISMATCH;
        }
 
      /* FIXME: rectangle pointer argument handling seems broken on 64 bits,
                currently Render() doesn't use it at all so for now NULL is passed. */
      return IPicture_Render(&This->IPicture_iface,
                LongToHandle(V_I4(&args[9])),
                             V_I4(&args[8]),
                             V_I4(&args[7]),
                             V_I4(&args[6]),
                             V_I4(&args[5]),
                             V_I4(&args[4]),
                             V_I4(&args[3]),
                             V_I4(&args[2]),
                             V_I4(&args[1]),
                                      NULL);
    }
    break;
  }
 
  ERR("invalid dispid 0x%x or wFlags 0x%x\n", dispIdMember, wFlags);
  return DISP_E_MEMBERNOTFOUND;
}

OLEPictureImpl_IPersistStream_AddRef()

static ULONG WINAPI OLEPictureImpl_IPersistStream_AddRef ( IPersistStream *  iface )

static

Definition at line 968 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IPersistStream(iface);
 
  return IPicture_AddRef(&This->IPicture_iface);
}

OLEPictureImpl_IPersistStream_QueryInterface()

static HRESULT WINAPI OLEPictureImpl_IPersistStream_QueryInterface ( IPersistStream *  iface, REFIID  riid, VOID **  ppvoid  )

static

Definition at line 953 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IPersistStream(iface);
 
  return IPicture_QueryInterface(&This->IPicture_iface, riid, ppvoid);
}

OLEPictureImpl_IPersistStream_Release()

static ULONG WINAPI OLEPictureImpl_IPersistStream_Release ( IPersistStream *  iface )

static

Definition at line 981 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IPersistStream(iface);
 
  return IPicture_Release(&This->IPicture_iface);
}

OLEPictureImpl_IsDirty()

static HRESULT WINAPI OLEPictureImpl_IsDirty ( IPersistStream *  iface )

static

Definition at line 1003 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IPersistStream(iface);
  FIXME("(%p),stub!\n",This);
  return E_NOTIMPL;
}

OLEPictureImpl_Load()

static HRESULT WINAPI OLEPictureImpl_Load ( IPersistStream *  iface, IStream *  pStm  )

static

Definition at line 1339 of file olepicture.c.

                                                                                {
  HRESULT   hr;
  BOOL      headerisdata;
  BOOL      statfailed = FALSE;
  ULONG     xread, toread;
  ULONG     headerread;
  BYTE      *xbuf;
  DWORD     header[2];
  WORD      magic;
  STATSTG       statstg;
  OLEPictureImpl *This = impl_from_IPersistStream(iface);
  
  TRACE("(%p,%p)\n",This,pStm);
 
  /****************************************************************************************
   * Part 1: Load the data
   */
  /* Sometimes we have a header, sometimes we don't. Apply some guesses to find
   * out whether we do.
   *
   * UPDATE: the IStream can be mapped to a plain file instead of a stream in a
   * compound file. This may explain most, if not all, of the cases of "no
   * header", and the header validation should take this into account.
   * At least in Visual Basic 6, resource streams, valid headers are
   *    header[0] == "lt\0\0",
   *    header[1] == length_of_stream.
   *
   * Also handle streams where we do not have a working "Stat" method by
   * reading all data until the end of the stream.
   */
  hr = IStream_Stat(pStm,&statstg,STATFLAG_NONAME);
  if (hr != S_OK) {
      TRACE("stat failed with hres %x, proceeding to read all data.\n",hr);
      statfailed = TRUE;
      /* we will read at least 8 byte ... just right below */
      statstg.cbSize.QuadPart = 8;
  }
 
  toread = 0;
  headerread = 0;
  headerisdata = FALSE;
  do {
      hr = IStream_Read(pStm, header, 8, &xread);
      if (hr != S_OK || xread!=8) {
          ERR("Failure while reading picture header (hr is %x, nread is %d).\n",hr,xread);
          return (hr?hr:E_FAIL);
      }
      headerread += xread;
      xread = 0;
 
      if (!memcmp(&(header[0]),"lt\0\0", 4) && (statfailed || (header[1] + headerread <= statstg.cbSize.QuadPart))) {
          if (toread != 0 && toread != header[1]) 
              FIXME("varying lengths of image data (prev=%u curr=%u), only last one will be used\n",
                  toread, header[1]);
          toread = header[1];
          if (statfailed)
          {
              statstg.cbSize.QuadPart = header[1] + 8;
              statfailed = FALSE;
          }
          if (toread == 0) break;
      } else {
          if (!memcmp(&(header[0]), "GIF8",     4) ||   /* GIF header */
              !memcmp(&(header[0]), "BM",       2) ||   /* BMP header */
              !memcmp(&(header[0]), "\xff\xd8", 2) ||   /* JPEG header */
              (header[0] == EMR_HEADER)            ||   /* EMF header */
              (header[0] == 0x10000)               ||   /* icon: idReserved 0, idType 1 */
              (header[0] == 0x20000)               ||   /* cursor: idReserved 0, idType 2 */
              (header[1] > statstg.cbSize.QuadPart)||   /* invalid size */
              (header[1]==0)
          ) {/* Found start of bitmap data */
              headerisdata = TRUE;
              if (toread == 0) 
                  toread = statstg.cbSize.QuadPart-8;
              else toread -= 8;
              xread = 8;
          } else {
              FIXME("Unknown stream header magic: %08x\n", header[0]);
              toread = header[1];
          }
      }
  } while (!headerisdata);
 
  if (statfailed) { /* we don't know the size ... read all we get */
      unsigned int sizeinc = 4096;
      unsigned int origsize = sizeinc;
      ULONG nread = 42;
 
      TRACE("Reading all data from stream.\n");
      xbuf = HeapAlloc (GetProcessHeap(), HEAP_ZERO_MEMORY, origsize);
      if (headerisdata)
          memcpy (xbuf, header, 8);
      while (1) {
          while (xread < origsize) {
              hr = IStream_Read(pStm,xbuf+xread,origsize-xread,&nread);
              xread += nread;
              if (hr != S_OK || !nread)
                  break;
          }
          if (!nread || hr != S_OK) /* done, or error */
              break;
          if (xread == origsize) {
              origsize += sizeinc;
              sizeinc = 2*sizeinc; /* exponential increase */
              xbuf = HeapReAlloc (GetProcessHeap(), HEAP_ZERO_MEMORY, xbuf, origsize);
          }
      }
      if (hr != S_OK)
          TRACE("hr in no-stat loader case is %08x\n", hr);
      TRACE("loaded %d bytes.\n", xread);
      This->datalen = xread;
      This->data    = xbuf;
  } else {
      This->datalen = toread+(headerisdata?8:0);
      xbuf = This->data = HeapAlloc (GetProcessHeap(), HEAP_ZERO_MEMORY, This->datalen);
      if (!xbuf)
          return E_OUTOFMEMORY;
 
      if (headerisdata)
          memcpy (xbuf, header, 8);
 
      while (xread < This->datalen) {
          ULONG nread;
          hr = IStream_Read(pStm,xbuf+xread,This->datalen-xread,&nread);
          xread += nread;
          if (hr != S_OK || !nread)
              break;
      }
      if (xread != This->datalen)
          ERR("Could only read %d of %d bytes out of stream?\n",xread,This->datalen);
  }
  if (This->datalen == 0) { /* Marks the "NONE" picture */
      This->desc.picType = PICTYPE_NONE;
      return S_OK;
  }
 
 
  /****************************************************************************************
   * Part 2: Process the loaded data
   */
 
  magic = xbuf[0] + (xbuf[1]<<8);
  This->loadtime_format = magic;
 
  switch (magic) {
  case BITMAP_FORMAT_GIF: /* GIF */
    hr = OLEPictureImpl_LoadWICDecoder(This, &CLSID_WICGifDecoder, xbuf, xread);
    break;
  case BITMAP_FORMAT_JPEG: /* JPEG */
    hr = OLEPictureImpl_LoadWICDecoder(This, &CLSID_WICJpegDecoder, xbuf, xread);
    break;
  case BITMAP_FORMAT_BMP: /* Bitmap */
    hr = OLEPictureImpl_LoadWICDecoder(This, &CLSID_WICBmpDecoder, xbuf, xread);
    break;
  case BITMAP_FORMAT_PNG: /* PNG */
    hr = OLEPictureImpl_LoadWICDecoder(This, &CLSID_WICPngDecoder, xbuf, xread);
    break;
  case BITMAP_FORMAT_APM: /* APM */
    hr = OLEPictureImpl_LoadAPM(This, xbuf, xread);
    break;
  case 0x0000: { /* ICON or CURSOR, first word is dwReserved */
    hr = OLEPictureImpl_LoadIcon(This, xbuf, xread);
    break;
  }
  default:
  {
    unsigned int i;
 
    /* let's see if it's a EMF */
    hr = OLEPictureImpl_LoadEnhMetafile(This, xbuf, xread);
    if (hr == S_OK) break;
 
    FIXME("Unknown magic %04x, %d read bytes:\n",magic,xread);
    hr=E_FAIL;
    for (i=0;i<xread+8;i++) {
    if (i<8) MESSAGE("%02x ",((unsigned char*)header)[i]);
    else MESSAGE("%02x ",xbuf[i-8]);
        if (i % 10 == 9) MESSAGE("\n");
    }
    MESSAGE("\n");
    break;
  }
  }
  This->bIsDirty = FALSE;
 
  /* FIXME: this notify is not really documented */
  if (hr==S_OK)
      OLEPicture_SendNotify(This,DISPID_PICT_TYPE);
  return hr;
}

OLEPictureImpl_LoadAPM()

static HRESULT OLEPictureImpl_LoadAPM ( OLEPictureImpl *  This, const BYTE *  data, ULONG  size  )

static

Definition at line 1302 of file olepicture.c.

{
    const APM_HEADER *header = (const APM_HEADER *)data;
    HMETAFILE hmf;
 
    if (size < sizeof(APM_HEADER))
        return E_FAIL;
    if (header->key != 0x9ac6cdd7)
        return E_FAIL;
 
    /* SetMetaFileBitsEx performs data check on its own */
    hmf = SetMetaFileBitsEx(size - sizeof(*header), data + sizeof(*header));
    if (!hmf) return E_FAIL;
 
    This->desc.picType = PICTYPE_METAFILE;
    This->desc.u.wmf.hmeta = hmf;
    This->desc.u.wmf.xExt = 0;
    This->desc.u.wmf.yExt = 0;
 
    This->origWidth = 0;
    This->origHeight = 0;
    This->himetricWidth = MulDiv((INT)header->right - header->left, 2540, header->inch);
    This->himetricHeight = MulDiv((INT)header->bottom - header->top, 2540, header->inch);
    return S_OK;
}

Referenced by OLEPictureImpl_Load().

OLEPictureImpl_LoadEnhMetafile()

static HRESULT OLEPictureImpl_LoadEnhMetafile ( OLEPictureImpl *  This, const BYTE *  data, ULONG  size  )

static

Definition at line 1280 of file olepicture.c.

{
    HENHMETAFILE hemf;
    ENHMETAHEADER hdr;
 
    hemf = SetEnhMetaFileBits(size, data);
    if (!hemf) return E_FAIL;
 
    GetEnhMetaFileHeader(hemf, sizeof(hdr), &hdr);
 
    This->desc.picType = PICTYPE_ENHMETAFILE;
    This->desc.u.emf.hemf = hemf;
 
    This->origWidth = 0;
    This->origHeight = 0;
    This->himetricWidth = hdr.rclFrame.right - hdr.rclFrame.left;
    This->himetricHeight = hdr.rclFrame.bottom - hdr.rclFrame.top;
 
    return S_OK;
}

Referenced by OLEPictureImpl_Load().

OLEPictureImpl_LoadIcon()

static HRESULT OLEPictureImpl_LoadIcon ( OLEPictureImpl *  This, BYTE *  xbuf, ULONG  xread  )

static

Definition at line 1187 of file olepicture.c.

{
    HICON hicon;
    CURSORICONFILEDIR   *cifd = (CURSORICONFILEDIR*)xbuf;
    HDC hdcRef;
    int i;
 
    TRACE("(this %p, xbuf %p, xread %u)\n", This, xbuf, xread);
 
    /*
    FIXME("icon.idReserved=%d\n",cifd->idReserved);
    FIXME("icon.idType=%d\n",cifd->idType);
    FIXME("icon.idCount=%d\n",cifd->idCount);
 
    for (i=0;i<cifd->idCount;i++) {
    FIXME("[%d] width %d\n",i,cifd->idEntries[i].bWidth);
    FIXME("[%d] height %d\n",i,cifd->idEntries[i].bHeight);
    FIXME("[%d] bColorCount %d\n",i,cifd->idEntries[i].bColorCount);
    FIXME("[%d] bReserved %d\n",i,cifd->idEntries[i].bReserved);
    FIXME("[%d] xHotspot %d\n",i,cifd->idEntries[i].xHotspot);
    FIXME("[%d] yHotspot %d\n",i,cifd->idEntries[i].yHotspot);
    FIXME("[%d] dwDIBSize %d\n",i,cifd->idEntries[i].dwDIBSize);
    FIXME("[%d] dwDIBOffset %d\n",i,cifd->idEntries[i].dwDIBOffset);
    }
    */
 
    /* Need at least one icon to do something. */
    if (!cifd->idCount)
    {
        ERR("Invalid icon count of zero.\n");
        return E_FAIL;
    }
    i=0;
    /* If we have more than one icon, try to find the best.
     * this currently means '32 pixel wide'.
     */
    if (cifd->idCount!=1) {
    for (i=0;i<cifd->idCount;i++) {
        if (cifd->idEntries[i].bWidth == 32)
        break;
    }
    if (i==cifd->idCount) i=0;
    }
    if (xread < cifd->idEntries[i].dwDIBOffset + cifd->idEntries[i].dwDIBSize)
    {
        ERR("Icon data address %u is over %u bytes available.\n",
            cifd->idEntries[i].dwDIBOffset + cifd->idEntries[i].dwDIBSize, xread);
        return E_FAIL;
    }
    if (cifd->idType == 2)
    {
        LPBYTE buf = HeapAlloc(GetProcessHeap(), 0, cifd->idEntries[i].dwDIBSize + 4);
        memcpy(buf, &cifd->idEntries[i].xHotspot, 4);
        memcpy(buf + 4, xbuf+cifd->idEntries[i].dwDIBOffset, cifd->idEntries[i].dwDIBSize);
        hicon = CreateIconFromResourceEx(
            buf,
            cifd->idEntries[i].dwDIBSize + 4,
            FALSE, /* is cursor */
            0x00030000,
            cifd->idEntries[i].bWidth,
            cifd->idEntries[i].bHeight,
            0
    );
    HeapFree(GetProcessHeap(), 0, buf);
    }
    else
    {
        hicon = CreateIconFromResourceEx(
            xbuf+cifd->idEntries[i].dwDIBOffset,
            cifd->idEntries[i].dwDIBSize,
            TRUE, /* is icon */
            0x00030000,
            cifd->idEntries[i].bWidth,
            cifd->idEntries[i].bHeight,
            0
    );
    }
    if (!hicon) {
    ERR("CreateIcon failed.\n");
    return E_FAIL;
    } else {
    This->desc.picType = PICTYPE_ICON;
    This->desc.u.icon.hicon = hicon;
    This->origWidth = cifd->idEntries[i].bWidth;
    This->origHeight = cifd->idEntries[i].bHeight;
    hdcRef = CreateCompatibleDC(0);
    This->himetricWidth = xpixels_to_himetric(cifd->idEntries[i].bWidth, hdcRef);
    This->himetricHeight= ypixels_to_himetric(cifd->idEntries[i].bHeight, hdcRef);
    DeleteDC(hdcRef);
    return S_OK;
    }
}

Referenced by OLEPictureImpl_Load().

OLEPictureImpl_LoadWICDecoder()

static HRESULT OLEPictureImpl_LoadWICDecoder ( OLEPictureImpl *  This, REFCLSID  decoder_clsid, BYTE *  xbuf, ULONG  xread  )

static

Definition at line 1132 of file olepicture.c.

{
    HRESULT hr;
    IWICImagingFactory *factory;
    IWICBitmapDecoder *decoder;
    IWICBitmapFrameDecode *framedecode;
    HRESULT initresult;
    IWICStream *stream;
 
    initresult = CoInitialize(NULL);
 
    hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
        &IID_IWICImagingFactory, (void**)&factory);
    if (SUCCEEDED(hr)) /* created factory */
    {
        hr = IWICImagingFactory_CreateStream(factory, &stream);
        IWICImagingFactory_Release(factory);
    }
 
    if (SUCCEEDED(hr)) /* created stream */
    {
        hr = IWICStream_InitializeFromMemory(stream, xbuf, xread);
 
        if (SUCCEEDED(hr)) /* initialized stream */
        {
            hr = CoCreateInstance(decoder_clsid, NULL, CLSCTX_INPROC_SERVER,
                &IID_IWICBitmapDecoder, (void**)&decoder);
            if (SUCCEEDED(hr)) /* created decoder */
            {
                hr = IWICBitmapDecoder_Initialize(decoder, (IStream*)stream, WICDecodeMetadataCacheOnLoad);
 
                if (SUCCEEDED(hr)) /* initialized decoder */
                    hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
 
                IWICBitmapDecoder_Release(decoder);
            }
        }
 
        IWICStream_Release(stream);
    }
 
    if (SUCCEEDED(hr)) /* got framedecode */
    {
        hr = OLEPictureImpl_LoadWICSource(This, (IWICBitmapSource*)framedecode);
        IWICBitmapFrameDecode_Release(framedecode);
    }
 
    if (SUCCEEDED(initresult)) CoUninitialize();
    return hr;
}

Referenced by OLEPictureImpl_Load().

OLEPictureImpl_LoadWICSource()

static HRESULT OLEPictureImpl_LoadWICSource ( OLEPictureImpl *  This, IWICBitmapSource *  src  )

static

Definition at line 1011 of file olepicture.c.

{
    HRESULT hr;
    BITMAPINFOHEADER bih;
    UINT width, height;
    UINT stride, buffersize;
    BYTE *bits, *mask = NULL;
    WICRect rc;
    IWICBitmapSource *real_source;
    UINT x, y;
    COLORREF white = RGB(255, 255, 255), black = RGB(0, 0, 0);
    BOOL has_alpha=FALSE;
 
    hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA, src, &real_source);
    if (FAILED(hr)) return hr;
 
    hr = IWICBitmapSource_GetSize(real_source, &width, &height);
    if (FAILED(hr)) goto end;
 
    bih.biSize = sizeof(bih);
    bih.biWidth = width;
    bih.biHeight = -height;
    bih.biPlanes = 1;
    bih.biBitCount = 32;
    bih.biCompression = BI_RGB;
    bih.biSizeImage = 0;
    bih.biXPelsPerMeter = 4085; /* olepicture ignores the stored resolution */
    bih.biYPelsPerMeter = 4085;
    bih.biClrUsed = 0;
    bih.biClrImportant = 0;
 
    stride = 4 * width;
    buffersize = stride * height;
 
    mask = HeapAlloc(GetProcessHeap(), 0, buffersize);
    if (!mask)
    {
        hr = E_OUTOFMEMORY;
        goto end;
    }
 
    This->desc.u.bmp.hbitmap = CreateDIBSection(0, (BITMAPINFO*)&bih, DIB_RGB_COLORS, (void **)&bits, NULL, 0);
    if (This->desc.u.bmp.hbitmap == 0)
    {
        hr = E_FAIL;
        goto end;
    }
 
    rc.X = 0;
    rc.Y = 0;
    rc.Width = width;
    rc.Height = height;
    hr = IWICBitmapSource_CopyPixels(real_source, &rc, stride, buffersize, bits);
    if (FAILED(hr))
    {
        DeleteObject(This->desc.u.bmp.hbitmap);
        goto end;
    }
 
    This->desc.picType = PICTYPE_BITMAP;
    OLEPictureImpl_SetBitmap(This);
 
    /* set transparent pixels to black, all others to white */
    for(y = 0; y < height; y++){
        for(x = 0; x < width; x++){
            DWORD *pixel = (DWORD*)(bits + stride*y + 4*x);
            if((*pixel & 0x80000000) == 0)
            {
                has_alpha = TRUE;
                *(DWORD *)(mask + stride * y + 4 * x) = black;
            }
            else
                *(DWORD *)(mask + stride * y + 4 * x) = white;
        }
    }
 
    if (has_alpha)
    {
        HDC hdcref, hdcBmp, hdcXor, hdcMask;
        HBITMAP hbmoldBmp, hbmoldXor, hbmoldMask;
 
        hdcref = GetDC(0);
 
        This->hbmXor = CreateDIBitmap(
            hdcref,
            &bih,
            CBM_INIT,
            mask,
            (BITMAPINFO*)&bih,
            DIB_RGB_COLORS
        );
 
        This->hbmMask = CreateBitmap(width,-height,1,1,NULL);
        hdcBmp = CreateCompatibleDC(NULL);
        hdcXor = CreateCompatibleDC(NULL);
        hdcMask = CreateCompatibleDC(NULL);
 
        hbmoldBmp = SelectObject(hdcBmp,This->desc.u.bmp.hbitmap);
        hbmoldXor = SelectObject(hdcXor,This->hbmXor);
        hbmoldMask = SelectObject(hdcMask,This->hbmMask);
 
        SetBkColor(hdcXor,black);
        BitBlt(hdcMask,0,0,width,height,hdcXor,0,0,SRCCOPY);
        BitBlt(hdcXor,0,0,width,height,hdcBmp,0,0,SRCAND);
 
        SelectObject(hdcBmp,hbmoldBmp);
        SelectObject(hdcXor,hbmoldXor);
        SelectObject(hdcMask,hbmoldMask);
 
        DeleteDC(hdcBmp);
        DeleteDC(hdcXor);
        DeleteDC(hdcMask);
        ReleaseDC(0, hdcref);
    }
 
end:
    HeapFree(GetProcessHeap(), 0, mask);
    IWICBitmapSource_Release(real_source);
    return hr;
}

Referenced by OLEPictureImpl_LoadWICDecoder().

OLEPictureImpl_PictureChanged()

static HRESULT WINAPI OLEPictureImpl_PictureChanged ( IPicture *  iface )

static

Definition at line 853 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IPicture(iface);
  TRACE("(%p)->()\n", This);
  OLEPicture_SendNotify(This,DISPID_PICT_HANDLE);
  This->bIsDirty = TRUE;
  return S_OK;
}

OLEPictureImpl_put_KeepOriginalFormat()

static HRESULT WINAPI OLEPictureImpl_put_KeepOriginalFormat ( IPicture *  iface, BOOL  keep  )

static

Definition at line 840 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IPicture(iface);
  TRACE("(%p)->(%d)\n", This, keep);
  This->keepOrigFormat = keep;
  /* FIXME: what DISPID notification here? */
  return S_OK;
}

OLEPictureImpl_QueryInterface()

static HRESULT WINAPI OLEPictureImpl_QueryInterface ( IPicture *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 458 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IPicture(iface);
 
  TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppvObject);
 
  if (!ppvObject)
    return E_INVALIDARG;
 
  *ppvObject = 0;
 
  if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IPicture, riid))
    *ppvObject = &This->IPicture_iface;
  else if (IsEqualIID(&IID_IDispatch, riid))
    *ppvObject = &This->IDispatch_iface;
  else if (IsEqualIID(&IID_IPictureDisp, riid))
    *ppvObject = &This->IDispatch_iface;
  else if (IsEqualIID(&IID_IPersist, riid) || IsEqualIID(&IID_IPersistStream, riid))
    *ppvObject = &This->IPersistStream_iface;
  else if (IsEqualIID(&IID_IConnectionPointContainer, riid))
    *ppvObject = &This->IConnectionPointContainer_iface;
 
  if (!*ppvObject)
  {
    FIXME("() : asking for unsupported interface %s\n",debugstr_guid(riid));
    return E_NOINTERFACE;
  }
 
  IPicture_AddRef(iface);
 
  return S_OK;
}

OLEPictureImpl_Release()

static ULONG WINAPI OLEPictureImpl_Release ( IPicture *  iface )

static

Definition at line 437 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IPicture(iface);
  ULONG refCount = InterlockedDecrement(&This->ref);
 
  TRACE("(%p)->(ref before=%d)\n", This, refCount + 1);
 
  /*
   * If the reference count goes down to 0, perform suicide.
   */
  if (!refCount) OLEPictureImpl_Destroy(This);
 
  return refCount;
}

OLEPictureImpl_Render()

static HRESULT WINAPI OLEPictureImpl_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, LPCRECT  prcWBounds  )

static

Definition at line 661 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IPicture(iface);
  TRACE("(%p)->(%p, (%d,%d), (%d,%d) <- (%d,%d), (%d,%d), %p)\n",
    This, hdc, x, y, cx, cy, xSrc, ySrc, cxSrc, cySrc, prcWBounds);
  if(prcWBounds)
  TRACE("prcWBounds %s\n", wine_dbgstr_rect(prcWBounds));
 
  if(cx == 0 || cy == 0 || cxSrc == 0 || cySrc == 0){
    return CTL_E_INVALIDPROPERTYVALUE;
  }
 
  /*
   * While the documentation suggests this to be here (or after rendering?)
   * it does cause an endless recursion in my sample app. -MM 20010804
  OLEPicture_SendNotify(This,DISPID_PICT_RENDER);
   */
 
  switch(This->desc.picType) {
  case PICTYPE_UNINITIALIZED:
  case PICTYPE_NONE:
    /* nothing to do */
    return S_OK;
  case PICTYPE_BITMAP:
  {
    HBITMAP hbmMask, hbmXor;
 
    if (This->hbmMask)
    {
        hbmMask = This->hbmMask;
        hbmXor = This->hbmXor;
    }
    else
    {
        hbmMask = 0;
        hbmXor = This->desc.u.bmp.hbitmap;
    }
 
    render_masked_bitmap(This, hdc, x, y, cx, cy, xSrc, ySrc, cxSrc, cySrc, hbmMask, hbmXor);
    break;
  }
 
  case PICTYPE_ICON:
  {
    ICONINFO info;
 
    if (!GetIconInfo(This->desc.u.icon.hicon, &info))
        return E_FAIL;
 
    render_masked_bitmap(This, hdc, x, y, cx, cy, xSrc, ySrc, cxSrc, cySrc, info.hbmMask, info.hbmColor);
 
    DeleteObject(info.hbmMask);
    if (info.hbmColor) DeleteObject(info.hbmColor);
    break;
  }
 
  case PICTYPE_METAFILE:
  {
    POINT prevOrg, prevWndOrg;
    SIZE prevExt, prevWndExt;
    int oldmode;
 
    /* Render the WMF to the appropriate location by setting the
       appropriate ratio between "device units" and "logical units" */
    oldmode = SetMapMode(hdc, MM_ANISOTROPIC);
    /* For the "source rectangle" the y-axis must be inverted */
    SetWindowOrgEx(hdc, xSrc, This->himetricHeight-ySrc, &prevWndOrg);
    SetWindowExtEx(hdc, cxSrc, -cySrc, &prevWndExt);
    /* For the "destination rectangle" no inversion is necessary */
    SetViewportOrgEx(hdc, x, y, &prevOrg);
    SetViewportExtEx(hdc, cx, cy, &prevExt);
 
    if (!PlayMetaFile(hdc, This->desc.u.wmf.hmeta))
        ERR("PlayMetaFile failed!\n");
 
    /* We're done, restore the DC to the previous settings for converting
       logical units to device units */
    SetWindowExtEx(hdc, prevWndExt.cx, prevWndExt.cy, NULL);
    SetWindowOrgEx(hdc, prevWndOrg.x, prevWndOrg.y, NULL);
    SetViewportExtEx(hdc, prevExt.cx, prevExt.cy, NULL);
    SetViewportOrgEx(hdc, prevOrg.x, prevOrg.y, NULL);
    SetMapMode(hdc, oldmode);
    break;
  }
 
  case PICTYPE_ENHMETAFILE:
  {
    RECT rc = { x, y, x + cx, y + cy };
    PlayEnhMetaFile(hdc, This->desc.u.emf.hemf, &rc);
    break;
  }
 
  default:
    FIXME("type %d not implemented\n", This->desc.picType);
    return E_NOTIMPL;
  }
  return S_OK;
}

OLEPictureImpl_Save()

static HRESULT WINAPI OLEPictureImpl_Save ( IPersistStream *  iface, IStream *  pStm, BOOL  fClearDirty  )

static

Definition at line 1757 of file olepicture.c.

{
    HRESULT hResult = E_NOTIMPL;
    void * pIconData;
    unsigned int iDataSize;
    DWORD header[2];
    ULONG dummy;
    BOOL serializeResult = FALSE;
    OLEPictureImpl *This = impl_from_IPersistStream(iface);
 
    TRACE("%p %p %d\n", This, pStm, fClearDirty);
 
    switch (This->desc.picType) {
    case PICTYPE_NONE:
        header[0] = 0x0000746c;
        header[1] = 0;
        hResult = IStream_Write(pStm, header, 2 * sizeof(DWORD), &dummy);
        break;
 
    case PICTYPE_ICON:
        if (This->bIsDirty || !This->data) {
            if (!serializeIcon(This->desc.u.icon.hicon, &pIconData, &iDataSize)) {
                ERR("(%p,%p,%d), serializeIcon() failed\n", This, pStm, fClearDirty);
                hResult = E_FAIL;
                break;
            }
            HeapFree(GetProcessHeap(), 0, This->data);
            This->data = pIconData;
            This->datalen = iDataSize;
        }
 
        header[0] = (This->loadtime_magic != 0xdeadbeef) ? This->loadtime_magic : 0x0000746c;
        header[1] = This->datalen;
        IStream_Write(pStm, header, 2 * sizeof(DWORD), &dummy);
        IStream_Write(pStm, This->data, This->datalen, &dummy);
        hResult = S_OK;
        break;
    case PICTYPE_BITMAP:
        if (This->bIsDirty || !This->data) {
            switch (This->keepOrigFormat ? This->loadtime_format : BITMAP_FORMAT_BMP) {
            case BITMAP_FORMAT_BMP:
                serializeResult = serializeBMP(This->desc.u.bmp.hbitmap, &pIconData, &iDataSize);
                break;
            case BITMAP_FORMAT_JPEG:
                FIXME("(%p,%p,%d), PICTYPE_BITMAP (format JPEG) not implemented!\n",This,pStm,fClearDirty);
                break;
            case BITMAP_FORMAT_GIF:
                FIXME("(%p,%p,%d), PICTYPE_BITMAP (format GIF) not implemented!\n",This,pStm,fClearDirty);
                break;
            case BITMAP_FORMAT_PNG:
                FIXME("(%p,%p,%d), PICTYPE_BITMAP (format PNG) not implemented!\n",This,pStm,fClearDirty);
                break;
            default:
                FIXME("(%p,%p,%d), PICTYPE_BITMAP (format UNKNOWN, using BMP?) not implemented!\n",This,pStm,fClearDirty);
                break;
            }
 
            if (!serializeResult)
            {
                hResult = E_FAIL;
                break;
            }
 
            HeapFree(GetProcessHeap(), 0, This->data);
            This->data = pIconData;
            This->datalen = iDataSize;
        }
 
        header[0] = (This->loadtime_magic != 0xdeadbeef) ? This->loadtime_magic : 0x0000746c;
        header[1] = This->datalen;
        IStream_Write(pStm, header, 2 * sizeof(DWORD), &dummy);
        IStream_Write(pStm, This->data, This->datalen, &dummy);
        hResult = S_OK;
        break;
 
    case PICTYPE_ENHMETAFILE:
        if (This->bIsDirty || !This->data)
        {
            serializeResult = serializeEMF(This->desc.u.emf.hemf, &pIconData, &iDataSize);
            if (!serializeResult)
            {
                hResult = E_FAIL;
                break;
            }
 
            HeapFree(GetProcessHeap(), 0, This->data);
            This->data = pIconData;
            This->datalen = iDataSize;
        }
        header[0] = 0x0000746c;
        header[1] = This->datalen;
        IStream_Write(pStm, header, 2 * sizeof(DWORD), &dummy);
        IStream_Write(pStm, This->data, This->datalen, &dummy);
        hResult = S_OK;
        break;
 
    case PICTYPE_METAFILE:
        FIXME("(%p,%p,%d), PICTYPE_METAFILE not implemented!\n",This,pStm,fClearDirty);
        break;
    default:
        FIXME("(%p,%p,%d), [unknown type] not implemented!\n",This,pStm,fClearDirty);
        break;
    }
    if (hResult == S_OK && fClearDirty) This->bIsDirty = FALSE;
    return hResult;
}

OLEPictureImpl_SaveAsFile()

static HRESULT WINAPI OLEPictureImpl_SaveAsFile ( IPicture *  iface, IStream *  stream, BOOL  mem_copy, LONG *  size  )

static

Definition at line 1876 of file olepicture.c.

{
    OLEPictureImpl *This = impl_from_IPicture(iface);
    void *data;
    unsigned data_size;
    ULONG written;
    HRESULT hr;
 
    FIXME("(%p)->(%p,%d,%p): semi-stub\n", This, stream, mem_copy, size);
 
    switch (This->desc.picType)
    {
    case PICTYPE_NONE:
        return S_OK;
 
    case PICTYPE_ICON:
        if (!mem_copy) return E_FAIL;
 
        if (This->bIsDirty || !This->data)
        {
            if (!serializeIcon(This->desc.u.icon.hicon, &data, &data_size))
                return E_FAIL;
            HeapFree(GetProcessHeap(), 0, This->data);
            This->data = data;
            This->datalen = data_size;
        }
        hr = IStream_Write(stream, This->data, This->datalen, &written);
        if (hr == S_OK && size) *size = written;
        return hr;
 
    case PICTYPE_BITMAP:
        if (!mem_copy) return E_FAIL;
 
        if (This->bIsDirty || !This->data)
        {
            switch (This->keepOrigFormat ? This->loadtime_format : BITMAP_FORMAT_BMP)
            {
            case BITMAP_FORMAT_BMP:
                if (!serializeBMP(This->desc.u.bmp.hbitmap, &data, &data_size))
                    return E_FAIL;
                break;
            case BITMAP_FORMAT_JPEG:
                FIXME("BITMAP_FORMAT_JPEG is not implemented\n");
                return E_NOTIMPL;
            case BITMAP_FORMAT_GIF:
                FIXME("BITMAP_FORMAT_GIF is not implemented\n");
                return E_NOTIMPL;
            case BITMAP_FORMAT_PNG:
                FIXME("BITMAP_FORMAT_PNG is not implemented\n");
                return E_NOTIMPL;
            default:
                FIXME("PICTYPE_BITMAP/%#x is not implemented\n", This->loadtime_format);
                return E_NOTIMPL;
            }
 
            HeapFree(GetProcessHeap(), 0, This->data);
            This->data = data;
            This->datalen = data_size;
        }
        hr = IStream_Write(stream, This->data, This->datalen, &written);
        if (hr == S_OK && size) *size = written;
        return hr;
 
    case PICTYPE_METAFILE:
        FIXME("PICTYPE_METAFILE is not implemented\n");
        return E_NOTIMPL;
 
    case PICTYPE_ENHMETAFILE:
        if (!mem_copy) return E_FAIL;
 
        if (This->bIsDirty || !This->data)
        {
            if (!serializeEMF(This->desc.u.emf.hemf, &data, &data_size))
                return E_FAIL;
            HeapFree(GetProcessHeap(), 0, This->data);
            This->data = data;
            This->datalen = data_size;
        }
        hr = IStream_Write(stream, This->data, This->datalen, &written);
        if (hr == S_OK && size) *size = written;
        return hr;
 
    default:
        FIXME("%#x is not implemented\n", This->desc.picType);
        break;
    }
    return E_NOTIMPL;
}

OLEPictureImpl_SelectPicture()

static HRESULT WINAPI OLEPictureImpl_SelectPicture ( IPicture *  iface, HDC  hdcIn, HDC *  phdcOut, OLE_HANDLE *  phbmpOut  )

static

Definition at line 801 of file olepicture.c.

{
  OLEPictureImpl *This = impl_from_IPicture(iface);
  TRACE("(%p)->(%p, %p, %p)\n", This, hdcIn, phdcOut, phbmpOut);
  if (This->desc.picType == PICTYPE_BITMAP) {
      if (phdcOut)
      *phdcOut = This->hDCCur;
      if (This->hDCCur) SelectObject(This->hDCCur,This->stock_bitmap);
      if (hdcIn) SelectObject(hdcIn,This->desc.u.bmp.hbitmap);
      This->hDCCur = hdcIn;
      if (phbmpOut)
      *phbmpOut = HandleToUlong(This->desc.u.bmp.hbitmap);
      return S_OK;
  } else {
      FIXME("Don't know how to select picture type %d\n",This->desc.picType);
      return E_FAIL;
  }
}

OLEPictureImpl_set_hPal()

static HRESULT WINAPI OLEPictureImpl_set_hPal ( IPicture *  iface, OLE_HANDLE  hpal  )

static

Definition at line 769 of file olepicture.c.

{
    OLEPictureImpl *This = impl_from_IPicture(iface);
 
    TRACE("(%p)->(%08x)\n", This, hpal);
 
    if (This->desc.picType == PICTYPE_BITMAP)
    {
        This->desc.u.bmp.hpal = ULongToHandle(hpal);
        OLEPicture_SendNotify(This,DISPID_PICT_HPAL);
        return S_OK;
    }
 
    return E_FAIL;
}

OLEPictureImpl_SetBitmap()

static void OLEPictureImpl_SetBitmap ( OLEPictureImpl *  This )

static

Definition at line 199 of file olepicture.c.

{
  BITMAP bm;
  HDC hdcRef;
 
  TRACE("bitmap handle %p\n", This->desc.u.bmp.hbitmap);
  if(GetObjectW(This->desc.u.bmp.hbitmap, sizeof(bm), &bm) != sizeof(bm)) {
    ERR("GetObject fails\n");
    return;
  }
  This->origWidth = bm.bmWidth;
  This->origHeight = bm.bmHeight;
 
  TRACE("width %d, height %d, bpp %d\n", bm.bmWidth, bm.bmHeight, bm.bmBitsPixel);
 
  /* The width and height are stored in HIMETRIC units (0.01 mm),
     so we take our pixel width divide by pixels per inch and
     multiply by 25.4 * 100 */
  /* Should we use GetBitmapDimension if available? */
  hdcRef = CreateCompatibleDC(0);
 
  This->himetricWidth  = xpixels_to_himetric(bm.bmWidth, hdcRef);
  This->himetricHeight = ypixels_to_himetric(bm.bmHeight, hdcRef);
  This->stock_bitmap = GetCurrentObject( hdcRef, OBJ_BITMAP );
 
  This->loadtime_format = BITMAP_FORMAT_BMP;
 
  DeleteDC(hdcRef);
}

Referenced by OLEPictureImpl_Construct(), and OLEPictureImpl_LoadWICSource().

OLEPictureImpl_SetEMF()

static void OLEPictureImpl_SetEMF ( OLEPictureImpl *  This )

static

Definition at line 261 of file olepicture.c.

{
    ENHMETAHEADER emh;
 
    GetEnhMetaFileHeader(This->desc.u.emf.hemf, sizeof(emh), &emh);
 
    This->origWidth = 0;
    This->origHeight = 0;
    This->himetricWidth = emh.rclFrame.right - emh.rclFrame.left;
    This->himetricHeight = emh.rclFrame.bottom - emh.rclFrame.top;
}

Referenced by OLEPictureImpl_Construct().

OLEPictureImpl_SetIcon()

static void OLEPictureImpl_SetIcon ( OLEPictureImpl *  This )

static

Definition at line 229 of file olepicture.c.

{
    ICONINFO infoIcon;
 
    TRACE("icon handle %p\n", This->desc.u.icon.hicon);
    if (GetIconInfo(This->desc.u.icon.hicon, &infoIcon)) {
        HDC hdcRef;
        BITMAP bm;
 
        TRACE("bitmap handle for icon is %p\n", infoIcon.hbmColor);
        if(GetObjectW(infoIcon.hbmColor ? infoIcon.hbmColor : infoIcon.hbmMask, sizeof(bm), &bm) != sizeof(bm)) {
            ERR("GetObject fails on icon bitmap\n");
            return;
        }
 
        This->origWidth = bm.bmWidth;
        This->origHeight = infoIcon.hbmColor ? bm.bmHeight : bm.bmHeight / 2;
        /* see comment on HIMETRIC on OLEPictureImpl_SetBitmap() */
        hdcRef = GetDC(0);
 
        This->himetricWidth  = xpixels_to_himetric(This->origWidth, hdcRef);
        This->himetricHeight = ypixels_to_himetric(This->origHeight, hdcRef);
 
        ReleaseDC(0, hdcRef);
 
        DeleteObject(infoIcon.hbmMask);
        if (infoIcon.hbmColor) DeleteObject(infoIcon.hbmColor);
    } else {
        ERR("GetIconInfo() fails on icon %p\n", This->desc.u.icon.hicon);
    }
}

Referenced by OLEPictureImpl_Construct().

OleSavePictureFile()

HRESULT WINAPI OleSavePictureFile	(	IDispatch *	picture,
		BSTR	filename
	)

Definition at line 2488 of file olepicture.c.

{
  FIXME("(%p %s): stub\n", picture, debugstr_w(filename));
  return CTL_E_FILENOTFOUND;
}

render_masked_bitmap()

static void render_masked_bitmap ( OLEPictureImpl *  This, 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, HBITMAP  hbmMask, HBITMAP  hbmXor  )

static

Definition at line 616 of file olepicture.c.

{
    HDC hdcBmp;
 
    /* Set a mapping mode that maps bitmap pixels into HIMETRIC units.
     * NB y-axis gets flipped
     */
 
    hdcBmp = CreateCompatibleDC(0);
    SetMapMode(hdcBmp, MM_ANISOTROPIC);
    SetWindowOrgEx(hdcBmp, 0, 0, NULL);
    SetWindowExtEx(hdcBmp, This->himetricWidth, This->himetricHeight, NULL);
    SetViewportOrgEx(hdcBmp, 0, This->origHeight, NULL);
    SetViewportExtEx(hdcBmp, This->origWidth, -This->origHeight, NULL);
 
    if (hbmMask)
    {
        SetBkColor(hdc, RGB(255, 255, 255));
        SetTextColor(hdc, RGB(0, 0, 0));
 
        SelectObject(hdcBmp, hbmMask);
        StretchBlt(hdc, x, y, cx, cy, hdcBmp, xSrc, ySrc, cxSrc, cySrc, SRCAND);
 
        if (hbmXor)
        {
            SelectObject(hdcBmp, hbmXor);
            StretchBlt(hdc, x, y, cx, cy, hdcBmp, xSrc, ySrc, cxSrc, cySrc, SRCPAINT);
        }
        else StretchBlt(hdc, x, y, cx, cy, hdcBmp, xSrc, ySrc - This->himetricHeight,
                        cxSrc, cySrc, SRCPAINT);
    }
    else
    {
        SelectObject(hdcBmp, hbmXor);
        StretchBlt(hdc, x, y, cx, cy, hdcBmp, xSrc, ySrc, cxSrc, cySrc, SRCCOPY);
    }
 
    DeleteDC(hdcBmp);
}

Referenced by OLEPictureImpl_Render().

serializeBMP()

static BOOL serializeBMP ( HBITMAP  hBitmap, void **  ppBuffer, unsigned int *  pLength  )

static

Definition at line 1530 of file olepicture.c.

{
    BOOL success = FALSE;
    HDC hDC;
    BITMAPINFO * pInfoBitmap;
    int iNumPaletteEntries;
    unsigned char * pPixelData;
    BITMAPFILEHEADER * pFileHeader;
    BITMAPINFO * pInfoHeader;
 
    pInfoBitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
        sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
 
    /* Find out bitmap size and padded length */
    hDC = GetDC(0);
    pInfoBitmap->bmiHeader.biSize = sizeof(pInfoBitmap->bmiHeader);
    GetDIBits(hDC, hBitmap, 0, 0, NULL, pInfoBitmap, DIB_RGB_COLORS);
 
    /* Fetch bitmap palette & pixel data */
 
    pPixelData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, pInfoBitmap->bmiHeader.biSizeImage);
    GetDIBits(hDC, hBitmap, 0, pInfoBitmap->bmiHeader.biHeight, pPixelData, pInfoBitmap, DIB_RGB_COLORS);
 
    /* Calculate the total length required for the BMP data */
    if (pInfoBitmap->bmiHeader.biClrUsed != 0) {
    iNumPaletteEntries = pInfoBitmap->bmiHeader.biClrUsed;
    if (iNumPaletteEntries > 256) iNumPaletteEntries = 256;
    } else {
    if (pInfoBitmap->bmiHeader.biBitCount <= 8)
        iNumPaletteEntries = 1 << pInfoBitmap->bmiHeader.biBitCount;
    else
            iNumPaletteEntries = 0;
    }
    *pLength =
        sizeof(BITMAPFILEHEADER) +
        sizeof(BITMAPINFOHEADER) +
        iNumPaletteEntries * sizeof(RGBQUAD) +
        pInfoBitmap->bmiHeader.biSizeImage;
    *ppBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *pLength);
 
    /* Fill the BITMAPFILEHEADER */
    pFileHeader = *ppBuffer;
    pFileHeader->bfType = BITMAP_FORMAT_BMP;
    pFileHeader->bfSize = *pLength;
    pFileHeader->bfOffBits =
        sizeof(BITMAPFILEHEADER) +
        sizeof(BITMAPINFOHEADER) +
        iNumPaletteEntries * sizeof(RGBQUAD);
 
    /* Fill the BITMAPINFOHEADER and the palette data */
    pInfoHeader = (BITMAPINFO *)((unsigned char *)(*ppBuffer) + sizeof(BITMAPFILEHEADER));
    memcpy(pInfoHeader, pInfoBitmap, sizeof(BITMAPINFOHEADER) + iNumPaletteEntries * sizeof(RGBQUAD));
    memcpy(
        (unsigned char *)(*ppBuffer) +
            sizeof(BITMAPFILEHEADER) +
            sizeof(BITMAPINFOHEADER) +
            iNumPaletteEntries * sizeof(RGBQUAD),
        pPixelData, pInfoBitmap->bmiHeader.biSizeImage);
    success = TRUE;
 
    HeapFree(GetProcessHeap(), 0, pPixelData);
    HeapFree(GetProcessHeap(), 0, pInfoBitmap);
    return success;
}

Referenced by OLEPictureImpl_Save(), and OLEPictureImpl_SaveAsFile().

serializeEMF()

static BOOL serializeEMF ( HENHMETAFILE  hemf, void **  buf, unsigned *  size  )

static

Definition at line 1746 of file olepicture.c.

{
    *size = GetEnhMetaFileBits(hemf, 0, NULL);
    if (!*size) return FALSE;
 
    *buf = HeapAlloc(GetProcessHeap(), 0, *size);
    if (!*buf) return FALSE;
 
    return GetEnhMetaFileBits(hemf, *size, *buf) != 0;
}

Referenced by OLEPictureImpl_Save(), and OLEPictureImpl_SaveAsFile().

serializeIcon()

static BOOL serializeIcon ( HICON  hIcon, void **  ppBuffer, unsigned int *  pLength  )

static

Definition at line 1595 of file olepicture.c.

{
    ICONINFO infoIcon;
        BOOL success = FALSE;
 
    *ppBuffer = NULL; *pLength = 0;
    if (GetIconInfo(hIcon, &infoIcon)) {
        HDC hDC;
        BITMAPINFO * pInfoBitmap;
        unsigned char * pIconData = NULL;
        unsigned int iDataSize = 0;
 
        pInfoBitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
 
        /* Find out icon size */
        hDC = GetDC(0);
        pInfoBitmap->bmiHeader.biSize = sizeof(pInfoBitmap->bmiHeader);
        GetDIBits(hDC, infoIcon.hbmColor, 0, 0, NULL, pInfoBitmap, DIB_RGB_COLORS);
        if (1) {
            /* Auxiliary pointers */
            CURSORICONFILEDIR * pIconDir;
            CURSORICONFILEDIRENTRY * pIconEntry;
            BITMAPINFOHEADER * pIconBitmapHeader;
            unsigned int iOffsetPalette;
            unsigned int iOffsetColorData;
            unsigned int iOffsetMaskData;
 
            unsigned int iLengthScanLineMask;
            unsigned int iNumEntriesPalette;
 
            iLengthScanLineMask = ((pInfoBitmap->bmiHeader.biWidth + 31) >> 5) << 2;
/*
            FIXME("DEBUG: bitmap size is %d x %d\n",
                pInfoBitmap->bmiHeader.biWidth,
                pInfoBitmap->bmiHeader.biHeight);
            FIXME("DEBUG: bitmap bpp is %d\n",
                pInfoBitmap->bmiHeader.biBitCount);
            FIXME("DEBUG: bitmap nplanes is %d\n",
                pInfoBitmap->bmiHeader.biPlanes);
            FIXME("DEBUG: bitmap biSizeImage is %u\n",
                pInfoBitmap->bmiHeader.biSizeImage);
*/
            /* Let's start with one CURSORICONFILEDIR and one CURSORICONFILEDIRENTRY */
            iDataSize += 3 * sizeof(WORD) + sizeof(CURSORICONFILEDIRENTRY) + sizeof(BITMAPINFOHEADER);
            pIconData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, iDataSize);
 
            /* Fill out the CURSORICONFILEDIR */
            pIconDir = (CURSORICONFILEDIR *)pIconData;
            pIconDir->idType = 1;
            pIconDir->idCount = 1;
            pIconDir->idReserved = 0;
 
            /* Fill out the CURSORICONFILEDIRENTRY */
            pIconEntry = (CURSORICONFILEDIRENTRY *)(pIconData + 3 * sizeof(WORD));
            pIconEntry->bWidth = (unsigned char)pInfoBitmap->bmiHeader.biWidth;
            pIconEntry->bHeight = (unsigned char)pInfoBitmap->bmiHeader.biHeight;
            pIconEntry->bColorCount =
                (pInfoBitmap->bmiHeader.biBitCount < 8)
                ? 1 << pInfoBitmap->bmiHeader.biBitCount
                : 0;
            pIconEntry->xHotspot = pInfoBitmap->bmiHeader.biPlanes;
            pIconEntry->yHotspot = pInfoBitmap->bmiHeader.biBitCount;
            pIconEntry->dwDIBSize = 0;
            pIconEntry->dwDIBOffset = 3 * sizeof(WORD) + sizeof(CURSORICONFILEDIRENTRY);
 
            /* Fill out the BITMAPINFOHEADER */
            pIconBitmapHeader = (BITMAPINFOHEADER *)(pIconData + 3 * sizeof(WORD) + sizeof(CURSORICONFILEDIRENTRY));
            *pIconBitmapHeader = pInfoBitmap->bmiHeader;
 
            /*  Find out whether a palette exists for the bitmap */
            if (    (pInfoBitmap->bmiHeader.biBitCount == 16 && pInfoBitmap->bmiHeader.biCompression == BI_RGB)
                ||  (pInfoBitmap->bmiHeader.biBitCount == 24)
                ||  (pInfoBitmap->bmiHeader.biBitCount == 32 && pInfoBitmap->bmiHeader.biCompression == BI_RGB)) {
                iNumEntriesPalette = pInfoBitmap->bmiHeader.biClrUsed;
                if (iNumEntriesPalette > 256) iNumEntriesPalette = 256; 
            } else if ((pInfoBitmap->bmiHeader.biBitCount == 16 || pInfoBitmap->bmiHeader.biBitCount == 32)
                && pInfoBitmap->bmiHeader.biCompression == BI_BITFIELDS) {
                iNumEntriesPalette = 3;
            } else if (pInfoBitmap->bmiHeader.biBitCount <= 8) {
                iNumEntriesPalette = 1 << pInfoBitmap->bmiHeader.biBitCount;
            } else {
                iNumEntriesPalette = 0;
            }
 
            /*  Add bitmap size and header size to icon data size. */
            iOffsetPalette = iDataSize;
            iDataSize += iNumEntriesPalette * sizeof(DWORD);
            iOffsetColorData = iDataSize;
            iDataSize += pIconBitmapHeader->biSizeImage;
            iOffsetMaskData = iDataSize;
            iDataSize += pIconBitmapHeader->biHeight * iLengthScanLineMask;
            pIconBitmapHeader->biSizeImage += pIconBitmapHeader->biHeight * iLengthScanLineMask;
            pIconBitmapHeader->biHeight *= 2;
            pIconData = HeapReAlloc(GetProcessHeap(), 0, pIconData, iDataSize);
            pIconEntry = (CURSORICONFILEDIRENTRY *)(pIconData + 3 * sizeof(WORD));
            pIconBitmapHeader = (BITMAPINFOHEADER *)(pIconData + 3 * sizeof(WORD) + sizeof(CURSORICONFILEDIRENTRY));
            pIconEntry->dwDIBSize = iDataSize - (3 * sizeof(WORD) + sizeof(CURSORICONFILEDIRENTRY));
 
            /* Get the actual bitmap data from the icon bitmap */
            GetDIBits(hDC, infoIcon.hbmColor, 0, pInfoBitmap->bmiHeader.biHeight,
                pIconData + iOffsetColorData, pInfoBitmap, DIB_RGB_COLORS);
            if (iNumEntriesPalette > 0) {
                memcpy(pIconData + iOffsetPalette, pInfoBitmap->bmiColors,
                    iNumEntriesPalette * sizeof(RGBQUAD));
            }
 
            /* Reset all values so that GetDIBits call succeeds */
            memset(pIconData + iOffsetMaskData, 0, iDataSize - iOffsetMaskData);
            memset(pInfoBitmap, 0, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
            pInfoBitmap->bmiHeader.biSize = sizeof(pInfoBitmap->bmiHeader);
/*
            if (!(GetDIBits(hDC, infoIcon.hbmMask, 0, 0, NULL, pInfoBitmap, DIB_RGB_COLORS)
                && GetDIBits(hDC, infoIcon.hbmMask, 0, pIconEntry->bHeight,
                    pIconData + iOffsetMaskData, pInfoBitmap, DIB_RGB_COLORS))) {
 
                printf("ERROR: unable to get bitmap mask (error %u)\n",
                    GetLastError());
 
            }
*/
            GetDIBits(hDC, infoIcon.hbmMask, 0, 0, NULL, pInfoBitmap, DIB_RGB_COLORS);
            GetDIBits(hDC, infoIcon.hbmMask, 0, pIconEntry->bHeight, pIconData + iOffsetMaskData, pInfoBitmap, DIB_RGB_COLORS);
 
            /* Write out everything produced so far to the stream */
            *ppBuffer = pIconData; *pLength = iDataSize;
                        success = TRUE;
        } else {
/*
            printf("ERROR: unable to get bitmap information via GetDIBits() (error %u)\n",
                GetLastError());
*/
        }
        /*
            Remarks (from MSDN entry on GetIconInfo):
 
            GetIconInfo creates bitmaps for the hbmMask and hbmColor
            members of ICONINFO. The calling application must manage
            these bitmaps and delete them when they are no longer
            necessary.
         */
        if (hDC) ReleaseDC(0, hDC);
        DeleteObject(infoIcon.hbmMask);
        if (infoIcon.hbmColor) DeleteObject(infoIcon.hbmColor);
        HeapFree(GetProcessHeap(), 0, pInfoBitmap);
    } else {
        printf("ERROR: Unable to get icon information (error %u)\n",
            GetLastError());
    }
        return success;
}

Referenced by OLEPictureImpl_Save(), and OLEPictureImpl_SaveAsFile().

SPCF_AddRef()

static ULONG WINAPI SPCF_AddRef ( LPCLASSFACTORY  iface )

static

Definition at line 2584 of file olepicture.c.

                                  {
    IClassFactoryImpl *This = impl_from_IClassFactory(iface);
    return InterlockedIncrement(&This->ref);
}

SPCF_CreateInstance()

static HRESULT WINAPI SPCF_CreateInstance ( LPCLASSFACTORY  iface, LPUNKNOWN  pOuter, REFIID  riid, LPVOID *  ppobj  )

static

Definition at line 2595 of file olepicture.c.

  {
    /* Creates an uninitialized picture */
    return OleCreatePictureIndirect(NULL,riid,TRUE,ppobj);
 
}

SPCF_LockServer()

static HRESULT WINAPI SPCF_LockServer ( LPCLASSFACTORY  iface, BOOL  dolock  )

static

Definition at line 2603 of file olepicture.c.

                                                                        {
    IClassFactoryImpl *This = impl_from_IClassFactory(iface);
    FIXME("(%p)->(%d),stub!\n",This,dolock);
    return S_OK;
}

SPCF_QueryInterface()

static HRESULT WINAPI SPCF_QueryInterface ( LPCLASSFACTORY  iface, REFIID  riid, LPVOID *  ppobj  )

static

Definition at line 2576 of file olepicture.c.

                                                                    {
    IClassFactoryImpl *This = impl_from_IClassFactory(iface);
 
    FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
    return E_NOINTERFACE;
}

SPCF_Release()

static ULONG WINAPI SPCF_Release ( LPCLASSFACTORY  iface )

static

Definition at line 2589 of file olepicture.c.

                                                       {
    IClassFactoryImpl *This = impl_from_IClassFactory(iface);
    /* static class, won't be  freed */
    return InterlockedDecrement(&This->ref);
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

olepicture

)

xpixels_to_himetric()

static OLE_XSIZE_HIMETRIC xpixels_to_himetric ( INT  pixels, HDC  hdc  )

inlinestatic

Definition at line 185 of file olepicture.c.

{
    return MulDiv(pixels, 2540, GetDeviceCaps(hdc, LOGPIXELSX));
}

Referenced by OLEPictureImpl_LoadIcon(), OLEPictureImpl_SetBitmap(), and OLEPictureImpl_SetIcon().

ypixels_to_himetric()

static OLE_YSIZE_HIMETRIC ypixels_to_himetric ( INT  pixels, HDC  hdc  )

inlinestatic

Definition at line 190 of file olepicture.c.

{
    return MulDiv(pixels, 2540, GetDeviceCaps(hdc, LOGPIXELSY));
}

Referenced by OLEPictureImpl_LoadIcon(), OLEPictureImpl_SetBitmap(), and OLEPictureImpl_SetIcon().

Variable Documentation

OLEPictureImpl_IConnectionPointContainer_VTable

static const IConnectionPointContainerVtbl OLEPictureImpl_IConnectionPointContainer_VTable

static

Initial value:

=
{
  OLEPictureImpl_IConnectionPointContainer_QueryInterface,
  OLEPictureImpl_IConnectionPointContainer_AddRef,
  OLEPictureImpl_IConnectionPointContainer_Release,
  OLEPictureImpl_EnumConnectionPoints,
  OLEPictureImpl_FindConnectionPoint
}

Definition at line 182 of file olepicture.c.

Referenced by OLEPictureImpl_Construct().

OLEPictureImpl_IDispatch_VTable

static const IDispatchVtbl OLEPictureImpl_IDispatch_VTable

static

Initial value:

=
{
  OLEPictureImpl_IDispatch_QueryInterface,
  OLEPictureImpl_IDispatch_AddRef,
  OLEPictureImpl_IDispatch_Release,
  OLEPictureImpl_GetTypeInfoCount,
  OLEPictureImpl_GetTypeInfo,
  OLEPictureImpl_GetIDsOfNames,
  OLEPictureImpl_Invoke
}

Definition at line 180 of file olepicture.c.

Referenced by OLEPictureImpl_Construct().

OLEPictureImpl_IPersistStream_VTable

static const IPersistStreamVtbl OLEPictureImpl_IPersistStream_VTable

static

Initial value:

=
{
  OLEPictureImpl_IPersistStream_QueryInterface,
  OLEPictureImpl_IPersistStream_AddRef,
  OLEPictureImpl_IPersistStream_Release,
  OLEPictureImpl_GetClassID,
  OLEPictureImpl_IsDirty,
  OLEPictureImpl_Load,
  OLEPictureImpl_Save,
  OLEPictureImpl_GetSizeMax
}

Definition at line 181 of file olepicture.c.

Referenced by OLEPictureImpl_Construct().

OLEPictureImpl_VTable

static const IPictureVtbl OLEPictureImpl_VTable

static

Initial value:

=
{
  OLEPictureImpl_QueryInterface,
  OLEPictureImpl_AddRef,
  OLEPictureImpl_Release,
  OLEPictureImpl_get_Handle,
  OLEPictureImpl_get_hPal,
  OLEPictureImpl_get_Type,
  OLEPictureImpl_get_Width,
  OLEPictureImpl_get_Height,
  OLEPictureImpl_Render,
  OLEPictureImpl_set_hPal,
  OLEPictureImpl_get_CurDC,
  OLEPictureImpl_SelectPicture,
  OLEPictureImpl_get_KeepOriginalFormat,
  OLEPictureImpl_put_KeepOriginalFormat,
  OLEPictureImpl_PictureChanged,
  OLEPictureImpl_SaveAsFile,
  OLEPictureImpl_get_Attributes
}

Definition at line 179 of file olepicture.c.

Referenced by OLEPictureImpl_Construct().

SPCF_Vtbl

const IClassFactoryVtbl SPCF_Vtbl

static

Initial value:

= {
    SPCF_QueryInterface,
    SPCF_AddRef,
    SPCF_Release,
    SPCF_CreateInstance,
    SPCF_LockServer
}

Definition at line 2609 of file olepicture.c.

STDPIC_CF

IClassFactoryImpl STDPIC_CF = {{&SPCF_Vtbl}, 1 }

static

Definition at line 2616 of file olepicture.c.

Referenced by _get_STDPIC_CF().