?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dmband: Rewrite band lbin list parsing.
[wine.git] / dlls / uiautomationcore / uia_provider.c
blobb16077b607c9b300b51198dccc5ad898948c68e0
1 /*
2 * Copyright 2022 Connor McAdams for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include "uia_private.h"
20 #include "ocidl.h"
21
22 #include "wine/debug.h"
23 #include "initguid.h"
24 #include "wine/iaccessible2.h"
25
26 WINE_DEFAULT_DEBUG_CHANNEL(uiautomation);
27
28 DEFINE_GUID(SID_AccFromDAWrapper, 0x33f139ee, 0xe509, 0x47f7, 0xbf,0x39, 0x83,0x76,0x44,0xf7,0x45,0x76);
29
30 static BOOL msaa_check_acc_state(IAccessible *acc, VARIANT cid, ULONG flag)
31 {
32 HRESULT hr;
33 VARIANT v;
34
35 VariantInit(&v);
36 hr = IAccessible_get_accState(acc, cid, &v);
37 if (SUCCEEDED(hr) && V_VT(&v) == VT_I4 && (V_I4(&v) & flag))
38 return TRUE;
39
40 return FALSE;
41 }
42
43 static IAccessible2 *msaa_acc_get_ia2(IAccessible *acc)
44 {
45 IServiceProvider *serv_prov;
46 IAccessible2 *ia2 = NULL;
47 HRESULT hr;
48
49 hr = IAccessible_QueryInterface(acc, &IID_IServiceProvider, (void **)&serv_prov);
50 if (SUCCEEDED(hr))
51 {
52 hr = IServiceProvider_QueryService(serv_prov, &IID_IAccessible2, &IID_IAccessible2, (void **)&ia2);
53 IServiceProvider_Release(serv_prov);
54 if (SUCCEEDED(hr) && ia2)
55 return ia2;
56 }
57
58 hr = IAccessible_QueryInterface(acc, &IID_IAccessible2, (void **)&ia2);
59 if (SUCCEEDED(hr) && ia2)
60 return ia2;
61
62 return NULL;
63 }
64
65 static IAccessible *msaa_acc_da_unwrap(IAccessible *acc)
66 {
67 IServiceProvider *sp;
68 IAccessible *acc2;
69 HRESULT hr;
70
71 hr = IAccessible_QueryInterface(acc, &IID_IServiceProvider, (void**)&sp);
72 if (SUCCEEDED(hr))
73 {
74 hr = IServiceProvider_QueryService(sp, &SID_AccFromDAWrapper, &IID_IAccessible, (void**)&acc2);
75 IServiceProvider_Release(sp);
76 }
77
78 if (SUCCEEDED(hr) && acc2)
79 return acc2;
80
81 IAccessible_AddRef(acc);
82 return acc;
83 }
84
85 /*
86 * Compare role, state, child count, and location properties of the two
87 * IAccessibles. If all four are successfully retrieved and are equal, this is
88 * considered a match.
89 */
90 static HRESULT msaa_acc_prop_match(IAccessible *acc, IAccessible *acc2)
91 {
92 BOOL role_match, state_match, child_count_match, location_match;
93 LONG child_count[2], left[2], top[2], width[2], height[2];
94 VARIANT cid, v, v2;
95 HRESULT hr, hr2;
96
97 role_match = state_match = child_count_match = location_match = FALSE;
98 variant_init_i4(&cid, CHILDID_SELF);
99 hr = IAccessible_get_accRole(acc, cid, &v);
100 if (SUCCEEDED(hr) && (V_VT(&v) == VT_I4))
101 {
102 VariantInit(&v2);
103 hr = IAccessible_get_accRole(acc2, cid, &v2);
104 if (SUCCEEDED(hr) && (V_VT(&v2) == VT_I4))
105 {
106 if (V_I4(&v) != V_I4(&v2))
107 return E_FAIL;
108
109 role_match = TRUE;
110 }
111 }
112
113 VariantInit(&v);
114 hr = IAccessible_get_accState(acc, cid, &v);
115 if (SUCCEEDED(hr) && (V_VT(&v) == VT_I4))
116 {
117 VariantInit(&v2);
118 hr = IAccessible_get_accState(acc2, cid, &v2);
119 if (SUCCEEDED(hr) && (V_VT(&v2) == VT_I4))
120 {
121 if (V_I4(&v) != V_I4(&v2))
122 return E_FAIL;
123
124 state_match = TRUE;
125 }
126 }
127
128 hr = IAccessible_get_accChildCount(acc, &child_count[0]);
129 hr2 = IAccessible_get_accChildCount(acc2, &child_count[1]);
130 if (SUCCEEDED(hr) && SUCCEEDED(hr2))
131 {
132 if (child_count[0] != child_count[1])
133 return E_FAIL;
134
135 child_count_match = TRUE;
136 }
137
138 hr = IAccessible_accLocation(acc, &left[0], &top[0], &width[0], &height[0], cid);
139 if (SUCCEEDED(hr))
140 {
141 hr = IAccessible_accLocation(acc2, &left[1], &top[1], &width[1], &height[1], cid);
142 if (SUCCEEDED(hr))
143 {
144 if ((left[0] != left[1]) || (top[0] != top[1]) || (width[0] != width[1]) ||
145 (height[0] != height[1]))
146 return E_FAIL;
147
148 location_match = TRUE;
149 }
150 }
151
152 if (role_match && state_match && child_count_match && location_match)
153 return S_OK;
154
155 return S_FALSE;
156 }
157
158 static BOOL msaa_acc_compare(IAccessible *acc, IAccessible *acc2)
159 {
160 IAccessible2 *ia2[2] = { NULL, NULL };
161 IUnknown *unk, *unk2;
162 BOOL matched = FALSE;
163 LONG unique_id[2];
164 BSTR name[2];
165 VARIANT cid;
166 HRESULT hr;
167
168 acc = msaa_acc_da_unwrap(acc);
169 acc2 = msaa_acc_da_unwrap(acc2);
170 IAccessible_QueryInterface(acc, &IID_IUnknown, (void**)&unk);
171 IAccessible_QueryInterface(acc2, &IID_IUnknown, (void**)&unk2);
172 if (unk == unk2)
173 {
174 matched = TRUE;
175 goto exit;
176 }
177
178 ia2[0] = msaa_acc_get_ia2(acc);
179 ia2[1] = msaa_acc_get_ia2(acc2);
180 if (!ia2[0] != !ia2[1])
181 goto exit;
182 if (ia2[0])
183 {
184 hr = IAccessible2_get_uniqueID(ia2[0], &unique_id[0]);
185 if (SUCCEEDED(hr))
186 {
187 hr = IAccessible2_get_uniqueID(ia2[1], &unique_id[1]);
188 if (SUCCEEDED(hr))
189 {
190 if (unique_id[0] == unique_id[1])
191 matched = TRUE;
192
193 goto exit;
194 }
195 }
196 }
197
198 hr = msaa_acc_prop_match(acc, acc2);
199 if (FAILED(hr))
200 goto exit;
201 if (hr == S_OK)
202 matched = TRUE;
203
204 variant_init_i4(&cid, CHILDID_SELF);
205 hr = IAccessible_get_accName(acc, cid, &name[0]);
206 if (SUCCEEDED(hr))
207 {
208 hr = IAccessible_get_accName(acc2, cid, &name[1]);
209 if (SUCCEEDED(hr))
210 {
211 if (!name[0] && !name[1])
212 matched = TRUE;
213 else if (!name[0] || !name[1])
214 matched = FALSE;
215 else
216 {
217 if (!wcscmp(name[0], name[1]))
218 matched = TRUE;
219 else
220 matched = FALSE;
221 }
222
223 SysFreeString(name[1]);
224 }
225
226 SysFreeString(name[0]);
227 }
228
229 exit:
230 IUnknown_Release(unk);
231 IUnknown_Release(unk2);
232 IAccessible_Release(acc);
233 IAccessible_Release(acc2);
234 if (ia2[0])
235 IAccessible2_Release(ia2[0]);
236 if (ia2[1])
237 IAccessible2_Release(ia2[1]);
238
239 return matched;
240 }
241
242 static HRESULT msaa_acc_get_parent(IAccessible *acc, IAccessible **parent)
243 {
244 IDispatch *disp = NULL;
245 HRESULT hr;
246
247 *parent = NULL;
248 hr = IAccessible_get_accParent(acc, &disp);
249 if (FAILED(hr) || !disp)
250 return hr;
251
252 hr = IDispatch_QueryInterface(disp, &IID_IAccessible, (void**)parent);
253 IDispatch_Release(disp);
254 return hr;
255 }
256
257 #define DIR_FORWARD 0
258 #define DIR_REVERSE 1
259 static HRESULT msaa_acc_get_next_child(IAccessible *acc, LONG start_pos, LONG direction,
260 IAccessible **child, LONG *child_id, LONG *child_pos, BOOL check_visible)
261 {
262 LONG child_count, cur_pos;
263 IDispatch *disp;
264 VARIANT cid;
265 HRESULT hr;
266
267 *child = NULL;
268 *child_id = 0;
269 cur_pos = start_pos;
270 while (1)
271 {
272 hr = IAccessible_get_accChildCount(acc, &child_count);
273 if (FAILED(hr) || (cur_pos > child_count))
274 break;
275
276 variant_init_i4(&cid, cur_pos);
277 hr = IAccessible_get_accChild(acc, cid, &disp);
278 if (FAILED(hr))
279 break;
280
281 if (hr == S_FALSE)
282 {
283 if (!check_visible || !msaa_check_acc_state(acc, cid, STATE_SYSTEM_INVISIBLE))
284 {
285 *child = acc;
286 *child_id = *child_pos = cur_pos;
287 IAccessible_AddRef(acc);
288 return S_OK;
289 }
290 }
291 else
292 {
293 IAccessible *acc_child = NULL;
294
295 hr = IDispatch_QueryInterface(disp, &IID_IAccessible, (void **)&acc_child);
296 IDispatch_Release(disp);
297 if (FAILED(hr))
298 break;
299
300 variant_init_i4(&cid, CHILDID_SELF);
301 if (!check_visible || !msaa_check_acc_state(acc_child, cid, STATE_SYSTEM_INVISIBLE))
302 {
303 *child = acc_child;
304 *child_id = CHILDID_SELF;
305 *child_pos = cur_pos;
306 return S_OK;
307 }
308
309 IAccessible_Release(acc_child);
310 }
311
312 if (direction == DIR_FORWARD)
313 cur_pos++;
314 else
315 cur_pos--;
316
317 if ((cur_pos > child_count) || (cur_pos <= 0))
318 break;
319 }
320
321 return hr;
322 }
323
324 static HRESULT msaa_acc_get_child_pos(IAccessible *acc, IAccessible **out_parent,
325 LONG *out_child_pos)
326 {
327 LONG child_count, child_id, child_pos, match_pos;
328 IAccessible *child, *parent, *match, **children;
329 HRESULT hr;
330 int i;
331
332 *out_parent = NULL;
333 *out_child_pos = 0;
334 hr = msaa_acc_get_parent(acc, &parent);
335 if (FAILED(hr) || !parent)
336 return hr;
337
338 hr = IAccessible_get_accChildCount(parent, &child_count);
339 if (FAILED(hr) || !child_count)
340 {
341 IAccessible_Release(parent);
342 return hr;
343 }
344
345 children = calloc(child_count, sizeof(*children));
346 if (!children)
347 return E_OUTOFMEMORY;
348
349 match = NULL;
350 for (i = 0; i < child_count; i++)
351 {
352 hr = msaa_acc_get_next_child(parent, i + 1, DIR_FORWARD, &child, &child_id, &child_pos, FALSE);
353 if (FAILED(hr) || !child)
354 goto exit;
355
356 if (child != parent)
357 children[i] = child;
358 else
359 IAccessible_Release(child);
360 }
361
362 for (i = 0; i < child_count; i++)
363 {
364 if (!children[i])
365 continue;
366
367 if (msaa_acc_compare(acc, children[i]))
368 {
369 if (!match)
370 {
371 match = children[i];
372 match_pos = i + 1;
373 }
374 /* Can't have more than one IAccessible match. */
375 else
376 {
377 match = NULL;
378 match_pos = 0;
379 break;
380 }
381 }
382 }
383
384 exit:
385 if (match)
386 {
387 *out_parent = parent;
388 *out_child_pos = match_pos;
389 }
390 else
391 IAccessible_Release(parent);
392
393 for (i = 0; i < child_count; i++)
394 {
395 if (children[i])
396 IAccessible_Release(children[i]);
397 }
398
399 free(children);
400
401 return hr;
402 }
403
404 static LONG msaa_role_to_uia_control_type(LONG role)
405 {
406 switch (role)
407 {
408 case ROLE_SYSTEM_TITLEBAR: return UIA_TitleBarControlTypeId;
409 case ROLE_SYSTEM_MENUBAR: return UIA_MenuBarControlTypeId;
410 case ROLE_SYSTEM_SCROLLBAR: return UIA_ScrollBarControlTypeId;
411 case ROLE_SYSTEM_INDICATOR:
412 case ROLE_SYSTEM_GRIP: return UIA_ThumbControlTypeId;
413 case ROLE_SYSTEM_APPLICATION:
414 case ROLE_SYSTEM_WINDOW: return UIA_WindowControlTypeId;
415 case ROLE_SYSTEM_MENUPOPUP: return UIA_MenuControlTypeId;
416 case ROLE_SYSTEM_TOOLTIP: return UIA_ToolTipControlTypeId;
417 case ROLE_SYSTEM_DOCUMENT: return UIA_DocumentControlTypeId;
418 case ROLE_SYSTEM_PANE: return UIA_PaneControlTypeId;
419 case ROLE_SYSTEM_GROUPING: return UIA_GroupControlTypeId;
420 case ROLE_SYSTEM_SEPARATOR: return UIA_SeparatorControlTypeId;
421 case ROLE_SYSTEM_TOOLBAR: return UIA_ToolBarControlTypeId;
422 case ROLE_SYSTEM_STATUSBAR: return UIA_StatusBarControlTypeId;
423 case ROLE_SYSTEM_TABLE: return UIA_TableControlTypeId;
424 case ROLE_SYSTEM_COLUMNHEADER:
425 case ROLE_SYSTEM_ROWHEADER: return UIA_HeaderControlTypeId;
426 case ROLE_SYSTEM_CELL: return UIA_DataItemControlTypeId;
427 case ROLE_SYSTEM_LINK: return UIA_HyperlinkControlTypeId;
428 case ROLE_SYSTEM_LIST: return UIA_ListControlTypeId;
429 case ROLE_SYSTEM_LISTITEM: return UIA_ListItemControlTypeId;
430 case ROLE_SYSTEM_OUTLINE: return UIA_TreeControlTypeId;
431 case ROLE_SYSTEM_OUTLINEITEM: return UIA_TreeItemControlTypeId;
432 case ROLE_SYSTEM_PAGETAB: return UIA_TabItemControlTypeId;
433 case ROLE_SYSTEM_GRAPHIC: return UIA_ImageControlTypeId;
434 case ROLE_SYSTEM_STATICTEXT: return UIA_TextControlTypeId;
435 case ROLE_SYSTEM_TEXT: return UIA_EditControlTypeId;
436 case ROLE_SYSTEM_CLOCK:
437 case ROLE_SYSTEM_BUTTONDROPDOWNGRID:
438 case ROLE_SYSTEM_PUSHBUTTON: return UIA_ButtonControlTypeId;
439 case ROLE_SYSTEM_CHECKBUTTON: return UIA_CheckBoxControlTypeId;
440 case ROLE_SYSTEM_RADIOBUTTON: return UIA_RadioButtonControlTypeId;
441 case ROLE_SYSTEM_COMBOBOX: return UIA_ComboBoxControlTypeId;
442 case ROLE_SYSTEM_PROGRESSBAR: return UIA_ProgressBarControlTypeId;
443 case ROLE_SYSTEM_SLIDER: return UIA_SliderControlTypeId;
444 case ROLE_SYSTEM_SPINBUTTON: return UIA_SpinnerControlTypeId;
445 case ROLE_SYSTEM_BUTTONMENU:
446 case ROLE_SYSTEM_MENUITEM: return UIA_MenuItemControlTypeId;
447 case ROLE_SYSTEM_PAGETABLIST: return UIA_TabControlTypeId;
448 case ROLE_SYSTEM_BUTTONDROPDOWN:
449 case ROLE_SYSTEM_SPLITBUTTON: return UIA_SplitButtonControlTypeId;
450 case ROLE_SYSTEM_SOUND:
451 case ROLE_SYSTEM_CURSOR:
452 case ROLE_SYSTEM_CARET:
453 case ROLE_SYSTEM_ALERT:
454 case ROLE_SYSTEM_CLIENT:
455 case ROLE_SYSTEM_CHART:
456 case ROLE_SYSTEM_DIALOG:
457 case ROLE_SYSTEM_BORDER:
458 case ROLE_SYSTEM_COLUMN:
459 case ROLE_SYSTEM_ROW:
460 case ROLE_SYSTEM_HELPBALLOON:
461 case ROLE_SYSTEM_CHARACTER:
462 case ROLE_SYSTEM_PROPERTYPAGE:
463 case ROLE_SYSTEM_DROPLIST:
464 case ROLE_SYSTEM_DIAL:
465 case ROLE_SYSTEM_HOTKEYFIELD:
466 case ROLE_SYSTEM_DIAGRAM:
467 case ROLE_SYSTEM_ANIMATION:
468 case ROLE_SYSTEM_EQUATION:
469 case ROLE_SYSTEM_WHITESPACE:
470 case ROLE_SYSTEM_IPADDRESS:
471 case ROLE_SYSTEM_OUTLINEBUTTON:
472 WARN("No UIA control type mapping for MSAA role %ld\n", role);
473 break;
474
475 default:
476 FIXME("UIA control type mapping unimplemented for MSAA role %ld\n", role);
477 break;
478 }
479
480 return 0;
481 }
482
483 /*
484 * UiaProviderFromIAccessible IRawElementProviderSimple interface.
485 */
486 struct msaa_provider {
487 IRawElementProviderSimple IRawElementProviderSimple_iface;
488 IRawElementProviderFragment IRawElementProviderFragment_iface;
489 ILegacyIAccessibleProvider ILegacyIAccessibleProvider_iface;
490 LONG refcount;
491
492 IAccessible *acc;
493 IAccessible2 *ia2;
494 VARIANT cid;
495 HWND hwnd;
496 LONG control_type;
497
498 BOOL root_acc_check_ran;
499 BOOL is_root_acc;
500
501 IAccessible *parent;
502 INT child_pos;
503 };
504
505 static BOOL msaa_check_root_acc(struct msaa_provider *msaa_prov)
506 {
507 IAccessible *acc;
508 HRESULT hr;
509
510 if (msaa_prov->root_acc_check_ran)
511 return msaa_prov->is_root_acc;
512
513 msaa_prov->root_acc_check_ran = TRUE;
514 if (V_I4(&msaa_prov->cid) != CHILDID_SELF || msaa_prov->parent)
515 return FALSE;
516
517 hr = AccessibleObjectFromWindow(msaa_prov->hwnd, OBJID_CLIENT, &IID_IAccessible, (void **)&acc);
518 if (FAILED(hr))
519 return FALSE;
520
521 if (msaa_acc_compare(msaa_prov->acc, acc))
522 msaa_prov->is_root_acc = TRUE;
523
524 IAccessible_Release(acc);
525 return msaa_prov->is_root_acc;
526 }
527
528 static inline struct msaa_provider *impl_from_msaa_provider(IRawElementProviderSimple *iface)
529 {
530 return CONTAINING_RECORD(iface, struct msaa_provider, IRawElementProviderSimple_iface);
531 }
532
533 HRESULT WINAPI msaa_provider_QueryInterface(IRawElementProviderSimple *iface, REFIID riid, void **ppv)
534 {
535 struct msaa_provider *msaa_prov = impl_from_msaa_provider(iface);
536
537 *ppv = NULL;
538 if (IsEqualIID(riid, &IID_IRawElementProviderSimple) || IsEqualIID(riid, &IID_IUnknown))
539 *ppv = iface;
540 else if (IsEqualIID(riid, &IID_IRawElementProviderFragment))
541 *ppv = &msaa_prov->IRawElementProviderFragment_iface;
542 else if (IsEqualIID(riid, &IID_ILegacyIAccessibleProvider))
543 *ppv = &msaa_prov->ILegacyIAccessibleProvider_iface;
544 else
545 return E_NOINTERFACE;
546
547 IRawElementProviderSimple_AddRef(iface);
548 return S_OK;
549 }
550
551 ULONG WINAPI msaa_provider_AddRef(IRawElementProviderSimple *iface)
552 {
553 struct msaa_provider *msaa_prov = impl_from_msaa_provider(iface);
554 ULONG refcount = InterlockedIncrement(&msaa_prov->refcount);
555
556 TRACE("%p, refcount %ld\n", iface, refcount);
557
558 return refcount;
559 }
560
561 ULONG WINAPI msaa_provider_Release(IRawElementProviderSimple *iface)
562 {
563 struct msaa_provider *msaa_prov = impl_from_msaa_provider(iface);
564 ULONG refcount = InterlockedDecrement(&msaa_prov->refcount);
565
566 TRACE("%p, refcount %ld\n", iface, refcount);
567
568 if (!refcount)
569 {
570 IAccessible_Release(msaa_prov->acc);
571 if (msaa_prov->parent)
572 IAccessible_Release(msaa_prov->parent);
573 if (msaa_prov->ia2)
574 IAccessible2_Release(msaa_prov->ia2);
575 free(msaa_prov);
576 }
577
578 return refcount;
579 }
580
581 HRESULT WINAPI msaa_provider_get_ProviderOptions(IRawElementProviderSimple *iface,
582 enum ProviderOptions *ret_val)
583 {
584 TRACE("%p, %p\n", iface, ret_val);
585 *ret_val = ProviderOptions_ServerSideProvider | ProviderOptions_UseComThreading;
586 return S_OK;
587 }
588
589 HRESULT WINAPI msaa_provider_GetPatternProvider(IRawElementProviderSimple *iface,
590 PATTERNID pattern_id, IUnknown **ret_val)
591 {
592 TRACE("%p, %d, %p\n", iface, pattern_id, ret_val);
593
594 *ret_val = NULL;
595 switch (pattern_id)
596 {
597 case UIA_LegacyIAccessiblePatternId:
598 return IRawElementProviderSimple_QueryInterface(iface, &IID_IUnknown, (void **)ret_val);
599
600 default:
601 FIXME("Unimplemented patternId %d\n", pattern_id);
602 break;
603 }
604
605 return S_OK;
606 }
607
608 HRESULT WINAPI msaa_provider_GetPropertyValue(IRawElementProviderSimple *iface,
609 PROPERTYID prop_id, VARIANT *ret_val)
610 {
611 struct msaa_provider *msaa_prov = impl_from_msaa_provider(iface);
612 HRESULT hr;
613 VARIANT v;
614
615 TRACE("%p, %d, %p\n", iface, prop_id, ret_val);
616
617 VariantInit(ret_val);
618 VariantInit(&v);
619 switch (prop_id)
620 {
621 case UIA_ProviderDescriptionPropertyId:
622 V_VT(ret_val) = VT_BSTR;
623 V_BSTR(ret_val) = SysAllocString(L"Wine: MSAA Proxy");
624 break;
625
626 case UIA_ControlTypePropertyId:
627 if (!msaa_prov->control_type)
628 {
629 hr = IAccessible_get_accRole(msaa_prov->acc, msaa_prov->cid, &v);
630 if (SUCCEEDED(hr) && (V_VT(&v) == VT_I4))
631 msaa_prov->control_type = msaa_role_to_uia_control_type(V_I4(&v));
632 }
633
634 if (msaa_prov->control_type)
635 variant_init_i4(ret_val, msaa_prov->control_type);
636
637 break;
638
639 case UIA_HasKeyboardFocusPropertyId:
640 variant_init_bool(ret_val, msaa_check_acc_state(msaa_prov->acc, msaa_prov->cid,
641 STATE_SYSTEM_FOCUSED));
642 break;
643
644 case UIA_IsKeyboardFocusablePropertyId:
645 variant_init_bool(ret_val, msaa_check_acc_state(msaa_prov->acc, msaa_prov->cid,
646 STATE_SYSTEM_FOCUSABLE));
647 break;
648
649 case UIA_IsEnabledPropertyId:
650 variant_init_bool(ret_val, !msaa_check_acc_state(msaa_prov->acc, msaa_prov->cid,
651 STATE_SYSTEM_UNAVAILABLE));
652 break;
653
654 case UIA_IsPasswordPropertyId:
655 variant_init_bool(ret_val, msaa_check_acc_state(msaa_prov->acc, msaa_prov->cid,
656 STATE_SYSTEM_PROTECTED));
657 break;
658
659 case UIA_NamePropertyId:
660 {
661 BSTR name;
662
663 hr = IAccessible_get_accName(msaa_prov->acc, msaa_prov->cid, &name);
664 if (SUCCEEDED(hr) && name)
665 {
666 V_VT(ret_val) = VT_BSTR;
667 V_BSTR(ret_val) = name;
668 }
669 break;
670 }
671
672 case UIA_IsOffscreenPropertyId:
673 {
674 RECT rect[2] = { 0 };
675 RECT intersect_rect;
676 LONG width, height;
677
678 variant_init_bool(ret_val, FALSE);
679 if (msaa_check_acc_state(msaa_prov->acc, msaa_prov->cid, STATE_SYSTEM_OFFSCREEN))
680 {
681 variant_init_bool(ret_val, TRUE);
682 break;
683 }
684
685 hr = IAccessible_accLocation(msaa_prov->acc, &rect[0].left, &rect[0].top, &width, &height, msaa_prov->cid);
686 if (FAILED(hr))
687 break;
688
689 rect[0].right = rect[0].left + width;
690 rect[0].bottom = rect[0].top + height;
691 SetLastError(NOERROR);
692 if (!GetClientRect(msaa_prov->hwnd, &rect[1]))
693 {
694 if (GetLastError() == ERROR_INVALID_WINDOW_HANDLE)
695 variant_init_bool(ret_val, TRUE);
696 break;
697 }
698
699 SetLastError(NOERROR);
700 if (!MapWindowPoints(msaa_prov->hwnd, NULL, (POINT *)&rect[1], 2) && GetLastError())
701 {
702 if (GetLastError() == ERROR_INVALID_WINDOW_HANDLE)
703 variant_init_bool(ret_val, TRUE);
704 break;
705 }
706
707 variant_init_bool(ret_val, !IntersectRect(&intersect_rect, &rect[0], &rect[1]));
708 break;
709 }
710
711 default:
712 FIXME("Unimplemented propertyId %d\n", prop_id);
713 break;
714 }
715
716 return S_OK;
717 }
718
719 HRESULT WINAPI msaa_provider_get_HostRawElementProvider(IRawElementProviderSimple *iface,
720 IRawElementProviderSimple **ret_val)
721 {
722 struct msaa_provider *msaa_prov = impl_from_msaa_provider(iface);
723
724 TRACE("%p, %p\n", iface, ret_val);
725
726 *ret_val = NULL;
727 if (msaa_check_root_acc(msaa_prov))
728 return UiaHostProviderFromHwnd(msaa_prov->hwnd, ret_val);
729
730 return S_OK;
731 }
732
733 static const IRawElementProviderSimpleVtbl msaa_provider_vtbl = {
734 msaa_provider_QueryInterface,
735 msaa_provider_AddRef,
736 msaa_provider_Release,
737 msaa_provider_get_ProviderOptions,
738 msaa_provider_GetPatternProvider,
739 msaa_provider_GetPropertyValue,
740 msaa_provider_get_HostRawElementProvider,
741 };
742
743 /*
744 * IRawElementProviderFragment interface for UiaProviderFromIAccessible
745 * providers.
746 */
747 static inline struct msaa_provider *impl_from_msaa_fragment(IRawElementProviderFragment *iface)
748 {
749 return CONTAINING_RECORD(iface, struct msaa_provider, IRawElementProviderFragment_iface);
750 }
751
752 static HRESULT WINAPI msaa_fragment_QueryInterface(IRawElementProviderFragment *iface, REFIID riid,
753 void **ppv)
754 {
755 struct msaa_provider *msaa_prov = impl_from_msaa_fragment(iface);
756 return IRawElementProviderSimple_QueryInterface(&msaa_prov->IRawElementProviderSimple_iface, riid, ppv);
757 }
758
759 static ULONG WINAPI msaa_fragment_AddRef(IRawElementProviderFragment *iface)
760 {
761 struct msaa_provider *msaa_prov = impl_from_msaa_fragment(iface);
762 return IRawElementProviderSimple_AddRef(&msaa_prov->IRawElementProviderSimple_iface);
763 }
764
765 static ULONG WINAPI msaa_fragment_Release(IRawElementProviderFragment *iface)
766 {
767 struct msaa_provider *msaa_prov = impl_from_msaa_fragment(iface);
768 return IRawElementProviderSimple_Release(&msaa_prov->IRawElementProviderSimple_iface);
769 }
770
771 static HRESULT WINAPI msaa_fragment_Navigate(IRawElementProviderFragment *iface,
772 enum NavigateDirection direction, IRawElementProviderFragment **ret_val)
773 {
774 struct msaa_provider *msaa_prov = impl_from_msaa_fragment(iface);
775 LONG child_count, child_id, child_pos;
776 IRawElementProviderSimple *elprov;
777 IAccessible *acc;
778 HRESULT hr;
779
780 TRACE("%p, %d, %p\n", iface, direction, ret_val);
781
782 *ret_val = NULL;
783 switch (direction)
784 {
785 case NavigateDirection_Parent:
786 if (msaa_check_root_acc(msaa_prov))
787 break;
788
789 if (V_I4(&msaa_prov->cid) == CHILDID_SELF)
790 {
791 hr = msaa_acc_get_parent(msaa_prov->acc, &acc);
792 if (FAILED(hr) || !acc)
793 break;
794 }
795 else
796 acc = msaa_prov->acc;
797
798 hr = create_msaa_provider(acc, CHILDID_SELF, NULL, FALSE, &elprov);
799 if (SUCCEEDED(hr))
800 {
801 struct msaa_provider *prov = impl_from_msaa_provider(elprov);
802 *ret_val = &prov->IRawElementProviderFragment_iface;
803 }
804
805 if (acc != msaa_prov->acc)
806 IAccessible_Release(acc);
807
808 break;
809
810 case NavigateDirection_FirstChild:
811 case NavigateDirection_LastChild:
812 if (V_I4(&msaa_prov->cid) != CHILDID_SELF)
813 break;
814
815 hr = IAccessible_get_accChildCount(msaa_prov->acc, &child_count);
816 if (FAILED(hr) || !child_count)
817 break;
818
819 if (direction == NavigateDirection_FirstChild)
820 hr = msaa_acc_get_next_child(msaa_prov->acc, 1, DIR_FORWARD, &acc, &child_id,
821 &child_pos, TRUE);
822 else
823 hr = msaa_acc_get_next_child(msaa_prov->acc, child_count, DIR_REVERSE, &acc, &child_id,
824 &child_pos, TRUE);
825
826 if (FAILED(hr) || !acc)
827 break;
828
829 hr = create_msaa_provider(acc, child_id, NULL, FALSE, &elprov);
830 if (SUCCEEDED(hr))
831 {
832 struct msaa_provider *prov = impl_from_msaa_provider(elprov);
833
834 *ret_val = &prov->IRawElementProviderFragment_iface;
835 prov->parent = msaa_prov->acc;
836 IAccessible_AddRef(msaa_prov->acc);
837 if (acc != msaa_prov->acc)
838 prov->child_pos = child_pos;
839 else
840 prov->child_pos = child_id;
841 }
842 IAccessible_Release(acc);
843
844 break;
845
846 case NavigateDirection_NextSibling:
847 case NavigateDirection_PreviousSibling:
848 if (msaa_check_root_acc(msaa_prov))
849 break;
850
851 if (!msaa_prov->parent)
852 {
853 if (V_I4(&msaa_prov->cid) != CHILDID_SELF)
854 {
855 msaa_prov->parent = msaa_prov->acc;
856 IAccessible_AddRef(msaa_prov->acc);
857 msaa_prov->child_pos = V_I4(&msaa_prov->cid);
858 }
859 else
860 {
861 hr = msaa_acc_get_child_pos(msaa_prov->acc, &acc, &child_pos);
862 if (FAILED(hr) || !acc)
863 break;
864 msaa_prov->parent = acc;
865 msaa_prov->child_pos = child_pos;
866 }
867 }
868
869 if (direction == NavigateDirection_NextSibling)
870 hr = msaa_acc_get_next_child(msaa_prov->parent, msaa_prov->child_pos + 1, DIR_FORWARD,
871 &acc, &child_id, &child_pos, TRUE);
872 else
873 hr = msaa_acc_get_next_child(msaa_prov->parent, msaa_prov->child_pos - 1, DIR_REVERSE,
874 &acc, &child_id, &child_pos, TRUE);
875
876 if (FAILED(hr) || !acc)
877 break;
878
879 hr = create_msaa_provider(acc, child_id, NULL, FALSE, &elprov);
880 if (SUCCEEDED(hr))
881 {
882 struct msaa_provider *prov = impl_from_msaa_provider(elprov);
883
884 *ret_val = &prov->IRawElementProviderFragment_iface;
885 prov->parent = msaa_prov->parent;
886 IAccessible_AddRef(msaa_prov->parent);
887 if (acc != msaa_prov->acc)
888 prov->child_pos = child_pos;
889 else
890 prov->child_pos = child_id;
891 }
892 IAccessible_Release(acc);
893
894 break;
895
896 default:
897 FIXME("Invalid NavigateDirection %d\n", direction);
898 return E_INVALIDARG;
899 }
900
901 return S_OK;
902 }
903
904 static HRESULT WINAPI msaa_fragment_GetRuntimeId(IRawElementProviderFragment *iface,
905 SAFEARRAY **ret_val)
906 {
907 FIXME("%p, %p: stub!\n", iface, ret_val);
908 *ret_val = NULL;
909 return E_NOTIMPL;
910 }
911
912 static HRESULT WINAPI msaa_fragment_get_BoundingRectangle(IRawElementProviderFragment *iface,
913 struct UiaRect *ret_val)
914 {
915 struct msaa_provider *msaa_prov = impl_from_msaa_fragment(iface);
916 LONG left, top, width, height;
917 HRESULT hr;
918
919 TRACE("%p, %p\n", iface, ret_val);
920
921 memset(ret_val, 0, sizeof(*ret_val));
922
923 /*
924 * If this IAccessible is at the root of its HWND, the BaseHwnd provider
925 * will supply the bounding rectangle.
926 */
927 if (msaa_check_root_acc(msaa_prov))
928 return S_OK;
929
930 if (msaa_check_acc_state(msaa_prov->acc, msaa_prov->cid, STATE_SYSTEM_OFFSCREEN))
931 return S_OK;
932
933 hr = IAccessible_accLocation(msaa_prov->acc, &left, &top, &width, &height, msaa_prov->cid);
934 if (FAILED(hr))
935 return hr;
936
937 ret_val->left = left;
938 ret_val->top = top;
939 ret_val->width = width;
940 ret_val->height = height;
941
942 return S_OK;
943 }
944
945 static HRESULT WINAPI msaa_fragment_GetEmbeddedFragmentRoots(IRawElementProviderFragment *iface,
946 SAFEARRAY **ret_val)
947 {
948 FIXME("%p, %p: stub!\n", iface, ret_val);
949 *ret_val = NULL;
950 return E_NOTIMPL;
951 }
952
953 static HRESULT WINAPI msaa_fragment_SetFocus(IRawElementProviderFragment *iface)
954 {
955 FIXME("%p: stub!\n", iface);
956 return E_NOTIMPL;
957 }
958
959 static HRESULT WINAPI msaa_fragment_get_FragmentRoot(IRawElementProviderFragment *iface,
960 IRawElementProviderFragmentRoot **ret_val)
961 {
962 FIXME("%p, %p: stub!\n", iface, ret_val);
963 *ret_val = NULL;
964 return E_NOTIMPL;
965 }
966
967 static const IRawElementProviderFragmentVtbl msaa_fragment_vtbl = {
968 msaa_fragment_QueryInterface,
969 msaa_fragment_AddRef,
970 msaa_fragment_Release,
971 msaa_fragment_Navigate,
972 msaa_fragment_GetRuntimeId,
973 msaa_fragment_get_BoundingRectangle,
974 msaa_fragment_GetEmbeddedFragmentRoots,
975 msaa_fragment_SetFocus,
976 msaa_fragment_get_FragmentRoot,
977 };
978
979 /*
980 * ILegacyIAccessibleProvider interface for UiaProviderFromIAccessible
981 * providers.
982 */
983 static inline struct msaa_provider *impl_from_msaa_acc_provider(ILegacyIAccessibleProvider *iface)
984 {
985 return CONTAINING_RECORD(iface, struct msaa_provider, ILegacyIAccessibleProvider_iface);
986 }
987
988 static HRESULT WINAPI msaa_acc_provider_QueryInterface(ILegacyIAccessibleProvider *iface, REFIID riid, void **ppv)
989 {
990 struct msaa_provider *msaa_prov = impl_from_msaa_acc_provider(iface);
991 return IRawElementProviderSimple_QueryInterface(&msaa_prov->IRawElementProviderSimple_iface, riid, ppv);
992 }
993
994 static ULONG WINAPI msaa_acc_provider_AddRef(ILegacyIAccessibleProvider *iface)
995 {
996 struct msaa_provider *msaa_prov = impl_from_msaa_acc_provider(iface);
997 return IRawElementProviderSimple_AddRef(&msaa_prov->IRawElementProviderSimple_iface);
998 }
999
1000 static ULONG WINAPI msaa_acc_provider_Release(ILegacyIAccessibleProvider *iface)
1001 {
1002 struct msaa_provider *msaa_prov = impl_from_msaa_acc_provider(iface);
1003 return IRawElementProviderSimple_Release(&msaa_prov->IRawElementProviderSimple_iface);
1004 }
1005
1006 static HRESULT WINAPI msaa_acc_provider_Select(ILegacyIAccessibleProvider *iface, LONG select_flags)
1007 {
1008 FIXME("%p, %#lx: stub!\n", iface, select_flags);
1009 return E_NOTIMPL;
1010 }
1011
1012 static HRESULT WINAPI msaa_acc_provider_DoDefaultAction(ILegacyIAccessibleProvider *iface)
1013 {
1014 FIXME("%p: stub!\n", iface);
1015 return E_NOTIMPL;
1016 }
1017
1018 static HRESULT WINAPI msaa_acc_provider_SetValue(ILegacyIAccessibleProvider *iface, LPCWSTR val)
1019 {
1020 FIXME("%p, %p<%s>: stub!\n", iface, val, debugstr_w(val));
1021 return E_NOTIMPL;
1022 }
1023
1024 static HRESULT WINAPI msaa_acc_provider_GetIAccessible(ILegacyIAccessibleProvider *iface,
1025 IAccessible **out_acc)
1026 {
1027 struct msaa_provider *msaa_prov = impl_from_msaa_acc_provider(iface);
1028
1029 TRACE("%p, %p\n", iface, out_acc);
1030
1031 IAccessible_AddRef(msaa_prov->acc);
1032 *out_acc = msaa_prov->acc;
1033
1034 return S_OK;
1035 }
1036
1037 static HRESULT WINAPI msaa_acc_provider_get_ChildId(ILegacyIAccessibleProvider *iface, int *out_cid)
1038 {
1039 struct msaa_provider *msaa_prov = impl_from_msaa_acc_provider(iface);
1040
1041 TRACE("%p, %p\n", iface, out_cid);
1042 *out_cid = V_I4(&msaa_prov->cid);
1043
1044 return S_OK;
1045 }
1046
1047 static HRESULT WINAPI msaa_acc_provider_get_Name(ILegacyIAccessibleProvider *iface, BSTR *out_name)
1048 {
1049 FIXME("%p, %p: stub!\n", iface, out_name);
1050 return E_NOTIMPL;
1051 }
1052
1053 static HRESULT WINAPI msaa_acc_provider_get_Value(ILegacyIAccessibleProvider *iface, BSTR *out_value)
1054 {
1055 FIXME("%p, %p: stub!\n", iface, out_value);
1056 return E_NOTIMPL;
1057 }
1058
1059 static HRESULT WINAPI msaa_acc_provider_get_Description(ILegacyIAccessibleProvider *iface,
1060 BSTR *out_description)
1061 {
1062 FIXME("%p, %p: stub!\n", iface, out_description);
1063 return E_NOTIMPL;
1064 }
1065
1066 static HRESULT WINAPI msaa_acc_provider_get_Role(ILegacyIAccessibleProvider *iface, DWORD *out_role)
1067 {
1068 struct msaa_provider *msaa_prov = impl_from_msaa_acc_provider(iface);
1069 HRESULT hr;
1070 VARIANT v;
1071
1072 TRACE("%p, %p\n", iface, out_role);
1073
1074 *out_role = 0;
1075 VariantInit(&v);
1076 hr = IAccessible_get_accRole(msaa_prov->acc, msaa_prov->cid, &v);
1077 if (SUCCEEDED(hr) && V_VT(&v) == VT_I4)
1078 *out_role = V_I4(&v);
1079
1080 return S_OK;
1081 }
1082
1083 static HRESULT WINAPI msaa_acc_provider_get_State(ILegacyIAccessibleProvider *iface, DWORD *out_state)
1084 {
1085 FIXME("%p, %p: stub!\n", iface, out_state);
1086 return E_NOTIMPL;
1087 }
1088
1089 static HRESULT WINAPI msaa_acc_provider_get_Help(ILegacyIAccessibleProvider *iface, BSTR *out_help)
1090 {
1091 FIXME("%p, %p: stub!\n", iface, out_help);
1092 return E_NOTIMPL;
1093 }
1094
1095 static HRESULT WINAPI msaa_acc_provider_get_KeyboardShortcut(ILegacyIAccessibleProvider *iface,
1096 BSTR *out_kbd_shortcut)
1097 {
1098 FIXME("%p, %p: stub!\n", iface, out_kbd_shortcut);
1099 return E_NOTIMPL;
1100 }
1101
1102 static HRESULT WINAPI msaa_acc_provider_GetSelection(ILegacyIAccessibleProvider *iface,
1103 SAFEARRAY **out_selected)
1104 {
1105 FIXME("%p, %p: stub!\n", iface, out_selected);
1106 return E_NOTIMPL;
1107 }
1108
1109 static HRESULT WINAPI msaa_acc_provider_get_DefaultAction(ILegacyIAccessibleProvider *iface,
1110 BSTR *out_default_action)
1111 {
1112 FIXME("%p, %p: stub!\n", iface, out_default_action);
1113 return E_NOTIMPL;
1114 }
1115
1116 static const ILegacyIAccessibleProviderVtbl msaa_acc_provider_vtbl = {
1117 msaa_acc_provider_QueryInterface,
1118 msaa_acc_provider_AddRef,
1119 msaa_acc_provider_Release,
1120 msaa_acc_provider_Select,
1121 msaa_acc_provider_DoDefaultAction,
1122 msaa_acc_provider_SetValue,
1123 msaa_acc_provider_GetIAccessible,
1124 msaa_acc_provider_get_ChildId,
1125 msaa_acc_provider_get_Name,
1126 msaa_acc_provider_get_Value,
1127 msaa_acc_provider_get_Description,
1128 msaa_acc_provider_get_Role,
1129 msaa_acc_provider_get_State,
1130 msaa_acc_provider_get_Help,
1131 msaa_acc_provider_get_KeyboardShortcut,
1132 msaa_acc_provider_GetSelection,
1133 msaa_acc_provider_get_DefaultAction,
1134 };
1135
1136 HRESULT create_msaa_provider(IAccessible *acc, LONG child_id, HWND hwnd, BOOL known_root_acc,
1137 IRawElementProviderSimple **elprov)
1138 {
1139 struct msaa_provider *msaa_prov = calloc(1, sizeof(*msaa_prov));
1140
1141 if (!msaa_prov)
1142 return E_OUTOFMEMORY;
1143
1144 msaa_prov->IRawElementProviderSimple_iface.lpVtbl = &msaa_provider_vtbl;
1145 msaa_prov->IRawElementProviderFragment_iface.lpVtbl = &msaa_fragment_vtbl;
1146 msaa_prov->ILegacyIAccessibleProvider_iface.lpVtbl = &msaa_acc_provider_vtbl;
1147 msaa_prov->refcount = 1;
1148 variant_init_i4(&msaa_prov->cid, child_id);
1149 msaa_prov->acc = acc;
1150 IAccessible_AddRef(acc);
1151 msaa_prov->ia2 = msaa_acc_get_ia2(acc);
1152
1153 if (!hwnd)
1154 {
1155 HRESULT hr;
1156
1157 hr = WindowFromAccessibleObject(acc, &msaa_prov->hwnd);
1158 if (FAILED(hr))
1159 WARN("WindowFromAccessibleObject failed with hr %#lx\n", hr);
1160 }
1161 else
1162 msaa_prov->hwnd = hwnd;
1163
1164 if (known_root_acc)
1165 msaa_prov->root_acc_check_ran = msaa_prov->is_root_acc = TRUE;
1166
1167 *elprov = &msaa_prov->IRawElementProviderSimple_iface;
1168
1169 return S_OK;
1170 }
1171
1172 /***********************************************************************
1173 * UiaProviderFromIAccessible (uiautomationcore.@)
1174 */
1175 HRESULT WINAPI UiaProviderFromIAccessible(IAccessible *acc, LONG child_id, DWORD flags,
1176 IRawElementProviderSimple **elprov)
1177 {
1178 IServiceProvider *serv_prov;
1179 HWND hwnd = NULL;
1180 HRESULT hr;
1181
1182 TRACE("(%p, %ld, %#lx, %p)\n", acc, child_id, flags, elprov);
1183
1184 if (elprov)
1185 *elprov = NULL;
1186
1187 if (!elprov)
1188 return E_POINTER;
1189 if (!acc)
1190 return E_INVALIDARG;
1191
1192 if (flags != UIA_PFIA_DEFAULT)
1193 {
1194 FIXME("unsupported flags %#lx\n", flags);
1195 return E_NOTIMPL;
1196 }
1197
1198 hr = IAccessible_QueryInterface(acc, &IID_IServiceProvider, (void **)&serv_prov);
1199 if (SUCCEEDED(hr))
1200 {
1201 IUnknown *unk;
1202
1203 hr = IServiceProvider_QueryService(serv_prov, &IIS_IsOleaccProxy, &IID_IUnknown, (void **)&unk);
1204 if (SUCCEEDED(hr))
1205 {
1206 WARN("Cannot wrap an oleacc proxy IAccessible!\n");
1207 IUnknown_Release(unk);
1208 IServiceProvider_Release(serv_prov);
1209 return E_INVALIDARG;
1210 }
1211
1212 IServiceProvider_Release(serv_prov);
1213 }
1214
1215 hr = WindowFromAccessibleObject(acc, &hwnd);
1216 if (FAILED(hr))
1217 return hr;
1218 if (!hwnd)
1219 return E_FAIL;
1220
1221 return create_msaa_provider(acc, child_id, hwnd, FALSE, elprov);
1222 }
1223
1224 static HRESULT uia_get_hr_for_last_error(void)
1225 {
1226 DWORD last_err = GetLastError();
1227
1228 switch (last_err)
1229 {
1230 case ERROR_INVALID_WINDOW_HANDLE:
1231 return UIA_E_ELEMENTNOTAVAILABLE;
1232
1233 case ERROR_TIMEOUT:
1234 return UIA_E_TIMEOUT;
1235
1236 default:
1237 return E_FAIL;
1238 }
1239 }
1240
1241 #define UIA_DEFAULT_MSG_TIMEOUT 10000
1242 static HRESULT uia_send_message_timeout(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam, UINT timeout, LRESULT *lres)
1243 {
1244 *lres = 0;
1245 if (!SendMessageTimeoutW(hwnd, msg, wparam, lparam, SMTO_NORMAL, timeout, (PDWORD_PTR)lres))
1246 return uia_get_hr_for_last_error();
1247
1248 return S_OK;
1249 }
1250
1251 static BOOL is_top_level_hwnd(HWND hwnd)
1252 {
1253 return GetAncestor(hwnd, GA_PARENT) == GetDesktopWindow();
1254 }
1255
1256 static HRESULT get_uia_control_type_for_hwnd(HWND hwnd, int *control_type)
1257 {
1258 LONG_PTR style, ex_style;
1259
1260 *control_type = 0;
1261 if ((ex_style = GetWindowLongPtrW(hwnd, GWL_EXSTYLE)) & WS_EX_APPWINDOW)
1262 {
1263 *control_type = UIA_WindowControlTypeId;
1264 return S_OK;
1265 }
1266
1267 SetLastError(NO_ERROR);
1268 if (!(style = GetWindowLongPtrW(hwnd, GWL_STYLE)) && (GetLastError() != NO_ERROR))
1269 return uia_get_hr_for_last_error();
1270
1271 /*
1272 * Non-caption HWNDs that are popups or tool windows aren't considered full
1273 * windows, only panes.
1274 */
1275 if (((style & WS_CAPTION) != WS_CAPTION) && ((ex_style & WS_EX_TOOLWINDOW) || (style & WS_POPUP)))
1276 {
1277 *control_type = UIA_PaneControlTypeId;
1278 return S_OK;
1279 }
1280
1281 /* Non top-level HWNDs are considered panes as well. */
1282 if (!is_top_level_hwnd(hwnd))
1283 *control_type = UIA_PaneControlTypeId;
1284 else
1285 *control_type = UIA_WindowControlTypeId;
1286
1287 return S_OK;
1288 }
1289
1290 /*
1291 * Default ProviderType_BaseHwnd IRawElementProviderSimple interface.
1292 */
1293 struct base_hwnd_provider {
1294 IRawElementProviderSimple IRawElementProviderSimple_iface;
1295 IRawElementProviderFragment IRawElementProviderFragment_iface;
1296 LONG refcount;
1297
1298 HWND hwnd;
1299 };
1300
1301 static inline struct base_hwnd_provider *impl_from_base_hwnd_provider(IRawElementProviderSimple *iface)
1302 {
1303 return CONTAINING_RECORD(iface, struct base_hwnd_provider, IRawElementProviderSimple_iface);
1304 }
1305
1306 static HRESULT WINAPI base_hwnd_provider_QueryInterface(IRawElementProviderSimple *iface, REFIID riid, void **ppv)
1307 {
1308 struct base_hwnd_provider *base_hwnd_prov = impl_from_base_hwnd_provider(iface);
1309
1310 *ppv = NULL;
1311 if (IsEqualIID(riid, &IID_IRawElementProviderSimple) || IsEqualIID(riid, &IID_IUnknown))
1312 *ppv = iface;
1313 else if (IsEqualIID(riid, &IID_IRawElementProviderFragment))
1314 *ppv = &base_hwnd_prov->IRawElementProviderFragment_iface;
1315 else
1316 return E_NOINTERFACE;
1317
1318 IRawElementProviderSimple_AddRef(iface);
1319 return S_OK;
1320 }
1321
1322 static ULONG WINAPI base_hwnd_provider_AddRef(IRawElementProviderSimple *iface)
1323 {
1324 struct base_hwnd_provider *base_hwnd_prov = impl_from_base_hwnd_provider(iface);
1325 ULONG refcount = InterlockedIncrement(&base_hwnd_prov->refcount);
1326
1327 TRACE("%p, refcount %ld\n", iface, refcount);
1328
1329 return refcount;
1330 }
1331
1332 static ULONG WINAPI base_hwnd_provider_Release(IRawElementProviderSimple *iface)
1333 {
1334 struct base_hwnd_provider *base_hwnd_prov = impl_from_base_hwnd_provider(iface);
1335 ULONG refcount = InterlockedDecrement(&base_hwnd_prov->refcount);
1336
1337 TRACE("%p, refcount %ld\n", iface, refcount);
1338
1339 if (!refcount)
1340 free(base_hwnd_prov);
1341
1342 return refcount;
1343 }
1344
1345 static HRESULT WINAPI base_hwnd_provider_get_ProviderOptions(IRawElementProviderSimple *iface,
1346 enum ProviderOptions *ret_val)
1347 {
1348 TRACE("%p, %p\n", iface, ret_val);
1349 *ret_val = ProviderOptions_ClientSideProvider;
1350 return S_OK;
1351 }
1352
1353 static HRESULT WINAPI base_hwnd_provider_GetPatternProvider(IRawElementProviderSimple *iface,
1354 PATTERNID pattern_id, IUnknown **ret_val)
1355 {
1356 FIXME("%p, %d, %p: stub\n", iface, pattern_id, ret_val);
1357 *ret_val = NULL;
1358 return E_NOTIMPL;
1359 }
1360
1361 static HRESULT WINAPI base_hwnd_provider_GetPropertyValue(IRawElementProviderSimple *iface,
1362 PROPERTYID prop_id, VARIANT *ret_val)
1363 {
1364 struct base_hwnd_provider *base_hwnd_prov = impl_from_base_hwnd_provider(iface);
1365 HRESULT hr = S_OK;
1366
1367 TRACE("%p, %d, %p\n", iface, prop_id, ret_val);
1368
1369 VariantInit(ret_val);
1370 if (!IsWindow(base_hwnd_prov->hwnd))
1371 return UIA_E_ELEMENTNOTAVAILABLE;
1372
1373 switch (prop_id)
1374 {
1375 case UIA_ProviderDescriptionPropertyId:
1376 V_VT(ret_val) = VT_BSTR;
1377 V_BSTR(ret_val) = SysAllocString(L"Wine: HWND Proxy");
1378 break;
1379
1380 case UIA_NativeWindowHandlePropertyId:
1381 V_VT(ret_val) = VT_I4;
1382 V_I4(ret_val) = HandleToUlong(base_hwnd_prov->hwnd);
1383 break;
1384
1385 case UIA_ProcessIdPropertyId:
1386 {
1387 DWORD pid;
1388
1389 if (!GetWindowThreadProcessId(base_hwnd_prov->hwnd, &pid))
1390 return UIA_E_ELEMENTNOTAVAILABLE;
1391
1392 V_VT(ret_val) = VT_I4;
1393 V_I4(ret_val) = pid;
1394 break;
1395 }
1396
1397 case UIA_ClassNamePropertyId:
1398 {
1399 WCHAR buf[256] = { 0 };
1400
1401 if (!GetClassNameW(base_hwnd_prov->hwnd, buf, ARRAY_SIZE(buf)))
1402 hr = uia_get_hr_for_last_error();
1403 else
1404 {
1405 V_VT(ret_val) = VT_BSTR;
1406 V_BSTR(ret_val) = SysAllocString(buf);
1407 }
1408 break;
1409 }
1410
1411 case UIA_NamePropertyId:
1412 {
1413 LRESULT lres;
1414
1415 V_VT(ret_val) = VT_BSTR;
1416 V_BSTR(ret_val) = SysAllocString(L"");
1417 hr = uia_send_message_timeout(base_hwnd_prov->hwnd, WM_GETTEXTLENGTH, 0, 0, UIA_DEFAULT_MSG_TIMEOUT, &lres);
1418 if (FAILED(hr) || !lres)
1419 break;
1420
1421 if (!SysReAllocStringLen(&V_BSTR(ret_val), NULL, lres))
1422 {
1423 hr = E_OUTOFMEMORY;
1424 break;
1425 }
1426
1427 hr = uia_send_message_timeout(base_hwnd_prov->hwnd, WM_GETTEXT, SysStringLen(V_BSTR(ret_val)) + 1,
1428 (LPARAM)V_BSTR(ret_val), UIA_DEFAULT_MSG_TIMEOUT, &lres);
1429 break;
1430 }
1431
1432 case UIA_ControlTypePropertyId:
1433 {
1434 int control_type;
1435
1436 hr = get_uia_control_type_for_hwnd(base_hwnd_prov->hwnd, &control_type);
1437 if (SUCCEEDED(hr))
1438 {
1439 V_VT(ret_val) = VT_I4;
1440 V_I4(ret_val) = control_type;
1441 }
1442 break;
1443 }
1444
1445 default:
1446 break;
1447 }
1448
1449 if (FAILED(hr))
1450 VariantClear(ret_val);
1451
1452 return hr;
1453 }
1454
1455 static HRESULT WINAPI base_hwnd_provider_get_HostRawElementProvider(IRawElementProviderSimple *iface,
1456 IRawElementProviderSimple **ret_val)
1457 {
1458 TRACE("%p, %p\n", iface, ret_val);
1459 *ret_val = NULL;
1460 return S_OK;
1461 }
1462
1463 static const IRawElementProviderSimpleVtbl base_hwnd_provider_vtbl = {
1464 base_hwnd_provider_QueryInterface,
1465 base_hwnd_provider_AddRef,
1466 base_hwnd_provider_Release,
1467 base_hwnd_provider_get_ProviderOptions,
1468 base_hwnd_provider_GetPatternProvider,
1469 base_hwnd_provider_GetPropertyValue,
1470 base_hwnd_provider_get_HostRawElementProvider,
1471 };
1472
1473 /*
1474 * IRawElementProviderFragment interface for default ProviderType_BaseHwnd
1475 * providers.
1476 */
1477 static inline struct base_hwnd_provider *impl_from_base_hwnd_fragment(IRawElementProviderFragment *iface)
1478 {
1479 return CONTAINING_RECORD(iface, struct base_hwnd_provider, IRawElementProviderFragment_iface);
1480 }
1481
1482 static HRESULT WINAPI base_hwnd_fragment_QueryInterface(IRawElementProviderFragment *iface, REFIID riid,
1483 void **ppv)
1484 {
1485 struct base_hwnd_provider *base_hwnd_prov = impl_from_base_hwnd_fragment(iface);
1486 return IRawElementProviderSimple_QueryInterface(&base_hwnd_prov->IRawElementProviderSimple_iface, riid, ppv);
1487 }
1488
1489 static ULONG WINAPI base_hwnd_fragment_AddRef(IRawElementProviderFragment *iface)
1490 {
1491 struct base_hwnd_provider *base_hwnd_prov = impl_from_base_hwnd_fragment(iface);
1492 return IRawElementProviderSimple_AddRef(&base_hwnd_prov->IRawElementProviderSimple_iface);
1493 }
1494
1495 static ULONG WINAPI base_hwnd_fragment_Release(IRawElementProviderFragment *iface)
1496 {
1497 struct base_hwnd_provider *base_hwnd_prov = impl_from_base_hwnd_fragment(iface);
1498 return IRawElementProviderSimple_Release(&base_hwnd_prov->IRawElementProviderSimple_iface);
1499 }
1500
1501 static HRESULT WINAPI base_hwnd_fragment_Navigate(IRawElementProviderFragment *iface,
1502 enum NavigateDirection direction, IRawElementProviderFragment **ret_val)
1503 {
1504 struct base_hwnd_provider *base_hwnd_prov = impl_from_base_hwnd_fragment(iface);
1505 IRawElementProviderSimple *elprov = NULL;
1506 HRESULT hr = S_OK;
1507
1508 TRACE("%p, %d, %p\n", iface, direction, ret_val);
1509
1510 *ret_val = NULL;
1511
1512 switch (direction)
1513 {
1514 case NavigateDirection_Parent:
1515 {
1516 HWND parent, owner;
1517
1518 /*
1519 * Top level owned windows have their owner window as a parent instead
1520 * of the desktop window.
1521 */
1522 if (is_top_level_hwnd(base_hwnd_prov->hwnd) && (owner = GetWindow(base_hwnd_prov->hwnd, GW_OWNER)))
1523 parent = owner;
1524 else
1525 parent = GetAncestor(base_hwnd_prov->hwnd, GA_PARENT);
1526
1527 if (parent)
1528 hr = create_base_hwnd_provider(parent, &elprov);
1529 break;
1530 }
1531
1532 case NavigateDirection_FirstChild:
1533 case NavigateDirection_LastChild:
1534 case NavigateDirection_PreviousSibling:
1535 case NavigateDirection_NextSibling:
1536 FIXME("Unimplemented NavigateDirection %d\n", direction);
1537 return E_NOTIMPL;
1538
1539 default:
1540 FIXME("Invalid NavigateDirection %d\n", direction);
1541 return E_INVALIDARG;
1542 }
1543
1544 if (elprov)
1545 {
1546 hr = IRawElementProviderSimple_QueryInterface(elprov, &IID_IRawElementProviderFragment, (void **)ret_val);
1547 IRawElementProviderSimple_Release(elprov);
1548 }
1549
1550 return hr;
1551 }
1552
1553 static HRESULT WINAPI base_hwnd_fragment_GetRuntimeId(IRawElementProviderFragment *iface,
1554 SAFEARRAY **ret_val)
1555 {
1556 FIXME("%p, %p: stub!\n", iface, ret_val);
1557 *ret_val = NULL;
1558 return E_NOTIMPL;
1559 }
1560
1561 static HRESULT WINAPI base_hwnd_fragment_get_BoundingRectangle(IRawElementProviderFragment *iface,
1562 struct UiaRect *ret_val)
1563 {
1564 struct base_hwnd_provider *base_hwnd_prov = impl_from_base_hwnd_fragment(iface);
1565 RECT rect = { 0 };
1566
1567 TRACE("%p, %p\n", iface, ret_val);
1568
1569 memset(ret_val, 0, sizeof(*ret_val));
1570
1571 /* Top level minimized window - Return empty rect. */
1572 if (is_top_level_hwnd(base_hwnd_prov->hwnd) && IsIconic(base_hwnd_prov->hwnd))
1573 return S_OK;
1574
1575 if (!GetWindowRect(base_hwnd_prov->hwnd, &rect))
1576 return uia_get_hr_for_last_error();
1577
1578 ret_val->left = rect.left;
1579 ret_val->top = rect.top;
1580 ret_val->width = (rect.right - rect.left);
1581 ret_val->height = (rect.bottom - rect.top);
1582
1583 return S_OK;
1584 }
1585
1586 static HRESULT WINAPI base_hwnd_fragment_GetEmbeddedFragmentRoots(IRawElementProviderFragment *iface,
1587 SAFEARRAY **ret_val)
1588 {
1589 FIXME("%p, %p: stub!\n", iface, ret_val);
1590 *ret_val = NULL;
1591 return E_NOTIMPL;
1592 }
1593
1594 static HRESULT WINAPI base_hwnd_fragment_SetFocus(IRawElementProviderFragment *iface)
1595 {
1596 FIXME("%p: stub!\n", iface);
1597 return E_NOTIMPL;
1598 }
1599
1600 static HRESULT WINAPI base_hwnd_fragment_get_FragmentRoot(IRawElementProviderFragment *iface,
1601 IRawElementProviderFragmentRoot **ret_val)
1602 {
1603 FIXME("%p, %p: stub!\n", iface, ret_val);
1604 *ret_val = NULL;
1605 return E_NOTIMPL;
1606 }
1607
1608 static const IRawElementProviderFragmentVtbl base_hwnd_fragment_vtbl = {
1609 base_hwnd_fragment_QueryInterface,
1610 base_hwnd_fragment_AddRef,
1611 base_hwnd_fragment_Release,
1612 base_hwnd_fragment_Navigate,
1613 base_hwnd_fragment_GetRuntimeId,
1614 base_hwnd_fragment_get_BoundingRectangle,
1615 base_hwnd_fragment_GetEmbeddedFragmentRoots,
1616 base_hwnd_fragment_SetFocus,
1617 base_hwnd_fragment_get_FragmentRoot,
1618 };
1619
1620 HRESULT create_base_hwnd_provider(HWND hwnd, IRawElementProviderSimple **elprov)
1621 {
1622 struct base_hwnd_provider *base_hwnd_prov;
1623
1624 *elprov = NULL;
1625
1626 if (!hwnd)
1627 return E_INVALIDARG;
1628
1629 if (!IsWindow(hwnd))
1630 return UIA_E_ELEMENTNOTAVAILABLE;
1631
1632 if (!(base_hwnd_prov = calloc(1, sizeof(*base_hwnd_prov))))
1633 return E_OUTOFMEMORY;
1634
1635 base_hwnd_prov->IRawElementProviderSimple_iface.lpVtbl = &base_hwnd_provider_vtbl;
1636 base_hwnd_prov->IRawElementProviderFragment_iface.lpVtbl = &base_hwnd_fragment_vtbl;
1637 base_hwnd_prov->refcount = 1;
1638 base_hwnd_prov->hwnd = hwnd;
1639 *elprov = &base_hwnd_prov->IRawElementProviderSimple_iface;
1640
1641 return S_OK;
1642 }
1643
1644 /*
1645 * UI Automation provider thread functions.
1646 */
1647 struct uia_provider_thread
1648 {
1649 struct rb_tree node_map;
1650 struct list nodes_list;
1651 HANDLE hthread;
1652 HWND hwnd;
1653 LONG ref;
1654 };
1655
1656 static struct uia_provider_thread provider_thread;
1657 static CRITICAL_SECTION provider_thread_cs;
1658 static CRITICAL_SECTION_DEBUG provider_thread_cs_debug =
1659 {
1660 0, 0, &provider_thread_cs,
1661 { &provider_thread_cs_debug.ProcessLocksList, &provider_thread_cs_debug.ProcessLocksList },
1662 0, 0, { (DWORD_PTR)(__FILE__ ": provider_thread_cs") }
1663 };
1664 static CRITICAL_SECTION provider_thread_cs = { &provider_thread_cs_debug, -1, 0, 0, 0, 0 };
1665
1666 struct uia_provider_thread_map_entry
1667 {
1668 struct rb_entry entry;
1669
1670 SAFEARRAY *runtime_id;
1671 struct list nodes_list;
1672 };
1673
1674 static int uia_runtime_id_compare(const void *key, const struct rb_entry *entry)
1675 {
1676 struct uia_provider_thread_map_entry *prov_entry = RB_ENTRY_VALUE(entry, struct uia_provider_thread_map_entry, entry);
1677 return uia_compare_safearrays(prov_entry->runtime_id, (SAFEARRAY *)key, UIAutomationType_IntArray);
1678 }
1679
1680 void uia_provider_thread_remove_node(HUIANODE node)
1681 {
1682 struct uia_node *node_data = impl_from_IWineUiaNode((IWineUiaNode *)node);
1683
1684 TRACE("Removing node %p\n", node);
1685
1686 EnterCriticalSection(&provider_thread_cs);
1687
1688 list_remove(&node_data->prov_thread_list_entry);
1689 list_init(&node_data->prov_thread_list_entry);
1690 if (!list_empty(&node_data->node_map_list_entry))
1691 {
1692 list_remove(&node_data->node_map_list_entry);
1693 list_init(&node_data->node_map_list_entry);
1694 if (list_empty(&node_data->map->nodes_list))
1695 {
1696 rb_remove(&provider_thread.node_map, &node_data->map->entry);
1697 SafeArrayDestroy(node_data->map->runtime_id);
1698 free(node_data->map);
1699 }
1700 node_data->map = NULL;
1701 }
1702
1703 LeaveCriticalSection(&provider_thread_cs);
1704 }
1705
1706 static void uia_provider_thread_disconnect_node(SAFEARRAY *sa)
1707 {
1708 struct rb_entry *rb_entry;
1709
1710 EnterCriticalSection(&provider_thread_cs);
1711
1712 /* Provider thread hasn't been started, no nodes to disconnect. */
1713 if (!provider_thread.ref)
1714 goto exit;
1715
1716 rb_entry = rb_get(&provider_thread.node_map, sa);
1717 if (rb_entry)
1718 {
1719 struct uia_provider_thread_map_entry *prov_map;
1720 struct list *cursor, *cursor2;
1721 struct uia_node *node_data;
1722
1723 prov_map = RB_ENTRY_VALUE(rb_entry, struct uia_provider_thread_map_entry, entry);
1724 LIST_FOR_EACH_SAFE(cursor, cursor2, &prov_map->nodes_list)
1725 {
1726 node_data = LIST_ENTRY(cursor, struct uia_node, node_map_list_entry);
1727
1728 list_remove(cursor);
1729 list_remove(&node_data->prov_thread_list_entry);
1730 list_init(&node_data->prov_thread_list_entry);
1731 list_init(&node_data->node_map_list_entry);
1732 node_data->map = NULL;
1733
1734 IWineUiaNode_disconnect(&node_data->IWineUiaNode_iface);
1735 }
1736
1737 rb_remove(&provider_thread.node_map, &prov_map->entry);
1738 SafeArrayDestroy(prov_map->runtime_id);
1739 free(prov_map);
1740 }
1741
1742 exit:
1743 LeaveCriticalSection(&provider_thread_cs);
1744 }
1745
1746 static HRESULT uia_provider_thread_add_node(HUIANODE node, SAFEARRAY *rt_id)
1747 {
1748 struct uia_node *node_data = impl_from_IWineUiaNode((IWineUiaNode *)node);
1749 int prov_type = get_node_provider_type_at_idx(node_data, 0);
1750 struct uia_provider *prov_data;
1751 HRESULT hr = S_OK;
1752
1753 prov_data = impl_from_IWineUiaProvider(node_data->prov[prov_type]);
1754 node_data->nested_node = prov_data->return_nested_node = prov_data->refuse_hwnd_node_providers = TRUE;
1755
1756 TRACE("Adding node %p\n", node);
1757
1758 EnterCriticalSection(&provider_thread_cs);
1759 list_add_tail(&provider_thread.nodes_list, &node_data->prov_thread_list_entry);
1760
1761 /* If we have a runtime ID, create an entry in the rb tree. */
1762 if (rt_id)
1763 {
1764 struct uia_provider_thread_map_entry *prov_map;
1765 struct rb_entry *rb_entry;
1766
1767 if ((rb_entry = rb_get(&provider_thread.node_map, rt_id)))
1768 prov_map = RB_ENTRY_VALUE(rb_entry, struct uia_provider_thread_map_entry, entry);
1769 else
1770 {
1771 prov_map = calloc(1, sizeof(*prov_map));
1772 if (!prov_map)
1773 {
1774 hr = E_OUTOFMEMORY;
1775 goto exit;
1776 }
1777
1778 hr = SafeArrayCopy(rt_id, &prov_map->runtime_id);
1779 if (FAILED(hr))
1780 {
1781 free(prov_map);
1782 goto exit;
1783 }
1784 list_init(&prov_map->nodes_list);
1785 rb_put(&provider_thread.node_map, prov_map->runtime_id, &prov_map->entry);
1786 }
1787
1788 list_add_tail(&prov_map->nodes_list, &node_data->node_map_list_entry);
1789 node_data->map = prov_map;
1790 }
1791
1792 exit:
1793 LeaveCriticalSection(&provider_thread_cs);
1794
1795 return hr;
1796 }
1797
1798 #define WM_GET_OBJECT_UIA_NODE (WM_USER + 1)
1799 #define WM_UIA_PROVIDER_THREAD_STOP (WM_USER + 2)
1800 static LRESULT CALLBACK uia_provider_thread_msg_proc(HWND hwnd, UINT msg, WPARAM wparam,
1801 LPARAM lparam)
1802 {
1803 switch (msg)
1804 {
1805 case WM_GET_OBJECT_UIA_NODE:
1806 {
1807 SAFEARRAY *rt_id = (SAFEARRAY *)wparam;
1808 HUIANODE node = (HUIANODE)lparam;
1809 LRESULT lr;
1810
1811 if (FAILED(uia_provider_thread_add_node(node, rt_id)))
1812 {
1813 WARN("Failed to add node %p to provider thread list.\n", node);
1814 return 0;
1815 }
1816
1817 /*
1818 * LresultFromObject returns an index into the global atom string table,
1819 * which has a valid range of 0xc000-0xffff.
1820 */
1821 lr = LresultFromObject(&IID_IWineUiaNode, 0, (IUnknown *)node);
1822 if ((lr > 0xffff) || (lr < 0xc000))
1823 {
1824 WARN("Got invalid lresult %Ix\n", lr);
1825 lr = 0;
1826 }
1827
1828 return lr;
1829 }
1830
1831 default:
1832 break;
1833 }
1834
1835 return DefWindowProcW(hwnd, msg, wparam, lparam);
1836 }
1837
1838 static DWORD WINAPI uia_provider_thread_proc(void *arg)
1839 {
1840 HANDLE initialized_event = arg;
1841 HWND hwnd;
1842 MSG msg;
1843
1844 CoInitializeEx(NULL, COINIT_MULTITHREADED);
1845 hwnd = CreateWindowW(L"Message", NULL, 0, 0, 0, 0, 0, HWND_MESSAGE, NULL, NULL, NULL);
1846 if (!hwnd)
1847 {
1848 WARN("CreateWindow failed: %ld\n", GetLastError());
1849 CoUninitialize();
1850 FreeLibraryAndExitThread(huia_module, 1);
1851 }
1852
1853 SetWindowLongPtrW(hwnd, GWLP_WNDPROC, (LONG_PTR)uia_provider_thread_msg_proc);
1854 provider_thread.hwnd = hwnd;
1855
1856 /* Initialization complete, thread can now process window messages. */
1857 SetEvent(initialized_event);
1858 TRACE("Provider thread started.\n");
1859 while (GetMessageW(&msg, NULL, 0, 0))
1860 {
1861 if (msg.message == WM_UIA_PROVIDER_THREAD_STOP)
1862 break;
1863 TranslateMessage(&msg);
1864 DispatchMessageW(&msg);
1865 }
1866
1867 TRACE("Shutting down UI Automation provider thread.\n");
1868
1869 DestroyWindow(hwnd);
1870 CoUninitialize();
1871 FreeLibraryAndExitThread(huia_module, 0);
1872 }
1873
1874 static BOOL uia_start_provider_thread(void)
1875 {
1876 BOOL started = TRUE;
1877
1878 EnterCriticalSection(&provider_thread_cs);
1879 if (++provider_thread.ref == 1)
1880 {
1881 HANDLE ready_event;
1882 HANDLE events[2];
1883 HMODULE hmodule;
1884 DWORD wait_obj;
1885
1886 /* Increment DLL reference count. */
1887 GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
1888 (const WCHAR *)uia_start_provider_thread, &hmodule);
1889
1890 list_init(&provider_thread.nodes_list);
1891 rb_init(&provider_thread.node_map, uia_runtime_id_compare);
1892 events[0] = ready_event = CreateEventW(NULL, FALSE, FALSE, NULL);
1893 if (!(provider_thread.hthread = CreateThread(NULL, 0, uia_provider_thread_proc,
1894 ready_event, 0, NULL)))
1895 {
1896 FreeLibrary(hmodule);
1897 started = FALSE;
1898 goto exit;
1899 }
1900
1901 events[1] = provider_thread.hthread;
1902 wait_obj = WaitForMultipleObjects(2, events, FALSE, INFINITE);
1903 if (wait_obj != WAIT_OBJECT_0)
1904 {
1905 CloseHandle(provider_thread.hthread);
1906 started = FALSE;
1907 }
1908
1909 exit:
1910 CloseHandle(ready_event);
1911 if (!started)
1912 {
1913 WARN("Failed to start provider thread\n");
1914 memset(&provider_thread, 0, sizeof(provider_thread));
1915 }
1916 }
1917
1918 LeaveCriticalSection(&provider_thread_cs);
1919 return started;
1920 }
1921
1922 void uia_stop_provider_thread(void)
1923 {
1924 EnterCriticalSection(&provider_thread_cs);
1925 if (!--provider_thread.ref)
1926 {
1927 PostMessageW(provider_thread.hwnd, WM_UIA_PROVIDER_THREAD_STOP, 0, 0);
1928 CloseHandle(provider_thread.hthread);
1929 if (!list_empty(&provider_thread.nodes_list))
1930 ERR("Provider thread shutdown with nodes still in the list\n");
1931 memset(&provider_thread, 0, sizeof(provider_thread));
1932 }
1933 LeaveCriticalSection(&provider_thread_cs);
1934 }
1935
1936 /*
1937 * Pass our IWineUiaNode interface to the provider thread for marshaling. UI
1938 * Automation has to work regardless of whether or not COM is initialized on
1939 * the thread calling UiaReturnRawElementProvider.
1940 */
1941 LRESULT uia_lresult_from_node(HUIANODE huianode)
1942 {
1943 SAFEARRAY *rt_id;
1944 LRESULT lr = 0;
1945 HRESULT hr;
1946
1947 hr = UiaGetRuntimeId(huianode, &rt_id);
1948 if (SUCCEEDED(hr) && uia_start_provider_thread())
1949 lr = SendMessageW(provider_thread.hwnd, WM_GET_OBJECT_UIA_NODE, (WPARAM)rt_id, (LPARAM)huianode);
1950
1951 if (FAILED(hr))
1952 WARN("UiaGetRuntimeId failed with hr %#lx\n", hr);
1953
1954 /*
1955 * LresultFromObject increases refcnt by 1. If LresultFromObject
1956 * failed or wasn't called, this is expected to release the node.
1957 */
1958 UiaNodeRelease(huianode);
1959 SafeArrayDestroy(rt_id);
1960 return lr;
1961 }
1962
1963 /***********************************************************************
1964 * UiaReturnRawElementProvider (uiautomationcore.@)
1965 */
1966 LRESULT WINAPI UiaReturnRawElementProvider(HWND hwnd, WPARAM wparam,
1967 LPARAM lparam, IRawElementProviderSimple *elprov)
1968 {
1969 HUIANODE node;
1970 HRESULT hr;
1971
1972 TRACE("(%p, %Ix, %#Ix, %p)\n", hwnd, wparam, lparam, elprov);
1973
1974 if (!wparam && !lparam && !elprov)
1975 {
1976 FIXME("UIA-to-MSAA bridge not implemented, no provider map to free.\n");
1977 return 0;
1978 }
1979
1980 if (lparam != UiaRootObjectId)
1981 {
1982 FIXME("Unsupported object id %Id, ignoring.\n", lparam);
1983 return 0;
1984 }
1985
1986 hr = create_uia_node_from_elprov(elprov, &node, FALSE);
1987 if (FAILED(hr))
1988 {
1989 WARN("Failed to create HUIANODE with hr %#lx\n", hr);
1990 return 0;
1991 }
1992
1993 return uia_lresult_from_node(node);
1994 }
1995
1996 /***********************************************************************
1997 * UiaDisconnectProvider (uiautomationcore.@)
1998 */
1999 HRESULT WINAPI UiaDisconnectProvider(IRawElementProviderSimple *elprov)
2000 {
2001 SAFEARRAY *sa;
2002 HUIANODE node;
2003 HRESULT hr;
2004
2005 TRACE("(%p)\n", elprov);
2006
2007 hr = create_uia_node_from_elprov(elprov, &node, FALSE);
2008 if (FAILED(hr))
2009 return hr;
2010
2011 hr = UiaGetRuntimeId(node, &sa);
2012 UiaNodeRelease(node);
2013 if (FAILED(hr))
2014 return hr;
2015
2016 if (!sa)
2017 return E_INVALIDARG;
2018
2019 uia_provider_thread_disconnect_node(sa);
2020
2021 SafeArrayDestroy(sa);
2022
2023 return S_OK;
2024 }
Windows API implementation