wined3d: Pack hardcoded local constants in ARB.
[wine] / 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 }