winaccessibility/source/service/AccObjectManagerAgent.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 <AccObjectManagerAgent.hxx>
  21 #include <AccObjectWinManager.hxx>
  22
  23 #include  <UAccCOM.h>
  24
  25 using namespace com::sun::star::uno;
  26 using namespace com::sun::star::accessibility;
  27
  28 /**
  29    * Construction/Destruction.
  30    * @param
  31    * @return
  32    */
  33 AccObjectManagerAgent::AccObjectManagerAgent()
  34     : pWinManager(new AccObjectWinManager(this))
  35 {
  36 }
  37
  38 AccObjectManagerAgent::~AccObjectManagerAgent()
  39 {
  40 }
  41
  42 /**
  43    * Interface of updating MSAA name when UNO name_changed event occurs.
  44    * @param pXAcc Uno XAccessible interface of control.
  45    * @return
  46    */
  47 void  AccObjectManagerAgent::UpdateAccName( XAccessible* pXAcc )
  48 {
  49     if( pWinManager )
  50         pWinManager->UpdateAccName( pXAcc );
  51 }
  52
  53 /**
  54    * Interface of updating MSAA name when UNO action changed event occurs.
  55    * @param pXAcc Uno XAccessible interface of control.
  56    * @return
  57    */
  58 void  AccObjectManagerAgent::UpdateAction( XAccessible* pXAcc )
  59 {
  60     if( pWinManager )
  61         pWinManager->UpdateAction( pXAcc );
  62 }
  63
  64 /**
  65    * Interface of updating MSAA value when UNO value_changed event occurs.
  66    * @param pXAcc Uno XAccessible interface of control.
  67    * @param pAny New value.
  68    * @return
  69    */
  70 void  AccObjectManagerAgent::UpdateValue( XAccessible* pXAcc, Any pAny )
  71 {
  72     if( pWinManager )
  73         pWinManager->SetValue( pXAcc, pAny );
  74 }
  75
  76 /**
  77    * Interface of updating MSAA value when UNO value_changed event occurs. If we can not
  78    * find new value, we'll get new value from pXAcc to update com value.
  79    * @param pXAcc Uno XAccessible interface of control.
  80    * @return
  81    */
  82 void  AccObjectManagerAgent::UpdateValue( XAccessible* pXAcc )
  83 {
  84     if( pWinManager )
  85         pWinManager->UpdateValue( pXAcc );
  86 }
  87
  88 /**
  89    * Interface of updating MSAA name when UNO name_changed event occurs.
  90    * @param pXAcc Uno XAccessible interface of control.
  91    * @param newName New UNO accessible name.
  92    * @return
  93    */
  94 void  AccObjectManagerAgent::UpdateAccName( XAccessible* pXAcc, Any newName)
  95 {
  96     if( pWinManager )
  97         pWinManager->SetAccName( pXAcc, newName );
  98 }
  99
 100 /**
 101    * When a new UNO XAccessible object is found by listener, we create a corresponding
 102    * com object and insert it to our manager list.
 103    * @param pXAcc Uno XAccessible interface of control.
 104    * @param pWnd The top window handle containing control.
 105    * @return If the method is correctly processed.
 106    */
 107 bool AccObjectManagerAgent::InsertAccObj(
 108         XAccessible* pXAcc, XAccessible* pParentXAcc, HWND hWnd)
 109 {
 110     if( pWinManager )
 111         return pWinManager->InsertAccObj(pXAcc, pParentXAcc, hWnd);
 112
 113     return false;
 114 }
 115
 116 /**
 117    * save the pair <topwindowhandle, XAccessible>
 118    * @param hWnd, top window handle
 119    * @param pXAcc XAccessible interface for top window
 120    * @return void
 121    */
 122 void
 123 AccObjectManagerAgent::SaveTopWindowHandle(HWND hWnd, XAccessible* pXAcc)
 124 {
 125     if( pWinManager )
 126         pWinManager->SaveTopWindowHandle(hWnd, pXAcc);
 127 }
 128
 129
 130 /**
 131    * When a UNO XAccessible object's new children are found by listener, we create
 132    * corresponding com objects and insert them to our manager list.
 133    * @param pXAcc Uno XAccessible interface of control.
 134    * @param pWnd The top window handle containing control.
 135    * @return If the method is correctly processed.
 136    */
 137 bool
 138 AccObjectManagerAgent::InsertChildrenAccObj(XAccessible* pXAcc, HWND hWnd)
 139 {
 140     if( pWinManager )
 141         return pWinManager->InsertChildrenAccObj(pXAcc, hWnd);
 142
 143     return false;
 144 }
 145
 146 /**
 147    * When a new UNO XAccessible object is destroyed, we delete its corresponding
 148    * com object and remove it from our manager list.
 149    * @param pXAcc Uno XAccessible interface of control.
 150    * @return
 151    */
 152 void AccObjectManagerAgent::DeleteAccObj( XAccessible* pXAcc )
 153 {
 154     if( pWinManager )
 155         pWinManager->DeleteAccObj( pXAcc );
 156 }
 157
 158 /**
 159    * When new UNO children XAccessible objects are destroyed, we delete their
 160    * corresponding com objects and remove them from our manager list.
 161    * @param pXAcc Uno XAccessible interface of control.
 162    * @return
 163    */
 164 void AccObjectManagerAgent::DeleteChildrenAccObj( XAccessible* pXAcc )
 165 {
 166     if( pWinManager )
 167         pWinManager->DeleteChildrenAccObj( pXAcc );
 168 }
 169
 170 /**
 171    * Interface of decreasing MSAA state when some UNO state is decreased.
 172    * @param pXAcc Uno XAccessible interface of control.
 173    * @param pState The lost state of control.
 174    * @return
 175    */
 176 void AccObjectManagerAgent::DecreaseState( XAccessible* pXAcc, sal_Int64 pState )
 177 {
 178     if(pWinManager)
 179     {
 180         pWinManager->DecreaseState( pXAcc,  pState );
 181     }
 182 }
 183
 184 /**
 185    * Interface of increasing MSAA name when some UNO state is increased.
 186    * @param pXAcc Uno XAccessible interface of control.
 187    * @param pState The new state of control.
 188    * @return
 189    */
 190 void AccObjectManagerAgent::IncreaseState( XAccessible* pXAcc, sal_Int64 pState )
 191 {
 192     if(pWinManager)
 193     {
 194         pWinManager->IncreaseState( pXAcc,  pState );
 195     }
 196 }
 197
 198 void  AccObjectManagerAgent::UpdateState( css::accessibility::XAccessible* pXAcc )
 199 {
 200     if(pWinManager)
 201         pWinManager->UpdateState(pXAcc);
 202 }
 203
 204 /**
 205    * Interface of notify MSAA event when some UNO event occurred.
 206    * @param pXAcc Uno XAccessible interface of control.
 207    * @param eEvent event type.
 208    * @return If the method is correctly processed.
 209    */
 210 bool AccObjectManagerAgent::NotifyAccEvent(UnoMSAAEvent eEvent, XAccessible* pXAcc)
 211 {
 212     if(pWinManager)
 213         return pWinManager->NotifyAccEvent(pXAcc, eEvent);
 214
 215     return false;
 216 }
 217
 218 /**
 219    * Judge whether a XAccessible object is a container object.
 220    * @param pXAcc Uno XAccessible interface of control.
 221    * @return If the method is correctly processed.
 222    */
 223 bool AccObjectManagerAgent::IsContainer( XAccessible* pXAcc )
 224 {
 225     if(pWinManager)
 226         return AccObjectWinManager::IsContainer(pXAcc);
 227
 228     return false;
 229 }
 230
 231 /**
 232    * Return com object interface by querying XAccessible interface.
 233    * @param pXAcc Uno XAccessible interface of control.
 234    * @return Com interface.
 235    */
 236 IMAccessible* AccObjectManagerAgent::GetIMAccByXAcc(XAccessible* pXAcc)
 237 {
 238     if(pWinManager)
 239         return pWinManager->GetIMAccByXAcc(pXAcc);
 240
 241     return nullptr;
 242 }
 243
 244 /**
 245    * Notify manager when a XAccessible object is destroying.
 246    * @param pXAcc Uno XAccessible interface of control.
 247    * @return.
 248    */
 249 void  AccObjectManagerAgent::NotifyDestroy(XAccessible* pXAcc)
 250 {
 251     if(pWinManager)
 252         pWinManager->NotifyDestroy(pXAcc);
 253 }
 254
 255 /**
 256    * Return com object interface by querying child id.
 257    * @param pXAcc Uno XAccessible interface of control.
 258    * @return Com interface.
 259    */
 260 void AccObjectManagerAgent::GetIAccessibleFromResID(long childID,IMAccessible** pIMAcc)
 261 {
 262     if(pWinManager)
 263         *pIMAcc = pWinManager->GetIAccessibleFromResID(childID);
 264 }
 265
 266 /**
 267    * Return object interface by querying interface.
 268    * @param pXAcc Uno XAccessible interface of control.
 269    * @return Com interface.
 270    */
 271 bool AccObjectManagerAgent::GetIAccessibleFromXAccessible(
 272         XAccessible* pXAcc, IAccessible** ppXI)
 273 {
 274     if(pWinManager)
 275     {
 276         *ppXI = pWinManager->GetIMAccByXAcc(pXAcc);
 277         if(*ppXI)
 278             return true;
 279     }
 280     return false;
 281 }
 282
 283 XAccessible* AccObjectManagerAgent::GetParentXAccessible( XAccessible* pXAcc )
 284 {
 285     if(pWinManager)
 286         return pWinManager->GetParentXAccessible( pXAcc );
 287
 288     return nullptr;
 289 }
 290
 291 short AccObjectManagerAgent::GetParentRole( XAccessible* pXAcc )
 292 {
 293     if(pWinManager)
 294         return pWinManager->GetParentRole( pXAcc );
 295
 296     return -1;
 297 }
 298
 299 void AccObjectManagerAgent::UpdateChildState(XAccessible* pXAcc)
 300 {
 301     if(pWinManager)
 302         pWinManager->UpdateChildState( pXAcc );
 303 }
 304
 305
 306 bool AccObjectManagerAgent::IsSpecialToolbarItem(XAccessible* pXAcc)
 307 {
 308     if(pWinManager)
 309         return pWinManager->IsSpecialToolbarItem(pXAcc);
 310
 311     return false;
 312 }
 313
 314 short AccObjectManagerAgent::GetRole(XAccessible* pXAcc)
 315 {
 316     if(pWinManager)
 317         return AccObjectWinManager::GetRole( pXAcc );
 318
 319     return -1;
 320 }
 321
 322 XAccessible* AccObjectManagerAgent::GetAccDocByAccTopWin( XAccessible* pXAcc )
 323 {
 324     if (pWinManager)
 325     {
 326         return pWinManager->GetAccDocByAccTopWin( pXAcc );
 327     }
 328     return nullptr;
 329 }
 330 bool AccObjectManagerAgent::IsTopWinAcc(XAccessible* pXAcc)
 331 {
 332     if (pWinManager)
 333     {
 334         return pWinManager->IsTopWinAcc( pXAcc );
 335     }
 336     return false;
 337 }
 338
 339 bool AccObjectManagerAgent::IsStateManageDescendant(XAccessible* pXAcc)
 340 {
 341     if(pWinManager)
 342         return AccObjectWinManager::IsStateManageDescendant( pXAcc );
 343
 344     return false;
 345 }
 346
 347 /**
 348  *  Implementation of interface XMSAAService's method getAccObjectPtr()
 349  *  that returns the corresponding COM interface with the MS event.
 350  *  @return  Com interface.
 351  */
 352 sal_Int64 AccObjectManagerAgent::Get_ToATInterface(
 353         sal_Int64 hWnd, sal_Int64 lParam, sal_Int64 wParam)
 354 {
 355     return static_cast<sal_Int64>(pWinManager->Get_ToATInterface(
 356             static_cast<HWND>(reinterpret_cast<void*>(hWnd)), lParam, wParam));
 357 }
 358
 359 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */