027795d25f4285e8852cd85cd5fe36e5e17c1ee8
[reactos.git] / rostests / winetests / msctf / inputprocessor.c
1 /*
2 * Unit tests for ITfInputProcessor
3 *
4 * Copyright 2009 Aric Stewart, CodeWeavers
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <stdio.h>
22
23 #define COBJMACROS
24 #define CONST_VTABLE
25 #include "wine/test.h"
26 #include "winuser.h"
27 #include "initguid.h"
28 #include "shlwapi.h"
29 #include "shlguid.h"
30 #include "comcat.h"
31 #include "msctf.h"
32 #include "olectl.h"
33
34 static ITfInputProcessorProfiles* g_ipp;
35 static LANGID gLangid;
36 static ITfCategoryMgr * g_cm = NULL;
37 static ITfThreadMgr* g_tm = NULL;
38 static ITfDocumentMgr *g_dm = NULL;
39 static TfClientId cid = 0;
40 static TfClientId tid = 0;
41
42 static ITextStoreACPSink *ACPSink;
43
44 #define SINK_UNEXPECTED 0
45 #define SINK_EXPECTED 1
46 #define SINK_FIRED 2
47 #define SINK_IGNORE 3
48 #define SINK_OPTIONAL 4
49 #define SINK_SAVE 5
50
51 #define SINK_ACTION_MASK 0xff
52 #define SINK_OPTION_MASK 0xff00
53 #define SINK_EXPECTED_COUNT_MASK 0xff0000
54
55 #define SINK_OPTION_TODO 0x0100
56
57 #define FOCUS_IGNORE (ITfDocumentMgr*)0xffffffff
58 #define FOCUS_SAVE (ITfDocumentMgr*)0xfffffffe
59
60 static BOOL test_ShouldActivate = FALSE;
61 static BOOL test_ShouldDeactivate = FALSE;
62
63 static DWORD tmSinkCookie;
64 static DWORD tmSinkRefCount;
65 static DWORD documentStatus;
66 static ITfDocumentMgr *test_CurrentFocus = NULL;
67 static ITfDocumentMgr *test_PrevFocus = NULL;
68 static ITfDocumentMgr *test_LastCurrentFocus = FOCUS_SAVE;
69 static ITfDocumentMgr *test_FirstPrevFocus = FOCUS_SAVE;
70 static INT test_OnSetFocus = SINK_UNEXPECTED;
71 static INT test_OnInitDocumentMgr = SINK_UNEXPECTED;
72 static INT test_OnPushContext = SINK_UNEXPECTED;
73 static INT test_OnPopContext = SINK_UNEXPECTED;
74 static INT test_KEV_OnSetFocus = SINK_UNEXPECTED;
75 static INT test_ACP_AdviseSink = SINK_UNEXPECTED;
76 static INT test_ACP_GetStatus = SINK_UNEXPECTED;
77 static INT test_ACP_RequestLock = SINK_UNEXPECTED;
78 static INT test_ACP_GetEndACP = SINK_UNEXPECTED;
79 static INT test_ACP_GetSelection = SINK_UNEXPECTED;
80 static INT test_DoEditSession = SINK_UNEXPECTED;
81 static INT test_ACP_InsertTextAtSelection = SINK_UNEXPECTED;
82 static INT test_ACP_SetSelection = SINK_UNEXPECTED;
83 static INT test_OnEndEdit = SINK_UNEXPECTED;
84
85
86 static inline int expected_count(int *sink)
87 {
88 return (*sink & SINK_EXPECTED_COUNT_MASK)>>16;
89 }
90
91 static inline void _sink_fire_ok(INT *sink, const CHAR* name)
92 {
93 int count;
94 int todo = *sink & SINK_OPTION_TODO;
95 int action = *sink & SINK_ACTION_MASK;
96
97 if (winetest_interactive)
98 winetest_trace("firing %s\n",name);
99
100 switch (action)
101 {
102 case SINK_OPTIONAL:
103 case SINK_EXPECTED:
104 count = expected_count(sink);
105 if (count > 1)
106 {
107 count --;
108 *sink = (*sink & ~SINK_EXPECTED_COUNT_MASK) + (count << 16);
109 return;
110 }
111 break;
112 case SINK_IGNORE:
113 winetest_trace("Ignoring %s\n",name);
114 return;
115 case SINK_SAVE:
116 count = expected_count(sink) + 1;
117 *sink = (*sink & ~SINK_EXPECTED_COUNT_MASK) + (count << 16);
118 return;
119 default:
120 if (todo)
121 todo_wine winetest_ok(0, "Unexpected %s sink\n",name);
122 else
123 winetest_ok(0, "Unexpected %s sink\n",name);
124 }
125 *sink = SINK_FIRED;
126 }
127
128 #define sink_fire_ok(a,b) (winetest_set_location(__FILE__,__LINE__), 0) ? 0 : _sink_fire_ok(a,b)
129
130 static inline void _sink_check_ok(INT *sink, const CHAR* name)
131 {
132 int action = *sink & SINK_ACTION_MASK;
133 int todo = *sink & SINK_OPTION_TODO;
134 int count = expected_count(sink);
135
136 switch (action)
137 {
138 case SINK_OPTIONAL:
139 if (winetest_interactive)
140 winetest_trace("optional sink %s not fired\n",name);
141 case SINK_FIRED:
142 break;
143 case SINK_IGNORE:
144 return;
145 case SINK_SAVE:
146 if (count == 0 && winetest_interactive)
147 winetest_trace("optional sink %s not fired\n",name);
148 break;
149 default:
150 if (todo)
151 todo_wine winetest_ok(0, "%s not fired as expected, in state %x\n",name,*sink);
152 else
153 winetest_ok(0, "%s not fired as expected, in state %x\n",name,*sink);
154 }
155 *sink = SINK_UNEXPECTED;
156 }
157
158 #define sink_check_ok(a,b) (winetest_set_location(__FILE__,__LINE__), 0) ? 0 : _sink_check_ok(a,b)
159
160 static inline void _sink_check_saved(INT *sink, ITfDocumentMgr *PrevFocus, ITfDocumentMgr *CurrentFocus, const CHAR* name)
161 {
162 int count = expected_count(sink);
163 _sink_check_ok(sink, name);
164 if (PrevFocus != FOCUS_IGNORE && count != 0)
165 winetest_ok(PrevFocus == test_FirstPrevFocus, "%s expected prev focus %p got %p\n", name, PrevFocus, test_FirstPrevFocus);
166 if (CurrentFocus != FOCUS_IGNORE && count != 0)
167 winetest_ok(CurrentFocus == test_LastCurrentFocus, "%s expected current focus %p got %p\n", name, CurrentFocus, test_LastCurrentFocus);
168 test_FirstPrevFocus = FOCUS_SAVE;
169 test_LastCurrentFocus = FOCUS_SAVE;
170 }
171
172 #define sink_check_saved(s,p,c,n) (winetest_set_location(__FILE__,__LINE__), 0) ? 0 : _sink_check_saved(s,p,c,n)
173
174 /**********************************************************************
175 * ITextStoreACP
176 **********************************************************************/
177 typedef struct tagTextStoreACP
178 {
179 ITextStoreACP ITextStoreACP_iface;
180 LONG refCount;
181
182 } TextStoreACP;
183
184 static inline TextStoreACP *impl_from_ITextStoreACP(ITextStoreACP *iface)
185 {
186 return CONTAINING_RECORD(iface, TextStoreACP, ITextStoreACP_iface);
187 }
188
189 static void TextStoreACP_Destructor(TextStoreACP *This)
190 {
191 HeapFree(GetProcessHeap(),0,This);
192 }
193
194 static HRESULT WINAPI TextStoreACP_QueryInterface(ITextStoreACP *iface, REFIID iid, LPVOID *ppvOut)
195 {
196 TextStoreACP *This = impl_from_ITextStoreACP(iface);
197 *ppvOut = NULL;
198
199 if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITextStoreACP))
200 {
201 *ppvOut = This;
202 }
203
204 if (*ppvOut)
205 {
206 ITextStoreACP_AddRef(iface);
207 return S_OK;
208 }
209
210 return E_NOINTERFACE;
211 }
212
213 static ULONG WINAPI TextStoreACP_AddRef(ITextStoreACP *iface)
214 {
215 TextStoreACP *This = impl_from_ITextStoreACP(iface);
216 return InterlockedIncrement(&This->refCount);
217 }
218
219 static ULONG WINAPI TextStoreACP_Release(ITextStoreACP *iface)
220 {
221 TextStoreACP *This = impl_from_ITextStoreACP(iface);
222 ULONG ret;
223
224 ret = InterlockedDecrement(&This->refCount);
225 if (ret == 0)
226 TextStoreACP_Destructor(This);
227 return ret;
228 }
229
230 static HRESULT WINAPI TextStoreACP_AdviseSink(ITextStoreACP *iface,
231 REFIID riid, IUnknown *punk, DWORD dwMask)
232 {
233 HRESULT hr;
234
235 sink_fire_ok(&test_ACP_AdviseSink,"TextStoreACP_AdviseSink");
236
237 hr = IUnknown_QueryInterface(punk, &IID_ITextStoreACPSink,(LPVOID*)(&ACPSink));
238 ok(SUCCEEDED(hr),"Unable to QueryInterface on sink\n");
239 return S_OK;
240 }
241
242 static HRESULT WINAPI TextStoreACP_UnadviseSink(ITextStoreACP *iface,
243 IUnknown *punk)
244 {
245 trace("\n");
246 return S_OK;
247 }
248
249 static HRESULT WINAPI TextStoreACP_RequestLock(ITextStoreACP *iface,
250 DWORD dwLockFlags, HRESULT *phrSession)
251 {
252 sink_fire_ok(&test_ACP_RequestLock,"TextStoreACP_RequestLock");
253 *phrSession = ITextStoreACPSink_OnLockGranted(ACPSink, dwLockFlags);
254 return S_OK;
255 }
256 static HRESULT WINAPI TextStoreACP_GetStatus(ITextStoreACP *iface,
257 TS_STATUS *pdcs)
258 {
259 sink_fire_ok(&test_ACP_GetStatus,"TextStoreACP_GetStatus");
260 pdcs->dwDynamicFlags = documentStatus;
261 return S_OK;
262 }
263 static HRESULT WINAPI TextStoreACP_QueryInsert(ITextStoreACP *iface,
264 LONG acpTestStart, LONG acpTestEnd, ULONG cch, LONG *pacpResultStart,
265 LONG *pacpResultEnd)
266 {
267 trace("\n");
268 return S_OK;
269 }
270 static HRESULT WINAPI TextStoreACP_GetSelection(ITextStoreACP *iface,
271 ULONG ulIndex, ULONG ulCount, TS_SELECTION_ACP *pSelection, ULONG *pcFetched)
272 {
273 sink_fire_ok(&test_ACP_GetSelection,"TextStoreACP_GetSelection");
274
275 pSelection->acpStart = 10;
276 pSelection->acpEnd = 20;
277 pSelection->style.fInterimChar = 0;
278 pSelection->style.ase = TS_AE_NONE;
279 *pcFetched = 1;
280
281 return S_OK;
282 }
283 static HRESULT WINAPI TextStoreACP_SetSelection(ITextStoreACP *iface,
284 ULONG ulCount, const TS_SELECTION_ACP *pSelection)
285 {
286 sink_fire_ok(&test_ACP_SetSelection,"TextStoreACP_SetSelection");
287 return S_OK;
288 }
289 static HRESULT WINAPI TextStoreACP_GetText(ITextStoreACP *iface,
290 LONG acpStart, LONG acpEnd, WCHAR *pchPlain, ULONG cchPlainReq,
291 ULONG *pcchPlainRet, TS_RUNINFO *prgRunInfo, ULONG cRunInfoReq,
292 ULONG *pcRunInfoRet, LONG *pacpNext)
293 {
294 trace("\n");
295 return S_OK;
296 }
297 static HRESULT WINAPI TextStoreACP_SetText(ITextStoreACP *iface,
298 DWORD dwFlags, LONG acpStart, LONG acpEnd, const WCHAR *pchText,
299 ULONG cch, TS_TEXTCHANGE *pChange)
300 {
301 trace("\n");
302 return S_OK;
303 }
304 static HRESULT WINAPI TextStoreACP_GetFormattedText(ITextStoreACP *iface,
305 LONG acpStart, LONG acpEnd, IDataObject **ppDataObject)
306 {
307 trace("\n");
308 return S_OK;
309 }
310 static HRESULT WINAPI TextStoreACP_GetEmbedded(ITextStoreACP *iface,
311 LONG acpPos, REFGUID rguidService, REFIID riid, IUnknown **ppunk)
312 {
313 trace("\n");
314 return S_OK;
315 }
316 static HRESULT WINAPI TextStoreACP_QueryInsertEmbedded(ITextStoreACP *iface,
317 const GUID *pguidService, const FORMATETC *pFormatEtc, BOOL *pfInsertable)
318 {
319 trace("\n");
320 return S_OK;
321 }
322 static HRESULT WINAPI TextStoreACP_InsertEmbedded(ITextStoreACP *iface,
323 DWORD dwFlags, LONG acpStart, LONG acpEnd, IDataObject *pDataObject,
324 TS_TEXTCHANGE *pChange)
325 {
326 trace("\n");
327 return S_OK;
328 }
329 static HRESULT WINAPI TextStoreACP_InsertTextAtSelection(ITextStoreACP *iface,
330 DWORD dwFlags, const WCHAR *pchText, ULONG cch, LONG *pacpStart,
331 LONG *pacpEnd, TS_TEXTCHANGE *pChange)
332 {
333 sink_fire_ok(&test_ACP_InsertTextAtSelection,"TextStoreACP_InsertTextAtSelection");
334 return S_OK;
335 }
336 static HRESULT WINAPI TextStoreACP_InsertEmbeddedAtSelection(ITextStoreACP *iface,
337 DWORD dwFlags, IDataObject *pDataObject, LONG *pacpStart, LONG *pacpEnd,
338 TS_TEXTCHANGE *pChange)
339 {
340 trace("\n");
341 return S_OK;
342 }
343 static HRESULT WINAPI TextStoreACP_RequestSupportedAttrs(ITextStoreACP *iface,
344 DWORD dwFlags, ULONG cFilterAttrs, const TS_ATTRID *paFilterAttrs)
345 {
346 trace("\n");
347 return S_OK;
348 }
349 static HRESULT WINAPI TextStoreACP_RequestAttrsAtPosition(ITextStoreACP *iface,
350 LONG acpPos, ULONG cFilterAttrs, const TS_ATTRID *paFilterAttrs,
351 DWORD dwFlags)
352 {
353 trace("\n");
354 return S_OK;
355 }
356 static HRESULT WINAPI TextStoreACP_RequestAttrsTransitioningAtPosition(ITextStoreACP *iface,
357 LONG acpPos, ULONG cFilterAttrs, const TS_ATTRID *paFilterAttrs,
358 DWORD dwFlags)
359 {
360 trace("\n");
361 return S_OK;
362 }
363 static HRESULT WINAPI TextStoreACP_FindNextAttrTransition(ITextStoreACP *iface,
364 LONG acpStart, LONG acpHalt, ULONG cFilterAttrs, const TS_ATTRID *paFilterAttrs,
365 DWORD dwFlags, LONG *pacpNext, BOOL *pfFound, LONG *plFoundOffset)
366 {
367 trace("\n");
368 return S_OK;
369 }
370 static HRESULT WINAPI TextStoreACP_RetrieveRequestedAttrs(ITextStoreACP *iface,
371 ULONG ulCount, TS_ATTRVAL *paAttrVals, ULONG *pcFetched)
372 {
373 trace("\n");
374 return S_OK;
375 }
376 static HRESULT WINAPI TextStoreACP_GetEndACP(ITextStoreACP *iface,
377 LONG *pacp)
378 {
379 sink_fire_ok(&test_ACP_GetEndACP,"TextStoreACP_GetEndACP");
380 return S_OK;
381 }
382 static HRESULT WINAPI TextStoreACP_GetActiveView(ITextStoreACP *iface,
383 TsViewCookie *pvcView)
384 {
385 trace("\n");
386 return S_OK;
387 }
388 static HRESULT WINAPI TextStoreACP_GetACPFromPoint(ITextStoreACP *iface,
389 TsViewCookie vcView, const POINT *ptScreen, DWORD dwFlags,
390 LONG *pacp)
391 {
392 trace("\n");
393 return S_OK;
394 }
395 static HRESULT WINAPI TextStoreACP_GetTextExt(ITextStoreACP *iface,
396 TsViewCookie vcView, LONG acpStart, LONG acpEnd, RECT *prc,
397 BOOL *pfClipped)
398 {
399 trace("\n");
400 return S_OK;
401 }
402 static HRESULT WINAPI TextStoreACP_GetScreenExt(ITextStoreACP *iface,
403 TsViewCookie vcView, RECT *prc)
404 {
405 trace("\n");
406 return S_OK;
407 }
408 static HRESULT WINAPI TextStoreACP_GetWnd(ITextStoreACP *iface,
409 TsViewCookie vcView, HWND *phwnd)
410 {
411 trace("\n");
412 return S_OK;
413 }
414
415 static const ITextStoreACPVtbl TextStoreACP_TextStoreACPVtbl =
416 {
417 TextStoreACP_QueryInterface,
418 TextStoreACP_AddRef,
419 TextStoreACP_Release,
420
421 TextStoreACP_AdviseSink,
422 TextStoreACP_UnadviseSink,
423 TextStoreACP_RequestLock,
424 TextStoreACP_GetStatus,
425 TextStoreACP_QueryInsert,
426 TextStoreACP_GetSelection,
427 TextStoreACP_SetSelection,
428 TextStoreACP_GetText,
429 TextStoreACP_SetText,
430 TextStoreACP_GetFormattedText,
431 TextStoreACP_GetEmbedded,
432 TextStoreACP_QueryInsertEmbedded,
433 TextStoreACP_InsertEmbedded,
434 TextStoreACP_InsertTextAtSelection,
435 TextStoreACP_InsertEmbeddedAtSelection,
436 TextStoreACP_RequestSupportedAttrs,
437 TextStoreACP_RequestAttrsAtPosition,
438 TextStoreACP_RequestAttrsTransitioningAtPosition,
439 TextStoreACP_FindNextAttrTransition,
440 TextStoreACP_RetrieveRequestedAttrs,
441 TextStoreACP_GetEndACP,
442 TextStoreACP_GetActiveView,
443 TextStoreACP_GetACPFromPoint,
444 TextStoreACP_GetTextExt,
445 TextStoreACP_GetScreenExt,
446 TextStoreACP_GetWnd
447 };
448
449 static HRESULT TextStoreACP_Constructor(IUnknown **ppOut)
450 {
451 TextStoreACP *This;
452
453 This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(TextStoreACP));
454 if (This == NULL)
455 return E_OUTOFMEMORY;
456
457 This->ITextStoreACP_iface.lpVtbl = &TextStoreACP_TextStoreACPVtbl;
458 This->refCount = 1;
459
460 *ppOut = (IUnknown *)This;
461 return S_OK;
462 }
463
464 /**********************************************************************
465 * ITfThreadMgrEventSink
466 **********************************************************************/
467 typedef struct tagThreadMgrEventSink
468 {
469 ITfThreadMgrEventSink ITfThreadMgrEventSink_iface;
470 LONG refCount;
471 } ThreadMgrEventSink;
472
473 static inline ThreadMgrEventSink *impl_from_ITfThreadMgrEventSink(ITfThreadMgrEventSink *iface)
474 {
475 return CONTAINING_RECORD(iface, ThreadMgrEventSink, ITfThreadMgrEventSink_iface);
476 }
477
478 static void ThreadMgrEventSink_Destructor(ThreadMgrEventSink *This)
479 {
480 HeapFree(GetProcessHeap(),0,This);
481 }
482
483 static HRESULT WINAPI ThreadMgrEventSink_QueryInterface(ITfThreadMgrEventSink *iface, REFIID iid, LPVOID *ppvOut)
484 {
485 ThreadMgrEventSink *This = impl_from_ITfThreadMgrEventSink(iface);
486 *ppvOut = NULL;
487
488 if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITfThreadMgrEventSink))
489 {
490 *ppvOut = This;
491 }
492
493 if (*ppvOut)
494 {
495 ITfThreadMgrEventSink_AddRef(iface);
496 return S_OK;
497 }
498
499 return E_NOINTERFACE;
500 }
501
502 static ULONG WINAPI ThreadMgrEventSink_AddRef(ITfThreadMgrEventSink *iface)
503 {
504 ThreadMgrEventSink *This = impl_from_ITfThreadMgrEventSink(iface);
505 ok (tmSinkRefCount == This->refCount,"ThreadMgrEventSink refcount off %i vs %i\n",This->refCount,tmSinkRefCount);
506 return InterlockedIncrement(&This->refCount);
507 }
508
509 static ULONG WINAPI ThreadMgrEventSink_Release(ITfThreadMgrEventSink *iface)
510 {
511 ThreadMgrEventSink *This = impl_from_ITfThreadMgrEventSink(iface);
512 ULONG ret;
513
514 ok (tmSinkRefCount == This->refCount,"ThreadMgrEventSink refcount off %i vs %i\n",This->refCount,tmSinkRefCount);
515 ret = InterlockedDecrement(&This->refCount);
516 if (ret == 0)
517 ThreadMgrEventSink_Destructor(This);
518 return ret;
519 }
520
521 static HRESULT WINAPI ThreadMgrEventSink_OnInitDocumentMgr(ITfThreadMgrEventSink *iface,
522 ITfDocumentMgr *pdim)
523 {
524 sink_fire_ok(&test_OnInitDocumentMgr,"ThreadMgrEventSink_OnInitDocumentMgr");
525 return S_OK;
526 }
527
528 static HRESULT WINAPI ThreadMgrEventSink_OnUninitDocumentMgr(ITfThreadMgrEventSink *iface,
529 ITfDocumentMgr *pdim)
530 {
531 trace("\n");
532 return S_OK;
533 }
534
535 static HRESULT WINAPI ThreadMgrEventSink_OnSetFocus(ITfThreadMgrEventSink *iface,
536 ITfDocumentMgr *pdimFocus, ITfDocumentMgr *pdimPrevFocus)
537 {
538 sink_fire_ok(&test_OnSetFocus,"ThreadMgrEventSink_OnSetFocus");
539 if (test_CurrentFocus == FOCUS_SAVE)
540 test_LastCurrentFocus = pdimFocus;
541 else if (test_CurrentFocus != FOCUS_IGNORE)
542 ok(pdimFocus == test_CurrentFocus,"Sink reports wrong focus\n");
543 if (test_PrevFocus == FOCUS_SAVE)
544 {
545 if (test_FirstPrevFocus == FOCUS_SAVE)
546 test_FirstPrevFocus = pdimPrevFocus;
547 }
548 else if (test_PrevFocus != FOCUS_IGNORE)
549 ok(pdimPrevFocus == test_PrevFocus,"Sink reports wrong previous focus\n");
550 return S_OK;
551 }
552
553 static HRESULT WINAPI ThreadMgrEventSink_OnPushContext(ITfThreadMgrEventSink *iface,
554 ITfContext *pic)
555 {
556 HRESULT hr;
557 ITfDocumentMgr *docmgr;
558 ITfContext *test;
559
560 hr = ITfContext_GetDocumentMgr(pic,&docmgr);
561 ok(SUCCEEDED(hr),"GetDocumentMgr failed\n");
562 test = (ITfContext*)0xdeadbeef;
563 ITfDocumentMgr_Release(docmgr);
564 hr = ITfDocumentMgr_GetTop(docmgr,&test);
565 ok(SUCCEEDED(hr),"GetTop failed\n");
566 ok(test == pic, "Wrong context is on top\n");
567 if (test)
568 ITfContext_Release(test);
569
570 sink_fire_ok(&test_OnPushContext,"ThreadMgrEventSink_OnPushContext");
571 return S_OK;
572 }
573
574 static HRESULT WINAPI ThreadMgrEventSink_OnPopContext(ITfThreadMgrEventSink *iface,
575 ITfContext *pic)
576 {
577 HRESULT hr;
578 ITfDocumentMgr *docmgr;
579 ITfContext *test;
580
581 hr = ITfContext_GetDocumentMgr(pic,&docmgr);
582 ok(SUCCEEDED(hr),"GetDocumentMgr failed\n");
583 ITfDocumentMgr_Release(docmgr);
584 test = (ITfContext*)0xdeadbeef;
585 hr = ITfDocumentMgr_GetTop(docmgr,&test);
586 ok(SUCCEEDED(hr),"GetTop failed\n");
587 ok(test == pic, "Wrong context is on top\n");
588 if (test)
589 ITfContext_Release(test);
590
591 sink_fire_ok(&test_OnPopContext,"ThreadMgrEventSink_OnPopContext");
592 return S_OK;
593 }
594
595 static const ITfThreadMgrEventSinkVtbl ThreadMgrEventSink_ThreadMgrEventSinkVtbl =
596 {
597 ThreadMgrEventSink_QueryInterface,
598 ThreadMgrEventSink_AddRef,
599 ThreadMgrEventSink_Release,
600
601 ThreadMgrEventSink_OnInitDocumentMgr,
602 ThreadMgrEventSink_OnUninitDocumentMgr,
603 ThreadMgrEventSink_OnSetFocus,
604 ThreadMgrEventSink_OnPushContext,
605 ThreadMgrEventSink_OnPopContext
606 };
607
608 static HRESULT ThreadMgrEventSink_Constructor(IUnknown **ppOut)
609 {
610 ThreadMgrEventSink *This;
611
612 This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ThreadMgrEventSink));
613 if (This == NULL)
614 return E_OUTOFMEMORY;
615
616 This->ITfThreadMgrEventSink_iface.lpVtbl = &ThreadMgrEventSink_ThreadMgrEventSinkVtbl;
617 This->refCount = 1;
618
619 *ppOut = (IUnknown *)This;
620 return S_OK;
621 }
622
623
624 /********************************************************************************************
625 * Stub text service for testing
626 ********************************************************************************************/
627
628 static LONG TS_refCount;
629 static IClassFactory *cf;
630 static DWORD regid;
631
632 typedef HRESULT (*LPFNCONSTRUCTOR)(IUnknown *pUnkOuter, IUnknown **ppvOut);
633
634 typedef struct tagClassFactory
635 {
636 IClassFactory IClassFactory_iface;
637 LONG ref;
638 LPFNCONSTRUCTOR ctor;
639 } ClassFactory;
640
641 static inline ClassFactory *impl_from_IClassFactory(IClassFactory *iface)
642 {
643 return CONTAINING_RECORD(iface, ClassFactory, IClassFactory_iface);
644 }
645
646 typedef struct tagTextService
647 {
648 ITfTextInputProcessor ITfTextInputProcessor_iface;
649 LONG refCount;
650 } TextService;
651
652 static inline TextService *impl_from_ITfTextInputProcessor(ITfTextInputProcessor *iface)
653 {
654 return CONTAINING_RECORD(iface, TextService, ITfTextInputProcessor_iface);
655 }
656
657 static void ClassFactory_Destructor(ClassFactory *This)
658 {
659 HeapFree(GetProcessHeap(),0,This);
660 TS_refCount--;
661 }
662
663 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, LPVOID *ppvOut)
664 {
665 *ppvOut = NULL;
666 if (IsEqualIID(riid, &IID_IClassFactory) || IsEqualIID(riid, &IID_IUnknown))
667 {
668 IClassFactory_AddRef(iface);
669 *ppvOut = iface;
670 return S_OK;
671 }
672
673 return E_NOINTERFACE;
674 }
675
676 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
677 {
678 ClassFactory *This = impl_from_IClassFactory(iface);
679 return InterlockedIncrement(&This->ref);
680 }
681
682 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
683 {
684 ClassFactory *This = impl_from_IClassFactory(iface);
685 ULONG ret = InterlockedDecrement(&This->ref);
686
687 if (ret == 0)
688 ClassFactory_Destructor(This);
689 return ret;
690 }
691
692 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *punkOuter, REFIID iid, LPVOID *ppvOut)
693 {
694 ClassFactory *This = impl_from_IClassFactory(iface);
695 HRESULT ret;
696 IUnknown *obj;
697
698 ret = This->ctor(punkOuter, &obj);
699 if (FAILED(ret))
700 return ret;
701 ret = IUnknown_QueryInterface(obj, iid, ppvOut);
702 IUnknown_Release(obj);
703 return ret;
704 }
705
706 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL fLock)
707 {
708 if(fLock)
709 InterlockedIncrement(&TS_refCount);
710 else
711 InterlockedDecrement(&TS_refCount);
712
713 return S_OK;
714 }
715
716 static const IClassFactoryVtbl ClassFactoryVtbl = {
717 /* IUnknown */
718 ClassFactory_QueryInterface,
719 ClassFactory_AddRef,
720 ClassFactory_Release,
721
722 /* IClassFactory*/
723 ClassFactory_CreateInstance,
724 ClassFactory_LockServer
725 };
726
727 static HRESULT ClassFactory_Constructor(LPFNCONSTRUCTOR ctor, LPVOID *ppvOut)
728 {
729 ClassFactory *This = HeapAlloc(GetProcessHeap(),0,sizeof(ClassFactory));
730 This->IClassFactory_iface.lpVtbl = &ClassFactoryVtbl;
731 This->ref = 1;
732 This->ctor = ctor;
733 *ppvOut = (LPVOID)This;
734 TS_refCount++;
735 return S_OK;
736 }
737
738 static void TextService_Destructor(TextService *This)
739 {
740 HeapFree(GetProcessHeap(),0,This);
741 }
742
743 static HRESULT WINAPI TextService_QueryInterface(ITfTextInputProcessor *iface, REFIID iid, LPVOID *ppvOut)
744 {
745 TextService *This = impl_from_ITfTextInputProcessor(iface);
746 *ppvOut = NULL;
747
748 if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITfTextInputProcessor))
749 {
750 *ppvOut = This;
751 }
752
753 if (*ppvOut)
754 {
755 ITfTextInputProcessor_AddRef(iface);
756 return S_OK;
757 }
758
759 return E_NOINTERFACE;
760 }
761
762 static ULONG WINAPI TextService_AddRef(ITfTextInputProcessor *iface)
763 {
764 TextService *This = impl_from_ITfTextInputProcessor(iface);
765 return InterlockedIncrement(&This->refCount);
766 }
767
768 static ULONG WINAPI TextService_Release(ITfTextInputProcessor *iface)
769 {
770 TextService *This = impl_from_ITfTextInputProcessor(iface);
771 ULONG ret;
772
773 ret = InterlockedDecrement(&This->refCount);
774 if (ret == 0)
775 TextService_Destructor(This);
776 return ret;
777 }
778
779 static HRESULT WINAPI TextService_Activate(ITfTextInputProcessor *iface,
780 ITfThreadMgr *ptim, TfClientId id)
781 {
782 trace("TextService_Activate\n");
783 ok(test_ShouldActivate,"Activation came unexpectedly\n");
784 tid = id;
785 return S_OK;
786 }
787
788 static HRESULT WINAPI TextService_Deactivate(ITfTextInputProcessor *iface)
789 {
790 trace("TextService_Deactivate\n");
791 ok(test_ShouldDeactivate,"Deactivation came unexpectedly\n");
792 return S_OK;
793 }
794
795 static const ITfTextInputProcessorVtbl TextService_TextInputProcessorVtbl=
796 {
797 TextService_QueryInterface,
798 TextService_AddRef,
799 TextService_Release,
800
801 TextService_Activate,
802 TextService_Deactivate
803 };
804
805 static HRESULT TextService_Constructor(IUnknown *pUnkOuter, IUnknown **ppOut)
806 {
807 TextService *This;
808 if (pUnkOuter)
809 return CLASS_E_NOAGGREGATION;
810
811 This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(TextService));
812 if (This == NULL)
813 return E_OUTOFMEMORY;
814
815 This->ITfTextInputProcessor_iface.lpVtbl = &TextService_TextInputProcessorVtbl;
816 This->refCount = 1;
817
818 *ppOut = (IUnknown *)This;
819 return S_OK;
820 }
821
822 static HRESULT RegisterTextService(REFCLSID rclsid)
823 {
824 ClassFactory_Constructor( TextService_Constructor ,(LPVOID*)&cf);
825 return CoRegisterClassObject(rclsid, (IUnknown*) cf, CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &regid);
826 }
827
828 static HRESULT UnregisterTextService(void)
829 {
830 return CoRevokeClassObject(regid);
831 }
832
833 /*
834 * The tests
835 */
836
837 DEFINE_GUID(CLSID_FakeService, 0xEDE1A7AD,0x66DE,0x47E0,0xB6,0x20,0x3E,0x92,0xF8,0x24,0x6B,0xF3);
838 DEFINE_GUID(CLSID_TF_InputProcessorProfiles, 0x33c53a50,0xf456,0x4884,0xb0,0x49,0x85,0xfd,0x64,0x3e,0xcf,0xed);
839 DEFINE_GUID(CLSID_TF_CategoryMgr, 0xA4B544A1,0x438D,0x4B41,0x93,0x25,0x86,0x95,0x23,0xE2,0xD6,0xC7);
840 DEFINE_GUID(GUID_TFCAT_TIP_KEYBOARD, 0x34745c63,0xb2f0,0x4784,0x8b,0x67,0x5e,0x12,0xc8,0x70,0x1a,0x31);
841 DEFINE_GUID(GUID_TFCAT_TIP_SPEECH, 0xB5A73CD1,0x8355,0x426B,0xA1,0x61,0x25,0x98,0x08,0xF2,0x6B,0x14);
842 DEFINE_GUID(GUID_TFCAT_TIP_HANDWRITING, 0x246ecb87,0xc2f2,0x4abe,0x90,0x5b,0xc8,0xb3,0x8a,0xdd,0x2c,0x43);
843 DEFINE_GUID (GUID_TFCAT_DISPLAYATTRIBUTEPROVIDER, 0x046B8C80,0x1647,0x40F7,0x9B,0x21,0xB9,0x3B,0x81,0xAA,0xBC,0x1B);
844 DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
845 DEFINE_GUID(CLSID_TF_ThreadMgr, 0x529a9e6b,0x6587,0x4f23,0xab,0x9e,0x9c,0x7d,0x68,0x3e,0x3c,0x50);
846 DEFINE_GUID(CLSID_PreservedKey, 0xA0ED8E55,0xCD3B,0x4274,0xB2,0x95,0xF6,0xC9,0xBA,0x2B,0x84,0x72);
847 DEFINE_GUID(GUID_COMPARTMENT_KEYBOARD_DISABLED, 0x71a5b253,0x1951,0x466b,0x9f,0xbc,0x9c,0x88,0x08,0xfa,0x84,0xf2);
848 DEFINE_GUID(GUID_COMPARTMENT_KEYBOARD_OPENCLOSE, 0x58273aad,0x01bb,0x4164,0x95,0xc6,0x75,0x5b,0xa0,0xb5,0x16,0x2d);
849 DEFINE_GUID(GUID_COMPARTMENT_HANDWRITING_OPENCLOSE, 0xf9ae2c6b,0x1866,0x4361,0xaf,0x72,0x7a,0xa3,0x09,0x48,0x89,0x0e);
850 DEFINE_GUID(GUID_COMPARTMENT_SPEECH_DISABLED, 0x56c5c607,0x0703,0x4e59,0x8e,0x52,0xcb,0xc8,0x4e,0x8b,0xbe,0x35);
851 DEFINE_GUID(GUID_COMPARTMENT_SPEECH_OPENCLOSE, 0x544d6a63,0xe2e8,0x4752,0xbb,0xd1,0x00,0x09,0x60,0xbc,0xa0,0x83);
852 DEFINE_GUID(GUID_COMPARTMENT_SPEECH_GLOBALSTATE, 0x2a54fe8e,0x0d08,0x460c,0xa7,0x5d,0x87,0x03,0x5f,0xf4,0x36,0xc5);
853 DEFINE_GUID(GUID_COMPARTMENT_PERSISTMENUENABLED, 0x575f3783,0x70c8,0x47c8,0xae,0x5d,0x91,0xa0,0x1a,0x1f,0x75,0x92);
854 DEFINE_GUID(GUID_COMPARTMENT_EMPTYCONTEXT, 0xd7487dbf,0x804e,0x41c5,0x89,0x4d,0xad,0x96,0xfd,0x4e,0xea,0x13);
855 DEFINE_GUID(GUID_COMPARTMENT_TIPUISTATUS, 0x148ca3ec,0x0366,0x401c,0x8d,0x75,0xed,0x97,0x8d,0x85,0xfb,0xc9);
856
857 static HRESULT initialize(void)
858 {
859 HRESULT hr;
860 CoInitialize(NULL);
861 hr = CoCreateInstance (&CLSID_TF_InputProcessorProfiles, NULL,
862 CLSCTX_INPROC_SERVER, &IID_ITfInputProcessorProfiles, (void**)&g_ipp);
863 if (SUCCEEDED(hr))
864 hr = CoCreateInstance (&CLSID_TF_CategoryMgr, NULL,
865 CLSCTX_INPROC_SERVER, &IID_ITfCategoryMgr, (void**)&g_cm);
866 if (SUCCEEDED(hr))
867 hr = CoCreateInstance (&CLSID_TF_ThreadMgr, NULL,
868 CLSCTX_INPROC_SERVER, &IID_ITfThreadMgr, (void**)&g_tm);
869 return hr;
870 }
871
872 static void cleanup(void)
873 {
874 if (g_ipp)
875 ITfInputProcessorProfiles_Release(g_ipp);
876 if (g_cm)
877 ITfCategoryMgr_Release(g_cm);
878 if (g_tm)
879 ITfThreadMgr_Release(g_tm);
880 CoUninitialize();
881 }
882
883 static void test_Register(void)
884 {
885 HRESULT hr;
886
887 static const WCHAR szDesc[] = {'F','a','k','e',' ','W','i','n','e',' ','S','e','r','v','i','c','e',0};
888 static const WCHAR szFile[] = {'F','a','k','e',' ','W','i','n','e',' ','S','e','r','v','i','c','e',' ','F','i','l','e',0};
889
890 hr = ITfInputProcessorProfiles_GetCurrentLanguage(g_ipp,&gLangid);
891 ok(SUCCEEDED(hr),"Unable to get current language id\n");
892 trace("Current Language %x\n",gLangid);
893
894 hr = RegisterTextService(&CLSID_FakeService);
895 ok(SUCCEEDED(hr),"Unable to register COM for TextService\n");
896 hr = ITfInputProcessorProfiles_Register(g_ipp, &CLSID_FakeService);
897 ok(SUCCEEDED(hr),"Unable to register text service(%x)\n",hr);
898 hr = ITfInputProcessorProfiles_AddLanguageProfile(g_ipp, &CLSID_FakeService, gLangid, &CLSID_FakeService, szDesc, sizeof(szDesc)/sizeof(WCHAR), szFile, sizeof(szFile)/sizeof(WCHAR), 1);
899 ok(SUCCEEDED(hr),"Unable to add Language Profile (%x)\n",hr);
900 }
901
902 static void test_Unregister(void)
903 {
904 HRESULT hr;
905 hr = ITfInputProcessorProfiles_Unregister(g_ipp, &CLSID_FakeService);
906 ok(SUCCEEDED(hr),"Unable to unregister text service(%x)\n",hr);
907 UnregisterTextService();
908 }
909
910 static void test_EnumInputProcessorInfo(void)
911 {
912 IEnumGUID *ppEnum;
913 BOOL found = FALSE;
914
915 if (SUCCEEDED(ITfInputProcessorProfiles_EnumInputProcessorInfo(g_ipp, &ppEnum)))
916 {
917 ULONG fetched;
918 GUID g;
919 while (IEnumGUID_Next(ppEnum, 1, &g, &fetched) == S_OK)
920 {
921 if(IsEqualGUID(&g,&CLSID_FakeService))
922 found = TRUE;
923 }
924 }
925 ok(found,"Did not find registered text service\n");
926 }
927
928 static void test_EnumLanguageProfiles(void)
929 {
930 BOOL found = FALSE;
931 IEnumTfLanguageProfiles *ppEnum;
932 if (SUCCEEDED(ITfInputProcessorProfiles_EnumLanguageProfiles(g_ipp,gLangid,&ppEnum)))
933 {
934 TF_LANGUAGEPROFILE profile;
935 while (IEnumTfLanguageProfiles_Next(ppEnum,1,&profile,NULL)==S_OK)
936 {
937 if (IsEqualGUID(&profile.clsid,&CLSID_FakeService))
938 {
939 found = TRUE;
940 ok(profile.langid == gLangid, "LangId Incorrect\n");
941 ok(IsEqualGUID(&profile.catid,&GUID_TFCAT_TIP_KEYBOARD), "CatId Incorrect\n");
942 ok(IsEqualGUID(&profile.guidProfile,&CLSID_FakeService), "guidProfile Incorrect\n");
943 }
944 }
945 }
946 ok(found,"Registered text service not found\n");
947 }
948
949 static void test_RegisterCategory(void)
950 {
951 HRESULT hr;
952 hr = ITfCategoryMgr_RegisterCategory(g_cm, &CLSID_FakeService, &GUID_TFCAT_TIP_KEYBOARD, &CLSID_FakeService);
953 ok(SUCCEEDED(hr),"ITfCategoryMgr_RegisterCategory failed\n");
954 hr = ITfCategoryMgr_RegisterCategory(g_cm, &CLSID_FakeService, &GUID_TFCAT_DISPLAYATTRIBUTEPROVIDER, &CLSID_FakeService);
955 ok(SUCCEEDED(hr),"ITfCategoryMgr_RegisterCategory failed\n");
956 }
957
958 static void test_UnregisterCategory(void)
959 {
960 HRESULT hr;
961 hr = ITfCategoryMgr_UnregisterCategory(g_cm, &CLSID_FakeService, &GUID_TFCAT_TIP_KEYBOARD, &CLSID_FakeService);
962 ok(SUCCEEDED(hr),"ITfCategoryMgr_UnregisterCategory failed\n");
963 hr = ITfCategoryMgr_UnregisterCategory(g_cm, &CLSID_FakeService, &GUID_TFCAT_DISPLAYATTRIBUTEPROVIDER, &CLSID_FakeService);
964 ok(SUCCEEDED(hr),"ITfCategoryMgr_UnregisterCategory failed\n");
965 }
966
967 static void test_FindClosestCategory(void)
968 {
969 GUID output;
970 HRESULT hr;
971 const GUID *list[3] = {&GUID_TFCAT_TIP_SPEECH, &GUID_TFCAT_TIP_KEYBOARD, &GUID_TFCAT_TIP_HANDWRITING};
972
973 hr = ITfCategoryMgr_FindClosestCategory(g_cm, &CLSID_FakeService, &output, NULL, 0);
974 ok(SUCCEEDED(hr),"ITfCategoryMgr_FindClosestCategory failed (%x)\n",hr);
975 ok(IsEqualGUID(&output,&GUID_TFCAT_DISPLAYATTRIBUTEPROVIDER),"Wrong GUID\n");
976
977 hr = ITfCategoryMgr_FindClosestCategory(g_cm, &CLSID_FakeService, &output, list, 1);
978 ok(SUCCEEDED(hr),"ITfCategoryMgr_FindClosestCategory failed (%x)\n",hr);
979 ok(IsEqualGUID(&output,&GUID_NULL),"Wrong GUID\n");
980
981 hr = ITfCategoryMgr_FindClosestCategory(g_cm, &CLSID_FakeService, &output, list, 3);
982 ok(SUCCEEDED(hr),"ITfCategoryMgr_FindClosestCategory failed (%x)\n",hr);
983 ok(IsEqualGUID(&output,&GUID_TFCAT_TIP_KEYBOARD),"Wrong GUID\n");
984 }
985
986 static void test_Enable(void)
987 {
988 HRESULT hr;
989 BOOL enabled = FALSE;
990
991 hr = ITfInputProcessorProfiles_EnableLanguageProfile(g_ipp,&CLSID_FakeService, gLangid, &CLSID_FakeService, TRUE);
992 ok(SUCCEEDED(hr),"Failed to enable text service\n");
993 hr = ITfInputProcessorProfiles_IsEnabledLanguageProfile(g_ipp,&CLSID_FakeService, gLangid, &CLSID_FakeService, &enabled);
994 ok(SUCCEEDED(hr),"Failed to get enabled state\n");
995 ok(enabled == TRUE,"enabled state incorrect\n");
996 }
997
998 static void test_Disable(void)
999 {
1000 HRESULT hr;
1001
1002 trace("Disabling\n");
1003 hr = ITfInputProcessorProfiles_EnableLanguageProfile(g_ipp,&CLSID_FakeService, gLangid, &CLSID_FakeService, FALSE);
1004 ok(SUCCEEDED(hr),"Failed to disable text service\n");
1005 }
1006
1007 static void test_ThreadMgrAdviseSinks(void)
1008 {
1009 ITfSource *source = NULL;
1010 HRESULT hr;
1011 IUnknown *sink;
1012
1013 hr = ITfThreadMgr_QueryInterface(g_tm, &IID_ITfSource, (LPVOID*)&source);
1014 ok(SUCCEEDED(hr),"Failed to get IID_ITfSource for ThreadMgr\n");
1015 if (!source)
1016 return;
1017
1018 hr = ThreadMgrEventSink_Constructor(&sink);
1019 ok(hr == S_OK, "got %08x\n", hr);
1020 if(FAILED(hr)) return;
1021
1022 tmSinkRefCount = 1;
1023 tmSinkCookie = 0;
1024 hr = ITfSource_AdviseSink(source,&IID_ITfThreadMgrEventSink, sink, &tmSinkCookie);
1025 ok(SUCCEEDED(hr),"Failed to Advise Sink\n");
1026 ok(tmSinkCookie!=0,"Failed to get sink cookie\n");
1027
1028 /* Advising the sink adds a ref, Releasing here lets the object be deleted
1029 when unadvised */
1030 tmSinkRefCount = 2;
1031 IUnknown_Release(sink);
1032 ITfSource_Release(source);
1033 }
1034
1035 static void test_ThreadMgrUnadviseSinks(void)
1036 {
1037 ITfSource *source = NULL;
1038 HRESULT hr;
1039
1040 hr = ITfThreadMgr_QueryInterface(g_tm, &IID_ITfSource, (LPVOID*)&source);
1041 ok(SUCCEEDED(hr),"Failed to get IID_ITfSource for ThreadMgr\n");
1042 if (!source)
1043 return;
1044
1045 tmSinkRefCount = 1;
1046 hr = ITfSource_UnadviseSink(source, tmSinkCookie);
1047 ok(SUCCEEDED(hr),"Failed to unadvise Sink\n");
1048 ITfSource_Release(source);
1049 }
1050
1051 /**********************************************************************
1052 * ITfKeyEventSink
1053 **********************************************************************/
1054 typedef struct tagKeyEventSink
1055 {
1056 ITfKeyEventSink ITfKeyEventSink_iface;
1057 LONG refCount;
1058 } KeyEventSink;
1059
1060 static inline KeyEventSink *impl_from_ITfKeyEventSink(ITfKeyEventSink *iface)
1061 {
1062 return CONTAINING_RECORD(iface, KeyEventSink, ITfKeyEventSink_iface);
1063 }
1064
1065 static void KeyEventSink_Destructor(KeyEventSink *This)
1066 {
1067 HeapFree(GetProcessHeap(),0,This);
1068 }
1069
1070 static HRESULT WINAPI KeyEventSink_QueryInterface(ITfKeyEventSink *iface, REFIID iid, LPVOID *ppvOut)
1071 {
1072 KeyEventSink *This = impl_from_ITfKeyEventSink(iface);
1073 *ppvOut = NULL;
1074
1075 if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITfKeyEventSink))
1076 {
1077 *ppvOut = This;
1078 }
1079
1080 if (*ppvOut)
1081 {
1082 ITfKeyEventSink_AddRef(iface);
1083 return S_OK;
1084 }
1085
1086 return E_NOINTERFACE;
1087 }
1088
1089 static ULONG WINAPI KeyEventSink_AddRef(ITfKeyEventSink *iface)
1090 {
1091 KeyEventSink *This = impl_from_ITfKeyEventSink(iface);
1092 return InterlockedIncrement(&This->refCount);
1093 }
1094
1095 static ULONG WINAPI KeyEventSink_Release(ITfKeyEventSink *iface)
1096 {
1097 KeyEventSink *This = impl_from_ITfKeyEventSink(iface);
1098 ULONG ret;
1099
1100 ret = InterlockedDecrement(&This->refCount);
1101 if (ret == 0)
1102 KeyEventSink_Destructor(This);
1103 return ret;
1104 }
1105
1106 static HRESULT WINAPI KeyEventSink_OnSetFocus(ITfKeyEventSink *iface,
1107 BOOL fForeground)
1108 {
1109 sink_fire_ok(&test_KEV_OnSetFocus,"KeyEventSink_OnSetFocus");
1110 return S_OK;
1111 }
1112
1113 static HRESULT WINAPI KeyEventSink_OnTestKeyDown(ITfKeyEventSink *iface,
1114 ITfContext *pic, WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
1115 {
1116 trace("\n");
1117 return S_OK;
1118 }
1119
1120 static HRESULT WINAPI KeyEventSink_OnTestKeyUp(ITfKeyEventSink *iface,
1121 ITfContext *pic, WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
1122 {
1123 trace("\n");
1124 return S_OK;
1125 }
1126
1127 static HRESULT WINAPI KeyEventSink_OnKeyDown(ITfKeyEventSink *iface,
1128 ITfContext *pic, WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
1129 {
1130 trace("\n");
1131 return S_OK;
1132 }
1133
1134 static HRESULT WINAPI KeyEventSink_OnKeyUp(ITfKeyEventSink *iface,
1135 ITfContext *pic, WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
1136 {
1137 trace("\n");
1138 return S_OK;
1139 }
1140
1141 static HRESULT WINAPI KeyEventSink_OnPreservedKey(ITfKeyEventSink *iface,
1142 ITfContext *pic, REFGUID rguid, BOOL *pfEaten)
1143 {
1144 trace("\n");
1145 return S_OK;
1146 }
1147
1148 static const ITfKeyEventSinkVtbl KeyEventSink_KeyEventSinkVtbl =
1149 {
1150 KeyEventSink_QueryInterface,
1151 KeyEventSink_AddRef,
1152 KeyEventSink_Release,
1153
1154 KeyEventSink_OnSetFocus,
1155 KeyEventSink_OnTestKeyDown,
1156 KeyEventSink_OnTestKeyUp,
1157 KeyEventSink_OnKeyDown,
1158 KeyEventSink_OnKeyUp,
1159 KeyEventSink_OnPreservedKey
1160 };
1161
1162 static HRESULT KeyEventSink_Constructor(ITfKeyEventSink **ppOut)
1163 {
1164 KeyEventSink *This;
1165
1166 This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(KeyEventSink));
1167 if (This == NULL)
1168 return E_OUTOFMEMORY;
1169
1170 This->ITfKeyEventSink_iface.lpVtbl = &KeyEventSink_KeyEventSinkVtbl;
1171 This->refCount = 1;
1172
1173 *ppOut = &This->ITfKeyEventSink_iface;
1174 return S_OK;
1175 }
1176
1177
1178 static void test_KeystrokeMgr(void)
1179 {
1180 ITfKeystrokeMgr *keymgr= NULL;
1181 HRESULT hr;
1182 TF_PRESERVEDKEY tfpk;
1183 BOOL preserved;
1184 ITfKeyEventSink *sink = NULL;
1185
1186 KeyEventSink_Constructor(&sink);
1187
1188 hr = ITfThreadMgr_QueryInterface(g_tm, &IID_ITfKeystrokeMgr, (LPVOID*)&keymgr);
1189 ok(SUCCEEDED(hr),"Failed to get IID_ITfKeystrokeMgr for ThreadMgr\n");
1190
1191 tfpk.uVKey = 'A';
1192 tfpk.uModifiers = TF_MOD_SHIFT;
1193
1194 test_KEV_OnSetFocus = SINK_EXPECTED;
1195 hr = ITfKeystrokeMgr_AdviseKeyEventSink(keymgr,tid,sink,TRUE);
1196 ok(SUCCEEDED(hr),"ITfKeystrokeMgr_AdviseKeyEventSink failed\n");
1197 sink_check_ok(&test_KEV_OnSetFocus,"KeyEventSink_OnSetFocus");
1198 hr = ITfKeystrokeMgr_AdviseKeyEventSink(keymgr,tid,sink,TRUE);
1199 ok(hr == CONNECT_E_ADVISELIMIT,"Wrong return, expected CONNECT_E_ADVISELIMIT\n");
1200 hr = ITfKeystrokeMgr_AdviseKeyEventSink(keymgr,cid,sink,TRUE);
1201 ok(hr == E_INVALIDARG,"Wrong return, expected E_INVALIDARG\n");
1202
1203 hr =ITfKeystrokeMgr_PreserveKey(keymgr, 0, &CLSID_PreservedKey, &tfpk, NULL, 0);
1204 ok(hr==E_INVALIDARG,"ITfKeystrokeMgr_PreserveKey inproperly succeeded\n");
1205
1206 hr =ITfKeystrokeMgr_PreserveKey(keymgr, tid, &CLSID_PreservedKey, &tfpk, NULL, 0);
1207 ok(SUCCEEDED(hr),"ITfKeystrokeMgr_PreserveKey failed\n");
1208
1209 hr =ITfKeystrokeMgr_PreserveKey(keymgr, tid, &CLSID_PreservedKey, &tfpk, NULL, 0);
1210 ok(hr == TF_E_ALREADY_EXISTS,"ITfKeystrokeMgr_PreserveKey inproperly succeeded\n");
1211
1212 preserved = FALSE;
1213 hr = ITfKeystrokeMgr_IsPreservedKey(keymgr, &CLSID_PreservedKey, &tfpk, &preserved);
1214 ok(hr == S_OK, "ITfKeystrokeMgr_IsPreservedKey failed\n");
1215 if (hr == S_OK) ok(preserved == TRUE,"misreporting preserved key\n");
1216
1217 hr = ITfKeystrokeMgr_UnpreserveKey(keymgr, &CLSID_PreservedKey,&tfpk);
1218 ok(SUCCEEDED(hr),"ITfKeystrokeMgr_UnpreserveKey failed\n");
1219
1220 hr = ITfKeystrokeMgr_IsPreservedKey(keymgr, &CLSID_PreservedKey, &tfpk, &preserved);
1221 ok(hr == S_FALSE, "ITfKeystrokeMgr_IsPreservedKey failed\n");
1222 if (hr == S_FALSE) ok(preserved == FALSE,"misreporting preserved key\n");
1223
1224 hr = ITfKeystrokeMgr_UnpreserveKey(keymgr, &CLSID_PreservedKey,&tfpk);
1225 ok(hr==CONNECT_E_NOCONNECTION,"ITfKeystrokeMgr_UnpreserveKey inproperly succeeded\n");
1226
1227 hr = ITfKeystrokeMgr_UnadviseKeyEventSink(keymgr,tid);
1228 ok(SUCCEEDED(hr),"ITfKeystrokeMgr_UnadviseKeyEventSink failed\n");
1229
1230 ITfKeystrokeMgr_Release(keymgr);
1231 ITfKeyEventSink_Release(sink);
1232 }
1233
1234 static void test_Activate(void)
1235 {
1236 HRESULT hr;
1237
1238 test_ShouldActivate = TRUE; /* Win7 */
1239 hr = ITfInputProcessorProfiles_ActivateLanguageProfile(g_ipp,&CLSID_FakeService,gLangid,&CLSID_FakeService);
1240 ok(SUCCEEDED(hr),"Failed to Activate text service\n");
1241 test_ShouldActivate = FALSE;
1242 }
1243
1244
1245 static void test_EnumContexts(ITfDocumentMgr *dm, ITfContext *search)
1246 {
1247 HRESULT hr;
1248 IEnumTfContexts* pEnum;
1249 BOOL found = FALSE;
1250
1251 hr = ITfDocumentMgr_EnumContexts(dm,&pEnum);
1252 ok(SUCCEEDED(hr),"EnumContexts failed\n");
1253 if (SUCCEEDED(hr))
1254 {
1255 ULONG fetched;
1256 ITfContext *cxt;
1257 while (IEnumTfContexts_Next(pEnum, 1, &cxt, &fetched) == S_OK)
1258 {
1259 if (!search)
1260 found = TRUE;
1261 else if (search == cxt)
1262 found = TRUE;
1263 ITfContext_Release(cxt);
1264 }
1265 IEnumTfContexts_Release(pEnum);
1266 }
1267 if (search)
1268 ok(found,"Did not find proper ITfContext\n");
1269 else
1270 ok(!found,"Found an ITfContext we should should not have\n");
1271 }
1272
1273 static void test_EnumDocumentMgr(ITfThreadMgr *tm, ITfDocumentMgr *search, ITfDocumentMgr *absent)
1274 {
1275 HRESULT hr;
1276 IEnumTfDocumentMgrs* pEnum;
1277 BOOL found = FALSE;
1278 BOOL notfound = TRUE;
1279
1280 hr = ITfThreadMgr_EnumDocumentMgrs(tm,&pEnum);
1281 ok(SUCCEEDED(hr),"EnumDocumentMgrs failed\n");
1282 if (SUCCEEDED(hr))
1283 {
1284 ULONG fetched;
1285 ITfDocumentMgr *dm;
1286 while (IEnumTfDocumentMgrs_Next(pEnum, 1, &dm, &fetched) == S_OK)
1287 {
1288 if (!search)
1289 found = TRUE;
1290 else if (search == dm)
1291 found = TRUE;
1292 if (absent && dm == absent)
1293 notfound = FALSE;
1294 ITfDocumentMgr_Release(dm);
1295 }
1296 IEnumTfDocumentMgrs_Release(pEnum);
1297 }
1298 if (search)
1299 ok(found,"Did not find proper ITfDocumentMgr\n");
1300 else
1301 ok(!found,"Found an ITfDocumentMgr we should should not have\n");
1302 if (absent)
1303 ok(notfound,"Found an ITfDocumentMgr we believe should be absent\n");
1304 }
1305
1306 static inline int check_context_refcount(ITfContext *iface)
1307 {
1308 ITfContext_AddRef(iface);
1309 return ITfContext_Release(iface);
1310 }
1311
1312
1313 /**********************************************************************
1314 * ITfTextEditSink
1315 **********************************************************************/
1316 typedef struct tagTextEditSink
1317 {
1318 ITfTextEditSink ITfTextEditSink_iface;
1319 LONG refCount;
1320 } TextEditSink;
1321
1322 static inline TextEditSink *impl_from_ITfTextEditSink(ITfTextEditSink *iface)
1323 {
1324 return CONTAINING_RECORD(iface, TextEditSink, ITfTextEditSink_iface);
1325 }
1326
1327 static void TextEditSink_Destructor(TextEditSink *This)
1328 {
1329 HeapFree(GetProcessHeap(),0,This);
1330 }
1331
1332 static HRESULT WINAPI TextEditSink_QueryInterface(ITfTextEditSink *iface, REFIID iid, LPVOID *ppvOut)
1333 {
1334 TextEditSink *This = impl_from_ITfTextEditSink(iface);
1335 *ppvOut = NULL;
1336
1337 if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITfTextEditSink))
1338 {
1339 *ppvOut = This;
1340 }
1341
1342 if (*ppvOut)
1343 {
1344 ITfTextEditSink_AddRef(iface);
1345 return S_OK;
1346 }
1347
1348 return E_NOINTERFACE;
1349 }
1350
1351 static ULONG WINAPI TextEditSink_AddRef(ITfTextEditSink *iface)
1352 {
1353 TextEditSink *This = impl_from_ITfTextEditSink(iface);
1354 return InterlockedIncrement(&This->refCount);
1355 }
1356
1357 static ULONG WINAPI TextEditSink_Release(ITfTextEditSink *iface)
1358 {
1359 TextEditSink *This = impl_from_ITfTextEditSink(iface);
1360 ULONG ret;
1361
1362 ret = InterlockedDecrement(&This->refCount);
1363 if (ret == 0)
1364 TextEditSink_Destructor(This);
1365 return ret;
1366 }
1367
1368 static HRESULT WINAPI TextEditSink_OnEndEdit(ITfTextEditSink *iface,
1369 ITfContext *pic, TfEditCookie ecReadOnly, ITfEditRecord *pEditRecord)
1370 {
1371 sink_fire_ok(&test_OnEndEdit,"TextEditSink_OnEndEdit");
1372 return S_OK;
1373 }
1374
1375 static const ITfTextEditSinkVtbl TextEditSink_TextEditSinkVtbl =
1376 {
1377 TextEditSink_QueryInterface,
1378 TextEditSink_AddRef,
1379 TextEditSink_Release,
1380
1381 TextEditSink_OnEndEdit
1382 };
1383
1384 static HRESULT TextEditSink_Constructor(ITfTextEditSink **ppOut)
1385 {
1386 TextEditSink *This;
1387
1388 *ppOut = NULL;
1389 This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(TextEditSink));
1390 if (This == NULL)
1391 return E_OUTOFMEMORY;
1392
1393 This->ITfTextEditSink_iface.lpVtbl = &TextEditSink_TextEditSinkVtbl;
1394 This->refCount = 1;
1395
1396 *ppOut = &This->ITfTextEditSink_iface;
1397 return S_OK;
1398 }
1399
1400 static void test_startSession(void)
1401 {
1402 HRESULT hr;
1403 DWORD cnt;
1404 DWORD editCookie;
1405 ITfDocumentMgr *dmtest;
1406 ITfContext *cxt,*cxt2,*cxt3,*cxtTest;
1407 ITextStoreACP *ts;
1408 TfClientId cid2 = 0;
1409
1410 hr = ITfThreadMgr_Deactivate(g_tm);
1411 ok(hr == E_UNEXPECTED,"Deactivate should have failed with E_UNEXPECTED\n");
1412
1413 test_ShouldActivate = TRUE;
1414 hr = ITfThreadMgr_Activate(g_tm,&cid);
1415 ok(SUCCEEDED(hr),"Failed to Activate\n");
1416 ok(cid != tid,"TextService id mistakenly matches Client id\n");
1417
1418 test_ShouldActivate = FALSE;
1419 hr = ITfThreadMgr_Activate(g_tm,&cid2);
1420 ok(SUCCEEDED(hr),"Failed to Activate\n");
1421 ok (cid == cid2, "Second activate client ID does not match\n");
1422
1423 hr = ITfThreadMgr_Deactivate(g_tm);
1424 ok(SUCCEEDED(hr),"Failed to Deactivate\n");
1425
1426 test_EnumDocumentMgr(g_tm,NULL,NULL);
1427
1428 hr = ITfThreadMgr_CreateDocumentMgr(g_tm,&g_dm);
1429 ok(SUCCEEDED(hr),"CreateDocumentMgr failed\n");
1430
1431 test_EnumDocumentMgr(g_tm,g_dm,NULL);
1432
1433 hr = ITfThreadMgr_CreateDocumentMgr(g_tm,&dmtest);
1434 ok(SUCCEEDED(hr),"CreateDocumentMgr failed\n");
1435
1436 test_EnumDocumentMgr(g_tm,dmtest,NULL);
1437
1438 ITfDocumentMgr_Release(dmtest);
1439 test_EnumDocumentMgr(g_tm,g_dm,dmtest);
1440
1441 hr = ITfThreadMgr_GetFocus(g_tm,&dmtest);
1442 ok(SUCCEEDED(hr),"GetFocus Failed\n");
1443 ok(dmtest == NULL,"Initial focus not null\n");
1444
1445 test_CurrentFocus = g_dm;
1446 test_PrevFocus = NULL;
1447 test_OnSetFocus = SINK_OPTIONAL; /* Doesn't always fire on Win7 */
1448 hr = ITfThreadMgr_SetFocus(g_tm,g_dm);
1449 ok(SUCCEEDED(hr),"SetFocus Failed\n");
1450 sink_check_ok(&test_OnSetFocus,"OnSetFocus");
1451
1452 hr = ITfThreadMgr_GetFocus(g_tm,&dmtest);
1453 ok(SUCCEEDED(hr),"GetFocus Failed\n");
1454 ok(g_dm == dmtest,"Expected DocumentMgr not focused\n");
1455
1456 ITfDocumentMgr_Release(g_dm);
1457
1458 hr = ITfThreadMgr_GetFocus(g_tm,&dmtest);
1459 ok(SUCCEEDED(hr),"GetFocus Failed\n");
1460 ok(g_dm == dmtest,"Expected DocumentMgr not focused\n");
1461 ITfDocumentMgr_Release(dmtest);
1462
1463 hr = TextStoreACP_Constructor((IUnknown**)&ts);
1464 if (SUCCEEDED(hr))
1465 {
1466 hr = ITfDocumentMgr_CreateContext(g_dm, cid, 0, (IUnknown*)ts, &cxt, &editCookie);
1467 ok(SUCCEEDED(hr),"CreateContext Failed\n");
1468 }
1469
1470 hr = ITfDocumentMgr_CreateContext(g_dm, cid, 0, NULL, &cxt2, &editCookie);
1471 ok(SUCCEEDED(hr),"CreateContext Failed\n");
1472
1473 hr = ITfDocumentMgr_CreateContext(g_dm, cid, 0, NULL, &cxt3, &editCookie);
1474 ok(SUCCEEDED(hr),"CreateContext Failed\n");
1475
1476 test_EnumContexts(g_dm, NULL);
1477
1478 hr = ITfContext_GetDocumentMgr(cxt,&dmtest);
1479 ok(hr == S_OK, "ITfContext_GetDocumentMgr failed with %x\n",hr);
1480 ok(dmtest == g_dm, "Wrong documentmgr\n");
1481 ITfDocumentMgr_Release(dmtest);
1482
1483 cnt = check_context_refcount(cxt);
1484 test_OnPushContext = SINK_EXPECTED;
1485 test_ACP_AdviseSink = SINK_EXPECTED;
1486 test_OnInitDocumentMgr = SINK_EXPECTED;
1487 hr = ITfDocumentMgr_Push(g_dm, cxt);
1488 ok(SUCCEEDED(hr),"Push Failed\n");
1489 ok(check_context_refcount(cxt) > cnt, "Ref count did not increase\n");
1490 sink_check_ok(&test_OnPushContext,"OnPushContext");
1491 sink_check_ok(&test_OnInitDocumentMgr,"OnInitDocumentMgr");
1492 sink_check_ok(&test_ACP_AdviseSink,"TextStoreACP_AdviseSink");
1493
1494 test_EnumContexts(g_dm, cxt);
1495
1496 hr = ITfDocumentMgr_GetTop(g_dm, &cxtTest);
1497 ok(SUCCEEDED(hr),"GetTop Failed\n");
1498 ok(cxtTest == cxt, "Wrong context on top\n");
1499 ok(check_context_refcount(cxt) > cnt, "Ref count did not increase\n");
1500 cnt = ITfContext_Release(cxtTest);
1501
1502 hr = ITfDocumentMgr_GetBase(g_dm, &cxtTest);
1503 ok(SUCCEEDED(hr),"GetBase Failed\n");
1504 ok(cxtTest == cxt, "Wrong context on Base\n");
1505 ok(check_context_refcount(cxt) > cnt, "Ref count did not increase\n");
1506 ITfContext_Release(cxtTest);
1507
1508 check_context_refcount(cxt2);
1509 test_OnPushContext = SINK_EXPECTED;
1510 hr = ITfDocumentMgr_Push(g_dm, cxt2);
1511 ok(SUCCEEDED(hr),"Push Failed\n");
1512 sink_check_ok(&test_OnPushContext,"OnPushContext");
1513
1514 cnt = check_context_refcount(cxt2);
1515 hr = ITfDocumentMgr_GetTop(g_dm, &cxtTest);
1516 ok(SUCCEEDED(hr),"GetTop Failed\n");
1517 ok(cxtTest == cxt2, "Wrong context on top\n");
1518 ok(check_context_refcount(cxt2) > cnt, "Ref count did not increase\n");
1519 ITfContext_Release(cxtTest);
1520
1521 cnt = check_context_refcount(cxt);
1522 hr = ITfDocumentMgr_GetBase(g_dm, &cxtTest);
1523 ok(SUCCEEDED(hr),"GetBase Failed\n");
1524 ok(cxtTest == cxt, "Wrong context on Base\n");
1525 ok(check_context_refcount(cxt) > cnt, "Ref count did not increase\n");
1526 ITfContext_Release(cxtTest);
1527
1528 cnt = check_context_refcount(cxt3);
1529 hr = ITfDocumentMgr_Push(g_dm, cxt3);
1530 ok(FAILED(hr),"Push Succeeded\n");
1531 ok(check_context_refcount(cxt3) == cnt, "Ref changed\n");
1532
1533 cnt = check_context_refcount(cxt2);
1534 hr = ITfDocumentMgr_GetTop(g_dm, &cxtTest);
1535 ok(SUCCEEDED(hr),"GetTop Failed\n");
1536 ok(cxtTest == cxt2, "Wrong context on top\n");
1537 ok(check_context_refcount(cxt2) > cnt, "Ref count did not increase\n");
1538 ITfContext_Release(cxtTest);
1539
1540 cnt = check_context_refcount(cxt);
1541 hr = ITfDocumentMgr_GetBase(g_dm, &cxtTest);
1542 ok(SUCCEEDED(hr),"GetBase Failed\n");
1543 ok(cxtTest == cxt, "Wrong context on Base\n");
1544 ok(check_context_refcount(cxt) > cnt, "Ref count did not increase\n");
1545 ITfContext_Release(cxtTest);
1546
1547 cnt = check_context_refcount(cxt2);
1548 test_OnPopContext = SINK_EXPECTED;
1549 hr = ITfDocumentMgr_Pop(g_dm, 0);
1550 ok(SUCCEEDED(hr),"Pop Failed\n");
1551 ok(check_context_refcount(cxt2) < cnt, "Ref count did not decrease\n");
1552 sink_check_ok(&test_OnPopContext,"OnPopContext");
1553
1554 dmtest = (void *)0xfeedface;
1555 hr = ITfContext_GetDocumentMgr(cxt2,&dmtest);
1556 ok(hr == S_FALSE, "ITfContext_GetDocumentMgr wrong rc %x\n",hr);
1557 ok(dmtest == NULL,"returned documentmgr should be null\n");
1558
1559 hr = ITfDocumentMgr_GetTop(g_dm, &cxtTest);
1560 ok(SUCCEEDED(hr),"GetTop Failed\n");
1561 ok(cxtTest == cxt, "Wrong context on top\n");
1562 ITfContext_Release(cxtTest);
1563
1564 hr = ITfDocumentMgr_GetBase(g_dm, &cxtTest);
1565 ok(SUCCEEDED(hr),"GetBase Failed\n");
1566 ok(cxtTest == cxt, "Wrong context on base\n");
1567 ITfContext_Release(cxtTest);
1568
1569 hr = ITfDocumentMgr_Pop(g_dm, 0);
1570 ok(FAILED(hr),"Pop Succeeded\n");
1571
1572 hr = ITfDocumentMgr_GetTop(g_dm, &cxtTest);
1573 ok(SUCCEEDED(hr),"GetTop Failed\n");
1574 ok(cxtTest == cxt, "Wrong context on top\n");
1575 ITfContext_Release(cxtTest);
1576
1577 hr = ITfDocumentMgr_GetBase(g_dm, &cxtTest);
1578 ok(SUCCEEDED(hr),"GetBase Failed\n");
1579 ok(cxtTest == cxt, "Wrong context on base\n");
1580 ITfContext_Release(cxtTest);
1581
1582 ITfContext_Release(cxt);
1583 ITfContext_Release(cxt2);
1584 ITfContext_Release(cxt3);
1585 }
1586
1587 static void test_endSession(void)
1588 {
1589 HRESULT hr;
1590 test_ShouldDeactivate = TRUE;
1591 test_CurrentFocus = NULL;
1592 test_PrevFocus = g_dm;
1593 test_OnSetFocus = SINK_OPTIONAL; /* Doesn't fire on Win7 */
1594 hr = ITfThreadMgr_Deactivate(g_tm);
1595 ok(SUCCEEDED(hr),"Failed to Deactivate\n");
1596 sink_check_ok(&test_OnSetFocus,"OnSetFocus");
1597 test_OnSetFocus = SINK_UNEXPECTED;
1598 }
1599
1600 static void test_TfGuidAtom(void)
1601 {
1602 GUID gtest,g1;
1603 HRESULT hr;
1604 TfGuidAtom atom1,atom2;
1605 BOOL equal;
1606
1607 CoCreateGuid(&gtest);
1608
1609 /* msdn reports this should return E_INVALIDARG. However my test show it crashing (winxp)*/
1610 /*
1611 hr = ITfCategoryMgr_RegisterGUID(g_cm,&gtest,NULL);
1612 ok(hr==E_INVALIDARG,"ITfCategoryMgr_RegisterGUID should have failed\n");
1613 */
1614 hr = ITfCategoryMgr_RegisterGUID(g_cm,&gtest,&atom1);
1615 ok(SUCCEEDED(hr),"ITfCategoryMgr_RegisterGUID failed\n");
1616 hr = ITfCategoryMgr_RegisterGUID(g_cm,&gtest,&atom2);
1617 ok(SUCCEEDED(hr),"ITfCategoryMgr_RegisterGUID failed\n");
1618 ok(atom1 == atom2,"atoms do not match\n");
1619 hr = ITfCategoryMgr_GetGUID(g_cm,atom2,NULL);
1620 ok(hr==E_INVALIDARG,"ITfCategoryMgr_GetGUID should have failed\n");
1621 hr = ITfCategoryMgr_GetGUID(g_cm,atom2,&g1);
1622 ok(SUCCEEDED(hr),"ITfCategoryMgr_GetGUID failed\n");
1623 ok(IsEqualGUID(&g1,&gtest),"guids do not match\n");
1624 hr = ITfCategoryMgr_IsEqualTfGuidAtom(g_cm,atom1,&gtest,NULL);
1625 ok(hr==E_INVALIDARG,"ITfCategoryMgr_IsEqualTfGuidAtom should have failed\n");
1626 hr = ITfCategoryMgr_IsEqualTfGuidAtom(g_cm,atom1,&gtest,&equal);
1627 ok(SUCCEEDED(hr),"ITfCategoryMgr_IsEqualTfGuidAtom failed\n");
1628 ok(equal == TRUE,"Equal value invalid\n");
1629
1630 /* show that cid and tid TfClientIds are also TfGuidAtoms */
1631 hr = ITfCategoryMgr_IsEqualTfGuidAtom(g_cm,tid,&CLSID_FakeService,&equal);
1632 ok(SUCCEEDED(hr),"ITfCategoryMgr_IsEqualTfGuidAtom failed\n");
1633 ok(equal == TRUE,"Equal value invalid\n");
1634 hr = ITfCategoryMgr_GetGUID(g_cm,cid,&g1);
1635 ok(SUCCEEDED(hr),"ITfCategoryMgr_GetGUID failed\n");
1636 ok(!IsEqualGUID(&g1,&GUID_NULL),"guid should not be NULL\n");
1637 }
1638
1639 static void test_ClientId(void)
1640 {
1641 ITfClientId *pcid;
1642 TfClientId id1,id2;
1643 HRESULT hr;
1644 GUID g2;
1645
1646 hr = ITfThreadMgr_QueryInterface(g_tm, &IID_ITfClientId, (LPVOID*)&pcid);
1647 ok(SUCCEEDED(hr),"Unable to acquire ITfClientId interface\n");
1648
1649 CoCreateGuid(&g2);
1650
1651 hr = ITfClientId_GetClientId(pcid,&GUID_NULL,&id1);
1652 ok(SUCCEEDED(hr),"GetClientId failed\n");
1653 hr = ITfClientId_GetClientId(pcid,&GUID_NULL,&id2);
1654 ok(SUCCEEDED(hr),"GetClientId failed\n");
1655 ok(id1==id2,"Id's for GUID_NULL do not match\n");
1656 hr = ITfClientId_GetClientId(pcid,&CLSID_FakeService,&id2);
1657 ok(SUCCEEDED(hr),"GetClientId failed\n");
1658 ok(id2!=id1,"Id matches GUID_NULL\n");
1659 ok(id2==tid,"Id for CLSID_FakeService not matching tid\n");
1660 ok(id2!=cid,"Id for CLSID_FakeService matching cid\n");
1661 hr = ITfClientId_GetClientId(pcid,&g2,&id2);
1662 ok(SUCCEEDED(hr),"GetClientId failed\n");
1663 ok(id2!=id1,"Id matches GUID_NULL\n");
1664 ok(id2!=tid,"Id for random guid matching tid\n");
1665 ok(id2!=cid,"Id for random guid matching cid\n");
1666 ITfClientId_Release(pcid);
1667 }
1668
1669 /**********************************************************************
1670 * ITfEditSession
1671 **********************************************************************/
1672 typedef struct tagEditSession
1673 {
1674 ITfEditSession ITfEditSession_iface;
1675 LONG refCount;
1676 } EditSession;
1677
1678 static inline EditSession *impl_from_ITfEditSession(ITfEditSession *iface)
1679 {
1680 return CONTAINING_RECORD(iface, EditSession, ITfEditSession_iface);
1681 }
1682
1683 static void EditSession_Destructor(EditSession *This)
1684 {
1685 HeapFree(GetProcessHeap(),0,This);
1686 }
1687
1688 static HRESULT WINAPI EditSession_QueryInterface(ITfEditSession *iface, REFIID iid, LPVOID *ppvOut)
1689 {
1690 EditSession *This = impl_from_ITfEditSession(iface);
1691 *ppvOut = NULL;
1692
1693 if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITfEditSession))
1694 {
1695 *ppvOut = This;
1696 }
1697
1698 if (*ppvOut)
1699 {
1700 ITfEditSession_AddRef(iface);
1701 return S_OK;
1702 }
1703
1704 return E_NOINTERFACE;
1705 }
1706
1707 static ULONG WINAPI EditSession_AddRef(ITfEditSession *iface)
1708 {
1709 EditSession *This = impl_from_ITfEditSession(iface);
1710 return InterlockedIncrement(&This->refCount);
1711 }
1712
1713 static ULONG WINAPI EditSession_Release(ITfEditSession *iface)
1714 {
1715 EditSession *This = impl_from_ITfEditSession(iface);
1716 ULONG ret;
1717
1718 ret = InterlockedDecrement(&This->refCount);
1719 if (ret == 0)
1720 EditSession_Destructor(This);
1721 return ret;
1722 }
1723
1724 static void test_InsertAtSelection(TfEditCookie ec, ITfContext *cxt)
1725 {
1726 HRESULT hr;
1727 ITfInsertAtSelection *iis;
1728 ITfRange *range=NULL;
1729 static const WCHAR txt[] = {'H','e','l','l','o',' ','W','o','r','l','d',0};
1730
1731 hr = ITfContext_QueryInterface(cxt, &IID_ITfInsertAtSelection , (LPVOID*)&iis);
1732 ok(SUCCEEDED(hr),"Failed to get ITfInsertAtSelection interface\n");
1733 test_ACP_InsertTextAtSelection = SINK_EXPECTED;
1734 hr = ITfInsertAtSelection_InsertTextAtSelection(iis, ec, 0, txt, 11, &range);
1735 ok(SUCCEEDED(hr),"ITfInsertAtSelection_InsertTextAtSelection failed %x\n",hr);
1736 sink_check_ok(&test_ACP_InsertTextAtSelection,"InsertTextAtSelection");
1737 ok(range != NULL,"No range returned\n");
1738 ITfRange_Release(range);
1739 ITfInsertAtSelection_Release(iis);
1740 }
1741
1742 static HRESULT WINAPI EditSession_DoEditSession(ITfEditSession *iface,
1743 TfEditCookie ec)
1744 {
1745 ITfContext *cxt;
1746 ITfDocumentMgr *dm;
1747 ITfRange *range;
1748 TF_SELECTION selection;
1749 ULONG fetched;
1750 HRESULT hr;
1751
1752 sink_fire_ok(&test_DoEditSession,"EditSession_DoEditSession");
1753 sink_check_ok(&test_ACP_RequestLock,"RequestLock");
1754
1755 ITfThreadMgr_GetFocus(g_tm, &dm);
1756 ITfDocumentMgr_GetTop(dm,&cxt);
1757
1758 hr = ITfContext_GetStart(cxt,ec,NULL);
1759 ok(hr == E_INVALIDARG,"Unexpected return code %x\n",hr);
1760
1761 range = (ITfRange*)0xdeaddead;
1762 hr = ITfContext_GetStart(cxt,0xdeadcafe,&range);
1763 ok(hr == TF_E_NOLOCK,"Unexpected return code %x\n",hr);
1764 ok(range == NULL,"Range not set to NULL\n");
1765
1766 hr = ITfContext_GetStart(cxt,ec,&range);
1767 ok(SUCCEEDED(hr),"Unexpected return code %x\n",hr);
1768 ok(range != NULL,"Range set to NULL\n");
1769
1770 ITfRange_Release(range);
1771
1772 hr = ITfContext_GetEnd(cxt,ec,NULL);
1773 ok(hr == E_INVALIDARG,"Unexpected return code %x\n",hr);
1774
1775 range = (ITfRange*)0xdeaddead;
1776 hr = ITfContext_GetEnd(cxt,0xdeadcafe,&range);
1777 ok(hr == TF_E_NOLOCK,"Unexpected return code %x\n",hr);
1778 ok(range == NULL,"Range not set to NULL\n");
1779
1780 test_ACP_GetEndACP = SINK_EXPECTED;
1781 hr = ITfContext_GetEnd(cxt,ec,&range);
1782 ok(SUCCEEDED(hr),"Unexpected return code %x\n",hr);
1783 ok(range != NULL,"Range set to NULL\n");
1784 sink_check_ok(&test_ACP_GetEndACP,"GetEndACP");
1785
1786 ITfRange_Release(range);
1787
1788 selection.range = NULL;
1789 test_ACP_GetSelection = SINK_EXPECTED;
1790 hr = ITfContext_GetSelection(cxt, ec, TF_DEFAULT_SELECTION, 1, &selection, &fetched);
1791 ok(SUCCEEDED(hr),"ITfContext_GetSelection failed\n");
1792 ok(fetched == 1,"fetched incorrect\n");
1793 ok(selection.range != NULL,"NULL range\n");
1794 sink_check_ok(&test_ACP_GetSelection,"ACP_GetSepection");
1795 ITfRange_Release(selection.range);
1796
1797 test_InsertAtSelection(ec, cxt);
1798
1799 test_ACP_GetEndACP = SINK_EXPECTED;
1800 hr = ITfContext_GetEnd(cxt,ec,&range);
1801 ok(SUCCEEDED(hr),"Unexpected return code %x\n",hr);
1802 ok(range != NULL,"Range set to NULL\n");
1803 sink_check_ok(&test_ACP_GetEndACP,"GetEndACP");
1804
1805 selection.range = range;
1806 selection.style.ase = TF_AE_NONE;
1807 selection.style.fInterimChar = FALSE;
1808 test_ACP_SetSelection = SINK_EXPECTED;
1809 hr = ITfContext_SetSelection(cxt, ec, 1, &selection);
1810 ok(SUCCEEDED(hr),"ITfContext_SetSelection failed\n");
1811 sink_check_ok(&test_ACP_SetSelection,"SetSelection");
1812 ITfRange_Release(range);
1813
1814 ITfContext_Release(cxt);
1815 ITfDocumentMgr_Release(dm);
1816 return 0xdeadcafe;
1817 }
1818
1819 static const ITfEditSessionVtbl EditSession_EditSessionVtbl =
1820 {
1821 EditSession_QueryInterface,
1822 EditSession_AddRef,
1823 EditSession_Release,
1824
1825 EditSession_DoEditSession
1826 };
1827
1828 static HRESULT EditSession_Constructor(ITfEditSession **ppOut)
1829 {
1830 EditSession *This;
1831
1832 *ppOut = NULL;
1833 This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(EditSession));
1834 if (This == NULL)
1835 return E_OUTOFMEMORY;
1836
1837 This->ITfEditSession_iface.lpVtbl = &EditSession_EditSessionVtbl;
1838 This->refCount = 1;
1839
1840 *ppOut = &This->ITfEditSession_iface;
1841 return S_OK;
1842 }
1843
1844 static void test_TStoApplicationText(void)
1845 {
1846 HRESULT hr, hrSession;
1847 ITfEditSession *es;
1848 ITfContext *cxt;
1849 ITfDocumentMgr *dm;
1850 ITfTextEditSink *sink;
1851 ITfSource *source = NULL;
1852 DWORD editSinkCookie = -1;
1853
1854 ITfThreadMgr_GetFocus(g_tm, &dm);
1855 EditSession_Constructor(&es);
1856 ITfDocumentMgr_GetTop(dm,&cxt);
1857
1858 TextEditSink_Constructor(&sink);
1859 hr = ITfContext_QueryInterface(cxt,&IID_ITfSource,(LPVOID*)&source);
1860 ok(SUCCEEDED(hr),"Failed to get IID_ITfSource for Context\n");
1861 if (source)
1862 {
1863 hr = ITfSource_AdviseSink(source, &IID_ITfTextEditSink, (LPVOID)sink, &editSinkCookie);
1864 ok(SUCCEEDED(hr),"Failed to advise Sink\n");
1865 ok(editSinkCookie != -1,"Failed to get sink cookie\n");
1866 }
1867
1868 hrSession = 0xfeedface;
1869 /* Test no permissions flags */
1870 hr = ITfContext_RequestEditSession(cxt, tid, es, TF_ES_SYNC, &hrSession);
1871 ok(hr == E_INVALIDARG,"RequestEditSession should have failed with %x not %x\n",E_INVALIDARG,hr);
1872 ok(hrSession == E_FAIL,"hrSession should be %x not %x\n",E_FAIL,hrSession);
1873
1874 documentStatus = TS_SD_READONLY;
1875 hrSession = 0xfeedface;
1876 test_ACP_GetStatus = SINK_EXPECTED;
1877 hr = ITfContext_RequestEditSession(cxt, tid, es, TF_ES_SYNC|TF_ES_READWRITE, &hrSession);
1878 ok(SUCCEEDED(hr),"ITfContext_RequestEditSession failed\n");
1879 ok(hrSession == TS_E_READONLY,"Unexpected hrSession (%x)\n",hrSession);
1880 sink_check_ok(&test_ACP_GetStatus,"GetStatus");
1881
1882 /* signal a change to allow readwrite sessions */
1883 documentStatus = 0;
1884 test_ACP_RequestLock = SINK_EXPECTED;
1885 ITextStoreACPSink_OnStatusChange(ACPSink,documentStatus);
1886 sink_check_ok(&test_ACP_RequestLock,"RequestLock");
1887
1888 test_ACP_GetStatus = SINK_EXPECTED;
1889 test_ACP_RequestLock = SINK_EXPECTED;
1890 test_DoEditSession = SINK_EXPECTED;
1891 hrSession = 0xfeedface;
1892 test_OnEndEdit = SINK_EXPECTED;
1893 hr = ITfContext_RequestEditSession(cxt, tid, es, TF_ES_SYNC|TF_ES_READWRITE, &hrSession);
1894 ok(SUCCEEDED(hr),"ITfContext_RequestEditSession failed\n");
1895 sink_check_ok(&test_OnEndEdit,"OnEndEdit");
1896 sink_check_ok(&test_DoEditSession,"DoEditSession");
1897 sink_check_ok(&test_ACP_GetStatus,"GetStatus");
1898 ok(hrSession == 0xdeadcafe,"Unexpected hrSession (%x)\n",hrSession);
1899
1900 if (source)
1901 {
1902 hr = ITfSource_UnadviseSink(source, editSinkCookie);
1903 ok(SUCCEEDED(hr),"Failed to unadvise Sink\n");
1904 ITfSource_Release(source);
1905 }
1906 ITfTextEditSink_Release(sink);
1907 ITfContext_Release(cxt);
1908 ITfDocumentMgr_Release(dm);
1909 ITfEditSession_Release(es);
1910 }
1911
1912 static void enum_compartments(ITfCompartmentMgr *cmpmgr, REFGUID present, REFGUID absent)
1913 {
1914 BOOL found,found2;
1915 IEnumGUID *ppEnum;
1916 found = FALSE;
1917 found2 = FALSE;
1918 if (SUCCEEDED(ITfCompartmentMgr_EnumCompartments(cmpmgr, &ppEnum)))
1919 {
1920 ULONG fetched;
1921 GUID g;
1922 while (IEnumGUID_Next(ppEnum, 1, &g, &fetched) == S_OK)
1923 {
1924 WCHAR str[50];
1925 CHAR strA[50];
1926 StringFromGUID2(&g,str,sizeof(str)/sizeof(str[0]));
1927 WideCharToMultiByte(CP_ACP,0,str,-1,strA,sizeof(strA),0,0);
1928 trace("found %s\n",strA);
1929 if (present && IsEqualGUID(present,&g))
1930 found = TRUE;
1931 if (absent && IsEqualGUID(absent, &g))
1932 found2 = TRUE;
1933 }
1934 IEnumGUID_Release(ppEnum);
1935 }
1936 if (present)
1937 ok(found,"Did not find compartment\n");
1938 if (absent)
1939 ok(!found2,"Found compartment that should be absent\n");
1940 }
1941
1942 static void test_Compartments(void)
1943 {
1944 ITfContext *cxt;
1945 ITfDocumentMgr *dm;
1946 ITfCompartmentMgr *cmpmgr;
1947 ITfCompartment *cmp;
1948 HRESULT hr;
1949
1950 ITfThreadMgr_GetFocus(g_tm, &dm);
1951 ITfDocumentMgr_GetTop(dm,&cxt);
1952
1953 /* Global */
1954 hr = ITfThreadMgr_GetGlobalCompartment(g_tm, &cmpmgr);
1955 ok(SUCCEEDED(hr),"GetGlobalCompartment failed\n");
1956 hr = ITfCompartmentMgr_GetCompartment(cmpmgr, &GUID_COMPARTMENT_SPEECH_OPENCLOSE, &cmp);
1957 ok(SUCCEEDED(hr),"GetCompartment failed\n");
1958 ITfCompartment_Release(cmp);
1959 enum_compartments(cmpmgr,&GUID_COMPARTMENT_SPEECH_OPENCLOSE,NULL);
1960 ITfCompartmentMgr_Release(cmpmgr);
1961
1962 /* Thread */
1963 hr = ITfThreadMgr_QueryInterface(g_tm, &IID_ITfCompartmentMgr, (LPVOID*)&cmpmgr);
1964 ok(SUCCEEDED(hr),"ThreadMgr QI for IID_ITfCompartmentMgr failed\n");
1965 hr = ITfCompartmentMgr_GetCompartment(cmpmgr, &CLSID_FakeService, &cmp);
1966 ok(SUCCEEDED(hr),"GetCompartment failed\n");
1967 enum_compartments(cmpmgr,&CLSID_FakeService,&GUID_COMPARTMENT_SPEECH_OPENCLOSE);
1968 ITfCompartmentMgr_ClearCompartment(cmpmgr,tid,&CLSID_FakeService);
1969 enum_compartments(cmpmgr,NULL,&CLSID_FakeService);
1970 ITfCompartmentMgr_Release(cmpmgr);
1971 ITfCompartment_Release(cmp);
1972
1973 /* DocumentMgr */
1974 hr = ITfDocumentMgr_QueryInterface(dm, &IID_ITfCompartmentMgr, (LPVOID*)&cmpmgr);
1975 ok(SUCCEEDED(hr),"DocumentMgr QI for IID_ITfCompartmentMgr failed\n");
1976
1977 hr = ITfCompartmentMgr_GetCompartment(cmpmgr, &GUID_COMPARTMENT_PERSISTMENUENABLED, &cmp);
1978 ok(SUCCEEDED(hr),"GetCompartment failed\n");
1979 enum_compartments(cmpmgr,&GUID_COMPARTMENT_PERSISTMENUENABLED,&GUID_COMPARTMENT_SPEECH_OPENCLOSE);
1980 ITfCompartmentMgr_Release(cmpmgr);
1981
1982 /* Context */
1983 hr = ITfContext_QueryInterface(cxt, &IID_ITfCompartmentMgr, (LPVOID*)&cmpmgr);
1984 ok(SUCCEEDED(hr),"Context QI for IID_ITfCompartmentMgr failed\n");
1985 enum_compartments(cmpmgr,NULL,&GUID_COMPARTMENT_PERSISTMENUENABLED);
1986 ITfCompartmentMgr_Release(cmpmgr);
1987
1988 ITfContext_Release(cxt);
1989 ITfDocumentMgr_Release(dm);
1990 }
1991
1992 static void processPendingMessages(void)
1993 {
1994 MSG msg;
1995 int diff = 200;
1996 int min_timeout = 100;
1997 DWORD time = GetTickCount() + diff;
1998
1999 while (diff > 0)
2000 {
2001 if (MsgWaitForMultipleObjects(0, NULL, FALSE, min_timeout, QS_ALLINPUT) == WAIT_TIMEOUT)
2002 break;
2003 while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
2004 {
2005 TranslateMessage(&msg);
2006 DispatchMessage(&msg);
2007 }
2008 diff = time - GetTickCount();
2009 }
2010 }
2011
2012 static void test_AssociateFocus(void)
2013 {
2014 ITfDocumentMgr *dm1, *dm2, *olddm, *dmcheck, *dmorig;
2015 HWND wnd1, wnd2, wnd3;
2016 HRESULT hr;
2017
2018 ITfThreadMgr_GetFocus(g_tm, &dmorig);
2019 test_CurrentFocus = NULL;
2020 test_PrevFocus = dmorig;
2021 test_OnSetFocus = SINK_OPTIONAL; /* Doesn't always fire on Win7 */
2022 test_ACP_GetStatus = SINK_OPTIONAL;
2023 hr = ITfThreadMgr_SetFocus(g_tm,NULL);
2024 ok(SUCCEEDED(hr),"ITfThreadMgr_SetFocus failed\n");
2025 sink_check_ok(&test_OnSetFocus,"OnSetFocus");
2026 test_ACP_GetStatus = SINK_UNEXPECTED;
2027 ITfDocumentMgr_Release(dmorig);
2028
2029 hr = ITfThreadMgr_CreateDocumentMgr(g_tm,&dm1);
2030 ok(SUCCEEDED(hr),"CreateDocumentMgr failed\n");
2031
2032 hr = ITfThreadMgr_CreateDocumentMgr(g_tm,&dm2);
2033 ok(SUCCEEDED(hr),"CreateDocumentMgr failed\n");
2034
2035 wnd1 = CreateWindow("edit",NULL,WS_POPUP,0,0,200,60,NULL,NULL,NULL,NULL);
2036 ok(wnd1!=NULL,"Unable to create window 1\n");
2037 wnd2 = CreateWindow("edit",NULL,WS_POPUP,0,65,200,60,NULL,NULL,NULL,NULL);
2038 ok(wnd2!=NULL,"Unable to create window 2\n");
2039 wnd3 = CreateWindow("edit",NULL,WS_POPUP,0,130,200,60,NULL,NULL,NULL,NULL);
2040 ok(wnd3!=NULL,"Unable to create window 3\n");
2041
2042 processPendingMessages();
2043
2044 test_OnInitDocumentMgr = SINK_OPTIONAL; /* Vista and greater */
2045 test_OnPushContext = SINK_OPTIONAL; /* Vista and greater */
2046 test_OnSetFocus = SINK_OPTIONAL; /* Win7 */
2047 test_PrevFocus = NULL;
2048 test_CurrentFocus = FOCUS_IGNORE;
2049
2050 ShowWindow(wnd1,SW_SHOWNORMAL);
2051 test_OnSetFocus = SINK_UNEXPECTED;
2052 SetFocus(wnd1);
2053 sink_check_ok(&test_OnInitDocumentMgr,"OnInitDocumentMgr");
2054 sink_check_ok(&test_OnPushContext,"OnPushContext");
2055
2056 test_OnSetFocus = SINK_OPTIONAL; /* Vista and greater */
2057 test_ACP_RequestLock = SINK_OPTIONAL; /* Win7 x64 */
2058 test_ACP_GetSelection = SINK_OPTIONAL; /* Win7 x64 */
2059 ITfThreadMgr_GetFocus(g_tm, &test_PrevFocus);
2060 test_CurrentFocus = FOCUS_IGNORE; /* This is a default system context */
2061 processPendingMessages();
2062 sink_check_ok(&test_OnSetFocus,"OnSetFocus");
2063 test_ACP_RequestLock = SINK_UNEXPECTED;
2064 test_ACP_GetSelection = SINK_UNEXPECTED;
2065
2066 test_CurrentFocus = dm1;
2067 test_PrevFocus = FOCUS_IGNORE;
2068 test_OnSetFocus = SINK_OPTIONAL;
2069 test_ShouldDeactivate = SINK_OPTIONAL;
2070 hr = ITfThreadMgr_AssociateFocus(g_tm,wnd1,dm1,&olddm);
2071 ok(SUCCEEDED(hr),"AssociateFocus failed\n");
2072 sink_check_ok(&test_OnSetFocus,"OnSetFocus");
2073 test_ShouldDeactivate = SINK_UNEXPECTED;
2074
2075 processPendingMessages();
2076
2077 ITfThreadMgr_GetFocus(g_tm, &dmcheck);
2078 if (dmcheck != NULL)
2079 {
2080 ok(dmcheck == dm1, "Expected DocumentMgr not focused\n");
2081 ITfDocumentMgr_Release(dmcheck);
2082 }
2083 else
2084 {
2085 /* Sometimes we need to explicitly set focus on Win7 */
2086 test_CurrentFocus = dm1;
2087 test_PrevFocus = FOCUS_IGNORE;
2088 test_OnSetFocus = SINK_EXPECTED;
2089 ITfThreadMgr_SetFocus(g_tm, dm1);
2090 sink_check_ok(&test_OnSetFocus,"OnSetFocus");
2091 }
2092
2093 hr = ITfThreadMgr_AssociateFocus(g_tm,wnd2,dm2,&olddm);
2094 ok(SUCCEEDED(hr),"AssociateFocus failed\n");
2095 processPendingMessages();
2096 ITfThreadMgr_GetFocus(g_tm, &dmcheck);
2097 ok(dmcheck == dm1, "Expected DocumentMgr not focused\n");
2098 ITfDocumentMgr_Release(dmcheck);
2099
2100 hr = ITfThreadMgr_AssociateFocus(g_tm,wnd3,dm2,&olddm);
2101 ok(SUCCEEDED(hr),"AssociateFocus failed\n");
2102 processPendingMessages();
2103 ITfThreadMgr_GetFocus(g_tm, &dmcheck);
2104 ok(dmcheck == dm1, "Expected DocumentMgr not focused\n");
2105 ITfDocumentMgr_Release(dmcheck);
2106
2107 test_CurrentFocus = FOCUS_SAVE;
2108 test_PrevFocus = FOCUS_SAVE;
2109 test_OnSetFocus = SINK_SAVE;
2110 ShowWindow(wnd2,SW_SHOWNORMAL);
2111 SetFocus(wnd2);
2112 sink_check_saved(&test_OnSetFocus,dm1,dm2,"OnSetFocus");
2113 test_CurrentFocus = FOCUS_IGNORE; /* occasional wine race */
2114 test_PrevFocus = FOCUS_IGNORE; /* occasional wine race */
2115 test_OnSetFocus = SINK_IGNORE; /* occasional wine race */
2116 processPendingMessages();
2117
2118 ShowWindow(wnd3,SW_SHOWNORMAL);
2119 SetFocus(wnd3);
2120 processPendingMessages();
2121
2122 test_CurrentFocus = FOCUS_SAVE;
2123 test_PrevFocus = FOCUS_SAVE;
2124 test_OnSetFocus = SINK_SAVE;
2125 SetFocus(wnd1);
2126 processPendingMessages();
2127 sink_check_saved(&test_OnSetFocus,dm2,dm1,"OnSetFocus");
2128
2129 hr = ITfThreadMgr_AssociateFocus(g_tm,wnd3,NULL,&olddm);
2130 ok(SUCCEEDED(hr),"AssociateFocus failed\n");
2131 ok(olddm == dm2, "incorrect old DocumentMgr returned\n");
2132 ITfDocumentMgr_Release(olddm);
2133
2134 test_CurrentFocus = dmorig;
2135 test_PrevFocus = dm1;
2136 test_OnSetFocus = SINK_EXPECTED;
2137 test_ACP_GetStatus = SINK_IGNORE;
2138 ITfThreadMgr_SetFocus(g_tm,dmorig);
2139 sink_check_ok(&test_OnSetFocus,"OnSetFocus");
2140
2141 test_CurrentFocus = FOCUS_SAVE;
2142 test_PrevFocus = FOCUS_SAVE;
2143 test_OnSetFocus = SINK_SAVE;
2144 SetFocus(wnd3);
2145 processPendingMessages();
2146 sink_check_saved(&test_OnSetFocus,dmorig,FOCUS_IGNORE,"OnSetFocus"); /* CurrentFocus NULL on XP, system default on Vista */
2147
2148 hr = ITfThreadMgr_AssociateFocus(g_tm,wnd2,NULL,&olddm);
2149 ok(SUCCEEDED(hr),"AssociateFocus failed\n");
2150 ok(olddm == dm2, "incorrect old DocumentMgr returned\n");
2151 ITfDocumentMgr_Release(olddm);
2152 hr = ITfThreadMgr_AssociateFocus(g_tm,wnd1,NULL,&olddm);
2153 ok(SUCCEEDED(hr),"AssociateFocus failed\n");
2154 ok(olddm == dm1, "incorrect old DocumentMgr returned\n");
2155 ITfDocumentMgr_Release(olddm);
2156
2157 test_OnSetFocus = SINK_IGNORE; /* OnSetFocus fires a couple of times on Win7 */
2158 test_CurrentFocus = FOCUS_IGNORE;
2159 test_PrevFocus = FOCUS_IGNORE;
2160 SetFocus(wnd2);
2161 processPendingMessages();
2162 SetFocus(wnd1);
2163 processPendingMessages();
2164 test_OnSetFocus = SINK_UNEXPECTED;
2165
2166 ITfDocumentMgr_Release(dm1);
2167 ITfDocumentMgr_Release(dm2);
2168
2169 test_CurrentFocus = dmorig;
2170 test_PrevFocus = FOCUS_IGNORE;
2171 test_OnSetFocus = SINK_OPTIONAL;
2172 test_ACP_GetStatus = SINK_IGNORE;
2173 ITfThreadMgr_SetFocus(g_tm,dmorig);
2174 sink_check_ok(&test_OnSetFocus,"OnSetFocus");
2175
2176 test_OnSetFocus = SINK_IGNORE; /* OnSetFocus fires a couple of times on Win7 */
2177 test_CurrentFocus = FOCUS_IGNORE;
2178 test_PrevFocus = FOCUS_IGNORE;
2179 DestroyWindow(wnd1);
2180 DestroyWindow(wnd2);
2181 test_OnSetFocus = SINK_UNEXPECTED;
2182 test_OnPopContext = SINK_OPTIONAL; /* Vista and greater */
2183 test_OnSetFocus = SINK_OPTIONAL; /* Vista and greater */
2184 ITfThreadMgr_GetFocus(g_tm, &test_PrevFocus);
2185 test_CurrentFocus = NULL;
2186 test_ShouldDeactivate = TRUE; /* Win7 */
2187 DestroyWindow(wnd3);
2188 test_ShouldDeactivate = FALSE;
2189 sink_check_ok(&test_OnSetFocus,"OnSetFocus");
2190 sink_check_ok(&test_OnPopContext,"OnPopContext");
2191 }
2192
2193 START_TEST(inputprocessor)
2194 {
2195 if (SUCCEEDED(initialize()))
2196 {
2197 test_Register();
2198 test_RegisterCategory();
2199 Sleep(2000); /* Win7 needs some time before the registrations become active */
2200 processPendingMessages();
2201 test_EnumLanguageProfiles();
2202 test_EnumInputProcessorInfo();
2203 test_Enable();
2204 test_ThreadMgrAdviseSinks();
2205 test_Activate();
2206 test_startSession();
2207 test_TfGuidAtom();
2208 test_ClientId();
2209 test_KeystrokeMgr();
2210 test_TStoApplicationText();
2211 test_Compartments();
2212 test_AssociateFocus();
2213 test_endSession();
2214 test_FindClosestCategory();
2215 test_Disable();
2216 test_ThreadMgrUnadviseSinks();
2217 test_UnregisterCategory();
2218 test_Unregister();
2219 }
2220 else
2221 skip("Unable to create InputProcessor\n");
2222 cleanup();
2223 }