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 <com/sun/star/uno/Sequence.h> 23 #include <com/sun/star/accessibility/AccessibleStateType.hpp> 24 #include <com/sun/star/accessibility/AccessibleRole.hpp> 25 #include <com/sun/star/accessibility/XAccessibleValue.hpp> 26 #include <com/sun/star/accessibility/XAccessibleComponent.hpp> 27 #include <com/sun/star/accessibility/XAccessibleText.hpp> 28 29 #include <stdlib.h> 30 #include <memory.h> 31 #include <stdio.h> 32 #include <memory.h> 33 #include <algorithm> 34 #include <assert.h> 35 36 #include "AccObject.hxx" 37 #include "AccEventListener.hxx" 38 #include "UAccCOM_i.c" 39 #include "AccResource.hxx" 40 41 #include "act.hxx" 42 43 using namespace std; 44 using namespace com::sun::star::uno; 45 using namespace com::sun::star::accessibility; 46 using namespace com::sun::star::accessibility::AccessibleRole; 47 using namespace com::sun::star::accessibility::AccessibleStateType; 48 49 50 /** 51 * Constructor. 52 * @param pXAcc Uno XAccessible interface of control. 53 * @param Agent The agent kept in all listeners,it's the sole interface by which 54 * listener communicate with windows manager. 55 * @param listener listener that registers in UNO system. 56 * @return. 57 */ 58 AccObject::AccObject(XAccessible* pAcc,AccObjectManagerAgent* pAgent ,AccEventListener* listener) : 59 m_pIMAcc (NULL), 60 m_resID (NULL), 61 m_pParantID (NULL), 62 m_pParentObj(NULL), 63 m_accListener (listener), 64 m_bShouldDestroy(sal_False), 65 m_xAccRef( pAcc ) 66 { 67 sal_Bool bRet = ImplInitilizeCreateObj(); 68 69 m_xAccContextRef = m_xAccRef->getAccessibleContext(); 70 m_xAccActionRef = Reference< XAccessibleAction > (m_xAccContextRef,UNO_QUERY); 71 m_accRole = m_xAccContextRef -> getAccessibleRole(); 72 if( m_pIMAcc ) 73 { 74 m_pIMAcc->SetXAccessible((long) m_xAccRef.get()); 75 m_pIMAcc->Put_XAccAgent((long)pAgent); 76 m_pIMAcc->SetDefaultAction((long)m_xAccActionRef.get()); 77 } 78 } 79 /** 80 * Destructor. 81 * @param 82 * @return 83 */ 84 AccObject::~AccObject() 85 { 86 m_pIMAcc = NULL; 87 m_xAccRef = NULL; 88 m_xAccActionRef = NULL; 89 m_xAccContextRef = NULL; 90 } 91 92 93 94 /** 95 * Insert a child element. 96 * @param pChild Child element that should be inserted into child list. 97 * @param pos Insert postion. 98 * @return 99 */ 100 void AccObject::InsertChild( AccObject* pChild,short pos ) 101 { 102 103 std::vector<AccObject*>::iterator iter; 104 iter = std::find(m_childrenList.begin(),m_childrenList.end(),pChild); 105 if(iter!=m_childrenList.end()) 106 return; 107 if(LAST_CHILD==pos) 108 { 109 m_childrenList.push_back(pChild); 110 } 111 else 112 { 113 std::vector<AccObject*>::iterator iter=m_childrenList.begin()+pos; 114 m_childrenList.insert(iter,pChild); 115 } 116 117 pChild->SetParentObj(this); 118 } 119 120 /** 121 * Delete a child element 122 * @param pChild Child element that should be inserted into child list. 123 * @param pos Insert postion. 124 * @return 125 */ 126 void AccObject::DeleteChild( AccObject* pChild ) 127 { 128 std::vector<AccObject*>::iterator iter; 129 iter = std::find(m_childrenList.begin(),m_childrenList.end(),pChild); 130 if(iter!=m_childrenList.end()) 131 { 132 m_childrenList.erase(iter); 133 if(m_pIMAcc) 134 pChild->SetParentObj(NULL); 135 } 136 } 137 138 /** 139 * In order to windows API WindowFromAccessibleObject,we sometimes to set a pure 140 * top window accessible object created by windows system as top ancestor. 141 * @param. 142 * @return 143 */ 144 void AccObject::UpdateValidWindow() 145 { 146 if(m_pIMAcc) 147 m_pIMAcc->Put_XAccWindowHandle(m_pParantID); 148 } 149 150 /** 151 * Translate all UNO basic information into MSAA com information. 152 * @param 153 * @return If the method is correctly processed. 154 */ 155 sal_Bool AccObject::ImplInitilizeCreateObj() 156 { 157 ActivateActContext(); 158 HRESULT hr = CoCreateInstance( CLSID_MAccessible, NULL, CLSCTX_ALL , 159 IID_IMAccessible, 160 (void **)&m_pIMAcc); 161 DeactivateActContext(); 162 163 if ( S_OK != hr ) 164 { 165 return sal_False; 166 } 167 168 return sal_True; 169 } 170 171 /** 172 * Update name property to com object. 173 * @param 174 * @return 175 */ 176 void AccObject::UpdateName( ) 177 { 178 if (!m_pIMAcc) 179 { 180 return; 181 } 182 183 if( ( TEXT_FRAME == m_accRole ) && ( m_pParentObj !=NULL )&& ( SCROLL_PANE == m_pParentObj -> m_accRole ) ) 184 m_pIMAcc->Put_XAccName( m_pParentObj->m_xAccContextRef->getAccessibleName().getStr() ); 185 if ( PARAGRAPH == m_accRole) 186 { 187 ::rtl::OUString emptyStr = ::rtl::OUString::createFromAscii(""); 188 m_pIMAcc->Put_XAccName(emptyStr.getStr()); 189 } 190 else 191 m_pIMAcc->Put_XAccName(m_xAccContextRef->getAccessibleName().getStr()); 192 193 return ; 194 } 195 /** 196 * Update description property to com object. 197 * no content for update description 198 * @param 199 * @return 200 */ 201 void AccObject::UpdateDescription() 202 { 203 if (!m_pIMAcc) 204 { 205 return; 206 } 207 208 m_pIMAcc->Put_XAccDescription(m_xAccContextRef->getAccessibleDescription().getStr()); 209 return ; 210 } 211 212 /** 213 * Update default action property to com object. 214 * @param 215 * @return 216 */ 217 void AccObject::UpdateAction() 218 { 219 m_xAccActionRef = Reference< XAccessibleAction > (m_xAccContextRef,UNO_QUERY); 220 221 if( m_xAccActionRef.is() && m_pIMAcc ) 222 { 223 if( m_xAccActionRef->getAccessibleActionCount() > 0 ) 224 { 225 UpdateDefaultAction( ); 226 m_pIMAcc->SetDefaultAction((long)m_xAccActionRef.get()); 227 } 228 } 229 } 230 231 /** 232 * Update value property to com object. 233 * @param 234 * @return 235 */ 236 void AccObject::UpdateValue() 237 { 238 if( NULL == m_pIMAcc || !m_xAccContextRef.is() ) 239 { 240 assert(false); 241 return ; 242 } 243 244 Reference< XAccessibleValue > pRValue(m_xAccContextRef.get(),UNO_QUERY); 245 Any pAny; 246 if( pRValue.is() ) 247 { 248 pAny = pRValue->getCurrentValue(); 249 } 250 251 SetValue( pAny ); 252 } 253 254 /** 255 * Set special default action description string via UNO role. 256 * @param Role UNO role 257 * @return 258 */ 259 void AccObject::UpdateDefaultAction( ) 260 { 261 if(!m_xAccActionRef.is()) 262 return ; 263 264 switch(m_accRole) 265 { 266 case PUSH_BUTTON: 267 case TOGGLE_BUTTON: 268 case RADIO_BUTTON: 269 case MENU_ITEM: 270 case RADIO_MENU_ITEM: 271 case CHECK_MENU_ITEM: 272 case LIST_ITEM: 273 case CHECK_BOX: 274 case TREE_ITEM: 275 case BUTTON_DROPDOWN: 276 m_pIMAcc->Put_ActionDescription( m_xAccActionRef->getAccessibleActionDescription((sal_Int32)0).getStr() ); 277 return; 278 } 279 } 280 281 /** 282 * Set value property via pAny. 283 * @param pAny New value. 284 * @return 285 */ 286 void AccObject::SetValue( Any pAny ) 287 { 288 unsigned short pUNumberString[100]; 289 memset( pUNumberString, 0 , sizeof( pUNumberString) ); 290 291 if( NULL == m_pIMAcc || !m_xAccContextRef.is() ) 292 { 293 assert(false); 294 return ; 295 } 296 Reference< XAccessibleText > pRText(m_xAccContextRef,UNO_QUERY); 297 ::rtl::OUString val; 298 int index = 0 ; 299 switch(m_accRole) 300 { 301 case SPIN_BOX: 302 // 3. date editor's msaa value should be the same as spinbox 303 case DATE_EDITOR: 304 case TEXT: 305 case PARAGRAPH: 306 case HEADING: 307 308 if(pRText.get()) 309 { 310 val = pRText->getText(); 311 } 312 m_pIMAcc->Put_XAccValue( val.getStr() ); 313 break; 314 case TREE_ITEM: 315 //case CHECK_BOX: //Commented by Li Xing to disable the value for general checkbox 316 case COMBO_BOX: 317 case TABLE_CELL: 318 case NOTE: 319 case SCROLL_BAR: 320 m_pIMAcc->Put_XAccValue( GetMAccessibleValueFromAny(pAny).getStr() ); 321 break ; 322 // Added by Li Xing, only the checkbox in tree should have the value. 323 case CHECK_BOX: 324 if( ( m_pParentObj !=NULL ) && (TREE == m_pParentObj->m_accRole || TREE_ITEM == m_pParentObj->m_accRole )) 325 m_pIMAcc->Put_XAccValue( GetMAccessibleValueFromAny(pAny).getStr() ); 326 break; 327 default: 328 break; 329 } 330 331 return; 332 333 334 } 335 ::rtl::OUString AccObject::GetMAccessibleValueFromAny(Any pAny) 336 { 337 ::rtl::OUString strValue; 338 339 if(NULL == m_pIMAcc) 340 return strValue; 341 342 if(pAny.getValueType() == getCppuType( (sal_uInt16 *)0 ) ) 343 { 344 sal_uInt16 val; 345 if (pAny >>= val) 346 { 347 strValue=::rtl::OUString::valueOf((sal_Int32)val); 348 349 } 350 } 351 else if(pAny.getValueType() == getCppuType( (::rtl::OUString *)0 ) ) 352 { 353 354 pAny >>= strValue ; 355 356 } 357 else if(pAny.getValueType() == getCppuType( (Sequence< ::rtl::OUString > *)0 ) ) 358 { 359 Sequence< ::rtl::OUString > val; 360 if (pAny >>= val) 361 { 362 363 int count = val.getLength(); 364 365 for( int iIndex = 0;iIndex < count;iIndex++ ) 366 { 367 strValue += val[iIndex]; 368 } 369 370 } 371 } 372 else if(pAny.getValueType() == getCppuType( (double *)0 ) ) 373 { 374 double val; 375 if (pAny >>= val) 376 { 377 strValue=::rtl::OUString::valueOf(val); 378 } 379 } 380 else if(pAny.getValueType() == getCppuType( (sal_Int32 *)0 ) ) 381 { 382 sal_Int32 val; 383 if (pAny >>= val) 384 { 385 strValue=::rtl::OUString::valueOf(val); 386 } 387 } 388 else if (pAny.getValueType() == getCppuType( (com::sun::star::accessibility::TextSegment *)0 ) ) 389 { 390 com::sun::star::accessibility::TextSegment val; 391 if (pAny >>= val) 392 { 393 ::rtl::OUString realVal(val.SegmentText); 394 strValue = realVal; 395 396 } 397 } 398 399 return strValue; 400 } 401 /** 402 * Set name property via pAny. 403 * @param pAny New accessible name. 404 * @return 405 */ 406 void AccObject::SetName( Any pAny) 407 { 408 if( NULL == m_pIMAcc ) 409 return ; 410 411 m_pIMAcc->Put_XAccName( GetMAccessibleValueFromAny(pAny).getStr() ); 412 413 } 414 415 /** 416 * Set description property via pAny. 417 * @param pAny New accessible description. 418 * @return 419 */ 420 void AccObject::SetDescription( Any pAny ) 421 { 422 if( NULL == m_pIMAcc ) 423 return ; 424 m_pIMAcc->Put_XAccDescription( GetMAccessibleValueFromAny(pAny).getStr() ); 425 } 426 427 /** 428 * Set role property via pAny 429 * @param Role New accessible role. 430 * @return 431 */ 432 void AccObject::SetRole( short Role ) 433 { 434 if( NULL == m_pIMAcc ) 435 return ; 436 m_pIMAcc->Put_XAccRole( Role ); 437 } 438 439 /** 440 * Get role property via pAny 441 * @param 442 * @return accessible role 443 */ 444 short AccObject::GetRole() const 445 { 446 return m_accRole; 447 } 448 449 /** 450 * Get MSAA state from UNO state 451 * @Role xState UNO state. 452 * @return 453 */ 454 DWORD AccObject::GetMSAAStateFromUNO(short xState) 455 { 456 DWORD IState = UNO_MSAA_UNMAPPING; 457 458 if( !m_xAccContextRef.is() ) 459 { 460 assert(false); 461 return IState; 462 } 463 short Role = m_accRole; 464 465 switch( xState ) 466 { 467 case BUSY: 468 IState = STATE_SYSTEM_BUSY; 469 break; 470 case CHECKED: 471 if( Role == PUSH_BUTTON || Role == TOGGLE_BUTTON ) 472 { 473 IState = STATE_SYSTEM_PRESSED; 474 } 475 else 476 IState = STATE_SYSTEM_CHECKED; 477 break; 478 case DEFUNC: 479 IState = STATE_SYSTEM_UNAVAILABLE; 480 break; 481 case EXPANDED: 482 IState = STATE_SYSTEM_EXPANDED; 483 break; 484 case FOCUSABLE: 485 IState = STATE_SYSTEM_FOCUSABLE; 486 break; 487 case FOCUSED: 488 IState = STATE_SYSTEM_FOCUSED; 489 break; 490 case INDETERMINATE: 491 IState = STATE_SYSTEM_MIXED; 492 break; 493 case MULTI_SELECTABLE: 494 IState = STATE_SYSTEM_MULTISELECTABLE; 495 break; 496 case PRESSED: 497 IState = STATE_SYSTEM_PRESSED; 498 break; 499 case RESIZABLE: 500 IState = STATE_SYSTEM_SIZEABLE; 501 break; 502 case SELECTABLE: 503 if( m_accRole == MENU || m_accRole == MENU_ITEM) 504 { 505 IState = UNO_MSAA_UNMAPPING; 506 } 507 else 508 { 509 IState = STATE_SYSTEM_SELECTABLE; 510 } 511 break; 512 case SELECTED: 513 if( m_accRole == MENU || m_accRole == MENU_ITEM ) 514 { 515 IState = UNO_MSAA_UNMAPPING; 516 } 517 else 518 { 519 IState = STATE_SYSTEM_SELECTED; 520 } 521 break; 522 case ARMED: 523 IState = STATE_SYSTEM_FOCUSED; 524 break; 525 case EXPANDABLE: 526 { 527 sal_Bool isExpanded = sal_True; 528 sal_Bool isExpandable = sal_True; 529 if( Role == PUSH_BUTTON || Role == TOGGLE_BUTTON || BUTTON_DROPDOWN == Role ) 530 { 531 IState = STATE_SYSTEM_HASPOPUP; 532 } 533 else 534 { 535 GetExpandedState(&isExpandable,&isExpanded); 536 if(!isExpanded) 537 IState = STATE_SYSTEM_COLLAPSED; 538 } 539 } 540 break; 541 //Remove the SENSITIVE state mapping. There is no corresponding MSAA state. 542 //case SENSITIVE: 543 // IState = STATE_SYSTEM_PROTECTED; 544 case EDITABLE: 545 if( m_pIMAcc ) 546 { 547 m_pIMAcc->DecreaseState( STATE_SYSTEM_READONLY ); 548 } 549 break; 550 case OFFSCREEN: 551 IState = STATE_SYSTEM_OFFSCREEN; 552 break; 553 case MOVEABLE: 554 IState = STATE_SYSTEM_MOVEABLE; 555 break; 556 case COLLAPSE: 557 IState = STATE_SYSTEM_COLLAPSED; 558 break; 559 case DEFAULT: 560 IState = STATE_SYSTEM_DEFAULT; 561 break; 562 default: 563 break; 564 } 565 566 return IState; 567 } 568 569 /** 570 * Decrease state of com object 571 * @param xState The lost state. 572 * @return 573 */ 574 void AccObject::DecreaseState( short xState ) 575 { 576 if( NULL == m_pIMAcc ) 577 { 578 return; 579 } 580 581 if( xState == FOCUSABLE) 582 { 583 short Role = m_accRole ; 584 if(Role == MENU_ITEM 585 || Role == RADIO_MENU_ITEM 586 || Role == CHECK_MENU_ITEM) 587 return; 588 else 589 { 590 if (Role == TOGGLE_BUTTON || Role == PUSH_BUTTON || BUTTON_DROPDOWN == Role) 591 { 592 if( ( m_pParentObj !=NULL ) && (TOOL_BAR == m_pParentObj->m_accRole ) ) 593 return; 594 } 595 } 596 } 597 598 else if( xState == AccessibleStateType::VISIBLE ) 599 { 600 m_pIMAcc->IncreaseState( STATE_SYSTEM_INVISIBLE ); 601 } 602 else if( xState == AccessibleStateType::SHOWING ) 603 { 604 m_pIMAcc->IncreaseState( STATE_SYSTEM_OFFSCREEN ); 605 } 606 607 DWORD msState = GetMSAAStateFromUNO(xState); 608 if(msState!=UNO_MSAA_UNMAPPING) 609 m_pIMAcc->DecreaseState(msState); 610 } 611 612 /** 613 * Increase state of com object 614 * @param xState The new state. 615 * @return 616 */ 617 void AccObject::IncreaseState( short xState ) 618 { 619 if( NULL == m_pIMAcc ) 620 { 621 assert(false); 622 return; 623 } 624 625 626 if( xState == AccessibleStateType::VISIBLE ) 627 { 628 m_pIMAcc->DecreaseState( STATE_SYSTEM_INVISIBLE ); 629 } 630 else if( xState == AccessibleStateType::SHOWING ) 631 { 632 m_pIMAcc->DecreaseState( STATE_SYSTEM_OFFSCREEN ); 633 } 634 635 636 DWORD msState = GetMSAAStateFromUNO(xState); 637 if(msState!=UNO_MSAA_UNMAPPING) 638 m_pIMAcc->IncreaseState( msState ); 639 } 640 641 /** 642 * Get next child element 643 * @param 644 * @return AccObject Object interface. 645 */ 646 AccObject* AccObject::NextChild() 647 { 648 IAccChildList::iterator pInd = m_childrenList.begin(); 649 if( pInd != m_childrenList.end() ) 650 return *pInd; 651 return NULL; 652 } 653 /** 654 * update action desciption desc 655 * @param 656 * @return 657 */ 658 void AccObject::UpdateActionDesc() 659 { 660 if (!m_pIMAcc) 661 { 662 return; 663 } 664 665 ::rtl::OUString pXString = m_xAccContextRef->getAccessibleDescription(); 666 m_pIMAcc->Put_XAccDescription(pXString.getStr()); 667 long Role = m_accRole; 668 669 if( Role == PUSH_BUTTON || Role == RADIO_BUTTON || Role == MENU_ITEM || 670 Role == LIST_ITEM || Role == CHECK_BOX || Role == TREE_ITEM || 671 Role == CHECK_MENU_ITEM || Role == RADIO_MENU_ITEM ) 672 { 673 UpdateDefaultAction( ); 674 } 675 else 676 { 677 678 if( m_xAccActionRef.is() ) 679 { 680 if( m_xAccActionRef->getAccessibleActionCount() > 0 ) 681 { 682 if (!(Role == SPIN_BOX || Role == COMBO_BOX || Role == DATE_EDITOR || 683 Role == EDIT_BAR || Role == PASSWORD_TEXT || Role == TEXT)) 684 { 685 pXString = m_xAccActionRef->getAccessibleActionDescription( 0 ); 686 //Solution:If string length is more than zero,action will will be set. 687 if( pXString.getLength() > 0) 688 m_pIMAcc->Put_ActionDescription( pXString.getStr() ); 689 } 690 } 691 } 692 } 693 694 } 695 /** 696 * update role information from uno to com 697 * @param 698 * @return 699 */ 700 void AccObject::UpdateRole() 701 { 702 if (!m_pIMAcc) 703 { 704 return; 705 } 706 707 XAccessibleContext* pContext = m_xAccContextRef.get(); 708 m_pIMAcc->Put_XAccRole( ROLE_SYSTEM_WINDOW ); 709 short iRoleIndex = pContext->getAccessibleRole(); 710 if (( 0 <= iRoleIndex) && ( iRoleIndex <= (sizeof(ROLE_TABLE)/(sizeof(short)*2)))) 711 { 712 short iIA2Role = ROLE_TABLE[iRoleIndex][1] ; 713 m_pIMAcc->Put_XAccRole( iIA2Role ); 714 } 715 716 } 717 /** 718 * update state information from uno to com 719 * @param 720 * @return 721 */ 722 void AccObject::UpdateState() 723 { 724 if (!m_pIMAcc) 725 { 726 return; 727 } 728 729 XAccessibleContext* pContext = m_xAccContextRef.get(); 730 Reference< XAccessibleStateSet > pRState = pContext->getAccessibleStateSet(); 731 if( !pRState.is() ) 732 { 733 assert(false); 734 return ; 735 } 736 737 m_pIMAcc->SetState(0L); 738 739 if ( m_accRole == POPUP_MENU ) 740 { 741 return; 742 } 743 744 Sequence<short> pStates = pRState->getStates(); 745 int count = pStates.getLength(); 746 747 sal_Bool isEnable = sal_False; 748 sal_Bool isShowing = sal_False; 749 sal_Bool isEditable = sal_False; 750 sal_Bool isVisible = sal_False; 751 sal_Bool isFocusable = sal_False; 752 753 for( int iIndex = 0;iIndex < count;iIndex++ ) 754 { 755 if( pStates[iIndex] == ENABLED ) 756 isEnable = sal_True; 757 else if( pStates[iIndex] == SHOWING) 758 isShowing = sal_True; 759 else if( pStates[iIndex] == VISIBLE) 760 isVisible = sal_True; 761 else if( pStates[iIndex] == EDITABLE ) 762 isEditable = sal_True; 763 else if (pStates[iIndex] == FOCUSABLE) 764 isFocusable = sal_True; 765 IncreaseState( pStates[iIndex]); 766 } 767 sal_Bool bIsMenuItem = m_accRole == MENU_ITEM || m_accRole == RADIO_MENU_ITEM || m_accRole == CHECK_MENU_ITEM; 768 769 if(bIsMenuItem) 770 { 771 if(!(isShowing && isVisible) ) 772 { 773 m_pIMAcc->IncreaseState( STATE_SYSTEM_INVISIBLE ); 774 m_pIMAcc->DecreaseState( STATE_SYSTEM_FOCUSABLE ); 775 } 776 } 777 else 778 { 779 if(!(isShowing || isVisible) ) 780 m_pIMAcc->IncreaseState( STATE_SYSTEM_INVISIBLE ); 781 } 782 783 short Role = m_accRole; 784 785 if( m_pIMAcc ) 786 { 787 switch(m_accRole) 788 { 789 case LABEL: 790 m_pIMAcc->IncreaseState( STATE_SYSTEM_READONLY ); 791 break; 792 case TEXT: 793 // 2. editable combobox -> readonly ------ bridge 794 case EMBEDDED_OBJECT: 795 case END_NOTE: 796 case FOOTER: 797 case FOOTNOTE: 798 case GRAPHIC: 799 case HEADER: 800 case HEADING: 801 802 //Image Map 803 case PARAGRAPH: 804 case PASSWORD_TEXT: 805 case SHAPE: 806 case SPIN_BOX: 807 case TABLE: 808 case TABLE_CELL: 809 case TEXT_FRAME: 810 case DATE_EDITOR: 811 case DOCUMENT: 812 case COLUMN_HEADER: 813 { 814 if(!isEditable) 815 m_pIMAcc->IncreaseState( STATE_SYSTEM_READONLY ); 816 } 817 break; 818 default: 819 break; 820 } 821 } 822 823 if( isEnable ) 824 { 825 826 if(!(Role == FILLER || Role == END_NOTE || Role == FOOTER || Role == FOOTNOTE || Role == GROUP_BOX || Role == RULER 827 || Role == HEADER || Role == ICON || Role == INTERNAL_FRAME || Role == LABEL || Role == LAYERED_PANE 828 || Role == SCROLL_BAR || Role == SCROLL_PANE || Role == SPLIT_PANE || Role == STATUS_BAR || Role == TOOL_TIP)) 829 { 830 if( SEPARATOR == Role ) 831 { 832 if( ( m_pParentObj != NULL ) && ( MENU == m_pParentObj->m_accRole || POPUP_MENU == m_pParentObj->m_accRole )) 833 IncreaseState( FOCUSABLE ); 834 } 835 836 else if (TABLE_CELL == Role || TABLE == Role || PANEL == Role || OPTION_PANE == Role || 837 COLUMN_HEADER == Role) 838 { 839 if (isFocusable) 840 IncreaseState( FOCUSABLE ); 841 } 842 else 843 { 844 if(bIsMenuItem) 845 { 846 if ( isShowing && isVisible) 847 { 848 IncreaseState( FOCUSABLE ); 849 } 850 } 851 else 852 { 853 IncreaseState( FOCUSABLE ); 854 } 855 } 856 } 857 } 858 else 859 { 860 m_pIMAcc->IncreaseState( STATE_SYSTEM_UNAVAILABLE ); 861 sal_Bool isDecreaseFocusable = sal_False; 862 if( !((Role == MENU_ITEM) || 863 (Role == RADIO_MENU_ITEM) || 864 (Role == CHECK_MENU_ITEM)) ) 865 { 866 if ( Role == TOGGLE_BUTTON || Role == PUSH_BUTTON || BUTTON_DROPDOWN == Role) 867 { 868 if(( m_pParentObj != NULL )&& (TOOL_BAR == m_pParentObj->m_accRole ) ) 869 IncreaseState( FOCUSABLE ); 870 else 871 DecreaseState( FOCUSABLE ); 872 } 873 else 874 DecreaseState( FOCUSABLE ); 875 } 876 else if( isShowing || isVisible ) 877 { 878 IncreaseState( FOCUSABLE ); 879 } 880 } 881 882 if( m_pIMAcc ) 883 { 884 switch(m_accRole) 885 { 886 case POPUP_MENU: 887 case MENU: 888 if( pContext->getAccessibleChildCount() > 0 ) 889 m_pIMAcc->IncreaseState( STATE_SYSTEM_HASPOPUP ); 890 break; 891 case PASSWORD_TEXT: 892 m_pIMAcc->IncreaseState( STATE_SYSTEM_PROTECTED ); 893 break; 894 default: 895 break; 896 } 897 } 898 899 } 900 /** 901 * update location information from uno to com 902 * @param 903 * @return 904 */ 905 void AccObject::UpdateLocation() 906 { 907 if (!m_pIMAcc) 908 { 909 return; 910 } 911 XAccessibleContext* pContext = m_xAccContextRef.get(); 912 913 Reference< XAccessibleComponent > pRComponent(pContext,UNO_QUERY); 914 if( pRComponent.is() ) 915 { 916 ::com::sun::star::awt::Point pCPoint = pRComponent->getLocationOnScreen(); 917 ::com::sun::star::awt::Size pCSize = pRComponent->getSize(); 918 Location tempLocation; 919 tempLocation.m_dLeft = pCPoint.X; 920 tempLocation.m_dTop = pCPoint.Y; 921 tempLocation.m_dWidth = pCSize.Width; 922 tempLocation.m_dHeight = pCSize.Height; 923 m_pIMAcc->Put_XAccLocation( tempLocation ); 924 } 925 926 } 927 928 929 /** 930 * Public method to mapping information between MSAA and UNO. 931 * @param 932 * @return If the method is correctly processed. 933 */ 934 sal_Bool AccObject:: UpdateAccessibleInfoFromUnoToMSAA ( ) 935 { 936 if( NULL == m_pIMAcc || !m_xAccContextRef.is() ) 937 { 938 assert(false); 939 return sal_False; 940 } 941 942 UpdateName(); 943 944 UpdateValue(); 945 946 UpdateActionDesc(); 947 948 UpdateRole(); 949 950 UpdateLocation(); 951 952 UpdateState(); 953 954 return sal_True; 955 } 956 957 /* 958 * Add a child selected element. 959 * @param pAccObj Child object pointer. 960 * @return 961 */ 962 void AccObject::AddSelect( long index, AccObject* accObj) 963 { 964 m_selectionList.insert(IAccSelectionList::value_type(index,accObj)); 965 } 966 967 IAccSelectionList& AccObject::GetSelection() 968 { 969 return m_selectionList; 970 } 971 972 973 /** 974 * Set self to focus object in parant child list 975 * @param 976 * @return 977 */ 978 void AccObject::setFocus() 979 { 980 if(m_pIMAcc) 981 { 982 IncreaseState(FOCUSED); 983 m_pIMAcc->Put_XAccFocus(CHILDID_SELF); 984 985 UpdateRole(); 986 } 987 } 988 989 /** 990 * Unset self from focus object in parant child list. 991 * @param 992 * @return 993 */ 994 void AccObject::unsetFocus() 995 { 996 if(m_pIMAcc) 997 { 998 DecreaseState( FOCUSED ); 999 m_pIMAcc->Put_XAccFocus(UACC_NO_FOCUS); 1000 } 1001 } 1002 1003 void AccObject::GetExpandedState( sal_Bool* isExpandable, sal_Bool* isExpanded) 1004 { 1005 *isExpanded = sal_False; 1006 *isExpandable = sal_False; 1007 1008 if( !m_xAccContextRef.is() ) 1009 { 1010 return; 1011 } 1012 Reference< XAccessibleStateSet > pRState = m_xAccContextRef->getAccessibleStateSet(); 1013 if( !pRState.is() ) 1014 { 1015 return; 1016 } 1017 1018 Sequence<short> pStates = pRState->getStates(); 1019 int count = pStates.getLength(); 1020 1021 for( int iIndex = 0;iIndex < count;iIndex++ ) 1022 { 1023 if( EXPANDED == pStates[iIndex] ) 1024 { 1025 *isExpanded = sal_True; 1026 } 1027 else if( EXPANDABLE == pStates[iIndex] ) 1028 { 1029 *isExpandable = sal_True; 1030 } 1031 } 1032 } 1033 1034 void AccObject::NotifyDestroy(sal_Bool ifDelete) 1035 { 1036 m_bShouldDestroy=ifDelete; 1037 if(m_pIMAcc) 1038 m_pIMAcc->NotifyDestroy(m_bShouldDestroy); 1039 } 1040 1041 void AccObject::SetParentObj(AccObject* pParentAccObj) 1042 { 1043 m_pParentObj = pParentAccObj; 1044 1045 if(m_pIMAcc) 1046 { 1047 if(m_pParentObj) 1048 { 1049 m_pIMAcc->Put_XAccParent(m_pParentObj->GetIMAccessible()); 1050 } 1051 else 1052 { 1053 m_pIMAcc->Put_XAccParent(NULL); 1054 } 1055 } 1056 } 1057 //ResID means ChildID in MSAA 1058 void AccObject::SetResID(long id) 1059 { 1060 m_resID = id; 1061 if(m_pIMAcc) 1062 m_pIMAcc->Put_XAccChildID(m_resID); 1063 } 1064 //return COM interface in acc object 1065 IMAccessible* AccObject::GetIMAccessible() 1066 { 1067 return m_pIMAcc; 1068 } 1069 1070 Reference < XAccessible > AccObject::GetXAccessible() 1071 { 1072 return m_xAccRef; 1073 } 1074 1075 void AccObject::SetParentHWND(HWND hWnd) 1076 { 1077 m_pParantID = hWnd; 1078 } 1079 void AccObject::SetListener( AccEventListener* Listener ) 1080 { 1081 m_accListener = Listener; 1082 } 1083 AccEventListener* AccObject::getListener() 1084 { 1085 return m_accListener; 1086 } 1087 1088 long AccObject::GetResID() 1089 { 1090 return m_resID; 1091 } 1092 1093 HWND AccObject::GetParentHWND() 1094 { 1095 return m_pParantID; 1096 } 1097 1098 AccObject* AccObject::GetParentObj() 1099 { 1100 return m_pParentObj; 1101 } 1102 sal_Bool AccObject::ifShouldDestroy() 1103 { 1104 return m_bShouldDestroy; 1105 } 1106