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 #define CONST_VTABLE
25 
26 #include <stdio.h>
27 #include <stdarg.h>
28 #include <windef.h>
29 #include <winbase.h>
30 #include <objbase.h>
31 #include <richedit.h>
32 #include <tom.h>
33 #include <richole.h>
34 #include <initguid.h>
35 #include <imm.h>
36 #include <textserv.h>
37 #include <wine/test.h>
38 #include <oleauto.h>
39 #include <limits.h>
40 
41 static HMODULE hmoduleRichEdit;
42 static IID *pIID_ITextServices;
43 static IID *pIID_ITextHost;
44 static IID *pIID_ITextHost2;
45 static PCreateTextServices pCreateTextServices;
46 
47 /* Define C Macros for ITextServices calls. */
48 
49 /* Use a special table for x86 machines to convert the thiscall
50  * calling convention.  This isn't needed on other platforms. */
51 #if defined(__i386__) && !defined(__MINGW32__)
52 static ITextServicesVtbl itextServicesStdcallVtbl;
53 #define TXTSERV_VTABLE(This) (&itextServicesStdcallVtbl)
54 #else /* __i386__ */
55 #define TXTSERV_VTABLE(This) (This)->lpVtbl
56 #endif /* __i386__ */
57 
58 #define ITextServices_TxSendMessage(This,a,b,c,d) TXTSERV_VTABLE(This)->TxSendMessage(This,a,b,c,d)
59 #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)
60 #define ITextServices_TxGetHScroll(This,a,b,c,d,e) TXTSERV_VTABLE(This)->TxGetHScroll(This,a,b,c,d,e)
61 #define ITextServices_TxGetVScroll(This,a,b,c,d,e) TXTSERV_VTABLE(This)->TxGetVScroll(This,a,b,c,d,e)
62 #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)
63 #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)
64 #define ITextServices_OnTxInplaceActivate(This,a) TXTSERV_VTABLE(This)->OnTxInplaceActivate(This,a)
65 #define ITextServices_OnTxInplaceDeactivate(This) TXTSERV_VTABLE(This)->OnTxInplaceDeactivate(This)
66 #define ITextServices_OnTxUIActivate(This) TXTSERV_VTABLE(This)->OnTxUIActivate(This)
67 #define ITextServices_OnTxUIDeactivate(This) TXTSERV_VTABLE(This)->OnTxUIDeactivate(This)
68 #define ITextServices_TxGetText(This,a) TXTSERV_VTABLE(This)->TxGetText(This,a)
69 #define ITextServices_TxSetText(This,a) TXTSERV_VTABLE(This)->TxSetText(This,a)
70 #define ITextServices_TxGetCurTargetX(This,a) TXTSERV_VTABLE(This)->TxGetCurTargetX(This,a)
71 #define ITextServices_TxGetBaseLinePos(This,a) TXTSERV_VTABLE(This)->TxGetBaseLinePos(This,a)
72 #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)
73 #define ITextServices_TxGetDropTarget(This,a) TXTSERV_VTABLE(This)->TxGetDropTarget(This,a)
74 #define ITextServices_OnTxPropertyBitsChange(This,a,b) TXTSERV_VTABLE(This)->OnTxPropertyBitsChange(This,a,b)
75 #define ITextServices_TxGetCachedSize(This,a,b) TXTSERV_VTABLE(This)->TxGetCachedSize(This,a,b)
76 
77 /* Set the WINETEST_DEBUG environment variable to be greater than 1 for verbose
78  * function call traces of ITextHost. */
79 #define TRACECALL if(winetest_debug > 1) trace
80 
81 /************************************************************************/
82 /* ITextHost implementation for conformance testing. */
83 
84 typedef struct ITextHostTestImpl
85 {
86     ITextHost ITextHost_iface;
87     LONG refCount;
88     CHARFORMAT2W char_format;
89 } ITextHostTestImpl;
90 
impl_from_ITextHost(ITextHost * iface)91 static inline ITextHostTestImpl *impl_from_ITextHost(ITextHost *iface)
92 {
93     return CONTAINING_RECORD(iface, ITextHostTestImpl, ITextHost_iface);
94 }
95 
ITextHostImpl_QueryInterface(ITextHost * iface,REFIID riid,LPVOID * ppvObject)96 static HRESULT WINAPI ITextHostImpl_QueryInterface(ITextHost *iface,
97                                                    REFIID riid,
98                                                    LPVOID *ppvObject)
99 {
100     ITextHostTestImpl *This = impl_from_ITextHost(iface);
101 
102     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, pIID_ITextHost)) {
103         *ppvObject = &This->ITextHost_iface;
104         ITextHost_AddRef((ITextHost *)*ppvObject);
105         return S_OK;
106     }
107 
108     return E_NOINTERFACE;
109 }
110 
ITextHostImpl_AddRef(ITextHost * iface)111 static ULONG WINAPI ITextHostImpl_AddRef(ITextHost *iface)
112 {
113     ITextHostTestImpl *This = impl_from_ITextHost(iface);
114     ULONG refCount = InterlockedIncrement(&This->refCount);
115     return refCount;
116 }
117 
ITextHostImpl_Release(ITextHost * iface)118 static ULONG WINAPI ITextHostImpl_Release(ITextHost *iface)
119 {
120     ITextHostTestImpl *This = impl_from_ITextHost(iface);
121     ULONG refCount = InterlockedDecrement(&This->refCount);
122 
123     if (!refCount)
124     {
125         CoTaskMemFree(This);
126         return 0;
127     } else {
128         return refCount;
129     }
130 }
131 
ITextHostImpl_TxGetDC(ITextHost * iface)132 static HDC __thiscall ITextHostImpl_TxGetDC(ITextHost *iface)
133 {
134     ITextHostTestImpl *This = impl_from_ITextHost(iface);
135     TRACECALL("Call to TxGetDC(%p)\n", This);
136     return NULL;
137 }
138 
ITextHostImpl_TxReleaseDC(ITextHost * iface,HDC hdc)139 static INT __thiscall ITextHostImpl_TxReleaseDC(ITextHost *iface, HDC hdc)
140 {
141     ITextHostTestImpl *This = impl_from_ITextHost(iface);
142     TRACECALL("Call to TxReleaseDC(%p)\n", This);
143     return 0;
144 }
145 
ITextHostImpl_TxShowScrollBar(ITextHost * iface,INT fnBar,BOOL fShow)146 static BOOL __thiscall ITextHostImpl_TxShowScrollBar(ITextHost *iface, INT fnBar, BOOL fShow)
147 {
148     ITextHostTestImpl *This = impl_from_ITextHost(iface);
149     TRACECALL("Call to TxShowScrollBar(%p, fnBar=%d, fShow=%d)\n",
150                 This, fnBar, fShow);
151     return FALSE;
152 }
153 
ITextHostImpl_TxEnableScrollBar(ITextHost * iface,INT fuSBFlags,INT fuArrowflags)154 static BOOL __thiscall ITextHostImpl_TxEnableScrollBar(ITextHost *iface, INT fuSBFlags, INT fuArrowflags)
155 {
156     ITextHostTestImpl *This = impl_from_ITextHost(iface);
157     TRACECALL("Call to TxEnableScrollBar(%p, fuSBFlags=%d, fuArrowflags=%d)\n",
158                This, fuSBFlags, fuArrowflags);
159     return FALSE;
160 }
161 
ITextHostImpl_TxSetScrollRange(ITextHost * iface,INT fnBar,LONG nMinPos,INT nMaxPos,BOOL fRedraw)162 static BOOL __thiscall ITextHostImpl_TxSetScrollRange(ITextHost *iface, INT fnBar, LONG nMinPos,
163                                                       INT nMaxPos, BOOL fRedraw)
164 {
165     ITextHostTestImpl *This = impl_from_ITextHost(iface);
166     TRACECALL("Call to TxSetScrollRange(%p, fnBar=%d, nMinPos=%d, nMaxPos=%d, fRedraw=%d)\n",
167                This, fnBar, nMinPos, nMaxPos, fRedraw);
168     return FALSE;
169 }
170 
ITextHostImpl_TxSetScrollPos(ITextHost * iface,INT fnBar,INT nPos,BOOL fRedraw)171 static BOOL __thiscall ITextHostImpl_TxSetScrollPos(ITextHost *iface, INT fnBar, INT nPos, BOOL fRedraw)
172 {
173     ITextHostTestImpl *This = impl_from_ITextHost(iface);
174     TRACECALL("Call to TxSetScrollPos(%p, fnBar=%d, nPos=%d, fRedraw=%d)\n",
175                This, fnBar, nPos, fRedraw);
176     return FALSE;
177 }
178 
ITextHostImpl_TxInvalidateRect(ITextHost * iface,LPCRECT prc,BOOL fMode)179 static void __thiscall ITextHostImpl_TxInvalidateRect(ITextHost *iface, LPCRECT prc, BOOL fMode)
180 {
181     ITextHostTestImpl *This = impl_from_ITextHost(iface);
182     TRACECALL("Call to TxInvalidateRect(%p, prc=%p, fMode=%d)\n",
183                This, prc, fMode);
184 }
185 
ITextHostImpl_TxViewChange(ITextHost * iface,BOOL fUpdate)186 static void __thiscall ITextHostImpl_TxViewChange(ITextHost *iface, BOOL fUpdate)
187 {
188     ITextHostTestImpl *This = impl_from_ITextHost(iface);
189     TRACECALL("Call to TxViewChange(%p, fUpdate=%d)\n",
190                This, fUpdate);
191 }
192 
ITextHostImpl_TxCreateCaret(ITextHost * iface,HBITMAP hbmp,INT xWidth,INT yHeight)193 static BOOL __thiscall ITextHostImpl_TxCreateCaret(ITextHost *iface, HBITMAP hbmp, INT xWidth, INT yHeight)
194 {
195     ITextHostTestImpl *This = impl_from_ITextHost(iface);
196     TRACECALL("Call to TxCreateCaret(%p, nbmp=%p, xWidth=%d, yHeight=%d)\n",
197                This, hbmp, xWidth, yHeight);
198     return FALSE;
199 }
200 
ITextHostImpl_TxShowCaret(ITextHost * iface,BOOL fShow)201 static BOOL __thiscall ITextHostImpl_TxShowCaret(ITextHost *iface, BOOL fShow)
202 {
203     ITextHostTestImpl *This = impl_from_ITextHost(iface);
204     TRACECALL("Call to TxShowCaret(%p, fShow=%d)\n",
205                This, fShow);
206     return FALSE;
207 }
208 
ITextHostImpl_TxSetCaretPos(ITextHost * iface,INT x,INT y)209 static BOOL __thiscall ITextHostImpl_TxSetCaretPos(ITextHost *iface, INT x, INT y)
210 {
211     ITextHostTestImpl *This = impl_from_ITextHost(iface);
212     TRACECALL("Call to TxSetCaretPos(%p, x=%d, y=%d)\n", This, x, y);
213     return FALSE;
214 }
215 
ITextHostImpl_TxSetTimer(ITextHost * iface,UINT idTimer,UINT uTimeout)216 static BOOL __thiscall ITextHostImpl_TxSetTimer(ITextHost *iface, UINT idTimer, UINT uTimeout)
217 {
218     ITextHostTestImpl *This = impl_from_ITextHost(iface);
219     TRACECALL("Call to TxSetTimer(%p, idTimer=%u, uTimeout=%u)\n",
220               This, idTimer, uTimeout);
221     return FALSE;
222 }
223 
ITextHostImpl_TxKillTimer(ITextHost * iface,UINT idTimer)224 static void __thiscall ITextHostImpl_TxKillTimer(ITextHost *iface, UINT idTimer)
225 {
226     ITextHostTestImpl *This = impl_from_ITextHost(iface);
227     TRACECALL("Call to TxKillTimer(%p, idTimer=%u)\n", This, idTimer);
228 }
229 
ITextHostImpl_TxScrollWindowEx(ITextHost * iface,INT dx,INT dy,LPCRECT lprcScroll,LPCRECT lprcClip,HRGN hRgnUpdate,LPRECT lprcUpdate,UINT fuScroll)230 static void __thiscall ITextHostImpl_TxScrollWindowEx(ITextHost *iface, INT dx, INT dy, LPCRECT lprcScroll,
231                                                       LPCRECT lprcClip, HRGN hRgnUpdate, LPRECT lprcUpdate,
232                                                       UINT fuScroll)
233 {
234     ITextHostTestImpl *This = impl_from_ITextHost(iface);
235     TRACECALL("Call to TxScrollWindowEx(%p, %d, %d, %p, %p, %p, %p, %d)\n",
236               This, dx, dy, lprcScroll, lprcClip, hRgnUpdate, lprcUpdate, fuScroll);
237 }
238 
ITextHostImpl_TxSetCapture(ITextHost * iface,BOOL fCapture)239 static void __thiscall ITextHostImpl_TxSetCapture(ITextHost *iface, BOOL fCapture)
240 {
241     ITextHostTestImpl *This = impl_from_ITextHost(iface);
242     TRACECALL("Call to TxSetCapture(%p, fCapture=%d)\n", This, fCapture);
243 }
244 
ITextHostImpl_TxSetFocus(ITextHost * iface)245 static void __thiscall ITextHostImpl_TxSetFocus(ITextHost *iface)
246 {
247     ITextHostTestImpl *This = impl_from_ITextHost(iface);
248     TRACECALL("Call to TxSetFocus(%p)\n", This);
249 }
250 
ITextHostImpl_TxSetCursor(ITextHost * iface,HCURSOR hcur,BOOL fText)251 static void __thiscall ITextHostImpl_TxSetCursor(ITextHost *iface, HCURSOR hcur, BOOL fText)
252 {
253     ITextHostTestImpl *This = impl_from_ITextHost(iface);
254     TRACECALL("Call to TxSetCursor(%p, hcur=%p, fText=%d)\n",
255               This, hcur, fText);
256 }
257 
ITextHostImpl_TxScreenToClient(ITextHost * iface,LPPOINT lppt)258 static BOOL __thiscall ITextHostImpl_TxScreenToClient(ITextHost *iface, LPPOINT lppt)
259 {
260     ITextHostTestImpl *This = impl_from_ITextHost(iface);
261     TRACECALL("Call to TxScreenToClient(%p, lppt=%p)\n", This, lppt);
262     return FALSE;
263 }
264 
ITextHostImpl_TxClientToScreen(ITextHost * iface,LPPOINT lppt)265 static BOOL __thiscall ITextHostImpl_TxClientToScreen(ITextHost *iface, LPPOINT lppt)
266 {
267     ITextHostTestImpl *This = impl_from_ITextHost(iface);
268     TRACECALL("Call to TxClientToScreen(%p, lppt=%p)\n", This, lppt);
269     return FALSE;
270 }
271 
ITextHostImpl_TxActivate(ITextHost * iface,LONG * plOldState)272 static HRESULT __thiscall ITextHostImpl_TxActivate(ITextHost *iface, LONG *plOldState)
273 {
274     ITextHostTestImpl *This = impl_from_ITextHost(iface);
275     TRACECALL("Call to TxActivate(%p, plOldState=%p)\n", This, plOldState);
276     return E_NOTIMPL;
277 }
278 
ITextHostImpl_TxDeactivate(ITextHost * iface,LONG lNewState)279 static HRESULT __thiscall ITextHostImpl_TxDeactivate(ITextHost *iface, LONG lNewState)
280 {
281     ITextHostTestImpl *This = impl_from_ITextHost(iface);
282     TRACECALL("Call to TxDeactivate(%p, lNewState=%d)\n", This, lNewState);
283     return E_NOTIMPL;
284 }
285 
ITextHostImpl_TxGetClientRect(ITextHost * iface,LPRECT prc)286 static HRESULT __thiscall ITextHostImpl_TxGetClientRect(ITextHost *iface, LPRECT prc)
287 {
288     ITextHostTestImpl *This = impl_from_ITextHost(iface);
289     TRACECALL("Call to TxGetClientRect(%p, prc=%p)\n", This, prc);
290     return E_NOTIMPL;
291 }
292 
ITextHostImpl_TxGetViewInset(ITextHost * iface,LPRECT prc)293 static HRESULT __thiscall ITextHostImpl_TxGetViewInset(ITextHost *iface, LPRECT prc)
294 {
295     ITextHostTestImpl *This = impl_from_ITextHost(iface);
296     TRACECALL("Call to TxGetViewInset(%p, prc=%p)\n", This, prc);
297     return E_NOTIMPL;
298 }
299 
ITextHostImpl_TxGetCharFormat(ITextHost * iface,const CHARFORMATW ** ppCF)300 static HRESULT __thiscall ITextHostImpl_TxGetCharFormat(ITextHost *iface, const CHARFORMATW **ppCF)
301 {
302     ITextHostTestImpl *This = impl_from_ITextHost(iface);
303     TRACECALL("Call to TxGetCharFormat(%p, ppCF=%p)\n", This, ppCF);
304     *ppCF = (CHARFORMATW *)&This->char_format;
305     return S_OK;
306 }
307 
ITextHostImpl_TxGetParaFormat(ITextHost * iface,const PARAFORMAT ** ppPF)308 static HRESULT __thiscall ITextHostImpl_TxGetParaFormat(ITextHost *iface, const PARAFORMAT **ppPF)
309 {
310     ITextHostTestImpl *This = impl_from_ITextHost(iface);
311     TRACECALL("Call to TxGetParaFormat(%p, ppPF=%p)\n", This, ppPF);
312     return E_NOTIMPL;
313 }
314 
ITextHostImpl_TxGetSysColor(ITextHost * iface,int nIndex)315 static COLORREF __thiscall ITextHostImpl_TxGetSysColor(ITextHost *iface, int nIndex)
316 {
317     ITextHostTestImpl *This = impl_from_ITextHost(iface);
318     TRACECALL("Call to TxGetSysColor(%p, nIndex=%d)\n", This, nIndex);
319     return E_NOTIMPL;
320 }
321 
ITextHostImpl_TxGetBackStyle(ITextHost * iface,TXTBACKSTYLE * pStyle)322 static HRESULT __thiscall ITextHostImpl_TxGetBackStyle(ITextHost *iface, TXTBACKSTYLE *pStyle)
323 {
324     ITextHostTestImpl *This = impl_from_ITextHost(iface);
325     TRACECALL("Call to TxGetBackStyle(%p, pStyle=%p)\n", This, pStyle);
326     return E_NOTIMPL;
327 }
328 
ITextHostImpl_TxGetMaxLength(ITextHost * iface,DWORD * pLength)329 static HRESULT __thiscall ITextHostImpl_TxGetMaxLength(ITextHost *iface, DWORD *pLength)
330 {
331     ITextHostTestImpl *This = impl_from_ITextHost(iface);
332     TRACECALL("Call to TxGetMaxLength(%p, pLength=%p)\n", This, pLength);
333     return E_NOTIMPL;
334 }
335 
ITextHostImpl_TxGetScrollBars(ITextHost * iface,DWORD * pdwScrollBar)336 static HRESULT __thiscall ITextHostImpl_TxGetScrollBars(ITextHost *iface, DWORD *pdwScrollBar)
337 {
338     ITextHostTestImpl *This = impl_from_ITextHost(iface);
339     TRACECALL("Call to TxGetScrollBars(%p, pdwScrollBar=%p)\n",
340                This, pdwScrollBar);
341     return E_NOTIMPL;
342 }
343 
ITextHostImpl_TxGetPasswordChar(ITextHost * iface,WCHAR * pch)344 static HRESULT __thiscall ITextHostImpl_TxGetPasswordChar(ITextHost *iface, WCHAR *pch)
345 {
346     ITextHostTestImpl *This = impl_from_ITextHost(iface);
347     TRACECALL("Call to TxGetPasswordChar(%p, pch=%p)\n", This, pch);
348     return E_NOTIMPL;
349 }
350 
ITextHostImpl_TxGetAcceleratorPos(ITextHost * iface,LONG * pch)351 static HRESULT __thiscall ITextHostImpl_TxGetAcceleratorPos(ITextHost *iface, LONG *pch)
352 {
353     ITextHostTestImpl *This = impl_from_ITextHost(iface);
354     TRACECALL("Call to TxGetAcceleratorPos(%p, pch=%p)\n", This, pch);
355     return E_NOTIMPL;
356 }
357 
ITextHostImpl_TxGetExtent(ITextHost * iface,LPSIZEL lpExtent)358 static HRESULT __thiscall ITextHostImpl_TxGetExtent(ITextHost *iface, LPSIZEL lpExtent)
359 {
360     ITextHostTestImpl *This = impl_from_ITextHost(iface);
361     TRACECALL("Call to TxGetExtent(%p, lpExtent=%p)\n", This, lpExtent);
362     return E_NOTIMPL;
363 }
364 
ITextHostImpl_OnTxCharFormatChange(ITextHost * iface,const CHARFORMATW * pcf)365 static HRESULT __thiscall ITextHostImpl_OnTxCharFormatChange(ITextHost *iface, const CHARFORMATW *pcf)
366 {
367     ITextHostTestImpl *This = impl_from_ITextHost(iface);
368     TRACECALL("Call to OnTxCharFormatChange(%p, pcf=%p)\n", This, pcf);
369     return E_NOTIMPL;
370 }
371 
ITextHostImpl_OnTxParaFormatChange(ITextHost * iface,const PARAFORMAT * ppf)372 static HRESULT __thiscall ITextHostImpl_OnTxParaFormatChange(ITextHost *iface, const PARAFORMAT *ppf)
373 {
374     ITextHostTestImpl *This = impl_from_ITextHost(iface);
375     TRACECALL("Call to OnTxParaFormatChange(%p, ppf=%p)\n", This, ppf);
376     return E_NOTIMPL;
377 }
378 
379 /* This must return S_OK for the native ITextServices object to
380    initialize. */
ITextHostImpl_TxGetPropertyBits(ITextHost * iface,DWORD dwMask,DWORD * pdwBits)381 static HRESULT __thiscall ITextHostImpl_TxGetPropertyBits(ITextHost *iface, DWORD dwMask, DWORD *pdwBits)
382 {
383     ITextHostTestImpl *This = impl_from_ITextHost(iface);
384     TRACECALL("Call to TxGetPropertyBits(%p, dwMask=0x%08x, pdwBits=%p)\n",
385               This, dwMask, pdwBits);
386     *pdwBits = 0;
387     return S_OK;
388 }
389 
ITextHostImpl_TxNotify(ITextHost * iface,DWORD iNotify,void * pv)390 static HRESULT __thiscall ITextHostImpl_TxNotify(ITextHost *iface, DWORD iNotify, void *pv)
391 {
392     ITextHostTestImpl *This = impl_from_ITextHost(iface);
393     TRACECALL("Call to TxNotify(%p, iNotify=%d, pv=%p)\n", This, iNotify, pv);
394     return E_NOTIMPL;
395 }
396 
ITextHostImpl_TxImmGetContext(ITextHost * iface)397 static HIMC __thiscall ITextHostImpl_TxImmGetContext(ITextHost *iface)
398 {
399     ITextHostTestImpl *This = impl_from_ITextHost(iface);
400     TRACECALL("Call to TxImmGetContext(%p)\n", This);
401     return 0;
402 }
403 
ITextHostImpl_TxImmReleaseContext(ITextHost * iface,HIMC himc)404 static void __thiscall ITextHostImpl_TxImmReleaseContext(ITextHost *iface, HIMC himc)
405 {
406     ITextHostTestImpl *This = impl_from_ITextHost(iface);
407     TRACECALL("Call to TxImmReleaseContext(%p, himc=%p)\n", This, himc);
408 }
409 
410 /* This function must set the variable pointed to by *lSelBarWidth.
411    Otherwise an uninitialized value will be used to calculate
412    positions and sizes even if E_NOTIMPL is returned. */
ITextHostImpl_TxGetSelectionBarWidth(ITextHost * iface,LONG * lSelBarWidth)413 static HRESULT __thiscall ITextHostImpl_TxGetSelectionBarWidth(ITextHost *iface, LONG *lSelBarWidth)
414 {
415     ITextHostTestImpl *This = impl_from_ITextHost(iface);
416     TRACECALL("Call to TxGetSelectionBarWidth(%p, lSelBarWidth=%p)\n",
417                 This, lSelBarWidth);
418     *lSelBarWidth = 0;
419     return E_NOTIMPL;
420 }
421 
422 static ITextHostVtbl itextHostVtbl = {
423     ITextHostImpl_QueryInterface,
424     ITextHostImpl_AddRef,
425     ITextHostImpl_Release,
426     ITextHostImpl_TxGetDC,
427     ITextHostImpl_TxReleaseDC,
428     ITextHostImpl_TxShowScrollBar,
429     ITextHostImpl_TxEnableScrollBar,
430     ITextHostImpl_TxSetScrollRange,
431     ITextHostImpl_TxSetScrollPos,
432     ITextHostImpl_TxInvalidateRect,
433     ITextHostImpl_TxViewChange,
434     ITextHostImpl_TxCreateCaret,
435     ITextHostImpl_TxShowCaret,
436     ITextHostImpl_TxSetCaretPos,
437     ITextHostImpl_TxSetTimer,
438     ITextHostImpl_TxKillTimer,
439     ITextHostImpl_TxScrollWindowEx,
440     ITextHostImpl_TxSetCapture,
441     ITextHostImpl_TxSetFocus,
442     ITextHostImpl_TxSetCursor,
443     ITextHostImpl_TxScreenToClient,
444     ITextHostImpl_TxClientToScreen,
445     ITextHostImpl_TxActivate,
446     ITextHostImpl_TxDeactivate,
447     ITextHostImpl_TxGetClientRect,
448     ITextHostImpl_TxGetViewInset,
449     ITextHostImpl_TxGetCharFormat,
450     ITextHostImpl_TxGetParaFormat,
451     ITextHostImpl_TxGetSysColor,
452     ITextHostImpl_TxGetBackStyle,
453     ITextHostImpl_TxGetMaxLength,
454     ITextHostImpl_TxGetScrollBars,
455     ITextHostImpl_TxGetPasswordChar,
456     ITextHostImpl_TxGetAcceleratorPos,
457     ITextHostImpl_TxGetExtent,
458     ITextHostImpl_OnTxCharFormatChange,
459     ITextHostImpl_OnTxParaFormatChange,
460     ITextHostImpl_TxGetPropertyBits,
461     ITextHostImpl_TxNotify,
462     ITextHostImpl_TxImmGetContext,
463     ITextHostImpl_TxImmReleaseContext,
464     ITextHostImpl_TxGetSelectionBarWidth
465 };
466 
467 static void *wrapperCodeMem = NULL;
468 
469 #include "pshpack1.h"
470 
471 /* Code structure for x86 byte code */
472 typedef struct
473 {
474     BYTE pop_eax;  /* popl  %eax  */
475     BYTE push_ecx; /* pushl %ecx  */
476     BYTE push_eax; /* pushl %eax  */
477     BYTE jmp_func; /* jmp   $func */
478     DWORD func;
479 } THISCALL_TO_STDCALL_THUNK;
480 
481 typedef struct
482 {
483     BYTE pop_eax;               /* popl  %eax */
484     BYTE pop_ecx;               /* popl  %ecx */
485     BYTE push_eax;              /* pushl %eax */
486     BYTE mov_vtable_eax[2];     /* movl (%ecx), %eax */
487     BYTE jmp_eax[2];            /* jmp *$vtablefunc_offset(%eax) */
488     int  vtablefunc_offset;
489 } STDCALL_TO_THISCALL_THUNK;
490 
491 #include "poppack.h"
492 
setup_thiscall_wrappers(void)493 static void setup_thiscall_wrappers(void)
494 {
495 #if defined(__i386__) && !defined(__MINGW32__)
496     void** pVtable;
497     void** pVtableEnd;
498     THISCALL_TO_STDCALL_THUNK *thunk;
499     STDCALL_TO_THISCALL_THUNK *thunk2;
500 
501     wrapperCodeMem = VirtualAlloc(NULL,
502                                   (sizeof(ITextHostVtbl)/sizeof(void*) - 3)
503                                     * sizeof(THISCALL_TO_STDCALL_THUNK)
504                                   +(sizeof(ITextServicesVtbl)/sizeof(void*) - 3)
505                                     * sizeof(STDCALL_TO_THISCALL_THUNK),
506                                   MEM_COMMIT, PAGE_EXECUTE_READWRITE);
507     thunk = wrapperCodeMem;
508 
509     /* Wrap all ITextHostImpl methods with code to perform a thiscall to
510      * stdcall conversion. The thiscall calling convention places the This
511      * pointer in ecx on the x86 platform, and the stdcall calling convention
512      * pushes the This pointer on the stack as the first argument.
513      *
514      * The byte code does the conversion then jumps to the real function.
515      *
516      * Each wrapper needs to be modified so that the function to jump to is
517      * modified in the byte code. */
518 
519     /* Skip QueryInterface, AddRef, and Release native actually
520      * defined them with the stdcall calling convention. */
521     pVtable = (void**)&itextHostVtbl + 3;
522     pVtableEnd = (void**)(&itextHostVtbl + 1);
523     while (pVtable != pVtableEnd) {
524         /* write byte code to executable memory */
525         thunk->pop_eax = 0x58;  /* popl  %eax  */
526         thunk->push_ecx = 0x51; /* pushl %ecx  */
527         thunk->push_eax = 0x50; /* pushl %eax  */
528         thunk->jmp_func = 0xe9; /* jmp   $func */
529         /* The address needs to be relative to the end of the jump instructions. */
530         thunk->func = (char*)*pVtable - (char*)(&thunk->func + 1);
531         *pVtable = thunk;
532         pVtable++;
533         thunk++;
534     }
535 
536     /* Setup an ITextServices standard call vtable that will call the
537      * native thiscall vtable when the methods are called. */
538 
539     /* QueryInterface, AddRef, and Release should be called directly on the
540      * real vtable since they use the stdcall calling convention. */
541     thunk2 = (STDCALL_TO_THISCALL_THUNK *)thunk;
542     pVtable = (void**)&itextServicesStdcallVtbl + 3;
543     pVtableEnd = (void**)(&itextServicesStdcallVtbl + 1);
544     while (pVtable != pVtableEnd) {
545         /* write byte code to executable memory */
546         thunk2->pop_eax = 0x58;               /* popl  %eax */
547         thunk2->pop_ecx = 0x59;               /* popl  %ecx */
548         thunk2->push_eax = 0x50;              /* pushl %eax */
549         thunk2->mov_vtable_eax[0] = 0x8b;     /* movl (%ecx), %eax */
550         thunk2->mov_vtable_eax[1] = 0x01;
551         thunk2->jmp_eax[0] = 0xff;            /* jmp *$vtablefunc_offset(%eax) */
552         thunk2->jmp_eax[1] = 0xa0;
553         thunk2->vtablefunc_offset = (char*)pVtable - (char*)&itextServicesStdcallVtbl;
554         *pVtable = thunk2;
555         pVtable++;
556         thunk2++;
557     }
558 #endif /* __i386__ */
559 }
560 
hf_to_cf(HFONT hf,CHARFORMAT2W * cf)561 static void hf_to_cf(HFONT hf, CHARFORMAT2W *cf)
562 {
563     LOGFONTW lf;
564 
565     GetObjectW(hf, sizeof(lf), &lf);
566     lstrcpyW(cf->szFaceName, lf.lfFaceName);
567     cf->yHeight = MulDiv(abs(lf.lfHeight), 1440, GetDeviceCaps(GetDC(NULL), LOGPIXELSY));
568     if (lf.lfWeight > FW_NORMAL) cf->dwEffects |= CFE_BOLD;
569     if (lf.lfItalic) cf->dwEffects |= CFE_ITALIC;
570     if (lf.lfUnderline) cf->dwEffects |= CFE_UNDERLINE;
571     if (lf.lfStrikeOut) cf->dwEffects |= CFE_SUBSCRIPT;
572     cf->bPitchAndFamily = lf.lfPitchAndFamily;
573     cf->bCharSet = lf.lfCharSet;
574 }
575 
576 /*************************************************************************/
577 /* Conformance test functions. */
578 
579 /* Initialize the test texthost structure */
init_texthost(ITextServices ** txtserv,ITextHost ** ret)580 static BOOL init_texthost(ITextServices **txtserv, ITextHost **ret)
581 {
582     ITextHostTestImpl *dummyTextHost;
583     IUnknown *init;
584     HRESULT result;
585     HFONT hf;
586 
587     dummyTextHost = CoTaskMemAlloc(sizeof(*dummyTextHost));
588     if (dummyTextHost == NULL) {
589         win_skip("Insufficient memory to create ITextHost interface\n");
590         return FALSE;
591     }
592     dummyTextHost->ITextHost_iface.lpVtbl = &itextHostVtbl;
593     dummyTextHost->refCount = 1;
594     memset(&dummyTextHost->char_format, 0, sizeof(dummyTextHost->char_format));
595     dummyTextHost->char_format.cbSize = sizeof(dummyTextHost->char_format);
596     dummyTextHost->char_format.dwMask = CFM_ALL2;
597     hf = GetStockObject(DEFAULT_GUI_FONT);
598     hf_to_cf(hf, &dummyTextHost->char_format);
599 
600     /* MSDN states that an IUnknown object is returned by
601        CreateTextServices which is then queried to obtain a
602        ITextServices object. */
603     result = pCreateTextServices(NULL, &dummyTextHost->ITextHost_iface, &init);
604     ok(result == S_OK, "Did not return S_OK when created (result =  %x)\n", result);
605     if (result != S_OK) {
606         CoTaskMemFree(dummyTextHost);
607         win_skip("CreateTextServices failed.\n");
608         return FALSE;
609     }
610 
611     result = IUnknown_QueryInterface(init, pIID_ITextServices, (void**)txtserv);
612     ok((result == S_OK) && (*txtserv != NULL), "Querying interface failed (result = %x, txtserv = %p)\n", result, *txtserv);
613     IUnknown_Release(init);
614     if (!((result == S_OK) && (*txtserv != NULL))) {
615         CoTaskMemFree(dummyTextHost);
616         win_skip("Could not retrieve ITextServices interface\n");
617         return FALSE;
618     }
619 
620     *ret = &dummyTextHost->ITextHost_iface;
621     return TRUE;
622 }
623 
test_TxGetText(void)624 static void test_TxGetText(void)
625 {
626     ITextServices *txtserv;
627     ITextHost *host;
628     HRESULT hres;
629     BSTR rettext;
630 
631     if (!init_texthost(&txtserv, &host))
632         return;
633 
634     hres = ITextServices_TxGetText(txtserv, &rettext);
635     ok(hres == S_OK, "ITextServices_TxGetText failed (result = %x)\n", hres);
636     SysFreeString(rettext);
637 
638     ITextServices_Release(txtserv);
639     ITextHost_Release(host);
640 }
641 
test_TxSetText(void)642 static void test_TxSetText(void)
643 {
644     ITextServices *txtserv;
645     ITextHost *host;
646     HRESULT hres;
647     BSTR rettext;
648     WCHAR settext[] = {'T','e','s','t',0};
649 
650     if (!init_texthost(&txtserv, &host))
651         return;
652 
653     hres = ITextServices_TxSetText(txtserv, settext);
654     ok(hres == S_OK, "ITextServices_TxSetText failed (result = %x)\n", hres);
655 
656     hres = ITextServices_TxGetText(txtserv, &rettext);
657     ok(hres == S_OK, "ITextServices_TxGetText failed (result = %x)\n", hres);
658 
659     ok(SysStringLen(rettext) == 4,
660                  "String returned of wrong length (expected 4, got %d)\n", SysStringLen(rettext));
661     ok(memcmp(rettext,settext,SysStringByteLen(rettext)) == 0,
662                  "String returned differs\n");
663 
664     SysFreeString(rettext);
665 
666     /* Null-pointer should behave the same as empty-string */
667 
668     hres = ITextServices_TxSetText(txtserv, 0);
669     ok(hres == S_OK, "ITextServices_TxSetText failed (result = %x)\n", hres);
670 
671     hres = ITextServices_TxGetText(txtserv, &rettext);
672     ok(hres == S_OK, "ITextServices_TxGetText failed (result = %x)\n", hres);
673     ok(SysStringLen(rettext) == 0,
674                  "String returned of wrong length (expected 0, got %d)\n", SysStringLen(rettext));
675 
676     SysFreeString(rettext);
677     ITextServices_Release(txtserv);
678     ITextHost_Release(host);
679 }
680 
681 #define CHECK_TXGETNATURALSIZE(res,width,height,hdc,rect,string) \
682     _check_txgetnaturalsize(res, width, height, hdc, rect, string, __LINE__)
_check_txgetnaturalsize(HRESULT res,LONG width,LONG height,HDC hdc,RECT rect,LPCWSTR string,int line)683 static void _check_txgetnaturalsize(HRESULT res, LONG width, LONG height, HDC hdc, RECT rect, LPCWSTR string, int line)
684 {
685     RECT expected_rect = rect;
686     LONG expected_width, expected_height;
687 
688     DrawTextW(hdc, string, -1, &expected_rect, DT_LEFT | DT_CALCRECT | DT_NOCLIP | DT_EDITCONTROL | DT_WORDBREAK);
689     expected_width = expected_rect.right - expected_rect.left;
690     expected_height = expected_rect.bottom - expected_rect.top;
691     ok_(__FILE__,line)(res == S_OK, "ITextServices_TxGetNaturalSize failed: 0x%08x.\n", res);
692     ok_(__FILE__,line)(width >= expected_width && width <= expected_width + 1,
693                        "got wrong width: %d, expected: %d {+1}.\n", width, expected_width);
694     ok_(__FILE__,line)(height == expected_height, "got wrong height: %d, expected: %d.\n",
695                        height, expected_height);
696 }
697 
test_TxGetNaturalSize(void)698 static void test_TxGetNaturalSize(void)
699 {
700     ITextServices *txtserv;
701     ITextHost *host;
702     HRESULT result;
703     SIZEL extent;
704     static const WCHAR test_text[] = {'T','e','s','t','S','o','m','e','T','e','x','t',0};
705     LONG width, height;
706     HDC hdcDraw;
707     HWND hwnd;
708     RECT rect;
709     CHARFORMAT2W cf;
710     LRESULT lresult;
711     HFONT hf;
712 
713     if (!init_texthost(&txtserv, &host))
714         return;
715 
716     hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP | WS_VISIBLE,
717                            0, 0, 100, 100, 0, 0, 0, NULL);
718     hdcDraw = GetDC(hwnd);
719     SetMapMode(hdcDraw,MM_TEXT);
720     GetClientRect(hwnd, &rect);
721 
722     memset(&cf, 0, sizeof(cf));
723     cf.cbSize = sizeof(cf);
724     cf.dwMask = CFM_ALL2;
725     hf = GetStockObject(DEFAULT_GUI_FONT);
726     hf_to_cf(hf, &cf);
727     result = ITextServices_TxSendMessage(txtserv, EM_SETCHARFORMAT, SCF_DEFAULT, (LPARAM)&cf, &lresult);
728     ok(result == S_OK, "ITextServices_TxSendMessage failed: 0x%08x.\n", result);
729     SelectObject(hdcDraw, hf);
730 
731     result = ITextServices_TxSetText(txtserv, test_text);
732     ok(result == S_OK, "ITextServices_TxSetText failed: 0x%08x.\n", result);
733 
734     extent.cx = -1; extent.cy = -1;
735     width = rect.right - rect.left;
736     height = 0;
737     result = ITextServices_TxGetNaturalSize(txtserv, DVASPECT_CONTENT, hdcDraw, NULL, NULL,
738                                             TXTNS_FITTOCONTENT, &extent, &width, &height);
739     todo_wine CHECK_TXGETNATURALSIZE(result, width, height, hdcDraw, rect, test_text);
740 
741     ReleaseDC(hwnd, hdcDraw);
742     DestroyWindow(hwnd);
743     ITextServices_Release(txtserv);
744     ITextHost_Release(host);
745 }
746 
test_TxDraw(void)747 static void test_TxDraw(void)
748 {
749     ITextServices *txtserv;
750     ITextHost *host;
751     HDC tmphdc = GetDC(NULL);
752     DWORD dwAspect = DVASPECT_CONTENT;
753     HDC hicTargetDev = NULL; /* Means "default" device */
754     DVTARGETDEVICE *ptd = NULL;
755     void *pvAspect = NULL;
756     HRESULT result;
757     RECTL client = {0,0,100,100};
758 
759 
760     if (!init_texthost(&txtserv, &host))
761         return;
762 
763     todo_wine {
764         result = ITextServices_TxDraw(txtserv, dwAspect, 0, pvAspect, ptd,
765                                       tmphdc, hicTargetDev, &client, NULL,
766                                       NULL, NULL, 0, 0);
767         ok(result == S_OK, "TxDraw failed (result = %x)\n", result);
768     }
769 
770     ITextServices_Release(txtserv);
771     ITextHost_Release(host);
772 }
773 
774 DEFINE_GUID(expected_iid_itextservices, 0x8d33f740, 0xcf58, 0x11ce, 0xa8, 0x9d, 0x00, 0xaa, 0x00, 0x6c, 0xad, 0xc5);
775 DEFINE_GUID(expected_iid_itexthost, 0x13e670f4,0x1a5a,0x11cf,0xab,0xeb,0x00,0xaa,0x00,0xb6,0x5e,0xa1);
776 DEFINE_GUID(expected_iid_itexthost2, 0x13e670f5,0x1a5a,0x11cf,0xab,0xeb,0x00,0xaa,0x00,0xb6,0x5e,0xa1);
777 
test_IIDs(void)778 static void test_IIDs(void)
779 {
780     ok(IsEqualIID(pIID_ITextServices, &expected_iid_itextservices),
781        "unexpected value for IID_ITextServices: %s\n", wine_dbgstr_guid(pIID_ITextServices));
782     ok(IsEqualIID(pIID_ITextHost, &expected_iid_itexthost),
783        "unexpected value for IID_ITextHost: %s\n", wine_dbgstr_guid(pIID_ITextHost));
784     ok(IsEqualIID(pIID_ITextHost2, &expected_iid_itexthost2),
785        "unexpected value for IID_ITextHost2: %s\n", wine_dbgstr_guid(pIID_ITextHost2));
786 }
787 
788 /* Outer IUnknown for COM aggregation tests */
789 struct unk_impl {
790     IUnknown IUnknown_iface;
791     LONG ref;
792     IUnknown *inner_unk;
793 };
794 
impl_from_IUnknown(IUnknown * iface)795 static inline struct unk_impl *impl_from_IUnknown(IUnknown *iface)
796 {
797     return CONTAINING_RECORD(iface, struct unk_impl, IUnknown_iface);
798 }
799 
unk_QueryInterface(IUnknown * iface,REFIID riid,void ** ppv)800 static HRESULT WINAPI unk_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
801 {
802     struct unk_impl *This = impl_from_IUnknown(iface);
803 
804     return IUnknown_QueryInterface(This->inner_unk, riid, ppv);
805 }
806 
unk_AddRef(IUnknown * iface)807 static ULONG WINAPI unk_AddRef(IUnknown *iface)
808 {
809     struct unk_impl *This = impl_from_IUnknown(iface);
810 
811     return InterlockedIncrement(&This->ref);
812 }
813 
unk_Release(IUnknown * iface)814 static ULONG WINAPI unk_Release(IUnknown *iface)
815 {
816     struct unk_impl *This = impl_from_IUnknown(iface);
817 
818     return InterlockedDecrement(&This->ref);
819 }
820 
821 static const IUnknownVtbl unk_vtbl =
822 {
823     unk_QueryInterface,
824     unk_AddRef,
825     unk_Release
826 };
827 
test_COM(void)828 static void test_COM(void)
829 {
830     struct unk_impl unk_obj = {{&unk_vtbl}, 19, NULL};
831     struct ITextHostTestImpl texthost = {{&itextHostVtbl}, 1};
832     ITextServices *textsrv;
833     ULONG refcount;
834     HRESULT hr;
835 
836     /* COM aggregation */
837     hr = pCreateTextServices(&unk_obj.IUnknown_iface, &texthost.ITextHost_iface,
838                              &unk_obj.inner_unk);
839     ok(hr == S_OK, "CreateTextServices failed: %08x\n", hr);
840     hr = IUnknown_QueryInterface(unk_obj.inner_unk, pIID_ITextServices, (void**)&textsrv);
841     ok(hr == S_OK, "QueryInterface for IID_ITextServices failed: %08x\n", hr);
842     refcount = ITextServices_AddRef(textsrv);
843     ok(refcount == unk_obj.ref, "CreateTextServices just pretends to support COM aggregation\n");
844     refcount = ITextServices_Release(textsrv);
845     ok(refcount == unk_obj.ref, "CreateTextServices just pretends to support COM aggregation\n");
846     refcount = ITextServices_Release(textsrv);
847     ok(refcount == 19, "Refcount should be back at 19 but is %u\n", refcount);
848 
849     IUnknown_Release(unk_obj.inner_unk);
850 }
851 
get_refcount(IUnknown * iface)852 static ULONG get_refcount(IUnknown *iface)
853 {
854     IUnknown_AddRef(iface);
855     return IUnknown_Release(iface);
856 }
857 
test_QueryInterface(void)858 static void test_QueryInterface(void)
859 {
860     ITextServices *txtserv;
861     ITextHost *host;
862     HRESULT hres;
863     IRichEditOle *reole, *txtsrv_reole;
864     ITextDocument *txtdoc, *txtsrv_txtdoc;
865     ITextDocument2Old *txtdoc2old, *txtsrv_txtdoc2old;
866     ULONG refcount;
867 
868     if(!init_texthost(&txtserv, &host))
869         return;
870 
871     refcount = get_refcount((IUnknown *)txtserv);
872     ok(refcount == 1, "got wrong ref count: %d\n", refcount);
873 
874     /* IID_IRichEditOle */
875     hres = ITextServices_QueryInterface(txtserv, &IID_IRichEditOle, (void **)&txtsrv_reole);
876     ok(hres == S_OK, "ITextServices_QueryInterface: 0x%08x\n", hres);
877     refcount = get_refcount((IUnknown *)txtserv);
878     ok(refcount == 2, "got wrong ref count: %d\n", refcount);
879     refcount = get_refcount((IUnknown *)txtsrv_reole);
880     ok(refcount == 2, "got wrong ref count: %d\n", refcount);
881 
882     hres = IRichEditOle_QueryInterface(txtsrv_reole, &IID_ITextDocument, (void **)&txtdoc);
883     ok(hres == S_OK, "IRichEditOle_QueryInterface: 0x%08x\n", hres);
884     refcount = get_refcount((IUnknown *)txtserv);
885     ok(refcount == 3, "got wrong ref count: %d\n", refcount);
886     refcount = get_refcount((IUnknown *)txtsrv_reole);
887     ok(refcount == 3, "got wrong ref count: %d\n", refcount);
888 
889     ITextDocument_Release(txtdoc);
890     refcount = get_refcount((IUnknown *)txtserv);
891     ok(refcount == 2, "got wrong ref count: %d\n", refcount);
892 
893     hres = IRichEditOle_QueryInterface(txtsrv_reole, &IID_ITextDocument2Old, (void **)&txtdoc2old);
894     ok(hres == S_OK, "IRichEditOle_QueryInterface: 0x%08x\n", hres);
895     refcount = get_refcount((IUnknown *)txtserv);
896     ok(refcount == 3, "got wrong ref count: %d\n", refcount);
897     refcount = get_refcount((IUnknown *)txtsrv_reole);
898     ok(refcount == 3, "got wrong ref count: %d\n", refcount);
899 
900     ITextDocument2Old_Release(txtdoc2old);
901     refcount = get_refcount((IUnknown *)txtserv);
902     ok(refcount == 2, "got wrong ref count: %d\n", refcount);
903     IRichEditOle_Release(txtsrv_reole);
904     refcount = get_refcount((IUnknown *)txtserv);
905     ok(refcount == 1, "got wrong ref count: %d\n", refcount);
906 
907     /* IID_ITextDocument */
908     hres = ITextServices_QueryInterface(txtserv, &IID_ITextDocument, (void **)&txtsrv_txtdoc);
909     ok(hres == S_OK, "ITextServices_QueryInterface: 0x%08x\n", hres);
910     refcount = get_refcount((IUnknown *)txtserv);
911     ok(refcount == 2, "got wrong ref count: %d\n", refcount);
912     refcount = get_refcount((IUnknown *)txtsrv_txtdoc);
913     ok(refcount == 2, "got wrong ref count: %d\n", refcount);
914 
915     hres = ITextDocument_QueryInterface(txtsrv_txtdoc, &IID_IRichEditOle, (void **)&reole);
916     ok(hres == S_OK, "ITextDocument_QueryInterface: 0x%08x\n", hres);
917     refcount = get_refcount((IUnknown *)txtserv);
918     ok(refcount == 3, "got wrong ref count: %d\n", refcount);
919     refcount = get_refcount((IUnknown *)txtsrv_txtdoc);
920     ok(refcount == 3, "got wrong ref count: %d\n", refcount);
921 
922     IRichEditOle_Release(reole);
923     refcount = get_refcount((IUnknown *)txtserv);
924     ok(refcount == 2, "got wrong ref count: %d\n", refcount);
925     ITextDocument_Release(txtsrv_txtdoc);
926     refcount = get_refcount((IUnknown *)txtserv);
927     ok(refcount == 1, "got wrong ref count: %d\n", refcount);
928 
929     /* ITextDocument2Old */
930     hres = ITextServices_QueryInterface(txtserv, &IID_ITextDocument2Old, (void **)&txtsrv_txtdoc2old);
931     ok(hres == S_OK, "ITextServices_QueryInterface: 0x%08x\n", hres);
932     refcount = get_refcount((IUnknown *)txtserv);
933     ok(refcount == 2, "got wrong ref count: %d\n", refcount);
934     refcount = get_refcount((IUnknown *)txtsrv_txtdoc2old);
935     ok(refcount == 2, "got wrong ref count: %d\n", refcount);
936 
937     hres = ITextDocument2Old_QueryInterface(txtsrv_txtdoc2old, &IID_IRichEditOle, (void **)&reole);
938     ok(hres == S_OK, "ITextDocument2Old_QueryInterface: 0x%08x\n", hres);
939     refcount = get_refcount((IUnknown *)txtserv);
940     ok(refcount == 3, "got wrong ref count: %d\n", refcount);
941     refcount = get_refcount((IUnknown *)txtsrv_txtdoc2old);
942     ok(refcount == 3, "got wrong ref count: %d\n", refcount);
943 
944     IRichEditOle_Release(reole);
945     refcount = get_refcount((IUnknown *)txtserv);
946     ok(refcount == 2, "got wrong ref count: %d\n", refcount);
947     ITextDocument2Old_Release(txtsrv_txtdoc2old);
948     refcount = get_refcount((IUnknown *)txtserv);
949     ok(refcount == 1, "got wrong ref count: %d\n", refcount);
950 
951     ITextServices_Release(txtserv);
952     ITextHost_Release(host);
953 }
954 
test_default_format(void)955 static void test_default_format(void)
956 {
957     ITextServices *txtserv;
958     ITextHost *host;
959     HRESULT result;
960     LRESULT lresult;
961     CHARFORMAT2W cf2;
962     const CHARFORMATW *host_cf;
963     DWORD expected_effects;
964 
965     if (!init_texthost(&txtserv, &host))
966         return;
967 
968     cf2.cbSize = sizeof(CHARFORMAT2W);
969     result = ITextServices_TxSendMessage(txtserv, EM_GETCHARFORMAT, SCF_DEFAULT, (LPARAM)&cf2, &lresult);
970     ok(result == S_OK, "ITextServices_TxSendMessage failed: 0x%08x.\n", result);
971 
972     ITextHostImpl_TxGetCharFormat(host, &host_cf);
973     ok(!lstrcmpW(host_cf->szFaceName, cf2.szFaceName), "got wrong font name: %s.\n", wine_dbgstr_w(cf2.szFaceName));
974     ok(cf2.yHeight == host_cf->yHeight, "got wrong yHeight: %d, expected %d.\n", cf2.yHeight, host_cf->yHeight);
975     expected_effects = (cf2.dwEffects & ~(CFE_AUTOCOLOR | CFE_AUTOBACKCOLOR));
976     ok(host_cf->dwEffects == expected_effects, "got wrong dwEffects: %x, expected %x.\n", cf2.dwEffects, expected_effects);
977     ok(cf2.bPitchAndFamily == host_cf->bPitchAndFamily, "got wrong bPitchAndFamily: %x, expected %x.\n",
978        cf2.bPitchAndFamily, host_cf->bPitchAndFamily);
979     ok(cf2.bCharSet == host_cf->bCharSet, "got wrong bCharSet: %x, expected %x.\n", cf2.bCharSet, host_cf->bCharSet);
980 
981     ITextServices_Release(txtserv);
982     ITextHost_Release(host);
983 }
984 
test_TxGetScroll(void)985 static void test_TxGetScroll(void)
986 {
987     ITextServices *txtserv;
988     ITextHost *host;
989     HRESULT ret;
990 
991     if (!init_texthost(&txtserv, &host))
992         return;
993 
994     ret = ITextServices_TxGetHScroll(txtserv, NULL, NULL, NULL, NULL, NULL);
995     ok(ret == S_OK, "ITextSerHices_GetVScroll failed: 0x%08x.\n", ret);
996 
997     ret = ITextServices_TxGetVScroll(txtserv, NULL, NULL, NULL, NULL, NULL);
998     ok(ret == S_OK, "ITextServices_GetVScroll failed: 0x%08x.\n", ret);
999 
1000     ITextServices_Release(txtserv);
1001     ITextHost_Release(host);
1002 }
1003 
START_TEST(txtsrv)1004 START_TEST( txtsrv )
1005 {
1006     ITextServices *txtserv;
1007     ITextHost *host;
1008 
1009     setup_thiscall_wrappers();
1010 
1011     /* Must explicitly LoadLibrary(). The test has no references to functions in
1012      * RICHED20.DLL, so the linker doesn't actually link to it. */
1013     hmoduleRichEdit = LoadLibraryA("riched20.dll");
1014     ok(hmoduleRichEdit != NULL, "error: %d\n", (int) GetLastError());
1015 
1016     pIID_ITextServices = (IID*)GetProcAddress(hmoduleRichEdit, "IID_ITextServices");
1017     pIID_ITextHost = (IID*)GetProcAddress(hmoduleRichEdit, "IID_ITextHost");
1018     pIID_ITextHost2 = (IID*)GetProcAddress(hmoduleRichEdit, "IID_ITextHost2");
1019     pCreateTextServices = (void*)GetProcAddress(hmoduleRichEdit, "CreateTextServices");
1020 
1021     test_IIDs();
1022     test_COM();
1023 
1024     if (init_texthost(&txtserv, &host))
1025     {
1026         ITextServices_Release(txtserv);
1027         ITextHost_Release(host);
1028 
1029         test_TxGetText();
1030         test_TxSetText();
1031         test_TxGetNaturalSize();
1032         test_TxDraw();
1033         test_QueryInterface();
1034         test_default_format();
1035         test_TxGetScroll();
1036     }
1037     if (wrapperCodeMem) VirtualFree(wrapperCodeMem, 0, MEM_RELEASE);
1038 }
1039