/[pcsx2_0.9.7]/branch/r3113_0.9.7_beta/3rdparty/wxWidgets/src/msw/ole/access.cpp
ViewVC logotype

Contents of /branch/r3113_0.9.7_beta/3rdparty/wxWidgets/src/msw/ole/access.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 32 - (show annotations) (download)
Tue Sep 7 03:29:01 2010 UTC (9 years, 11 months ago) by william
File size: 61010 byte(s)
branching from upstream revision (http://pcsx2.googlecode.com/svn/trunk
): r3113 to
https://svn.netsolutions.dnsalias.com/websvn/ps2/pcsx2/pcsx2_0.9.7/branch/r3113_0.9.7_beta
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/ole/access.cpp
3 // Purpose: implementation of wxIAccessible and wxAccessible
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 2003-02-12
7 // RCS-ID: $Id: access.cpp 51833 2008-02-16 11:15:07Z JS $
8 // Copyright: (c) 2003 Julian Smart
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #if defined(__BORLANDC__)
24 #pragma hdrstop
25 #endif
26
27 #if wxUSE_OLE && wxUSE_ACCESSIBILITY
28
29 #include "wx/access.h"
30
31 #ifndef WX_PRECOMP
32 #include "wx/msw/wrapwin.h"
33 #include "wx/window.h"
34 #include "wx/log.h"
35 #endif
36
37 // for some compilers, the entire ole2.h must be included, not only oleauto.h
38 #if wxUSE_NORLANDER_HEADERS || defined(__WATCOMC__)
39 #include <ole2.h>
40 #endif
41
42 #include <oleauto.h>
43 #include <oleacc.h>
44
45 #include "wx/msw/ole/oleutils.h"
46
47 #ifndef CHILDID_SELF
48 #define CHILDID_SELF 0
49 #endif
50
51 #ifndef OBJID_CLIENT
52 #define OBJID_CLIENT 0xFFFFFFFC
53 #endif
54
55 // Convert to Windows role
56 int wxConvertToWindowsRole(wxAccRole wxrole);
57
58 // Convert to Windows state
59 long wxConvertToWindowsState(long wxstate);
60
61 // Convert to Windows selection flag
62 int wxConvertToWindowsSelFlag(wxAccSelectionFlags sel);
63
64 // Convert from Windows selection flag
65 wxAccSelectionFlags wxConvertFromWindowsSelFlag(int sel);
66
67 #if wxUSE_VARIANT
68 // ----------------------------------------------------------------------------
69 // wxIEnumVARIANT interface implementation
70 // ----------------------------------------------------------------------------
71
72 class wxIEnumVARIANT : public IEnumVARIANT
73 {
74 public:
75 wxIEnumVARIANT(const wxVariant& variant);
76 virtual ~wxIEnumVARIANT() { }
77
78 DECLARE_IUNKNOWN_METHODS;
79
80 // IEnumVARIANT
81 STDMETHODIMP Next(ULONG celt, VARIANT *rgelt, ULONG *pceltFetched);
82 STDMETHODIMP Skip(ULONG celt);
83 STDMETHODIMP Reset();
84 STDMETHODIMP Clone(IEnumVARIANT **ppenum);
85
86 private:
87 wxVariant m_variant; // List of further variants
88 int m_nCurrent; // Current enum position
89
90 DECLARE_NO_COPY_CLASS(wxIEnumVARIANT)
91 };
92
93 // ----------------------------------------------------------------------------
94 // wxIEnumVARIANT
95 // ----------------------------------------------------------------------------
96
97 BEGIN_IID_TABLE(wxIEnumVARIANT)
98 ADD_IID(Unknown)
99 ADD_IID(EnumVARIANT)
100 END_IID_TABLE;
101
102 IMPLEMENT_IUNKNOWN_METHODS(wxIEnumVARIANT)
103
104 // wxVariant contains a list of further variants.
105 wxIEnumVARIANT::wxIEnumVARIANT(const wxVariant& variant)
106 {
107 m_variant = variant;
108 }
109
110 STDMETHODIMP wxIEnumVARIANT::Next(ULONG celt,
111 VARIANT *rgelt,
112 ULONG *pceltFetched)
113 {
114 wxLogTrace(wxTRACE_OleCalls, wxT("wxIEnumVARIANT::Next"));
115
116 if ( celt > 1 ) {
117 // we only return 1 element at a time - mainly because I'm too lazy to
118 // implement something which you're never asked for anyhow
119 return S_FALSE;
120 }
121
122 if (m_variant.GetType() != wxT("list"))
123 return S_FALSE;
124
125 if ( m_nCurrent < (int) m_variant.GetList().GetCount() ) {
126 if (!wxConvertVariantToOle(m_variant[m_nCurrent++], rgelt[0]))
127 {
128 return S_FALSE;
129 }
130
131 // TODO: should we AddRef if this is an object?
132
133 * pceltFetched = 1;
134 return S_OK;
135 }
136 else {
137 // bad index
138 return S_FALSE;
139 }
140 }
141
142 STDMETHODIMP wxIEnumVARIANT::Skip(ULONG celt)
143 {
144 wxLogTrace(wxTRACE_OleCalls, wxT("wxIEnumVARIANT::Skip"));
145
146 if (m_variant.GetType() != wxT("list"))
147 return S_FALSE;
148
149 m_nCurrent += celt;
150 if ( m_nCurrent < (int) m_variant.GetList().GetCount() )
151 return S_OK;
152
153 // no, can't skip this many elements
154 m_nCurrent -= celt;
155
156 return S_FALSE;
157 }
158
159 STDMETHODIMP wxIEnumVARIANT::Reset()
160 {
161 wxLogTrace(wxTRACE_OleCalls, wxT("wxIEnumVARIANT::Reset"));
162
163 m_nCurrent = 0;
164
165 return S_OK;
166 }
167
168 STDMETHODIMP wxIEnumVARIANT::Clone(IEnumVARIANT **ppenum)
169 {
170 wxLogTrace(wxTRACE_OleCalls, wxT("wxIEnumVARIANT::Clone"));
171
172 wxIEnumVARIANT *pNew = new wxIEnumVARIANT(m_variant);
173 pNew->AddRef();
174 *ppenum = pNew;
175
176 return S_OK;
177 }
178
179 #endif // wxUSE_VARIANT
180
181 // ----------------------------------------------------------------------------
182 // wxIAccessible implementation of IAccessible interface
183 // ----------------------------------------------------------------------------
184
185 class wxIAccessible : public IAccessible
186 {
187 public:
188 wxIAccessible(wxAccessible *pAccessible);
189
190 DECLARE_IUNKNOWN_METHODS;
191
192 // IAccessible
193
194 // Navigation and Hierarchy
195
196 // Retrieves the child element or child object at a given point on the screen.
197 // All visual objects support this method; sound objects do not support it.
198
199 STDMETHODIMP accHitTest(long xLeft, long yLeft, VARIANT* pVarID);
200
201 // Retrieves the specified object's current screen location. All visual objects must
202 // support this method; sound objects do not support it.
203
204 STDMETHODIMP accLocation ( long* pxLeft, long* pyTop, long* pcxWidth, long* pcyHeight, VARIANT varID);
205
206 // Traverses to another user interface element within a container and retrieves the object.
207 // All visual objects must support this method.
208
209 STDMETHODIMP accNavigate ( long navDir, VARIANT varStart, VARIANT* pVarEnd);
210
211 // Retrieves the address of an IDispatch interface for the specified child.
212 // All objects must support this property.
213
214 STDMETHODIMP get_accChild ( VARIANT varChildID, IDispatch** ppDispChild);
215
216 // Retrieves the number of children that belong to this object.
217 // All objects must support this property.
218
219 STDMETHODIMP get_accChildCount ( long* pCountChildren);
220
221 // Retrieves the IDispatch interface of the object's parent.
222 // All objects support this property.
223
224 STDMETHODIMP get_accParent ( IDispatch** ppDispParent);
225
226 // Descriptive Properties and Methods
227
228 // Performs the object's default action. Not all objects have a default
229 // action.
230
231 STDMETHODIMP accDoDefaultAction(VARIANT varID);
232
233 // Retrieves a string that describes the object's default action.
234 // Not all objects have a default action.
235
236 STDMETHODIMP get_accDefaultAction ( VARIANT varID, BSTR* pszDefaultAction);
237
238 // Retrieves a string that describes the visual appearance of the specified object.
239 // Not all objects have a description.
240
241 STDMETHODIMP get_accDescription ( VARIANT varID, BSTR* pszDescription);
242
243 // Retrieves an object's Help property string.
244 // Not all objects support this property.
245
246 STDMETHODIMP get_accHelp ( VARIANT varID, BSTR* pszHelp);
247
248 // Retrieves the full path of the WinHelp file associated with the specified
249 // object and the identifier of the appropriate topic within that file.
250 // Not all objects support this property.
251
252 STDMETHODIMP get_accHelpTopic ( BSTR* pszHelpFile, VARIANT varChild, long* pidTopic);
253
254 // Retrieves the specified object's shortcut key or access key, also known as
255 // the mnemonic. All objects that have a shortcut key or access key support
256 // this property.
257
258 STDMETHODIMP get_accKeyboardShortcut ( VARIANT varID, BSTR* pszKeyboardShortcut);
259
260 // Retrieves the name of the specified object.
261 // All objects support this property.
262
263 STDMETHODIMP get_accName ( VARIANT varID, BSTR* pszName);
264
265 // Retrieves information that describes the role of the specified object.
266 // All objects support this property.
267
268 STDMETHODIMP get_accRole ( VARIANT varID, VARIANT* pVarRole);
269
270 // Retrieves the current state of the specified object.
271 // All objects support this property.
272
273 STDMETHODIMP get_accState ( VARIANT varID, VARIANT* pVarState);
274
275 // Retrieves the value of the specified object.
276 // Not all objects have a value.
277
278 STDMETHODIMP get_accValue ( VARIANT varID, BSTR* pszValue);
279
280 // Selection and Focus
281
282 // Modifies the selection or moves the keyboard focus of the
283 // specified object. All objects that select or receive the
284 // keyboard focus must support this method.
285
286 STDMETHODIMP accSelect ( long flagsSelect, VARIANT varID );
287
288 // Retrieves the object that has the keyboard focus. All objects
289 // that receive the keyboard focus must support this property.
290
291 STDMETHODIMP get_accFocus ( VARIANT* pVarID);
292
293 // Retrieves the selected children of this object. All objects
294 // selected must support this property.
295
296 STDMETHODIMP get_accSelection ( VARIANT * pVarChildren);
297
298 // Obsolete
299
300 STDMETHODIMP put_accName(VARIANT WXUNUSED(varChild), BSTR WXUNUSED(szName)) { return E_FAIL; }
301 STDMETHODIMP put_accValue(VARIANT WXUNUSED(varChild), BSTR WXUNUSED(szName)) { return E_FAIL; }
302
303 // IDispatch
304
305 // Get type info
306
307 STDMETHODIMP GetTypeInfo(unsigned int typeInfo, LCID lcid, ITypeInfo** ppTypeInfo);
308
309 // Get type info count
310
311 STDMETHODIMP GetTypeInfoCount(unsigned int* typeInfoCount);
312
313 // Get ids of names
314
315 STDMETHODIMP GetIDsOfNames(REFIID riid, OLECHAR** names, unsigned int cNames,
316 LCID lcid, DISPID* dispId);
317
318 // Invoke
319
320 STDMETHODIMP Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
321 WORD wFlags, DISPPARAMS *pDispParams,
322 VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
323 unsigned int *puArgErr );
324
325 // Helpers
326
327 // Gets the standard IAccessible interface for the given child or object.
328 // Call Release if this is non-NULL.
329 IAccessible* GetChildStdAccessible(int id);
330
331 // Gets the IAccessible interface for the given child or object.
332 // Call Release if this is non-NULL.
333 IAccessible* GetChildAccessible(int id);
334
335 private:
336 wxAccessible *m_pAccessible; // pointer to C++ class we belong to
337
338 DECLARE_NO_COPY_CLASS(wxIAccessible)
339 };
340
341 // ============================================================================
342 // Implementation
343 // ============================================================================
344
345 // ----------------------------------------------------------------------------
346 // wxIAccessible implementation
347 // ----------------------------------------------------------------------------
348 BEGIN_IID_TABLE(wxIAccessible)
349 ADD_IID(Unknown)
350 ADD_IID(Accessible)
351 ADD_IID(Dispatch)
352 END_IID_TABLE;
353
354 IMPLEMENT_IUNKNOWN_METHODS(wxIAccessible)
355
356 wxIAccessible::wxIAccessible(wxAccessible *pAccessible)
357 {
358 wxASSERT( pAccessible != NULL );
359
360 m_pAccessible = pAccessible;
361 }
362
363 // Retrieves the child element or child object at a given point on the screen.
364 // All visual objects support this method; sound objects do not support it.
365
366 STDMETHODIMP wxIAccessible::accHitTest(long xLeft, long yLeft, VARIANT* pVarID)
367 {
368 wxLogTrace(wxT("access"), wxT("accHitTest"));
369 wxASSERT (m_pAccessible != NULL);
370 if (!m_pAccessible)
371 return E_FAIL;
372
373 wxAccessible* childObject = NULL;
374 int childId = 0;
375 VariantInit(pVarID);
376
377 wxAccStatus status = m_pAccessible->HitTest(wxPoint(xLeft, yLeft), & childId, & childObject);
378
379 if (status == wxACC_FAIL)
380 return E_FAIL;
381
382 if (status == wxACC_NOT_IMPLEMENTED)
383 {
384 // Use standard interface instead.
385 IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
386 if (!stdInterface)
387 return E_NOTIMPL;
388 else
389 return stdInterface->accHitTest(xLeft, yLeft, pVarID);
390 }
391
392 if (childObject)
393 {
394 if (childObject == m_pAccessible)
395 {
396 pVarID->vt = VT_I4;
397 pVarID->lVal = CHILDID_SELF;
398 return S_OK;
399 }
400 else
401 {
402 wxIAccessible* childIA = childObject->GetIAccessible();
403 if (!childIA)
404 return E_NOTIMPL;
405
406 if (childIA->QueryInterface(IID_IDispatch, (LPVOID*) & pVarID->pdispVal) != S_OK)
407 return E_FAIL;
408
409 pVarID->vt = VT_DISPATCH;
410 return S_OK;
411 }
412 }
413 else if (childId > 0)
414 {
415 pVarID->vt = VT_I4;
416 pVarID->lVal = childId;
417 return S_OK;
418 }
419 else
420 {
421 pVarID->vt = VT_EMPTY;
422 return S_FALSE;
423 }
424
425 #if 0
426 // all cases above already cause some return action so below line
427 // is unreachable and cause unnecessary warning
428 return E_NOTIMPL;
429 #endif
430 }
431
432 // Retrieves the specified object's current screen location. All visual objects must
433 // support this method; sound objects do not support it.
434
435 STDMETHODIMP wxIAccessible::accLocation ( long* pxLeft, long* pyTop, long* pcxWidth, long* pcyHeight, VARIANT varID)
436 {
437 wxLogTrace(wxT("access"), wxT("accLocation"));
438 wxASSERT (m_pAccessible != NULL);
439 if (!m_pAccessible)
440 return E_FAIL;
441
442 wxRect rect;
443
444 wxAccStatus status = m_pAccessible->GetLocation(rect, varID.lVal);
445 if (status == wxACC_FAIL)
446 return E_FAIL;
447
448 if (status == wxACC_NOT_IMPLEMENTED)
449 {
450 // Try to use child object directly.
451 if (varID.lVal > 0)
452 {
453 IAccessible* childAccessible = GetChildAccessible(varID.lVal);
454 if (childAccessible)
455 {
456 varID.lVal = 0;
457 HRESULT hResult = childAccessible->accLocation(pxLeft, pyTop, pcxWidth, pcyHeight, varID);
458 childAccessible->Release();
459 return hResult;
460 }
461 else if (m_pAccessible->GetIAccessibleStd())
462 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->accLocation(pxLeft, pyTop, pcxWidth, pcyHeight, varID);
463 }
464 else if (m_pAccessible->GetIAccessibleStd())
465 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->accLocation(pxLeft, pyTop, pcxWidth, pcyHeight, varID);
466 }
467 else
468 {
469 *pxLeft = rect.x;
470 *pyTop = rect.y;
471 *pcxWidth = rect.width;
472 *pcyHeight = rect.height;
473 return S_OK;
474 }
475
476 return E_NOTIMPL;
477 }
478
479 // Traverses to another user interface element within a container and retrieves the object.
480 // All visual objects must support this method.
481
482 STDMETHODIMP wxIAccessible::accNavigate ( long navDir, VARIANT varStart, VARIANT* pVarEnd)
483 {
484 wxASSERT (m_pAccessible != NULL);
485 if (!m_pAccessible)
486 return E_FAIL;
487 wxLogTrace(wxT("access"), wxString(wxT("accNavigate for ")) + m_pAccessible->GetWindow()->GetClassInfo()->GetClassName());
488
489 if ((varStart.vt != VT_I4 && varStart.vt != VT_EMPTY)
490 #if 0
491 // according to MSDN and sources varStart.vt is unsigned
492 // so below line cause warning "Condition is always false"
493 || varStart.vt < 0
494 #endif
495 )
496 {
497 wxLogTrace(wxT("access"), wxT("Invalid arg for accNavigate"));
498 return E_INVALIDARG;
499 }
500
501 wxAccessible* elementObject = NULL;
502 int elementId = 0;
503 VariantInit(pVarEnd);
504 wxNavDir navDirWX = wxNAVDIR_FIRSTCHILD;
505
506 wxString navStr;
507
508 switch (navDir)
509 {
510 case NAVDIR_DOWN:
511 navDirWX = wxNAVDIR_DOWN;
512 navStr = wxT("wxNAVDIR_DOWN");
513 break;
514
515 case NAVDIR_FIRSTCHILD:
516 navDirWX = wxNAVDIR_FIRSTCHILD;
517 navStr = wxT("wxNAVDIR_FIRSTCHILD");
518 break;
519
520 case NAVDIR_LASTCHILD:
521 navDirWX = wxNAVDIR_LASTCHILD;
522 navStr = wxT("wxNAVDIR_LASTCHILD");
523 break;
524
525 case NAVDIR_LEFT:
526 navDirWX = wxNAVDIR_LEFT;
527 navStr = wxT("wxNAVDIR_LEFT");
528 break;
529
530 case NAVDIR_NEXT:
531 navDirWX = wxNAVDIR_NEXT;
532 navStr = wxT("wxNAVDIR_NEXT");
533 break;
534
535 case NAVDIR_PREVIOUS:
536 navDirWX = wxNAVDIR_PREVIOUS;
537 navStr = wxT("wxNAVDIR_PREVIOUS");
538 break;
539
540 case NAVDIR_RIGHT:
541 navDirWX = wxNAVDIR_RIGHT;
542 navStr = wxT("wxNAVDIR_RIGHT");
543 break;
544
545 case NAVDIR_UP:
546 navDirWX = wxNAVDIR_UP;
547 navStr = wxT("wxNAVDIR_UP");
548 break;
549 default:
550 {
551 wxLogTrace(wxT("access"), wxT("Unknown NAVDIR symbol"));
552 break;
553 }
554 }
555 wxLogTrace(wxT("access"), navStr);
556
557 wxAccStatus status = m_pAccessible->Navigate(navDirWX, varStart.lVal, & elementId,
558 & elementObject);
559
560 if (status == wxACC_FAIL)
561 {
562 wxLogTrace(wxT("access"), wxT("wxAccessible::Navigate failed"));
563 return E_FAIL;
564 }
565
566 if (status == wxACC_FALSE)
567 {
568 wxLogTrace(wxT("access"), wxT("wxAccessible::Navigate found no object in this direction"));
569 return S_FALSE;
570 }
571
572 if (status == wxACC_NOT_IMPLEMENTED)
573 {
574 wxLogTrace(wxT("access"), wxT("Navigate not implemented"));
575
576 // Try to use child object directly.
577 if (varStart.vt == VT_I4 && varStart.lVal > 0)
578 {
579 IAccessible* childAccessible = GetChildAccessible(varStart.lVal);
580 if (childAccessible)
581 {
582 varStart.lVal = 0;
583 HRESULT hResult = childAccessible->accNavigate(navDir, varStart, pVarEnd);
584 childAccessible->Release();
585 return hResult;
586 }
587 else if (m_pAccessible->GetIAccessibleStd())
588 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->accNavigate(navDir, varStart, pVarEnd);
589 }
590 else if (m_pAccessible->GetIAccessibleStd())
591 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->accNavigate(navDir, varStart, pVarEnd);
592 }
593 else
594 {
595 if (elementObject)
596 {
597 wxLogTrace(wxT("access"), wxT("Getting wxIAccessible and calling QueryInterface for Navigate"));
598 wxIAccessible* objectIA = elementObject->GetIAccessible();
599 if (!objectIA)
600 {
601 wxLogTrace(wxT("access"), wxT("No wxIAccessible"));
602 return E_FAIL;
603 }
604
605 HRESULT hResult = objectIA->QueryInterface(IID_IDispatch, (LPVOID*) & pVarEnd->pdispVal);
606 if (hResult != S_OK)
607 {
608 wxLogTrace(wxT("access"), wxT("QueryInterface failed"));
609 return E_FAIL;
610 }
611
612 wxLogTrace(wxT("access"), wxT("Called QueryInterface for Navigate"));
613 pVarEnd->vt = VT_DISPATCH;
614 return S_OK;
615 }
616 else if (elementId > 0)
617 {
618 wxLogTrace(wxT("access"), wxT("Returning element id from Navigate"));
619 pVarEnd->vt = VT_I4;
620 pVarEnd->lVal = elementId;
621 return S_OK;
622 }
623 else
624 {
625 wxLogTrace(wxT("access"), wxT("No object in accNavigate"));
626 pVarEnd->vt = VT_EMPTY;
627 return S_FALSE;
628 }
629 }
630
631 wxLogTrace(wxT("access"), wxT("Failing Navigate"));
632 return E_NOTIMPL;
633 }
634
635 // Retrieves the address of an IDispatch interface for the specified child.
636 // All objects must support this property.
637
638 STDMETHODIMP wxIAccessible::get_accChild ( VARIANT varChildID, IDispatch** ppDispChild)
639 {
640 wxLogTrace(wxT("access"), wxT("get_accChild"));
641 wxASSERT (m_pAccessible != NULL);
642 if (!m_pAccessible)
643 return E_FAIL;
644
645 if (varChildID.vt != VT_I4)
646 {
647 wxLogTrace(wxT("access"), wxT("Invalid arg for get_accChild"));
648 return E_INVALIDARG;
649 }
650
651 if (varChildID.lVal == CHILDID_SELF)
652 {
653 *ppDispChild = this;
654 AddRef();
655 return S_OK;
656 }
657
658 wxAccessible* child = NULL;
659
660 wxAccStatus status = m_pAccessible->GetChild(varChildID.lVal, & child);
661 if (status == wxACC_FAIL)
662 {
663 wxLogTrace(wxT("access"), wxT("GetChild failed"));
664 return E_FAIL;
665 }
666
667 if (status == wxACC_NOT_IMPLEMENTED)
668 {
669 // Use standard interface instead.
670 IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
671 if (!stdInterface)
672 return E_NOTIMPL;
673 else
674 {
675 wxLogTrace(wxT("access"), wxT("Using standard interface for get_accChild"));
676 return stdInterface->get_accChild (varChildID, ppDispChild);
677 }
678 }
679 else
680 {
681 if (child)
682 {
683 wxIAccessible* objectIA = child->GetIAccessible();
684 if (!objectIA)
685 return E_NOTIMPL;
686
687 if (objectIA->QueryInterface(IID_IDispatch, (LPVOID*) ppDispChild) != S_OK)
688 {
689 wxLogTrace(wxT("access"), wxT("QueryInterface failed in get_accChild"));
690 return E_FAIL;
691 }
692
693 return S_OK;
694 }
695 else
696 {
697 wxLogTrace(wxT("access"), wxT("Not an accessible object"));
698 return S_FALSE; // Indicates it's not an accessible object
699 }
700 }
701
702 #if 0
703 // all cases above already cause some return action so below line
704 // is unreachable and cause unnecessary warning
705 return E_NOTIMPL;
706 #endif
707 }
708
709 // Retrieves the number of children that belong to this object.
710 // All objects must support this property.
711
712 STDMETHODIMP wxIAccessible::get_accChildCount ( long* pCountChildren)
713 {
714 wxLogTrace(wxT("access"), wxT("get_accChildCount"));
715 wxASSERT (m_pAccessible != NULL);
716 if (!m_pAccessible)
717 return E_FAIL;
718
719 int childCount = 0;
720 wxAccStatus status = m_pAccessible->GetChildCount(& childCount);
721 if (status == wxACC_FAIL)
722 return E_FAIL;
723
724 if (status == wxACC_NOT_IMPLEMENTED)
725 {
726 // Use standard interface instead.
727 IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
728 if (!stdInterface)
729 return E_NOTIMPL;
730 else
731 {
732 wxLogTrace(wxT("access"), wxT("Using standard interface for get_accChildCount"));
733 HRESULT res = stdInterface->get_accChildCount (pCountChildren);
734 wxString str;
735 str.Printf(wxT("Number of children was %d"), (int) (*pCountChildren));
736 wxLogTrace(wxT("access"), str);
737 return res;
738 }
739 }
740 else
741 {
742 * pCountChildren = (long) childCount;
743 return S_OK;
744 }
745
746 #if 0
747 // all cases above already cause some return action so below line
748 // is unreachable and cause unnecessary warning
749 return E_NOTIMPL;
750 #endif
751 }
752
753 // Retrieves the IDispatch interface of the object's parent.
754 // All objects support this property.
755
756 STDMETHODIMP wxIAccessible::get_accParent ( IDispatch** ppDispParent)
757 {
758 wxLogTrace(wxT("access"), wxT("get_accParent"));
759 wxASSERT (m_pAccessible != NULL);
760 if (!m_pAccessible)
761 return E_FAIL;
762
763 wxAccessible* parent = NULL;
764 wxAccStatus status = m_pAccessible->GetParent(& parent);
765
766 if (status == wxACC_FAIL)
767 return E_FAIL;
768
769 // It doesn't seem acceptable to return S_FALSE with a NULL
770 // ppDispParent, so if we have no wxWidgets parent, we leave
771 // it to the standard interface.
772 if (status == wxACC_NOT_IMPLEMENTED || !parent)
773 {
774 wxLogTrace(wxT("access"), wxT("Using standard interface to get the parent."));
775 // Use standard interface instead.
776 IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
777 if (!stdInterface)
778 return E_NOTIMPL;
779 else
780 return stdInterface->get_accParent (ppDispParent);
781 }
782 else
783 {
784 if (parent)
785 {
786 wxIAccessible* objectIA = parent->GetIAccessible();
787 if (!objectIA)
788 return E_FAIL;
789
790 wxLogTrace(wxT("access"), wxT("About to call QueryInterface"));
791 if (objectIA->QueryInterface(IID_IDispatch, (LPVOID*) ppDispParent) != S_OK)
792 {
793 wxLogTrace(wxT("access"), wxT("Failed QueryInterface"));
794 return E_FAIL;
795 }
796
797 wxLogTrace(wxT("access"), wxT("Returning S_OK for get_accParent"));
798 return S_OK;
799 }
800 else
801 {
802 // This doesn't seem to be allowed, despite the documentation,
803 // so we handle it higher up by using the standard interface.
804 wxLogTrace(wxT("access"), wxT("Returning NULL parent because there was none"));
805 *ppDispParent = NULL;
806 return S_FALSE;
807 }
808 }
809
810 #if 0
811 // all cases above already cause some return action so below line
812 // is unreachable and cause unnecessary warning
813 return E_NOTIMPL;
814 #endif
815 }
816
817 // Performs the object's default action. Not all objects have a default
818 // action.
819
820 STDMETHODIMP wxIAccessible::accDoDefaultAction(VARIANT varID)
821 {
822 wxLogTrace(wxT("access"), wxT("accDoDefaultAction"));
823 wxASSERT (m_pAccessible != NULL);
824 if (!m_pAccessible)
825 return E_FAIL;
826
827 if (varID.vt != VT_I4)
828 {
829 wxLogTrace(wxT("access"), wxT("Invalid arg for accDoDefaultAction"));
830 return E_INVALIDARG;
831 }
832
833 wxAccStatus status = m_pAccessible->DoDefaultAction(varID.lVal);
834 if (status == wxACC_FAIL)
835 return E_FAIL;
836
837 if (status == wxACC_NOT_SUPPORTED)
838 return DISP_E_MEMBERNOTFOUND;
839
840 if (status == wxACC_NOT_IMPLEMENTED)
841 {
842 // Try to use child object directly.
843 if (varID.lVal > 0)
844 {
845 IAccessible* childAccessible = GetChildAccessible(varID.lVal);
846 if (childAccessible)
847 {
848 varID.lVal = 0;
849 HRESULT hResult = childAccessible->accDoDefaultAction(varID);
850 childAccessible->Release();
851 return hResult;
852 }
853 else if (m_pAccessible->GetIAccessibleStd())
854 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->accDoDefaultAction(varID);
855 }
856 else if (m_pAccessible->GetIAccessibleStd())
857 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->accDoDefaultAction(varID);
858 }
859 return E_FAIL;
860 }
861
862 // Retrieves a string that describes the object's default action.
863 // Not all objects have a default action.
864
865 STDMETHODIMP wxIAccessible::get_accDefaultAction ( VARIANT varID, BSTR* pszDefaultAction)
866 {
867 wxLogTrace(wxT("access"), wxT("get_accDefaultAction"));
868 wxASSERT (m_pAccessible != NULL);
869 if (!m_pAccessible)
870 return E_FAIL;
871
872 if (varID.vt != VT_I4)
873 {
874 wxLogTrace(wxT("access"), wxT("Invalid arg for get_accDefaultAction"));
875 return E_INVALIDARG;
876 }
877
878 wxString defaultAction;
879 wxAccStatus status = m_pAccessible->GetDefaultAction(varID.lVal, & defaultAction);
880 if (status == wxACC_FAIL)
881 return E_FAIL;
882
883 if (status == wxACC_NOT_SUPPORTED)
884 return DISP_E_MEMBERNOTFOUND;
885
886 if (status == wxACC_NOT_IMPLEMENTED)
887 {
888 // Try to use child object directly.
889 if (varID.lVal > 0)
890 {
891 IAccessible* childAccessible = GetChildAccessible(varID.lVal);
892 if (childAccessible)
893 {
894 varID.lVal = 0;
895 HRESULT hResult = childAccessible->get_accDefaultAction(varID, pszDefaultAction);
896 childAccessible->Release();
897 return hResult;
898 }
899 else if (m_pAccessible->GetIAccessibleStd())
900 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accDefaultAction(varID, pszDefaultAction);
901 }
902 else if (m_pAccessible->GetIAccessibleStd())
903 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accDefaultAction(varID, pszDefaultAction);
904 }
905 else
906 {
907 if (defaultAction.IsEmpty())
908 {
909 * pszDefaultAction = NULL;
910 return S_FALSE;
911 }
912 else
913 {
914 wxBasicString basicString(defaultAction);
915 * pszDefaultAction = basicString.Get();
916 return S_OK;
917 }
918 }
919 return E_FAIL;
920 }
921
922 // Retrieves a string that describes the visual appearance of the specified object.
923 // Not all objects have a description.
924
925 STDMETHODIMP wxIAccessible::get_accDescription ( VARIANT varID, BSTR* pszDescription)
926 {
927 wxLogTrace(wxT("access"), wxT("get_accDescription"));
928 wxASSERT (m_pAccessible != NULL);
929 if (!m_pAccessible)
930 return E_FAIL;
931
932 if (varID.vt != VT_I4)
933 {
934 wxLogTrace(wxT("access"), wxT("Invalid arg for get_accDescription"));
935 return E_INVALIDARG;
936 }
937
938 wxString description;
939 wxAccStatus status = m_pAccessible->GetDescription(varID.lVal, & description);
940 if (status == wxACC_FAIL)
941 return E_FAIL;
942
943 if (status == wxACC_NOT_IMPLEMENTED)
944 {
945 // Try to use child object directly.
946 if (varID.lVal > 0)
947 {
948 IAccessible* childAccessible = GetChildAccessible(varID.lVal);
949 if (childAccessible)
950 {
951 varID.lVal = 0;
952 HRESULT hResult = childAccessible->get_accDescription(varID, pszDescription);
953 childAccessible->Release();
954 return hResult;
955 }
956 else if (m_pAccessible->GetIAccessibleStd())
957 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accDescription(varID, pszDescription);
958 }
959 else if (m_pAccessible->GetIAccessibleStd())
960 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accDescription(varID, pszDescription);
961 }
962 else
963 {
964 if (description.empty())
965 {
966 * pszDescription = NULL;
967 return S_FALSE;
968 }
969 else
970 {
971 wxBasicString basicString(description);
972 * pszDescription = basicString.Get();
973 return S_OK;
974 }
975 }
976 return E_NOTIMPL;
977 }
978
979 // Retrieves an object's Help property string.
980 // Not all objects support this property.
981
982 STDMETHODIMP wxIAccessible::get_accHelp ( VARIANT varID, BSTR* pszHelp)
983 {
984 wxLogTrace(wxT("access"), wxT("get_accHelp"));
985 wxASSERT (m_pAccessible != NULL);
986 if (!m_pAccessible)
987 return E_FAIL;
988
989 if (varID.vt != VT_I4)
990 {
991 wxLogTrace(wxT("access"), wxT("Invalid arg for get_accHelp"));
992 return E_INVALIDARG;
993 }
994
995 wxString helpString;
996 wxAccStatus status = m_pAccessible->GetHelpText(varID.lVal, & helpString);
997 if (status == wxACC_FAIL)
998 return E_FAIL;
999
1000 if (status == wxACC_NOT_IMPLEMENTED)
1001 {
1002 // Try to use child object directly.
1003 if (varID.lVal > 0)
1004 {
1005 IAccessible* childAccessible = GetChildAccessible(varID.lVal);
1006 if (childAccessible)
1007 {
1008 varID.lVal = 0;
1009 HRESULT hResult = childAccessible->get_accHelp(varID, pszHelp);
1010 childAccessible->Release();
1011 return hResult;
1012 }
1013 else if (m_pAccessible->GetIAccessibleStd())
1014 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accHelp(varID, pszHelp);
1015 }
1016 else if (m_pAccessible->GetIAccessibleStd())
1017 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accHelp (varID, pszHelp);
1018 }
1019 else
1020 {
1021 if (helpString.empty())
1022 {
1023 * pszHelp = NULL;
1024 return S_FALSE;
1025 }
1026 else
1027 {
1028 wxBasicString basicString(helpString);
1029 * pszHelp = basicString.Get();
1030 return S_OK;
1031 }
1032 }
1033 return E_NOTIMPL;
1034 }
1035
1036 // Retrieves the full path of the WinHelp file associated with the specified
1037 // object and the identifier of the appropriate topic within that file.
1038 // Not all objects support this property.
1039 // NOTE: not supported by wxWidgets at this time. Use
1040 // GetHelpText instead.
1041
1042 STDMETHODIMP wxIAccessible::get_accHelpTopic ( BSTR* pszHelpFile, VARIANT varChild, long* pidTopic)
1043 {
1044 wxLogTrace(wxT("access"), wxT("get_accHelpTopic"));
1045 wxASSERT (m_pAccessible != NULL);
1046 if (!m_pAccessible)
1047 return E_FAIL;
1048
1049 if (varChild.vt != VT_I4)
1050 {
1051 wxLogTrace(wxT("access"), wxT("Invalid arg for get_accHelpTopic"));
1052 return E_INVALIDARG;
1053 }
1054
1055 wxAccStatus status = wxACC_NOT_IMPLEMENTED;
1056 if (status == wxACC_FAIL)
1057 return E_FAIL;
1058
1059 if (status == wxACC_NOT_IMPLEMENTED)
1060 {
1061 // Try to use child object directly.
1062 if (varChild.lVal > 0)
1063 {
1064 IAccessible* childAccessible = GetChildAccessible(varChild.lVal);
1065 if (childAccessible)
1066 {
1067 varChild.lVal = 0;
1068 HRESULT hResult = childAccessible->get_accHelpTopic(pszHelpFile, varChild, pidTopic);
1069 childAccessible->Release();
1070 return hResult;
1071 }
1072 else if (m_pAccessible->GetIAccessibleStd())
1073 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accHelpTopic(pszHelpFile, varChild, pidTopic);
1074 }
1075 else if (m_pAccessible->GetIAccessibleStd())
1076 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accHelpTopic (pszHelpFile, varChild, pidTopic);
1077 }
1078 return E_NOTIMPL;
1079 }
1080
1081 // Retrieves the specified object's shortcut key or access key, also known as
1082 // the mnemonic. All objects that have a shortcut key or access key support
1083 // this property.
1084
1085 STDMETHODIMP wxIAccessible::get_accKeyboardShortcut ( VARIANT varID, BSTR* pszKeyboardShortcut)
1086 {
1087 wxLogTrace(wxT("access"), wxT("get_accKeyboardShortcut"));
1088 *pszKeyboardShortcut = NULL;
1089
1090 wxASSERT (m_pAccessible != NULL);
1091 if (!m_pAccessible)
1092 return E_FAIL;
1093
1094 if (varID.vt != VT_I4)
1095 {
1096 wxLogTrace(wxT("access"), wxT("Invalid arg for get_accKeyboardShortcut"));
1097 return E_INVALIDARG;
1098 }
1099
1100 wxString keyboardShortcut;
1101 wxAccStatus status = m_pAccessible->GetKeyboardShortcut(varID.lVal, & keyboardShortcut);
1102 if (status == wxACC_FAIL)
1103 return E_FAIL;
1104
1105 if (status == wxACC_NOT_IMPLEMENTED)
1106 {
1107 // Try to use child object directly.
1108 if (varID.lVal > 0)
1109 {
1110 IAccessible* childAccessible = GetChildAccessible(varID.lVal);
1111 if (childAccessible)
1112 {
1113 varID.lVal = 0;
1114 HRESULT hResult = childAccessible->get_accKeyboardShortcut(varID, pszKeyboardShortcut);
1115 childAccessible->Release();
1116 return hResult;
1117 }
1118 else if (m_pAccessible->GetIAccessibleStd())
1119 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accKeyboardShortcut(varID, pszKeyboardShortcut);
1120 }
1121 else if (m_pAccessible->GetIAccessibleStd())
1122 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accKeyboardShortcut (varID, pszKeyboardShortcut);
1123 }
1124 else
1125 {
1126 if (keyboardShortcut.empty())
1127 {
1128 * pszKeyboardShortcut = NULL;
1129 return S_FALSE;
1130 }
1131 else
1132 {
1133 wxBasicString basicString(keyboardShortcut);
1134 * pszKeyboardShortcut = basicString.Get();
1135 return S_OK;
1136 }
1137 }
1138 return E_NOTIMPL;
1139 }
1140
1141 // Retrieves the name of the specified object.
1142 // All objects support this property.
1143
1144 STDMETHODIMP wxIAccessible::get_accName ( VARIANT varID, BSTR* pszName)
1145 {
1146 wxLogTrace(wxT("access"), wxT("get_accName"));
1147 *pszName = NULL;
1148
1149 wxASSERT (m_pAccessible != NULL);
1150 if (!m_pAccessible)
1151 return E_FAIL;
1152
1153 if (varID.vt != VT_I4)
1154 {
1155 wxLogTrace(wxT("access"), wxT("Invalid arg for get_accName"));
1156 return E_INVALIDARG;
1157 }
1158
1159 wxString name;
1160
1161 wxAccStatus status = m_pAccessible->GetName(varID.lVal, & name);
1162
1163 if (status == wxACC_FAIL)
1164 return E_FAIL;
1165
1166 if (status == wxACC_NOT_IMPLEMENTED)
1167 {
1168 // Try to use child object directly.
1169 if (varID.lVal > 0)
1170 {
1171 IAccessible* childAccessible = GetChildAccessible(varID.lVal);
1172 if (childAccessible)
1173 {
1174 varID.lVal = 0;
1175 HRESULT hResult = childAccessible->get_accName(varID, pszName);
1176 childAccessible->Release();
1177 return hResult;
1178 }
1179 else if (m_pAccessible->GetIAccessibleStd())
1180 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accName(varID, pszName);
1181 }
1182 else if (m_pAccessible->GetIAccessibleStd())
1183 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accName (varID, pszName);
1184 }
1185 else
1186 {
1187 wxBasicString basicString(name);
1188 *pszName = basicString.Get();
1189 return S_OK;
1190 }
1191 return E_NOTIMPL;
1192 }
1193
1194 // Retrieves information that describes the role of the specified object.
1195 // All objects support this property.
1196
1197 STDMETHODIMP wxIAccessible::get_accRole ( VARIANT varID, VARIANT* pVarRole)
1198 {
1199 wxLogTrace(wxT("access"), wxT("get_accRole"));
1200 wxASSERT (m_pAccessible != NULL);
1201 if (!m_pAccessible)
1202 return E_FAIL;
1203
1204 if (varID.vt != VT_I4)
1205 {
1206 wxLogTrace(wxT("access"), wxT("Invalid arg for get_accRole"));
1207 return E_INVALIDARG;
1208 }
1209
1210 VariantInit(pVarRole);
1211
1212 wxAccRole role = wxROLE_NONE;
1213
1214 wxAccStatus status = m_pAccessible->GetRole(varID.lVal, & role);
1215
1216 if (status == wxACC_FAIL)
1217 return E_FAIL;
1218
1219 if (status == wxACC_NOT_IMPLEMENTED)
1220 {
1221 // Try to use child object directly.
1222 if (varID.lVal > 0)
1223 {
1224 IAccessible* childAccessible = GetChildAccessible(varID.lVal);
1225 if (childAccessible)
1226 {
1227 varID.lVal = 0;
1228 HRESULT hResult = childAccessible->get_accRole(varID, pVarRole);
1229 childAccessible->Release();
1230 return hResult;
1231 }
1232 else if (m_pAccessible->GetIAccessibleStd())
1233 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accRole(varID, pVarRole);
1234 }
1235 else if (m_pAccessible->GetIAccessibleStd())
1236 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accRole (varID, pVarRole);
1237 }
1238 else
1239 {
1240 if (role == wxROLE_NONE)
1241 {
1242 pVarRole->vt = VT_EMPTY;
1243 return S_OK;
1244 }
1245
1246 pVarRole->lVal = wxConvertToWindowsRole(role);
1247 pVarRole->vt = VT_I4;
1248
1249 return S_OK;
1250 }
1251 return E_NOTIMPL;
1252 }
1253
1254 // Retrieves the current state of the specified object.
1255 // All objects support this property.
1256
1257 STDMETHODIMP wxIAccessible::get_accState ( VARIANT varID, VARIANT* pVarState)
1258 {
1259 wxLogTrace(wxT("access"), wxT("get_accState"));
1260 wxASSERT (m_pAccessible != NULL);
1261 if (!m_pAccessible)
1262 return E_FAIL;
1263
1264 if (varID.vt != VT_I4 && varID.vt != VT_EMPTY)
1265 {
1266 wxLogTrace(wxT("access"), wxT("Invalid arg for get_accState"));
1267 return E_INVALIDARG;
1268 }
1269
1270 long wxstate = 0;
1271
1272 wxAccStatus status = m_pAccessible->GetState(varID.lVal, & wxstate);
1273 if (status == wxACC_FAIL)
1274 return E_FAIL;
1275
1276 if (status == wxACC_NOT_IMPLEMENTED)
1277 {
1278 // Try to use child object directly.
1279 if (varID.lVal > 0)
1280 {
1281 IAccessible* childAccessible = GetChildAccessible(varID.lVal);
1282 if (childAccessible)
1283 {
1284 varID.lVal = 0;
1285 HRESULT hResult = childAccessible->get_accState(varID, pVarState);
1286 childAccessible->Release();
1287 return hResult;
1288 }
1289 else if (m_pAccessible->GetIAccessibleStd())
1290 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accState(varID, pVarState);
1291 }
1292 else if (m_pAccessible->GetIAccessibleStd())
1293 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accState (varID, pVarState);
1294 }
1295 else
1296 {
1297 long state = wxConvertToWindowsState(wxstate);
1298 pVarState->lVal = state;
1299 pVarState->vt = VT_I4;
1300 return S_OK;
1301 }
1302 return E_NOTIMPL;
1303 }
1304
1305 // Retrieves the value of the specified object.
1306 // Not all objects have a value.
1307
1308 STDMETHODIMP wxIAccessible::get_accValue ( VARIANT varID, BSTR* pszValue)
1309 {
1310 wxLogTrace(wxT("access"), wxT("get_accValue"));
1311 wxASSERT (m_pAccessible != NULL);
1312 if (!m_pAccessible)
1313 return E_FAIL;
1314
1315 if (varID.vt != VT_I4)
1316 {
1317 wxLogTrace(wxT("access"), wxT("Invalid arg for get_accValue"));
1318 return E_INVALIDARG;
1319 }
1320
1321 wxString strValue;
1322
1323 wxAccStatus status = m_pAccessible->GetValue(varID.lVal, & strValue);
1324
1325 if (status == wxACC_FAIL)
1326 return E_FAIL;
1327
1328 if (status == wxACC_NOT_IMPLEMENTED)
1329 {
1330 // Try to use child object directly.
1331 if (varID.lVal > 0)
1332 {
1333 IAccessible* childAccessible = GetChildAccessible(varID.lVal);
1334 if (childAccessible)
1335 {
1336 varID.lVal = 0;
1337 HRESULT hResult = childAccessible->get_accValue(varID, pszValue);
1338 childAccessible->Release();
1339 return hResult;
1340 }
1341 else if (m_pAccessible->GetIAccessibleStd())
1342 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accValue(varID, pszValue);
1343 }
1344 else if (m_pAccessible->GetIAccessibleStd())
1345 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accValue (varID, pszValue);
1346 }
1347 else
1348 {
1349 wxBasicString basicString(strValue);
1350 * pszValue = basicString.Get();
1351 return S_OK;
1352 }
1353 return E_NOTIMPL;
1354 }
1355
1356 // Modifies the selection or moves the keyboard focus of the
1357 // specified object. All objects that select or receive the
1358 // keyboard focus must support this method.
1359
1360 STDMETHODIMP wxIAccessible::accSelect ( long flagsSelect, VARIANT varID )
1361 {
1362 wxLogTrace(wxT("access"), wxT("get_accSelect"));
1363 wxASSERT (m_pAccessible != NULL);
1364 if (!m_pAccessible)
1365 return E_FAIL;
1366
1367 if (varID.vt != VT_I4 && varID.vt != VT_EMPTY)
1368 {
1369 wxLogTrace(wxT("access"), wxT("Invalid arg for accSelect"));
1370 return E_INVALIDARG;
1371 }
1372
1373 wxAccSelectionFlags wxsel = wxConvertFromWindowsSelFlag(flagsSelect);
1374
1375 wxAccStatus status = m_pAccessible->Select(varID.lVal, wxsel);
1376 if (status == wxACC_FAIL)
1377 return E_FAIL;
1378
1379 if (status == wxACC_NOT_IMPLEMENTED)
1380 {
1381 // Try to use child object directly.
1382 if (varID.lVal > 0 && varID.lVal > 0)
1383 {
1384 IAccessible* childAccessible = GetChildAccessible(varID.lVal);
1385 if (childAccessible)
1386 {
1387 varID.lVal = 0;
1388 HRESULT hResult = childAccessible->accSelect(flagsSelect, varID);
1389 childAccessible->Release();
1390 return hResult;
1391 }
1392 else if (m_pAccessible->GetIAccessibleStd())
1393 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->accSelect(flagsSelect, varID);
1394 }
1395 else if (m_pAccessible->GetIAccessibleStd())
1396 return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->accSelect(flagsSelect, varID);
1397 }
1398 else
1399 return S_OK;
1400
1401 return E_NOTIMPL;
1402 }
1403
1404 // Retrieves the object that has the keyboard focus. All objects
1405 // that receive the keyboard focus must support this property.
1406
1407 STDMETHODIMP wxIAccessible::get_accFocus ( VARIANT* pVarID)
1408 {
1409 wxLogTrace(wxT("access"), wxT("get_accFocus"));
1410 wxASSERT (m_pAccessible != NULL);
1411 if (!m_pAccessible)
1412 return E_FAIL;
1413
1414 wxAccessible* childObject = NULL;
1415 int childId = 0;
1416 VariantInit(pVarID);
1417
1418 wxAccStatus status = m_pAccessible->GetFocus(& childId, & childObject);
1419 if (status == wxACC_FAIL)
1420 return E_FAIL;
1421
1422 if (status == wxACC_NOT_IMPLEMENTED)
1423 {
1424 // Use standard interface instead.
1425 IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
1426 if (!stdInterface)
1427 return E_NOTIMPL;
1428 else
1429 return stdInterface->get_accFocus (pVarID);
1430 }
1431 if (childObject)
1432 {
1433 if (childObject == m_pAccessible)
1434 {
1435 pVarID->vt = VT_I4;
1436 pVarID->lVal = CHILDID_SELF;
1437 return S_OK; }
1438 else
1439 {
1440 wxIAccessible* childIA = childObject->GetIAccessible();
1441 if (!childIA)
1442 return E_NOTIMPL;
1443
1444 if (childIA->QueryInterface(IID_IDispatch, (LPVOID*) & pVarID->pdispVal) != S_OK)
1445 return E_FAIL;
1446
1447 pVarID->vt = VT_DISPATCH;
1448 return S_OK;
1449 }
1450 }
1451 else if (childId > 0)
1452 {
1453 pVarID->vt = VT_I4;
1454 pVarID->lVal = childId;
1455 return S_OK;
1456 }
1457 else
1458 {
1459 pVarID->vt = VT_EMPTY;
1460 return S_FALSE;
1461 }
1462
1463 #if 0
1464 // all cases above already cause some return action so below line
1465 // is unreachable and cause unnecessary warning
1466 return E_NOTIMPL;
1467 #endif
1468 }
1469
1470 // Retrieves the selected children of this object. All objects
1471 // selected must support this property.
1472
1473 STDMETHODIMP wxIAccessible::get_accSelection ( VARIANT * pVarChildren)
1474 {
1475 #if wxUSE_VARIANT
1476 wxLogTrace(wxT("access"), wxT("get_accSelection"));
1477 wxASSERT (m_pAccessible != NULL);
1478 if (!m_pAccessible)
1479 return E_FAIL;
1480
1481 VariantInit(pVarChildren);
1482
1483 wxVariant selections;
1484 wxAccStatus status = m_pAccessible->GetSelections(& selections);
1485 if (status == wxACC_FAIL)
1486 return E_FAIL;
1487
1488 if (status == wxACC_NOT_IMPLEMENTED)
1489 {
1490 // Use standard interface instead.
1491 IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
1492 if (!stdInterface)
1493 return E_NOTIMPL;
1494 else
1495 return stdInterface->get_accSelection (pVarChildren);
1496 }
1497 else
1498 {
1499 if (selections.GetType() == wxT("long"))
1500 {
1501 pVarChildren->vt = VT_I4;
1502 pVarChildren->lVal = selections.GetLong();
1503
1504 return S_OK;
1505 }
1506 else if (selections.GetType() == wxT("void*"))
1507 {
1508 wxAccessible* childObject = (wxAccessible*) selections.GetVoidPtr();
1509 wxIAccessible* childIA = childObject->GetIAccessible();
1510 if (!childIA)
1511 return E_NOTIMPL;
1512
1513 if (childIA->QueryInterface(IID_IDispatch, (LPVOID*) & pVarChildren->pdispVal) != S_OK)
1514 return E_FAIL;
1515
1516 pVarChildren->vt = VT_DISPATCH;
1517
1518 return S_OK;
1519 }
1520 else if (selections.GetType() == wxT("list"))
1521 {
1522 // TODO: should we AddRef for every "void*" member??
1523
1524 wxIEnumVARIANT* enumVariant = new wxIEnumVARIANT(selections);
1525 enumVariant->AddRef();
1526
1527 pVarChildren->vt = VT_UNKNOWN;
1528 pVarChildren->punkVal = enumVariant;
1529
1530 return S_OK;
1531 }
1532 }
1533 #else
1534 wxUnusedVar(pVarChildren);
1535 #endif // wxUSE_VARIANT
1536
1537 return E_NOTIMPL;
1538 }
1539
1540 // Get type info
1541
1542 STDMETHODIMP wxIAccessible::GetTypeInfo(unsigned int WXUNUSED(typeInfo), LCID WXUNUSED(lcid), ITypeInfo** ppTypeInfo)
1543 {
1544 *ppTypeInfo = NULL;
1545 return E_NOTIMPL;
1546 }
1547
1548 // Get type info count
1549
1550 STDMETHODIMP wxIAccessible::GetTypeInfoCount(unsigned int* typeInfoCount)
1551 {
1552 *typeInfoCount = 0;
1553 return E_NOTIMPL;
1554 }
1555
1556 // Get ids of names
1557
1558 STDMETHODIMP wxIAccessible::GetIDsOfNames(REFIID WXUNUSED(riid), OLECHAR** WXUNUSED(names), unsigned int WXUNUSED(cNames),
1559 LCID WXUNUSED(lcid), DISPID* WXUNUSED(dispId))
1560 {
1561 return E_NOTIMPL;
1562 }
1563
1564 // Invoke
1565
1566 STDMETHODIMP wxIAccessible::Invoke(DISPID WXUNUSED(dispIdMember), REFIID WXUNUSED(riid), LCID WXUNUSED(lcid),
1567 WORD WXUNUSED(wFlags), DISPPARAMS *WXUNUSED(pDispParams),
1568 VARIANT *WXUNUSED(pVarResult), EXCEPINFO *WXUNUSED(pExcepInfo),
1569 unsigned int *WXUNUSED(puArgErr) )
1570 {
1571 return E_NOTIMPL;
1572 }
1573
1574 // Gets the standard IAccessible interface for the given child or object.
1575 // Call Release if this is non-NULL.
1576 IAccessible* wxIAccessible::GetChildStdAccessible(int id)
1577 {
1578 if (id == 0)
1579 {
1580 IAccessible* obj = (IAccessible*)m_pAccessible->GetIAccessibleStd();
1581
1582 obj->AddRef();
1583 return obj;
1584 }
1585 else
1586 {
1587 VARIANT var;
1588 VariantInit(& var);
1589 var.vt = VT_I4;
1590 var.lVal = id;
1591 IDispatch* pDispatch = NULL;
1592 if (S_OK == get_accChild ( var, & pDispatch))
1593 {
1594 IAccessible* childAccessible = NULL;
1595 if (pDispatch->QueryInterface(IID_IAccessible, (LPVOID*) & childAccessible) == S_OK)
1596 {
1597 pDispatch->Release();
1598 wxIAccessible* c = (wxIAccessible*) childAccessible;
1599 IAccessible* stdChildAccessible = (IAccessible*) c->m_pAccessible->GetIAccessibleStd();
1600 stdChildAccessible->AddRef();
1601 childAccessible->Release();
1602 return stdChildAccessible;
1603 }
1604 else
1605 {
1606 pDispatch->Release();
1607 }
1608 }
1609 }
1610
1611 #if 0
1612 {
1613 // Loop until we find the right id
1614 long nChildren = 0;
1615 this->get_accChildCount(& nChildren);
1616
1617 int i;
1618 for (i = 0; i < nChildren; i++)
1619 {
1620 long obtained = 0;
1621 VARIANT var;
1622 VariantInit(& var);
1623 var.vt = VT_I4;
1624 if (S_OK == AccessibleChildren(this, i, 1, & var, &obtained))
1625 {
1626 if (var.lVal == id)
1627 {
1628 VariantInit(& var);
1629 var.vt = VT_DISPATCH;
1630 if (S_OK == AccessibleChildren(this, i, 1, & var, &obtained))
1631 {
1632 IAccessible* childAccessible = NULL;
1633 if (var.pdispVal->QueryInterface(IID_IAccessible, (LPVOID*) & childAccessible) == S_OK)
1634 {
1635 var.pdispVal->Release();
1636 return childAccessible;
1637 }
1638 else
1639 {
1640 var.pdispVal->Release();
1641 }
1642 }
1643 }
1644 break;
1645 }
1646 }
1647 }
1648 #endif
1649 return NULL;
1650 }
1651
1652 // Gets the IAccessible interface for the given child or object.
1653 // Call Release if this is non-NULL.
1654 IAccessible* wxIAccessible::GetChildAccessible(int id)
1655 {
1656 if (id == 0)
1657 {
1658 IAccessible* obj = this;
1659
1660 obj->AddRef();
1661 return obj;
1662 }
1663 else
1664 {
1665 VARIANT var;
1666 VariantInit(& var);
1667 var.vt = VT_I4;
1668 var.lVal = id;
1669 IDispatch* pDispatch = NULL;
1670 if (S_OK == get_accChild ( var, & pDispatch))
1671 {
1672 IAccessible* childAccessible = NULL;
1673 if (pDispatch->QueryInterface(IID_IAccessible, (LPVOID*) & childAccessible) == S_OK)
1674 {
1675 pDispatch->Release();
1676 return childAccessible;
1677 }
1678 else
1679 {
1680 pDispatch->Release();
1681 }
1682 }
1683 }
1684 return NULL;
1685 }
1686
1687 // ----------------------------------------------------------------------------
1688 // wxAccessible implementation
1689 // ----------------------------------------------------------------------------
1690
1691 // ctors
1692
1693 // common part of all ctors
1694 void wxAccessible::Init()
1695 {
1696 m_pIAccessibleStd = NULL;
1697 m_pIAccessible = new wxIAccessible(this);
1698 m_pIAccessible->AddRef();
1699 }
1700
1701 wxAccessible::wxAccessible(wxWindow* win)
1702 : wxAccessibleBase(win)
1703 {
1704 Init();
1705 }
1706
1707 wxAccessible::~wxAccessible()
1708 {
1709 m_pIAccessible->Release();
1710 if (m_pIAccessibleStd)
1711 ((IAccessible*)m_pIAccessibleStd)->Release();
1712 }
1713
1714 // Gets or creates a standard interface for this object.
1715 void* wxAccessible::GetIAccessibleStd()
1716 {
1717 if (m_pIAccessibleStd)
1718 return m_pIAccessibleStd;
1719
1720 if (GetWindow())
1721 {
1722 HRESULT retCode = ::CreateStdAccessibleObject((HWND) GetWindow()->GetHWND(),
1723 OBJID_CLIENT, IID_IAccessible, (void**) & m_pIAccessibleStd);
1724 if (retCode == S_OK)
1725 return m_pIAccessibleStd;
1726 else
1727 {
1728 m_pIAccessibleStd = NULL;
1729 return NULL;
1730 }
1731 }
1732 return NULL;
1733 }
1734
1735 // Sends an event when something changes in an accessible object.
1736 void wxAccessible::NotifyEvent(int eventType, wxWindow* window, wxAccObject objectType,
1737 int objectId)
1738 {
1739 ::NotifyWinEvent((DWORD) eventType, (HWND) window->GetHWND(),
1740 (LONG) objectType, (LONG) objectId);
1741 }
1742
1743 // Utilities
1744
1745 // Convert to Windows role
1746 int wxConvertToWindowsRole(wxAccRole wxrole)
1747 {
1748 switch (wxrole)
1749 {
1750 case wxROLE_NONE:
1751 return 0;
1752 case wxROLE_SYSTEM_ALERT:
1753 return ROLE_SYSTEM_ALERT;
1754 case wxROLE_SYSTEM_ANIMATION:
1755 return ROLE_SYSTEM_ANIMATION;
1756 case wxROLE_SYSTEM_APPLICATION:
1757 return ROLE_SYSTEM_APPLICATION;
1758 case wxROLE_SYSTEM_BORDER:
1759 return ROLE_SYSTEM_BORDER;
1760 case wxROLE_SYSTEM_BUTTONDROPDOWN:
1761 return ROLE_SYSTEM_BUTTONDROPDOWN;
1762 case wxROLE_SYSTEM_BUTTONDROPDOWNGRID:
1763 return ROLE_SYSTEM_BUTTONDROPDOWNGRID;
1764 case wxROLE_SYSTEM_BUTTONMENU:
1765 return ROLE_SYSTEM_BUTTONMENU;
1766 case wxROLE_SYSTEM_CARET:
1767 return ROLE_SYSTEM_CARET;
1768 case wxROLE_SYSTEM_CELL:
1769 return ROLE_SYSTEM_CELL;
1770 case wxROLE_SYSTEM_CHARACTER:
1771 return ROLE_SYSTEM_CHARACTER;
1772 case wxROLE_SYSTEM_CHART:
1773 return ROLE_SYSTEM_CHART;
1774 case wxROLE_SYSTEM_CHECKBUTTON:
1775 return ROLE_SYSTEM_CHECKBUTTON;
1776 case wxROLE_SYSTEM_CLIENT:
1777 return ROLE_SYSTEM_CLIENT;
1778 case wxROLE_SYSTEM_CLOCK:
1779 return ROLE_SYSTEM_CLOCK;
1780 case wxROLE_SYSTEM_COLUMN:
1781 return ROLE_SYSTEM_COLUMN;
1782 case wxROLE_SYSTEM_COLUMNHEADER:
1783 return ROLE_SYSTEM_COLUMNHEADER;
1784 case wxROLE_SYSTEM_COMBOBOX:
1785 return ROLE_SYSTEM_COMBOBOX;
1786 case wxROLE_SYSTEM_CURSOR:
1787 return ROLE_SYSTEM_CURSOR;
1788 case wxROLE_SYSTEM_DIAGRAM:
1789 return ROLE_SYSTEM_DIAGRAM;
1790 case wxROLE_SYSTEM_DIAL:
1791 return ROLE_SYSTEM_DIAL;
1792 case wxROLE_SYSTEM_DIALOG:
1793 return ROLE_SYSTEM_DIALOG;
1794 case wxROLE_SYSTEM_DOCUMENT:
1795 return ROLE_SYSTEM_DOCUMENT;
1796 case wxROLE_SYSTEM_DROPLIST:
1797 return ROLE_SYSTEM_DROPLIST;
1798 case wxROLE_SYSTEM_EQUATION:
1799 return ROLE_SYSTEM_EQUATION;
1800 case wxROLE_SYSTEM_GRAPHIC:
1801 return ROLE_SYSTEM_GRAPHIC;
1802 case wxROLE_SYSTEM_GRIP:
1803 return ROLE_SYSTEM_GRIP;
1804 case wxROLE_SYSTEM_GROUPING:
1805 return ROLE_SYSTEM_GROUPING;
1806 case wxROLE_SYSTEM_HELPBALLOON:
1807 return ROLE_SYSTEM_HELPBALLOON;
1808 case wxROLE_SYSTEM_HOTKEYFIELD:
1809 return ROLE_SYSTEM_HOTKEYFIELD;
1810 case wxROLE_SYSTEM_INDICATOR:
1811 return ROLE_SYSTEM_INDICATOR;
1812 case wxROLE_SYSTEM_LINK:
1813 return ROLE_SYSTEM_LINK;
1814 case wxROLE_SYSTEM_LIST:
1815 return ROLE_SYSTEM_LIST;
1816 case wxROLE_SYSTEM_LISTITEM:
1817 return ROLE_SYSTEM_LISTITEM;
1818 case wxROLE_SYSTEM_MENUBAR:
1819 return ROLE_SYSTEM_MENUBAR;
1820 case wxROLE_SYSTEM_MENUITEM:
1821 return ROLE_SYSTEM_MENUITEM;
1822 case wxROLE_SYSTEM_MENUPOPUP:
1823 return ROLE_SYSTEM_MENUPOPUP;
1824 case wxROLE_SYSTEM_OUTLINE:
1825 return ROLE_SYSTEM_OUTLINE;
1826 case wxROLE_SYSTEM_OUTLINEITEM:
1827 return ROLE_SYSTEM_OUTLINEITEM;
1828 case wxROLE_SYSTEM_PAGETAB:
1829 return ROLE_SYSTEM_PAGETAB;
1830 case wxROLE_SYSTEM_PAGETABLIST:
1831 return ROLE_SYSTEM_PAGETABLIST;
1832 case wxROLE_SYSTEM_PANE:
1833 return ROLE_SYSTEM_PANE;
1834 case wxROLE_SYSTEM_PROGRESSBAR:
1835 return ROLE_SYSTEM_PROGRESSBAR;
1836 case wxROLE_SYSTEM_PROPERTYPAGE:
1837 return ROLE_SYSTEM_PROPERTYPAGE;
1838 case wxROLE_SYSTEM_PUSHBUTTON:
1839 return ROLE_SYSTEM_PUSHBUTTON;
1840 case wxROLE_SYSTEM_RADIOBUTTON:
1841 return ROLE_SYSTEM_RADIOBUTTON;
1842 case wxROLE_SYSTEM_ROW:
1843 return ROLE_SYSTEM_ROW;
1844 case wxROLE_SYSTEM_ROWHEADER:
1845 return ROLE_SYSTEM_ROWHEADER;
1846 case wxROLE_SYSTEM_SCROLLBAR:
1847 return ROLE_SYSTEM_SCROLLBAR;
1848 case wxROLE_SYSTEM_SEPARATOR:
1849 return ROLE_SYSTEM_SEPARATOR;
1850 case wxROLE_SYSTEM_SLIDER:
1851 return ROLE_SYSTEM_SLIDER;
1852 case wxROLE_SYSTEM_SOUND:
1853 return ROLE_SYSTEM_SOUND;
1854 case wxROLE_SYSTEM_SPINBUTTON:
1855 return ROLE_SYSTEM_SPINBUTTON;
1856 case wxROLE_SYSTEM_STATICTEXT:
1857 return ROLE_SYSTEM_STATICTEXT;
1858 case wxROLE_SYSTEM_STATUSBAR:
1859 return ROLE_SYSTEM_STATUSBAR;
1860 case wxROLE_SYSTEM_TABLE:
1861 return ROLE_SYSTEM_TABLE;
1862 case wxROLE_SYSTEM_TEXT:
1863 return ROLE_SYSTEM_TEXT;
1864 case wxROLE_SYSTEM_TITLEBAR:
1865 return ROLE_SYSTEM_TITLEBAR;
1866 case wxROLE_SYSTEM_TOOLBAR:
1867 return ROLE_SYSTEM_TOOLBAR;
1868 case wxROLE_SYSTEM_TOOLTIP:
1869 return ROLE_SYSTEM_TOOLTIP;
1870 case wxROLE_SYSTEM_WHITESPACE:
1871 return ROLE_SYSTEM_WHITESPACE;
1872 case wxROLE_SYSTEM_WINDOW:
1873 return ROLE_SYSTEM_WINDOW;
1874 }
1875 return 0;
1876 }
1877
1878 // Convert to Windows state
1879 long wxConvertToWindowsState(long wxstate)
1880 {
1881 long state = 0;
1882 if (wxstate & wxACC_STATE_SYSTEM_ALERT_HIGH)
1883 state |= STATE_SYSTEM_ALERT_HIGH;
1884
1885 if (wxstate & wxACC_STATE_SYSTEM_ALERT_MEDIUM)
1886 state |= STATE_SYSTEM_ALERT_MEDIUM;
1887
1888 if (wxstate & wxACC_STATE_SYSTEM_ALERT_LOW)
1889 state |= STATE_SYSTEM_ALERT_LOW;
1890
1891 if (wxstate & wxACC_STATE_SYSTEM_ANIMATED)
1892 state |= STATE_SYSTEM_ANIMATED;
1893
1894 if (wxstate & wxACC_STATE_SYSTEM_BUSY)
1895 state |= STATE_SYSTEM_BUSY;
1896
1897 if (wxstate & wxACC_STATE_SYSTEM_CHECKED)
1898 state |= STATE_SYSTEM_CHECKED;
1899
1900 if (wxstate & wxACC_STATE_SYSTEM_COLLAPSED)
1901 state |= STATE_SYSTEM_COLLAPSED;
1902
1903 if (wxstate & wxACC_STATE_SYSTEM_DEFAULT)
1904 state |= STATE_SYSTEM_DEFAULT;
1905
1906 if (wxstate & wxACC_STATE_SYSTEM_EXPANDED)
1907 state |= STATE_SYSTEM_EXPANDED;
1908
1909 if (wxstate & wxACC_STATE_SYSTEM_EXTSELECTABLE)
1910 state |= STATE_SYSTEM_EXTSELECTABLE;
1911
1912 if (wxstate & wxACC_STATE_SYSTEM_FLOATING)
1913 state |= STATE_SYSTEM_FLOATING;
1914
1915 if (wxstate & wxACC_STATE_SYSTEM_FOCUSABLE)
1916 state |= STATE_SYSTEM_FOCUSABLE;
1917
1918 if (wxstate & wxACC_STATE_SYSTEM_FOCUSED)
1919 state |= STATE_SYSTEM_FOCUSED;
1920
1921 if (wxstate & wxACC_STATE_SYSTEM_HOTTRACKED)
1922 state |= STATE_SYSTEM_HOTTRACKED;
1923
1924 if (wxstate & wxACC_STATE_SYSTEM_INVISIBLE)
1925 state |= STATE_SYSTEM_INVISIBLE;
1926
1927 if (wxstate & wxACC_STATE_SYSTEM_INVISIBLE)
1928 state |= STATE_SYSTEM_INVISIBLE;
1929
1930 if (wxstate & wxACC_STATE_SYSTEM_MIXED)
1931 state |= STATE_SYSTEM_MIXED;
1932
1933 if (wxstate & wxACC_STATE_SYSTEM_MULTISELECTABLE)
1934 state |= STATE_SYSTEM_MULTISELECTABLE;
1935
1936 if (wxstate & wxACC_STATE_SYSTEM_OFFSCREEN)
1937 state |= STATE_SYSTEM_OFFSCREEN;
1938
1939 if (wxstate & wxACC_STATE_SYSTEM_PRESSED)
1940 state |= STATE_SYSTEM_PRESSED;
1941
1942 // if (wxstate & wxACC_STATE_SYSTEM_PROTECTED)
1943 // state |= STATE_SYSTEM_PROTECTED;
1944
1945 if (wxstate & wxACC_STATE_SYSTEM_READONLY)
1946 state |= STATE_SYSTEM_READONLY;
1947
1948 if (wxstate & wxACC_STATE_SYSTEM_SELECTABLE)
1949 state |= STATE_SYSTEM_SELECTABLE;
1950
1951 if (wxstate & wxACC_STATE_SYSTEM_SELECTED)
1952 state |= STATE_SYSTEM_SELECTED;
1953
1954 if (wxstate & wxACC_STATE_SYSTEM_SELFVOICING)
1955 state |= STATE_SYSTEM_SELFVOICING;
1956
1957 if (wxstate & wxACC_STATE_SYSTEM_UNAVAILABLE)
1958 state |= STATE_SYSTEM_UNAVAILABLE;
1959
1960 return state;
1961 }
1962
1963 // Convert to Windows selection flag
1964 int wxConvertToWindowsSelFlag(wxAccSelectionFlags wxsel)
1965 {
1966 int sel = 0;
1967
1968 if (wxsel & wxACC_SEL_TAKEFOCUS)
1969 sel |= SELFLAG_TAKEFOCUS;
1970 if (wxsel & wxACC_SEL_TAKESELECTION)
1971 sel |= SELFLAG_TAKESELECTION;
1972 if (wxsel & wxACC_SEL_EXTENDSELECTION)
1973 sel |= SELFLAG_EXTENDSELECTION;
1974 if (wxsel & wxACC_SEL_ADDSELECTION)
1975 sel |= SELFLAG_ADDSELECTION;
1976 if (wxsel & wxACC_SEL_REMOVESELECTION)
1977 sel |= SELFLAG_REMOVESELECTION;
1978 return sel;
1979 }
1980
1981 // Convert from Windows selection flag
1982 wxAccSelectionFlags wxConvertFromWindowsSelFlag(int sel)
1983 {
1984 int wxsel = 0;
1985
1986 if (sel & SELFLAG_TAKEFOCUS)
1987 wxsel |= wxACC_SEL_TAKEFOCUS;
1988 if (sel & SELFLAG_TAKESELECTION)
1989 wxsel |= wxACC_SEL_TAKESELECTION;
1990 if (sel & SELFLAG_EXTENDSELECTION)
1991 wxsel |= wxACC_SEL_EXTENDSELECTION;
1992 if (sel & SELFLAG_ADDSELECTION)
1993 wxsel |= wxACC_SEL_ADDSELECTION;
1994 if (sel & SELFLAG_REMOVESELECTION)
1995 wxsel |= wxACC_SEL_REMOVESELECTION;
1996 return (wxAccSelectionFlags) wxsel;
1997 }
1998
1999
2000 #endif // wxUSE_OLE && wxUSE_ACCESSIBILITY

  ViewVC Help
Powered by ViewVC 1.1.22