winaccessibility/source/service/AccContainerEventListener.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 <com/sun/star/accessibility/XAccessible.hpp>
  21 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  22 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  23 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  24 #include <com/sun/star/accessibility/XAccessibleEventBroadcaster.hpp>
  25
  26 #include <vcl/svapp.hxx>
  27
  28 #include "AccContainerEventListener.hxx"
  29 #include "AccObjectManagerAgent.hxx"
  30 #include "unomsaaevent.hxx"
  31
  32 using namespace com::sun::star::uno;
  33 using namespace com::sun::star::accessibility;
  34
  35 AccContainerEventListener::AccContainerEventListener(com::sun::star::accessibility::XAccessible* pAcc, AccObjectManagerAgent* Agent)
  36         :AccEventListener(pAcc, Agent)
  37 {
  38 }
  39
  40 AccContainerEventListener::~AccContainerEventListener()
  41 {
  42 }
  43
  44 /**
  45  *  Uno's event notifier when event is captured
  46  *
  47  *  @param AccessibleEventObject    the event object which contains information about event
  48  */
  49 void  AccContainerEventListener::notifyEvent( const ::com::sun::star::accessibility::AccessibleEventObject& aEvent )
  50 throw (::com::sun::star::uno::RuntimeException)
  51 {
  52     SolarMutexGuard g;
  53
  54     switch (aEvent.EventId)
  55     {
  56     case AccessibleEventId::CHILD:
  57         HandleChildChangedEvent(aEvent.OldValue, aEvent.NewValue);
  58         break;
  59     case AccessibleEventId::SELECTION_CHANGED:
  60         HandleSelectionChangedEvent(aEvent.OldValue, aEvent.NewValue);
  61         break;
  62     case AccessibleEventId::INVALIDATE_ALL_CHILDREN:
  63         HandleAllChildrenChangedEvent();
  64         break;
  65     case AccessibleEventId::TEXT_CHANGED:
  66         HandleTextChangedEvent(aEvent.OldValue, aEvent.NewValue);
  67     case AccessibleEventId::VISIBLE_DATA_CHANGED:
  68         HandleVisibleDataChangedEvent();
  69         break;
  70     case AccessibleEventId::BOUNDRECT_CHANGED:
  71         HandleBoundrectChangedEvent();
  72         break;
  73     case AccessibleEventId::STATE_CHANGED:
  74         HandleStateChangedEvent(aEvent.OldValue, aEvent.NewValue);
  75         break;
  76     case AccessibleEventId::VALUE_CHANGED:
  77         HandleValueChangedEvent(aEvent.OldValue, aEvent.NewValue);
  78         break;
  79     case AccessibleEventId::SELECTION_CHANGED_ADD:
  80         HandleSelectionChangedAddEvent(aEvent.OldValue, aEvent.NewValue);
  81         break;
  82     case AccessibleEventId::SELECTION_CHANGED_REMOVE:
  83         HandleSelectionChangedRemoveEvent(aEvent.OldValue, aEvent.NewValue);
  84         break;
  85     case AccessibleEventId::SELECTION_CHANGED_WITHIN:
  86         HandleSelectionChangedWithinEvent(aEvent.OldValue, aEvent.NewValue);
  87         break;
  88     case AccessibleEventId::PAGE_CHANGED:
  89         HandlePageChangedEvent(aEvent.OldValue, aEvent.NewValue);
  90         break;
  91     case AccessibleEventId::SECTION_CHANGED:
  92         HandleSectionChangedEvent(aEvent.OldValue, aEvent.NewValue);
  93         break;
  94     case AccessibleEventId::COLUMN_CHANGED:
  95         HandleColumnChangedEvent(aEvent.OldValue, aEvent.NewValue);
  96         break;
  97     default:
  98         AccEventListener::notifyEvent(aEvent);
  99         break;
 100     }
 101 }
 102
 103 void AccContainerEventListener::HandleStateChangedEvent(Any oldValue, Any newValue)
 104 {
 105     short State;
 106     if( newValue >>= State)
 107     {
 108         SetComponentState(State, true);
 109     }
 110     else if (oldValue >>= State)
 111     {
 112         SetComponentState(State, false);
 113     }
 114
 115 }
 116
 117 /**
 118  * handle the CHILD event
 119  * @param   oldValue    the child to be deleted
 120  * @param   newValue    the child to be added
 121  */
 122 void AccContainerEventListener::HandleChildChangedEvent(Any oldValue, Any newValue)
 123 {
 124     Reference< XAccessible > xChild;
 125     if( newValue >>= xChild)
 126     {
 127         //create a new child
 128         if(xChild.is())
 129         {
 130             XAccessible* pAcc = xChild.get();
 131             //add this child
 132
 133             if (pAgent->InsertAccObj(pAcc, m_xAccessible.get()))
 134             {
 135                 //add all oldValue's existing children
 136                 pAgent->InsertChildrenAccObj(pAcc);
 137                 pAgent->NotifyAccEvent(UM_EVENT_CHILD_ADDED, pAcc);
 138             }
 139         }
 140         else
 141         {}
 142     }
 143     else if (oldValue >>= xChild)
 144     {
 145         //delete a existing child
 146         if(xChild.is())
 147         {
 148             XAccessible* pAcc = xChild.get();
 149             pAgent->NotifyAccEvent(UM_EVENT_CHILD_REMOVED, pAcc);
 150             //delete all oldValue's existing children
 151             pAgent->DeleteChildrenAccObj( pAcc );
 152             //delete this child
 153             pAgent->DeleteAccObj( pAcc );
 154
 155         }
 156         else
 157         {}
 158     }
 159
 160 }
 161
 162 /**
 163  * handle the SELECTION_CHANGED event
 164  * @param   oldValue    the old value of the source of event
 165  * @param   newValue    the new value of the source of event
 166  */
 167 void AccContainerEventListener::HandleSelectionChangedEvent(const Any& /*oldValue*/, const Any& newValue)
 168 {
 169     if(NotifyChildEvent(UM_EVENT_SELECTION_CHANGED,newValue))
 170     {
 171         return ;
 172     }
 173
 174     //menu bar does not process selection change event,just same as word behavior
 175     if (GetRole()!=AccessibleRole::MENU_BAR)
 176         pAgent->NotifyAccEvent(UM_EVENT_SELECTION_CHANGED, m_xAccessible.get());
 177 }
 178
 179 /**
 180  *  handle the INVALIDATE_ALL_CHILDREN event
 181  */
 182 void AccContainerEventListener::HandleAllChildrenChangedEvent()
 183 {
 184     //TODO: update all the children
 185     if (m_xAccessible.is())
 186     {
 187         //delete all oldValue's existing children
 188         pAgent->DeleteChildrenAccObj(m_xAccessible.get());
 189         //add all oldValue's existing children
 190         pAgent->InsertChildrenAccObj(m_xAccessible.get());
 191         pAgent->NotifyAccEvent(UM_EVENT_OBJECT_REORDER , m_xAccessible.get());
 192     }
 193 }
 194
 195 /**
 196  *  handle the TEXT_CHANGED event
 197  */
 198 void AccContainerEventListener::HandleTextChangedEvent(Any oldValue, Any newValue)
 199 {
 200     pAgent->UpdateValue(m_xAccessible.get(), newValue);
 201     pAgent->NotifyAccEvent(UM_EVENT_OBJECT_TEXTCHANGE, m_xAccessible.get());
 202 }
 203
 204 /**
 205  * set the new state and fire the MSAA event
 206  * @param   state   new state id
 207  * @param   enable  true if state is set, false if state is unset
 208  */
 209 void AccContainerEventListener::SetComponentState(short state, bool enable )
 210 {
 211     // only the following state can be fired state event.
 212
 213     switch (state)
 214     {
 215     case AccessibleStateType::SELECTED:
 216     case AccessibleStateType::BUSY:
 217     case AccessibleStateType::INDETERMINATE:
 218     case AccessibleStateType::OFFSCREEN:
 219     case AccessibleStateType::FOCUSABLE:
 220     case AccessibleStateType::SHOWING:
 221     case AccessibleStateType::VISIBLE:
 222         FireStatePropertyChange(state, enable);
 223         break;
 224     case AccessibleStateType::FOCUSED:
 225         FireStateFocusedChange(enable);
 226         break;
 227     case AccessibleStateType::ENABLED:
 228         if(enable)
 229         {
 230             pAgent->DecreaseState(m_xAccessible.get(), AccessibleStateType::DEFUNC);
 231             pAgent->IncreaseState(m_xAccessible.get(), AccessibleStateType::FOCUSABLE);
 232             pAgent->UpdateState(m_xAccessible.get());
 233
 234             UpdateAllChildrenState(m_xAccessible.get());
 235         }
 236         else
 237         {
 238             pAgent->IncreaseState(m_xAccessible.get(), AccessibleStateType::DEFUNC);
 239             pAgent->DecreaseState(m_xAccessible.get(), AccessibleStateType::FOCUSABLE);
 240             pAgent->UpdateState(m_xAccessible.get());
 241
 242             UpdateAllChildrenState(m_xAccessible.get());
 243         }
 244         break;
 245     case AccessibleStateType::ACTIVE:
 246         // Only frames should be active
 247         // no msaa state mapping
 248         //for PAGE_TAB_LIST, there will be ACTIVE state, then it should be converted to FOCUSED event.
 249         if (GetRole() == AccessibleRole::PAGE_TAB_LIST)
 250         {
 251             if (!enable) /* get the active state */
 252             {
 253                 pAgent->IncreaseState(m_xAccessible.get(), AccessibleStateType::FOCUSED);
 254             }
 255
 256             else    /* lose the active state */
 257             {
 258                 pAgent->DecreaseState(m_xAccessible.get(), AccessibleStateType::FOCUSED);
 259             }
 260         }
 261         break;
 262
 263     case AccessibleStateType::EXPANDED:
 264     case AccessibleStateType::COLLAPSE:
 265     case AccessibleStateType::CHECKED:
 266         {
 267             pAgent->UpdateState(m_xAccessible.get());
 268             pAgent->NotifyAccEvent(UM_EVENT_STATE_BUSY, m_xAccessible.get());
 269             break;
 270         }
 271
 272     default:
 273         break;
 274     }
 275 }
 276
 277 /**
 278  * fire the MSAA state changed event
 279  * @param   state   the state id
 280  * @param   set     true if state is set, false if state is unset
 281  */
 282 void AccContainerEventListener::FireStatePropertyChange(short state, bool set)
 283 {
 284     if( set )
 285     {
 286         // new value
 287         switch(state)
 288         {
 289         case AccessibleStateType::SELECTED:
 290             pAgent->IncreaseState(m_xAccessible.get(), state);
 291             break;
 292         case AccessibleStateType::INDETERMINATE:
 293         case AccessibleStateType::BUSY:
 294         case AccessibleStateType::FOCUSABLE:
 295         case AccessibleStateType::OFFSCREEN:
 296             pAgent->IncreaseState(m_xAccessible.get(), state);
 297             pAgent->NotifyAccEvent(UM_EVENT_STATE_BUSY, m_xAccessible.get());
 298             break;
 299         case AccessibleStateType::SHOWING:
 300             // UNO !SHOWING == MSAA OFFSCREEN
 301             pAgent->IncreaseState(m_xAccessible.get(), AccessibleStateType::SHOWING);
 302             break;
 303         case AccessibleStateType::VISIBLE:
 304             // UNO !VISIBLE == MSAA INVISIBLE
 305             pAgent->IncreaseState(m_xAccessible.get(), AccessibleStateType::VISIBLE);
 306             break;
 307         default:
 308             break;
 309         }
 310     }
 311     else
 312     {
 313         // old value
 314         switch(state)
 315         {
 316         case AccessibleStateType::SELECTED:
 317             pAgent->DecreaseState(m_xAccessible.get(), state);
 318             break;
 319         case AccessibleStateType::BUSY:
 320         case AccessibleStateType::INDETERMINATE:
 321         case AccessibleStateType::FOCUSABLE:
 322         case AccessibleStateType::OFFSCREEN:
 323             pAgent->DecreaseState(m_xAccessible.get(), state);
 324             pAgent->NotifyAccEvent(UM_EVENT_STATE_BUSY, m_xAccessible.get());
 325             break;
 326         case AccessibleStateType::SHOWING:
 327             // UNO !SHOWING == MSAA OFFSCREEN
 328             pAgent->DecreaseState(m_xAccessible.get(), AccessibleStateType::SHOWING);
 329             break;
 330         case AccessibleStateType::VISIBLE:
 331             // UNO !VISIBLE == MSAA INVISIBLE
 332             pAgent->DecreaseState(m_xAccessible.get(), AccessibleStateType::VISIBLE);
 333             break;
 334         default:
 335             break;
 336         }
 337     }
 338 }
 339
 340 /**
 341  * handle the focused event
 342  * @param   enable  true if get focus, false if lose focus
 343  */
 344 void AccContainerEventListener::FireStateFocusedChange(bool enable)
 345 {
 346     if(enable)
 347     {
 348         pAgent->IncreaseState(m_xAccessible.get(), AccessibleStateType::FOCUSED);
 349         //if the acc role is MENU_BAR, MSAA UM_EVENT_MENU_START event should be sent
 350         //if the acc role is POPUP_MENU, MSAA UM_EVENT_MENUPOPUPSTART event should be sent
 351         short role = GetRole();
 352         if(role == AccessibleRole::MENU_BAR)
 353         {
 354             pAgent->NotifyAccEvent(UM_EVENT_MENU_START, m_xAccessible.get());
 355         }
 356         else if (role == AccessibleRole::POPUP_MENU)
 357             pAgent->NotifyAccEvent(UM_EVENT_MENUPOPUPSTART, m_xAccessible.get());
 358         //Disable the focused event on option_pane and Panel.
 359         //only disable option_pane for toolbar has panel to get focus
 360         else if (role == AccessibleRole::PANEL || role == AccessibleRole::OPTION_PANE )
 361         {
 362             //don't send focused event on PANEL & OPTION_PANE if the parent is not toolbar
 363             short parentRole = GetParentRole();
 364             if (parentRole == AccessibleRole::TOOL_BAR
 365                 || parentRole == AccessibleRole::SCROLL_PANE // sidebar
 366                 || parentRole == AccessibleRole::PANEL) // sidebar
 367                 pAgent->NotifyAccEvent(UM_EVENT_STATE_FOCUSED, m_xAccessible.get());
 368         }
 369         //to update ComboBox's description
 370         else if (role == AccessibleRole::COMBO_BOX )
 371         {
 372             pAgent->UpdateDescription(m_xAccessible.get());
 373             //for editable combobox, send focus event on only edit control,
 374             bool bSendFocusOnCombobox = true;
 375             //send focused event to the first text child
 376             Reference<XAccessibleContext> mxContext(m_xAccessible.get()->getAccessibleContext(), UNO_QUERY);
 377             if(mxContext.is())
 378             {
 379                 Reference<XAccessible> mxChild = mxContext->getAccessibleChild(0);
 380                 if(mxChild.is())
 381                 {
 382                     Reference<XAccessibleContext> mxChildContext(mxChild->getAccessibleContext(),UNO_QUERY);
 383                     short childrole = mxChildContext->getAccessibleRole();
 384                     if (childrole == AccessibleRole::TEXT)
 385                     {
 386                         if (IsEditable(mxChildContext))
 387                         {
 388                             pAgent->DecreaseState(m_xAccessible.get(), AccessibleStateType::FOCUSED);
 389                             pAgent->IncreaseState( mxChild.get(), AccessibleStateType::FOCUSED);
 390                             pAgent->NotifyAccEvent(UM_EVENT_STATE_FOCUSED, mxChild.get());
 391                             bSendFocusOnCombobox = false;
 392                         }
 393                     }
 394                 }
 395             }
 396             if (bSendFocusOnCombobox)
 397                 pAgent->NotifyAccEvent(UM_EVENT_STATE_FOCUSED, m_xAccessible.get());
 398         }
 399         else
 400             pAgent->NotifyAccEvent(UM_EVENT_STATE_FOCUSED, m_xAccessible.get());
 401     }
 402     else
 403     {
 404         pAgent->DecreaseState(m_xAccessible.get(), AccessibleStateType::FOCUSED);
 405         //if the acc role is MENU_BAR, MSAA UM_EVENT_MENU_END event should be sent
 406         //if the acc role is POPUP_MENU, MSAA UM_EVENT_MENUPOPUPEND event should be sent
 407         if (GetRole() == AccessibleRole::MENU_BAR)
 408         {
 409             pAgent->NotifyAccEvent(UM_EVENT_MENU_END, m_xAccessible.get());
 410         }
 411         else if (GetRole() == AccessibleRole::POPUP_MENU)
 412         {
 413             pAgent->NotifyAccEvent(UM_EVENT_MENUPOPUPEND, m_xAccessible.get());
 414         }
 415     }
 416 }
 417
 418 /**
 419  * handle the VALUE_CHANGED event
 420  *
 421  * @param   oldValue    the old value of the source of event
 422  * @param   newValue    the new value of the source of event
 423  */
 424 void AccContainerEventListener::HandleValueChangedEvent(Any oldValue, Any newValue)
 425 {
 426     pAgent->UpdateValue(m_xAccessible.get());
 427     pAgent->NotifyAccEvent(UM_EVENT_OBJECT_VALUECHANGE, m_xAccessible.get());
 428 }
 429
 430 bool AccContainerEventListener::IsEditable(Reference<XAccessibleContext> xContext)
 431 {
 432     bool ret = false;
 433     Reference< XAccessibleStateSet > pRState = xContext->getAccessibleStateSet();
 434     if( !pRState.is() )
 435         return false;
 436
 437     Sequence<short> pStates = pRState->getStates();
 438     int count = pStates.getLength();
 439     for( int iIndex = 0;iIndex < count;iIndex++ )
 440     {
 441         if(pStates[iIndex] == AccessibleStateType::EDITABLE)
 442             return true;
 443     }
 444     return ret;
 445 }
 446
 447 bool AccContainerEventListener::NotifyChildEvent(short nWinEvent,const Any &Value)
 448 {
 449     Reference< XAccessible > xChild;
 450     if(Value >>= xChild )
 451     {
 452         if(xChild.is())
 453         {
 454             XAccessible* pAcc = xChild.get();
 455             pAgent->NotifyAccEvent(nWinEvent, pAcc);
 456             return true;
 457         }
 458     }
 459     return false;
 460 }
 461
 462 void AccContainerEventListener::HandleSelectionChangedAddEvent(const Any& /*oldValue*/, const Any& newValue)
 463 {
 464     if(NotifyChildEvent(UM_EVENT_SELECTION_CHANGED_ADD,newValue))
 465     {
 466         return ;
 467     }
 468     pAgent->NotifyAccEvent(UM_EVENT_SELECTION_CHANGED_ADD, m_xAccessible.get());
 469 }
 470
 471 void AccContainerEventListener::HandleSelectionChangedRemoveEvent(const Any& /*oldValue*/, const Any& newValue)
 472 {
 473     if(NotifyChildEvent(UM_EVENT_SELECTION_CHANGED_REMOVE,newValue))
 474     {
 475         return ;
 476     }
 477     pAgent->NotifyAccEvent(UM_EVENT_SELECTION_CHANGED_REMOVE, m_xAccessible.get());
 478 }
 479
 480 void AccContainerEventListener::HandleSelectionChangedWithinEvent(const Any& /*oldValue*/, const Any& newValue)
 481 {
 482     if(NotifyChildEvent(UM_EVENT_SELECTION_CHANGED_WITHIN,newValue))
 483     {
 484         return ;
 485     }
 486     pAgent->NotifyAccEvent(UM_EVENT_SELECTION_CHANGED_WITHIN, m_xAccessible.get());
 487 }
 488
 489 void AccContainerEventListener::UpdateAllChildrenState(XAccessible* pXAccessible)
 490 {
 491     Reference<com::sun::star::accessibility::XAccessibleContext> xContext(pXAccessible->getAccessibleContext(),UNO_QUERY);
 492     if(!xContext.is())
 493     {
 494         return;
 495     }
 496     com::sun::star::accessibility::XAccessibleContext* pAccessibleContext = xContext.get();
 497     if(pAccessibleContext == NULL)
 498     {
 499         return;
 500     }
 501
 502     if (pAgent && pAgent->IsStateManageDescendant(pXAccessible))
 503     {
 504         return;
 505     }
 506
 507     int count = pAccessibleContext->getAccessibleChildCount();
 508     for (int i=0;i<count;i++)
 509     {
 510         Reference<com::sun::star::accessibility::XAccessible> mxAccessible
 511         = pAccessibleContext->getAccessibleChild(i);
 512
 513         com::sun::star::accessibility::XAccessible* mpAccessible = mxAccessible.get();
 514         if(mpAccessible != NULL)
 515         {
 516             pAgent->UpdateState(mpAccessible);
 517             UpdateAllChildrenState(mpAccessible);
 518         }
 519     }
 520 }
 521
 522 void AccContainerEventListener::HandlePageChangedEvent(const Any& /*oldValue*/, const Any& /*newValue*/)
 523 {
 524     pAgent->NotifyAccEvent(UM_EVENT_OBJECT_PAGECHANGED, m_xAccessible.get());
 525 }
 526
 527 void AccContainerEventListener::HandleSectionChangedEvent(const Any& /*oldValue*/, const Any& /*newValue*/ )
 528 {
 529     pAgent->NotifyAccEvent(UM_EVENT_SECTION_CHANGED, m_xAccessible.get());
 530 }
 531
 532 void AccContainerEventListener::HandleColumnChangedEvent(const Any& /*oldValue*/, const Any& /*newValue*/)
 533 {
 534     pAgent->NotifyAccEvent(UM_EVENT_COLUMN_CHANGED, m_xAccessible.get());
 535 }
 536
 537 void  AccContainerEventListener::HandleNameChangedEvent( Any name )
 538 {
 539     if (GetRole() == AccessibleRole::COMBO_BOX)
 540     {
 541         Reference<XAccessibleContext> mxContext(m_xAccessible->getAccessibleContext());
 542         if(mxContext.is())
 543         {
 544             Reference<XAccessible> mxChild = mxContext->getAccessibleChild(0);
 545             if(mxChild.is())
 546             {
 547                 Reference<XAccessibleContext> mxChildContext(mxChild->getAccessibleContext(),UNO_QUERY);
 548                 short childrole = mxChildContext->getAccessibleRole();
 549                 if (childrole == AccessibleRole::TEXT)
 550                 {
 551                     pAgent->UpdateAccName(mxChild.get(), name);
 552                 }
 553             }
 554         }
 555     }
 556     AccEventListener::HandleNameChangedEvent(name);
 557 }
 558
 559 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */