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 /******************************************************************************
  88  *              OleCreateFromDataEx        [OLE32.@]
  89  *
  90  * Creates an embedded object from data transfer object retrieved from
  91  * the clipboard or OLE drag and drop.
  92  */
  93 HRESULT WINAPI OleCreateFromDataEx(IDataObject *data, REFIID iid, DWORD flags,
  94                                    DWORD renderopt, ULONG num_fmts, DWORD *adv_flags, FORMATETC *fmts,
  95                                    IAdviseSink *sink, DWORD *conns,
  96                                    IOleClientSite *client_site, IStorage *stg, void **obj)
  97 {
  98     FIXME("(%p, %s, %08x, %08x, %d, %p, %p, %p, %p, %p, %p, %p): stub\n",
  99           data, debugstr_guid(iid), flags, renderopt, num_fmts, adv_flags, fmts,
 100           sink, conns, client_site, stg, obj);
 101
 102     return E_NOTIMPL;
 103 }
 104
 105 /******************************************************************************
 106  *              OleCreateFromData        [OLE32.@]
 107  *
 108  * Author   : Abey George
 109  * Creates an embedded object from data transfer object retrieved from
 110  * the clipboard or OLE drag and drop.
 111  * Returns  : S_OK - Embedded object was created successfully.
 112  *            OLE_E_STATIC - OLE can create only a static object
 113  *            DV_E_FORMATETC - No acceptable format is available (only error return code)
 114  * TODO : CF_FILENAME, CF_EMBEDEDOBJECT formats. Parameter renderopt is currently ignored.
 115  */
 116
 117 HRESULT WINAPI OleCreateFromData(LPDATAOBJECT pSrcDataObject, REFIID riid,
 118                 DWORD renderopt, LPFORMATETC pFormatEtc,
 119                 LPOLECLIENTSITE pClientSite, LPSTORAGE pStg,
 120                 LPVOID* ppvObj)
 121 {
 122   IEnumFORMATETC *pfmt;
 123   FORMATETC fmt;
 124   CHAR szFmtName[MAX_CLIPFORMAT_NAME];
 125   STGMEDIUM std;
 126   HRESULT hr;
 127   HRESULT hr1;
 128
 129   hr = IDataObject_EnumFormatEtc(pSrcDataObject, DATADIR_GET, &pfmt);
 130
 131   if (hr == S_OK)
 132   {
 133     memset(&std, 0, sizeof(STGMEDIUM));
 134
 135     hr = IEnumFORMATETC_Next(pfmt, 1, &fmt, NULL);
 136     while (hr == S_OK)
 137     {
 138       GetClipboardFormatNameA(fmt.cfFormat, szFmtName, MAX_CLIPFORMAT_NAME-1);
 139
 140       /* first, Check for Embedded Object, Embed Source or Filename */
 141       /* TODO: Currently checks only for Embed Source. */
 142
 143       if (!strcmp(szFmtName, CF_EMBEDSOURCE))
 144       {
 145         std.tymed = TYMED_HGLOBAL;
 146
 147         if ((hr1 = IDataObject_GetData(pSrcDataObject, &fmt, &std)) == S_OK)
 148         {
 149           ILockBytes *ptrILockBytes = 0;
 150           IStorage *pStorage = 0;
 151           IOleObject *pOleObject = 0;
 152           IPersistStorage *pPersistStorage = 0;
 153           CLSID clsID;
 154
 155           /* Create ILock bytes */
 156
 157           hr1 = CreateILockBytesOnHGlobal(std.u.hGlobal, FALSE, &ptrILockBytes);
 158
 159           /* Open storage on the ILock bytes */
 160
 161           if (hr1 == S_OK)
 162             hr1 = StgOpenStorageOnILockBytes(ptrILockBytes, NULL, STGM_SHARE_EXCLUSIVE, NULL, 0, &pStorage);
 163
 164           /* Get Class ID from the opened storage */
 165
 166           if (hr1 == S_OK)
 167             hr1 = ReadClassStg(pStorage, &clsID);
 168
 169           /* Create default handler for Persist storage */
 170
 171           if (hr1 == S_OK)
 172             hr1 = OleCreateDefaultHandler(&clsID, NULL, &IID_IPersistStorage, (LPVOID*)&pPersistStorage);
 173
 174           /* Load the storage to Persist storage */
 175
 176           if (hr1 == S_OK)
 177             hr1 = IPersistStorage_Load(pPersistStorage, pStorage);
 178
 179           /* Query for IOleObject */
 180
 181           if (hr1 == S_OK)
 182             hr1 = IPersistStorage_QueryInterface(pPersistStorage, &IID_IOleObject, (LPVOID*)&pOleObject);
 183
 184           /* Set client site with the IOleObject */
 185
 186           if (hr1 == S_OK)
 187             hr1 = IOleObject_SetClientSite(pOleObject, pClientSite);
 188
 189           IPersistStorage_Release(pPersistStorage);
 190           /* Query for the requested interface */
 191
 192           if (hr1 == S_OK)
 193             hr1 = IPersistStorage_QueryInterface(pPersistStorage, riid, ppvObj);
 194
 195           IPersistStorage_Release(pPersistStorage);
 196
 197           IStorage_Release(pStorage);
 198
 199           if (hr1 == S_OK)
 200             return S_OK;
 201         }
 202
 203         /* Return error */
 204
 205         return DV_E_FORMATETC;
 206       }
 207
 208       hr = IEnumFORMATETC_Next(pfmt, 1, &fmt, NULL);
 209     }
 210   }
 211
 212   return DV_E_FORMATETC;
 213 }
 214
 215
 216 /******************************************************************************
 217  *              OleDuplicateData        [OLE32.@]
 218  *
 219  * Duplicates clipboard data.
 220  *
 221  * PARAMS
 222  *  hSrc     [I] Handle of the source clipboard data.
 223  *  cfFormat [I] The clipboard format of hSrc.
 224  *  uiFlags  [I] Flags to pass to GlobalAlloc.
 225  *
 226  * RETURNS
 227  *  Success: handle to the duplicated data.
 228  *  Failure: NULL.
 229  */
 230 HANDLE WINAPI OleDuplicateData(HANDLE hSrc, CLIPFORMAT cfFormat,
 231                                   UINT uiFlags)
 232 {
 233     HANDLE hDst = NULL;
 234
 235     TRACE("(%p,%x,%x)\n", hSrc, cfFormat, uiFlags);
 236
 237     if (!uiFlags) uiFlags = GMEM_MOVEABLE;
 238
 239     switch (cfFormat)
 240     {
 241     case CF_ENHMETAFILE:
 242         hDst = CopyEnhMetaFileW(hSrc, NULL);
 243         break;
 244     case CF_METAFILEPICT:
 245         hDst = CopyMetaFileW(hSrc, NULL);
 246         break;
 247     case CF_PALETTE:
 248         {
 249             LOGPALETTE * logpalette;
 250             UINT nEntries = GetPaletteEntries(hSrc, 0, 0, NULL);
 251             if (!nEntries) return NULL;
 252             logpalette = HeapAlloc(GetProcessHeap(), 0,
 253                 FIELD_OFFSET(LOGPALETTE, palPalEntry[nEntries]));
 254             if (!logpalette) return NULL;
 255             if (!GetPaletteEntries(hSrc, 0, nEntries, logpalette->palPalEntry))
 256             {
 257                 HeapFree(GetProcessHeap(), 0, logpalette);
 258                 return NULL;
 259             }
 260             logpalette->palVersion = 0x300;
 261             logpalette->palNumEntries = (WORD)nEntries;
 262
 263             hDst = CreatePalette(logpalette);
 264
 265             HeapFree(GetProcessHeap(), 0, logpalette);
 266             break;
 267         }
 268     case CF_BITMAP:
 269         {
 270             LONG size;
 271             BITMAP bm;
 272             if (!GetObjectW(hSrc, sizeof(bm), &bm))
 273                 return NULL;
 274             size = GetBitmapBits(hSrc, 0, NULL);
 275             if (!size) return NULL;
 276             bm.bmBits = HeapAlloc(GetProcessHeap(), 0, size);
 277             if (!bm.bmBits) return NULL;
 278             if (GetBitmapBits(hSrc, size, bm.bmBits))
 279                 hDst = CreateBitmapIndirect(&bm);
 280             HeapFree(GetProcessHeap(), 0, bm.bmBits);
 281             break;
 282         }
 283     default:
 284         {
 285             SIZE_T size = GlobalSize(hSrc);
 286             LPVOID pvSrc = NULL;
 287             LPVOID pvDst = NULL;
 288
 289             /* allocate space for object */
 290             if (!size) return NULL;
 291             hDst = GlobalAlloc(uiFlags, size);
 292             if (!hDst) return NULL;
 293
 294             /* lock pointers */
 295             pvSrc = GlobalLock(hSrc);
 296             if (!pvSrc)
 297             {
 298                 GlobalFree(hDst);
 299                 return NULL;
 300             }
 301             pvDst = GlobalLock(hDst);
 302             if (!pvDst)
 303             {
 304                 GlobalUnlock(hSrc);
 305                 GlobalFree(hDst);
 306                 return NULL;
 307             }
 308             /* copy data */
 309             memcpy(pvDst, pvSrc, size);
 310
 311             /* cleanup */
 312             GlobalUnlock(hDst);
 313             GlobalUnlock(hSrc);
 314         }
 315     }
 316
 317     TRACE("returning %p\n", hDst);
 318     return hDst;
 319 }