1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22 #include "stdafx.h"
23 #include "UAccCOM2.h"
24 #include "MAccessible.h"
25
26 #include <algorithm>
27 #include "AccAction.h"
28
29 #include <com/sun/star/accessibility/XAccessibleText.hpp>
30 #include <com/sun/star/accessibility/XAccessibleEditableText.hpp>
31 #include <com/sun/star/accessibility/XAccessibleImage.hpp>
32 #include <com/sun/star/accessibility/XAccessibleTable.hpp>
33 #include <com/sun/star/accessibility/XAccessibleExtendedComponent.hpp>
34 #include <com/sun/star/accessibility/XAccessibleAction.hpp>
35 #include <com/sun/star/accessibility/XAccessibleKeyBinding.hpp>
36 #include <com/sun/star/accessibility/XAccessibleHyperText.hpp>
37 #include <com/sun/star/accessibility/XAccessibleHyperlink.hpp>
38 #include <com/sun/star/accessibility/XAccessibleRelationSet.hpp>
39 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
40 #include <com/sun/star/accessibility/AccessibleRole.hpp>
41 #include <com/sun/star/accessibility/XAccessibleGroupPosition.hpp>
42 #include <com/sun/star/accessibility/XAccessibleValue.hpp>
43 #include <com/sun/star/accessibility/XAccessibleExtendedAttributes.hpp>
44 #include <com/sun/star/style/LineSpacing.hpp>
45 #include <com/sun/star/style/TabStop.hpp>
46 #include <com/sun/star/container/XIndexReplace.hpp>
47
48 #include "act.hxx"
49
50 using namespace com::sun::star::accessibility::AccessibleStateType;
51
52 // IA2 states mapping, and name
53 // maintenance the consistency, change one array, change the three all
54 long IA2_STATES[] =
55 {
56 IA2_STATE_ACTIVE, // = 0x1;
57 IA2_STATE_ARMED, // = 0x2;
58 IA2_STATE_DEFUNCT, // = 0x4;
59 IA2_STATE_EDITABLE, // = 0x8;
60 IA2_STATE_HORIZONTAL, // = 0x10;
61 IA2_STATE_ICONIFIED, // = 0x20;
62 IA2_STATE_INVALID_ENTRY, // = 0x80;
63 IA2_STATE_MANAGES_DESCENDANTS, // = 0x100;
64 IA2_STATE_MODAL, // = 0x200;
65 IA2_STATE_MULTI_LINE, // = 0x400;
66 IA2_STATE_OPAQUE, // = 0x800;
67 IA2_STATE_REQUIRED, // = 0x2000;
68 IA2_STATE_SELECTABLE_TEXT, // = 0x3000;
69 IA2_STATE_SINGLE_LINE, // = 0x4000;
70 IA2_STATE_STALE, // = 0x8000;
71 IA2_STATE_SUPPORTS_AUTOCOMPLETION, // = 0x10000;
72 IA2_STATE_TRANSIENT, //= 0x20000;
73 IA2_STATE_VERTICAL // = 0x40000;
74 };
75 /*
76
77 <=== map ===>
78
79 */
80 short UNO_STATES[] =
81 {
82 ACTIVE, // = (sal_Int16)1;
83 ARMED, // = (sal_Int16)2;
84 DEFUNC, // = (sal_Int16)5;
85 EDITABLE, // = (sal_Int16)6;
86 HORIZONTAL, // = (sal_Int16)12;
87 ICONIFIED, // = (sal_Int16)13;
88 -1, //IA2_STATE_INVALID_ENTRY
89 MANAGES_DESCENDANTS, // = (sal_Int16)15;
90 MODAL, // = (sal_Int16)16;
91 MULTI_LINE, // = (sal_Int16)17;
92 OPAQUE, // = (sal_Int16)19;
93 -1, //IA2_STATE_REQUIRED
94 -1, //IA2_STATE_SELECTABLE_TEXT
95 SINGLE_LINE, // = (sal_Int16)26;
96 STALE, // = (sal_Int16)27;
97 -1, //IA2_STATE_SUPPORTS_AUTOCOMPLETION
98 TRANSIENT, //IA2_STATE_TRANSIENT
99 VERTICAL // = (sal_Int16)29;
100 };
101
102 // <=== map ===>
103
104 BSTR IA2_STATES_NAME[] =
105 {
106 _T("Active"),
107 _T("Armed"),
108 _T("Defunct"),
109 _T("Editable"),
110 _T("Horizontal"),
111 _T("Iconified"),
112 _T("Invalid Entry"),
113 _T("Manages Descendants"),
114 _T("Modal"),
115 _T("Multi Line"),
116 _T("Opaque"),
117 _T("Required"),
118 _T("Selectable Text"),
119 _T("Single Line"),
120 _T("Stale"),
121 _T("Supports Autocompletion"),
122 _T("Transient"),
123 _T("Vertical")
124 };
125
126 // IA2 states mapping, and name
127 // maintenance the consistency. change one, change them all
128
129 BSTR UNO_ALL_STATES[] =
130 {
131 _T("INVALID"), // INVALID ( 0 )
132 _T("ACTIVE"), // ACTIVE ( 1 )
133 _T("ARMED"), // ARMED ( 2 )
134 _T("BUSY"), // BUSY ( 3 )
135 _T("CHECKED"), // CHECKED ( 4 )
136 _T("DEFUNC"), // DEFUNC ( 5 )
137 _T("EDITABLE"), // EDITABLE ( 6 )
138 _T("ENABLED"), // ENABLED ( 7 )
139 _T("EXPANDABLE"), // EXPANDABLE ( 8 )
140 _T("EXPANDED"), // EXPANDED ( 9 )
141 _T("FOCUSABLE"), // FOCUSABLE ( 10 )
142 _T("FOCUSED"), // FOCUSED ( 11 )
143 _T("HORIZONTAL"), // HORIZONTAL ( 12 )
144 _T("ICONIFIED"), // ICONIFIED ( 13 )
145 _T("INDETERMINATE"), // INDETERMINATE ( 14 )
146 _T("MANAGES_DESCENDANTS"),// MANAGES_DESCENDANTS ( 15 )
147 _T("MODAL"), // MODAL ( 16 )
148 _T("MULTI_LINE"), // MULTI_LINE ( 17 )
149 _T("MULTI_SELECTABLE"), // MULTI_SELECTABLE ( 18 )
150 _T("OPAQUE"), // OPAQUE ( 19 )
151 _T("PRESSED"), // PRESSED ( 20 )
152 _T("RESIZABLE"), // RESIZABLE ( 21 )
153 _T("SELECTABLE"), // SELECTABLE ( 22 )
154 _T("SELECTED"), // SELECTED ( 23 )
155 _T("SENSITIVE"), // SENSITIVE ( 24 )
156 _T("SHOWING"), // SHOWING ( 25 )
157 _T("SINGLE_LINE"), // SINGLE_LINE ( 26 )
158 _T("STALE"), // STALE ( 27 )
159 _T("TRANSIENT"), // TRANSIENT ( 28 )
160 _T("VERTICAL"), // VERTICAL ( 29 )
161 _T("VISIBLE"), // VISIBLE ( 30 )
162 _T("MOVEABLE"), // MOVEABLE ( 31 )
163 _T("OFFSCREEN"), // OFFSCREEN ( 32 )
164 _T("COLLAPSE"), // COLLAPSE ( 33 )
165 _T("DEFAULT") // DEFAULT ( 34 )
166 };
167
168
169 using namespace com::sun::star::accessibility::AccessibleRole;
170
171
172
173 #define QUERYXINTERFACE(ainterface) \
174 { \
175 if(pXAcc == NULL) \
176 return FALSE; \
177 pRContext = pXAcc->getAccessibleContext(); \
178 if( !pRContext.is() ) \
179 { \
180 return FALSE; \
181 } \
182 Reference<X##ainterface> pRXI(pRContext,UNO_QUERY);\
183 if( !pRXI.is() ) \
184 { \
185 return FALSE; \
186 } \
187 *ppXI = (XInterface*)pRXI.get(); \
188 return TRUE; \
189 }
190
191 #define ISDESTROY() \
192 if(m_isDestroy) \
193 return S_FALSE;
194
195
196 AccObjectManagerAgent* CMAccessible::g_pAgent = NULL;
197
CMAccessible()198 CMAccessible::CMAccessible():
199 m_iRole(0x00),
200 m_dState(0x00),
201 m_dChildID(0x00),
202 m_dFocusChildID(UACC_NO_FOCUS),
203 m_hwnd(NULL),
204 m_pIParent(NULL),
205 m_pszName(NULL),
206 m_pszValue(NULL),
207 m_pszDescription(NULL),
208 m_isDestroy(FALSE),
209 m_pszActionDescription(NULL),
210 m_pXAction(NULL),
211 m_bRequiresSave(FALSE),
212 pUNOInterface(NULL)
213 {
214 m_sLocation.m_dLeft=0;
215 m_sLocation.m_dTop = 0;
216 m_sLocation.m_dWidth=0;
217 m_sLocation.m_dHeight=0;
218 CEnumVariant::Create(&m_pEnumVar);
219 m_containedObjects.clear();
220 }
221
~CMAccessible()222 CMAccessible::~CMAccessible()
223 {
224 if(m_pszName!=NULL)
225 {
226 SAFE_SYSFREESTRING(m_pszName);
227 m_pszName=NULL;
228 }
229 if(m_pszValue!=NULL)
230 {
231 SAFE_SYSFREESTRING(m_pszValue);
232 m_pszValue=NULL;
233 }
234 if(m_pszDescription!=NULL)
235 {
236 SAFE_SYSFREESTRING(m_pszDescription);
237 m_pszDescription=NULL;
238 }
239
240 if(m_pszActionDescription!=NULL)
241 {
242 SAFE_SYSFREESTRING(m_pszActionDescription);
243 m_pszActionDescription=NULL;
244 }
245
246 if(m_pIParent)
247 {
248 m_pIParent->Release();
249 m_pIParent=NULL;
250 }
251 pRef = NULL;
252 m_pEnumVar->Release();
253 m_containedObjects.clear();
254 pRContext = NULL;
255 }
256
257 /**
258 * Returns the Parent IAccessible interface pointer to AT.
259 * It should add reference, and the client should release the component.
260 * It should return E_FAIL when the parent point is null.
261 * @param ppdispParent [in,out] used to return the parent interface point.
262 * when the point is null, should return null.
263 * @return S_OK if successful and E_FAIL if the m_pIParent is NULL.
264 */
get_accParent(IDispatch ** ppdispParent)265 STDMETHODIMP CMAccessible::get_accParent(IDispatch **ppdispParent)
266 {
267
268 CHECK_ENABLE_INF
269 ENTER_PROTECTED_BLOCK
270 ISDESTROY()
271 // #CHECK#
272 if(ppdispParent == NULL)
273 {
274 return E_INVALIDARG;
275 }
276
277 if(m_pIParent)
278 {
279 *ppdispParent = m_pIParent;
280 (*ppdispParent)->AddRef();
281 return S_OK;
282 }
283 else if(m_hwnd)
284 {
285 HRESULT hr = AccessibleObjectFromWindow(m_hwnd, OBJID_WINDOW, IID_IAccessible, (void**)ppdispParent);
286 if( ! SUCCEEDED( hr ) || ! ppdispParent )
287 {
288 return S_FALSE;
289 }
290 return S_OK;
291 }
292 return S_FALSE;
293
294 LEAVE_PROTECTED_BLOCK
295 }
296
297 /**
298 * Returns child count of current COM object.
299 * @param pcountChildren [in,out] used to return the children count.
300 * @return S_OK if successful.
301 */
get_accChildCount(long * pcountChildren)302 STDMETHODIMP CMAccessible::get_accChildCount(long *pcountChildren)
303 {
304
305 CHECK_ENABLE_INF
306 ENTER_PROTECTED_BLOCK
307 ISDESTROY()
308 // #CHECK#
309 if(pcountChildren == NULL)
310 {
311 return E_INVALIDARG;
312 }
313
314 if(!pUNOInterface)
315 return S_FALSE;
316
317 Reference< XAccessibleContext > pRContext = pUNOInterface->getAccessibleContext();
318 if( pRContext.is() )
319 {
320 *pcountChildren = pRContext->getAccessibleChildCount();
321 }
322
323 return S_OK;
324
325 LEAVE_PROTECTED_BLOCK
326 }
327
328 /**
329 * Returns child interface pointer for AT according to input child ID.
330 * @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID,
331 * the child ID specify child index from 0 to children count, 0 stands for object self.
332 * @param ppdispChild, [in,out] use to return the child interface point.
333 * @return S_OK if successful and S_FALSE if failure.
334 */
get_accChild(VARIANT varChild,IDispatch ** ppdispChild)335 STDMETHODIMP CMAccessible::get_accChild(VARIANT varChild, IDispatch **ppdispChild)
336 {
337
338 CHECK_ENABLE_INF
339 ENTER_PROTECTED_BLOCK
340 ISDESTROY()
341 // #CHECK#
342 if(ppdispChild == NULL)
343 {
344 return E_INVALIDARG;
345 }
346 if(varChild.vt==VT_I4)
347 {
348 //get child interface pointer due to child ID
349 if(varChild.lVal==CHILDID_SELF)
350 {
351 AddRef();
352 *ppdispChild = this;
353 return S_OK;
354 }
355 *ppdispChild = GetChildInterface(varChild.lVal);
356 if((*ppdispChild) == NULL)
357 return E_FAIL;
358 (*ppdispChild)->AddRef();
359 return S_OK;
360 }
361 return S_FALSE;
362
363 LEAVE_PROTECTED_BLOCK
364 }
365
366 /**
367 * Returns the accessible name of the current COM object self or its one child to AT.
368 * @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID,
369 * the child ID specify child index from 0 to children count, 0 stands for object self.
370 * @param pszName, [in,out] use to return the name of the proper object.
371 * @return S_OK if successful and S_FALSE if failure.
372 */
get_accName(VARIANT varChild,BSTR * pszName)373 STDMETHODIMP CMAccessible::get_accName(VARIANT varChild, BSTR *pszName)
374 {
375
376 CHECK_ENABLE_INF
377 ENTER_PROTECTED_BLOCK
378 ISDESTROY()
379 // #CHECK#
380 if(pszName == NULL)
381 {
382 return E_INVALIDARG;
383 }
384 if(varChild.vt==VT_I4)
385 {
386 if(varChild.lVal==CHILDID_SELF)
387 {
388 SAFE_SYSFREESTRING(*pszName);
389 *pszName = SysAllocString(m_pszName);
390 return S_OK;
391 }
392
393 long lVal = varChild.lVal;
394 varChild.lVal = CHILDID_SELF;
395 IMAccessible *pChild = this->GetChildInterface(lVal);
396 if(!pChild)
397 return E_FAIL;
398 return pChild->get_accName(varChild,pszName);
399 }
400 return S_FALSE;
401
402 LEAVE_PROTECTED_BLOCK
403 }
404
405 /**
406 * Returns the accessible value of the current COM object self or its one child to AT.
407 * @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID,
408 * the child ID specify child index from 0 to children count, 0 stands for object self.
409 * @param pszValue, [in,out] use to return the value of the proper object.
410 * @return S_OK if successful and S_FALSE if failure.
411 */
get_accValue(VARIANT varChild,BSTR * pszValue)412 STDMETHODIMP CMAccessible::get_accValue(VARIANT varChild, BSTR *pszValue)
413 {
414
415 CHECK_ENABLE_INF
416 ENTER_PROTECTED_BLOCK
417 ISDESTROY()
418 // #CHECK#
419 if( pszValue == NULL )
420 {
421 return E_INVALIDARG;
422 }
423 if( varChild.vt==VT_I4 )
424 {
425 if(varChild.lVal==CHILDID_SELF)
426 {
427 if(m_dState & STATE_SYSTEM_PROTECTED)
428 return E_ACCESSDENIED;
429
430 if ( m_pszValue !=NULL && wcslen(m_pszValue) == 0 )
431 return S_OK;
432
433 SAFE_SYSFREESTRING(*pszValue);
434 *pszValue = SysAllocString(m_pszValue);
435 return S_OK;
436 }
437
438 long lVal = varChild.lVal;
439 varChild.lVal = CHILDID_SELF;
440 IMAccessible *pChild = this->GetChildInterface(lVal);
441 if(!pChild)
442 return E_FAIL;
443 return pChild->get_accValue(varChild,pszValue);
444 }
445 return S_FALSE;
446
447 LEAVE_PROTECTED_BLOCK
448 }
449
450 /**
451 * Returns the accessible description of the current COM object self or its one child to AT.
452 * @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID,
453 * the child ID specify child index from 0 to children count, 0 stands for object self.
454 * @param pszDescription, [in,out] use to return the description of the proper object.
455 * @return S_OK if successful and E_FAIL if failure.
456 */
get_accDescription(VARIANT varChild,BSTR * pszDescription)457 STDMETHODIMP CMAccessible::get_accDescription(VARIANT varChild, BSTR *pszDescription)
458 {
459
460 CHECK_ENABLE_INF
461 ENTER_PROTECTED_BLOCK
462 ISDESTROY()
463 // #CHECK#
464 if(pszDescription == NULL)
465 {
466 return E_INVALIDARG;
467 }
468 if(varChild.vt==VT_I4)
469 {
470 if(varChild.lVal==CHILDID_SELF)
471 {
472 SAFE_SYSFREESTRING(*pszDescription);
473 *pszDescription = SysAllocString(m_pszDescription);
474 return S_OK;
475 }
476
477 long lVal = varChild.lVal;
478 varChild.lVal = CHILDID_SELF;
479 IMAccessible *pChild = this->GetChildInterface(lVal);
480 if(!pChild)
481 return E_FAIL;
482 return pChild->get_accDescription(varChild,pszDescription);
483 }
484 return S_FALSE;
485
486 LEAVE_PROTECTED_BLOCK
487 }
488
489 /**
490 * Returns the accessible role of the current COM object self or its one child to AT.
491 * @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID,
492 * the child ID specify child index from 0 to children count, 0 stands for object self.
493 * @param pvarRole, [in,out] use to return the role of the proper object.
494 * @return S_OK if successful and S_FALSE if failure.
495 */
get_accRole(VARIANT varChild,VARIANT * pvarRole)496 STDMETHODIMP CMAccessible::get_accRole(VARIANT varChild, VARIANT *pvarRole)
497 {
498
499 CHECK_ENABLE_INF
500 ENTER_PROTECTED_BLOCK
501 ISDESTROY()
502 // #CHECK#
503 if(pvarRole == NULL)
504 {
505 return E_INVALIDARG;
506 }
507 if(varChild.vt == VT_I4)
508 {
509
510 if(varChild.lVal == CHILDID_SELF)
511 {
512 if( m_iRole < IA2_ROLE_CAPTION )
513 {
514 VariantInit(pvarRole);
515 pvarRole->vt = VT_I4;
516 pvarRole->lVal = m_iRole;
517 }
518 else
519 {
520 VariantInit(pvarRole);
521 pvarRole->vt = VT_I4;
522 pvarRole->lVal = ROLE_SYSTEM_CLIENT;
523 }
524 return S_OK;
525 }
526
527
528 long lVal = varChild.lVal;
529 varChild.lVal = CHILDID_SELF;
530 IMAccessible *pChild = this->GetChildInterface(lVal);
531 if(!pChild)
532 return E_FAIL;
533 return pChild->get_accRole(varChild,pvarRole);
534 }
535 return S_FALSE;
536
537 LEAVE_PROTECTED_BLOCK
538 }
539
540 /**
541 * Returns the accessible state of the current COM object self or its one child to AT.
542 * @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID,
543 * the child ID specify child index from 0 to children count, 0 stands for object self.
544 * @param pvarState, [in,out] use to return the state of the proper object.
545 * @return S_OK if successful and S_FALSE if failure.
546 */
get_accState(VARIANT varChild,VARIANT * pvarState)547 STDMETHODIMP CMAccessible::get_accState(VARIANT varChild, VARIANT *pvarState)
548 {
549
550 CHECK_ENABLE_INF
551 ENTER_PROTECTED_BLOCK
552 ISDESTROY()
553 // #CHECK#
554 if(pvarState == NULL)
555 {
556 return E_INVALIDARG;
557 }
558 if(varChild.vt==VT_I4)
559 {
560 if(varChild.lVal == CHILDID_SELF)
561 {
562 if(pUNOInterface)
563 {
564 Reference< XAccessibleContext > pContext = pUNOInterface->getAccessibleContext();
565 if(pContext.is())
566 {
567 // add the STATE_SYSTEM_LINKED state
568 Reference< XAccessibleHypertext > pRHypertext(pContext,UNO_QUERY);
569 if(pRHypertext.is())
570 {
571 if( pRHypertext->getHyperLinkCount() > 0 )
572 m_dState |= STATE_SYSTEM_LINKED;
573 else
574 m_dState &= ~STATE_SYSTEM_LINKED;
575 }
576 else
577 m_dState &= ~STATE_SYSTEM_LINKED;
578 }
579 }
580
581 VariantInit(pvarState);
582 pvarState->vt = VT_I4;
583 pvarState->lVal = m_dState;
584 return S_OK;
585 }
586
587 long lVal = varChild.lVal;
588 varChild.lVal = CHILDID_SELF;
589 IMAccessible *pChild = this->GetChildInterface(lVal);
590 if(!pChild)
591 return E_FAIL;
592 return pChild->get_accState(varChild,pvarState);
593 }
594 return S_FALSE;
595
596 LEAVE_PROTECTED_BLOCK
597 }
598
599 /**
600 * Returns the accessible helpString of the current COM object self or its one child to AT.
601 * @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID,
602 * the child ID specify child index from 0 to children count, 0 stands for object self.
603 * @param pszHelp, [in,out] use to return the helpString of the proper object.
604 * @return S_OK if successful and E_FAIL if failure.
605 */
get_accHelp(VARIANT,BSTR *)606 STDMETHODIMP CMAccessible::get_accHelp(VARIANT, BSTR *)
607 {
608 return E_NOTIMPL;
609 }
610
611 /**
612 * Returns the accessible HelpTopic of the current COM object self or its one child to AT.
613 * @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID,
614 * the child ID specify child index from 0 to children count, 0 stands for object self.
615 * @param pszHelpFile, [in,out] use to return the HelpTopic of the proper object.
616 * @param pidTopic, use to return the HelpTopic ID of the proper object.
617 * @return S_OK if successful and E_FAIL if failure.
618 * Not implemented yet
619 */
get_accHelpTopic(BSTR *,VARIANT,long *)620 STDMETHODIMP CMAccessible::get_accHelpTopic(BSTR *, VARIANT, long *)
621 {
622 return E_NOTIMPL;
623 }
624
GetMnemonicChar(const::rtl::OUString & aStr,WCHAR * wStr)625 static void GetMnemonicChar( const ::rtl::OUString& aStr, WCHAR* wStr)
626 {
627 int nLen = aStr.pData->length;
628 int i = 0;
629 WCHAR* text = aStr.pData->buffer;
630
631 while ( i < nLen )
632 {
633 if ( text[i] == L'~' )
634 if ( text[i+1] != L'~' )
635 {
636 wStr[0] = text[i+1];
637 break;
638 }
639 i++;
640 }
641 }
642
643 /**
644 * Returns the accessible keyboard shortcut of the current COM object self or its one child to AT.
645 * @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID,
646 * the child ID specify child index from 0 to children count, 0 stands for object self.
647 * @param pszKeyboardShortcut, [in,out] use to return the kbshortcut of the proper object.
648 * @return S_OK if successful and E_FAIL if failure.
649 */
get_accKeyboardShortcut(VARIANT varChild,BSTR * pszKeyboardShortcut)650 STDMETHODIMP CMAccessible::get_accKeyboardShortcut(VARIANT varChild, BSTR *pszKeyboardShortcut)
651 {
652
653 CHECK_ENABLE_INF
654 ENTER_PROTECTED_BLOCK
655
656 ISDESTROY()
657 // #CHECK#
658 if(pszKeyboardShortcut == NULL)
659 {
660 return E_INVALIDARG;
661 }
662
663 if(varChild.vt==VT_I4)
664 {
665 if(varChild.lVal == CHILDID_SELF)
666 {
667 if( pUNOInterface )
668 {
669 Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext();
670 if( !pRContext.is() )
671 return S_FALSE;
672
673 Reference<XAccessibleAction> pRXI(pRContext,UNO_QUERY);
674
675 OLECHAR wString[64]={0};
676
677 if( pRXI.is() && pRXI->getAccessibleActionCount() >= 1)
678 {
679 Reference< XAccessibleKeyBinding > binding = pRXI->getAccessibleActionKeyBinding(0);
680 if( binding.is() )
681 {
682 long nCount = binding->getAccessibleKeyBindingCount();
683 if(nCount >= 1)
684 {
685 CAccAction::GetkeyBindingStrByXkeyBinding( binding->getAccessibleKeyBinding(0),wString );
686 }
687 }
688 }
689 if(wString[0] == 0)
690 {
691 Reference<XAccessibleRelationSet> pRrelationSet = pRContext->getAccessibleRelationSet();
692 if(!pRrelationSet.is())
693 {
694 return S_FALSE;
695 }
696
697 long nRelCount = pRrelationSet->getRelationCount();
698
699 // Modified by Steve Yin, for SODC_1552
700 if( /*nRelCount <= 0 &&*/ m_iRole == ROLE_SYSTEM_TEXT )
701 {
702 VARIANT varParentRole;
703 VariantInit( &varParentRole );
704
705 m_pIParent->get_accRole(varChild, &varParentRole);
706
707 if( m_pIParent && varParentRole.lVal == ROLE_SYSTEM_COMBOBOX ) // edit in comoboBox
708 {
709 m_pIParent->get_accKeyboardShortcut(varChild, pszKeyboardShortcut);
710 return S_OK;
711 }
712 }
713
714 AccessibleRelation *paccRelation = NULL;
715 AccessibleRelation accRelation;
716 for(int i=0; i<nRelCount ; i++)
717 {
718 if( pRrelationSet->getRelation(i).RelationType == 6 )
719 {
720 accRelation = pRrelationSet->getRelation(i);
721 paccRelation = &accRelation;
722 }
723 }
724
725 if(paccRelation == NULL)
726 return S_FALSE;
727
728 Sequence< Reference< XInterface > > xTargets = paccRelation->TargetSet;
729 Reference<XInterface> pRAcc = xTargets[0];
730
731 XAccessible* pXAcc = (XAccessible*)pRAcc.get();
732
733 Reference<XAccessibleContext> pRLebelContext = pXAcc->getAccessibleContext();
734 if(!pRLebelContext.is())
735 return S_FALSE;
736
737 pRrelationSet = pRLebelContext->getAccessibleRelationSet();
738 nRelCount = pRrelationSet->getRelationCount();
739
740 paccRelation = NULL;
741 for(int j=0; j<nRelCount ; j++)
742 {
743 if( pRrelationSet->getRelation(j).RelationType == 5 )
744 {
745 accRelation = pRrelationSet->getRelation(j);
746 paccRelation = &accRelation;
747 }
748 }
749
750 if(paccRelation)
751 {
752 xTargets = paccRelation->TargetSet;
753 pRAcc = xTargets[0];
754 if(pUNOInterface != (XAccessible*)pRAcc.get())
755 return S_FALSE;
756 }
757
758 Reference<XAccessibleExtendedComponent> pRXIE(pRLebelContext,UNO_QUERY);
759 if(!pRXIE.is())
760 return S_FALSE;
761
762 ::rtl::OUString ouStr = pRXIE->getTitledBorderText();
763 WCHAR key[2] = {NULL};
764 GetMnemonicChar(ouStr, key);
765 if(key[0] != 0)
766 {
767 wcscat(wString, L"Alt+");
768 wcscat(wString, key);
769 }
770 else
771 return S_FALSE;
772 }
773
774 SAFE_SYSFREESTRING(*pszKeyboardShortcut);
775 *pszKeyboardShortcut = SysAllocString(wString);
776
777 return S_OK;
778 }
779 else
780 {
781 return S_FALSE;
782 }
783 }
784
785 long lVal = varChild.lVal;
786 varChild.lVal = CHILDID_SELF;
787 IMAccessible *pChild = this->GetChildInterface(lVal);
788 if(!pChild)
789 return E_FAIL;
790
791 return pChild->get_accKeyboardShortcut(varChild,pszKeyboardShortcut);
792 }
793 return S_FALSE;
794
795 LEAVE_PROTECTED_BLOCK
796 }
797
798 /**
799 * Returns the current focused child to AT.
800 * @param pvarChild, [in,out] vt member of pvarChild must be VT_I4,and lVal member stores the child ID,
801 * the child ID specify child index from 0 to children count, 0 stands for object self.
802 * @return S_OK if successful and E_FAIL if failure.
803 */
get_accFocus(VARIANT * pvarChild)804 STDMETHODIMP CMAccessible::get_accFocus(VARIANT *pvarChild)
805 {
806
807 CHECK_ENABLE_INF
808 ENTER_PROTECTED_BLOCK
809 ISDESTROY()
810 // #CHECK#
811 if(pvarChild == NULL)
812 {
813 return E_INVALIDARG;
814 }
815 if( m_dFocusChildID==UACC_NO_FOCUS )
816 {
817 pvarChild->vt = VT_EMPTY;//no focus on the object and its children
818 return S_OK;
819 }
820 //if the descendant of current object has focus indicated by m_dFocusChildID, return the IDispatch of this focused object
821 else
822 {
823 IMAccessible* pIMAcc = NULL;
824 g_pAgent->GetIAccessibleFromResID(m_dFocusChildID,&pIMAcc);
825 pIMAcc->AddRef();
826 pvarChild->vt = VT_DISPATCH;
827 pvarChild->pdispVal = pIMAcc;
828
829 }
830 return S_OK;
831
832 LEAVE_PROTECTED_BLOCK
833 }
834
835 /**
836 * Returns the selection of the current COM object to AT.
837 * @param pvarChildren,[in,out]
838 * if selection num is 0,return VT_EMPTY for vt,
839 * if selection num is 1,return VT_I4 for vt,and child index for lVal
840 * if selection num >1,return VT_UNKNOWN for vt, and IEnumVariant* for punkVal
841 * @return S_OK if successful and S_FALSE if failure.
842 */
get_accSelection(VARIANT * pvarChildren)843 STDMETHODIMP CMAccessible::get_accSelection(VARIANT *pvarChildren)
844 {
845
846 CHECK_ENABLE_INF
847 ENTER_PROTECTED_BLOCK
848 ISDESTROY()
849 // #CHECK#
850 if(pvarChildren == NULL)
851 {
852 return E_INVALIDARG;
853 }
854 switch(m_pEnumVar->GetCountOfElements())
855 {
856 case 0:
857 pvarChildren->vt = VT_EMPTY;
858 break;
859 case 1:
860 VARIANT varTmp[1];
861 ULONG count;
862 VariantInit(&varTmp[0]);
863 m_pEnumVar->Next(1,varTmp,&count);
864 if(count!=1)
865 return S_FALSE;
866 pvarChildren->vt = VT_I4;
867 pvarChildren->lVal = varTmp[0].lVal;
868 VariantClear(&varTmp[0]);
869 m_pEnumVar->Reset();
870 break;
871 default:
872 pvarChildren->vt = VT_UNKNOWN;
873 m_pEnumVar->AddRef();
874 pvarChildren->punkVal = m_pEnumVar;
875 break;
876 }
877 return S_OK;
878
879 LEAVE_PROTECTED_BLOCK
880 }
881
882 /**
883 * Returns the location of the current COM object self or its one child to AT.
884 * @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID,
885 * the child ID specify child index from 0 to children count, 0 stands for object self.
886 * @param pxLeft, [in,out] use to return the x-coordination of the proper object.
887 * @param pyTop, [in,out] use to return the y-coordination of the proper object.
888 * @param pcxWidth, [in,out] use to return the x-coordination width of the proper object.
889 * @param pcyHeight, [in,out] use to return the y-coordination height of the proper object.
890 * @return S_OK if successful and S_FALSE if failure.
891 */
accLocation(long * pxLeft,long * pyTop,long * pcxWidth,long * pcyHeight,VARIANT varChild)892 STDMETHODIMP CMAccessible::accLocation(long *pxLeft, long *pyTop, long *pcxWidth, long *pcyHeight, VARIANT varChild)
893 {
894
895 CHECK_ENABLE_INF
896 ENTER_PROTECTED_BLOCK
897 ISDESTROY()
898 // #CHECK#
899 if(pxLeft == NULL || pyTop == NULL || pcxWidth == NULL || pcyHeight == NULL)
900 {
901 return E_INVALIDARG;
902 }
903
904 if(varChild.vt==VT_I4)
905 {
906 if(varChild.lVal==CHILDID_SELF)
907 {
908
909 if(pUNOInterface)
910 {
911 Reference< XAccessibleContext > pRContext = pUNOInterface->getAccessibleContext();
912 if( !pRContext.is() )
913 return S_FALSE;
914 Reference< XAccessibleComponent > pRComponent(pRContext,UNO_QUERY);
915 if( !pRComponent.is() )
916 return S_FALSE;
917
918 ::com::sun::star::awt::Point pCPoint = pRComponent->getLocationOnScreen();
919 ::com::sun::star::awt::Size pCSize = pRComponent->getSize();
920 *pxLeft = pCPoint.X;
921 *pyTop = pCPoint.Y;
922 *pcxWidth = pCSize.Width;
923 *pcyHeight = pCSize.Height;
924 return S_OK;
925 }
926 else
927 {
928 *pxLeft = m_sLocation.m_dLeft;
929 *pyTop = m_sLocation.m_dTop;
930 *pcxWidth = m_sLocation.m_dWidth;
931 *pcyHeight = m_sLocation.m_dHeight;
932 return S_OK;
933 }
934 }
935
936 }
937 return S_FALSE;
938
939 LEAVE_PROTECTED_BLOCK
940 }
941
942 /**
943 * Returns the current focused child to AT.
944 * @param navDir, the direction flag of the navigation.
945 * @param varStart, the start child id of this navigation action.
946 * @param pvarEndUpAt, [in,out] the end up child of this navigation action.
947 * @return S_OK if successful and E_FAIL if failure.
948 */
accNavigate(long navDir,VARIANT varStart,VARIANT * pvarEndUpAt)949 STDMETHODIMP CMAccessible::accNavigate(long navDir, VARIANT varStart, VARIANT *pvarEndUpAt)
950 {
951
952 CHECK_ENABLE_INF
953 ENTER_PROTECTED_BLOCK
954 ISDESTROY()
955 // #CHECK#
956 if(pvarEndUpAt == NULL)
957 {
958 return E_INVALIDARG;
959 }
960 HRESULT ret = E_FAIL;
961 switch (navDir)
962 {
963 case NAVDIR_FIRSTCHILD:
964 ret = GetFirstChild(varStart,pvarEndUpAt);
965 break;
966 case NAVDIR_LASTCHILD:
967 ret = GetLastChild(varStart,pvarEndUpAt);
968 break;
969 case NAVDIR_NEXT:
970 ret = GetNextSibling(varStart,pvarEndUpAt);
971 break;
972 case NAVDIR_PREVIOUS:
973 ret = GetPreSibling(varStart,pvarEndUpAt);
974 break;
975 case NAVDIR_DOWN://do not implement temporarily
976 break;
977 case NAVDIR_UP://do not implement temporarily
978 break;
979 case NAVDIR_LEFT://do not implement temporarily
980 break;
981 case NAVDIR_RIGHT://do not implement temporarily
982 break;
983 default:
984 break;
985 };
986 return ret;
987
988 LEAVE_PROTECTED_BLOCK
989 }
990
accHitTest(long xLeft,long yTop,VARIANT * pvarChild)991 STDMETHODIMP CMAccessible::accHitTest(long xLeft, long yTop, VARIANT *pvarChild)
992 {
993
994 CHECK_ENABLE_INF
995 ENTER_PROTECTED_BLOCK
996 ISDESTROY()
997 // #CHECK#
998 if(pvarChild == NULL)
999 {
1000 return E_INVALIDARG;
1001 }
1002 long x, y, w, h;
1003 VARIANT varSelf;
1004 VariantInit(&varSelf);
1005 varSelf.vt = VT_I4;
1006 varSelf.lVal = CHILDID_SELF;
1007 accLocation(&x,&y,&w,&h,varSelf);
1008 if( (x < xLeft && (x + w) >xLeft) && (y < yTop && (y + h) >yTop) )
1009 {
1010 int i, nCount;
1011 pvarChild->vt = VT_EMPTY;
1012 Reference< XAccessibleContext > pRContext = GetContextByXAcc(pUNOInterface);
1013 nCount = pRContext->getAccessibleChildCount();
1014 if(nCount > 256)
1015 return E_FAIL;
1016 IMAccessible* child = NULL;
1017 for( i = 0; i<nCount; i++)
1018 {
1019
1020 child = GetChildInterface(i + 1);
1021 if(child && child->accHitTest(xLeft,yTop,pvarChild) == S_OK)
1022 break;
1023 }
1024
1025 if(pvarChild->vt == VT_DISPATCH)
1026 return S_OK;
1027
1028 if( i < nCount)
1029 {
1030 pvarChild->vt = VT_DISPATCH;
1031 pvarChild->pdispVal = child;
1032 child->AddRef();
1033 }
1034 else
1035 {
1036 pvarChild->vt = VT_I4;
1037 pvarChild->lVal = CHILDID_SELF;
1038 }
1039 return S_OK;
1040 }
1041 return S_FALSE;
1042
1043 LEAVE_PROTECTED_BLOCK
1044 }
1045
1046 /**
1047 * Get The other Interface from CMAccessible.
1048 * @param guidService, must be IID_IAccessible here.
1049 * @param riid, the IID interface .
1050 * @return S_OK if successful and S_FALSE if failure.
1051 */
QueryService(REFGUID guidService,REFIID riid,void ** ppvObject)1052 STDMETHODIMP CMAccessible::QueryService(REFGUID guidService, REFIID riid, void** ppvObject)
1053 {
1054 if( InlineIsEqualGUID(guidService, IID_IAccessible) )
1055 return QueryInterface(riid, ppvObject);
1056 return S_FALSE;
1057 }
1058
1059 /**
1060 * Set the accessible name of the current COM object self or its one child from UNO.
1061 * @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID,
1062 * the child ID specify child index from 0 to children count, 0 stands for object self.
1063 * @param szName, the name used to set the name of the proper object.
1064 * @return S_OK if successful and E_FAIL if failure.
1065 */
put_accName(VARIANT varChild,BSTR szName)1066 STDMETHODIMP CMAccessible::put_accName(VARIANT varChild, BSTR szName)
1067 {
1068
1069 ENTER_PROTECTED_BLOCK
1070 ISDESTROY()
1071 if(varChild.vt==VT_I4)
1072 {
1073 if(varChild.lVal==CHILDID_SELF)
1074 {
1075 SAFE_SYSFREESTRING(m_pszName);
1076 m_pszName=SysAllocString(szName);
1077 return S_OK;
1078 }
1079
1080 long lVal = varChild.lVal;
1081 varChild.lVal = CHILDID_SELF;
1082 IMAccessible *pChild = this->GetChildInterface(lVal);
1083 if(!pChild)
1084 return E_FAIL;
1085 return pChild->put_accName(varChild,szName);
1086 }
1087 return E_FAIL;
1088
1089 LEAVE_PROTECTED_BLOCK
1090 }
1091
1092 /**
1093 * Set the accessible value of the current COM object self or its one child from UNO.
1094 * @param varChild, vt member of varChild must be VT_I4,and lVal member stores the child ID,
1095 * the child ID specify child index from 0 to children count, 0 stands for object self.
1096 * @param szValue, the value used to set the value of the proper object.
1097 * @return S_OK if successful and E_FAIL if failure.
1098 */
put_accValue(VARIANT varChild,BSTR szValue)1099 STDMETHODIMP CMAccessible::put_accValue(VARIANT varChild, BSTR szValue)
1100 {
1101
1102 ENTER_PROTECTED_BLOCK
1103 ISDESTROY()
1104 if(varChild.vt==VT_I4)
1105 {
1106 if(varChild.lVal==CHILDID_SELF)
1107 {
1108 SysAllocString(m_pszValue);
1109 m_pszValue=SysAllocString(szValue);
1110 return S_OK;
1111 }
1112
1113 long lVal = varChild.lVal;
1114 varChild.lVal = CHILDID_SELF;
1115 IMAccessible *pChild = this->GetChildInterface(lVal);
1116 if(!pChild)
1117 return E_FAIL;
1118 return pChild->put_accValue(varChild,szValue);
1119 }
1120 return E_FAIL;
1121
1122 LEAVE_PROTECTED_BLOCK
1123 }
1124
1125 /**
1126 * Set the accessible name of the current COM object self from UNO.
1127 * @param pszName, the name value used to set the name of the current object.
1128 * @return S_OK if successful and E_FAIL if failure.
1129 */
Put_XAccName(const OLECHAR __RPC_FAR * pszName)1130 STDMETHODIMP CMAccessible::Put_XAccName(const OLECHAR __RPC_FAR *pszName)
1131 {
1132
1133 ENTER_PROTECTED_BLOCK
1134 ISDESTROY()
1135 // #CHECK#
1136 if(pszName == NULL)
1137 {
1138 return E_INVALIDARG;
1139 }
1140
1141 SAFE_SYSFREESTRING(m_pszName);//??
1142 m_pszName = SysAllocString(pszName);
1143 if(m_pszName==NULL)
1144 return E_FAIL;
1145 return S_OK;
1146
1147 LEAVE_PROTECTED_BLOCK
1148 }
1149
1150 /**
1151 * Set the accessible role of the current COM object self from UNO.
1152 * @param pRole, the role value used to set the role of the current object.
1153 * @return S_OK if successful and E_FAIL if failure.
1154 */
Put_XAccRole(unsigned short pRole)1155 STDMETHODIMP CMAccessible::Put_XAccRole(unsigned short pRole)
1156 {
1157 m_iRole = pRole;
1158 return S_OK;
1159 }
1160
1161 /**
1162 * Add one state into the current state set for the current COM object from UNO.
1163 * @param pXSate, the state used to set the name of the current object.
1164 * @return S_OK if successful and E_FAIL if failure.
1165 */
DecreaseState(DWORD pXSate)1166 STDMETHODIMP CMAccessible::DecreaseState(DWORD pXSate)
1167 {
1168 m_dState &= (~pXSate);
1169 return S_OK;
1170 }
1171
1172 /**
1173 * Delete one state into the current state set for the current COM object from UNO.
1174 * @param pXSate, the state used to set the name of the current object.
1175 * @return S_OK if successful and E_FAIL if failure.
1176 */
IncreaseState(DWORD pXSate)1177 STDMETHODIMP CMAccessible::IncreaseState(DWORD pXSate)
1178 {
1179 m_dState |= pXSate;
1180 return S_OK;
1181 }
1182
1183 /**
1184 * Set state into the current state set for the current COM object from UNO.
1185 * @param pXSate, the state used to set the name of the current object.
1186 * @return S_OK if successful and E_FAIL if failure.
1187 */
SetState(DWORD pXSate)1188 STDMETHODIMP CMAccessible::SetState(DWORD pXSate)
1189 {
1190 m_dState = pXSate;
1191 return S_OK;
1192 }
1193
1194
1195
1196 /**
1197 * Set the accessible description of the current COM object self from UNO.
1198 * @param pszDescription, the name used to set the description of the current object.
1199 * @return S_OK if successful and E_FAIL if failure.
1200 */
Put_XAccDescription(const OLECHAR __RPC_FAR * pszDescription)1201 STDMETHODIMP CMAccessible::Put_XAccDescription(const OLECHAR __RPC_FAR *pszDescription)
1202 {
1203
1204 ENTER_PROTECTED_BLOCK
1205 ISDESTROY()
1206 // #CHECK#
1207 if(pszDescription == NULL)
1208 {
1209 return E_INVALIDARG;
1210 }
1211
1212 SAFE_SYSFREESTRING(m_pszDescription);
1213 m_pszDescription = SysAllocString(pszDescription);
1214
1215 if(m_pszDescription==NULL)
1216 return E_FAIL;
1217 return S_OK;
1218
1219 LEAVE_PROTECTED_BLOCK
1220 }
1221
1222 /**
1223 * Set the accessible value of the current COM object self from UNO.
1224 * @param pszAccValue, the name used to set the value of the current object.
1225 * @return S_OK if successful and E_FAIL if failure.
1226 */
Put_XAccValue(const OLECHAR __RPC_FAR * pszAccValue)1227 STDMETHODIMP CMAccessible::Put_XAccValue(const OLECHAR __RPC_FAR *pszAccValue)
1228 {
1229
1230 ENTER_PROTECTED_BLOCK
1231 ISDESTROY()
1232 // #CHECK#
1233 if(pszAccValue == NULL)
1234 {
1235 return E_INVALIDARG;
1236 }
1237 SAFE_SYSFREESTRING(m_pszValue);
1238 m_pszValue = SysAllocString(pszAccValue);
1239 if(m_pszValue==NULL)
1240 return E_FAIL;
1241 return S_OK;
1242
1243 LEAVE_PROTECTED_BLOCK
1244 }
1245
1246 /**
1247 * Set the HWND value of the current COM object self from UNO. It should set the parent IAccessible
1248 * Object through the method AccessibleObjectFromWindow(...).
1249 * @param hwnd, the HWND used to set the value of the current object.
1250 * @return S_OK if successful and E_FAIL if failure.
1251 */
Put_XAccWindowHandle(HWND hwnd)1252 STDMETHODIMP CMAccessible::Put_XAccWindowHandle(HWND hwnd)
1253 {
1254
1255 ENTER_PROTECTED_BLOCK
1256 ISDESTROY()
1257 m_hwnd = hwnd;
1258 return S_OK;
1259
1260 LEAVE_PROTECTED_BLOCK
1261 }
1262
1263 /**
1264 * Set accessible focus by specifying child ID
1265 * @param dChildID, the child id identifies the focus child.
1266 * @return S_OK if successful and E_FAIL if failure.
1267 */
Put_XAccFocus(long dChildID)1268 STDMETHODIMP CMAccessible::Put_XAccFocus(long dChildID)
1269 {
1270
1271 ENTER_PROTECTED_BLOCK
1272 ISDESTROY()
1273
1274 if(dChildID==CHILDID_SELF)
1275 {
1276 if(m_pIParent)
1277 {
1278 m_pIParent->Put_XAccFocus(m_dChildID);
1279 }
1280 }
1281 else
1282 {
1283 m_dFocusChildID = dChildID;
1284 //traverse all ancestors to set the focused child ID so that when the get_accFocus is called on
1285 //any of the ancestors, this id can be used to get the IAccessible of focused object.
1286 if(m_pIParent)
1287 {
1288 m_pIParent->Put_XAccFocus(dChildID);
1289 }
1290 }
1291 return S_OK;
1292
1293 LEAVE_PROTECTED_BLOCK
1294 }
1295
1296 /**
1297 *Set accessible object location for the current COM object
1298 * @param sLocation, the location of the current object.
1299 * @return S_OK if successful and E_FAIL if failure.
1300 */
Put_XAccLocation(const Location sLocation)1301 STDMETHODIMP CMAccessible::Put_XAccLocation(const Location sLocation)
1302 {
1303
1304 this->m_sLocation = sLocation;
1305 return S_OK;
1306 }
1307
1308 /**
1309 * Set accessible parent object for the current COM object if
1310 * the current object is a child of some COM object
1311 * @param pIParent, the parent of the current object.
1312 * @return S_OK if successful and E_FAIL if failure.
1313 */
Put_XAccParent(IMAccessible __RPC_FAR * pIParent)1314 STDMETHODIMP CMAccessible::Put_XAccParent(IMAccessible __RPC_FAR *pIParent)
1315 {
1316 this->m_pIParent = pIParent;
1317
1318 if(pIParent)
1319 m_pIParent->AddRef();
1320
1321 return S_OK;
1322 }
1323
1324 /**
1325 * Set unique child id to COM
1326 * @param dChildID, the id of the current object.
1327 * @return S_OK if successful and E_FAIL if failure.
1328 */
Put_XAccChildID(long dChildID)1329 STDMETHODIMP CMAccessible::Put_XAccChildID(long dChildID)
1330 {
1331
1332 this->m_dChildID = dChildID;
1333 return S_OK;
1334 }
1335
1336 /**
1337 * Set AccObjectManagerAgent object pointer to COM
1338 * @param pAgent, the AccObjectManagerAgent point.
1339 * @return S_OK if successful and E_FAIL if failure.
1340 */
Put_XAccAgent(long pAgent)1341 STDMETHODIMP CMAccessible::Put_XAccAgent(long pAgent)
1342 {
1343 g_pAgent = (AccObjectManagerAgent*)pAgent;
1344 return S_OK;
1345 }
1346
1347 /**
1348 * When a UNO control disposing, it disposes its listeners,
1349 * then notify AccObject in bridge management, then notify
1350 * COM that the XAccessible is invalid,so set pUNOInterface as NULL
1351 * @param isDestroy, true is it need to be destroyed.
1352 * @return S_OK if successful and E_FAIL if failure.
1353 */
NotifyDestroy(BOOL isDestroy)1354 STDMETHODIMP CMAccessible::NotifyDestroy(BOOL isDestroy)
1355 {
1356
1357 m_isDestroy = isDestroy;
1358 pUNOInterface = NULL;
1359 return S_OK;
1360 }
1361
1362 /**
1363 *private methods that help implement public functions
1364 */
1365
1366 /**
1367 * Return child interface pointer by child ID,note: need to call AddRef()
1368 * @param lChildID, specify child index,which AT(such as Inspect32) gives.
1369 * @return IMAccessible*, pointer to the corresponding child object.
1370 */
GetChildInterface(long dChildID)1371 IMAccessible* CMAccessible::GetChildInterface(long dChildID)//for test
1372 {
1373
1374 long dChildIndex = 0;
1375 if(dChildID<0)
1376 {
1377 if(g_pAgent)
1378 {
1379 IMAccessible* pIMAcc = NULL;
1380 g_pAgent->GetIAccessibleFromResID(dChildID,&pIMAcc);
1381 return pIMAcc;
1382 }
1383 return NULL;
1384 }
1385 else
1386 {
1387 Reference< XAccessibleContext > pRContext = pUNOInterface->getAccessibleContext();
1388 if( !pRContext.is() )
1389 return NULL;
1390
1391 if(dChildID<1 || dChildID>pRContext->getAccessibleChildCount())
1392 return NULL;
1393
1394 IAccessible* pChild = NULL;
1395 Reference< XAccessible > pXChild = pRContext->getAccessibleChild(dChildID-1);
1396 BOOL isGet = get_IAccessibleFromXAccessible((long)pXChild.get(),&pChild);
1397
1398 if(!isGet)
1399 {
1400 g_pAgent->InsertAccObj(pXChild.get(),pUNOInterface,(long)m_hwnd);
1401 isGet = get_IAccessibleFromXAccessible((long)pXChild.get(),&pChild);
1402 }
1403
1404 if(isGet)
1405 {
1406 IMAccessible* pIMAcc = (IMAccessible*)pChild;
1407 return pIMAcc;
1408 }
1409 }
1410
1411 return NULL;
1412 }
1413
1414 /**
1415 * For List, tree and table,these roles belong to manage_decendant in UNO,
1416 * need to process specifically when navigate
1417 * @return BOOL, if it is decendantmanager, return true.
1418 */
IsDecendantManage()1419 BOOL CMAccessible::IsDecendantManage()
1420 {
1421
1422 return (m_iRole==ROLE_SYSTEM_LIST)||(m_iRole==ROLE_SYSTEM_OUTLINE)||(m_iRole==ROLE_SYSTEM_TABLE);
1423 }
1424
1425 /**
1426 * for decendantmanager circumstance,provide child interface when navigate
1427 * @param varCur, the current child.
1428 * @param flags, the navigation direction.
1429 * @return IMAccessible*, the child of the end up node.
1430 */
GetNavigateChildForDM(VARIANT varCur,short flags)1431 IMAccessible* CMAccessible::GetNavigateChildForDM(VARIANT varCur, short flags)
1432 {
1433
1434 XAccessibleContext* pXContext = GetContextByXAcc(pUNOInterface);
1435 if(pXContext==NULL)
1436 {
1437 return NULL;
1438 }
1439
1440 int count = pXContext->getAccessibleChildCount();
1441 if(count<1)
1442 {
1443 return NULL;
1444 }
1445
1446 IMAccessible* pCurChild = NULL;
1447 XAccessible* pChildXAcc = NULL;
1448 Reference<XAccessible> pRChildXAcc;
1449 XAccessibleContext* pChildContext = NULL;
1450 int index = 0,delta=0;
1451 switch(flags)
1452 {
1453 case DM_FIRSTCHILD:
1454 pRChildXAcc = pXContext->getAccessibleChild(0);
1455 break;
1456 case DM_LASTCHILD:
1457 pRChildXAcc = pXContext->getAccessibleChild(count-1);
1458 break;
1459 case DM_NEXTCHILD:
1460 case DM_PREVCHILD:
1461 pCurChild = GetChildInterface(varCur.lVal);
1462 if(pCurChild==NULL)
1463 {
1464 return NULL;
1465 }
1466 pCurChild->GetUNOInterface((long*)&pChildXAcc);
1467 if(pChildXAcc==NULL)
1468 {
1469 return NULL;
1470 }
1471 pChildContext = GetContextByXAcc(pChildXAcc);
1472 if(pChildContext == NULL)
1473 {
1474 return NULL;
1475 }
1476 delta = (flags==DM_NEXTCHILD)?1:-1;
1477 //currently, getAccessibleIndexInParent is error in UNO for
1478 //some kind of List,such as ValueSet, the index will be less 1 than
1479 //what should be, need to fix UNO code
1480 index = pChildContext->getAccessibleIndexInParent()+delta;
1481 if((index>=0)&&(index<=count-1))
1482 {
1483 pRChildXAcc = pXContext->getAccessibleChild(index);
1484 }
1485 break;
1486 default:
1487 break;
1488 }
1489
1490 if(!pRChildXAcc.is())
1491 {
1492 return NULL;
1493 }
1494 pChildXAcc = pRChildXAcc.get();
1495 g_pAgent->InsertAccObj(pChildXAcc,pUNOInterface);
1496 return g_pAgent->GetIMAccByXAcc(pChildXAcc);
1497 }
1498
1499 /**
1500 *the following 4 private methods are for accNavigate implementation
1501 */
1502
1503 /**
1504 * Return first child for parent container, process differently according
1505 * to whether it is descendant manage
1506 * @param varStart, the start child id of this navigation action.
1507 * @param pvarEndUpAt, [in,out] the end up child of this navigation action.
1508 * @return S_OK if successful and E_FAIL if failure.
1509 */
GetFirstChild(VARIANT varStart,VARIANT * pvarEndUpAt)1510 HRESULT CMAccessible::GetFirstChild(VARIANT varStart,VARIANT* pvarEndUpAt)
1511 {
1512
1513 ENTER_PROTECTED_BLOCK
1514 ISDESTROY()
1515 // #CHECK#
1516 if(pvarEndUpAt == NULL)
1517 {
1518 return E_INVALIDARG;
1519 }
1520 if(varStart.vt != VT_I4)
1521 {
1522 pvarEndUpAt->vt = VT_EMPTY;
1523 return E_INVALIDARG;
1524 }
1525
1526 pvarEndUpAt->pdispVal = GetNavigateChildForDM(varStart, DM_FIRSTCHILD);
1527 if(pvarEndUpAt->pdispVal)
1528 {
1529 pvarEndUpAt->pdispVal->AddRef();
1530 pvarEndUpAt->vt = VT_DISPATCH;
1531 return S_OK;
1532 }
1533
1534 pvarEndUpAt->vt = VT_EMPTY;
1535 return E_FAIL;
1536
1537 LEAVE_PROTECTED_BLOCK
1538 }
1539
1540 /**
1541 * Return last child for parent container, process differently according
1542 * to whether it is descendant manage
1543 * @param varStart, the start child id of this navigation action.
1544 * @param pvarEndUpAt, [in,out] the end up child of this navigation action.
1545 * @return S_OK if successful and E_FAIL if failure.
1546 */
GetLastChild(VARIANT varStart,VARIANT * pvarEndUpAt)1547 HRESULT CMAccessible::GetLastChild(VARIANT varStart,VARIANT* pvarEndUpAt)
1548 {
1549
1550 ENTER_PROTECTED_BLOCK
1551 ISDESTROY()
1552 // #CHECK#
1553 if(pvarEndUpAt == NULL)
1554 {
1555 return E_INVALIDARG;
1556 }
1557 if(varStart.vt != VT_I4)
1558 {
1559 pvarEndUpAt->vt = VT_EMPTY;
1560 return E_INVALIDARG;
1561 }
1562
1563 pvarEndUpAt->pdispVal = GetNavigateChildForDM(varStart, DM_LASTCHILD);
1564 if(pvarEndUpAt->pdispVal)
1565 {
1566 pvarEndUpAt->pdispVal->AddRef();
1567 pvarEndUpAt->vt = VT_DISPATCH;
1568 return S_OK;
1569 }
1570 pvarEndUpAt->vt = VT_EMPTY;
1571 return E_FAIL;
1572
1573 LEAVE_PROTECTED_BLOCK
1574 }
1575
1576 /**
1577 * The method GetNextSibling is general, whatever it is descendant manage or not
1578 * Get the next sibling object.
1579 * @param varStart, the start child id of this navigation action.
1580 * @param pvarEndUpAt, [in,out] the end up child of this navigation action.
1581 * @return S_OK if successful and E_FAIL if failure.
1582 */
GetNextSibling(VARIANT varStart,VARIANT * pvarEndUpAt)1583 HRESULT CMAccessible::GetNextSibling(VARIANT varStart,VARIANT* pvarEndUpAt)
1584 {
1585
1586 ENTER_PROTECTED_BLOCK
1587 ISDESTROY()
1588 if(varStart.vt != VT_I4)
1589 {
1590 pvarEndUpAt->vt = VT_EMPTY;
1591 return E_INVALIDARG;
1592 }
1593
1594 Reference< XAccessibleContext > pRContext = GetContextByXAcc(pUNOInterface);
1595 if(pRContext.is())
1596 {
1597 varStart.iVal = sal_Int16(pRContext->getAccessibleIndexInParent() + 2);
1598 if(m_pIParent)
1599 if( m_pIParent->get_accChild(varStart,&pvarEndUpAt->pdispVal) == S_OK)
1600 {
1601 pvarEndUpAt->vt = VT_DISPATCH;
1602 return S_OK;
1603 }
1604 }
1605 pvarEndUpAt->vt = VT_EMPTY;
1606 return E_FAIL;
1607
1608 LEAVE_PROTECTED_BLOCK
1609 }
1610
1611 /**
1612 *the method GetPreSibling is general, whatever it is descendant manage or not
1613 * @param varStart, the start child id of this navigation action.
1614 * @param pvarEndUpAt, [in,out] the end up child of this navigation action.
1615 * @return S_OK if successful and E_FAIL if failure.
1616 */
GetPreSibling(VARIANT varStart,VARIANT * pvarEndUpAt)1617 HRESULT CMAccessible::GetPreSibling(VARIANT varStart,VARIANT* pvarEndUpAt)
1618 {
1619
1620 ENTER_PROTECTED_BLOCK
1621 ISDESTROY()
1622 // #CHECK#
1623 if(pvarEndUpAt == NULL)
1624 {
1625 return E_INVALIDARG;
1626 }
1627 if(varStart.vt != VT_I4)
1628 {
1629 pvarEndUpAt->vt = VT_EMPTY;
1630 return E_INVALIDARG;
1631 }
1632
1633 Reference< XAccessibleContext > pRContext = GetContextByXAcc(pUNOInterface);
1634 if(pRContext.is())
1635 {
1636 varStart.iVal = sal_Int16(pRContext->getAccessibleIndexInParent());
1637 if(m_pIParent && varStart.iVal > 0)
1638 if( m_pIParent->get_accChild(varStart,&pvarEndUpAt->pdispVal) == S_OK)
1639 {
1640 pvarEndUpAt->vt = VT_DISPATCH;
1641 return S_OK;
1642 }
1643 }
1644 pvarEndUpAt->vt = VT_EMPTY;
1645 return E_FAIL;
1646
1647 LEAVE_PROTECTED_BLOCK
1648 }
1649
1650 /**
1651 * For IAccessible2 implementation methods
1652 */
get_nRelations(long __RPC_FAR * nRelations)1653 STDMETHODIMP CMAccessible::get_nRelations( long __RPC_FAR *nRelations)
1654 {
1655
1656 CHECK_ENABLE_INF
1657 ENTER_PROTECTED_BLOCK
1658 ISDESTROY()
1659
1660 // #CHECK#
1661 if(nRelations == NULL)
1662 {
1663 return E_INVALIDARG;
1664 }
1665
1666 *nRelations = 0;
1667
1668 if( !pRContext.is() )
1669 return E_FAIL;
1670 Reference<XAccessibleRelationSet> pRrelationSet = pRContext.get()->getAccessibleRelationSet();
1671 if(!pRrelationSet.is())
1672 {
1673 *nRelations = 0;
1674 return S_OK;
1675 }
1676
1677 *nRelations = pRrelationSet->getRelationCount();
1678 return S_OK;
1679
1680 LEAVE_PROTECTED_BLOCK
1681 }
1682
get_relation(long relationIndex,IAccessibleRelation __RPC_FAR * __RPC_FAR * relation)1683 STDMETHODIMP CMAccessible::get_relation( long relationIndex, IAccessibleRelation __RPC_FAR *__RPC_FAR *relation)
1684 {
1685
1686 CHECK_ENABLE_INF
1687 ENTER_PROTECTED_BLOCK
1688 ISDESTROY()
1689 // #CHECK#
1690 if(relation == NULL)
1691 {
1692 return E_INVALIDARG;
1693 }
1694
1695 if( !pRContext.is() )
1696 return E_FAIL;
1697
1698
1699 long nMax = 0;
1700 long nReal = 0;
1701 get_nRelations(&nMax);
1702
1703 *relation = (IAccessibleRelation*)::CoTaskMemAlloc(sizeof(IAccessibleRelation));
1704
1705 // #CHECK Memory Allocation#
1706 if(*relation == NULL)
1707 {
1708 return E_FAIL;
1709 }
1710
1711 if( relationIndex < nMax )
1712 {
1713
1714
1715 Reference<XAccessibleRelationSet> pRrelationSet = pRContext.get()->getAccessibleRelationSet();
1716 if(!pRrelationSet.is())
1717 {
1718
1719 return E_FAIL;
1720 }
1721
1722 IAccessibleRelation* pRelation = NULL;
1723 ActivateActContext();
1724 HRESULT hr = CoCreateInstance( CLSID_AccRelation, NULL, CLSCTX_SERVER ,
1725 IID_IAccessibleRelation,
1726 (void **)&pRelation);
1727 DeactivateActContext();
1728 if(SUCCEEDED(hr))
1729 {
1730 IUNOXWrapper* wrapper = NULL;
1731 hr = pRelation->QueryInterface(IID_IUNOXWrapper, (void**)&wrapper);
1732 if(SUCCEEDED(hr))
1733 {
1734 AccessibleRelation accRelation = pRrelationSet->getRelation(relationIndex);
1735 wrapper->put_XSubInterface((long)&accRelation);
1736 wrapper->Release();
1737 *relation = pRelation;
1738 return S_OK;
1739 }
1740
1741 }
1742 }
1743
1744 return E_FAIL;
1745
1746 LEAVE_PROTECTED_BLOCK
1747 }
1748
get_relations(long,IAccessibleRelation __RPC_FAR * __RPC_FAR * relation,long __RPC_FAR * nRelations)1749 STDMETHODIMP CMAccessible::get_relations( long, IAccessibleRelation __RPC_FAR *__RPC_FAR *relation, long __RPC_FAR *nRelations)
1750 {
1751
1752 CHECK_ENABLE_INF
1753 ENTER_PROTECTED_BLOCK
1754 ISDESTROY()
1755
1756 // #CHECK#
1757 if(relation == NULL || nRelations == NULL)
1758 {
1759 return E_INVALIDARG;
1760 }
1761 // #CHECK XInterface#
1762
1763 if( !pRContext.is() )
1764 return E_FAIL;
1765
1766 Reference<XAccessibleRelationSet> pRrelationSet = pRContext.get()->getAccessibleRelationSet();
1767 if(!pRrelationSet.is())
1768 {
1769 *nRelations = 0;
1770 return S_OK;
1771 }
1772
1773 long nCount = pRrelationSet->getRelationCount();
1774
1775 *relation = (IAccessibleRelation*)::CoTaskMemAlloc(nCount*sizeof(IAccessibleRelation));
1776
1777 // #CHECK Memory Allocation#
1778 if(*relation == NULL)
1779 {
1780 return E_FAIL;
1781 }
1782
1783 for(int i=0; i<nCount ; i++)
1784 {
1785 IAccessibleRelation* pRelation = NULL;
1786 ActivateActContext();
1787 HRESULT hr = CoCreateInstance( CLSID_AccRelation, NULL, CLSCTX_SERVER ,
1788 IID_IAccessibleRelation,
1789 (void **)&pRelation);
1790 DeactivateActContext();
1791 if(SUCCEEDED(hr))
1792 {
1793 IUNOXWrapper* wrapper = NULL;
1794 hr = pRelation->QueryInterface(IID_IUNOXWrapper, (void**)&wrapper);
1795 if(SUCCEEDED(hr))
1796 {
1797 AccessibleRelation accRelation = pRrelationSet->getRelation(i);
1798 wrapper->put_XSubInterface((long)&accRelation);
1799 wrapper->Release();
1800 }
1801 (relation)[i] = pRelation;
1802 }
1803 }
1804
1805 *nRelations = nCount;
1806 return S_OK;
1807
1808 LEAVE_PROTECTED_BLOCK
1809 }
1810
role(long __RPC_FAR * role)1811 STDMETHODIMP CMAccessible::role(long __RPC_FAR *role)
1812 {
1813 ENTER_PROTECTED_BLOCK
1814
1815 (*role) = m_iRole;
1816
1817 return S_OK;
1818
1819 LEAVE_PROTECTED_BLOCK
1820 }
1821
1822
get_nActions(long __RPC_FAR * nActions)1823 STDMETHODIMP CMAccessible:: get_nActions(long __RPC_FAR *nActions)
1824 {
1825
1826 try
1827 {
1828 ISDESTROY()
1829 // #CHECK#
1830 if(nActions == NULL)
1831 {
1832 return E_INVALIDARG;
1833 }
1834 *nActions = 0L;
1835 IAccessibleAction* pAcc = NULL;
1836 HRESULT hr = QueryInterface(IID_IAccessibleAction, (void**)&pAcc);
1837 if( hr == S_OK )
1838 {
1839 pAcc->nActions(nActions);
1840 pAcc->Release();
1841 }
1842
1843 return S_OK;
1844 }
1845 catch(...)
1846 {
1847 *nActions = 0L;
1848 return S_OK;
1849 }
1850 }
1851
1852
scrollToPoint(enum IA2CoordinateType,long,long)1853 STDMETHODIMP CMAccessible:: scrollToPoint(enum IA2CoordinateType, long, long)
1854 {
1855
1856 ENTER_PROTECTED_BLOCK
1857 ISDESTROY()
1858 return E_NOTIMPL;
1859 LEAVE_PROTECTED_BLOCK
1860
1861 }
scrollTo(enum IA2ScrollType)1862 STDMETHODIMP CMAccessible:: scrollTo(enum IA2ScrollType)
1863 {
1864
1865 ENTER_PROTECTED_BLOCK
1866 ISDESTROY()
1867
1868 return E_NOTIMPL;
1869
1870 LEAVE_PROTECTED_BLOCK
1871 }
1872
getTheParentOfMember(XAccessible * pXAcc)1873 static XAccessible* getTheParentOfMember(XAccessible* pXAcc)
1874 {
1875 // #CHECK#
1876 if(pXAcc == NULL)
1877 {
1878 return NULL;
1879 }
1880 Reference<XAccessibleContext> pRContext = pXAcc->getAccessibleContext();
1881 Reference<XAccessibleRelationSet> pRrelationSet = pRContext->getAccessibleRelationSet();
1882 long nRelations = pRrelationSet->getRelationCount();
1883 for(int i=0 ; i<nRelations ; i++)
1884 {
1885 AccessibleRelation accRelation = pRrelationSet->getRelation(i);
1886 if(accRelation.RelationType == 7)
1887 {
1888 Sequence< Reference< XInterface > > xTargets = accRelation.TargetSet;
1889 return (XAccessible*)xTargets[0].get();
1890 }
1891 }
1892 return NULL;
1893 }
1894
get_groupPosition(long __RPC_FAR * groupLevel,long __RPC_FAR * similarItemsInGroup,long __RPC_FAR * positionInGroup)1895 STDMETHODIMP CMAccessible:: get_groupPosition(long __RPC_FAR *groupLevel,long __RPC_FAR *similarItemsInGroup,long __RPC_FAR *positionInGroup)
1896 {
1897
1898 CHECK_ENABLE_INF
1899 ENTER_PROTECTED_BLOCK
1900 ISDESTROY()
1901 // #CHECK#
1902 if(groupLevel == NULL || similarItemsInGroup == NULL || positionInGroup == NULL)
1903 {
1904 return E_INVALIDARG;
1905 }
1906
1907 Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext();
1908 if(!pRContext.is())
1909 return E_FAIL;
1910 long Role = pRContext->getAccessibleRole();
1911
1912 *groupLevel = 0;
1913 *similarItemsInGroup = 0;
1914 *positionInGroup = 0;
1915
1916 if (Role != AccessibleRole::DOCUMENT)
1917 {
1918 Reference< XAccessibleGroupPosition > xGroupPosition( pRContext, UNO_QUERY );
1919 if ( xGroupPosition.is() )
1920 {
1921 Sequence< sal_Int32 > rSeq = xGroupPosition->getGroupPosition( makeAny( pRContext ) );
1922 sal_Int32* pSeq = rSeq.getArray();
1923 if ( pSeq )
1924 {
1925 *groupLevel = pSeq[0];
1926 *similarItemsInGroup = pSeq[1];
1927 *positionInGroup = pSeq[2];
1928 return S_OK;
1929 }
1930 return S_OK;
1931 }
1932 }
1933
1934 Reference< XAccessible> pParentAcc = pRContext->getAccessibleParent();
1935 if( !pParentAcc.is() )
1936 {
1937 return S_OK;
1938 }
1939
1940 Reference<XAccessibleContext> pRParentContext = pParentAcc->getAccessibleContext();
1941
1942 int level = 0;
1943 int index = 0;
1944 int number = 0;
1945
1946 if( Role == RADIO_BUTTON )
1947 {
1948 Reference<XAccessibleRelationSet> pRrelationSet = pRContext->getAccessibleRelationSet();
1949 long nRel = pRrelationSet->getRelationCount();
1950 for(int i=0 ; i<nRel ; i++)
1951 {
1952 AccessibleRelation accRelation = pRrelationSet->getRelation(i);
1953 if(accRelation.RelationType == 7)
1954 {
1955 Sequence< Reference< XInterface > > xTargets = accRelation.TargetSet;
1956 int nCount = xTargets.getLength();
1957
1958 Reference<XInterface> pRAcc = xTargets[0];
1959 for(int j=0; j<pRParentContext->getAccessibleChildCount(); j++)
1960 {
1961 if( getTheParentOfMember(pRParentContext->getAccessibleChild(j).get())
1962 == (XAccessible*)pRAcc.get() &&
1963 pRParentContext->getAccessibleChild(j)->getAccessibleContext()->getAccessibleRole() == RADIO_BUTTON)
1964 number++;
1965 if(pRParentContext->getAccessibleChild(j).get() == pUNOInterface)
1966 index = number;
1967 }
1968 }
1969 }
1970 *groupLevel = 1;
1971 *similarItemsInGroup = number;
1972 *positionInGroup = index;
1973 return S_OK;
1974 }
1975
1976 else if ( COMBO_BOX == Role )
1977 {
1978 *groupLevel = 1;
1979 *similarItemsInGroup = 0;
1980 *positionInGroup = -1;
1981
1982 long nCount = pRContext->getAccessibleChildCount();
1983 if( 2 != nCount)
1984 {
1985 return S_OK;
1986 }
1987 Reference<XAccessible> xList=pRContext->getAccessibleChild(1);
1988 if (!xList.is())
1989 {
1990 return S_OK;
1991 }
1992 Reference<XAccessibleContext> xListContext(xList,UNO_QUERY);
1993 if (!xListContext.is())
1994 {
1995 return S_OK;
1996 }
1997 Reference<XAccessibleSelection> xListSel(xList,UNO_QUERY);
1998 if (!xListSel.is())
1999 {
2000 return S_OK;
2001 }
2002 *similarItemsInGroup = xListContext->getAccessibleChildCount();
2003 if (*similarItemsInGroup > 0 )
2004 {
2005 try
2006 {
2007 Reference<XAccessible> xChild = xListSel->getSelectedAccessibleChild(0);
2008 if (xChild.is())
2009 {
2010 Reference<XAccessibleContext> xChildContext(xChild,UNO_QUERY);
2011 if (xChildContext.is())
2012 {
2013 *positionInGroup=xChildContext->getAccessibleIndexInParent() + 1 ;
2014 return S_OK;
2015 }
2016 }
2017 }
2018 catch(...)
2019 {}
2020 }
2021 return S_OK;
2022 }
2023 else if ( PAGE_TAB == Role )
2024 {
2025 *groupLevel = 1;
2026 *similarItemsInGroup = pRParentContext->getAccessibleChildCount();
2027
2028 if (*similarItemsInGroup > 0 )
2029 {
2030 *positionInGroup=pRContext->getAccessibleIndexInParent() + 1 ;
2031 }
2032 else
2033 {
2034 *positionInGroup = -1;
2035 }
2036 return S_OK;
2037 }
2038
2039
2040 BOOL isFound = FALSE;
2041 while( pParentAcc.is() && !isFound)
2042 {
2043 level++;
2044 pRParentContext = pParentAcc->getAccessibleContext();
2045 Role = pRParentContext->getAccessibleRole();
2046 if( (Role == TREE) || (Role == LIST) )
2047 isFound = TRUE;
2048 pParentAcc = pRParentContext->getAccessibleParent();
2049 }
2050
2051 if( isFound )
2052 {
2053 Reference< XAccessible> pTempAcc = pRContext->getAccessibleParent();
2054 pRParentContext = pTempAcc->getAccessibleContext();
2055 *groupLevel = level;
2056 *similarItemsInGroup = pRParentContext->getAccessibleChildCount();
2057 *positionInGroup = pRContext->getAccessibleIndexInParent() + 1;
2058 }
2059 else
2060 {
2061 *groupLevel = 0;
2062 *similarItemsInGroup = 0;
2063 *positionInGroup = 0;
2064 }
2065 return S_OK;
2066
2067 LEAVE_PROTECTED_BLOCK
2068 }
2069
get_extendedStates(long,BSTR __RPC_FAR * __RPC_FAR *,long __RPC_FAR *)2070 STDMETHODIMP CMAccessible:: get_extendedStates( long, BSTR __RPC_FAR *__RPC_FAR *, long __RPC_FAR *)
2071 {
2072
2073 CHECK_ENABLE_INF
2074 ENTER_PROTECTED_BLOCK
2075 ISDESTROY()
2076
2077 return E_NOTIMPL;
2078
2079 LEAVE_PROTECTED_BLOCK
2080 }
2081
2082
get_uniqueID(long __RPC_FAR * uniqueID)2083 STDMETHODIMP CMAccessible:: get_uniqueID(long __RPC_FAR *uniqueID)
2084 {
2085
2086 ENTER_PROTECTED_BLOCK
2087 ISDESTROY()
2088 // #CHECK#
2089 if(uniqueID == NULL)
2090 {
2091 return E_INVALIDARG;
2092 }
2093 *uniqueID = m_dChildID;
2094 return S_OK;
2095
2096 LEAVE_PROTECTED_BLOCK
2097 }
2098
get_windowHandle(HWND __RPC_FAR * windowHandle)2099 STDMETHODIMP CMAccessible:: get_windowHandle(HWND __RPC_FAR *windowHandle)
2100 {
2101
2102 ENTER_PROTECTED_BLOCK
2103 ISDESTROY()
2104 // #CHECK#
2105 if(windowHandle == NULL)
2106 {
2107 return E_INVALIDARG;
2108 }
2109
2110 HWND nHwnd = m_hwnd;
2111 IAccessible* pParent = m_pIParent;
2112 CMAccessible* pChild = this;
2113 while((nHwnd==0) && pParent)
2114 {
2115 pChild = (CMAccessible*)pParent;
2116 if(pChild)
2117 {
2118 pParent = (IAccessible*)pChild->m_pIParent;
2119 nHwnd = (HWND)pChild->m_hwnd;
2120 }
2121 else
2122 pParent = NULL;
2123 }
2124
2125 *windowHandle = nHwnd;
2126 return S_OK;
2127
2128 LEAVE_PROTECTED_BLOCK
2129 }
2130
2131 /**
2132 * Get XAccessibleContext directly from UNO by the stored XAccessible pointer
2133 * @param pXAcc, UNO XAccessible object point.
2134 * @return XAccessibleContext*, the context of the pXAcc.
2135 */
GetContextByXAcc(XAccessible * pXAcc)2136 XAccessibleContext* CMAccessible::GetContextByXAcc( XAccessible* pXAcc )
2137 {
2138 Reference< XAccessibleContext > pRContext;
2139 if( pXAcc == NULL)
2140 return NULL;
2141
2142 pRContext = pXAcc->getAccessibleContext();
2143 if( !pRContext.is() )
2144 return NULL;
2145 return pRContext.get();
2146 }
2147
2148 /**
2149 * Return the member variable m_pXAccessibleSelection, instead of
2150 * get XAccessibleSelection according to XAccessibleContext because if so,it will
2151 * depend on the UNO implementation code,so when COM is created, put XAccessibleSelection
2152 * by bridge management system
2153 * @return XAccessibleSelection*, the selection of the current object.
2154 */
GetSelection()2155 Reference< XAccessibleSelection > CMAccessible::GetSelection()
2156 {
2157 if( pUNOInterface == NULL )
2158 return NULL;
2159 Reference< XAccessibleContext > pRContext = pUNOInterface->getAccessibleContext();
2160 if(pRContext.is())
2161 {
2162 Reference< XAccessibleSelection > pRSelection(pRContext,UNO_QUERY);
2163 return pRSelection;
2164 }
2165 return NULL;
2166 }
2167
2168 /**
2169 * Select one XAccessible item, for accSelect implementation
2170 * @param pItem, the item should be selected.
2171 * @return S_OK if successful.
2172 */
SelectChild(XAccessible * pItem)2173 HRESULT CMAccessible::SelectChild(XAccessible* pItem)
2174 {
2175
2176 ENTER_PROTECTED_BLOCK
2177 ISDESTROY()
2178 XAccessibleContext* pParentContext = GetContextByXAcc( pUNOInterface );
2179 XAccessibleContext* pContext = GetContextByXAcc( pItem );
2180 if( pParentContext == NULL || pContext == NULL )
2181 return E_FAIL;
2182
2183 Reference< XAccessibleSelection > pRSelection = GetSelection();
2184 if( !pRSelection.is() )
2185 return E_FAIL;
2186 long Index = pContext->getAccessibleIndexInParent();
2187 pRSelection->selectAccessibleChild( Index );
2188 return S_OK;
2189
2190 LEAVE_PROTECTED_BLOCK
2191 }
2192
2193 /**
2194 * Deselect one XAccessible item, for accSelect implimentation
2195 * @param pItem, the item should be deselected.
2196 * @return S_OK if successful.
2197 */
DeSelectChild(XAccessible * pItem)2198 HRESULT CMAccessible::DeSelectChild(XAccessible* pItem)
2199 {
2200
2201 ENTER_PROTECTED_BLOCK
2202 ISDESTROY()
2203 XAccessibleContext* pParentContext = GetContextByXAcc( pUNOInterface );
2204 ;
2205 XAccessibleContext* pContext = GetContextByXAcc( pItem );
2206 if( pParentContext == NULL || pContext == NULL )
2207 return E_INVALIDARG;
2208
2209 Reference< XAccessibleSelection > pRSelection = GetSelection();
2210 if( !pRSelection.is() )
2211 return E_FAIL;
2212 long Index = pContext->getAccessibleIndexInParent();
2213 pRSelection->deselectAccessibleChild( Index );
2214
2215 return S_OK;
2216
2217 LEAVE_PROTECTED_BLOCK
2218 }
2219
2220 /**
2221 * Select multiple XAccessible items,for implementation of accSelect
2222 * @param pItem, the items should be selected.
2223 * @param size, the size of the items.
2224 * @return S_OK if successful.
2225 */
SelectMultipleChidren(XAccessible ** pItem,int size)2226 HRESULT CMAccessible::SelectMultipleChidren( XAccessible** pItem,int size )
2227 {
2228
2229 ENTER_PROTECTED_BLOCK
2230 ISDESTROY()
2231 // #CHECK#
2232 if(pItem == NULL)
2233 {
2234 return E_INVALIDARG;
2235 }
2236 for(int index = 0;index < size;index++)
2237 {
2238 SelectChild( pItem[index] );
2239 }
2240 return S_OK;
2241
2242 LEAVE_PROTECTED_BLOCK
2243 }
2244
2245 /**
2246 * Deselect multiple XAccessible items,for implementation of accSelect
2247 * @param pItem, the items should be selected.
2248 * @param size, the size of the items.
2249 * @return S_OK if successful.
2250 */
DeSelectMultipleChildren(XAccessible ** pItem,int size)2251 HRESULT CMAccessible::DeSelectMultipleChildren( XAccessible** pItem,int size )
2252 {
2253
2254 ENTER_PROTECTED_BLOCK
2255 ISDESTROY()
2256 // #CHECK#
2257 if(pItem == NULL)
2258 {
2259 return E_INVALIDARG;
2260 }
2261 for(int index = 0;index < size;index++)
2262 {
2263 DeSelectChild( pItem[index] );
2264 }
2265 return S_OK;
2266
2267 LEAVE_PROTECTED_BLOCK
2268 }
2269
2270 /**
2271 * When COM is created, UNO set XAccessible pointer to it
2272 * in order to COM can operate UNO information
2273 * @param pXAcc, the XAccessible object of current object.
2274 * @return S_OK if successful.
2275 */
SetXAccessible(long pXAcc)2276 STDMETHODIMP CMAccessible::SetXAccessible(long pXAcc)
2277 {
2278 pUNOInterface = (XAccessible*)pXAcc;
2279 pRef = pUNOInterface;
2280 m_pEnumVar->PutSelection(/*XAccessibleSelection*/(long)pUNOInterface);
2281
2282 pRContext = pUNOInterface->getAccessibleContext();
2283 pRContextInterface = (XAccessibleContext*)pRContext.is();
2284
2285 return S_OK;
2286 }
2287
2288 /**
2289 * accSelect method has many optional flags, needs to process comprehensively
2290 * Mozilla and Microsoft do not implement SELFLAG_EXTENDSELECTION flag.
2291 * The implementation of this flag is a little trouble-shooting,so we also
2292 * do not implement it now
2293 * @param flagsSelect, the selection flag of the select action.
2294 * @param varChild, the child object pointer of current action.
2295 * @return S_OK if successful.
2296 */
accSelect(long flagsSelect,VARIANT varChild)2297 STDMETHODIMP CMAccessible::accSelect(long flagsSelect, VARIANT varChild)
2298 {
2299
2300 CHECK_ENABLE_INF
2301 ENTER_PROTECTED_BLOCK
2302 ISDESTROY()
2303 if( (flagsSelect&SELFLAG_ADDSELECTION) &&
2304 (SELFLAG_REMOVESELECTION&flagsSelect) )
2305 return E_INVALIDARG;
2306
2307 if ( (flagsSelect&SELFLAG_TAKESELECTION) &&
2308 (
2309 (flagsSelect&SELFLAG_ADDSELECTION) ||
2310 (flagsSelect&SELFLAG_REMOVESELECTION) ||
2311 (flagsSelect&SELFLAG_EXTENDSELECTION )
2312 )
2313 )
2314 return E_INVALIDARG;
2315
2316 if ( varChild.vt != VT_I4 )
2317 return E_INVALIDARG;
2318
2319 IMAccessible* pSelectAcc;
2320 if( varChild.lVal == CHILDID_SELF )
2321 {
2322 pSelectAcc = this;
2323 pSelectAcc->AddRef();
2324 }
2325 else
2326 {
2327 pSelectAcc = GetChildInterface(varChild.lVal);
2328 }
2329
2330 if( pSelectAcc == NULL )
2331 return E_INVALIDARG;
2332
2333 if( flagsSelect&SELFLAG_TAKEFOCUS )
2334 {
2335 long pTempUNO = 0;
2336 pSelectAcc->GetUNOInterface( &pTempUNO);
2337
2338 if( pTempUNO == NULL )
2339 return NULL;
2340
2341 Reference< XAccessibleContext > pRContext = ( (XAccessible*)pTempUNO)->getAccessibleContext();
2342 Reference< XAccessibleComponent > pRComponent(pRContext,UNO_QUERY);
2343 Reference< XAccessible > pRParentXAcc = pRContext->getAccessibleParent();
2344 Reference< XAccessibleContext > pRParentContext = pRParentXAcc->getAccessibleContext();
2345 Reference< XAccessibleComponent > pRParentComponent(pRParentContext,UNO_QUERY);
2346 Reference< XAccessibleSelection > pRParentSelection(pRParentContext,UNO_QUERY);
2347
2348
2349 pRComponent->grabFocus();
2350
2351 if( flagsSelect & SELFLAG_TAKESELECTION )
2352 {
2353 pRParentSelection->clearAccessibleSelection();
2354 pRParentSelection->selectAccessibleChild( pRContext->getAccessibleIndexInParent() );
2355 }
2356
2357 if( flagsSelect & SELFLAG_ADDSELECTION )
2358 {
2359 pRParentSelection->selectAccessibleChild( pRContext->getAccessibleIndexInParent() );
2360 }
2361
2362 if( flagsSelect & SELFLAG_REMOVESELECTION )
2363 {
2364 pRParentSelection->deselectAccessibleChild( pRContext->getAccessibleIndexInParent() );
2365 }
2366
2367 if( flagsSelect & SELFLAG_EXTENDSELECTION )
2368 {
2369 long indexInParrent = pRContext->getAccessibleIndexInParent();
2370
2371 if( pRParentSelection->isAccessibleChildSelected( indexInParrent + 1 ) ||
2372 pRParentSelection->isAccessibleChildSelected( indexInParrent - 1 ) )
2373 {
2374 pRParentSelection->selectAccessibleChild( indexInParrent );
2375 }
2376 }
2377
2378 }
2379
2380 pSelectAcc->Release();
2381 return S_OK;
2382
2383 LEAVE_PROTECTED_BLOCK
2384 }
2385
2386 /**
2387 * Return XAccessible interface pointer when needed
2388 * @param pXAcc, [in, out] the Uno interface of the current object.
2389 * @return S_OK if successful.
2390 */
GetUNOInterface(long * pXAcc)2391 STDMETHODIMP CMAccessible::GetUNOInterface(long* pXAcc)
2392 {
2393 // #CHECK#
2394 if(pXAcc == NULL)
2395 return E_INVALIDARG;
2396
2397 *pXAcc = (long)pUNOInterface;
2398 return S_OK;
2399 }
2400
2401 /**
2402 * Helper method for Implementation of get_accDefaultAction
2403 * @param pAction, the default action point of the current object.
2404 * @return S_OK if successful.
2405 */
SetDefaultAction(long pAction)2406 STDMETHODIMP CMAccessible::SetDefaultAction(long pAction)
2407 {
2408 m_pXAction = (XAccessibleAction*)pAction;
2409 return S_OK;
2410 }
2411
2412 /**
2413 * This method is called when AT open some UI elements initially
2414 * the UI element takes the default action defined here
2415 * @param varChild, the child id of the defaultaction.
2416 * @param pszDefaultAction,[in/out] the description of the current action.
2417 * @return S_OK if successful.
2418 */
get_accDefaultAction(VARIANT varChild,BSTR * pszDefaultAction)2419 HRESULT STDMETHODCALLTYPE CMAccessible::get_accDefaultAction(VARIANT varChild, BSTR *pszDefaultAction)
2420 {
2421
2422 ENTER_PROTECTED_BLOCK
2423 ISDESTROY()
2424 // #CHECK#
2425 if(pszDefaultAction == NULL)
2426 {
2427 return E_INVALIDARG;
2428 }
2429 if(varChild.vt==VT_I4)
2430 {
2431 if(varChild.lVal==CHILDID_SELF)
2432 {
2433 if( m_pXAction == NULL )
2434 return DISP_E_MEMBERNOTFOUND;
2435 SAFE_SYSFREESTRING(*pszDefaultAction);
2436 *pszDefaultAction = SysAllocString(m_pszActionDescription);
2437 return S_OK;
2438 }
2439
2440 long lVal = varChild.lVal;
2441 varChild.lVal = CHILDID_SELF;
2442 IMAccessible *pChild = this->GetChildInterface(lVal);
2443 if(!pChild)
2444 return E_FAIL;
2445 return pChild->get_accDefaultAction(varChild,pszDefaultAction);
2446 }
2447 return S_FALSE;
2448
2449 LEAVE_PROTECTED_BLOCK
2450 }
2451
2452 /**
2453 * AT call this method to operate application
2454 * @param varChild, the child id of the action object.
2455 * @return S_OK if successful.
2456 */
accDoDefaultAction(VARIANT varChild)2457 HRESULT STDMETHODCALLTYPE CMAccessible::accDoDefaultAction(VARIANT varChild)
2458 {
2459
2460 ENTER_PROTECTED_BLOCK
2461 ISDESTROY()
2462 if( varChild.vt != VT_I4 )
2463 return E_INVALIDARG;
2464 if( m_pXAction == NULL )
2465 return E_FAIL;
2466 if( m_pXAction->getAccessibleActionCount() == 0 )
2467 return E_FAIL;
2468
2469 if(varChild.lVal==CHILDID_SELF)
2470 {
2471 if(m_pXAction->getAccessibleActionCount() > 0)
2472 m_pXAction->doAccessibleAction(0);
2473 return S_OK;
2474 }
2475
2476 long lVal = varChild.lVal;
2477 varChild.lVal = CHILDID_SELF;
2478 IMAccessible *pChild = this->GetChildInterface(lVal);
2479 if(!pChild)
2480 return E_FAIL;
2481 return pChild->accDoDefaultAction( varChild );
2482
2483 LEAVE_PROTECTED_BLOCK
2484 }
2485
2486 /**
2487 * UNO set description information for action to COM.
2488 * @param szAction, the action description of the current object.
2489 * @return S_OK if successful.
2490 */
Put_ActionDescription(const OLECHAR * szAction)2491 STDMETHODIMP CMAccessible::Put_ActionDescription( const OLECHAR* szAction)
2492 {
2493
2494 ENTER_PROTECTED_BLOCK
2495 ISDESTROY()
2496 // #CHECK#
2497 if(szAction == NULL)
2498 {
2499 return E_INVALIDARG;
2500 }
2501 SAFE_SYSFREESTRING(m_pszActionDescription );
2502 m_pszActionDescription = SysAllocString( szAction );
2503 return S_OK;
2504
2505 LEAVE_PROTECTED_BLOCK
2506 }
2507
GetXInterfaceFromXAccessible(XAccessible * pXAcc,XInterface ** ppXI,int index)2508 BOOL CMAccessible::GetXInterfaceFromXAccessible(XAccessible* pXAcc, XInterface** ppXI, int index)
2509 {
2510 Reference< XAccessibleContext > pRContext;
2511
2512 switch(index)
2513 {
2514 case XI_COMPONENT:
2515 QUERYXINTERFACE(AccessibleComponent)
2516 break;
2517 case XI_TEXT:
2518 QUERYXINTERFACE(AccessibleText)
2519 break;
2520 case XI_EDITABLETEXT:
2521 QUERYXINTERFACE(AccessibleEditableText)
2522 break;
2523 case XI_TABLE:
2524 QUERYXINTERFACE(AccessibleTable)
2525 break;
2526 case XI_SELECTION:
2527 QUERYXINTERFACE(AccessibleSelection)
2528 break;
2529 case XI_EXTENDEDCOMP:
2530 QUERYXINTERFACE(AccessibleExtendedComponent)
2531 break;
2532 case XI_KEYBINDING:
2533 QUERYXINTERFACE(AccessibleKeyBinding)
2534 break;
2535 case XI_ACTION:
2536 QUERYXINTERFACE(AccessibleAction)
2537 break;
2538 case XI_VALUE:
2539 QUERYXINTERFACE(AccessibleValue)
2540 break;
2541 case XI_HYPERTEXT:
2542 QUERYXINTERFACE(AccessibleHypertext)
2543 break;
2544 case XI_HYPERLINK:
2545 QUERYXINTERFACE(AccessibleHyperlink)
2546 break;
2547 case XI_IMAGE:
2548 QUERYXINTERFACE(AccessibleImage)
2549 break;
2550 default:
2551 break;
2552 }
2553
2554 return FALSE;
2555 }
2556
SmartQI(void * pv,REFIID iid,void ** ppvObject)2557 HRESULT WINAPI CMAccessible::SmartQI(void* pv, REFIID iid, void** ppvObject)
2558 {
2559 ENTER_PROTECTED_BLOCK
2560 ISDESTROY()
2561 if( ImplIsEqualGUID(iid,IID_IAccIdentity) ||
2562 ImplIsEqualGUID(iid,IID_IStdMarshalInfo) ||
2563 ImplIsEqualGUID(iid,IID_IMarshal) ||
2564 ImplIsEqualGUID(iid,IID_IExternalConnection)||
2565 ImplIsEqualGUID(iid,IID_IOleWindow))
2566 return E_FAIL;
2567
2568
2569 _UNO_AGGMAP_ENTRY* pMap = _GetAggEntries();
2570 while(pMap && pMap->piid)
2571 {
2572 if(ImplIsEqualGUID(iid, *pMap->piid))
2573 {
2574 XInterface* pXI = NULL;
2575 BOOL bFound = GetXInterfaceFromXAccessible(pUNOInterface,&pXI,pMap->XIFIndex);
2576 if(!bFound)
2577 {
2578 return E_FAIL;
2579 }
2580
2581 XGUIDToComObjHash::iterator pIndTemp = m_containedObjects.find( iid );
2582 if ( pIndTemp != m_containedObjects.end() )
2583 {
2584 return pIndTemp->second.p->QueryInterface( iid, ppvObject );
2585 }
2586 else
2587 {
2588 ActivateActContext();
2589 HRESULT hr = pMap->pfnCreateInstance(pv, iid, ppvObject);
2590 DeactivateActContext();
2591 if(hr == S_OK)
2592 {
2593 m_containedObjects.insert(XGUIDToComObjHash::value_type(*pMap->piid,(IUnknown*)*ppvObject));
2594 IUNOXWrapper* wrapper = NULL;
2595 ((IUnknown*)*ppvObject)->QueryInterface(IID_IUNOXWrapper, (void**)&wrapper);
2596 if(wrapper)
2597 {
2598 wrapper->put_XInterface((long)pUNOInterface);
2599 wrapper->Release();
2600 }
2601 return S_OK;
2602 }
2603 }
2604 return E_FAIL;
2605 }
2606 pMap++;
2607 }
2608 return E_FAIL;
2609
2610 LEAVE_PROTECTED_BLOCK
2611 }
2612
get_IAccessibleFromXAccessible(long pXAcc,IAccessible ** ppIA)2613 BOOL CMAccessible::get_IAccessibleFromXAccessible(long pXAcc, IAccessible **ppIA)
2614 {
2615
2616 ENTER_PROTECTED_BLOCK
2617
2618 // #CHECK#
2619 if(ppIA == NULL)
2620 {
2621 return E_INVALIDARG;
2622 }
2623 BOOL isGet = FALSE;
2624 if(g_pAgent)
2625 isGet = g_pAgent->GetIAccessibleFromXAccessible((XAccessible*)pXAcc,ppIA);
2626
2627 if(isGet)
2628 return TRUE;
2629 else
2630 return FALSE;
2631
2632 LEAVE_PROTECTED_BLOCK
2633 }
2634
get_OLECHARFromAny(Any & pAny,OLECHAR * pChar)2635 void CMAccessible::get_OLECHARFromAny(Any& pAny, OLECHAR* pChar)
2636 {
2637 // #CHECK#
2638 if(pChar == NULL)
2639 return;
2640
2641 switch(pAny.getValueTypeClass())
2642 {
2643 case TypeClass_CHAR:
2644 {
2645 sal_Int8 val;
2646 pAny >>= val;
2647 swprintf( pChar, L"%d", val);
2648 break;
2649 }
2650 case TypeClass_BOOLEAN:
2651 {
2652 sal_Bool val;
2653 pAny >>= val;
2654 swprintf( pChar, L"%d", val);
2655 break;
2656 }
2657 case TypeClass_BYTE:
2658 {
2659 sal_Int8 val;
2660 pAny >>= val;
2661 swprintf( pChar, L"%d", val);
2662 break;
2663 }
2664 case TypeClass_SHORT:
2665 {
2666 SHORT val;
2667 pAny >>= val;
2668 swprintf( pChar, L"%d", val);
2669 break;
2670 }
2671 case TypeClass_UNSIGNED_SHORT:
2672 {
2673 USHORT val;
2674 pAny >>= val;
2675 swprintf( pChar, L"%d", val);
2676 break;
2677 }
2678 case TypeClass_LONG:
2679 {
2680 LONG val;
2681 pAny >>= val;
2682 swprintf( pChar, L"%ld", val);
2683 break;
2684 }
2685 case TypeClass_UNSIGNED_LONG:
2686 {
2687 ULONG val;
2688 pAny >>= val;
2689 swprintf( pChar, L"%ld", val);
2690 break;
2691 }
2692 case TypeClass_FLOAT:
2693 {
2694 FLOAT val;
2695 pAny >>= val;
2696 swprintf( pChar, L"%.3f", val);
2697 break;
2698 }
2699 case TypeClass_DOUBLE:
2700 {
2701 DOUBLE val;
2702 pAny >>= val;
2703 swprintf( pChar, L"%.6lf", val);
2704 break;
2705 }
2706 case TypeClass_STRING:
2707 {
2708 ::rtl::OUString val;
2709 pAny >>= val;
2710 wcscpy(pChar, val.getStr());
2711 break;
2712 }
2713 case TypeClass_SEQUENCE:
2714 {
2715 if(pAny.getValueType() == getCppuType( (Sequence< ::rtl::OUString > *)0 ) )
2716 {
2717 Sequence < ::rtl::OUString > val;
2718 pAny >>= val;
2719
2720 ::rtl::OUString pString;
2721
2722 int count = val.getLength();
2723
2724 for( int iIndex = 0;iIndex < count;iIndex++ )
2725 {
2726 pString += val[iIndex];
2727 }
2728 wcscpy(pChar, pString.getStr());
2729 }
2730 else if (pAny.getValueType() == getCppuType( (Sequence< ::com::sun::star::style::TabStop >* )0 ) )
2731 {
2732 Sequence < ::com::sun::star::style::TabStop > val;
2733 pAny >>= val;
2734 int count = val.getLength();
2735
2736 for( int iIndex = 0;iIndex < count;iIndex++ )
2737 {
2738 OLECHAR pAttrs[512] = {NULL};
2739
2740 OLECHAR pAttrsPosition[512] = {NULL};
2741 OLECHAR pAttrsDescimalChar[512] = {NULL};
2742 OLECHAR pAttrsFillChar[512] = {NULL};
2743
2744 ::com::sun::star::style::TabStop sigleVal = val[iIndex];
2745
2746 swprintf( pAttrsPosition, L"Position=%ld,TabAlign=%ld",
2747 sigleVal.Position, sigleVal.Alignment);
2748
2749 if(sigleVal.DecimalChar==';' || sigleVal.DecimalChar == ':' || sigleVal.DecimalChar == ',' ||
2750 sigleVal.DecimalChar == '=' || sigleVal.DecimalChar == '\\')
2751 swprintf( pAttrsDescimalChar, L"DecimalChar=\\%c",sigleVal.DecimalChar);
2752 else
2753 swprintf( pAttrsDescimalChar, L"DecimalChar=%c",sigleVal.DecimalChar);
2754
2755 if(sigleVal.FillChar==';' || sigleVal.FillChar == ':' || sigleVal.FillChar == ',' ||
2756 sigleVal.FillChar == '=' || sigleVal.FillChar == '\\')
2757 swprintf( pAttrsFillChar, L"FillChar=\\%c",sigleVal.FillChar);
2758 else
2759 swprintf( pAttrsFillChar, L"FillChar=%c",sigleVal.FillChar);
2760
2761 swprintf( pAttrs, L"%s,%s,%s,",pAttrsPosition,pAttrsDescimalChar,pAttrsFillChar);
2762
2763 wcscat(pChar,pAttrs);
2764 }
2765 }
2766 break;
2767 }
2768 case TypeClass_ENUM:
2769 {
2770 if (pAny.getValueType() == getCppuType( (::com::sun::star::awt::FontSlant* )0 ) )
2771 {
2772 com::sun::star::awt::FontSlant val;
2773 pAny >>= val;
2774 swprintf( pChar, L"%d", val);
2775 }
2776 }
2777 case TypeClass_STRUCT:
2778 {
2779 if (pAny.getValueType() == getCppuType( (::com::sun::star::style::LineSpacing* )0 ) )
2780 {
2781 com::sun::star::style::LineSpacing val;
2782 pAny >>= val;
2783 swprintf( pChar, L"Mode=%ld,Height=%ld,", val.Mode, val.Height);
2784 }
2785 else if (pAny.getValueType() == getCppuType( (com::sun::star::accessibility::TextSegment *)0 ) )
2786 {
2787 com::sun::star::accessibility::TextSegment val;
2788 pAny >>= val;
2789 ::rtl::OUString realVal(val.SegmentText);
2790 wcscpy(pChar, realVal.getStr());
2791 }
2792 break;
2793 }
2794 case TypeClass_VOID:
2795 case TypeClass_HYPER:
2796 case TypeClass_UNSIGNED_HYPER:
2797 case TypeClass_TYPE:
2798 case TypeClass_ANY:
2799 case TypeClass_TYPEDEF:
2800 case TypeClass_UNION:
2801 case TypeClass_EXCEPTION:
2802 case TypeClass_ARRAY:
2803 case TypeClass_INTERFACE:
2804 case TypeClass_SERVICE:
2805 case TypeClass_MODULE:
2806 case TypeClass_INTERFACE_METHOD:
2807 case TypeClass_INTERFACE_ATTRIBUTE:
2808 case TypeClass_UNKNOWN:
2809 case TypeClass_PROPERTY:
2810 case TypeClass_CONSTANT:
2811 case TypeClass_CONSTANTS:
2812 case TypeClass_SINGLETON:
2813 case TypeClass_MAKE_FIXED_SIZE:
2814 break;
2815 default:
2816 break;
2817 }
2818 }
2819
get_OLECHAR4Numbering(const Any & pAny,short numberingLevel,const OUString & numberingPrefix,OLECHAR * pChar)2820 void CMAccessible::get_OLECHAR4Numbering(const Any& pAny, short numberingLevel,const OUString& numberingPrefix,OLECHAR* pChar)
2821 {
2822 if(pChar == NULL)
2823 return;
2824 Reference< ::com::sun::star::container::XIndexReplace > pXIndex;
2825 if((pAny>>=pXIndex) && (numberingLevel !=-1))//numbering level is -1,means invalid value
2826 {
2827 Any aAny = pXIndex->getByIndex(numberingLevel);
2828 Sequence< ::com::sun::star::beans::PropertyValue > aProps;
2829 aAny >>= aProps;
2830 const ::com::sun::star::beans::PropertyValue* pPropArray = aProps.getConstArray();
2831 sal_Int32 nCount = aProps.getLength();
2832 swprintf(pChar,L"Numbering:NumberingLevel=%d,",numberingLevel);
2833 for( sal_Int32 i=0; i<nCount; i++ )
2834 {
2835 ::com::sun::star::beans::PropertyValue rProp = pPropArray[i];
2836 if( (rProp.Name.compareTo(OUString::createFromAscii("BulletChar"))==0)||
2837 (rProp.Name.compareTo(OUString::createFromAscii("GraphicURL"))==0)||
2838 (rProp.Name.compareTo(OUString::createFromAscii("NumberingType"))==0))
2839 {
2840 OLECHAR propStr[512] = {NULL};
2841 swprintf(propStr,L"%s=",rProp.Name.getStr());
2842 OLECHAR pTemp[256] = {NULL};
2843 CMAccessible::get_OLECHARFromAny(rProp.Value,pTemp);
2844 if(rProp.Name.compareTo(OUString::createFromAscii("GraphicURL"))==0)
2845 {
2846 OLECHAR* pOccur = wcschr(pTemp,':');
2847 if(pOccur)
2848 *pOccur = '.';
2849 }
2850 wcscat(propStr,pTemp);
2851 wcscat(pChar,propStr);
2852 wcscat(pChar,L",");
2853
2854 if(rProp.Name.compareTo(OUString::createFromAscii("NumberingType"))==0)
2855 {
2856 if(numberingPrefix.getLength()!=0)
2857 {
2858 swprintf(pTemp,L"NumberingPrefix=%s,",numberingPrefix.getStr());
2859 wcscat(pChar,pTemp);
2860 }
2861 }
2862 }
2863 }
2864 }
2865
2866 //Because now have three types numbering level:
2867 //1.real numbering list,numbering level>=0 and numbering Rule !=NULL;
2868 //2.common paragraph, numbering level >=0, and numbering Rule == NULL;
2869 //3.TOC paragraph, numbering level >0, and numbering Rule ==NULL;
2870 // IAText:numberinglevel base on 0, but TOC's level base on 1,
2871 // so NumberingLevel value will be decreased 1 in bridge code.
2872 else if(numberingLevel >0)
2873 {
2874 swprintf(pChar,L"Numbering:NumberingLevel=%d,NumberingType=4,NumberingPrefix=,",numberingLevel-1);
2875 }
2876 else
2877 {
2878 swprintf(pChar,L"Numbering:");
2879 }
2880 }
2881
ConvertAnyToVariant(const::com::sun::star::uno::Any & rAnyVal,VARIANT * pvData)2882 void CMAccessible::ConvertAnyToVariant(const ::com::sun::star::uno::Any &rAnyVal, VARIANT *pvData)
2883 {
2884 if(rAnyVal.hasValue())
2885 {
2886 // Clear VARIANT variable.
2887 VariantClear(pvData);
2888
2889 // Set value according to value type.
2890 switch(rAnyVal.getValueTypeClass())
2891 {
2892 case TypeClass_CHAR:
2893 pvData->vt = VT_UI1;
2894 memcpy(&pvData->bVal, rAnyVal.getValue(), sizeof(sal_Char));
2895 break;
2896
2897 case TypeClass_BOOLEAN:
2898 pvData->vt = VT_BOOL;
2899 memcpy(&pvData->boolVal, rAnyVal.getValue(), sizeof(sal_Bool));
2900 break;
2901
2902 case TypeClass_BYTE:
2903 pvData->vt = VT_UI1;
2904 memcpy(&pvData->bVal, rAnyVal.getValue(), sizeof(sal_Int8));
2905 break;
2906
2907 case TypeClass_SHORT:
2908 pvData->vt = VT_I2;
2909 memcpy(&pvData->iVal, rAnyVal.getValue(), sizeof(sal_Int16));
2910 break;
2911
2912 case TypeClass_UNSIGNED_SHORT:
2913 pvData->vt = VT_I2;
2914 memcpy(&pvData->iVal, rAnyVal.getValue(), sizeof(sal_uInt16));
2915 break;
2916
2917 case TypeClass_LONG:
2918 pvData->vt = VT_I4;
2919 memcpy(&pvData->lVal, rAnyVal.getValue(), sizeof(sal_Int32));
2920 break;
2921
2922 case TypeClass_UNSIGNED_LONG:
2923 pvData->vt = VT_I4;
2924 memcpy(&pvData->lVal, rAnyVal.getValue(), sizeof(sal_uInt32));
2925 break;
2926
2927 case TypeClass_FLOAT:
2928 pvData->vt = VT_R4;
2929 memcpy(&pvData->fltVal, rAnyVal.getValue(), sizeof(float));
2930 break;
2931
2932 case TypeClass_DOUBLE:
2933 pvData->vt = VT_R8;
2934 memcpy(&pvData->dblVal, rAnyVal.getValue(), sizeof(double));
2935 break;
2936
2937 case TypeClass_STRING:
2938 {
2939 pvData->vt = VT_BSTR;
2940 ::rtl::OUString val;
2941 rAnyVal >>= val;
2942 pvData->bstrVal = SysAllocString((OLECHAR *)val.getStr());
2943 break;
2944 }
2945
2946 case TypeClass_VOID:
2947 case TypeClass_HYPER:
2948 case TypeClass_UNSIGNED_HYPER:
2949 case TypeClass_TYPE:
2950 case TypeClass_ANY:
2951 case TypeClass_ENUM:
2952 case TypeClass_TYPEDEF:
2953 case TypeClass_STRUCT:
2954 case TypeClass_UNION:
2955 case TypeClass_EXCEPTION:
2956 case TypeClass_SEQUENCE:
2957 case TypeClass_ARRAY:
2958 case TypeClass_INTERFACE:
2959 {
2960 Reference< XAccessible > pXAcc;
2961 if(rAnyVal >>= pXAcc)
2962 {
2963 if(pXAcc.is())
2964 {
2965 IAccessible* pIAcc = NULL;
2966 get_IAccessibleFromXAccessible((long)pXAcc.get(), &pIAcc);
2967 if(pIAcc == NULL)
2968 {
2969 Reference< XAccessibleContext > pXAccContext = pXAcc->getAccessibleContext();
2970 g_pAgent->InsertAccObj(pXAcc.get(),pXAccContext->getAccessibleParent().get());
2971 get_IAccessibleFromXAccessible((long)pXAcc.get(), &pIAcc);
2972 }
2973 if(pIAcc)
2974 {
2975 pIAcc->AddRef();
2976
2977 pvData->vt = VT_UNKNOWN;
2978 pvData->pdispVal = (IAccessible2*)pIAcc;
2979 break;
2980 }
2981 }
2982 }
2983 }
2984 case TypeClass_SERVICE:
2985 case TypeClass_MODULE:
2986 case TypeClass_INTERFACE_METHOD:
2987 case TypeClass_INTERFACE_ATTRIBUTE:
2988 case TypeClass_UNKNOWN:
2989 case TypeClass_PROPERTY:
2990 case TypeClass_CONSTANT:
2991 case TypeClass_CONSTANTS:
2992 case TypeClass_SINGLETON:
2993 case TypeClass_MAKE_FIXED_SIZE:
2994 // Output the type string, if there is other uno value type.
2995 pvData->vt = VT_BSTR;
2996 pvData->bstrVal = SysAllocString(rAnyVal.getValueTypeName().getStr());
2997 break;
2998
2999 default:
3000 break;
3001 }
3002 }
3003 else
3004 {
3005 VariantClear(pvData);
3006 }
3007 }
3008
Get_XAccChildID(long * childID)3009 STDMETHODIMP CMAccessible::Get_XAccChildID(long* childID)
3010 {
3011 // #CHECK#
3012 if(childID == NULL)
3013 {
3014 return E_FAIL;
3015 }
3016 *childID = m_dChildID;
3017 return S_OK;
3018 }
get_states(AccessibleStates __RPC_FAR * states)3019 STDMETHODIMP CMAccessible:: get_states(AccessibleStates __RPC_FAR *states )
3020 {
3021
3022 CHECK_ENABLE_INF
3023 ENTER_PROTECTED_BLOCK
3024 ISDESTROY()
3025 // #CHECK XInterface#
3026 if( !pRContext.is() )
3027 return E_FAIL;
3028
3029 Reference<XAccessibleStateSet> pRStateSet = pRContext.get()->getAccessibleStateSet();
3030 if(!pRStateSet.is())
3031 {
3032 return S_OK;
3033 }
3034 Sequence<short> pStates = pRStateSet->getStates();
3035
3036
3037 long count = pStates.getLength() ;
3038 *states = 0x0;
3039 for( int i = 0; i < count; i++ )
3040 {
3041 for( int j = 0; j < sizeof(UNO_STATES) / sizeof(UNO_STATES[0]); j++ )
3042 {
3043 if( pStates[i] == UNO_STATES[j] )
3044 {
3045 *states |= IA2_STATES[j];
3046 break;
3047 }
3048 }
3049 }
3050 return S_OK;
3051
3052
3053 LEAVE_PROTECTED_BLOCK
3054 }
3055
3056 // return the UNO roles
get_extendedRole(BSTR __RPC_FAR *)3057 STDMETHODIMP CMAccessible:: get_extendedRole( BSTR __RPC_FAR * )
3058 {
3059
3060 CHECK_ENABLE_INF
3061 ENTER_PROTECTED_BLOCK
3062 ISDESTROY()
3063
3064 return E_NOTIMPL;
3065
3066 LEAVE_PROTECTED_BLOCK
3067 }
3068
get_localizedExtendedRole(BSTR __RPC_FAR *)3069 STDMETHODIMP CMAccessible:: get_localizedExtendedRole( BSTR __RPC_FAR * )
3070 {
3071
3072 ENTER_PROTECTED_BLOCK
3073 ISDESTROY()
3074 return E_NOTIMPL;
3075
3076 LEAVE_PROTECTED_BLOCK
3077 }
get_nExtendedStates(long __RPC_FAR *)3078 STDMETHODIMP CMAccessible:: get_nExtendedStates( long __RPC_FAR * )
3079 {
3080
3081 CHECK_ENABLE_INF
3082 ENTER_PROTECTED_BLOCK
3083 ISDESTROY()
3084
3085 return E_NOTIMPL;
3086
3087 LEAVE_PROTECTED_BLOCK
3088 }
3089
3090
get_localizedExtendedStates(long,BSTR __RPC_FAR * __RPC_FAR *,long __RPC_FAR *)3091 STDMETHODIMP CMAccessible:: get_localizedExtendedStates( long, BSTR __RPC_FAR *__RPC_FAR *, long __RPC_FAR *)
3092 {
3093
3094 ENTER_PROTECTED_BLOCK
3095 ISDESTROY()
3096 return E_NOTIMPL;
3097
3098 LEAVE_PROTECTED_BLOCK
3099 }
3100
3101
get_indexInParent(long __RPC_FAR * accParentIndex)3102 STDMETHODIMP CMAccessible:: get_indexInParent( long __RPC_FAR *accParentIndex)
3103 {
3104
3105 CHECK_ENABLE_INF
3106 ENTER_PROTECTED_BLOCK
3107 ISDESTROY()
3108 // #CHECK#
3109 if(accParentIndex == NULL)
3110 return E_INVALIDARG;
3111
3112 // #CHECK XInterface#
3113 if( !pRContext.is() )
3114 return E_FAIL;
3115
3116 *accParentIndex = pRContext.get()->getAccessibleIndexInParent();
3117 return S_OK;
3118
3119
3120 LEAVE_PROTECTED_BLOCK
3121 }
get_locale(IA2Locale __RPC_FAR * locale)3122 STDMETHODIMP CMAccessible:: get_locale( IA2Locale __RPC_FAR *locale )
3123 {
3124
3125 CHECK_ENABLE_INF
3126 ENTER_PROTECTED_BLOCK
3127 ISDESTROY()
3128 if(locale == NULL)
3129 return E_INVALIDARG;
3130 // #CHECK XInterface#
3131
3132 if( !pRContext.is() )
3133 return E_FAIL;
3134
3135 ::com::sun::star::lang::Locale unoLoc = pRContext.get()->getLocale();
3136 locale->language = SysAllocString((OLECHAR*)unoLoc.Language.getStr());
3137 locale->country = SysAllocString((OLECHAR*)unoLoc.Country.getStr());
3138 locale->variant = SysAllocString((OLECHAR*)unoLoc.Variant.getStr());
3139
3140 return S_OK;
3141
3142 LEAVE_PROTECTED_BLOCK
3143 }
3144
GetMSAAStateFromUNO(short xState)3145 DWORD GetMSAAStateFromUNO(short xState)
3146 {
3147 DWORD IState = STATE_SYSTEM_UNAVAILABLE;
3148 switch( xState )
3149 {
3150 case /*AccessibleStateType::*/AccessibleStateType::BUSY:
3151 IState = STATE_SYSTEM_BUSY;
3152 break;
3153 case /*AccessibleStateType::*/AccessibleStateType::CHECKED:
3154 IState = STATE_SYSTEM_CHECKED;
3155 break;
3156 case /*AccessibleStateType::*/AccessibleStateType::DEFUNC:
3157 IState = STATE_SYSTEM_UNAVAILABLE;
3158 break;
3159 case /*AccessibleStateType::*/AccessibleStateType::EXPANDED:
3160 IState = STATE_SYSTEM_EXPANDED;
3161 break;
3162 case /*AccessibleStateType::*/AccessibleStateType::FOCUSABLE:
3163 IState = STATE_SYSTEM_FOCUSABLE;
3164 break;
3165 case /*AccessibleStateType::*/AccessibleStateType::FOCUSED:
3166 IState = STATE_SYSTEM_FOCUSED;
3167 break;
3168 case /*AccessibleStateType::*/AccessibleStateType::INDETERMINATE:
3169 IState = STATE_SYSTEM_MIXED;
3170 break;
3171 case /*AccessibleStateType::*/AccessibleStateType::MULTI_SELECTABLE:
3172 IState = STATE_SYSTEM_MULTISELECTABLE;
3173 break;
3174 case /*AccessibleStateType::*/AccessibleStateType::PRESSED:
3175 IState = STATE_SYSTEM_PRESSED;
3176 break;
3177 case /*AccessibleStateType::*/AccessibleStateType::RESIZABLE:
3178 IState = STATE_SYSTEM_SIZEABLE;
3179 break;
3180 case /*AccessibleStateType::*/AccessibleStateType::SELECTABLE:
3181 IState = STATE_SYSTEM_SELECTABLE;
3182 break;
3183 case /*AccessibleStateType::*/AccessibleStateType::SELECTED:
3184 IState = STATE_SYSTEM_SELECTED;
3185 break;
3186 case /*AccessibleStateType::*/AccessibleStateType::ARMED:
3187 IState = STATE_SYSTEM_FOCUSED;
3188 break;
3189 case /*AccessibleStateType::*/AccessibleStateType::EXPANDABLE:
3190 IState = STATE_SYSTEM_COLLAPSED;
3191 break;
3192 default:
3193 break;
3194 }
3195 return IState;
3196 }
3197
get_appName(BSTR __RPC_FAR * name)3198 STDMETHODIMP CMAccessible:: get_appName( BSTR __RPC_FAR *name)
3199 {
3200
3201 ENTER_PROTECTED_BLOCK
3202 ISDESTROY()
3203 if(name == NULL)
3204 return E_INVALIDARG;
3205
3206 *name = SysAllocString(OLESTR("Hannover"));
3207 return S_OK;
3208 LEAVE_PROTECTED_BLOCK
3209 }
get_appVersion(BSTR __RPC_FAR * version)3210 STDMETHODIMP CMAccessible:: get_appVersion(BSTR __RPC_FAR *version)
3211 {
3212
3213 ENTER_PROTECTED_BLOCK
3214 ISDESTROY()
3215 if(version == NULL)
3216 return E_INVALIDARG;
3217 *version=SysAllocString(OLESTR("3.0"));
3218 return S_OK;
3219 LEAVE_PROTECTED_BLOCK
3220 }
get_toolkitName(BSTR __RPC_FAR * name)3221 STDMETHODIMP CMAccessible:: get_toolkitName(BSTR __RPC_FAR *name)
3222 {
3223
3224 ENTER_PROTECTED_BLOCK
3225 ISDESTROY()
3226 if(name == NULL)
3227 return E_INVALIDARG;
3228 *name = SysAllocString(OLESTR(" "));
3229 return S_OK;
3230 LEAVE_PROTECTED_BLOCK
3231 }
get_toolkitVersion(BSTR __RPC_FAR * version)3232 STDMETHODIMP CMAccessible:: get_toolkitVersion(BSTR __RPC_FAR *version)
3233 {
3234
3235 ENTER_PROTECTED_BLOCK
3236 ISDESTROY()
3237 if(version == NULL)
3238 return E_INVALIDARG;
3239 *version = SysAllocString(OLESTR(" "));
3240 return S_OK;
3241 LEAVE_PROTECTED_BLOCK
3242 }
3243
3244
get_attributes(BSTR * pAttr)3245 STDMETHODIMP CMAccessible::get_attributes(/*[out]*/ BSTR *pAttr)
3246 {
3247 ENTER_PROTECTED_BLOCK
3248 ISDESTROY()
3249 CHECK_ENABLE_INF
3250 Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext();
3251 if( !pRContext.is() )
3252 {
3253 return E_FAIL;
3254 }
3255 Reference<XAccessibleExtendedAttributes> pRXI(pRContext,UNO_QUERY);
3256 if( !pRXI.is() )
3257 return E_FAIL;
3258 else
3259 {
3260 com::sun::star::uno::Reference<com::sun::star::accessibility::XAccessibleExtendedAttributes> pRXAttr;
3261 pRXAttr = pRXI.get();
3262 ::com::sun::star::uno::Any anyVal = pRXAttr->getExtendedAttributes();
3263
3264 ::rtl::OUString val;
3265 anyVal >>= val;
3266
3267 if(*pAttr)
3268 SAFE_SYSFREESTRING(*pAttr);
3269 *pAttr = SysAllocString((OLECHAR *)val.getStr());
3270
3271 return S_OK;
3272 }
3273 LEAVE_PROTECTED_BLOCK
3274 }
3275
3276