[MSCTF_WINETEST]
[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) ||
942 broken(IsEqualGUID(&profile.catid,&GUID_NULL) /* Win8 */), "CatId Incorrect\n");
943 ok(IsEqualGUID(&profile.guidProfile,&CLSID_FakeService), "guidProfile Incorrect\n");
944 }
945 }
946 }
947 ok(found,"Registered text service not found\n");
948 }
949
950 static void test_RegisterCategory(void)
951 {
952 HRESULT hr;
953 hr = ITfCategoryMgr_RegisterCategory(g_cm, &CLSID_FakeService, &GUID_TFCAT_TIP_KEYBOARD, &CLSID_FakeService);
954 ok(SUCCEEDED(hr),"ITfCategoryMgr_RegisterCategory failed\n");
955 hr = ITfCategoryMgr_RegisterCategory(g_cm, &CLSID_FakeService, &GUID_TFCAT_DISPLAYATTRIBUTEPROVIDER, &CLSID_FakeService);
956 ok(SUCCEEDED(hr),"ITfCategoryMgr_RegisterCategory failed\n");
957 }
958
959 static void test_UnregisterCategory(void)
960 {
961 HRESULT hr;
962 hr = ITfCategoryMgr_UnregisterCategory(g_cm, &CLSID_FakeService, &GUID_TFCAT_TIP_KEYBOARD, &CLSID_FakeService);
963 ok(SUCCEEDED(hr),"ITfCategoryMgr_UnregisterCategory failed\n");
964 hr = ITfCategoryMgr_UnregisterCategory(g_cm, &CLSID_FakeService, &GUID_TFCAT_DISPLAYATTRIBUTEPROVIDER, &CLSID_FakeService);
965 ok(SUCCEEDED(hr),"ITfCategoryMgr_UnregisterCategory failed\n");
966 }
967
968 static void test_FindClosestCategory(void)
969 {
970 GUID output;
971 HRESULT hr;
972 const GUID *list[3] = {&GUID_TFCAT_TIP_SPEECH, &GUID_TFCAT_TIP_KEYBOARD, &GUID_TFCAT_TIP_HANDWRITING};
973
974 hr = ITfCategoryMgr_FindClosestCategory(g_cm, &CLSID_FakeService, &output, NULL, 0);
975 ok(SUCCEEDED(hr),"ITfCategoryMgr_FindClosestCategory failed (%x)\n",hr);
976 ok(IsEqualGUID(&output,&GUID_TFCAT_DISPLAYATTRIBUTEPROVIDER),"Wrong GUID\n");
977
978 hr = ITfCategoryMgr_FindClosestCategory(g_cm, &CLSID_FakeService, &output, list, 1);
979 ok(SUCCEEDED(hr),"ITfCategoryMgr_FindClosestCategory failed (%x)\n",hr);
980 ok(IsEqualGUID(&output,&GUID_NULL),"Wrong GUID\n");
981
982 hr = ITfCategoryMgr_FindClosestCategory(g_cm, &CLSID_FakeService, &output, list, 3);
983 ok(SUCCEEDED(hr),"ITfCategoryMgr_FindClosestCategory failed (%x)\n",hr);
984 ok(IsEqualGUID(&output,&GUID_TFCAT_TIP_KEYBOARD),"Wrong GUID\n");
985 }
986
987 static void test_Enable(void)
988 {
989 HRESULT hr;
990 BOOL enabled = FALSE;
991
992 hr = ITfInputProcessorProfiles_EnableLanguageProfile(g_ipp,&CLSID_FakeService, gLangid, &CLSID_FakeService, TRUE);
993 ok(SUCCEEDED(hr),"Failed to enable text service\n");
994 hr = ITfInputProcessorProfiles_IsEnabledLanguageProfile(g_ipp,&CLSID_FakeService, gLangid, &CLSID_FakeService, &enabled);
995 ok(SUCCEEDED(hr),"Failed to get enabled state\n");
996 ok(enabled == TRUE,"enabled state incorrect\n");
997 }
998
999 static void test_Disable(void)
1000 {
1001 HRESULT hr;
1002
1003 trace("Disabling\n");
1004 hr = ITfInputProcessorProfiles_EnableLanguageProfile(g_ipp,&CLSID_FakeService, gLangid, &CLSID_FakeService, FALSE);
1005 ok(SUCCEEDED(hr),"Failed to disable text service\n");
1006 }
1007
1008 static void test_ThreadMgrAdviseSinks(void)
1009 {
1010 ITfSource *source = NULL;
1011 HRESULT hr;
1012 IUnknown *sink;
1013
1014 hr = ITfThreadMgr_QueryInterface(g_tm, &IID_ITfSource, (LPVOID*)&source);
1015 ok(SUCCEEDED(hr),"Failed to get IID_ITfSource for ThreadMgr\n");
1016 if (!source)
1017 return;
1018
1019 hr = ThreadMgrEventSink_Constructor(&sink);
1020 ok(hr == S_OK, "got %08x\n", hr);
1021 if(FAILED(hr)) return;
1022
1023 tmSinkRefCount = 1;
1024 tmSinkCookie = 0;
1025 hr = ITfSource_AdviseSink(source,&IID_ITfThreadMgrEventSink, sink, &tmSinkCookie);
1026 ok(SUCCEEDED(hr),"Failed to Advise Sink\n");
1027 ok(tmSinkCookie!=0,"Failed to get sink cookie\n");
1028
1029 /* Advising the sink adds a ref, Releasing here lets the object be deleted
1030 when unadvised */
1031 tmSinkRefCount = 2;
1032 IUnknown_Release(sink);
1033 ITfSource_Release(source);
1034 }
1035
1036 static void test_ThreadMgrUnadviseSinks(void)
1037 {
1038 ITfSource *source = NULL;
1039 HRESULT hr;
1040
1041 hr = ITfThreadMgr_QueryInterface(g_tm, &IID_ITfSource, (LPVOID*)&source);
1042 ok(SUCCEEDED(hr),"Failed to get IID_ITfSource for ThreadMgr\n");
1043 if (!source)
1044 return;
1045
1046 tmSinkRefCount = 1;
1047 hr = ITfSource_UnadviseSink(source, tmSinkCookie);
1048 ok(SUCCEEDED(hr),"Failed to unadvise Sink\n");
1049 ITfSource_Release(source);
1050 }
1051
1052 /**********************************************************************
1053 * ITfKeyEventSink
1054 **********************************************************************/
1055 typedef struct tagKeyEventSink
1056 {
1057 ITfKeyEventSink ITfKeyEventSink_iface;
1058 LONG refCount;
1059 } KeyEventSink;
1060
1061 static inline KeyEventSink *impl_from_ITfKeyEventSink(ITfKeyEventSink *iface)
1062 {
1063 return CONTAINING_RECORD(iface, KeyEventSink, ITfKeyEventSink_iface);
1064 }
1065
1066 static void KeyEventSink_Destructor(KeyEventSink *This)
1067 {
1068 HeapFree(GetProcessHeap(),0,This);
1069 }
1070
1071 static HRESULT WINAPI KeyEventSink_QueryInterface(ITfKeyEventSink *iface, REFIID iid, LPVOID *ppvOut)
1072 {
1073 KeyEventSink *This = impl_from_ITfKeyEventSink(iface);
1074 *ppvOut = NULL;
1075
1076 if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITfKeyEventSink))
1077 {
1078 *ppvOut = This;
1079 }
1080
1081 if (*ppvOut)
1082 {
1083 ITfKeyEventSink_AddRef(iface);
1084 return S_OK;
1085 }
1086
1087 return E_NOINTERFACE;
1088 }
1089
1090 static ULONG WINAPI KeyEventSink_AddRef(ITfKeyEventSink *iface)
1091 {
1092 KeyEventSink *This = impl_from_ITfKeyEventSink(iface);
1093 return InterlockedIncrement(&This->refCount);
1094 }
1095
1096 static ULONG WINAPI KeyEventSink_Release(ITfKeyEventSink *iface)
1097 {
1098 KeyEventSink *This = impl_from_ITfKeyEventSink(iface);
1099 ULONG ret;
1100
1101 ret = InterlockedDecrement(&This->refCount);
1102 if (ret == 0)
1103 KeyEventSink_Destructor(This);
1104 return ret;
1105 }
1106
1107 static HRESULT WINAPI KeyEventSink_OnSetFocus(ITfKeyEventSink *iface,
1108 BOOL fForeground)
1109 {
1110 sink_fire_ok(&test_KEV_OnSetFocus,"KeyEventSink_OnSetFocus");
1111 return S_OK;
1112 }
1113
1114 static HRESULT WINAPI KeyEventSink_OnTestKeyDown(ITfKeyEventSink *iface,
1115 ITfContext *pic, WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
1116 {
1117 trace("\n");
1118 return S_OK;
1119 }
1120
1121 static HRESULT WINAPI KeyEventSink_OnTestKeyUp(ITfKeyEventSink *iface,
1122 ITfContext *pic, WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
1123 {
1124 trace("\n");
1125 return S_OK;
1126 }
1127
1128 static HRESULT WINAPI KeyEventSink_OnKeyDown(ITfKeyEventSink *iface,
1129 ITfContext *pic, WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
1130 {
1131 trace("\n");
1132 return S_OK;
1133 }
1134
1135 static HRESULT WINAPI KeyEventSink_OnKeyUp(ITfKeyEventSink *iface,
1136 ITfContext *pic, WPARAM wParam, LPARAM lParam, BOOL *pfEaten)
1137 {
1138 trace("\n");
1139 return S_OK;
1140 }
1141
1142 static HRESULT WINAPI KeyEventSink_OnPreservedKey(ITfKeyEventSink *iface,
1143 ITfContext *pic, REFGUID rguid, BOOL *pfEaten)
1144 {
1145 trace("\n");
1146 return S_OK;
1147 }
1148
1149 static const ITfKeyEventSinkVtbl KeyEventSink_KeyEventSinkVtbl =
1150 {
1151 KeyEventSink_QueryInterface,
1152 KeyEventSink_AddRef,
1153 KeyEventSink_Release,
1154
1155 KeyEventSink_OnSetFocus,
1156 KeyEventSink_OnTestKeyDown,
1157 KeyEventSink_OnTestKeyUp,
1158 KeyEventSink_OnKeyDown,
1159 KeyEventSink_OnKeyUp,
1160 KeyEventSink_OnPreservedKey
1161 };
1162
1163 static HRESULT KeyEventSink_Constructor(ITfKeyEventSink **ppOut)
1164 {
1165 KeyEventSink *This;
1166
1167 This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(KeyEventSink));
1168 if (This == NULL)
1169 return E_OUTOFMEMORY;
1170
1171 This->ITfKeyEventSink_iface.lpVtbl = &KeyEventSink_KeyEventSinkVtbl;
1172 This->refCount = 1;
1173
1174 *ppOut = &This->ITfKeyEventSink_iface;
1175 return S_OK;
1176 }
1177
1178
1179 static void test_KeystrokeMgr(void)
1180 {
1181 ITfKeystrokeMgr *keymgr= NULL;
1182 HRESULT hr;
1183 TF_PRESERVEDKEY tfpk;
1184 BOOL preserved;
1185 ITfKeyEventSink *sink = NULL;
1186
1187 KeyEventSink_Constructor(&sink);
1188
1189 hr = ITfThreadMgr_QueryInterface(g_tm, &IID_ITfKeystrokeMgr, (LPVOID*)&keymgr);
1190 ok(SUCCEEDED(hr),"Failed to get IID_ITfKeystrokeMgr for ThreadMgr\n");
1191
1192 tfpk.uVKey = 'A';
1193 tfpk.uModifiers = TF_MOD_SHIFT;
1194
1195 test_KEV_OnSetFocus = SINK_EXPECTED;
1196 hr = ITfKeystrokeMgr_AdviseKeyEventSink(keymgr,tid,sink,TRUE);
1197 ok(SUCCEEDED(hr),"ITfKeystrokeMgr_AdviseKeyEventSink failed\n");
1198 sink_check_ok(&test_KEV_OnSetFocus,"KeyEventSink_OnSetFocus");
1199 hr = ITfKeystrokeMgr_AdviseKeyEventSink(keymgr,tid,sink,TRUE);
1200 ok(hr == CONNECT_E_ADVISELIMIT,"Wrong return, expected CONNECT_E_ADVISELIMIT\n");
1201 hr = ITfKeystrokeMgr_AdviseKeyEventSink(keymgr,cid,sink,TRUE);
1202 ok(hr == E_INVALIDARG,"Wrong return, expected E_INVALIDARG\n");
1203
1204 hr =ITfKeystrokeMgr_PreserveKey(keymgr, 0, &CLSID_PreservedKey, &tfpk, NULL, 0);
1205 ok(hr==E_INVALIDARG,"ITfKeystrokeMgr_PreserveKey inproperly succeeded\n");
1206
1207 hr =ITfKeystrokeMgr_PreserveKey(keymgr, tid, &CLSID_PreservedKey, &tfpk, NULL, 0);
1208 ok(SUCCEEDED(hr),"ITfKeystrokeMgr_PreserveKey failed\n");
1209
1210 hr =ITfKeystrokeMgr_PreserveKey(keymgr, tid, &CLSID_PreservedKey, &tfpk, NULL, 0);
1211 ok(hr == TF_E_ALREADY_EXISTS,"ITfKeystrokeMgr_PreserveKey inproperly succeeded\n");
1212
1213 preserved = FALSE;
1214 hr = ITfKeystrokeMgr_IsPreservedKey(keymgr, &CLSID_PreservedKey, &tfpk, &preserved);
1215 ok(hr == S_OK, "ITfKeystrokeMgr_IsPreservedKey failed\n");
1216 if (hr == S_OK) ok(preserved == TRUE,"misreporting preserved key\n");
1217
1218 hr = ITfKeystrokeMgr_UnpreserveKey(keymgr, &CLSID_PreservedKey,&tfpk);
1219 ok(SUCCEEDED(hr),"ITfKeystrokeMgr_UnpreserveKey failed\n");
1220
1221 hr = ITfKeystrokeMgr_IsPreservedKey(keymgr, &CLSID_PreservedKey, &tfpk, &preserved);
1222 ok(hr == S_FALSE, "ITfKeystrokeMgr_IsPreservedKey failed\n");
1223 if (hr == S_FALSE) ok(preserved == FALSE,"misreporting preserved key\n");
1224
1225 hr = ITfKeystrokeMgr_UnpreserveKey(keymgr, &CLSID_PreservedKey,&tfpk);
1226 ok(hr==CONNECT_E_NOCONNECTION,"ITfKeystrokeMgr_UnpreserveKey inproperly succeeded\n");
1227
1228 hr = ITfKeystrokeMgr_UnadviseKeyEventSink(keymgr,tid);
1229 ok(SUCCEEDED(hr),"ITfKeystrokeMgr_UnadviseKeyEventSink failed\n");
1230
1231 ITfKeystrokeMgr_Release(keymgr);
1232 ITfKeyEventSink_Release(sink);
1233 }
1234
1235 static void test_Activate(void)
1236 {
1237 HRESULT hr;
1238
1239 test_ShouldActivate = TRUE; /* Win7 */
1240 hr = ITfInputProcessorProfiles_ActivateLanguageProfile(g_ipp,&CLSID_FakeService,gLangid,&CLSID_FakeService);
1241 ok(SUCCEEDED(hr),"Failed to Activate text service\n");
1242 test_ShouldActivate = FALSE;
1243 }
1244
1245
1246 static void test_EnumContexts(ITfDocumentMgr *dm, ITfContext *search)
1247 {
1248 HRESULT hr;
1249 IEnumTfContexts* pEnum;
1250 BOOL found = FALSE;
1251
1252 hr = ITfDocumentMgr_EnumContexts(dm,&pEnum);
1253 ok(SUCCEEDED(hr),"EnumContexts failed\n");
1254 if (SUCCEEDED(hr))
1255 {
1256 ULONG fetched;
1257 ITfContext *cxt;
1258 while (IEnumTfContexts_Next(pEnum, 1, &cxt, &fetched) == S_OK)
1259 {
1260 if (!search)
1261 found = TRUE;
1262 else if (search == cxt)
1263 found = TRUE;
1264 ITfContext_Release(cxt);
1265 }
1266 IEnumTfContexts_Release(pEnum);
1267 }
1268 if (search)
1269 ok(found,"Did not find proper ITfContext\n");
1270 else
1271 ok(!found,"Found an ITfContext we should should not have\n");
1272 }
1273
1274 static void test_EnumDocumentMgr(ITfThreadMgr *tm, ITfDocumentMgr *search, ITfDocumentMgr *absent)
1275 {
1276 HRESULT hr;
1277 IEnumTfDocumentMgrs* pEnum;
1278 BOOL found = FALSE;
1279 BOOL notfound = TRUE;
1280
1281 hr = ITfThreadMgr_EnumDocumentMgrs(tm,&pEnum);
1282 ok(SUCCEEDED(hr),"EnumDocumentMgrs failed\n");
1283 if (SUCCEEDED(hr))
1284 {
1285 ULONG fetched;
1286 ITfDocumentMgr *dm;
1287 while (IEnumTfDocumentMgrs_Next(pEnum, 1, &dm, &fetched) == S_OK)
1288 {
1289 if (!search)
1290 found = TRUE;
1291 else if (search == dm)
1292 found = TRUE;
1293 if (absent && dm == absent)
1294 notfound = FALSE;
1295 ITfDocumentMgr_Release(dm);
1296 }
1297 IEnumTfDocumentMgrs_Release(pEnum);
1298 }
1299 if (search)
1300 ok(found,"Did not find proper ITfDocumentMgr\n");
1301 else
1302 ok(!found,"Found an ITfDocumentMgr we should should not have\n");
1303 if (absent)
1304 ok(notfound,"Found an ITfDocumentMgr we believe should be absent\n");
1305 }
1306
1307 static inline int check_context_refcount(ITfContext *iface)
1308 {
1309 ITfContext_AddRef(iface);
1310 return ITfContext_Release(iface);
1311 }
1312
1313
1314 /**********************************************************************
1315 * ITfTextEditSink
1316 **********************************************************************/
1317 typedef struct tagTextEditSink
1318 {
1319 ITfTextEditSink ITfTextEditSink_iface;
1320 LONG refCount;
1321 } TextEditSink;
1322
1323 static inline TextEditSink *impl_from_ITfTextEditSink(ITfTextEditSink *iface)
1324 {
1325 return CONTAINING_RECORD(iface, TextEditSink, ITfTextEditSink_iface);
1326 }
1327
1328 static void TextEditSink_Destructor(TextEditSink *This)
1329 {
1330 HeapFree(GetProcessHeap(),0,This);
1331 }
1332
1333 static HRESULT WINAPI TextEditSink_QueryInterface(ITfTextEditSink *iface, REFIID iid, LPVOID *ppvOut)
1334 {
1335 TextEditSink *This = impl_from_ITfTextEditSink(iface);
1336 *ppvOut = NULL;
1337
1338 if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITfTextEditSink))
1339 {
1340 *ppvOut = This;
1341 }
1342
1343 if (*ppvOut)
1344 {
1345 ITfTextEditSink_AddRef(iface);
1346 return S_OK;
1347 }
1348
1349 return E_NOINTERFACE;
1350 }
1351
1352 static ULONG WINAPI TextEditSink_AddRef(ITfTextEditSink *iface)
1353 {
1354 TextEditSink *This = impl_from_ITfTextEditSink(iface);
1355 return InterlockedIncrement(&This->refCount);
1356 }
1357
1358 static ULONG WINAPI TextEditSink_Release(ITfTextEditSink *iface)
1359 {
1360 TextEditSink *This = impl_from_ITfTextEditSink(iface);
1361 ULONG ret;
1362
1363 ret = InterlockedDecrement(&This->refCount);
1364 if (ret == 0)
1365 TextEditSink_Destructor(This);
1366 return ret;
1367 }
1368
1369 static HRESULT WINAPI TextEditSink_OnEndEdit(ITfTextEditSink *iface,
1370 ITfContext *pic, TfEditCookie ecReadOnly, ITfEditRecord *pEditRecord)
1371 {
1372 sink_fire_ok(&test_OnEndEdit,"TextEditSink_OnEndEdit");
1373 return S_OK;
1374 }
1375
1376 static const ITfTextEditSinkVtbl TextEditSink_TextEditSinkVtbl =
1377 {
1378 TextEditSink_QueryInterface,
1379 TextEditSink_AddRef,
1380 TextEditSink_Release,
1381
1382 TextEditSink_OnEndEdit
1383 };
1384
1385 static HRESULT TextEditSink_Constructor(ITfTextEditSink **ppOut)
1386 {
1387 TextEditSink *This;
1388
1389 *ppOut = NULL;
1390 This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(TextEditSink));
1391 if (This == NULL)
1392 return E_OUTOFMEMORY;
1393
1394 This->ITfTextEditSink_iface.lpVtbl = &TextEditSink_TextEditSinkVtbl;
1395 This->refCount = 1;
1396
1397 *ppOut = &This->ITfTextEditSink_iface;
1398 return S_OK;
1399 }
1400
1401 static void test_startSession(void)
1402 {
1403 HRESULT hr;
1404 DWORD cnt;
1405 DWORD editCookie;
1406 ITfDocumentMgr *dmtest;
1407 ITfContext *cxt,*cxt2,*cxt3,*cxtTest;
1408 ITextStoreACP *ts;
1409 TfClientId cid2 = 0;
1410
1411 hr = ITfThreadMgr_Deactivate(g_tm);
1412 ok(hr == E_UNEXPECTED,"Deactivate should have failed with E_UNEXPECTED\n");
1413
1414 test_ShouldActivate = TRUE;
1415 hr = ITfThreadMgr_Activate(g_tm,&cid);
1416 ok(SUCCEEDED(hr),"Failed to Activate\n");
1417 ok(cid != tid,"TextService id mistakenly matches Client id\n");
1418
1419 test_ShouldActivate = FALSE;
1420 hr = ITfThreadMgr_Activate(g_tm,&cid2);
1421 ok(SUCCEEDED(hr),"Failed to Activate\n");
1422 ok (cid == cid2, "Second activate client ID does not match\n");
1423
1424 hr = ITfThreadMgr_Deactivate(g_tm);
1425 ok(SUCCEEDED(hr),"Failed to Deactivate\n");
1426
1427 test_EnumDocumentMgr(g_tm,NULL,NULL);
1428
1429 hr = ITfThreadMgr_CreateDocumentMgr(g_tm,&g_dm);
1430 ok(SUCCEEDED(hr),"CreateDocumentMgr failed\n");
1431
1432 test_EnumDocumentMgr(g_tm,g_dm,NULL);
1433
1434 hr = ITfThreadMgr_CreateDocumentMgr(g_tm,&dmtest);
1435 ok(SUCCEEDED(hr),"CreateDocumentMgr failed\n");
1436
1437 test_EnumDocumentMgr(g_tm,dmtest,NULL);
1438
1439 ITfDocumentMgr_Release(dmtest);
1440 test_EnumDocumentMgr(g_tm,g_dm,dmtest);
1441
1442 hr = ITfThreadMgr_GetFocus(g_tm,&dmtest);
1443 ok(SUCCEEDED(hr),"GetFocus Failed\n");
1444 ok(dmtest == NULL,"Initial focus not null\n");
1445
1446 test_CurrentFocus = g_dm;
1447 test_PrevFocus = NULL;
1448 test_OnSetFocus = SINK_OPTIONAL; /* Doesn't always fire on Win7 */
1449 hr = ITfThreadMgr_SetFocus(g_tm,g_dm);
1450 ok(SUCCEEDED(hr),"SetFocus Failed\n");
1451 sink_check_ok(&test_OnSetFocus,"OnSetFocus");
1452
1453 hr = ITfThreadMgr_GetFocus(g_tm,&dmtest);
1454 ok(SUCCEEDED(hr),"GetFocus Failed\n");
1455 ok(g_dm == dmtest,"Expected DocumentMgr not focused\n");
1456
1457 ITfDocumentMgr_Release(g_dm);
1458
1459 hr = ITfThreadMgr_GetFocus(g_tm,&dmtest);
1460 ok(SUCCEEDED(hr),"GetFocus Failed\n");
1461 ok(g_dm == dmtest,"Expected DocumentMgr not focused\n");
1462 ITfDocumentMgr_Release(dmtest);
1463
1464 hr = TextStoreACP_Constructor((IUnknown**)&ts);
1465 if (SUCCEEDED(hr))
1466 {
1467 hr = ITfDocumentMgr_CreateContext(g_dm, cid, 0, (IUnknown*)ts, &cxt, &editCookie);
1468 ok(SUCCEEDED(hr),"CreateContext Failed\n");
1469 }
1470
1471 hr = ITfDocumentMgr_CreateContext(g_dm, cid, 0, NULL, &cxt2, &editCookie);
1472 ok(SUCCEEDED(hr),"CreateContext Failed\n");
1473
1474 hr = ITfDocumentMgr_CreateContext(g_dm, cid, 0, NULL, &cxt3, &editCookie);
1475 ok(SUCCEEDED(hr),"CreateContext Failed\n");
1476
1477 test_EnumContexts(g_dm, NULL);
1478
1479 hr = ITfContext_GetDocumentMgr(cxt,&dmtest);
1480 ok(hr == S_OK, "ITfContext_GetDocumentMgr failed with %x\n",hr);
1481 ok(dmtest == g_dm, "Wrong documentmgr\n");
1482 ITfDocumentMgr_Release(dmtest);
1483
1484 cnt = check_context_refcount(cxt);
1485 test_OnPushContext = SINK_EXPECTED;
1486 test_ACP_AdviseSink = SINK_EXPECTED;
1487 test_OnInitDocumentMgr = SINK_EXPECTED;
1488 hr = ITfDocumentMgr_Push(g_dm, cxt);
1489 ok(SUCCEEDED(hr),"Push Failed\n");
1490 ok(check_context_refcount(cxt) > cnt, "Ref count did not increase\n");
1491 sink_check_ok(&test_OnPushContext,"OnPushContext");
1492 sink_check_ok(&test_OnInitDocumentMgr,"OnInitDocumentMgr");
1493 sink_check_ok(&test_ACP_AdviseSink,"TextStoreACP_AdviseSink");
1494
1495 test_EnumContexts(g_dm, cxt);
1496
1497 hr = ITfDocumentMgr_GetTop(g_dm, &cxtTest);
1498 ok(SUCCEEDED(hr),"GetTop Failed\n");
1499 ok(cxtTest == cxt, "Wrong context on top\n");
1500 ok(check_context_refcount(cxt) > cnt, "Ref count did not increase\n");
1501 cnt = ITfContext_Release(cxtTest);
1502
1503 hr = ITfDocumentMgr_GetBase(g_dm, &cxtTest);
1504 ok(SUCCEEDED(hr),"GetBase Failed\n");
1505 ok(cxtTest == cxt, "Wrong context on Base\n");
1506 ok(check_context_refcount(cxt) > cnt, "Ref count did not increase\n");
1507 ITfContext_Release(cxtTest);
1508
1509 check_context_refcount(cxt2);
1510 test_OnPushContext = SINK_EXPECTED;
1511 hr = ITfDocumentMgr_Push(g_dm, cxt2);
1512 ok(SUCCEEDED(hr),"Push Failed\n");
1513 sink_check_ok(&test_OnPushContext,"OnPushContext");
1514
1515 cnt = check_context_refcount(cxt2);
1516 hr = ITfDocumentMgr_GetTop(g_dm, &cxtTest);
1517 ok(SUCCEEDED(hr),"GetTop Failed\n");
1518 ok(cxtTest == cxt2, "Wrong context on top\n");
1519 ok(check_context_refcount(cxt2) > cnt, "Ref count did not increase\n");
1520 ITfContext_Release(cxtTest);
1521
1522 cnt = check_context_refcount(cxt);
1523 hr = ITfDocumentMgr_GetBase(g_dm, &cxtTest);
1524 ok(SUCCEEDED(hr),"GetBase Failed\n");
1525 ok(cxtTest == cxt, "Wrong context on Base\n");
1526 ok(check_context_refcount(cxt) > cnt, "Ref count did not increase\n");
1527 ITfContext_Release(cxtTest);
1528
1529 cnt = check_context_refcount(cxt3);
1530 hr = ITfDocumentMgr_Push(g_dm, cxt3);
1531 ok(FAILED(hr),"Push Succeeded\n");
1532 ok(check_context_refcount(cxt3) == cnt, "Ref changed\n");
1533
1534 cnt = check_context_refcount(cxt2);
1535 hr = ITfDocumentMgr_GetTop(g_dm, &cxtTest);
1536 ok(SUCCEEDED(hr),"GetTop Failed\n");
1537 ok(cxtTest == cxt2, "Wrong context on top\n");
1538 ok(check_context_refcount(cxt2) > cnt, "Ref count did not increase\n");
1539 ITfContext_Release(cxtTest);
1540
1541 cnt = check_context_refcount(cxt);
1542 hr = ITfDocumentMgr_GetBase(g_dm, &cxtTest);
1543 ok(SUCCEEDED(hr),"GetBase Failed\n");
1544 ok(cxtTest == cxt, "Wrong context on Base\n");
1545 ok(check_context_refcount(cxt) > cnt, "Ref count did not increase\n");
1546 ITfContext_Release(cxtTest);
1547
1548 cnt = check_context_refcount(cxt2);
1549 test_OnPopContext = SINK_EXPECTED;
1550 hr = ITfDocumentMgr_Pop(g_dm, 0);
1551 ok(SUCCEEDED(hr),"Pop Failed\n");
1552 ok(check_context_refcount(cxt2) < cnt, "Ref count did not decrease\n");
1553 sink_check_ok(&test_OnPopContext,"OnPopContext");
1554
1555 dmtest = (void *)0xfeedface;
1556 hr = ITfContext_GetDocumentMgr(cxt2,&dmtest);
1557 ok(hr == S_FALSE, "ITfContext_GetDocumentMgr wrong rc %x\n",hr);
1558 ok(dmtest == NULL,"returned documentmgr should be null\n");
1559
1560 hr = ITfDocumentMgr_GetTop(g_dm, &cxtTest);
1561 ok(SUCCEEDED(hr),"GetTop Failed\n");
1562 ok(cxtTest == cxt, "Wrong context on top\n");
1563 ITfContext_Release(cxtTest);
1564
1565 hr = ITfDocumentMgr_GetBase(g_dm, &cxtTest);
1566 ok(SUCCEEDED(hr),"GetBase Failed\n");
1567 ok(cxtTest == cxt, "Wrong context on base\n");
1568 ITfContext_Release(cxtTest);
1569
1570 hr = ITfDocumentMgr_Pop(g_dm, 0);
1571 ok(FAILED(hr),"Pop Succeeded\n");
1572
1573 hr = ITfDocumentMgr_GetTop(g_dm, &cxtTest);
1574 ok(SUCCEEDED(hr),"GetTop Failed\n");
1575 ok(cxtTest == cxt, "Wrong context on top\n");
1576 ITfContext_Release(cxtTest);
1577
1578 hr = ITfDocumentMgr_GetBase(g_dm, &cxtTest);
1579 ok(SUCCEEDED(hr),"GetBase Failed\n");
1580 ok(cxtTest == cxt, "Wrong context on base\n");
1581 ITfContext_Release(cxtTest);
1582
1583 ITfContext_Release(cxt);
1584 ITfContext_Release(cxt2);
1585 ITfContext_Release(cxt3);
1586 }
1587
1588 static void test_endSession(void)
1589 {
1590 HRESULT hr;
1591 test_ShouldDeactivate = TRUE;
1592 test_CurrentFocus = NULL;
1593 test_PrevFocus = g_dm;
1594 test_OnSetFocus = SINK_OPTIONAL; /* Doesn't fire on Win7 */
1595 hr = ITfThreadMgr_Deactivate(g_tm);
1596 ok(SUCCEEDED(hr),"Failed to Deactivate\n");
1597 sink_check_ok(&test_OnSetFocus,"OnSetFocus");
1598 test_OnSetFocus = SINK_UNEXPECTED;
1599 }
1600
1601 static void test_TfGuidAtom(void)
1602 {
1603 GUID gtest,g1;
1604 HRESULT hr;
1605 TfGuidAtom atom1,atom2;
1606 BOOL equal;
1607
1608 CoCreateGuid(&gtest);
1609
1610 /* msdn reports this should return E_INVALIDARG. However my test show it crashing (winxp)*/
1611 /*
1612 hr = ITfCategoryMgr_RegisterGUID(g_cm,&gtest,NULL);
1613 ok(hr==E_INVALIDARG,"ITfCategoryMgr_RegisterGUID should have failed\n");
1614 */
1615 hr = ITfCategoryMgr_RegisterGUID(g_cm,&gtest,&atom1);
1616 ok(SUCCEEDED(hr),"ITfCategoryMgr_RegisterGUID failed\n");
1617 hr = ITfCategoryMgr_RegisterGUID(g_cm,&gtest,&atom2);
1618 ok(SUCCEEDED(hr),"ITfCategoryMgr_RegisterGUID failed\n");
1619 ok(atom1 == atom2,"atoms do not match\n");
1620 hr = ITfCategoryMgr_GetGUID(g_cm,atom2,NULL);
1621 ok(hr==E_INVALIDARG,"ITfCategoryMgr_GetGUID should have failed\n");
1622 hr = ITfCategoryMgr_GetGUID(g_cm,atom2,&g1);
1623 ok(SUCCEEDED(hr),"ITfCategoryMgr_GetGUID failed\n");
1624 ok(IsEqualGUID(&g1,&gtest),"guids do not match\n");
1625 hr = ITfCategoryMgr_IsEqualTfGuidAtom(g_cm,atom1,&gtest,NULL);
1626 ok(hr==E_INVALIDARG,"ITfCategoryMgr_IsEqualTfGuidAtom should have failed\n");
1627 hr = ITfCategoryMgr_IsEqualTfGuidAtom(g_cm,atom1,&gtest,&equal);
1628 ok(SUCCEEDED(hr),"ITfCategoryMgr_IsEqualTfGuidAtom failed\n");
1629 ok(equal == TRUE,"Equal value invalid\n");
1630
1631 /* show that cid and tid TfClientIds are also TfGuidAtoms */
1632 hr = ITfCategoryMgr_IsEqualTfGuidAtom(g_cm,tid,&CLSID_FakeService,&equal);
1633 ok(SUCCEEDED(hr),"ITfCategoryMgr_IsEqualTfGuidAtom failed\n");
1634 ok(equal == TRUE,"Equal value invalid\n");
1635 hr = ITfCategoryMgr_GetGUID(g_cm,cid,&g1);
1636 ok(SUCCEEDED(hr),"ITfCategoryMgr_GetGUID failed\n");
1637 ok(!IsEqualGUID(&g1,&GUID_NULL),"guid should not be NULL\n");
1638 }
1639
1640 static void test_ClientId(void)
1641 {
1642 ITfClientId *pcid;
1643 TfClientId id1,id2;
1644 HRESULT hr;
1645 GUID g2;
1646
1647 hr = ITfThreadMgr_QueryInterface(g_tm, &IID_ITfClientId, (LPVOID*)&pcid);
1648 ok(SUCCEEDED(hr),"Unable to acquire ITfClientId interface\n");
1649
1650 CoCreateGuid(&g2);
1651
1652 hr = ITfClientId_GetClientId(pcid,&GUID_NULL,&id1);
1653 ok(SUCCEEDED(hr),"GetClientId failed\n");
1654 hr = ITfClientId_GetClientId(pcid,&GUID_NULL,&id2);
1655 ok(SUCCEEDED(hr),"GetClientId failed\n");
1656 ok(id1==id2,"Id's for GUID_NULL do not match\n");
1657 hr = ITfClientId_GetClientId(pcid,&CLSID_FakeService,&id2);
1658 ok(SUCCEEDED(hr),"GetClientId failed\n");
1659 ok(id2!=id1,"Id matches GUID_NULL\n");
1660 ok(id2==tid,"Id for CLSID_FakeService not matching tid\n");
1661 ok(id2!=cid,"Id for CLSID_FakeService matching cid\n");
1662 hr = ITfClientId_GetClientId(pcid,&g2,&id2);
1663 ok(SUCCEEDED(hr),"GetClientId failed\n");
1664 ok(id2!=id1,"Id matches GUID_NULL\n");
1665 ok(id2!=tid,"Id for random guid matching tid\n");
1666 ok(id2!=cid,"Id for random guid matching cid\n");
1667 ITfClientId_Release(pcid);
1668 }
1669
1670 /**********************************************************************
1671 * ITfEditSession
1672 **********************************************************************/
1673 typedef struct tagEditSession
1674 {
1675 ITfEditSession ITfEditSession_iface;
1676 LONG refCount;
1677 } EditSession;
1678
1679 static inline EditSession *impl_from_ITfEditSession(ITfEditSession *iface)
1680 {
1681 return CONTAINING_RECORD(iface, EditSession, ITfEditSession_iface);
1682 }
1683
1684 static void EditSession_Destructor(EditSession *This)
1685 {
1686 HeapFree(GetProcessHeap(),0,This);
1687 }
1688
1689 static HRESULT WINAPI EditSession_QueryInterface(ITfEditSession *iface, REFIID iid, LPVOID *ppvOut)
1690 {
1691 EditSession *This = impl_from_ITfEditSession(iface);
1692 *ppvOut = NULL;
1693
1694 if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITfEditSession))
1695 {
1696 *ppvOut = This;
1697 }
1698
1699 if (*ppvOut)
1700 {
1701 ITfEditSession_AddRef(iface);
1702 return S_OK;
1703 }
1704
1705 return E_NOINTERFACE;
1706 }
1707
1708 static ULONG WINAPI EditSession_AddRef(ITfEditSession *iface)
1709 {
1710 EditSession *This = impl_from_ITfEditSession(iface);
1711 return InterlockedIncrement(&This->refCount);
1712 }
1713
1714 static ULONG WINAPI EditSession_Release(ITfEditSession *iface)
1715 {
1716 EditSession *This = impl_from_ITfEditSession(iface);
1717 ULONG ret;
1718
1719 ret = InterlockedDecrement(&This->refCount);
1720 if (ret == 0)
1721 EditSession_Destructor(This);
1722 return ret;
1723 }
1724
1725 static void test_InsertAtSelection(TfEditCookie ec, ITfContext *cxt)
1726 {
1727 HRESULT hr;
1728 ITfInsertAtSelection *iis;
1729 ITfRange *range=NULL;
1730 static const WCHAR txt[] = {'H','e','l','l','o',' ','W','o','r','l','d',0};
1731
1732 hr = ITfContext_QueryInterface(cxt, &IID_ITfInsertAtSelection , (LPVOID*)&iis);
1733 ok(SUCCEEDED(hr),"Failed to get ITfInsertAtSelection interface\n");
1734 test_ACP_InsertTextAtSelection = SINK_EXPECTED;
1735 hr = ITfInsertAtSelection_InsertTextAtSelection(iis, ec, 0, txt, 11, &range);
1736 ok(SUCCEEDED(hr),"ITfInsertAtSelection_InsertTextAtSelection failed %x\n",hr);
1737 sink_check_ok(&test_ACP_InsertTextAtSelection,"InsertTextAtSelection");
1738 ok(range != NULL,"No range returned\n");
1739 ITfRange_Release(range);
1740 ITfInsertAtSelection_Release(iis);
1741 }
1742
1743 static HRESULT WINAPI EditSession_DoEditSession(ITfEditSession *iface,
1744 TfEditCookie ec)
1745 {
1746 ITfContext *cxt;
1747 ITfDocumentMgr *dm;
1748 ITfRange *range;
1749 TF_SELECTION selection;
1750 ULONG fetched;
1751 HRESULT hr;
1752
1753 sink_fire_ok(&test_DoEditSession,"EditSession_DoEditSession");
1754 sink_check_ok(&test_ACP_RequestLock,"RequestLock");
1755
1756 ITfThreadMgr_GetFocus(g_tm, &dm);
1757 ITfDocumentMgr_GetTop(dm,&cxt);
1758
1759 hr = ITfContext_GetStart(cxt,ec,NULL);
1760 ok(hr == E_INVALIDARG,"Unexpected return code %x\n",hr);
1761
1762 range = (ITfRange*)0xdeaddead;
1763 hr = ITfContext_GetStart(cxt,0xdeadcafe,&range);
1764 ok(hr == TF_E_NOLOCK,"Unexpected return code %x\n",hr);
1765 ok(range == NULL,"Range not set to NULL\n");
1766
1767 hr = ITfContext_GetStart(cxt,ec,&range);
1768 ok(SUCCEEDED(hr),"Unexpected return code %x\n",hr);
1769 ok(range != NULL,"Range set to NULL\n");
1770
1771 ITfRange_Release(range);
1772
1773 hr = ITfContext_GetEnd(cxt,ec,NULL);
1774 ok(hr == E_INVALIDARG,"Unexpected return code %x\n",hr);
1775
1776 range = (ITfRange*)0xdeaddead;
1777 hr = ITfContext_GetEnd(cxt,0xdeadcafe,&range);
1778 ok(hr == TF_E_NOLOCK,"Unexpected return code %x\n",hr);
1779 ok(range == NULL,"Range not set to NULL\n");
1780
1781 test_ACP_GetEndACP = SINK_EXPECTED;
1782 hr = ITfContext_GetEnd(cxt,ec,&range);
1783 ok(SUCCEEDED(hr),"Unexpected return code %x\n",hr);
1784 ok(range != NULL,"Range set to NULL\n");
1785 sink_check_ok(&test_ACP_GetEndACP,"GetEndACP");
1786
1787 ITfRange_Release(range);
1788
1789 selection.range = NULL;
1790 test_ACP_GetSelection = SINK_EXPECTED;
1791 hr = ITfContext_GetSelection(cxt, ec, TF_DEFAULT_SELECTION, 1, &selection, &fetched);
1792 ok(SUCCEEDED(hr),"ITfContext_GetSelection failed\n");
1793 ok(fetched == 1,"fetched incorrect\n");
1794 ok(selection.range != NULL,"NULL range\n");
1795 sink_check_ok(&test_ACP_GetSelection,"ACP_GetSepection");
1796 ITfRange_Release(selection.range);
1797
1798 test_InsertAtSelection(ec, cxt);
1799
1800 test_ACP_GetEndACP = SINK_EXPECTED;
1801 hr = ITfContext_GetEnd(cxt,ec,&range);
1802 ok(SUCCEEDED(hr),"Unexpected return code %x\n",hr);
1803 ok(range != NULL,"Range set to NULL\n");
1804 sink_check_ok(&test_ACP_GetEndACP,"GetEndACP");
1805
1806 selection.range = range;
1807 selection.style.ase = TF_AE_NONE;
1808 selection.style.fInterimChar = FALSE;
1809 test_ACP_SetSelection = SINK_EXPECTED;
1810 hr = ITfContext_SetSelection(cxt, ec, 1, &selection);
1811 ok(SUCCEEDED(hr),"ITfContext_SetSelection failed\n");
1812 sink_check_ok(&test_ACP_SetSelection,"SetSelection");
1813 ITfRange_Release(range);
1814
1815 ITfContext_Release(cxt);
1816 ITfDocumentMgr_Release(dm);
1817 return 0xdeadcafe;
1818 }
1819
1820 static const ITfEditSessionVtbl EditSession_EditSessionVtbl =
1821 {
1822 EditSession_QueryInterface,
1823 EditSession_AddRef,
1824 EditSession_Release,
1825
1826 EditSession_DoEditSession
1827 };
1828
1829 static HRESULT EditSession_Constructor(ITfEditSession **ppOut)
1830 {
1831 EditSession *This;
1832
1833 *ppOut = NULL;
1834 This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(EditSession));
1835 if (This == NULL)
1836 return E_OUTOFMEMORY;
1837
1838 This->ITfEditSession_iface.lpVtbl = &EditSession_EditSessionVtbl;
1839 This->refCount = 1;
1840
1841 *ppOut = &This->ITfEditSession_iface;
1842 return S_OK;
1843 }
1844
1845 static void test_TStoApplicationText(void)
1846 {
1847 HRESULT hr, hrSession;
1848 ITfEditSession *es;
1849 ITfContext *cxt;
1850 ITfDocumentMgr *dm;
1851 ITfTextEditSink *sink;
1852 ITfSource *source = NULL;
1853 DWORD editSinkCookie = -1;
1854
1855 ITfThreadMgr_GetFocus(g_tm, &dm);
1856 EditSession_Constructor(&es);
1857 ITfDocumentMgr_GetTop(dm,&cxt);
1858
1859 TextEditSink_Constructor(&sink);
1860 hr = ITfContext_QueryInterface(cxt,&IID_ITfSource,(LPVOID*)&source);
1861 ok(SUCCEEDED(hr),"Failed to get IID_ITfSource for Context\n");
1862 if (source)
1863 {
1864 hr = ITfSource_AdviseSink(source, &IID_ITfTextEditSink, (LPVOID)sink, &editSinkCookie);
1865 ok(SUCCEEDED(hr),"Failed to advise Sink\n");
1866 ok(editSinkCookie != -1,"Failed to get sink cookie\n");
1867 }
1868
1869 hrSession = 0xfeedface;
1870 /* Test no permissions flags */
1871 hr = ITfContext_RequestEditSession(cxt, tid, es, TF_ES_SYNC, &hrSession);
1872 ok(hr == E_INVALIDARG,"RequestEditSession should have failed with %x not %x\n",E_INVALIDARG,hr);
1873 ok(hrSession == E_FAIL,"hrSession should be %x not %x\n",E_FAIL,hrSession);
1874
1875 documentStatus = TS_SD_READONLY;
1876 hrSession = 0xfeedface;
1877 test_ACP_GetStatus = SINK_EXPECTED;
1878 hr = ITfContext_RequestEditSession(cxt, tid, es, TF_ES_SYNC|TF_ES_READWRITE, &hrSession);
1879 ok(SUCCEEDED(hr),"ITfContext_RequestEditSession failed\n");
1880 ok(hrSession == TS_E_READONLY,"Unexpected hrSession (%x)\n",hrSession);
1881 sink_check_ok(&test_ACP_GetStatus,"GetStatus");
1882
1883 /* signal a change to allow readwrite sessions */
1884 documentStatus = 0;
1885 test_ACP_RequestLock = SINK_EXPECTED;
1886 ITextStoreACPSink_OnStatusChange(ACPSink,documentStatus);
1887 sink_check_ok(&test_ACP_RequestLock,"RequestLock");
1888
1889 test_ACP_GetStatus = SINK_EXPECTED;
1890 test_ACP_RequestLock = SINK_EXPECTED;
1891 test_DoEditSession = SINK_EXPECTED;
1892 hrSession = 0xfeedface;
1893 test_OnEndEdit = SINK_EXPECTED;
1894 hr = ITfContext_RequestEditSession(cxt, tid, es, TF_ES_SYNC|TF_ES_READWRITE, &hrSession);
1895 ok(SUCCEEDED(hr),"ITfContext_RequestEditSession failed\n");
1896 sink_check_ok(&test_OnEndEdit,"OnEndEdit");
1897 sink_check_ok(&test_DoEditSession,"DoEditSession");
1898 sink_check_ok(&test_ACP_GetStatus,"GetStatus");
1899 ok(hrSession == 0xdeadcafe,"Unexpected hrSession (%x)\n",hrSession);
1900
1901 if (source)
1902 {
1903 hr = ITfSource_UnadviseSink(source, editSinkCookie);
1904 ok(SUCCEEDED(hr),"Failed to unadvise Sink\n");
1905 ITfSource_Release(source);
1906 }
1907 ITfTextEditSink_Release(sink);
1908 ITfContext_Release(cxt);
1909 ITfDocumentMgr_Release(dm);
1910 ITfEditSession_Release(es);
1911 }
1912
1913 static void enum_compartments(ITfCompartmentMgr *cmpmgr, REFGUID present, REFGUID absent)
1914 {
1915 BOOL found,found2;
1916 IEnumGUID *ppEnum;
1917 found = FALSE;
1918 found2 = FALSE;
1919 if (SUCCEEDED(ITfCompartmentMgr_EnumCompartments(cmpmgr, &ppEnum)))
1920 {
1921 ULONG fetched;
1922 GUID g;
1923 while (IEnumGUID_Next(ppEnum, 1, &g, &fetched) == S_OK)
1924 {
1925 WCHAR str[50];
1926 CHAR strA[50];
1927 StringFromGUID2(&g,str,sizeof(str)/sizeof(str[0]));
1928 WideCharToMultiByte(CP_ACP,0,str,-1,strA,sizeof(strA),0,0);
1929 trace("found %s\n",strA);
1930 if (present && IsEqualGUID(present,&g))
1931 found = TRUE;
1932 if (absent && IsEqualGUID(absent, &g))
1933 found2 = TRUE;
1934 }
1935 IEnumGUID_Release(ppEnum);
1936 }
1937 if (present)
1938 ok(found,"Did not find compartment\n");
1939 if (absent)
1940 ok(!found2,"Found compartment that should be absent\n");
1941 }
1942
1943 static void test_Compartments(void)
1944 {
1945 ITfContext *cxt;
1946 ITfDocumentMgr *dm;
1947 ITfCompartmentMgr *cmpmgr;
1948 ITfCompartment *cmp;
1949 HRESULT hr;
1950
1951 ITfThreadMgr_GetFocus(g_tm, &dm);
1952 ITfDocumentMgr_GetTop(dm,&cxt);
1953
1954 /* Global */
1955 hr = ITfThreadMgr_GetGlobalCompartment(g_tm, &cmpmgr);
1956 ok(SUCCEEDED(hr),"GetGlobalCompartment failed\n");
1957 hr = ITfCompartmentMgr_GetCompartment(cmpmgr, &GUID_COMPARTMENT_SPEECH_OPENCLOSE, &cmp);
1958 ok(SUCCEEDED(hr),"GetCompartment failed\n");
1959 ITfCompartment_Release(cmp);
1960 enum_compartments(cmpmgr,&GUID_COMPARTMENT_SPEECH_OPENCLOSE,NULL);
1961 ITfCompartmentMgr_Release(cmpmgr);
1962
1963 /* Thread */
1964 hr = ITfThreadMgr_QueryInterface(g_tm, &IID_ITfCompartmentMgr, (LPVOID*)&cmpmgr);
1965 ok(SUCCEEDED(hr),"ThreadMgr QI for IID_ITfCompartmentMgr failed\n");
1966 hr = ITfCompartmentMgr_GetCompartment(cmpmgr, &CLSID_FakeService, &cmp);
1967 ok(SUCCEEDED(hr),"GetCompartment failed\n");
1968 enum_compartments(cmpmgr,&CLSID_FakeService,&GUID_COMPARTMENT_SPEECH_OPENCLOSE);
1969 ITfCompartmentMgr_ClearCompartment(cmpmgr,tid,&CLSID_FakeService);
1970 enum_compartments(cmpmgr,NULL,&CLSID_FakeService);
1971 ITfCompartmentMgr_Release(cmpmgr);
1972 ITfCompartment_Release(cmp);
1973
1974 /* DocumentMgr */
1975 hr = ITfDocumentMgr_QueryInterface(dm, &IID_ITfCompartmentMgr, (LPVOID*)&cmpmgr);
1976 ok(SUCCEEDED(hr),"DocumentMgr QI for IID_ITfCompartmentMgr failed\n");
1977
1978 hr = ITfCompartmentMgr_GetCompartment(cmpmgr, &GUID_COMPARTMENT_PERSISTMENUENABLED, &cmp);
1979 ok(SUCCEEDED(hr),"GetCompartment failed\n");
1980 enum_compartments(cmpmgr,&GUID_COMPARTMENT_PERSISTMENUENABLED,&GUID_COMPARTMENT_SPEECH_OPENCLOSE);
1981 ITfCompartmentMgr_Release(cmpmgr);
1982
1983 /* Context */
1984 hr = ITfContext_QueryInterface(cxt, &IID_ITfCompartmentMgr, (LPVOID*)&cmpmgr);
1985 ok(SUCCEEDED(hr),"Context QI for IID_ITfCompartmentMgr failed\n");
1986 enum_compartments(cmpmgr,NULL,&GUID_COMPARTMENT_PERSISTMENUENABLED);
1987 ITfCompartmentMgr_Release(cmpmgr);
1988
1989 ITfContext_Release(cxt);
1990 ITfDocumentMgr_Release(dm);
1991 }
1992
1993 static void processPendingMessages(void)
1994 {
1995 MSG msg;
1996 int diff = 200;
1997 int min_timeout = 100;
1998 DWORD time = GetTickCount() + diff;
1999
2000 while (diff > 0)
2001 {
2002 if (MsgWaitForMultipleObjects(0, NULL, FALSE, min_timeout, QS_ALLINPUT) == WAIT_TIMEOUT)
2003 break;
2004 while (PeekMessageW(&msg, 0, 0, 0, PM_REMOVE))
2005 {
2006 TranslateMessage(&msg);
2007 DispatchMessageW(&msg);
2008 }
2009 diff = time - GetTickCount();
2010 }
2011 }
2012
2013 static void test_AssociateFocus(void)
2014 {
2015 ITfDocumentMgr *dm1, *dm2, *olddm, *dmcheck, *dmorig;
2016 HWND wnd1, wnd2, wnd3;
2017 HRESULT hr;
2018
2019 ITfThreadMgr_GetFocus(g_tm, &dmorig);
2020 test_CurrentFocus = NULL;
2021 test_PrevFocus = dmorig;
2022 test_OnSetFocus = SINK_OPTIONAL; /* Doesn't always fire on Win7 */
2023 test_ACP_GetStatus = SINK_OPTIONAL;
2024 hr = ITfThreadMgr_SetFocus(g_tm,NULL);
2025 ok(SUCCEEDED(hr),"ITfThreadMgr_SetFocus failed\n");
2026 sink_check_ok(&test_OnSetFocus,"OnSetFocus");
2027 test_ACP_GetStatus = SINK_UNEXPECTED;
2028 ITfDocumentMgr_Release(dmorig);
2029
2030 hr = ITfThreadMgr_CreateDocumentMgr(g_tm,&dm1);
2031 ok(SUCCEEDED(hr),"CreateDocumentMgr failed\n");
2032
2033 hr = ITfThreadMgr_CreateDocumentMgr(g_tm,&dm2);
2034 ok(SUCCEEDED(hr),"CreateDocumentMgr failed\n");
2035
2036 wnd1 = CreateWindowA("edit",NULL,WS_POPUP,0,0,200,60,NULL,NULL,NULL,NULL);
2037 ok(wnd1!=NULL,"Unable to create window 1\n");
2038 wnd2 = CreateWindowA("edit",NULL,WS_POPUP,0,65,200,60,NULL,NULL,NULL,NULL);
2039 ok(wnd2!=NULL,"Unable to create window 2\n");
2040 wnd3 = CreateWindowA("edit",NULL,WS_POPUP,0,130,200,60,NULL,NULL,NULL,NULL);
2041 ok(wnd3!=NULL,"Unable to create window 3\n");
2042
2043 processPendingMessages();
2044
2045 test_OnInitDocumentMgr = SINK_OPTIONAL; /* Vista and greater */
2046 test_OnPushContext = SINK_OPTIONAL; /* Vista and greater */
2047 test_OnSetFocus = SINK_OPTIONAL; /* Win7 */
2048 test_PrevFocus = NULL;
2049 test_CurrentFocus = FOCUS_IGNORE;
2050
2051 ShowWindow(wnd1,SW_SHOWNORMAL);
2052 test_OnSetFocus = SINK_UNEXPECTED;
2053 SetFocus(wnd1);
2054 sink_check_ok(&test_OnInitDocumentMgr,"OnInitDocumentMgr");
2055 sink_check_ok(&test_OnPushContext,"OnPushContext");
2056
2057 test_OnSetFocus = SINK_OPTIONAL; /* Vista and greater */
2058 test_ACP_RequestLock = SINK_OPTIONAL; /* Win7 x64 */
2059 test_ACP_GetSelection = SINK_OPTIONAL; /* Win7 x64 */
2060 ITfThreadMgr_GetFocus(g_tm, &test_PrevFocus);
2061 test_CurrentFocus = FOCUS_IGNORE; /* This is a default system context */
2062 processPendingMessages();
2063 sink_check_ok(&test_OnSetFocus,"OnSetFocus");
2064 test_ACP_RequestLock = SINK_UNEXPECTED;
2065 test_ACP_GetSelection = SINK_UNEXPECTED;
2066
2067 test_CurrentFocus = dm1;
2068 test_PrevFocus = FOCUS_IGNORE;
2069 test_OnSetFocus = SINK_OPTIONAL;
2070 test_ShouldDeactivate = SINK_OPTIONAL;
2071 hr = ITfThreadMgr_AssociateFocus(g_tm,wnd1,dm1,&olddm);
2072 ok(SUCCEEDED(hr),"AssociateFocus failed\n");
2073 sink_check_ok(&test_OnSetFocus,"OnSetFocus");
2074 test_ShouldDeactivate = SINK_UNEXPECTED;
2075
2076 processPendingMessages();
2077
2078 ITfThreadMgr_GetFocus(g_tm, &dmcheck);
2079 ok(dmcheck == dm1 || broken(dmcheck == dmorig /* Win7+ */), "Expected DocumentMgr not focused\n");
2080 ITfDocumentMgr_Release(dmcheck);
2081
2082 /* We need to explicitly set focus on Win7+ */
2083 test_CurrentFocus = dm1;
2084 test_PrevFocus = FOCUS_IGNORE;
2085 test_OnSetFocus = SINK_OPTIONAL; /* Doesn't always fire on Win7+ */
2086 ITfThreadMgr_SetFocus(g_tm, dm1);
2087 sink_check_ok(&test_OnSetFocus, "OnSetFocus");
2088
2089 hr = ITfThreadMgr_AssociateFocus(g_tm,wnd2,dm2,&olddm);
2090 ok(SUCCEEDED(hr),"AssociateFocus failed\n");
2091 processPendingMessages();
2092 ITfThreadMgr_GetFocus(g_tm, &dmcheck);
2093 ok(dmcheck == dm1, "Expected DocumentMgr not focused\n");
2094 ITfDocumentMgr_Release(dmcheck);
2095
2096 hr = ITfThreadMgr_AssociateFocus(g_tm,wnd3,dm2,&olddm);
2097 ok(SUCCEEDED(hr),"AssociateFocus failed\n");
2098 processPendingMessages();
2099 ITfThreadMgr_GetFocus(g_tm, &dmcheck);
2100 ok(dmcheck == dm1, "Expected DocumentMgr not focused\n");
2101 ITfDocumentMgr_Release(dmcheck);
2102
2103 test_CurrentFocus = FOCUS_SAVE;
2104 test_PrevFocus = FOCUS_SAVE;
2105 test_OnSetFocus = SINK_SAVE;
2106 ShowWindow(wnd2,SW_SHOWNORMAL);
2107 SetFocus(wnd2);
2108 sink_check_saved(&test_OnSetFocus,dm1,dm2,"OnSetFocus");
2109 test_CurrentFocus = FOCUS_IGNORE; /* occasional wine race */
2110 test_PrevFocus = FOCUS_IGNORE; /* occasional wine race */
2111 test_OnSetFocus = SINK_IGNORE; /* occasional wine race */
2112 processPendingMessages();
2113
2114 ShowWindow(wnd3,SW_SHOWNORMAL);
2115 SetFocus(wnd3);
2116 processPendingMessages();
2117
2118 test_CurrentFocus = FOCUS_SAVE;
2119 test_PrevFocus = FOCUS_SAVE;
2120 test_OnSetFocus = SINK_SAVE;
2121 SetFocus(wnd1);
2122 processPendingMessages();
2123 sink_check_saved(&test_OnSetFocus,dm2,dm1,"OnSetFocus");
2124
2125 hr = ITfThreadMgr_AssociateFocus(g_tm,wnd3,NULL,&olddm);
2126 ok(SUCCEEDED(hr),"AssociateFocus failed\n");
2127 ok(olddm == dm2, "incorrect old DocumentMgr returned\n");
2128 ITfDocumentMgr_Release(olddm);
2129
2130 test_CurrentFocus = dmorig;
2131 test_PrevFocus = dm1;
2132 test_OnSetFocus = SINK_OPTIONAL; /* Doesn't always fire on Win7+ */
2133 test_ACP_GetStatus = SINK_IGNORE;
2134 ITfThreadMgr_SetFocus(g_tm,dmorig);
2135 sink_check_ok(&test_OnSetFocus,"OnSetFocus");
2136
2137 test_CurrentFocus = FOCUS_SAVE;
2138 test_PrevFocus = FOCUS_SAVE;
2139 test_OnSetFocus = SINK_SAVE;
2140 SetFocus(wnd3);
2141 processPendingMessages();
2142 sink_check_saved(&test_OnSetFocus,dmorig,FOCUS_IGNORE,"OnSetFocus"); /* CurrentFocus NULL on XP, system default on Vista */
2143
2144 hr = ITfThreadMgr_AssociateFocus(g_tm,wnd2,NULL,&olddm);
2145 ok(SUCCEEDED(hr),"AssociateFocus failed\n");
2146 ok(olddm == dm2, "incorrect old DocumentMgr returned\n");
2147 ITfDocumentMgr_Release(olddm);
2148 hr = ITfThreadMgr_AssociateFocus(g_tm,wnd1,NULL,&olddm);
2149 ok(SUCCEEDED(hr),"AssociateFocus failed\n");
2150 ok(olddm == dm1, "incorrect old DocumentMgr returned\n");
2151 ITfDocumentMgr_Release(olddm);
2152
2153 test_OnSetFocus = SINK_IGNORE; /* OnSetFocus fires a couple of times on Win7 */
2154 test_CurrentFocus = FOCUS_IGNORE;
2155 test_PrevFocus = FOCUS_IGNORE;
2156 SetFocus(wnd2);
2157 processPendingMessages();
2158 SetFocus(wnd1);
2159 processPendingMessages();
2160 test_OnSetFocus = SINK_UNEXPECTED;
2161
2162 ITfDocumentMgr_Release(dm1);
2163 ITfDocumentMgr_Release(dm2);
2164
2165 test_CurrentFocus = dmorig;
2166 test_PrevFocus = FOCUS_IGNORE;
2167 test_OnSetFocus = SINK_OPTIONAL;
2168 test_ACP_GetStatus = SINK_IGNORE;
2169 ITfThreadMgr_SetFocus(g_tm,dmorig);
2170 sink_check_ok(&test_OnSetFocus,"OnSetFocus");
2171
2172 test_OnSetFocus = SINK_IGNORE; /* OnSetFocus fires a couple of times on Win7 */
2173 test_CurrentFocus = FOCUS_IGNORE;
2174 test_PrevFocus = FOCUS_IGNORE;
2175 DestroyWindow(wnd1);
2176 DestroyWindow(wnd2);
2177 test_OnSetFocus = SINK_UNEXPECTED;
2178 test_OnPopContext = SINK_OPTIONAL; /* Vista and greater */
2179 test_OnSetFocus = SINK_OPTIONAL; /* Vista and greater */
2180 ITfThreadMgr_GetFocus(g_tm, &test_PrevFocus);
2181 test_CurrentFocus = NULL;
2182 test_ShouldDeactivate = TRUE; /* Win7 */
2183 DestroyWindow(wnd3);
2184 test_ShouldDeactivate = FALSE;
2185 sink_check_ok(&test_OnSetFocus,"OnSetFocus");
2186 sink_check_ok(&test_OnPopContext,"OnPopContext");
2187 }
2188
2189 static void test_profile_mgr(void)
2190 {
2191 IEnumTfInputProcessorProfiles *enum_profiles;
2192 ITfInputProcessorProfileMgr *ipp_mgr;
2193 HRESULT hres;
2194
2195 hres = ITfInputProcessorProfiles_QueryInterface(g_ipp, &IID_ITfInputProcessorProfileMgr, (void**)&ipp_mgr);
2196 if (hres != S_OK)
2197 {
2198 win_skip("ITfInputProcessorProfileMgr is not supported.\n");
2199 return;
2200 }
2201 ok(hres == S_OK, "Could not get ITfInputProcessorProfileMgr iface: %08x\n", hres);
2202
2203 hres = ITfInputProcessorProfileMgr_EnumProfiles(ipp_mgr, 0, &enum_profiles);
2204 ok(hres == S_OK, "EnumProfiles failed: %08x\n", hres);
2205
2206 IEnumTfInputProcessorProfiles_Release(enum_profiles);
2207
2208 ITfInputProcessorProfileMgr_Release(ipp_mgr);
2209 }
2210
2211 START_TEST(inputprocessor)
2212 {
2213 if (SUCCEEDED(initialize()))
2214 {
2215 test_Register();
2216 test_RegisterCategory();
2217 Sleep(2000); /* Win7 needs some time before the registrations become active */
2218 processPendingMessages();
2219 test_EnumLanguageProfiles();
2220 test_EnumInputProcessorInfo();
2221 test_Enable();
2222 test_ThreadMgrAdviseSinks();
2223 test_Activate();
2224 test_startSession();
2225 test_TfGuidAtom();
2226 test_ClientId();
2227 test_KeystrokeMgr();
2228 test_TStoApplicationText();
2229 test_Compartments();
2230 test_AssociateFocus();
2231 test_endSession();
2232 test_FindClosestCategory();
2233 test_Disable();
2234 test_ThreadMgrUnadviseSinks();
2235 test_UnregisterCategory();
2236 test_Unregister();
2237 test_profile_mgr();
2238 }
2239 else
2240 skip("Unable to create InputProcessor\n");
2241 cleanup();
2242 }