reactos/lib/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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 "winreg.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  38
  39 #define MAX_CLIPFORMAT_NAME   80
  40
  41 /******************************************************************************
  42  *              OleQueryCreateFromData [OLE32.@]
  43  *
  44  * Author   : Abey George
  45  * Checks whether an object can become an embedded object.
  46  * the clipboard or OLE drag and drop.
  47  * Returns  : S_OK - Format that supports Embedded object creation are present.
  48  *            OLE_E_STATIC - Format that supports static object creation are present.
  49  *            S_FALSE - No acceptable format is available.
  50  */
  51
  52 HRESULT WINAPI OleQueryCreateFromData(LPDATAOBJECT pSrcDataObject)
  53 {
  54   IEnumFORMATETC *pfmt;
  55   FORMATETC fmt;
  56   CHAR szFmtName[MAX_CLIPFORMAT_NAME];
  57   BOOL bFoundStatic = FALSE;
  58
  59   HRESULT hr = IDataObject_EnumFormatEtc(pSrcDataObject, DATADIR_GET, &pfmt);
  60
  61   if (hr == S_OK)
  62     hr = IEnumFORMATETC_Next(pfmt, 1, &fmt, NULL);
  63
  64   while (hr == S_OK)
  65   {
  66     GetClipboardFormatNameA(fmt.cfFormat, szFmtName, MAX_CLIPFORMAT_NAME-1);
  67
  68     /* first, Check for Embedded Object, Embed Source or Filename */
  69
  70     if (!strcmp(szFmtName, CF_EMBEDDEDOBJECT) || !strcmp(szFmtName, CF_EMBEDSOURCE) || !strcmp(szFmtName, CF_FILENAME))
  71       return S_OK;
  72
  73     /* Check for Metafile, Bitmap or DIB */
  74
  75     if (fmt.cfFormat == CF_METAFILEPICT || fmt.cfFormat == CF_BITMAP || fmt.cfFormat == CF_DIB)
  76       bFoundStatic = TRUE;
  77
  78     hr = IEnumFORMATETC_Next(pfmt, 1, &fmt, NULL);
  79   }
  80
  81   /* Found a static format, but no embed format */
  82
  83   if (bFoundStatic)
  84     return OLE_S_STATIC;
  85
  86   return S_FALSE;
  87 }
  88
  89 /******************************************************************************
  90  *              OleCreateFromData        [OLE32.@]
  91  *
  92  * Author   : Abey George
  93  * Creates an embedded object from data transfer object retrieved from
  94  * the clipboard or OLE drag and drop.
  95  * Returns  : S_OK - Embedded object was created successfully.
  96  *            OLE_E_STATIC - OLE can create only a static object
  97  *            DV_E_FORMATETC - No acceptable format is available (only error return code)
  98  * TODO : CF_FILENAME, CF_EMBEDEDOBJECT formats. Parameter renderopt is currently ignored.
  99  */
 100
 101 HRESULT WINAPI OleCreateFromData(LPDATAOBJECT pSrcDataObject, REFIID riid,
 102                 DWORD renderopt, LPFORMATETC pFormatEtc,
 103                 LPOLECLIENTSITE pClientSite, LPSTORAGE pStg,
 104                 LPVOID* ppvObj)
 105 {
 106   IEnumFORMATETC *pfmt;
 107   FORMATETC fmt;
 108   CHAR szFmtName[MAX_CLIPFORMAT_NAME];
 109   STGMEDIUM std;
 110   HRESULT hr;
 111   HRESULT hr1;
 112
 113   hr = IDataObject_EnumFormatEtc(pSrcDataObject, DATADIR_GET, &pfmt);
 114
 115   if (hr == S_OK)
 116   {
 117     memset(&std, 0, sizeof(STGMEDIUM));
 118
 119     hr = IEnumFORMATETC_Next(pfmt, 1, &fmt, NULL);
 120     while (hr == S_OK)
 121     {
 122       GetClipboardFormatNameA(fmt.cfFormat, szFmtName, MAX_CLIPFORMAT_NAME-1);
 123
 124       /* first, Check for Embedded Object, Embed Source or Filename */
 125       /* TODO: Currently checks only for Embed Source. */
 126
 127       if (!strcmp(szFmtName, CF_EMBEDSOURCE))
 128       {
 129         std.tymed = TYMED_HGLOBAL;
 130
 131         if ((hr1 = IDataObject_GetData(pSrcDataObject, &fmt, &std)) == S_OK)
 132         {
 133           ILockBytes *ptrILockBytes = 0;
 134           IStorage *pStorage = 0;
 135           IOleObject *pOleObject = 0;
 136           IPersistStorage *pPersistStorage = 0;
 137           CLSID clsID;
 138
 139           /* Create ILock bytes */
 140
 141           hr1 = CreateILockBytesOnHGlobal(std.u.hGlobal, FALSE, &ptrILockBytes);
 142
 143           /* Open storage on the ILock bytes */
 144
 145           if (hr1 == S_OK)
 146             hr1 = StgOpenStorageOnILockBytes(ptrILockBytes, NULL, STGM_SHARE_EXCLUSIVE, NULL, 0, &pStorage);
 147
 148           /* Get Class ID from the opened storage */
 149
 150           if (hr1 == S_OK)
 151             hr1 = ReadClassStg(pStorage, &clsID);
 152
 153           /* Create default handler for Persist storage */
 154
 155           if (hr1 == S_OK)
 156             hr1 = OleCreateDefaultHandler(&clsID, NULL, &IID_IPersistStorage, (LPVOID*)&pPersistStorage);
 157
 158           /* Load the storage to Persist storage */
 159
 160           if (hr1 == S_OK)
 161             hr1 = IPersistStorage_Load(pPersistStorage, pStorage);
 162
 163           /* Query for IOleObject */
 164
 165           if (hr1 == S_OK)
 166             hr1 = IPersistStorage_QueryInterface(pPersistStorage, &IID_IOleObject, (LPVOID*)&pOleObject);
 167
 168           /* Set client site with the IOleObject */
 169
 170           if (hr1 == S_OK)
 171             hr1 = IOleObject_SetClientSite(pOleObject, pClientSite);
 172
 173           IPersistStorage_Release(pPersistStorage);
 174           /* Query for the requested interface */
 175
 176           if (hr1 == S_OK)
 177             hr1 = IPersistStorage_QueryInterface(pPersistStorage, riid, ppvObj);
 178
 179           IPersistStorage_Release(pPersistStorage);
 180
 181           IStorage_Release(pStorage);
 182
 183           if (hr1 == S_OK)
 184             return S_OK;
 185         }
 186
 187         /* Return error */
 188
 189         return DV_E_FORMATETC;
 190       }
 191
 192       hr = IEnumFORMATETC_Next(pfmt, 1, &fmt, NULL);
 193     }
 194   }
 195
 196   return DV_E_FORMATETC;
 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 }