git.oblomov.eu Git - wine/blob - 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.cx = MulDiv(dibsect.dsBm.bmWidth,
 686                        c->editor->nZoomNumerator, c->editor->nZoomDenominator);
 687         sz.cy = 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 }