dlls/ole32/ole2impl.c

   1 /*
   2  * Ole 2 Create functions implementation
   3  *
   4  * Copyright (C) 1999-2000 Abey George
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22 #include <string.h>
  23
  24 #define COBJMACROS
  25 #define NONAMELESSUNION
  26 #define NONAMELESSSTRUCT
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "wingdi.h"
  31 #include "winuser.h"
  32 #include "wine/debug.h"
  33 #include "ole2.h"
  34 #include "olestd.h"
  35 #include "compobj_private.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  38
  39 #define MAX_CLIPFORMAT_NAME   80
  40
  41 /******************************************************************************
  42  *              OleQueryCreateFromData [OLE32.@]
  43  *
  44  * Checks whether an object can become an embedded object.
  45  * the clipboard or OLE drag and drop.
  46  * Returns  : S_OK - Format that supports Embedded object creation are present.
  47  *            OLE_E_STATIC - Format that supports static object creation are present.
  48  *            S_FALSE - No acceptable format is available.
  49  */
  50
  51 HRESULT WINAPI OleQueryCreateFromData(IDataObject *data)
  52 {
  53     IEnumFORMATETC *enum_fmt;
  54     FORMATETC fmt;
  55     BOOL found_static = FALSE;
  56     HRESULT hr;
  57
  58     hr = IDataObject_EnumFormatEtc(data, DATADIR_GET, &enum_fmt);
  59
  60     if(FAILED(hr)) return hr;
  61
  62     do
  63     {
  64         hr = IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL);
  65         if(hr == S_OK)
  66         {
  67             if(fmt.cfFormat == embedded_object_clipboard_format ||
  68                fmt.cfFormat == embed_source_clipboard_format ||
  69                fmt.cfFormat == filename_clipboard_format)
  70             {
  71                 IEnumFORMATETC_Release(enum_fmt);
  72                 return S_OK;
  73             }
  74
  75             if(fmt.cfFormat == CF_METAFILEPICT ||
  76                fmt.cfFormat == CF_BITMAP ||
  77                fmt.cfFormat == CF_DIB)
  78                 found_static = TRUE;
  79         }
  80     } while (hr == S_OK);
  81
  82     IEnumFORMATETC_Release(enum_fmt);
  83
  84     return found_static ? OLE_S_STATIC : S_FALSE;
  85 }
  86
  87 static inline void init_fmtetc(FORMATETC *fmt, CLIPFORMAT cf, TYMED tymed)
  88 {
  89     fmt->cfFormat = cf;
  90     fmt->ptd = NULL;
  91     fmt->dwAspect = DVASPECT_CONTENT;
  92     fmt->lindex = -1;
  93     fmt->tymed = tymed;
  94 }
  95
  96 /***************************************************************************
  97  *         get_storage
  98  *
  99  * Retrieve an object's storage from a variety of sources.
 100  *
 101  * FIXME: CF_FILENAME.
 102  */
 103 static HRESULT get_storage(IDataObject *data, IStorage *stg, UINT *src_cf)
 104 {
 105     HRESULT hr;
 106     FORMATETC fmt;
 107     STGMEDIUM med;
 108     IPersistStorage *persist;
 109     CLSID clsid;
 110
 111     *src_cf = 0;
 112
 113     /* CF_EMBEDEDOBJECT */
 114     init_fmtetc(&fmt, embedded_object_clipboard_format, TYMED_ISTORAGE);
 115     med.tymed = TYMED_ISTORAGE;
 116     med.u.pstg = stg;
 117     hr = IDataObject_GetDataHere(data, &fmt, &med);
 118     if(SUCCEEDED(hr))
 119     {
 120         *src_cf = embedded_object_clipboard_format;
 121         return hr;
 122     }
 123
 124     /* CF_EMBEDSOURCE */
 125     init_fmtetc(&fmt, embed_source_clipboard_format, TYMED_ISTORAGE);
 126     med.tymed = TYMED_ISTORAGE;
 127     med.u.pstg = stg;
 128     hr = IDataObject_GetDataHere(data, &fmt, &med);
 129     if(SUCCEEDED(hr))
 130     {
 131         *src_cf = embed_source_clipboard_format;
 132         return hr;
 133     }
 134
 135     /* IPersistStorage */
 136     hr = IDataObject_QueryInterface(data, &IID_IPersistStorage, (void**)&persist);
 137     if(FAILED(hr)) return hr;
 138
 139     hr = IPersistStorage_GetClassID(persist, &clsid);
 140     if(FAILED(hr)) goto end;
 141
 142     hr = IStorage_SetClass(stg, &clsid);
 143     if(FAILED(hr)) goto end;
 144
 145     hr = IPersistStorage_Save(persist, stg, FALSE);
 146     if(FAILED(hr)) goto end;
 147
 148     hr = IPersistStorage_SaveCompleted(persist, NULL);
 149
 150 end:
 151     IPersistStorage_Release(persist);
 152
 153     return hr;
 154 }
 155
 156 /******************************************************************************
 157  *              OleCreateFromDataEx        [OLE32.@]
 158  *
 159  * Creates an embedded object from data transfer object retrieved from
 160  * the clipboard or OLE drag and drop.
 161  */
 162 HRESULT WINAPI OleCreateFromDataEx(IDataObject *data, REFIID iid, DWORD flags,
 163                                    DWORD renderopt, ULONG num_cache_fmts, DWORD *adv_flags, FORMATETC *cache_fmts,
 164                                    IAdviseSink *sink, DWORD *conns,
 165                                    IOleClientSite *client_site, IStorage *stg, void **obj)
 166 {
 167     HRESULT hr;
 168     UINT src_cf;
 169
 170     FIXME("(%p, %s, %08x, %08x, %d, %p, %p, %p, %p, %p, %p, %p): stub\n",
 171           data, debugstr_guid(iid), flags, renderopt, num_cache_fmts, adv_flags, cache_fmts,
 172           sink, conns, client_site, stg, obj);
 173
 174     hr = get_storage(data, stg, &src_cf);
 175     if(FAILED(hr)) return hr;
 176
 177     hr = OleLoad(stg, iid, client_site, obj);
 178     if(FAILED(hr)) return hr;
 179
 180     /* FIXME: Init cache */
 181
 182     return hr;
 183 }
 184
 185 /******************************************************************************
 186  *              OleCreateFromData        [OLE32.@]
 187  */
 188 HRESULT WINAPI OleCreateFromData(LPDATAOBJECT data, REFIID iid,
 189                                  DWORD renderopt, LPFORMATETC fmt,
 190                                  LPOLECLIENTSITE client_site, LPSTORAGE stg,
 191                                  LPVOID* obj)
 192 {
 193     DWORD advf = ADVF_PRIMEFIRST;
 194
 195     return OleCreateFromDataEx(data, iid, 0, renderopt, fmt ? 1 : 0, fmt ? &advf : NULL,
 196                                fmt, NULL, NULL, client_site, stg, obj);
 197 }
 198
 199
 200 /******************************************************************************
 201  *              OleDuplicateData        [OLE32.@]
 202  *
 203  * Duplicates clipboard data.
 204  *
 205  * PARAMS
 206  *  hSrc     [I] Handle of the source clipboard data.
 207  *  cfFormat [I] The clipboard format of hSrc.
 208  *  uiFlags  [I] Flags to pass to GlobalAlloc.
 209  *
 210  * RETURNS
 211  *  Success: handle to the duplicated data.
 212  *  Failure: NULL.
 213  */
 214 HANDLE WINAPI OleDuplicateData(HANDLE hSrc, CLIPFORMAT cfFormat,
 215                                   UINT uiFlags)
 216 {
 217     HANDLE hDst = NULL;
 218
 219     TRACE("(%p,%x,%x)\n", hSrc, cfFormat, uiFlags);
 220
 221     if (!uiFlags) uiFlags = GMEM_MOVEABLE;
 222
 223     switch (cfFormat)
 224     {
 225     case CF_ENHMETAFILE:
 226         hDst = CopyEnhMetaFileW(hSrc, NULL);
 227         break;
 228     case CF_METAFILEPICT:
 229         hDst = CopyMetaFileW(hSrc, NULL);
 230         break;
 231     case CF_PALETTE:
 232         {
 233             LOGPALETTE * logpalette;
 234             UINT nEntries = GetPaletteEntries(hSrc, 0, 0, NULL);
 235             if (!nEntries) return NULL;
 236             logpalette = HeapAlloc(GetProcessHeap(), 0,
 237                 FIELD_OFFSET(LOGPALETTE, palPalEntry[nEntries]));
 238             if (!logpalette) return NULL;
 239             if (!GetPaletteEntries(hSrc, 0, nEntries, logpalette->palPalEntry))
 240             {
 241                 HeapFree(GetProcessHeap(), 0, logpalette);
 242                 return NULL;
 243             }
 244             logpalette->palVersion = 0x300;
 245             logpalette->palNumEntries = (WORD)nEntries;
 246
 247             hDst = CreatePalette(logpalette);
 248
 249             HeapFree(GetProcessHeap(), 0, logpalette);
 250             break;
 251         }
 252     case CF_BITMAP:
 253         {
 254             LONG size;
 255             BITMAP bm;
 256             if (!GetObjectW(hSrc, sizeof(bm), &bm))
 257                 return NULL;
 258             size = GetBitmapBits(hSrc, 0, NULL);
 259             if (!size) return NULL;
 260             bm.bmBits = HeapAlloc(GetProcessHeap(), 0, size);
 261             if (!bm.bmBits) return NULL;
 262             if (GetBitmapBits(hSrc, size, bm.bmBits))
 263                 hDst = CreateBitmapIndirect(&bm);
 264             HeapFree(GetProcessHeap(), 0, bm.bmBits);
 265             break;
 266         }
 267     default:
 268         {
 269             SIZE_T size = GlobalSize(hSrc);
 270             LPVOID pvSrc = NULL;
 271             LPVOID pvDst = NULL;
 272
 273             /* allocate space for object */
 274             if (!size) return NULL;
 275             hDst = GlobalAlloc(uiFlags, size);
 276             if (!hDst) return NULL;
 277
 278             /* lock pointers */
 279             pvSrc = GlobalLock(hSrc);
 280             if (!pvSrc)
 281             {
 282                 GlobalFree(hDst);
 283                 return NULL;
 284             }
 285             pvDst = GlobalLock(hDst);
 286             if (!pvDst)
 287             {
 288                 GlobalUnlock(hSrc);
 289                 GlobalFree(hDst);
 290                 return NULL;
 291             }
 292             /* copy data */
 293             memcpy(pvDst, pvSrc, size);
 294
 295             /* cleanup */
 296             GlobalUnlock(hDst);
 297             GlobalUnlock(hSrc);
 298         }
 299     }
 300
 301     TRACE("returning %p\n", hDst);
 302     return hDst;
 303 }