winaccessibility/source/service/AccObjectWinManager.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <cassert>
  21
  22 #include <com/sun/star/accessibility/XAccessibleEventBroadcaster.hpp>
  23 #include <com/sun/star/accessibility/XAccessibleEventListener.hpp>
  24 #include <com/sun/star/accessibility/XAccessibleComponent.hpp>
  25 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  26 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  27
  28 #include <oleacc.h>
  29 #include "AccObjectWinManager.hxx"
  30 #include "AccEventListener.hxx"
  31 #include "AccComponentEventListener.hxx"
  32 #include "AccContainerEventListener.hxx"
  33 #include "AccDialogEventListener.hxx"
  34 #include "AccWindowEventListener.hxx"
  35 #include "AccFrameEventListener.hxx"
  36 #include "AccMenuEventListener.hxx"
  37 #include "AccObjectContainerEventListener.hxx"
  38 #include "AccParagraphEventListener.hxx"
  39 #include "AccTextComponentEventListener.hxx"
  40 #include "AccListEventListener.hxx"
  41 #include "AccTreeEventListener.hxx"
  42 #include "AccTableEventListener.hxx"
  43 #include "AccObject.hxx"
  44 #include "unomsaaevent.hxx"
  45
  46
  47 using namespace std;
  48 using namespace com::sun::star::accessibility;
  49 using namespace com::sun::star::accessibility::AccessibleRole;
  50 using namespace com::sun::star::accessibility::AccessibleStateType;
  51 using namespace com::sun::star::uno;
  52
  53 /**
  54    * constructor
  55    * @param   Agent The agent kept in all listeners,it's the sole interface by which
  56    *                listener communicate with windows manager.
  57    *          pEventAccObj The present event accobject.
  58    *          oldFocus     Last focused object.
  59    *          isSelectionChanged flag that identifies if there is selection changed.
  60    *          selectionChildObj  Selected object.
  61    *          dChildID  Chile resource ID.
  62    *          hAcc TopWindowHWND
  63    * @return
  64    */
  65 AccObjectWinManager::AccObjectWinManager( AccObjectManagerAgent* Agent ):
  66         pAgent( Agent ),
  67         oldFocus( NULL )
  68 {
  69 }
  70
  71 /**
  72    * Destructor,clear all resource.
  73    * @param
  74    * @return
  75    */
  76 AccObjectWinManager::~AccObjectWinManager()
  77 {
  78     XIdAccList.clear();
  79     HwndXAcc.clear();
  80     XResIdAccList.clear();
  81     XHWNDDocList.clear();
  82 #ifdef ACC_DEBUG
  83
  84     fclose( pFile );
  85 #endif
  86 }
  87
  88
  89 /**
  90    * Get valid com object interface when notifying some MSAA event
  91    * @param pWND The top window handle that contains that event control.
  92    * @param wParam Windows system interface.
  93    * @return Com interface with event.
  94    */
  95
  96 LRESULT
  97 AccObjectWinManager::Get_ToATInterface(HWND hWnd, long lParam, WPARAM wParam)
  98 {
  99     IMAccessible* pRetIMAcc = NULL;
 100
 101     if(lParam == OBJID_CLIENT )
 102     {
 103         AccObject* topWindowAccObj = GetTopWindowAccObj(hWnd);
 104         if(topWindowAccObj)
 105         {
 106             pRetIMAcc = topWindowAccObj->GetIMAccessible();
 107             if(pRetIMAcc)
 108                 pRetIMAcc->AddRef();//increase COM reference count
 109         }
 110     }
 111
 112     if ( pRetIMAcc && lParam == OBJID_CLIENT )
 113     {
 114         IAccessible* pTemp = dynamic_cast<IAccessible*>( pRetIMAcc );
 115         LRESULT result = LresultFromObject(IID_IAccessible, wParam, pTemp);
 116         pTemp->Release();
 117         return result;
 118     }
 119     return 0;
 120 }
 121
 122 /**
 123    * Search AccObject by XAccessible pointer from our container.
 124    * @param pXAcc XAccessible interface.
 125    * @return Pointer of accObject that is found.
 126    */
 127 AccObject* AccObjectWinManager::GetAccObjByXAcc( XAccessible* pXAcc)
 128 {
 129     if( pXAcc == NULL)
 130         return NULL;
 131
 132     XIdToAccObjHash::iterator pIndTemp = XIdAccList.find( (void*)pXAcc );
 133     if ( pIndTemp == XIdAccList.end() )
 134         return NULL;
 135
 136     return &(pIndTemp->second);
 137 }
 138
 139 /**
 140    * get acc object of top window by its handle
 141    * @param hWnd, top window handle
 142    * @return pointer to AccObject
 143    */
 144 AccObject* AccObjectWinManager::GetTopWindowAccObj(HWND hWnd)
 145 {
 146     XHWNDToXAccHash::iterator iterResult =HwndXAcc.find(hWnd);
 147     if(iterResult == HwndXAcc.end())
 148         return NULL;
 149     XAccessible* pXAcc = (XAccessible*)(iterResult->second);
 150     return GetAccObjByXAcc(pXAcc);
 151 }
 152
 153 /**
 154    * Simulate MSAA event via XAccessible interface and event type.
 155    * @param pXAcc XAccessible interface.
 156    * @param state Customize Interface
 157    * @return The terminate result that identifies if the call is successful.
 158    */
 159 sal_Bool AccObjectWinManager::NotifyAccEvent(XAccessible* pXAcc,short state)
 160 {
 161     Reference< XAccessibleContext > pRContext;
 162
 163     if( pXAcc == NULL)
 164         return sal_False;
 165
 166
 167     pRContext = pXAcc->getAccessibleContext();
 168     if( !pRContext.is() )
 169         return sal_False;
 170
 171
 172     AccObject* selfAccObj= GetAccObjByXAcc(pXAcc);
 173
 174     if(selfAccObj==NULL)
 175         return sal_False;
 176
 177     long dChildID = selfAccObj->GetResID();
 178     HWND hAcc = selfAccObj->GetParentHWND();
 179
 180     switch(state)
 181     {
 182     case UM_EVENT_STATE_FOCUSED:
 183         {
 184             UpdateAccFocus(pXAcc);
 185             if( selfAccObj )
 186                 selfAccObj->UpdateDefaultAction( );
 187             UpdateValue(pXAcc);
 188             NotifyWinEvent( EVENT_OBJECT_FOCUS,hAcc, OBJID_CLIENT,dChildID  );
 189             break;
 190         }
 191     case UM_EVENT_STATE_BUSY:
 192         NotifyWinEvent( EVENT_OBJECT_STATECHANGE,hAcc, OBJID_CLIENT,dChildID  );
 193         break;
 194     case UM_EVENT_STATE_CHECKED:
 195         NotifyWinEvent( EVENT_OBJECT_STATECHANGE,hAcc, OBJID_CLIENT,dChildID  );
 196         break;
 197     case UM_EVENT_STATE_PRESSED:
 198         NotifyWinEvent( EVENT_OBJECT_STATECHANGE,hAcc, OBJID_CLIENT,dChildID  );
 199         break;
 200
 201     //Removed fire out selected event
 202     //case UM_EVENT_STATE_SELECTED:
 203     //  NotifyWinEvent( EVENT_OBJECT_STATECHANGE,hAcc, OBJID_CLIENT,dChildID  );
 204     //  break;
 205     case UM_EVENT_STATE_ARMED:
 206         UpdateAccFocus(pXAcc);
 207         NotifyWinEvent( EVENT_OBJECT_FOCUS,hAcc, OBJID_CLIENT,dChildID  );
 208         break;
 209     case UM_EVENT_MENU_START:
 210         NotifyWinEvent( EVENT_SYSTEM_MENUSTART,hAcc, OBJID_CLIENT,dChildID  );
 211         break;
 212     case UM_EVENT_MENU_END:
 213         NotifyWinEvent( EVENT_SYSTEM_MENUEND,hAcc, OBJID_CLIENT,dChildID  );
 214         break;
 215     case UM_EVENT_MENUPOPUPSTART:
 216         NotifyWinEvent( EVENT_SYSTEM_MENUPOPUPSTART,hAcc, OBJID_CLIENT,dChildID  );
 217         break;
 218     case UM_EVENT_MENUPOPUPEND:
 219         NotifyWinEvent( EVENT_SYSTEM_MENUPOPUPEND,hAcc, OBJID_CLIENT,dChildID  );
 220         break;
 221     case UM_EVENT_SELECTION_CHANGED:
 222         NotifyWinEvent( EVENT_OBJECT_SELECTION,hAcc, OBJID_CLIENT,dChildID  );
 223         break;
 224     case UM_EVENT_SELECTION_CHANGED_ADD:
 225         NotifyWinEvent( EVENT_OBJECT_SELECTIONADD,hAcc, OBJID_CLIENT,dChildID  );
 226         break;
 227     case UM_EVENT_SELECTION_CHANGED_REMOVE:
 228         NotifyWinEvent( EVENT_OBJECT_SELECTIONREMOVE,hAcc, OBJID_CLIENT,dChildID  );
 229         break;
 230     case UM_EVENT_SELECTION_CHANGED_WITHIN:
 231         NotifyWinEvent( EVENT_OBJECT_SELECTIONWITHIN,hAcc, OBJID_CLIENT,dChildID  );
 232         break;
 233     case UM_EVENT_OBJECT_VALUECHANGE:
 234         UpdateValue(pXAcc);
 235         NotifyWinEvent( EVENT_OBJECT_VALUECHANGE,hAcc, OBJID_CLIENT,dChildID  );
 236         break;
 237     case UM_EVENT_OBJECT_NAMECHANGE:
 238         NotifyWinEvent( EVENT_OBJECT_NAMECHANGE,hAcc, OBJID_CLIENT,dChildID  );
 239         break;
 240     case UM_EVENT_OBJECT_DESCRIPTIONCHANGE:
 241         NotifyWinEvent( EVENT_OBJECT_DESCRIPTIONCHANGE,hAcc, OBJID_CLIENT,dChildID  );
 242         break;
 243     case UM_EVENT_OBJECT_DEFACTIONCHANGE:
 244         NotifyWinEvent( IA2_EVENT_ACTION_CHANGED,hAcc, OBJID_CLIENT,dChildID  );
 245         break;
 246     case UM_EVENT_OBJECT_CARETCHANGE:
 247         NotifyWinEvent( IA2_EVENT_TEXT_CARET_MOVED,hAcc, OBJID_CLIENT,dChildID  );
 248         break;
 249     case UM_EVENT_OBJECT_TEXTCHANGE:
 250         NotifyWinEvent( IA2_EVENT_TEXT_CHANGED,hAcc, OBJID_CLIENT,dChildID  );
 251         break;
 252     case UM_EVENT_ACTIVE_DESCENDANT_CHANGED:
 253         UpdateAccFocus(pXAcc);
 254         NotifyWinEvent( EVENT_OBJECT_FOCUS,hAcc, OBJID_CLIENT,dChildID  );
 255         break;
 256     case UM_EVENT_BOUNDRECT_CHANGED:
 257         NotifyWinEvent( EVENT_OBJECT_LOCATIONCHANGE,hAcc, OBJID_CLIENT,dChildID  );
 258         break;
 259     case UM_EVENT_VISIBLE_DATA_CHANGED:
 260         NotifyWinEvent( IA2_EVENT_VISIBLE_DATA_CHANGED,hAcc, OBJID_CLIENT,dChildID  );
 261         break;
 262     case UM_EVENT_SHOW :
 263         NotifyWinEvent( EVENT_OBJECT_SHOW,hAcc, OBJID_CLIENT,dChildID  );
 264         NotifyWinEvent( EVENT_SYSTEM_FOREGROUND,hAcc, OBJID_CLIENT,dChildID  );
 265     break;
 266     case UM_EVENT_TABLE_CAPTION_CHANGED:
 267         NotifyWinEvent( IA2_EVENT_TABLE_CAPTION_CHANGED,hAcc, OBJID_CLIENT,dChildID  );
 268         break;
 269     case UM_EVENT_TABLE_COLUMN_DESCRIPTION_CHANGED:
 270         NotifyWinEvent( IA2_EVENT_TABLE_COLUMN_DESCRIPTION_CHANGED,hAcc, OBJID_CLIENT,dChildID  );
 271         break;
 272     case UM_EVENT_TABLE_COLUMN_HEADER_CHANGED:
 273         NotifyWinEvent( IA2_EVENT_TABLE_COLUMN_HEADER_CHANGED,hAcc, OBJID_CLIENT,dChildID  );
 274         break;
 275     case UM_EVENT_TABLE_MODEL_CHANGED:
 276         NotifyWinEvent( IA2_EVENT_TABLE_MODEL_CHANGED,hAcc, OBJID_CLIENT,dChildID  );
 277         break;
 278     case UM_EVENT_TABLE_ROW_HEADER_CHANGED:
 279         NotifyWinEvent( IA2_EVENT_TABLE_ROW_HEADER_CHANGED,hAcc, OBJID_CLIENT,dChildID  );
 280         break;
 281     case UM_EVENT_TABLE_SUMMARY_CHANGED:
 282         NotifyWinEvent( IA2_EVENT_TABLE_SUMMARY_CHANGED,hAcc, OBJID_CLIENT,dChildID  );
 283         break;
 284     case UM_EVENT_TABLE_ROW_DESCRIPTION_CHANGED:
 285         NotifyWinEvent( IA2_EVENT_TABLE_ROW_DESCRIPTION_CHANGED,hAcc, OBJID_CLIENT,dChildID  );
 286         break;
 287     case UM_EVENT_OBJECT_REORDER:
 288         NotifyWinEvent( EVENT_OBJECT_REORDER,hAcc, OBJID_CLIENT,dChildID  );
 289         break;
 290     case UM_EVENT_PAGE_CHANGED:
 291         NotifyWinEvent( IA2_EVENT_PAGE_CHANGED,hAcc, OBJID_CLIENT,dChildID  );
 292         break;
 293     case UM_EVENT_CHILD_REMOVED:
 294         NotifyWinEvent( EVENT_OBJECT_DESTROY,hAcc, OBJID_CLIENT,dChildID  );
 295         break;
 296     case UM_EVENT_CHILD_ADDED:
 297         NotifyWinEvent( EVENT_OBJECT_CREATE ,hAcc, OBJID_CLIENT,dChildID  );
 298         break;
 299     case UM_EVENT_OBJECT_PAGECHANGED:
 300         NotifyWinEvent( IA2_EVENT_PAGE_CHANGED ,hAcc, OBJID_CLIENT,dChildID  );
 301         break;
 302     case UM_EVENT_TEXT_SELECTION_CHANGED:
 303         NotifyWinEvent( IA2_EVENT_TEXT_SELECTION_CHANGED ,hAcc, OBJID_CLIENT,dChildID  );
 304         break;
 305     case UM_EVENT_SECTION_CHANGED:
 306         NotifyWinEvent( IA2_EVENT_SECTION_CHANGED ,hAcc, OBJID_CLIENT,dChildID  );
 307         break;
 308     case UM_EVENT_COLUMN_CHANGED:
 309         NotifyWinEvent( IA2_EVENT_TEXT_COLUMN_CHANGED ,hAcc, OBJID_CLIENT,dChildID  );
 310         break;
 311     default:
 312         break;
 313     }
 314
 315     return sal_True;
 316 }
 317
 318 /**
 319    * Get Parent XAccessible interface by XAccessible interface.
 320    * @param pXAcc XAccessible interface.
 321    * @return Parent XAccessible interface.
 322    */
 323 XAccessible* AccObjectWinManager::GetParentXAccessible( XAccessible* pXAcc )
 324 {
 325     AccObject* pObj= GetAccObjByXAcc(pXAcc);
 326     if( pObj ==NULL )
 327         return NULL;
 328     if(pObj->GetParentObj())
 329     {
 330         pObj = pObj->GetParentObj();
 331         return pObj->GetXAccessible().get();
 332     }
 333     return NULL;
 334 }
 335
 336 /**
 337    * Get Parent role by XAccessible interface.
 338    * @param pXAcc XAccessible interface.
 339    * @return Parent role.
 340    */
 341 short AccObjectWinManager::GetParentRole( XAccessible* pXAcc )
 342 {
 343     AccObject* pObj= GetAccObjByXAcc(pXAcc);
 344     if( pObj ==NULL )
 345         return -1;
 346     if(pObj->GetParentObj())
 347     {
 348         pObj = pObj->GetParentObj();
 349         if(pObj->GetXAccessible().is())
 350         {
 351             XAccessible* pXAcc = pObj->GetXAccessible().get();
 352             Reference< XAccessibleContext > pRContext = pXAcc->getAccessibleContext();
 353             if(pRContext.is())
 354                 return pRContext->getAccessibleRole();
 355         }
 356     }
 357     return -1;
 358 }
 359
 360 /**
 361    * Update focus objcet by new focused XAccessible interface.
 362    * @param newFocus New XAccessible interface that gets focus.
 363    * @return
 364    */
 365 void AccObjectWinManager::UpdateAccFocus(XAccessible* newFocus)
 366 {
 367     AccObject* pAccObjNew = GetAccObjByXAcc(newFocus);
 368     if(pAccObjNew)
 369     {
 370         AccObject* pAccObjOld = GetAccObjByXAcc(oldFocus);
 371         oldFocus = newFocus;
 372         pAccObjNew->setFocus();
 373         //if old == new, the pAccObjNew will be without focused state
 374         if (pAccObjOld && pAccObjOld != pAccObjNew)
 375             pAccObjOld->unsetFocus();
 376     }
 377 }
 378
 379 /**
 380    * Update selected objcet by new focused XAccessible interface.
 381    * @param pXAcc XAccessible interface that has selected child changed.
 382    * @return Selected children count.
 383    */
 384 int AccObjectWinManager::UpdateAccSelection(XAccessible* pXAcc)
 385 {
 386     Reference< XAccessibleContext > pRContext;
 387
 388     if( pXAcc == NULL)
 389         return sal_False;
 390
 391     pRContext = pXAcc->getAccessibleContext();
 392     if( !pRContext.is() )
 393         return sal_False;
 394
 395     Reference< XAccessibleSelection > pRSelection(pRContext,UNO_QUERY);
 396     if( !pRSelection.is() )
 397         return sal_False;
 398
 399     AccObject* pAccObj = GetAccObjByXAcc(pXAcc);
 400     if(pAccObj==NULL)
 401         return sal_False;
 402
 403     Reference<XAccessible> pRChild = NULL;
 404     AccObject* pAccChildObj = NULL;
 405     int selectNum= pRSelection->getSelectedAccessibleChildCount();
 406
 407     IAccSelectionList oldSelection = pAccObj->GetSelection();
 408
 409     if(selectNum > 4)//for selected.
 410         return selectNum;
 411     if(selectNum == 1 && oldSelection.size() == 0)
 412         return 1;
 413
 414     for (int i=0;i<selectNum;i++)
 415     {
 416         pRChild = pRSelection->getSelectedAccessibleChild(i);
 417         if(!pRChild.is())
 418         {
 419             continue;
 420         }
 421         Reference<XAccessibleContext> pRChildContext = pRChild->getAccessibleContext();
 422         if(!pRChildContext.is())
 423         {
 424             continue;
 425         }
 426         long index = pRChildContext->getAccessibleIndexInParent();
 427         IAccSelectionList::iterator temp = oldSelection.find(index);
 428         if ( temp != oldSelection.end() )
 429         {
 430             oldSelection.erase(index);
 431             continue;
 432         }
 433
 434         pAccChildObj = NULL;
 435         pAccChildObj = GetAccObjByXAcc(pRChild.get());
 436         if(!pAccChildObj)
 437         {
 438             InsertAccObj(pRChild.get(), pXAcc,pAccObj->GetParentHWND());
 439             pAccChildObj = GetAccObjByXAcc(pRChild.get());
 440         }
 441
 442         pAccObj->AddSelect(index, pAccChildObj);
 443
 444         if(pAccChildObj != NULL)
 445             NotifyWinEvent(EVENT_OBJECT_SELECTIONADD,pAccObj->GetParentHWND(), OBJID_CLIENT,pAccChildObj->GetResID());
 446     }
 447
 448     IAccSelectionList::iterator iter = oldSelection.begin();
 449     while(iter!=oldSelection.end())
 450     {
 451         pAccObj->GetSelection().erase(iter->first);
 452         pAccChildObj = (AccObject*)(iter->second);
 453         if(pAccChildObj != NULL)
 454             NotifyWinEvent(EVENT_OBJECT_SELECTIONREMOVE,pAccObj->GetParentHWND(), OBJID_CLIENT,pAccChildObj->GetResID());
 455         ++iter;
 456     }
 457     return 0;
 458
 459 }
 460
 461 /**
 462    * Delete child element from children list.
 463    * @param pObj Child element that should be removed from parant child list.
 464    * @return
 465    */
 466 void AccObjectWinManager::DeleteAccChildNode( AccObject* pObj )
 467 {
 468     AccObject *parentAccObj = pObj->GetParentObj();
 469     if( parentAccObj )
 470         parentAccObj->DeleteChild( pObj );
 471 }
 472
 473 /**
 474    * Delete XAccessible items in top window handle hashtable
 475    * @param pXAcc XAccessible interface.
 476    * @return
 477    */
 478 void AccObjectWinManager::DeleteFromHwndXAcc(XAccessible* pXAcc )
 479 {
 480     XHWNDToXAccHash::iterator iter = HwndXAcc.begin();
 481     while(iter!=HwndXAcc.end())
 482     {
 483         if(iter->second == pXAcc )
 484         {
 485             HwndXAcc.erase(iter);
 486             return;
 487         }
 488         ++iter;
 489     }
 490 }
 491
 492 /**
 493    * Delete all children with the tree root of XAccessible pointer
 494    * @param pXAcc Tree root XAccessible interface.
 495    * @return
 496    */
 497 void AccObjectWinManager::DeleteChildrenAccObj(XAccessible* pXAcc)
 498 {
 499     AccObject* currentObj=NULL;
 500     AccObject* childObj=NULL;
 501
 502     currentObj =  GetAccObjByXAcc( pXAcc);
 503     if(currentObj)
 504     {
 505         childObj = currentObj->NextChild();
 506         while(childObj)
 507         {
 508             XAccessible *const pTmpXAcc = childObj->GetXAccessible().get();
 509             if(pTmpXAcc)
 510             {
 511                 DeleteChildrenAccObj(pTmpXAcc);
 512                 DeleteAccObj(pTmpXAcc);
 513             }
 514             childObj = currentObj->NextChild();
 515         }
 516     }
 517 }
 518
 519 /**
 520    * Delete Acc object self.
 521    * @param pXAcc The XAccessible interface.
 522    * @return
 523    */
 524 void AccObjectWinManager::DeleteAccObj( XAccessible* pXAcc )
 525 {
 526     if( pXAcc == NULL )
 527         return;
 528     XIdToAccObjHash::iterator temp = XIdAccList.find(pXAcc);
 529     if( temp != XIdAccList.end() )
 530     {
 531         ResIdGen.SetSub( temp->second.GetResID() );
 532     }
 533     else
 534     {
 535         return;
 536     }
 537
 538     AccObject& accObj = temp->second;
 539     DeleteAccChildNode( &accObj );
 540     DeleteAccListener( &accObj );
 541     if( accObj.GetIMAccessible() )
 542     {
 543         accObj.GetIMAccessible()->Release();
 544     }
 545     size_t i = XResIdAccList.erase(accObj.GetResID());
 546     assert(i != 0);
 547     DeleteFromHwndXAcc(pXAcc);
 548     if( accObj.GetRole() == DOCUMENT ||
 549         accObj.GetRole() == DOCUMENT_PRESENTATION ||
 550         accObj.GetRole() == DOCUMENT_SPREADSHEET ||
 551         accObj.GetRole() == DOCUMENT_TEXT )
 552     {
 553         XHWNDDocList.erase(accObj.GetParentHWND());
 554     }
 555     XIdAccList.erase(pXAcc); // note: this invalidates accObj so do it last!
 556 }
 557
 558 /**
 559    * Delete listener that inspects some XAccessible object
 560    * @param pAccObj Accobject pointer.
 561    * @return
 562    */
 563 void AccObjectWinManager::DeleteAccListener( AccObject*  pAccObj )
 564 {
 565     AccEventListener* listener = pAccObj->getListener();
 566     if( listener==NULL )
 567         return;
 568     listener->RemoveMeFromBroadcaster();
 569     pAccObj->SetListener(NULL);
 570 }
 571
 572 /**
 573    * Generate a child ID, which is used for AT
 574    * @param
 575    * @return New resource ID.
 576    */
 577 inline long AccObjectWinManager::ImpleGenerateResID()
 578 {
 579     return ResIdGen.GenerateNewResID();
 580 }
 581
 582 /**
 583    * Insert all children of the current acc object
 584    * @param pXAcc XAccessible interface
 585    * @param pWnd  Top Window handle
 586    * @return The calling result.
 587    */
 588 sal_Bool AccObjectWinManager::InsertChildrenAccObj( com::sun::star::accessibility::XAccessible* pXAcc,
 589         HWND pWnd)
 590 {
 591     if(!IsContainer(pXAcc))
 592         return sal_False;
 593
 594     Reference< XAccessibleContext > pRContext;
 595
 596     if( pXAcc == NULL)
 597         return sal_False;
 598     pRContext = pXAcc->getAccessibleContext();
 599     if( !pRContext.is() )
 600         return sal_False;
 601
 602     short role = pRContext->getAccessibleRole();
 603
 604     if(com::sun::star::accessibility::AccessibleRole::DOCUMENT == role ||
 605             com::sun::star::accessibility::AccessibleRole::DOCUMENT_PRESENTATION == role ||
 606             com::sun::star::accessibility::AccessibleRole::DOCUMENT_SPREADSHEET == role ||
 607             com::sun::star::accessibility::AccessibleRole::DOCUMENT_TEXT == role)
 608     {
 609         if(IsStateManageDescendant(pXAcc))
 610         {
 611             return sal_True;
 612         }
 613     }
 614
 615     int count = pRContext->getAccessibleChildCount();
 616     for (int i=0;i<count;i++)
 617     {
 618         Reference<XAccessible> mxAccessible
 619         = pRContext->getAccessibleChild(i);
 620         XAccessible* mpAccessible = mxAccessible.get();
 621         if(mpAccessible != NULL)
 622         {
 623             InsertAccObj( mpAccessible,pXAcc,pWnd );
 624             InsertChildrenAccObj(mpAccessible,pWnd);
 625         }
 626     }
 627
 628     return sal_True;
 629 }
 630
 631 /**
 632    * Insert child object.
 633    * @param pCurObj The child object
 634    * @param pParentObj The parant object
 635    * @param pWnd Top window handle.
 636    * @return
 637    */
 638 void AccObjectWinManager::InsertAccChildNode( AccObject* pCurObj, AccObject* pParentObj, HWND /* pWnd */ )
 639 {
 640     if(pCurObj)
 641     {
 642         if(pParentObj)
 643         {
 644             pParentObj->InsertChild(pCurObj);
 645         }
 646         else
 647         {
 648             pCurObj->UpdateValidWindow();
 649         }
 650     }
 651 }
 652
 653 /**
 654    * Insert child object.
 655    * @param pCurObj The child object
 656    * @param pParentObj The parant object
 657    * @param pWnd Top window handle.
 658    * @return
 659    */
 660 sal_Bool AccObjectWinManager::InsertAccObj( XAccessible* pXAcc,XAccessible* pParentXAcc,HWND pWnd )
 661 {
 662     XIdToAccObjHash::iterator itXacc = XIdAccList.find( (void*)pXAcc );
 663     if (itXacc != XIdAccList.end() )
 664     {
 665         short nCurRole =GetRole(pXAcc);
 666         if (AccessibleRole::SHAPE == nCurRole)
 667         {
 668             AccObject &objXacc = itXacc->second;
 669             AccObject *pObjParent = objXacc.GetParentObj();
 670             if (pObjParent &&
 671                     pObjParent->GetXAccessible().is() &&
 672                     pObjParent->GetXAccessible().get() != pParentXAcc)
 673             {
 674                 XIdToAccObjHash::iterator itXaccParent  = XIdAccList.find( (void*)pParentXAcc );
 675                 if(itXaccParent != XIdAccList.end())
 676                 {
 677                     objXacc.SetParentObj(&(itXaccParent->second));
 678                 }
 679             }
 680         }
 681         return sal_False;
 682     }
 683
 684
 685     Reference< XAccessibleContext > pRContext;
 686
 687     if( pXAcc == NULL)
 688         return sal_False;
 689
 690     pRContext = pXAcc->getAccessibleContext();
 691     if( !pRContext.is() )
 692         return sal_False;
 693
 694     if( pWnd == NULL )
 695     {
 696         if(pParentXAcc)
 697         {
 698             AccObject* pObj = GetAccObjByXAcc(pParentXAcc);
 699             if(pObj)
 700                 pWnd = pObj->GetParentHWND();
 701         }
 702         if( pWnd == NULL )
 703             return sal_False;
 704     }
 705
 706     AccObject pObj( pXAcc,pAgent );
 707     if( pObj.GetIMAccessible() == NULL )
 708         return sal_False;
 709     pObj.SetResID( this->ImpleGenerateResID());
 710     pObj.SetParentHWND( pWnd );
 711
 712     //for file name support
 713     if( pObj.GetRole() == DOCUMENT ||
 714         pObj.GetRole() == DOCUMENT_PRESENTATION ||
 715         pObj.GetRole() == DOCUMENT_SPREADSHEET ||
 716         pObj.GetRole() == DOCUMENT_TEXT )
 717     {
 718         XHWNDToDocumentHash::iterator aIter = XHWNDDocList.find(pWnd);
 719         if ( aIter != XHWNDDocList.end() )
 720         {
 721             XHWNDDocList.erase( aIter );
 722         }
 723         XHWNDDocList.insert( XHWNDToDocumentHash::value_type(pWnd, pXAcc) );
 724     }
 725     //end of file name
 726
 727     ::rtl::Reference<AccEventListener> const pListener =
 728         CreateAccEventListener(pXAcc);
 729     if (!pListener.is())
 730         return sal_False;
 731     Reference<XAccessibleComponent> xComponent(pRContext,UNO_QUERY);
 732     Reference<XAccessibleEventBroadcaster> broadcaster(xComponent,UNO_QUERY);
 733     if (broadcaster.is())
 734     {
 735         Reference<XAccessibleEventListener> const xListener(pListener.get());
 736         broadcaster->addAccessibleEventListener(xListener);
 737     }
 738     else
 739         return sal_False;
 740
 741     XIdAccList.insert( XIdToAccObjHash::value_type( (void*)pXAcc, pObj ));
 742     XIdToAccObjHash::iterator pIndTemp = XIdAccList.find( (void*)pXAcc );
 743     XResIdAccList.insert(XResIdToAccObjHash::value_type(pObj.GetResID(),&(pIndTemp->second)));
 744
 745     AccObject* pCurObj = GetAccObjByXAcc(pXAcc);
 746     if( pCurObj )
 747     {
 748         pCurObj->SetListener(pListener);
 749     }
 750
 751     AccObject* pParentObj = GetAccObjByXAcc(pParentXAcc);
 752     InsertAccChildNode(pCurObj,pParentObj,pWnd);
 753     if( pCurObj )
 754         pCurObj->UpdateAccessibleInfoFromUnoToMSAA();
 755     return sal_True;
 756 }
 757
 758
 759 /**
 760    * save the pair <topwindowhandle, XAccessible>
 761    * @param hWnd, top window handle
 762    * @param pXAcc XAccessible interface for top window
 763    * @return void
 764    */
 765 void AccObjectWinManager::SaveTopWindowHandle(HWND hWnd, com::sun::star::accessibility::XAccessible* pXAcc)
 766 {
 767     HwndXAcc.insert( XHWNDToXAccHash::value_type( hWnd,(void*)pXAcc ) );
 768 }
 769
 770
 771 /** Create the corresponding listener.
 772  *  @param pXAcc XAccessible interface.
 773  */
 774 ::rtl::Reference<AccEventListener>
 775 AccObjectWinManager::CreateAccEventListener(XAccessible* pXAcc)
 776 {
 777     ::rtl::Reference<AccEventListener> pRet;
 778     Reference<XAccessibleContext> xContext(pXAcc->getAccessibleContext(),UNO_QUERY);
 779     if(xContext.is())
 780     {
 781         switch( xContext->getAccessibleRole() )
 782         {
 783         case /*AccessibleRole::*/DIALOG:
 784             pRet = new AccDialogEventListener(pXAcc,pAgent);
 785             break;
 786         case /*AccessibleRole::*/FRAME:
 787             pRet = new AccFrameEventListener(pXAcc,pAgent);
 788             break;
 789         case /*AccessibleRole::*/WINDOW:
 790             pRet = new AccWindowEventListener(pXAcc,pAgent);
 791             break;
 792         case /*AccessibleRole::*/ROOT_PANE:
 793             pRet = new AccFrameEventListener(pXAcc,pAgent);
 794             break;
 795             //Container
 796         case /*AccessibleRole::*/CANVAS:
 797         case /*AccessibleRole::*/COMBO_BOX:
 798         case /*AccessibleRole::*/DOCUMENT:
 799         case /*AccessibleRole::*/DOCUMENT_PRESENTATION:
 800         case /*AccessibleRole::*/DOCUMENT_SPREADSHEET:
 801         case /*AccessibleRole::*/DOCUMENT_TEXT:
 802         case /*AccessibleRole::*/END_NOTE:
 803         case /*AccessibleRole::*/FILLER:
 804         case /*AccessibleRole::*/FOOTNOTE:
 805         case /*AccessibleRole::*/FOOTER:
 806         case /*AccessibleRole::*/HEADER:
 807         case /*AccessibleRole::*/LAYERED_PANE:
 808         case /*AccessibleRole::*/MENU_BAR:
 809         case /*AccessibleRole::*/POPUP_MENU:
 810         case /*AccessibleRole::*/OPTION_PANE:
 811         case /*AccessibleRole::*/PAGE_TAB:
 812         case /*AccessibleRole::*/PAGE_TAB_LIST:
 813         case /*AccessibleRole::*/PANEL:
 814         case /*AccessibleRole::*/SCROLL_PANE:
 815         case /*AccessibleRole::*/SPLIT_PANE:
 816         case /*AccessibleRole::*/STATUS_BAR:
 817         case /*AccessibleRole::*/TABLE_CELL:
 818         case /*AccessibleRole::*/TOOL_BAR:
 819         case /*AccessibleRole::*/VIEW_PORT:
 820             pRet = new AccContainerEventListener(pXAcc,pAgent);
 821             break;
 822         case /*AccessibleRole::*/PARAGRAPH:
 823         case /*AccessibleRole::*/HEADING:
 824             pRet = new AccParagraphEventListener(pXAcc,pAgent);
 825             break;
 826             //Component
 827         case /*AccessibleRole::*/CHECK_BOX:
 828         case /*AccessibleRole::*/ICON:
 829         case /*AccessibleRole::*/LABEL:
 830         case /*AccessibleRole::*/MENU_ITEM:
 831         case /*AccessibleRole::*/CHECK_MENU_ITEM:
 832         case /*AccessibleRole::*/RADIO_MENU_ITEM:
 833         case /*AccessibleRole::*/PUSH_BUTTON:
 834         case /*AccessibleRole::*/RADIO_BUTTON:
 835         case /*AccessibleRole::*/SCROLL_BAR:
 836         case /*AccessibleRole::*/SEPARATOR:
 837         case /*AccessibleRole::*/TOGGLE_BUTTON:
 838         case /*AccessibleRole::*/BUTTON_DROPDOWN:
 839         case /*AccessibleRole::*/TOOL_TIP:
 840         case /*AccessibleRole::*/SPIN_BOX:
 841         case DATE_EDITOR:
 842             pRet = new AccComponentEventListener(pXAcc,pAgent);
 843             break;
 844             //text component
 845         case /*AccessibleRole::*/TEXT:
 846             pRet = new AccTextComponentEventListener(pXAcc,pAgent);
 847             break;
 848             //menu
 849         case /*AccessibleRole::*/MENU:
 850             pRet = new AccMenuEventListener(pXAcc,pAgent);
 851             break;
 852             //object container
 853         case /*AccessibleRole::*/SHAPE:
 854
 855         case /*AccessibleRole::*/EMBEDDED_OBJECT:
 856         case /*AccessibleRole::*/GRAPHIC:
 857         case /*AccessibleRole::*/TEXT_FRAME:
 858             pRet = new AccObjectContainerEventListener(pXAcc,pAgent);
 859             break;
 860             //descendmanager
 861         case /*AccessibleRole::*/LIST:
 862             pRet = new AccListEventListener(pXAcc,pAgent);
 863             break;
 864         case /*AccessibleRole::*/TREE:
 865             pRet = new AccTreeEventListener(pXAcc,pAgent);
 866             break;
 867             //special
 868         case /*AccessibleRole::*/COLUMN_HEADER:
 869         case /*AccessibleRole::*/TABLE:
 870             pRet = new AccTableEventListener(pXAcc,pAgent);
 871             break;
 872         default:
 873             pRet = new AccContainerEventListener(pXAcc,pAgent);
 874             break;
 875         }
 876     }
 877     return pRet;
 878 }
 879
 880 /**
 881    * state is a combination integer, each bit of which represents a single state,
 882    * such as focused,1 for the state on,0 for the state off. Here call COM interface
 883    * to modify the state value, including DecreaseState.
 884    * @param pXAcc XAccessible interface.
 885    * @param pState Changed state.
 886    * @return
 887    */
 888 void AccObjectWinManager::DecreaseState( XAccessible* pXAcc,unsigned short pState )
 889 {
 890     AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
 891     if( pAccObj )
 892         pAccObj->DecreaseState( pState );
 893 }
 894
 895 /**
 896    * state is a combination integer, each bit of which represents a single state,such as focused,1 for
 897    * the state on,0 for the state off. Here call COM interface to modify the state value, including
 898    * IncreaseState.
 899    * @param pXAcc XAccessible interface.
 900    * @param pState Changed state.
 901    * @return
 902    */
 903 void AccObjectWinManager::IncreaseState( XAccessible* pXAcc,unsigned short pState )
 904 {
 905     AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
 906     if( pAccObj )
 907         pAccObj->IncreaseState( pState );
 908 }
 909
 910 void  AccObjectWinManager::UpdateState( com::sun::star::accessibility::XAccessible* pXAcc )
 911 {
 912     AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
 913     if( pAccObj )
 914         pAccObj->UpdateState( );
 915 }
 916
 917 /**
 918    * Set corresponding com object's accessible name via XAccessilbe interface and new
 919    * name
 920    * @param pXAcc XAccessible interface.
 921    * @return
 922    */
 923 void  AccObjectWinManager::UpdateAccName( XAccessible* pXAcc )
 924 {
 925     AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
 926     if( pAccObj )
 927         pAccObj->UpdateName();
 928 }
 929
 930 void  AccObjectWinManager::UpdateAction( XAccessible* pXAcc )
 931 {
 932     AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
 933     if( pAccObj )
 934         pAccObj->UpdateAction();
 935 }
 936
 937 void AccObjectWinManager::UpdateDescription( XAccessible* pXAcc )
 938 {
 939     AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
 940     if ( pAccObj )
 941         pAccObj->UpdateDescription();
 942 }
 943
 944 /**
 945    * Set corresponding com object's accessible location via XAccessilbe interface and new
 946    * location.
 947    * @param pXAcc XAccessible interface.
 948    * @return
 949    */
 950 void  AccObjectWinManager::SetLocation( XAccessible* pXAcc, long /*top*/, long /*left*/, long /*width*/, long /*height*/ )
 951 {
 952     AccObject* pObj = GetAccObjByXAcc( pXAcc );
 953     //get the location from XComponent.
 954     Reference< XAccessibleContext > pRContext = pXAcc->getAccessibleContext();
 955     if( pObj )
 956         pObj->UpdateLocation();
 957 }
 958
 959 /**
 960    * Set corresponding com object's value  via XAccessilbe interface and new value.
 961    * @param pXAcc XAccessible interface.
 962    * @param pAny new value.
 963    * @return
 964    */
 965 void  AccObjectWinManager::SetValue( XAccessible* pXAcc, Any pAny )
 966 {
 967     AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
 968     if( pAccObj )
 969         pAccObj->SetValue( pAny );
 970 }
 971
 972 /**
 973    * Set corresponding com object's value  via XAccessilbe interface.
 974    * @param pXAcc XAccessible interface.
 975    * @return
 976    */
 977 void  AccObjectWinManager::UpdateValue( XAccessible* pXAcc )
 978 {
 979     AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
 980     if( pAccObj )
 981         pAccObj->UpdateValue();
 982 }
 983
 984 /**
 985    * Set corresponding com object's name via XAccessilbe interface and new name.
 986    * @param pXAcc XAccessible interface.
 987    * @param newName new name
 988    * @return
 989    */
 990 void  AccObjectWinManager::SetAccName( XAccessible* pXAcc, Any newName)
 991 {
 992     AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
 993     if( pAccObj )
 994         pAccObj->SetName( newName );
 995 }
 996
 997 /**
 998    * Set corresponding com object's description via XAccessilbe interface and new description.
 999    * @param pXAcc XAccessible interface.
1000    * @param newDesc new description
1001    * @return
1002    */
1003 void  AccObjectWinManager::SetDescription( XAccessible* pXAcc, Any newDesc )
1004 {
1005     AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
1006     if( pAccObj )
1007         pAccObj->SetDescription( newDesc );
1008 }
1009
1010 /**
1011    * Set corresponding com object's role via XAccessilbe interface and new role.
1012    * @param pXAcc XAccessible interface.
1013    * @param Role new role
1014    * @return
1015    */
1016 void  AccObjectWinManager::SetRole( XAccessible* pXAcc, long Role )
1017 {
1018     AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
1019     if( pAccObj )
1020         pAccObj->SetRole( (short)Role );
1021 }
1022
1023 /**
1024    * Judge if a XAccessible object is a container object.
1025    * @param pAccessible XAccessible interface.
1026    * @return If XAccessible object is container.
1027    */
1028 sal_Bool AccObjectWinManager::IsContainer(XAccessible* pAccessible)
1029 {
1030     try
1031     {
1032         if(pAccessible)
1033         {
1034             Reference<XAccessibleContext> xContext(pAccessible->getAccessibleContext(),UNO_QUERY);
1035             if(xContext.is())
1036             {
1037                 switch( xContext->getAccessibleRole() )
1038                 {
1039                 case /*AccessibleRole::*/DIALOG:
1040                 case /*AccessibleRole::*/FRAME:
1041                 case /*AccessibleRole::*/WINDOW:
1042                 case /*AccessibleRole::*/ROOT_PANE:
1043                 case /*AccessibleRole::*/CANVAS:
1044                 case /*AccessibleRole::*/COMBO_BOX:
1045                 case /*AccessibleRole::*/DOCUMENT:
1046                 case /*AccessibleRole::*/DOCUMENT_PRESENTATION:
1047                 case /*AccessibleRole::*/DOCUMENT_SPREADSHEET:
1048                 case /*AccessibleRole::*/DOCUMENT_TEXT:
1049                 case /*AccessibleRole::*/EMBEDDED_OBJECT:
1050                 case /*AccessibleRole::*/END_NOTE:
1051                 case /*AccessibleRole::*/FILLER:
1052                 case /*AccessibleRole::*/FOOTNOTE:
1053                 case /*AccessibleRole::*/FOOTER:
1054                 case /*AccessibleRole::*/GRAPHIC:
1055                 case /*AccessibleRole::*/GROUP_BOX:
1056                 case /*AccessibleRole::*/HEADER:
1057                 case /*AccessibleRole::*/LAYERED_PANE:
1058                 case /*AccessibleRole::*/MENU_BAR:
1059                 case /*AccessibleRole::*/POPUP_MENU:
1060                 case /*AccessibleRole::*/OPTION_PANE:
1061                 case /*AccessibleRole::*/PAGE_TAB:
1062                 case /*AccessibleRole::*/PAGE_TAB_LIST:
1063                 case /*AccessibleRole::*/PANEL:
1064                 case /*AccessibleRole::*/SCROLL_PANE:
1065                 case /*AccessibleRole::*/SPLIT_PANE:
1066                 case /*AccessibleRole::*/STATUS_BAR:
1067                 case /*AccessibleRole::*/TABLE_CELL:
1068                 case /*AccessibleRole::*/TEXT_FRAME:
1069                 case /*AccessibleRole::*/TOOL_BAR:
1070                 case /*AccessibleRole::*/VIEW_PORT:
1071                 case /*AccessibleRole::*/SHAPE:
1072                     return sal_True;
1073                     break;
1074                 case /*AccessibleRole::*/COLUMN_HEADER:
1075                 case /*AccessibleRole::*/TABLE:
1076                     if(!IsStateManageDescendant(pAccessible))
1077                         return sal_True;
1078                     break;
1079                 case /*AccessibleRole::*/MENU:
1080                     return sal_True;
1081                     break;
1082                 default:
1083                     return sal_False;
1084                 }
1085             }
1086         }
1087     }
1088     catch(...)
1089     {
1090         return sal_False;
1091     }
1092     return sal_False;
1093 }
1094
1095 /**
1096    * Judge if a XAccessible object has ManageDescendant event.
1097    * @param pAccessible XAccessible interface.
1098    * @return If XAccessible object is managedescendant.
1099    */
1100 bool AccObjectWinManager::IsStateManageDescendant(XAccessible* pAccessible)
1101 {
1102     if(pAccessible)
1103     {
1104         Reference<XAccessibleContext> xContext(pAccessible->getAccessibleContext(),UNO_QUERY);
1105         if(xContext.is())
1106         {
1107             Reference< XAccessibleStateSet > pRState = xContext->getAccessibleStateSet();
1108             if( !pRState.is() )
1109                 return sal_False;
1110
1111             Sequence<short> pStates = pRState->getStates();
1112             int count = pStates.getLength();
1113             for( int iIndex = 0;iIndex < count;iIndex++ )
1114             {
1115                 if(pStates[iIndex] == /*AccessibleStateType::*/MANAGES_DESCENDANTS)
1116                     return sal_True;
1117             }
1118         }
1119     }
1120     return sal_False;
1121 }
1122
1123 /**
1124    * Query and get IAccessible interface by XAccessible interface from list.
1125    * @param pXAcc XAccessible interface.
1126    * @return Com accobject interface.
1127    */
1128 IMAccessible* AccObjectWinManager::GetIMAccByXAcc(XAccessible* pXAcc)
1129 {
1130     AccObject* pAccObj = GetAccObjByXAcc(pXAcc);
1131     if(pAccObj)
1132     {
1133         return pAccObj->GetIMAccessible();
1134     }
1135     else
1136     {
1137         return NULL;
1138     }
1139 }
1140
1141 /**
1142    * Query and get IAccessible interface by child id from list.
1143    * @param resID, childID.
1144    * @return Com accobject interface.
1145    */
1146 IMAccessible * AccObjectWinManager::GetIAccessibleFromResID(long resID)
1147 {
1148     XResIdToAccObjHash::iterator pIndTemp = XResIdAccList.find( resID );
1149     if ( pIndTemp == XResIdAccList.end() )
1150         return NULL;
1151
1152     AccObject* pObj = pIndTemp->second;
1153
1154     if(pObj->GetIMAccessible())
1155         return pObj->GetIMAccessible();
1156     return NULL;
1157 }
1158 /**
1159    * Notify some object will be destroyed.
1160    * @param pXAcc XAccessible interface.
1161    * @return Com accobject interface.
1162    */
1163 void AccObjectWinManager::NotifyDestroy(XAccessible* pXAcc)
1164 {
1165     AccObject* accObj = GetAccObjByXAcc(pXAcc);
1166     if(accObj)
1167     {
1168         accObj->NotifyDestroy(sal_True);
1169     }
1170 }
1171
1172
1173 void AccObjectWinManager::UpdateChildState(com::sun::star::accessibility::XAccessible* pAccSubMenu)
1174 {
1175     Reference<com::sun::star::accessibility::XAccessibleContext> xContext(pAccSubMenu,UNO_QUERY);
1176     if (!xContext.is())
1177     {
1178         return;
1179     }
1180     sal_Int32 nCount = xContext->getAccessibleChildCount();
1181     for (sal_Int32 i = 0 ; i < nCount ; ++i)
1182     {
1183         Reference<com::sun::star::accessibility::XAccessible> xChild = xContext->getAccessibleChild(i);
1184         if (xChild.is())
1185         {
1186             AccObject *pObj =  GetAccObjByXAcc(xChild.get());
1187             if (pObj)
1188             {
1189                 pObj->UpdateState();
1190             }
1191         }
1192     }
1193 }
1194
1195
1196 bool AccObjectWinManager::IsSpecialToolboItem(com::sun::star::accessibility::XAccessible* pXAcc)
1197 {
1198     if (pXAcc && oldFocus != pXAcc)
1199     {
1200         if(GetParentRole(pXAcc) == TOOL_BAR)
1201         {
1202             Reference< XAccessibleContext > pRContext(pXAcc->getAccessibleContext());
1203             if (pRContext.is())
1204             {
1205                 if(pRContext->getAccessibleRole() == TOGGLE_BUTTON)
1206                 {
1207                     return true;
1208                 }
1209             }
1210         }
1211     }
1212     return false;
1213 }
1214
1215 short AccObjectWinManager::GetRole(com::sun::star::accessibility::XAccessible* pXAcc)
1216 {
1217     assert(pXAcc != NULL);
1218     Reference<com::sun::star::accessibility::XAccessibleContext> xContext(pXAcc->getAccessibleContext(),UNO_QUERY);
1219     if(xContext.is())
1220     {
1221         return xContext->getAccessibleRole();
1222     }
1223     return -1;
1224 }
1225
1226 XAccessible* AccObjectWinManager::GetAccDocByHWND(HWND pWnd)
1227 {
1228     XHWNDToDocumentHash::iterator aIter;
1229     aIter = XHWNDDocList.find( pWnd );
1230     if ( aIter != XHWNDDocList.end() )
1231     {
1232         return aIter->second;
1233     }
1234
1235     return NULL;
1236 }
1237
1238 XAccessible* AccObjectWinManager::GetAccDocByAccTopWin( XAccessible* pXAcc )
1239 {
1240     AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
1241     HWND hWnd = pAccObj->GetParentHWND();
1242     return GetAccDocByHWND(hWnd);
1243 }
1244
1245 bool AccObjectWinManager::IsTopWinAcc( com::sun::star::accessibility::XAccessible* pXAcc )
1246 {
1247     bool bRet = false;
1248     AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
1249     if ( pAccObj )
1250     {
1251         bRet = ( pAccObj->GetParentObj() == NULL );
1252     }
1253     return bRet;
1254 }
1255 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */