reactos/dll/win32/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 "precomp.h"
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  24
  25 #define MAX_CLIPFORMAT_NAME   80
  26
  27 /******************************************************************************
  28  *              OleQueryCreateFromData [OLE32.@]
  29  *
  30  * Checks whether an object can become an embedded object.
  31  * the clipboard or OLE drag and drop.
  32  * Returns  : S_OK - Format that supports Embedded object creation are present.
  33  *            OLE_E_STATIC - Format that supports static object creation are present.
  34  *            S_FALSE - No acceptable format is available.
  35  */
  36
  37 HRESULT WINAPI OleQueryCreateFromData(IDataObject *data)
  38 {
  39     IEnumFORMATETC *enum_fmt;
  40     FORMATETC fmt;
  41     BOOL found_static = FALSE;
  42     HRESULT hr;
  43
  44     hr = IDataObject_EnumFormatEtc(data, DATADIR_GET, &enum_fmt);
  45
  46     if(FAILED(hr)) return hr;
  47
  48     do
  49     {
  50         hr = IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL);
  51         if(hr == S_OK)
  52         {
  53             if(fmt.cfFormat == embedded_object_clipboard_format ||
  54                fmt.cfFormat == embed_source_clipboard_format ||
  55                fmt.cfFormat == filename_clipboard_format)
  56             {
  57                 IEnumFORMATETC_Release(enum_fmt);
  58                 return S_OK;
  59             }
  60
  61             if(fmt.cfFormat == CF_METAFILEPICT ||
  62                fmt.cfFormat == CF_BITMAP ||
  63                fmt.cfFormat == CF_DIB)
  64                 found_static = TRUE;
  65         }
  66     } while (hr == S_OK);
  67
  68     IEnumFORMATETC_Release(enum_fmt);
  69
  70     return found_static ? OLE_S_STATIC : S_FALSE;
  71 }
  72
  73 static inline void init_fmtetc(FORMATETC *fmt, CLIPFORMAT cf, TYMED tymed)
  74 {
  75     fmt->cfFormat = cf;
  76     fmt->ptd = NULL;
  77     fmt->dwAspect = DVASPECT_CONTENT;
  78     fmt->lindex = -1;
  79     fmt->tymed = tymed;
  80 }
  81
  82 /***************************************************************************
  83  *         get_storage
  84  *
  85  * Retrieve an object's storage from a variety of sources.
  86  *
  87  * FIXME: CF_FILENAME.
  88  */
  89 static HRESULT get_storage(IDataObject *data, IStorage *stg, UINT *src_cf)
  90 {
  91     static const UINT fmt_id[] = { CF_METAFILEPICT, CF_BITMAP, CF_DIB };
  92     UINT i;
  93     HRESULT hr;
  94     FORMATETC fmt;
  95     STGMEDIUM med;
  96     IPersistStorage *persist;
  97     CLSID clsid;
  98
  99     *src_cf = 0;
 100
 101     /* CF_EMBEDEDOBJECT */
 102     init_fmtetc(&fmt, embedded_object_clipboard_format, TYMED_ISTORAGE);
 103     med.tymed = TYMED_ISTORAGE;
 104     med.u.pstg = stg;
 105     hr = IDataObject_GetDataHere(data, &fmt, &med);
 106     if(SUCCEEDED(hr))
 107     {
 108         *src_cf = embedded_object_clipboard_format;
 109         return hr;
 110     }
 111
 112     /* CF_EMBEDSOURCE */
 113     init_fmtetc(&fmt, embed_source_clipboard_format, TYMED_ISTORAGE);
 114     med.tymed = TYMED_ISTORAGE;
 115     med.u.pstg = stg;
 116     hr = IDataObject_GetDataHere(data, &fmt, &med);
 117     if(SUCCEEDED(hr))
 118     {
 119         *src_cf = embed_source_clipboard_format;
 120         return hr;
 121     }
 122
 123     for (i = 0; i < sizeof(fmt_id)/sizeof(fmt_id[0]); i++)
 124     {
 125         init_fmtetc(&fmt, fmt_id[i], TYMED_ISTORAGE);
 126         hr = IDataObject_QueryGetData(data, &fmt);
 127         if(SUCCEEDED(hr))
 128         {
 129             *src_cf = fmt_id[i];
 130             return hr;
 131         }
 132     }
 133
 134     /* IPersistStorage */
 135     hr = IDataObject_QueryInterface(data, &IID_IPersistStorage, (void**)&persist);
 136     if(FAILED(hr)) return hr;
 137
 138     hr = IPersistStorage_GetClassID(persist, &clsid);
 139     if(FAILED(hr)) goto end;
 140
 141     hr = IStorage_SetClass(stg, &clsid);
 142     if(FAILED(hr)) goto end;
 143
 144     hr = IPersistStorage_Save(persist, stg, FALSE);
 145     if(FAILED(hr)) goto end;
 146
 147     hr = IPersistStorage_SaveCompleted(persist, NULL);
 148
 149 end:
 150     IPersistStorage_Release(persist);
 151
 152     return hr;
 153 }
 154
 155 /******************************************************************************
 156  *              OleCreateFromDataEx        [OLE32.@]
 157  *
 158  * Creates an embedded object from data transfer object retrieved from
 159  * the clipboard or OLE drag and drop.
 160  */
 161 HRESULT WINAPI OleCreateFromDataEx(IDataObject *data, REFIID iid, DWORD flags,
 162                                    DWORD renderopt, ULONG num_cache_fmts, DWORD *adv_flags, FORMATETC *cache_fmts,
 163                                    IAdviseSink *sink, DWORD *conns,
 164                                    IOleClientSite *client_site, IStorage *stg, void **obj)
 165 {
 166     HRESULT hr;
 167     UINT src_cf;
 168
 169     FIXME("(%p, %s, %08x, %08x, %d, %p, %p, %p, %p, %p, %p, %p): stub\n",
 170           data, debugstr_guid(iid), flags, renderopt, num_cache_fmts, adv_flags, cache_fmts,
 171           sink, conns, client_site, stg, obj);
 172
 173     hr = get_storage(data, stg, &src_cf);
 174     if(FAILED(hr)) return hr;
 175
 176     hr = OleLoad(stg, iid, client_site, obj);
 177     if(FAILED(hr)) return hr;
 178
 179     /* FIXME: Init cache */
 180
 181     return hr;
 182 }
 183
 184 /******************************************************************************
 185  *              OleCreateFromData        [OLE32.@]
 186  */
 187 HRESULT WINAPI OleCreateFromData(LPDATAOBJECT data, REFIID iid,
 188                                  DWORD renderopt, LPFORMATETC fmt,
 189                                  LPOLECLIENTSITE client_site, LPSTORAGE stg,
 190                                  LPVOID* obj)
 191 {
 192     DWORD advf = ADVF_PRIMEFIRST;
 193
 194     return OleCreateFromDataEx(data, iid, 0, renderopt, fmt ? 1 : 0, fmt ? &advf : NULL,
 195                                fmt, NULL, NULL, client_site, stg, obj);
 196 }
 197
 198 /******************************************************************************
 199  *              OleCreateLinkFromData        [OLE32.@]
 200  */
 201 HRESULT WINAPI OleCreateLinkFromData(IDataObject *data, REFIID iid,
 202                                      DWORD renderopt, FORMATETC *fmt,
 203                                      IOleClientSite *client_site, IStorage *stg,
 204                                      void **obj)
 205 {
 206     FIXME("%p,%s,%08x,%p,%p,%p,%p: semi-stub\n",
 207           data, debugstr_guid(iid), renderopt, fmt, client_site, stg, obj);
 208     return OleCreateFromData(data, iid, renderopt, fmt, client_site, stg, obj);
 209 }
 210
 211 /******************************************************************************
 212  *              OleCreateStaticFromData        [OLE32.@]
 213  */
 214 HRESULT WINAPI OleCreateStaticFromData(IDataObject *data, REFIID iid,
 215                                        DWORD renderopt, FORMATETC *fmt,
 216                                        IOleClientSite *client_site, IStorage *stg,
 217                                        void **obj)
 218 {
 219     FIXME("%p,%s,%08x,%p,%p,%p,%p: semi-stub\n",
 220           data, debugstr_guid(iid), renderopt, fmt, client_site, stg, obj);
 221     return OleCreateFromData(data, iid, renderopt, fmt, client_site, stg, obj);
 222 }
 223
 224 /******************************************************************************
 225  *              OleDuplicateData        [OLE32.@]
 226  *
 227  * Duplicates clipboard data.
 228  *
 229  * PARAMS
 230  *  hSrc     [I] Handle of the source clipboard data.
 231  *  cfFormat [I] The clipboard format of hSrc.
 232  *  uiFlags  [I] Flags to pass to GlobalAlloc.
 233  *
 234  * RETURNS
 235  *  Success: handle to the duplicated data.
 236  *  Failure: NULL.
 237  */
 238 HANDLE WINAPI OleDuplicateData(HANDLE hSrc, CLIPFORMAT cfFormat,
 239                                   UINT uiFlags)
 240 {
 241     HANDLE hDst = NULL;
 242
 243     TRACE("(%p,%x,%x)\n", hSrc, cfFormat, uiFlags);
 244
 245     if (!uiFlags) uiFlags = GMEM_MOVEABLE;
 246
 247     switch (cfFormat)
 248     {
 249     case CF_ENHMETAFILE:
 250         hDst = CopyEnhMetaFileW(hSrc, NULL);
 251         break;
 252     case CF_METAFILEPICT:
 253         hDst = CopyMetaFileW(hSrc, NULL);
 254         break;
 255     case CF_PALETTE:
 256         {
 257             LOGPALETTE * logpalette;
 258             UINT nEntries = GetPaletteEntries(hSrc, 0, 0, NULL);
 259             if (!nEntries) return NULL;
 260             logpalette = HeapAlloc(GetProcessHeap(), 0,
 261                 FIELD_OFFSET(LOGPALETTE, palPalEntry[nEntries]));
 262             if (!logpalette) return NULL;
 263             if (!GetPaletteEntries(hSrc, 0, nEntries, logpalette->palPalEntry))
 264             {
 265                 HeapFree(GetProcessHeap(), 0, logpalette);
 266                 return NULL;
 267             }
 268             logpalette->palVersion = 0x300;
 269             logpalette->palNumEntries = (WORD)nEntries;
 270
 271             hDst = CreatePalette(logpalette);
 272
 273             HeapFree(GetProcessHeap(), 0, logpalette);
 274             break;
 275         }
 276     case CF_BITMAP:
 277         {
 278             LONG size;
 279             BITMAP bm;
 280             if (!GetObjectW(hSrc, sizeof(bm), &bm))
 281                 return NULL;
 282             size = GetBitmapBits(hSrc, 0, NULL);
 283             if (!size) return NULL;
 284             bm.bmBits = HeapAlloc(GetProcessHeap(), 0, size);
 285             if (!bm.bmBits) return NULL;
 286             if (GetBitmapBits(hSrc, size, bm.bmBits))
 287                 hDst = CreateBitmapIndirect(&bm);
 288             HeapFree(GetProcessHeap(), 0, bm.bmBits);
 289             break;
 290         }
 291     default:
 292         {
 293             SIZE_T size = GlobalSize(hSrc);
 294             LPVOID pvSrc = NULL;
 295             LPVOID pvDst = NULL;
 296
 297             /* allocate space for object */
 298             if (!size) return NULL;
 299             hDst = GlobalAlloc(uiFlags, size);
 300             if (!hDst) return NULL;
 301
 302             /* lock pointers */
 303             pvSrc = GlobalLock(hSrc);
 304             if (!pvSrc)
 305             {
 306                 GlobalFree(hDst);
 307                 return NULL;
 308             }
 309             pvDst = GlobalLock(hDst);
 310             if (!pvDst)
 311             {
 312                 GlobalUnlock(hSrc);
 313                 GlobalFree(hDst);
 314                 return NULL;
 315             }
 316             /* copy data */
 317             memcpy(pvDst, pvSrc, size);
 318
 319             /* cleanup */
 320             GlobalUnlock(hDst);
 321             GlobalUnlock(hSrc);
 322         }
 323     }
 324
 325     TRACE("returning %p\n", hDst);
 326     return hDst;
 327 }