dlls/riched20/tests/txtsrv.c

   1 /*
   2  * Unit test suite for windowless rich edit controls
   3  *
   4  * Copyright 2008 Maarten Lankhorst
   5  * Copyright 2008 Austin Lund
   6  * Copyright 2008 Dylan Smith
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #define COBJMACROS
  24
  25 #include <stdio.h>
  26 #include <stdarg.h>
  27 #include <windef.h>
  28 #include <winbase.h>
  29 #include <objbase.h>
  30 #include <richedit.h>
  31 #include <initguid.h>
  32 #include <textserv.h>
  33 #include <wine/test.h>
  34 #include <oleauto.h>
  35 #include <limits.h>
  36
  37 static HMODULE hmoduleRichEdit;
  38
  39 /* Define C Macros for ITextServices calls. */
  40
  41 /* Use a special table for x86 machines to convert the thiscall
  42  * calling convention.  This isn't needed on other platforms. */
  43 #ifdef __i386__
  44 static ITextServicesVtbl itextServicesStdcallVtbl;
  45 #define TXTSERV_VTABLE(This) (&itextServicesStdcallVtbl)
  46 #else /* __i386__ */
  47 #define TXTSERV_VTABLE(This) (This)->lpVtbl
  48 #endif /* __i386__ */
  49
  50 #define ITextServices_TxSendMessage(This,a,b,c,d) TXTSERV_VTABLE(This)->TxSendMessage(This,a,b,c,d)
  51 #define ITextServices_TxDraw(This,a,b,c,d,e,f,g,h,i,j,k,l) TXTSERV_VTABLE(This)->TxDraw(This,a,b,c,d,e,f,g,h,i,j,k,l)
  52 #define ITextServices_TxGetHScroll(This,a,b,c,d,e) TXTSERV_VTABLE(This)->TxGetHScroll(This,a,b,c,d,e)
  53 #define ITextServices_TxGetVScroll(This,a,b,c,d,e) TXTSERV_VTABLE(This)->TxGetVScroll(This,a,b,c,d,e)
  54 #define ITextServices_OnTxSetCursor(This,a,b,c,d,e,f,g,h,i) TXTSERV_VTABLE(This)->OnTxSetCursor(This,a,b,c,d,e,f,g,h,i)
  55 #define ITextServices_TxQueryHitPoint(This,a,b,c,d,e,f,g,h,i,j) TXTSERV_VTABLE(This)->TxQueryHitPoint(This,a,b,c,d,e,f,g,h,i,j)
  56 #define ITextServices_OnTxInplaceActivate(This,a) TXTSERV_VTABLE(This)->OnTxInplaceActivate(This,a)
  57 #define ITextServices_OnTxInplaceDeactivate(This) TXTSERV_VTABLE(This)->OnTxInplaceDeactivate(This)
  58 #define ITextServices_OnTxUIActivate(This) TXTSERV_VTABLE(This)->OnTxUIActivate(This)
  59 #define ITextServices_OnTxUIDeactivate(This) TXTSERV_VTABLE(This)->OnTxUIDeactivate(This)
  60 #define ITextServices_TxGetText(This,a) TXTSERV_VTABLE(This)->TxGetText(This,a)
  61 #define ITextServices_TxSetText(This,a) TXTSERV_VTABLE(This)->TxSetText(This,a)
  62 #define ITextServices_TxGetCurrentTargetX(This,a) TXTSERV_VTABLE(This)->TxGetCurrentTargetX(This,a)
  63 #define ITextServices_TxGetBaseLinePos(This,a) TXTSERV_VTABLE(This)->TxGetBaseLinePos(This,a)
  64 #define ITextServices_TxGetNaturalSize(This,a,b,c,d,e,f,g,h) TXTSERV_VTABLE(This)->TxGetNaturalSize(This,a,b,c,d,e,f,g,h)
  65 #define ITextServices_TxGetDropTarget(This,a) TXTSERV_VTABLE(This)->TxGetDropTarget(This,a)
  66 #define ITextServices_OnTxPropertyBitsChange(This,a,b) TXTSERV_VTABLE(This)->OnTxPropertyBitsChange(This,a,b)
  67 #define ITextServices_TxGetCachedSize(This,a,b) TXTSERV_VTABLE(This)->TxGetCachedSize(This,a,b)
  68
  69 /* Set the WINETEST_DEBUG environment variable to be greater than 1 for verbose
  70  * function call traces of ITextHost. */
  71 #define TRACECALL if(winetest_debug > 1) trace
  72
  73 /************************************************************************/
  74 /* ITextHost implementation for conformance testing. */
  75
  76 typedef struct ITextHostTestImpl
  77 {
  78     ITextHostVtbl *lpVtbl;
  79     LONG refCount;
  80 } ITextHostTestImpl;
  81
  82 static HRESULT WINAPI ITextHostImpl_QueryInterface(ITextHost *iface,
  83                                                    REFIID riid,
  84                                                    LPVOID *ppvObject)
  85 {
  86     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
  87
  88     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_ITextHost)) {
  89         *ppvObject = This;
  90         ITextHost_AddRef((ITextHost *)*ppvObject);
  91         return S_OK;
  92     }
  93
  94     return E_NOINTERFACE;
  95 }
  96
  97 static ULONG WINAPI ITextHostImpl_AddRef(ITextHost *iface)
  98 {
  99     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 100     ULONG refCount = InterlockedIncrement(&This->refCount);
 101     return refCount;
 102 }
 103
 104 static ULONG WINAPI ITextHostImpl_Release(ITextHost *iface)
 105 {
 106     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 107     ULONG refCount = InterlockedDecrement(&This->refCount);
 108
 109     if (!refCount)
 110     {
 111         CoTaskMemFree(This);
 112         return 0;
 113     } else {
 114         return refCount;
 115     }
 116 }
 117
 118 static HDC WINAPI ITextHostImpl_TxGetDC(ITextHost *iface)
 119 {
 120     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 121     TRACECALL("Call to TxGetDC(%p)\n", This);
 122     return NULL;
 123 }
 124
 125 static INT WINAPI ITextHostImpl_TxReleaseDC(ITextHost *iface,
 126                                             HDC hdc)
 127 {
 128     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 129     TRACECALL("Call to TxReleaseDC(%p)\n", This);
 130     return 0;
 131 }
 132
 133 static BOOL WINAPI ITextHostImpl_TxShowScrollBar(ITextHost *iface,
 134                                                  INT fnBar,
 135                                                  BOOL fShow)
 136 {
 137     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 138     TRACECALL("Call to TxShowScrollBar(%p, fnBar=%d, fShow=%d)\n",
 139                 This, fnBar, fShow);
 140     return FALSE;
 141 }
 142
 143 static BOOL WINAPI ITextHostImpl_TxEnableScrollBar(ITextHost *iface,
 144                                                    INT fuSBFlags,
 145                                                    INT fuArrowflags)
 146 {
 147     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 148     TRACECALL("Call to TxEnableScrollBar(%p, fuSBFlags=%d, fuArrowflags=%d)\n",
 149                This, fuSBFlags, fuArrowflags);
 150     return FALSE;
 151 }
 152
 153 static BOOL WINAPI ITextHostImpl_TxSetScrollRange(ITextHost *iface,
 154                                                   INT fnBar,
 155                                                   LONG nMinPos,
 156                                                   INT nMaxPos,
 157                                                   BOOL fRedraw)
 158 {
 159     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 160     TRACECALL("Call to TxSetScrollRange(%p, fnBar=%d, nMinPos=%d, nMaxPos=%d, fRedraw=%d)\n",
 161                This, fnBar, nMinPos, nMaxPos, fRedraw);
 162     return FALSE;
 163 }
 164
 165 static BOOL WINAPI ITextHostImpl_TxSetScrollPos(ITextHost *iface,
 166                                                 INT fnBar,
 167                                                 INT nPos,
 168                                                 BOOL fRedraw)
 169 {
 170     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 171     TRACECALL("Call to TxSetScrollPos(%p, fnBar=%d, nPos=%d, fRedraw=%d)\n",
 172                This, fnBar, nPos, fRedraw);
 173     return FALSE;
 174 }
 175
 176 static void WINAPI ITextHostImpl_TxInvalidateRect(ITextHost *iface,
 177                                                   LPCRECT prc,
 178                                                   BOOL fMode)
 179 {
 180     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 181     TRACECALL("Call to TxInvalidateRect(%p, prc=%p, fMode=%d)\n",
 182                This, prc, fMode);
 183 }
 184
 185 static void WINAPI ITextHostImpl_TxViewChange(ITextHost *iface, BOOL fUpdate)
 186 {
 187     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 188     TRACECALL("Call to TxViewChange(%p, fUpdate=%d)\n",
 189                This, fUpdate);
 190 }
 191
 192 static BOOL WINAPI ITextHostImpl_TxCreateCaret(ITextHost *iface,
 193                                                HBITMAP hbmp,
 194                                                INT xWidth, INT yHeight)
 195 {
 196     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 197     TRACECALL("Call to TxCreateCaret(%p, nbmp=%p, xWidth=%d, yHeight=%d)\n",
 198                This, hbmp, xWidth, yHeight);
 199     return FALSE;
 200 }
 201
 202 static BOOL WINAPI ITextHostImpl_TxShowCaret(ITextHost *iface, BOOL fShow)
 203 {
 204     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 205     TRACECALL("Call to TxShowCaret(%p, fShow=%d)\n",
 206                This, fShow);
 207     return FALSE;
 208 }
 209
 210 static BOOL WINAPI ITextHostImpl_TxSetCaretPos(ITextHost *iface,
 211                                                INT x, INT y)
 212 {
 213     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 214     TRACECALL("Call to TxSetCaretPos(%p, x=%d, y=%d)\n", This, x, y);
 215     return FALSE;
 216 }
 217
 218 static BOOL WINAPI ITextHostImpl_TxSetTimer(ITextHost *iface,
 219                                             UINT idTimer, UINT uTimeout)
 220 {
 221     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 222     TRACECALL("Call to TxSetTimer(%p, idTimer=%u, uTimeout=%u)\n",
 223               This, idTimer, uTimeout);
 224     return FALSE;
 225 }
 226
 227 static void WINAPI ITextHostImpl_TxKillTimer(ITextHost *iface, UINT idTimer)
 228 {
 229     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 230     TRACECALL("Call to TxKillTimer(%p, idTimer=%u)\n", This, idTimer);
 231 }
 232
 233 static void WINAPI ITextHostImpl_TxScrollWindowEx(ITextHost *iface,
 234                                                   INT dx, INT dy,
 235                                                   LPCRECT lprcScroll,
 236                                                   LPCRECT lprcClip,
 237                                                   HRGN hRgnUpdate,
 238                                                   LPRECT lprcUpdate,
 239                                                   UINT fuScroll)
 240 {
 241     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 242     TRACECALL("Call to TxScrollWindowEx(%p, %d, %d, %p, %p, %p, %p, %d)\n",
 243               This, dx, dy, lprcScroll, lprcClip, hRgnUpdate, lprcUpdate, fuScroll);
 244 }
 245
 246 static void WINAPI ITextHostImpl_TxSetCapture(ITextHost *iface, BOOL fCapture)
 247 {
 248     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 249     TRACECALL("Call to TxSetCapture(%p, fCapture=%d)\n", This, fCapture);
 250 }
 251
 252 static void WINAPI ITextHostImpl_TxSetFocus(ITextHost *iface)
 253 {
 254     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 255     TRACECALL("Call to TxSetFocus(%p)\n", This);
 256 }
 257
 258 static void WINAPI ITextHostImpl_TxSetCursor(ITextHost *iface,
 259                                              HCURSOR hcur,
 260                                              BOOL fText)
 261 {
 262     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 263     TRACECALL("Call to TxSetCursor(%p, hcur=%p, fText=%d)\n",
 264               This, hcur, fText);
 265 }
 266
 267 static BOOL WINAPI ITextHostImpl_TxScreenToClient(ITextHost *iface,
 268                                                   LPPOINT lppt)
 269 {
 270     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 271     TRACECALL("Call to TxScreenToClient(%p, lppt=%p)\n", This, lppt);
 272     return FALSE;
 273 }
 274
 275 static BOOL WINAPI ITextHostImpl_TxClientToScreen(ITextHost *iface,
 276                                                   LPPOINT lppt)
 277 {
 278     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 279     TRACECALL("Call to TxClientToScreen(%p, lppt=%p)\n", This, lppt);
 280     return FALSE;
 281 }
 282
 283 static HRESULT WINAPI ITextHostImpl_TxActivate(ITextHost *iface,
 284                                                LONG *plOldState)
 285 {
 286     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 287     TRACECALL("Call to TxActivate(%p, plOldState=%p)\n", This, plOldState);
 288     return E_NOTIMPL;
 289 }
 290
 291 static HRESULT WINAPI ITextHostImpl_TxDeactivate(ITextHost *iface,
 292                                                  LONG lNewState)
 293 {
 294     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 295     TRACECALL("Call to TxDeactivate(%p, lNewState=%d)\n", This, lNewState);
 296     return E_NOTIMPL;
 297 }
 298
 299 static HRESULT WINAPI ITextHostImpl_TxGetClientRect(ITextHost *iface,
 300                                                     LPRECT prc)
 301 {
 302     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 303     TRACECALL("Call to TxGetClientRect(%p, prc=%p)\n", This, prc);
 304     return E_NOTIMPL;
 305 }
 306
 307 static HRESULT WINAPI ITextHostImpl_TxGetViewInset(ITextHost *iface,
 308                                                    LPRECT prc)
 309 {
 310     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 311     TRACECALL("Call to TxGetViewInset(%p, prc=%p)\n", This, prc);
 312     return E_NOTIMPL;
 313 }
 314
 315 static HRESULT WINAPI ITextHostImpl_TxGetCharFormat(ITextHost *iface,
 316                                                     const CHARFORMATW **ppCF)
 317 {
 318     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 319     TRACECALL("Call to TxGetCharFormat(%p, ppCF=%p)\n", This, ppCF);
 320     return E_NOTIMPL;
 321 }
 322
 323 static HRESULT WINAPI ITextHostImpl_TxGetParaFormat(ITextHost *iface,
 324                                                     const PARAFORMAT **ppPF)
 325 {
 326     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 327     TRACECALL("Call to TxGetParaFormat(%p, ppPF=%p)\n", This, ppPF);
 328     return E_NOTIMPL;
 329 }
 330
 331 static COLORREF WINAPI ITextHostImpl_TxGetSysColor(ITextHost *iface,
 332                                                    int nIndex)
 333 {
 334     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 335     TRACECALL("Call to TxGetSysColor(%p, nIndex=%d)\n", This, nIndex);
 336     return E_NOTIMPL;
 337 }
 338
 339 static HRESULT WINAPI ITextHostImpl_TxGetBackStyle(ITextHost *iface,
 340                                                    TXTBACKSTYLE *pStyle)
 341 {
 342     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 343     TRACECALL("Call to TxGetBackStyle(%p, pStyle=%p)\n", This, pStyle);
 344     return E_NOTIMPL;
 345 }
 346
 347 static HRESULT WINAPI ITextHostImpl_TxGetMaxLength(ITextHost *iface,
 348                                                    DWORD *pLength)
 349 {
 350     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 351     TRACECALL("Call to TxGetMaxLength(%p, pLength=%p)\n", This, pLength);
 352     return E_NOTIMPL;
 353 }
 354
 355 static HRESULT WINAPI ITextHostImpl_TxGetScrollBars(ITextHost *iface,
 356                                                     DWORD *pdwScrollBar)
 357 {
 358     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 359     TRACECALL("Call to TxGetScrollBars(%p, pdwScrollBar=%p)\n",
 360                This, pdwScrollBar);
 361     return E_NOTIMPL;
 362 }
 363
 364 static HRESULT WINAPI ITextHostImpl_TxGetPasswordChar(ITextHost *iface,
 365                                                       WCHAR *pch)
 366 {
 367     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 368     TRACECALL("Call to TxGetPasswordChar(%p, pch=%p)\n", This, pch);
 369     return E_NOTIMPL;
 370 }
 371
 372 static HRESULT WINAPI ITextHostImpl_TxGetAcceleratorPos(ITextHost *iface,
 373                                                         LONG *pch)
 374 {
 375     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 376     TRACECALL("Call to TxGetAcceleratorPos(%p, pch=%p)\n", This, pch);
 377     return E_NOTIMPL;
 378 }
 379
 380 static HRESULT WINAPI ITextHostImpl_TxGetExtent(ITextHost *iface,
 381                                                 LPSIZEL lpExtent)
 382 {
 383     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 384     TRACECALL("Call to TxGetExtent(%p, lpExtent=%p)\n", This, lpExtent);
 385     return E_NOTIMPL;
 386 }
 387
 388 static HRESULT WINAPI ITextHostImpl_OnTxCharFormatChange(ITextHost *iface,
 389                                                          const CHARFORMATW *pcf)
 390 {
 391     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 392     TRACECALL("Call to OnTxCharFormatChange(%p, pcf=%p)\n", This, pcf);
 393     return E_NOTIMPL;
 394 }
 395
 396 static HRESULT WINAPI ITextHostImpl_OnTxParaFormatChange(ITextHost *iface,
 397                                                          const PARAFORMAT *ppf)
 398 {
 399     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 400     TRACECALL("Call to OnTxParaFormatChange(%p, ppf=%p)\n", This, ppf);
 401     return E_NOTIMPL;
 402 }
 403
 404 /* This must return S_OK for the native ITextServices object to
 405    initialize. */
 406 static HRESULT WINAPI ITextHostImpl_TxGetPropertyBits(ITextHost *iface,
 407                                                       DWORD dwMask,
 408                                                       DWORD *pdwBits)
 409 {
 410     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 411     TRACECALL("Call to TxGetPropertyBits(%p, dwMask=0x%08x, pdwBits=%p)\n",
 412               This, dwMask, pdwBits);
 413     *pdwBits = 0;
 414     return S_OK;
 415 }
 416
 417 static HRESULT WINAPI ITextHostImpl_TxNotify(ITextHost *iface, DWORD iNotify,
 418                                              void *pv)
 419 {
 420     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 421     TRACECALL("Call to TxNotify(%p, iNotify=%d, pv=%p)\n", This, iNotify, pv);
 422     return E_NOTIMPL;
 423 }
 424
 425 static HIMC WINAPI ITextHostImpl_TxImmGetContext(ITextHost *iface)
 426 {
 427     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 428     TRACECALL("Call to TxImmGetContext(%p)\n", This);
 429     return 0;
 430 }
 431
 432 static void WINAPI ITextHostImpl_TxImmReleaseContext(ITextHost *iface, HIMC himc)
 433 {
 434     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 435     TRACECALL("Call to TxImmReleaseContext(%p, himc=%p)\n", This, himc);
 436 }
 437
 438 /* This function must set the variable pointed to by *lSelBarWidth.
 439    Otherwise an uninitalized value will be used to calculate
 440    positions and sizes even if E_NOTIMPL is returned. */
 441 static HRESULT WINAPI ITextHostImpl_TxGetSelectionBarWidth(ITextHost *iface,
 442                                                            LONG *lSelBarWidth)
 443 {
 444     ITextHostTestImpl *This = (ITextHostTestImpl *)iface;
 445     TRACECALL("Call to TxGetSelectionBarWidth(%p, lSelBarWidth=%p)\n",
 446                 This, lSelBarWidth);
 447     *lSelBarWidth = 0;
 448     return E_NOTIMPL;
 449 }
 450
 451 static ITextHostVtbl itextHostVtbl = {
 452     ITextHostImpl_QueryInterface,
 453     ITextHostImpl_AddRef,
 454     ITextHostImpl_Release,
 455     ITextHostImpl_TxGetDC,
 456     ITextHostImpl_TxReleaseDC,
 457     ITextHostImpl_TxShowScrollBar,
 458     ITextHostImpl_TxEnableScrollBar,
 459     ITextHostImpl_TxSetScrollRange,
 460     ITextHostImpl_TxSetScrollPos,
 461     ITextHostImpl_TxInvalidateRect,
 462     ITextHostImpl_TxViewChange,
 463     ITextHostImpl_TxCreateCaret,
 464     ITextHostImpl_TxShowCaret,
 465     ITextHostImpl_TxSetCaretPos,
 466     ITextHostImpl_TxSetTimer,
 467     ITextHostImpl_TxKillTimer,
 468     ITextHostImpl_TxScrollWindowEx,
 469     ITextHostImpl_TxSetCapture,
 470     ITextHostImpl_TxSetFocus,
 471     ITextHostImpl_TxSetCursor,
 472     ITextHostImpl_TxScreenToClient,
 473     ITextHostImpl_TxClientToScreen,
 474     ITextHostImpl_TxActivate,
 475     ITextHostImpl_TxDeactivate,
 476     ITextHostImpl_TxGetClientRect,
 477     ITextHostImpl_TxGetViewInset,
 478     ITextHostImpl_TxGetCharFormat,
 479     ITextHostImpl_TxGetParaFormat,
 480     ITextHostImpl_TxGetSysColor,
 481     ITextHostImpl_TxGetBackStyle,
 482     ITextHostImpl_TxGetMaxLength,
 483     ITextHostImpl_TxGetScrollBars,
 484     ITextHostImpl_TxGetPasswordChar,
 485     ITextHostImpl_TxGetAcceleratorPos,
 486     ITextHostImpl_TxGetExtent,
 487     ITextHostImpl_OnTxCharFormatChange,
 488     ITextHostImpl_OnTxParaFormatChange,
 489     ITextHostImpl_TxGetPropertyBits,
 490     ITextHostImpl_TxNotify,
 491     ITextHostImpl_TxImmGetContext,
 492     ITextHostImpl_TxImmReleaseContext,
 493     ITextHostImpl_TxGetSelectionBarWidth
 494 };
 495
 496 static ITextServices *txtserv = NULL;
 497 static ITextHostTestImpl *dummyTextHost;
 498 static void *wrapperCodeMem = NULL;
 499
 500 #include "pshpack1.h"
 501
 502 /* Code structure for x86 byte code */
 503 typedef struct
 504 {
 505     BYTE pop_eax;  /* popl  %eax  */
 506     BYTE push_ecx; /* pushl %ecx  */
 507     BYTE push_eax; /* pushl %eax  */
 508     BYTE jmp_func; /* jmp   $func */
 509     DWORD func;
 510 } THISCALL_TO_STDCALL_THUNK;
 511
 512 typedef struct
 513 {
 514     BYTE pop_eax;               /* popl  %eax */
 515     BYTE pop_ecx;               /* popl  %ecx */
 516     BYTE push_eax;              /* pushl %eax */
 517     BYTE mov_vtable_eax[2];     /* movl (%ecx), %eax */
 518     BYTE jmp_eax[2];            /* jmp *$vtablefunc_offset(%eax) */
 519     int  vtablefunc_offset;
 520 } STDCALL_TO_THISCALL_THUNK;
 521
 522 #include "poppack.h"
 523
 524 static void setup_thiscall_wrappers(void)
 525 {
 526 #ifdef __i386__
 527     void** pVtable;
 528     void** pVtableEnd;
 529     THISCALL_TO_STDCALL_THUNK *thunk;
 530     STDCALL_TO_THISCALL_THUNK *thunk2;
 531
 532     wrapperCodeMem = VirtualAlloc(NULL,
 533                                   (sizeof(ITextHostVtbl)/sizeof(void*) - 3)
 534                                     * sizeof(THISCALL_TO_STDCALL_THUNK)
 535                                   +(sizeof(ITextServicesVtbl)/sizeof(void*) - 3)
 536                                     * sizeof(STDCALL_TO_THISCALL_THUNK),
 537                                   MEM_COMMIT, PAGE_EXECUTE_READWRITE);
 538     thunk = wrapperCodeMem;
 539
 540     /* Wrap all ITextHostImpl methods with code to perform a thiscall to
 541      * stdcall conversion. The thiscall calling convention places the This
 542      * pointer in ecx on the x86 platform, and the stdcall calling convention
 543      * pushes the This pointer on the stack as the first argument.
 544      *
 545      * The byte code does the conversion then jumps to the real function.
 546      *
 547      * Each wrapper needs to be modified so that the function to jump to is
 548      * modified in the byte code. */
 549
 550     /* Skip QueryInterface, AddRef, and Release native actually
 551      * defined them with the stdcall calling convention. */
 552     pVtable = (void**)&itextHostVtbl + 3;
 553     pVtableEnd = (void**)(&itextHostVtbl + 1);
 554     while (pVtable != pVtableEnd) {
 555         /* write byte code to executable memory */
 556         thunk->pop_eax = 0x58;  /* popl  %eax  */
 557         thunk->push_ecx = 0x51; /* pushl %ecx  */
 558         thunk->push_eax = 0x50; /* pushl %eax  */
 559         thunk->jmp_func = 0xe9; /* jmp   $func */
 560         /* The address needs to be relative to the end of the jump instructions. */
 561         thunk->func = (char*)*pVtable - (char*)(&thunk->func + 1);
 562         *pVtable = thunk;
 563         pVtable++;
 564         thunk++;
 565     }
 566
 567     /* Setup an ITextServices standard call vtable that will call the
 568      * native thiscall vtable when the methods are called. */
 569
 570     /* QueryInterface, AddRef, and Release should be called directly on the
 571      * real vtable since they use the stdcall calling convention. */
 572     thunk2 = (STDCALL_TO_THISCALL_THUNK *)thunk;
 573     pVtable = (void**)&itextServicesStdcallVtbl + 3;
 574     pVtableEnd = (void**)(&itextServicesStdcallVtbl + 1);
 575     while (pVtable != pVtableEnd) {
 576         /* write byte code to executable memory */
 577         thunk2->pop_eax = 0x58;               /* popl  %eax */
 578         thunk2->pop_ecx = 0x59;               /* popl  %ecx */
 579         thunk2->push_eax = 0x50;              /* pushl %eax */
 580         thunk2->mov_vtable_eax[0] = 0x8b;     /* movl (%ecx), %eax */
 581         thunk2->mov_vtable_eax[1] = 0x01;
 582         thunk2->jmp_eax[0] = 0xff;            /* jmp *$vtablefunc_offset(%eax) */
 583         thunk2->jmp_eax[1] = 0xa0;
 584         thunk2->vtablefunc_offset = (char*)pVtable - (char*)&itextServicesStdcallVtbl;
 585         *pVtable = thunk2;
 586         pVtable++;
 587         thunk2++;
 588     }
 589 #endif /* __i386__ */
 590 }
 591
 592 /*************************************************************************/
 593 /* Conformance test functions. */
 594
 595 /* Initialize the test texthost structure */
 596 static BOOL init_texthost(void)
 597 {
 598     IUnknown *init;
 599     HRESULT result;
 600     PCreateTextServices pCreateTextServices;
 601
 602     dummyTextHost = CoTaskMemAlloc(sizeof(*dummyTextHost));
 603     if (dummyTextHost == NULL) {
 604         skip("Insufficient memory to create ITextHost interface\n");
 605         return FALSE;
 606     }
 607     dummyTextHost->lpVtbl = &itextHostVtbl;
 608     dummyTextHost->refCount = 1;
 609
 610     /* MSDN states that an IUnknown object is returned by
 611        CreateTextServices which is then queried to obtain a
 612        ITextServices object. */
 613     pCreateTextServices = (void*)GetProcAddress(hmoduleRichEdit, "CreateTextServices");
 614     result = (*pCreateTextServices)(NULL,(ITextHost*)dummyTextHost, &init);
 615     ok(result == S_OK, "Did not return OK when created. Returned %x\n", result);
 616     if (result != S_OK) {
 617         CoTaskMemFree(dummyTextHost);
 618         skip("CreateTextServices failed.\n");
 619         return FALSE;
 620     }
 621
 622     result = IUnknown_QueryInterface(init, &IID_ITextServices,
 623                                      (void **)&txtserv);
 624     ok((result == S_OK) && (txtserv != NULL), "Querying interface failed\n");
 625     IUnknown_Release(init);
 626     if (!((result == S_OK) && (txtserv != NULL))) {
 627         CoTaskMemFree(dummyTextHost);
 628         skip("Could not retrieve ITextServices interface\n");
 629         return FALSE;
 630     }
 631
 632     return TRUE;
 633 }
 634
 635 static void test_TxGetText(void)
 636 {
 637     HRESULT hres;
 638     BSTR rettext;
 639
 640     if (!init_texthost())
 641         return;
 642
 643     hres = ITextServices_TxGetText(txtserv, &rettext);
 644     ok(hres == S_OK, "ITextServices_TxGetText failed\n");
 645
 646     IUnknown_Release(txtserv);
 647     CoTaskMemFree(dummyTextHost);
 648 }
 649
 650 static void test_TxSetText(void)
 651 {
 652     HRESULT hres;
 653     BSTR rettext;
 654     WCHAR settext[] = {'T','e','s','t',0};
 655
 656     if (!init_texthost())
 657         return;
 658
 659     hres = ITextServices_TxSetText(txtserv, settext);
 660     ok(hres == S_OK, "ITextServices_TxSetText failed\n");
 661
 662     hres = ITextServices_TxGetText(txtserv, &rettext);
 663     ok(hres == S_OK, "ITextServices_TxGetText failed\n");
 664
 665     ok(SysStringLen(rettext) == 4,
 666                  "String returned of wrong length\n");
 667     ok(memcmp(rettext,settext,SysStringByteLen(rettext)) == 0,
 668                  "String returned differs\n");
 669
 670     SysFreeString(rettext);
 671     IUnknown_Release(txtserv);
 672     CoTaskMemFree(dummyTextHost);
 673 }
 674
 675 static void test_TxGetNaturalSize(void) {
 676     HRESULT result;
 677     BOOL ret;
 678
 679     /* This value is used when calling TxGetNaturalSize.  MSDN says
 680        that this is not supported however a null pointer cannot be
 681        used as it will cause a segmentation violation.  The values in
 682        the structure being pointed to are required to be INT_MAX
 683        otherwise calculations can give wrong values. */
 684     const SIZEL psizelExtent = {INT_MAX,INT_MAX};
 685
 686     static const WCHAR oneA[] = {'A',0};
 687
 688     /* Results of measurements */
 689     LONG xdim, ydim;
 690
 691     /* The device context to do the tests in */
 692     HDC hdcDraw;
 693
 694     /* Variables with the text metric information */
 695     INT charwidth_caps_text[26];
 696     TEXTMETRIC tmInfo_text;
 697
 698     if (!init_texthost())
 699         return;
 700
 701     hdcDraw = GetDC(NULL);
 702     SaveDC(hdcDraw);
 703
 704     /* Populate the metric strucs */
 705     SetMapMode(hdcDraw,MM_TEXT);
 706     GetTextMetrics(hdcDraw, &tmInfo_text);
 707     SetLastError(0xdeadbeef);
 708     ret = GetCharWidth32(hdcDraw,'A','Z',charwidth_caps_text);
 709     if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) {
 710         win_skip("GetCharWidth32 is not available\n");
 711         RestoreDC(hdcDraw,1);
 712         ReleaseDC(NULL,hdcDraw);
 713         return;
 714     }
 715
 716     /* Make measurements in MM_TEXT */
 717     SetMapMode(hdcDraw,MM_TEXT);
 718     xdim = 0; ydim = 0;
 719
 720     result = ITextServices_TxSetText(txtserv, oneA);
 721     ok(result == S_OK, "ITextServices_TxSetText failed\n");
 722
 723     result = ITextServices_TxGetNaturalSize(txtserv, DVASPECT_CONTENT,
 724                                             hdcDraw, NULL, NULL,
 725                                             TXTNS_FITTOCONTENT, &psizelExtent,
 726                                             &xdim, &ydim);
 727     todo_wine ok(result == S_OK, "TxGetNaturalSize failed\n");
 728     todo_wine ok(ydim == tmInfo_text.tmHeight,
 729                  "Height calculated incorrectly (expected %d, got %d)\n",
 730                  tmInfo_text.tmHeight, ydim);
 731     /* The native DLL adds one pixel extra when calculating widths. */
 732     todo_wine ok(xdim >= charwidth_caps_text[0] && xdim <= charwidth_caps_text[0] + 1,
 733                  "Width calculated incorrectly (expected %d {+1}, got %d)\n",
 734                  charwidth_caps_text[0], xdim);
 735
 736     RestoreDC(hdcDraw,1);
 737     ReleaseDC(NULL,hdcDraw);
 738
 739     IUnknown_Release(txtserv);
 740     CoTaskMemFree(dummyTextHost);
 741 }
 742
 743 static void test_TxDraw(void)
 744 {
 745     HDC tmphdc = GetDC(NULL);
 746     DWORD dwAspect = DVASPECT_CONTENT;
 747     HDC hicTargetDev = NULL; /* Means "default" device */
 748     DVTARGETDEVICE *ptd = NULL;
 749     void *pvAspect = NULL;
 750     HRESULT result;
 751     RECTL client = {0,0,100,100};
 752
 753     if (!init_texthost())
 754         return;
 755
 756     todo_wine {
 757         result = ITextServices_TxDraw(txtserv, dwAspect, 0, pvAspect, ptd,
 758                                       tmphdc, hicTargetDev, &client, NULL,
 759                                       NULL, NULL, 0, 0);
 760         ok(result == S_OK, "TxDraw failed\n");
 761     }
 762
 763     IUnknown_Release(txtserv);
 764     CoTaskMemFree(dummyTextHost);
 765
 766 }
 767
 768 START_TEST( txtsrv )
 769 {
 770     setup_thiscall_wrappers();
 771
 772     /* Must explicitly LoadLibrary(). The test has no references to functions in
 773      * RICHED20.DLL, so the linker doesn't actually link to it. */
 774     hmoduleRichEdit = LoadLibrary("RICHED20.DLL");
 775     ok(hmoduleRichEdit != NULL, "error: %d\n", (int) GetLastError());
 776
 777     if (init_texthost())
 778     {
 779         IUnknown_Release(txtserv);
 780         CoTaskMemFree(dummyTextHost);
 781
 782         test_TxGetText();
 783         test_TxSetText();
 784         test_TxGetNaturalSize();
 785         test_TxDraw();
 786     }
 787     if (wrapperCodeMem) VirtualFree(wrapperCodeMem, 0, MEM_RELEASE);
 788 }