winealsa: Use "default" as the default card name instead of "default:0".
[wine] / dlls / riched20 / richole.c
1 /*
2  * RichEdit GUIDs and OLE interface
3  *
4  * Copyright 2004 by Krzysztof Foltman
5  * Copyright 2004 Aric Stewart
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 #include <stdarg.h>
23
24 #define NONAMELESSUNION
25 #define NONAMELESSSTRUCT
26 #define COBJMACROS
27
28 #include "windef.h"
29 #include "winbase.h"
30 #include "wingdi.h"
31 #include "winuser.h"
32 #include "ole2.h"
33 #include "richole.h"
34 #include "editor.h"
35 #include "tom.h"
36 #include "wine/debug.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(richedit);
39
40 /* there is no way to be consistent across different sets of headers - mingw, Wine, Win32 SDK*/
41
42 /* FIXME: the next 6 lines should be in textserv.h */
43 #include "initguid.h"
44 #define TEXTSERV_GUID(name, l, w1, w2, b1, b2) \
45     DEFINE_GUID(name, l, w1, w2, b1, b2, 0x00, 0xaa, 0x00, 0x6c, 0xad, 0xc5)
46
47 TEXTSERV_GUID(IID_ITextServices, 0x8d33f740, 0xcf58, 0x11ce, 0xa8, 0x9d);
48 TEXTSERV_GUID(IID_ITextHost, 0xc5bdd8d0, 0xd26e, 0x11ce, 0xa8, 0x9e);
49 TEXTSERV_GUID(IID_ITextHost2, 0xc5bdd8d0, 0xd26e, 0x11ce, 0xa8, 0x9e);
50 DEFINE_GUID(IID_ITextDocument, 0x8cc497c0, 0xa1df, 0x11ce, 0x80, 0x98, 0x00, 0xaa, 0x00, 0x47, 0xbe, 0x5d);
51
52 typedef struct IRichEditOleImpl {
53     const IRichEditOleVtbl *lpRichEditOleVtbl;
54     const ITextDocumentVtbl *lpTextDocumentVtbl;
55     LONG ref;
56
57     ME_TextEditor *editor;
58 } IRichEditOleImpl;
59
60 static inline IRichEditOleImpl *impl_from_IRichEditOle(IRichEditOle *iface)
61 {
62     return (IRichEditOleImpl *)((BYTE*)iface - FIELD_OFFSET(IRichEditOleImpl, lpRichEditOleVtbl));
63 }
64
65 static inline IRichEditOleImpl *impl_from_ITextDocument(ITextDocument *iface)
66 {
67     return (IRichEditOleImpl *)((BYTE*)iface - FIELD_OFFSET(IRichEditOleImpl, lpTextDocumentVtbl));
68 }
69
70 static HRESULT WINAPI
71 IRichEditOle_fnQueryInterface(IRichEditOle *me, REFIID riid, LPVOID *ppvObj)
72 {
73     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
74
75     TRACE("%p %s\n", This, debugstr_guid(riid) );
76
77     *ppvObj = NULL;
78     if (IsEqualGUID(riid, &IID_IUnknown) ||
79         IsEqualGUID(riid, &IID_IRichEditOle))
80         *ppvObj = &This->lpRichEditOleVtbl;
81     else if (IsEqualGUID(riid, &IID_ITextDocument))
82         *ppvObj = &This->lpTextDocumentVtbl;
83     if (*ppvObj)
84     {
85         IRichEditOle_AddRef(me);
86         return S_OK;
87     }
88     FIXME("%p: unhandled interface %s\n", This, debugstr_guid(riid) );
89  
90     return E_NOINTERFACE;   
91 }
92
93 static ULONG WINAPI
94 IRichEditOle_fnAddRef(IRichEditOle *me)
95 {
96     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
97     ULONG ref = InterlockedIncrement( &This->ref );
98
99     TRACE("%p ref = %u\n", This, ref);
100
101     return ref;
102 }
103
104 static ULONG WINAPI
105 IRichEditOle_fnRelease(IRichEditOle *me)
106 {
107     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
108     ULONG ref = InterlockedDecrement(&This->ref);
109
110     TRACE ("%p ref=%u\n", This, ref);
111
112     if (!ref)
113     {
114         TRACE ("Destroying %p\n", This);
115         heap_free(This);
116     }
117     return ref;
118 }
119
120 static HRESULT WINAPI
121 IRichEditOle_fnActivateAs(IRichEditOle *me, REFCLSID rclsid, REFCLSID rclsidAs)
122 {
123     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
124     FIXME("stub %p\n",This);
125     return E_NOTIMPL;
126 }
127
128 static HRESULT WINAPI
129 IRichEditOle_fnContextSensitiveHelp(IRichEditOle *me, BOOL fEnterMode)
130 {
131     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
132     FIXME("stub %p\n",This);
133     return E_NOTIMPL;
134 }
135
136 static HRESULT WINAPI
137 IRichEditOle_fnConvertObject(IRichEditOle *me, LONG iob,
138                REFCLSID rclsidNew, LPCSTR lpstrUserTypeNew)
139 {
140     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
141     FIXME("stub %p\n",This);
142     return E_NOTIMPL;
143 }
144
145 static HRESULT WINAPI
146 IRichEditOle_fnGetClientSite(IRichEditOle *me,
147                LPOLECLIENTSITE *lplpolesite)
148 {
149     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
150     FIXME("stub %p\n",This);
151     return E_NOTIMPL;
152 }
153
154 static HRESULT WINAPI
155 IRichEditOle_fnGetClipboardData(IRichEditOle *me, CHARRANGE *lpchrg,
156                DWORD reco, LPDATAOBJECT *lplpdataobj)
157 {
158     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
159     CHARRANGE tmpchrg;
160
161     TRACE("(%p,%p,%d)\n",This, lpchrg, reco);
162     if(!lplpdataobj)
163         return E_INVALIDARG;
164     if(!lpchrg) {
165         ME_GetSelection(This->editor, &tmpchrg.cpMin, &tmpchrg.cpMax);
166         lpchrg = &tmpchrg;
167     }
168     return ME_GetDataObject(This->editor, lpchrg, lplpdataobj);
169 }
170
171 static LONG WINAPI IRichEditOle_fnGetLinkCount(IRichEditOle *me)
172 {
173     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
174     FIXME("stub %p\n",This);
175     return E_NOTIMPL;
176 }
177
178 static HRESULT WINAPI
179 IRichEditOle_fnGetObject(IRichEditOle *me, LONG iob,
180                REOBJECT *lpreobject, DWORD dwFlags)
181 {
182     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
183     FIXME("stub %p\n",This);
184     return E_NOTIMPL;
185 }
186
187 static LONG WINAPI
188 IRichEditOle_fnGetObjectCount(IRichEditOle *me)
189 {
190     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
191     FIXME("stub %p\n",This);
192     return E_NOTIMPL;
193 }
194
195 static HRESULT WINAPI
196 IRichEditOle_fnHandsOffStorage(IRichEditOle *me, LONG iob)
197 {
198     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
199     FIXME("stub %p\n",This);
200     return E_NOTIMPL;
201 }
202
203 static HRESULT WINAPI
204 IRichEditOle_fnImportDataObject(IRichEditOle *me, LPDATAOBJECT lpdataobj,
205                CLIPFORMAT cf, HGLOBAL hMetaPict)
206 {
207     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
208     FIXME("stub %p\n",This);
209     return E_NOTIMPL;
210 }
211
212 static HRESULT WINAPI
213 IRichEditOle_fnInPlaceDeactivate(IRichEditOle *me)
214 {
215     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
216     FIXME("stub %p\n",This);
217     return E_NOTIMPL;
218 }
219
220 static HRESULT WINAPI
221 IRichEditOle_fnInsertObject(IRichEditOle *me, REOBJECT *reo)
222 {
223     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
224     TRACE("(%p,%p)\n", This, reo);
225
226     if (reo->cbStruct < sizeof(*reo)) return STG_E_INVALIDPARAMETER;
227     if (reo->poleobj)   IOleObject_AddRef(reo->poleobj);
228     if (reo->pstg)      IStorage_AddRef(reo->pstg);
229     if (reo->polesite)  IOleClientSite_AddRef(reo->polesite);
230
231     ME_InsertOLEFromCursor(This->editor, reo, 0);
232     return S_OK;
233 }
234
235 static HRESULT WINAPI IRichEditOle_fnSaveCompleted(IRichEditOle *me, LONG iob,
236                LPSTORAGE lpstg)
237 {
238     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
239     FIXME("stub %p\n",This);
240     return E_NOTIMPL;
241 }
242
243 static HRESULT WINAPI
244 IRichEditOle_fnSetDvaspect(IRichEditOle *me, LONG iob, DWORD dvaspect)
245 {
246     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
247     FIXME("stub %p\n",This);
248     return E_NOTIMPL;
249 }
250
251 static HRESULT WINAPI IRichEditOle_fnSetHostNames(IRichEditOle *me,
252                LPCSTR lpstrContainerApp, LPCSTR lpstrContainerObj)
253 {
254     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
255     FIXME("stub %p %s %s\n",This, lpstrContainerApp, lpstrContainerObj);
256     return E_NOTIMPL;
257 }
258
259 static HRESULT WINAPI
260 IRichEditOle_fnSetLinkAvailable(IRichEditOle *me, LONG iob, BOOL fAvailable)
261 {
262     IRichEditOleImpl *This = impl_from_IRichEditOle(me);
263     FIXME("stub %p\n",This);
264     return E_NOTIMPL;
265 }
266
267 static const IRichEditOleVtbl revt = {
268     IRichEditOle_fnQueryInterface,
269     IRichEditOle_fnAddRef,
270     IRichEditOle_fnRelease,
271     IRichEditOle_fnGetClientSite,
272     IRichEditOle_fnGetObjectCount,
273     IRichEditOle_fnGetLinkCount,
274     IRichEditOle_fnGetObject,
275     IRichEditOle_fnInsertObject,
276     IRichEditOle_fnConvertObject,
277     IRichEditOle_fnActivateAs,
278     IRichEditOle_fnSetHostNames,
279     IRichEditOle_fnSetLinkAvailable,
280     IRichEditOle_fnSetDvaspect,
281     IRichEditOle_fnHandsOffStorage,
282     IRichEditOle_fnSaveCompleted,
283     IRichEditOle_fnInPlaceDeactivate,
284     IRichEditOle_fnContextSensitiveHelp,
285     IRichEditOle_fnGetClipboardData,
286     IRichEditOle_fnImportDataObject
287 };
288
289 static HRESULT WINAPI
290 ITextDocument_fnQueryInterface(ITextDocument* me, REFIID riid,
291     void** ppvObject)
292 {
293     IRichEditOleImpl *This = impl_from_ITextDocument(me);
294     return IRichEditOle_fnQueryInterface((IRichEditOle*)&This->lpRichEditOleVtbl,
295             riid, ppvObject);
296 }
297
298 static ULONG WINAPI
299 ITextDocument_fnAddRef(ITextDocument* me)
300 {
301     IRichEditOleImpl *This = impl_from_ITextDocument(me);
302     return IRichEditOle_fnAddRef((IRichEditOle*)&This->lpRichEditOleVtbl);
303 }
304
305 static ULONG WINAPI
306 ITextDocument_fnRelease(ITextDocument* me)
307 {
308     IRichEditOleImpl *This = impl_from_ITextDocument(me);
309     return IRichEditOle_fnRelease((IRichEditOle*)&This->lpRichEditOleVtbl);
310 }
311
312 static HRESULT WINAPI
313 ITextDocument_fnGetTypeInfoCount(ITextDocument* me,
314     UINT* pctinfo)
315 {
316     IRichEditOleImpl *This = impl_from_ITextDocument(me);
317     FIXME("stub %p\n",This);
318     return E_NOTIMPL;
319 }
320
321 static HRESULT WINAPI
322 ITextDocument_fnGetTypeInfo(ITextDocument* me, UINT iTInfo, LCID lcid,
323     ITypeInfo** ppTInfo)
324 {
325     IRichEditOleImpl *This = impl_from_ITextDocument(me);
326     FIXME("stub %p\n",This);
327     return E_NOTIMPL;
328 }
329
330 static HRESULT WINAPI
331 ITextDocument_fnGetIDsOfNames(ITextDocument* me, REFIID riid,
332     LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgDispId)
333 {
334     IRichEditOleImpl *This = impl_from_ITextDocument(me);
335     FIXME("stub %p\n",This);
336     return E_NOTIMPL;
337 }
338
339 static HRESULT WINAPI
340 ITextDocument_fnInvoke(ITextDocument* me, DISPID dispIdMember,
341     REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
342     VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
343 {
344     IRichEditOleImpl *This = impl_from_ITextDocument(me);
345     FIXME("stub %p\n",This);
346     return E_NOTIMPL;
347 }
348
349 static HRESULT WINAPI
350 ITextDocument_fnGetName(ITextDocument* me, BSTR* pName)
351 {
352     IRichEditOleImpl *This = impl_from_ITextDocument(me);
353     FIXME("stub %p\n",This);
354     return E_NOTIMPL;
355 }
356
357 static HRESULT WINAPI
358 ITextDocument_fnGetSelection(ITextDocument* me, ITextSelection** ppSel)
359 {
360     IRichEditOleImpl *This = impl_from_ITextDocument(me);
361     FIXME("stub %p\n",This);
362     return E_NOTIMPL;
363 }
364
365 static HRESULT WINAPI
366 ITextDocument_fnGetStoryCount(ITextDocument* me, long* pCount)
367 {
368     IRichEditOleImpl *This = impl_from_ITextDocument(me);
369     FIXME("stub %p\n",This);
370     return E_NOTIMPL;
371 }
372
373 static HRESULT WINAPI
374 ITextDocument_fnGetStoryRanges(ITextDocument* me,
375     ITextStoryRanges** ppStories)
376 {
377     IRichEditOleImpl *This = impl_from_ITextDocument(me);
378     FIXME("stub %p\n",This);
379     return E_NOTIMPL;
380 }
381
382 static HRESULT WINAPI
383 ITextDocument_fnGetSaved(ITextDocument* me, long* pValue)
384 {
385     IRichEditOleImpl *This = impl_from_ITextDocument(me);
386     FIXME("stub %p\n",This);
387     return E_NOTIMPL;
388 }
389
390 static HRESULT WINAPI
391 ITextDocument_fnSetSaved(ITextDocument* me, long Value)
392 {
393     IRichEditOleImpl *This = impl_from_ITextDocument(me);
394     FIXME("stub %p\n",This);
395     return E_NOTIMPL;
396 }
397
398 static HRESULT WINAPI
399 ITextDocument_fnGetDefaultTabStop(ITextDocument* me, float* pValue)
400 {
401     IRichEditOleImpl *This = impl_from_ITextDocument(me);
402     FIXME("stub %p\n",This);
403     return E_NOTIMPL;
404 }
405
406 static HRESULT WINAPI
407 ITextDocument_fnSetDefaultTabStop(ITextDocument* me, float Value)
408 {
409     IRichEditOleImpl *This = impl_from_ITextDocument(me);
410     FIXME("stub %p\n",This);
411     return E_NOTIMPL;
412 }
413
414 static HRESULT WINAPI
415 ITextDocument_fnNew(ITextDocument* me)
416 {
417     IRichEditOleImpl *This = impl_from_ITextDocument(me);
418     FIXME("stub %p\n",This);
419     return E_NOTIMPL;
420 }
421
422 static HRESULT WINAPI
423 ITextDocument_fnOpen(ITextDocument* me, VARIANT* pVar, long Flags,
424     long CodePage)
425 {
426     IRichEditOleImpl *This = impl_from_ITextDocument(me);
427     FIXME("stub %p\n",This);
428     return E_NOTIMPL;
429 }
430
431 static HRESULT WINAPI
432 ITextDocument_fnSave(ITextDocument* me, VARIANT* pVar, long Flags,
433     long CodePage)
434 {
435     IRichEditOleImpl *This = impl_from_ITextDocument(me);
436     FIXME("stub %p\n",This);
437     return E_NOTIMPL;
438 }
439
440 static HRESULT WINAPI
441 ITextDocument_fnFreeze(ITextDocument* me, long* pCount)
442 {
443     IRichEditOleImpl *This = impl_from_ITextDocument(me);
444     FIXME("stub %p\n",This);
445     return E_NOTIMPL;
446 }
447
448 static HRESULT WINAPI
449 ITextDocument_fnUnfreeze(ITextDocument* me, long* pCount)
450 {
451     IRichEditOleImpl *This = impl_from_ITextDocument(me);
452     FIXME("stub %p\n",This);
453     return E_NOTIMPL;
454 }
455
456 static HRESULT WINAPI
457 ITextDocument_fnBeginEditCollection(ITextDocument* me)
458 {
459     IRichEditOleImpl *This = impl_from_ITextDocument(me);
460     FIXME("stub %p\n",This);
461     return E_NOTIMPL;
462 }
463
464 static HRESULT WINAPI
465 ITextDocument_fnEndEditCollection(ITextDocument* me)
466 {
467     IRichEditOleImpl *This = impl_from_ITextDocument(me);
468     FIXME("stub %p\n",This);
469     return E_NOTIMPL;
470 }
471
472 static HRESULT WINAPI
473 ITextDocument_fnUndo(ITextDocument* me, long Count, long* prop)
474 {
475     IRichEditOleImpl *This = impl_from_ITextDocument(me);
476     FIXME("stub %p\n",This);
477     return E_NOTIMPL;
478 }
479
480 static HRESULT WINAPI
481 ITextDocument_fnRedo(ITextDocument* me, long Count, long* prop)
482 {
483     IRichEditOleImpl *This = impl_from_ITextDocument(me);
484     FIXME("stub %p\n",This);
485     return E_NOTIMPL;
486 }
487
488 static HRESULT WINAPI
489 ITextDocument_fnRange(ITextDocument* me, long cp1, long cp2,
490     ITextRange** ppRange)
491 {
492     IRichEditOleImpl *This = impl_from_ITextDocument(me);
493     FIXME("stub %p\n",This);
494     return E_NOTIMPL;
495 }
496
497 static HRESULT WINAPI
498 ITextDocument_fnRangeFromPoint(ITextDocument* me, long x, long y,
499     ITextRange** ppRange)
500 {
501     IRichEditOleImpl *This = impl_from_ITextDocument(me);
502     FIXME("stub %p\n",This);
503     return E_NOTIMPL;
504 }
505
506 static const ITextDocumentVtbl tdvt = {
507     ITextDocument_fnQueryInterface,
508     ITextDocument_fnAddRef,
509     ITextDocument_fnRelease,
510     ITextDocument_fnGetTypeInfoCount,
511     ITextDocument_fnGetTypeInfo,
512     ITextDocument_fnGetIDsOfNames,
513     ITextDocument_fnInvoke,
514     ITextDocument_fnGetName,
515     ITextDocument_fnGetSelection,
516     ITextDocument_fnGetStoryCount,
517     ITextDocument_fnGetStoryRanges,
518     ITextDocument_fnGetSaved,
519     ITextDocument_fnSetSaved,
520     ITextDocument_fnGetDefaultTabStop,
521     ITextDocument_fnSetDefaultTabStop,
522     ITextDocument_fnNew,
523     ITextDocument_fnOpen,
524     ITextDocument_fnSave,
525     ITextDocument_fnFreeze,
526     ITextDocument_fnUnfreeze,
527     ITextDocument_fnBeginEditCollection,
528     ITextDocument_fnEndEditCollection,
529     ITextDocument_fnUndo,
530     ITextDocument_fnRedo,
531     ITextDocument_fnRange,
532     ITextDocument_fnRangeFromPoint
533 };
534
535 LRESULT CreateIRichEditOle(ME_TextEditor *editor, LPVOID *ppObj)
536 {
537     IRichEditOleImpl *reo;
538
539     reo = heap_alloc(sizeof(IRichEditOleImpl));
540     if (!reo)
541         return 0;
542
543     reo->lpRichEditOleVtbl = &revt;
544     reo->lpTextDocumentVtbl = &tdvt;
545     reo->ref = 1;
546     reo->editor = editor;
547     TRACE("Created %p\n",reo);
548     *ppObj = (LPVOID) reo;
549
550     return 1;
551 }
552
553 static void convert_sizel(ME_Context *c, const SIZEL* szl, SIZE* sz)
554 {
555   /* sizel is in .01 millimeters, sz in pixels */
556   sz->cx = MulDiv(szl->cx, c->dpi.cx, 2540);
557   sz->cy = MulDiv(szl->cy, c->dpi.cy, 2540);
558 }
559
560 /******************************************************************************
561  * ME_GetOLEObjectSize
562  *
563  * Sets run extent for OLE objects.
564  */
565 void ME_GetOLEObjectSize(ME_Context *c, ME_Run *run, SIZE *pSize)
566 {
567   IDataObject*  ido;
568   FORMATETC     fmt;
569   STGMEDIUM     stgm;
570   DIBSECTION    dibsect;
571   ENHMETAHEADER emh;
572
573   assert(run->nFlags & MERF_GRAPHICS);
574   assert(run->ole_obj);
575
576   if (run->ole_obj->sizel.cx != 0 || run->ole_obj->sizel.cy != 0)
577   {
578     convert_sizel(c, &run->ole_obj->sizel, pSize);
579     return;
580   }
581
582   IOleObject_QueryInterface(run->ole_obj->poleobj, &IID_IDataObject, (void**)&ido);
583   fmt.cfFormat = CF_BITMAP;
584   fmt.ptd = NULL;
585   fmt.dwAspect = DVASPECT_CONTENT;
586   fmt.lindex = -1;
587   fmt.tymed = TYMED_GDI;
588   if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
589   {
590     fmt.cfFormat = CF_ENHMETAFILE;
591     fmt.tymed = TYMED_ENHMF;
592     if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
593     {
594       FIXME("unsupported format\n");
595       pSize->cx = pSize->cy = 0;
596       IDataObject_Release(ido);
597       return;
598     }
599   }
600
601   switch (stgm.tymed)
602   {
603   case TYMED_GDI:
604     GetObjectW(stgm.u.hBitmap, sizeof(dibsect), &dibsect);
605     pSize->cx = dibsect.dsBm.bmWidth;
606     pSize->cy = dibsect.dsBm.bmHeight;
607     if (!stgm.pUnkForRelease) DeleteObject(stgm.u.hBitmap);
608     break;
609   case TYMED_ENHMF:
610     GetEnhMetaFileHeader(stgm.u.hEnhMetaFile, sizeof(emh), &emh);
611     pSize->cx = emh.rclBounds.right - emh.rclBounds.left;
612     pSize->cy = emh.rclBounds.bottom - emh.rclBounds.top;
613     if (!stgm.pUnkForRelease) DeleteEnhMetaFile(stgm.u.hEnhMetaFile);
614     break;
615   default:
616     FIXME("Unsupported tymed %d\n", stgm.tymed);
617     break;
618   }
619   IDataObject_Release(ido);
620   if (c->editor->nZoomNumerator != 0)
621   {
622     pSize->cx = MulDiv(pSize->cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
623     pSize->cy = MulDiv(pSize->cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
624   }
625 }
626
627 void ME_DrawOLE(ME_Context *c, int x, int y, ME_Run *run,
628                 ME_Paragraph *para, BOOL selected)
629 {
630   IDataObject*  ido;
631   FORMATETC     fmt;
632   STGMEDIUM     stgm;
633   DIBSECTION    dibsect;
634   ENHMETAHEADER emh;
635   HDC           hMemDC;
636   SIZE          sz;
637   BOOL          has_size;
638
639   assert(run->nFlags & MERF_GRAPHICS);
640   assert(run->ole_obj);
641   if (IOleObject_QueryInterface(run->ole_obj->poleobj, &IID_IDataObject, (void**)&ido) != S_OK)
642   {
643     FIXME("Couldn't get interface\n");
644     return;
645   }
646   has_size = run->ole_obj->sizel.cx != 0 || run->ole_obj->sizel.cy != 0;
647   fmt.cfFormat = CF_BITMAP;
648   fmt.ptd = NULL;
649   fmt.dwAspect = DVASPECT_CONTENT;
650   fmt.lindex = -1;
651   fmt.tymed = TYMED_GDI;
652   if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
653   {
654     fmt.cfFormat = CF_ENHMETAFILE;
655     fmt.tymed = TYMED_ENHMF;
656     if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
657     {
658       FIXME("Couldn't get storage medium\n");
659       IDataObject_Release(ido);
660       return;
661     }
662   }
663   switch (stgm.tymed)
664   {
665   case TYMED_GDI:
666     GetObjectW(stgm.u.hBitmap, sizeof(dibsect), &dibsect);
667     hMemDC = CreateCompatibleDC(c->hDC);
668     SelectObject(hMemDC, stgm.u.hBitmap);
669     if (!has_size && c->editor->nZoomNumerator == 0)
670     {
671       sz.cx = dibsect.dsBm.bmWidth;
672       sz.cy = dibsect.dsBm.bmHeight;
673       BitBlt(c->hDC, x, y - dibsect.dsBm.bmHeight,
674              dibsect.dsBm.bmWidth, dibsect.dsBm.bmHeight,
675              hMemDC, 0, 0, SRCCOPY);
676     }
677     else
678     {
679       if (has_size)
680       {
681         convert_sizel(c, &run->ole_obj->sizel, &sz);
682       }
683       else
684       {
685         sz.cy = MulDiv(dibsect.dsBm.bmWidth,
686                        c->editor->nZoomNumerator, c->editor->nZoomDenominator);
687         sz.cx = MulDiv(dibsect.dsBm.bmHeight,
688                        c->editor->nZoomNumerator, c->editor->nZoomDenominator);
689       }
690       StretchBlt(c->hDC, x, y - sz.cy, sz.cx, sz.cy,
691                  hMemDC, 0, 0, dibsect.dsBm.bmWidth, dibsect.dsBm.bmHeight, SRCCOPY);
692     }
693     if (!stgm.pUnkForRelease) DeleteObject(stgm.u.hBitmap);
694     break;
695   case TYMED_ENHMF:
696     GetEnhMetaFileHeader(stgm.u.hEnhMetaFile, sizeof(emh), &emh);
697     if (!has_size && c->editor->nZoomNumerator == 0)
698     {
699       sz.cy = emh.rclBounds.bottom - emh.rclBounds.top;
700       sz.cx = emh.rclBounds.right - emh.rclBounds.left;
701     }
702     else
703     {
704       if (has_size)
705       {
706         convert_sizel(c, &run->ole_obj->sizel, &sz);
707       }
708       else
709       {
710         sz.cy = MulDiv(emh.rclBounds.bottom - emh.rclBounds.top,
711                        c->editor->nZoomNumerator, c->editor->nZoomDenominator);
712         sz.cx = MulDiv(emh.rclBounds.right - emh.rclBounds.left,
713                        c->editor->nZoomNumerator, c->editor->nZoomDenominator);
714       }
715     }
716     {
717       RECT    rc;
718
719       rc.left = x;
720       rc.top = y - sz.cy;
721       rc.right = x + sz.cx;
722       rc.bottom = y;
723       PlayEnhMetaFile(c->hDC, stgm.u.hEnhMetaFile, &rc);
724     }
725     if (!stgm.pUnkForRelease) DeleteEnhMetaFile(stgm.u.hEnhMetaFile);
726     break;
727   default:
728     FIXME("Unsupported tymed %d\n", stgm.tymed);
729     selected = FALSE;
730     break;
731   }
732   if (selected && !c->editor->bHideSelection)
733     PatBlt(c->hDC, x, y - sz.cy, sz.cx, sz.cy, DSTINVERT);
734   IDataObject_Release(ido);
735 }
736
737 void ME_DeleteReObject(REOBJECT* reo)
738 {
739     if (reo->poleobj)   IOleObject_Release(reo->poleobj);
740     if (reo->pstg)      IStorage_Release(reo->pstg);
741     if (reo->polesite)  IOleClientSite_Release(reo->polesite);
742     FREE_OBJ(reo);
743 }
744
745 void ME_CopyReObject(REOBJECT* dst, const REOBJECT* src)
746 {
747     *dst = *src;
748
749     if (dst->poleobj)   IOleObject_AddRef(dst->poleobj);
750     if (dst->pstg)      IStorage_AddRef(dst->pstg);
751     if (dst->polesite)  IOleClientSite_AddRef(dst->polesite);
752 }