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 /**
 102    * Interface of updating MSAA location when UNO location_changed event occurs.
 103    * @param pXAcc Uno XAccessible interface of control.
 104    * @param pXAcc Uno The top position of new location.
 105    * @param pXAcc Uno The left position of new location.
 106    * @param pXAcc Uno The width of new location.
 107    * @param pXAcc Uno The width of new location.
 108    * @return
 109    */
 110 void  AccObjectManagerAgent::UpdateLocation( XAccessible* /* pXAcc */, long /*top*/, long /*left*/, long /*width*/, long /*height*/ )
 111 {
 112 #ifdef _IMPL_WIN
 113     if( pWinManager )
 114         pWinManager->SetLocation( pXAcc, top, left, width, height );
 115 #endif
 116 }
 117
 118 /**
 119    * Interface of updating MSAA name when UNO description_changed event occurs.
 120    * @param pXAcc Uno XAccessible interface of control.
 121    * @param newDesc New UNO accessible description.
 122    * @return
 123    */
 124 void  AccObjectManagerAgent::UpdateDescription( XAccessible* pXAcc, Any newDesc )
 125 {
 126     if( pWinManager )
 127         pWinManager->SetDescription( pXAcc, newDesc );
 128 }
 129
 130 /**
 131    * When a new UNO XAccessible object is found by listener,we'll create a corresponding
 132    * com object and insert it 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 AccObjectManagerAgent::InsertAccObj(
 138         XAccessible* pXAcc, XAccessible* pParentXAcc, sal_Int64 nWnd)
 139 {
 140     if( pWinManager )
 141         return pWinManager->InsertAccObj(pXAcc, pParentXAcc,
 142                 static_cast<HWND>(reinterpret_cast<void*>(nWnd)));
 143
 144     return false;
 145 }
 146
 147 /**
 148    * save the pair <topwindowhandle, XAccessible>
 149    * @param hWnd, top window handle
 150    * @param pXAcc XAccessible interface for top window
 151    * @return void
 152    */
 153 void
 154 AccObjectManagerAgent::SaveTopWindowHandle(sal_Int64 hWnd, XAccessible* pXAcc)
 155 {
 156     if( pWinManager )
 157         pWinManager->SaveTopWindowHandle(
 158                 static_cast<HWND>(reinterpret_cast<void*>(hWnd)), pXAcc);
 159 }
 160
 161
 162 /**
 163    * When a UNO XAccessible object's new children are found by listener,we'll create
 164    * corresponding com objects and insert them to our manager list.
 165    * @param pXAcc Uno XAccessible interface of control.
 166    * @param pWnd The top window handle containing control.
 167    * @return If the method is correctly processed.
 168    */
 169 bool
 170 AccObjectManagerAgent::InsertChildrenAccObj(XAccessible* pXAcc, sal_Int64 pWnd)
 171 {
 172     if( pWinManager )
 173         return pWinManager->InsertChildrenAccObj( pXAcc, HWND((void*)pWnd) );
 174
 175     return false;
 176 }
 177
 178 /**
 179    * When a new UNO XAccessible object is destroied,we'll delete its corresponding
 180    * com object and remove it from our manager list.
 181    * @param pXAcc Uno XAccessible interface of control.
 182    * @return
 183    */
 184 void AccObjectManagerAgent::DeleteAccObj( XAccessible* pXAcc )
 185 {
 186     if( pWinManager )
 187         pWinManager->DeleteAccObj( pXAcc );
 188 }
 189
 190 /**
 191    * When new UNO children XAccessible objects are destroyed,we'll delete their
 192    * corresponding com objects and remove them from our manager list.
 193    * @param pXAcc Uno XAccessible interface of control.
 194    * @return
 195    */
 196 void AccObjectManagerAgent::DeleteChildrenAccObj( XAccessible* pXAcc )
 197 {
 198     if( pWinManager )
 199         pWinManager->DeleteChildrenAccObj( pXAcc );
 200 }
 201
 202 /**
 203    * Interface of decreasing MSAA state when some UNO state is decreased.
 204    * @param pXAcc Uno XAccessible interface of control.
 205    * @param pState The lost state of control.
 206    * @return
 207    */
 208 void AccObjectManagerAgent::DecreaseState( XAccessible* pXAcc,unsigned short pState )
 209 {
 210     if(pWinManager)
 211     {
 212         pWinManager->DecreaseState( pXAcc,  pState );
 213     }
 214 }
 215
 216 /**
 217    * Interface of increasing MSAA name when some UNO state is increased.
 218    * @param pXAcc Uno XAccessible interface of control.
 219    * @param pState The new state of control.
 220    * @return
 221    */
 222 void AccObjectManagerAgent::IncreaseState( XAccessible* pXAcc,unsigned short pState )
 223 {
 224     if(pWinManager)
 225     {
 226         pWinManager->IncreaseState( pXAcc,  pState );
 227     }
 228 }
 229
 230 void  AccObjectManagerAgent::UpdateState( com::sun::star::accessibility::XAccessible* pXAcc )
 231 {
 232     if(pWinManager)
 233         pWinManager->UpdateState(pXAcc);
 234 }
 235
 236 /**
 237    * Interface of notify MSAA event when some UNO event occurred.
 238    * @param pXAcc Uno XAccessible interface of control.
 239    * @param pEvent UNO event ID.
 240    * @return If the method is correctly processed.
 241    */
 242 bool AccObjectManagerAgent::NotifyAccEvent(short pEvent, XAccessible* pXAcc)
 243 {
 244     if(pWinManager)
 245         return pWinManager->NotifyAccEvent(pXAcc,pEvent);
 246
 247     return false;
 248 }
 249
 250 /**
 251    * Judge whether a XAccessible object is a container object.
 252    * @param pXAcc Uno XAccessible interface of control.
 253    * @return If the method is correctly processed.
 254    */
 255 bool AccObjectManagerAgent::IsContainer( XAccessible* pXAcc )
 256 {
 257     if(pWinManager)
 258         return pWinManager->IsContainer(pXAcc);
 259
 260     return false;
 261 }
 262
 263 /**
 264    * Return com object interface by querying XAccessible interface.
 265    * @param pXAcc Uno XAccessible interface of control.
 266    * @return Com interface.
 267    */
 268 IMAccessible* AccObjectManagerAgent::GetIMAccByXAcc(XAccessible* pXAcc)
 269 {
 270     if(pWinManager)
 271         return pWinManager->GetIMAccByXAcc(pXAcc);
 272
 273     return NULL;
 274 }
 275
 276 /**
 277    * Notify manger when a XAccessible object is destroying.
 278    * @param pXAcc Uno XAccessible interface of control.
 279    * @return.
 280    */
 281 void  AccObjectManagerAgent::NotifyDestroy(XAccessible* pXAcc)
 282 {
 283     if(pWinManager)
 284         pWinManager->NotifyDestroy(pXAcc);
 285 }
 286
 287 /**
 288    * Return com object interface by querying child id.
 289    * @param pXAcc Uno XAccessible interface of control.
 290    * @return Com interface.
 291    */
 292 void AccObjectManagerAgent::GetIAccessibleFromResID(long childID,IMAccessible** pIMAcc)
 293 {
 294     if(pWinManager)
 295         *pIMAcc = pWinManager->GetIAccessibleFromResID(childID);
 296 }
 297
 298 /**
 299    * Return object interface by querying interface.
 300    * @param pXAcc Uno XAccessible interface of control.
 301    * @return Com interface.
 302    */
 303 bool AccObjectManagerAgent::GetIAccessibleFromXAccessible(
 304         XAccessible* pXAcc, IAccessible** ppXI)
 305 {
 306     if(pWinManager)
 307     {
 308         *ppXI = (IAccessible*)pWinManager->GetIMAccByXAcc(pXAcc);
 309         if(*ppXI)
 310             return true;
 311     }
 312     return false;
 313 }
 314
 315 XAccessible* AccObjectManagerAgent::GetParentXAccessible( XAccessible* pXAcc )
 316 {
 317     if(pWinManager)
 318         return pWinManager->GetParentXAccessible( pXAcc );
 319
 320     return NULL;
 321 }
 322
 323 short AccObjectManagerAgent::GetParentRole( XAccessible* pXAcc )
 324 {
 325     if(pWinManager)
 326         return pWinManager->GetParentRole( pXAcc );
 327
 328     return -1;
 329 }
 330
 331 void AccObjectManagerAgent::UpdateDescription( XAccessible* pXAcc )
 332 {
 333     if(pWinManager)
 334         pWinManager->UpdateDescription( pXAcc );
 335 }
 336
 337 void AccObjectManagerAgent::UpdateChildState(XAccessible* pXAcc)
 338 {
 339     if(pWinManager)
 340         pWinManager->UpdateChildState( pXAcc );
 341 }
 342
 343
 344 bool AccObjectManagerAgent::IsSpecialToolboItem(XAccessible* pXAcc)
 345 {
 346     if(pWinManager)
 347         return pWinManager->IsSpecialToolboItem( pXAcc );
 348
 349     return false;
 350 }
 351
 352 short AccObjectManagerAgent::GetRole(XAccessible* pXAcc)
 353 {
 354     if(pWinManager)
 355         return pWinManager->GetRole( pXAcc );
 356
 357     return -1;
 358 }
 359
 360 XAccessible* AccObjectManagerAgent::GetAccDocByAccTopWin( XAccessible* pXAcc )
 361 {
 362     if (pWinManager)
 363     {
 364         return pWinManager->GetAccDocByAccTopWin( pXAcc );
 365     }
 366     return NULL;
 367 }
 368 bool AccObjectManagerAgent::IsTopWinAcc(XAccessible* pXAcc)
 369 {
 370     if (pWinManager)
 371     {
 372         return pWinManager->IsTopWinAcc( pXAcc );
 373     }
 374     return NULL;
 375 }
 376
 377 bool AccObjectManagerAgent::IsStateManageDescendant(XAccessible* pXAcc)
 378 {
 379     if(pWinManager)
 380         return pWinManager->IsStateManageDescendant( pXAcc );
 381
 382     return false;
 383 }
 384
 385 /**
 386  *  Implementation of interface XMSAAService's method getAccObjectPtr()
 387  *  that returns the corresponding COM interface with the MS event.
 388  *  @return  Com interface.
 389  */
 390 sal_Int64 AccObjectManagerAgent::Get_ToATInterface(
 391         sal_Int64 hWnd, sal_Int64 lParam, sal_Int64 wParam)
 392 {
 393     return static_cast<sal_Int64>(pWinManager->Get_ToATInterface(
 394             static_cast<HWND>(reinterpret_cast<void*>(hWnd)), lParam, wParam));
 395 }
 396
 397 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */