svx/source/accessibility/svxrectctaccessiblecontext.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 <svxrectctaccessiblecontext.hxx>
  21 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  22 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  23 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  24 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  25 #include <utility>
  26 #include <vcl/svapp.hxx>
  27 #include <osl/mutex.hxx>
  28 #include <tools/debug.hxx>
  29 #include <tools/gen.hxx>
  30 #include <sal/log.hxx>
  31 #include <vcl/settings.hxx>
  32 #include <vcl/unohelp.hxx>
  33 #include <svx/strings.hrc>
  34 #include <svx/dlgctrl.hxx>
  35 #include <svx/dialmgr.hxx>
  36 #include <com/sun/star/accessibility/AccessibleRelationType.hpp>
  37 #include <unotools/accessiblerelationsethelper.hxx>
  38
  39 using namespace ::cppu;
  40 using namespace ::osl;
  41 using namespace ::com::sun::star;
  42 using namespace ::com::sun::star::uno;
  43 using namespace ::com::sun::star::accessibility;
  44
  45 using namespace ::com::sun::star::lang;
  46
  47 #define MAX_NUM_OF_CHILDREN   9
  48 #define NOCHILDSELECTED     -1
  49
  50 // internal
  51 namespace
  52 {
  53     struct ChildIndexToPointData
  54     {
  55         TranslateId pResIdName;
  56         TranslateId pResIdDescr;
  57         RectPoint  ePoint;
  58     };
  59 }
  60
  61
  62 static const ChildIndexToPointData* IndexToPoint( tools::Long nIndex )
  63 {
  64     DBG_ASSERT( nIndex < 9 && nIndex >= 0, "-IndexToPoint(): invalid child index! You have been warned..." );
  65
  66     // corners are counted from left to right and top to bottom
  67     static const ChildIndexToPointData  pCornerData[] =
  68     {                                                                   // index
  69         {   RID_SVXSTR_RECTCTL_ACC_CHLD_LT, RID_SVXSTR_RECTCTL_ACC_CHLD_LT, RectPoint::LT },    //  0
  70         {   RID_SVXSTR_RECTCTL_ACC_CHLD_MT, RID_SVXSTR_RECTCTL_ACC_CHLD_MT, RectPoint::MT },    //  1
  71         {   RID_SVXSTR_RECTCTL_ACC_CHLD_RT, RID_SVXSTR_RECTCTL_ACC_CHLD_RT, RectPoint::RT },    //  2
  72         {   RID_SVXSTR_RECTCTL_ACC_CHLD_LM, RID_SVXSTR_RECTCTL_ACC_CHLD_LM, RectPoint::LM },    //  3
  73         {   RID_SVXSTR_RECTCTL_ACC_CHLD_MM, RID_SVXSTR_RECTCTL_ACC_CHLD_MM, RectPoint::MM },    //  4
  74         {   RID_SVXSTR_RECTCTL_ACC_CHLD_RM, RID_SVXSTR_RECTCTL_ACC_CHLD_RM, RectPoint::RM },    //  5
  75         {   RID_SVXSTR_RECTCTL_ACC_CHLD_LB, RID_SVXSTR_RECTCTL_ACC_CHLD_LB, RectPoint::LB },    //  6
  76         {   RID_SVXSTR_RECTCTL_ACC_CHLD_MB, RID_SVXSTR_RECTCTL_ACC_CHLD_MB, RectPoint::MB },    //  7
  77         {   RID_SVXSTR_RECTCTL_ACC_CHLD_RB, RID_SVXSTR_RECTCTL_ACC_CHLD_RB, RectPoint::RB }     //  8
  78     };
  79
  80     return pCornerData + nIndex;
  81 }
  82
  83
  84 static tools::Long PointToIndex( RectPoint ePoint )
  85 {
  86     tools::Long    nRet( static_cast<tools::Long>(ePoint) );
  87     // corner control
  88     // corners are counted from left to right and top to bottom
  89     DBG_ASSERT( int(RectPoint::LT) == 0 && int(RectPoint::MT) == 1 && int(RectPoint::RT) == 2 && int(RectPoint::LM) == 3 && int(RectPoint::MM) == 4 && int(RectPoint::RM) == 5 &&
  90                 int(RectPoint::LB) == 6 && int(RectPoint::MB) == 7 && int(RectPoint::RB) == 8, "*PointToIndex(): unexpected enum value!" );
  91
  92     nRet = static_cast<tools::Long>(ePoint);
  93
  94     return nRet;
  95 }
  96
  97 SvxRectCtlAccessibleContext::SvxRectCtlAccessibleContext(SvxRectCtl* pRepr)
  98     : mpRepr(pRepr)
  99     , mnSelectedChild(NOCHILDSELECTED)
 100 {
 101     {
 102         ::SolarMutexGuard aSolarGuard;
 103         msName = SvxResId( RID_SVXSTR_RECTCTL_ACC_CORN_NAME );
 104         msDescription = SvxResId( RID_SVXSTR_RECTCTL_ACC_CORN_DESCR );
 105     }
 106
 107     mvChildren.resize(MAX_NUM_OF_CHILDREN);
 108 }
 109
 110 SvxRectCtlAccessibleContext::~SvxRectCtlAccessibleContext()
 111 {
 112     ensureDisposed();
 113 }
 114
 115 Reference< XAccessible > SAL_CALL SvxRectCtlAccessibleContext::getAccessibleAtPoint( const awt::Point& rPoint )
 116 {
 117     ::osl::MutexGuard           aGuard( m_aMutex );
 118
 119     Reference< XAccessible >    xRet;
 120
 121     tools::Long nChild = mpRepr ? PointToIndex(mpRepr->GetApproxRPFromPixPt(rPoint)) : NOCHILDSELECTED;
 122
 123     if (nChild != NOCHILDSELECTED)
 124         xRet = getAccessibleChild( nChild );
 125
 126     return xRet;
 127 }
 128
 129 // XAccessibleContext
 130 sal_Int64 SAL_CALL SvxRectCtlAccessibleContext::getAccessibleChildCount()
 131 {
 132     return SvxRectCtl::NO_CHILDREN;
 133 }
 134
 135 Reference< XAccessible > SAL_CALL SvxRectCtlAccessibleContext::getAccessibleChild( sal_Int64 nIndex )
 136 {
 137     checkChildIndex( nIndex );
 138
 139     Reference< XAccessible > xChild(mvChildren[ nIndex ]);
 140     if( !xChild.is() )
 141     {
 142         ::SolarMutexGuard aSolarGuard;
 143
 144         ::osl::MutexGuard   aGuard( m_aMutex );
 145
 146         xChild = mvChildren[ nIndex ].get();
 147
 148         if (!xChild.is() && mpRepr)
 149         {
 150             const ChildIndexToPointData*    p = IndexToPoint( nIndex );
 151
 152             tools::Rectangle       aFocusRect( mpRepr->CalculateFocusRectangle( p->ePoint ) );
 153
 154             rtl::Reference<SvxRectCtlChildAccessibleContext> pChild = new SvxRectCtlChildAccessibleContext(this,
 155                     SvxResId(p->pResIdName), SvxResId(p->pResIdDescr), aFocusRect, nIndex );
 156             mvChildren[ nIndex ] = pChild;
 157             xChild = pChild;
 158
 159             // set actual state
 160             if( mnSelectedChild == nIndex )
 161                 pChild->setStateChecked( true );
 162         }
 163     }
 164
 165     return xChild;
 166 }
 167
 168 Reference< XAccessible > SAL_CALL SvxRectCtlAccessibleContext::getAccessibleParent()
 169 {
 170     ::osl::MutexGuard aGuard( m_aMutex );
 171     if (mpRepr)
 172         return mpRepr->getAccessibleParent();
 173     return uno::Reference<css::accessibility::XAccessible>();
 174 }
 175
 176 sal_Int16 SAL_CALL SvxRectCtlAccessibleContext::getAccessibleRole()
 177 {
 178     return AccessibleRole::PANEL;
 179 }
 180
 181 OUString SAL_CALL SvxRectCtlAccessibleContext::getAccessibleDescription()
 182 {
 183     ::osl::MutexGuard   aGuard( m_aMutex );
 184     return msDescription + " Please use arrow key to selection.";
 185 }
 186
 187 OUString SAL_CALL SvxRectCtlAccessibleContext::getAccessibleName()
 188 {
 189     ::osl::MutexGuard   aGuard( m_aMutex );
 190     return msName;
 191 }
 192
 193 /** Return empty reference to indicate that the relation set is not
 194     supported.
 195 */
 196 Reference< XAccessibleRelationSet > SAL_CALL SvxRectCtlAccessibleContext::getAccessibleRelationSet()
 197 {
 198     ::osl::MutexGuard   aGuard( m_aMutex );
 199     if (mpRepr)
 200         return mpRepr->get_accessible_relation_set();
 201     return uno::Reference<css::accessibility::XAccessibleRelationSet>();
 202 }
 203
 204 sal_Int64 SAL_CALL SvxRectCtlAccessibleContext::getAccessibleStateSet()
 205 {
 206     ::osl::MutexGuard                       aGuard( m_aMutex );
 207     sal_Int64 nStateSet = 0;
 208
 209     if (mpRepr)
 210     {
 211         nStateSet |= AccessibleStateType::ENABLED;
 212         nStateSet |= AccessibleStateType::FOCUSABLE;
 213         if( mpRepr->HasFocus() )
 214             nStateSet |= AccessibleStateType::FOCUSED;
 215         nStateSet |= AccessibleStateType::OPAQUE;
 216
 217         nStateSet |= AccessibleStateType::SHOWING;
 218
 219         if( mpRepr->IsVisible() )
 220             nStateSet |= AccessibleStateType::VISIBLE;
 221     }
 222     else
 223         nStateSet |= AccessibleStateType::DEFUNC;
 224
 225     return nStateSet;
 226 }
 227
 228 void SAL_CALL SvxRectCtlAccessibleContext::grabFocus()
 229 {
 230     ::SolarMutexGuard aSolarGuard;
 231     ::osl::MutexGuard   aGuard( m_aMutex );
 232
 233     if (mpRepr)
 234         mpRepr->GrabFocus();
 235 }
 236
 237 sal_Int32 SvxRectCtlAccessibleContext::getForeground()
 238 {
 239     ::SolarMutexGuard aSolarGuard;
 240     ::osl::MutexGuard   aGuard( m_aMutex );
 241
 242     //see SvxRectCtl::Paint
 243     const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
 244     return sal_Int32(rStyles.GetLabelTextColor());
 245 }
 246
 247 sal_Int32 SvxRectCtlAccessibleContext::getBackground(  )
 248 {
 249     ::SolarMutexGuard aSolarGuard;
 250     ::osl::MutexGuard   aGuard( m_aMutex );
 251
 252     //see SvxRectCtl::Paint
 253     const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
 254     return sal_Int32(rStyles.GetDialogColor());
 255 }
 256
 257 // XAccessibleSelection
 258 void SvxRectCtlAccessibleContext::implSelect(sal_Int64 nIndex, bool bSelect)
 259 {
 260     ::SolarMutexGuard aSolarGuard;
 261
 262     ::osl::MutexGuard   aGuard( m_aMutex );
 263
 264     checkChildIndex( nIndex );
 265
 266     if (mpRepr)
 267     {
 268         const ChildIndexToPointData* pData = IndexToPoint(nIndex);
 269
 270         assert(pData && "SvxRectCtlAccessibleContext::selectAccessibleChild(): this is an impossible state! Or at least should be...");
 271
 272         if (bSelect)
 273         {
 274             // this does all what is needed, including the change of the child's state!
 275             mpRepr->SetActualRP( pData->ePoint );
 276         }
 277         else
 278         {
 279             SAL_WARN( "svx", "SvxRectCtlAccessibleContext::clearAccessibleSelection() is not possible!" );
 280         }
 281     }
 282 }
 283
 284 bool SvxRectCtlAccessibleContext::implIsSelected( sal_Int64 nIndex )
 285 {
 286     ::osl::MutexGuard   aGuard( m_aMutex );
 287
 288     checkChildIndex( nIndex );
 289
 290     return nIndex == mnSelectedChild;
 291 }
 292
 293 // internals
 294 void SvxRectCtlAccessibleContext::checkChildIndex( sal_Int64 nIndex )
 295 {
 296     if( nIndex < 0 || nIndex >= getAccessibleChildCount() )
 297         throw lang::IndexOutOfBoundsException();
 298 }
 299
 300 void SvxRectCtlAccessibleContext::FireChildFocus( RectPoint eButton )
 301 {
 302     ::osl::MutexGuard   aGuard( m_aMutex );
 303     tools::Long nNew = PointToIndex( eButton );
 304     tools::Long nNumOfChildren = getAccessibleChildCount();
 305     if( nNew < nNumOfChildren )
 306     {
 307         // select new child
 308         mnSelectedChild = nNew;
 309         if( nNew != NOCHILDSELECTED )
 310         {
 311             if( mvChildren[ nNew ].is() )
 312                 mvChildren[ nNew ]->FireFocusEvent();
 313         }
 314         else
 315         {
 316             Any                             aOld;
 317             Any                             aNew;
 318             aNew <<= AccessibleStateType::FOCUSED;
 319             NotifyAccessibleEvent(AccessibleEventId::STATE_CHANGED, aOld, aNew);
 320         }
 321     }
 322     else
 323         mnSelectedChild = NOCHILDSELECTED;
 324 }
 325
 326 void SvxRectCtlAccessibleContext::selectChild( tools::Long nNew )
 327 {
 328     ::osl::MutexGuard   aGuard( m_aMutex );
 329     if( nNew == mnSelectedChild )
 330         return;
 331
 332     tools::Long    nNumOfChildren = getAccessibleChildCount();
 333     if( nNew < nNumOfChildren )
 334     {   // valid index
 335         if( mnSelectedChild != NOCHILDSELECTED )
 336         {   // deselect old selected child if one is selected
 337             SvxRectCtlChildAccessibleContext* pChild = mvChildren[ mnSelectedChild ].get();
 338             if( pChild )
 339                 pChild->setStateChecked( false );
 340         }
 341
 342         // select new child
 343         mnSelectedChild = nNew;
 344
 345         if( nNew != NOCHILDSELECTED )
 346         {
 347             if( mvChildren[ nNew ].is() )
 348                 mvChildren[ nNew ]->setStateChecked( true );
 349         }
 350     }
 351     else
 352         mnSelectedChild = NOCHILDSELECTED;
 353 }
 354
 355 void SvxRectCtlAccessibleContext::selectChild(RectPoint eButton )
 356 {
 357     // no guard -> is done in next selectChild
 358     selectChild(PointToIndex( eButton ));
 359 }
 360
 361 void SAL_CALL SvxRectCtlAccessibleContext::disposing()
 362 {
 363     ::osl::MutexGuard aGuard(m_aMutex);
 364     OAccessibleSelectionHelper::disposing();
 365     for (auto & rxChild : mvChildren)
 366     {
 367         if( rxChild.is() )
 368             rxChild->dispose();
 369     }
 370     mvChildren.clear();
 371     mpRepr = nullptr;
 372 }
 373
 374 awt::Rectangle SvxRectCtlAccessibleContext::implGetBounds()
 375 {
 376     ::SolarMutexGuard aSolarGuard;
 377     ::osl::MutexGuard   aGuard( m_aMutex );
 378
 379     awt::Rectangle aRet;
 380
 381     if (mpRepr)
 382     {
 383         const Point   aOutPos;
 384         Size          aOutSize(mpRepr->GetOutputSizePixel());
 385
 386         aRet.X = aOutPos.X();
 387         aRet.Y = aOutPos.Y();
 388         aRet.Width = aOutSize.Width();
 389         aRet.Height = aOutSize.Height();
 390     }
 391
 392     return aRet;
 393 }
 394
 395 SvxRectCtlChildAccessibleContext::SvxRectCtlChildAccessibleContext(
 396     const Reference<XAccessible>&   rxParent,
 397     OUString               aName,
 398     OUString               aDescription,
 399     const tools::Rectangle& rBoundingBox,
 400     tools::Long nIndexInParent )
 401     : msDescription(std::move( aDescription ))
 402     , msName(std::move( aName ))
 403     , mxParent(rxParent)
 404     , maBoundingBox( rBoundingBox )
 405     , mnIndexInParent( nIndexInParent )
 406     , mbIsChecked( false )
 407 {
 408 }
 409
 410 SvxRectCtlChildAccessibleContext::~SvxRectCtlChildAccessibleContext()
 411 {
 412     ensureDisposed();
 413 }
 414
 415 Reference< XAccessible > SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleAtPoint( const awt::Point& /*rPoint*/ )
 416 {
 417     return Reference< XAccessible >();
 418 }
 419
 420 void SAL_CALL SvxRectCtlChildAccessibleContext::grabFocus()
 421 {
 422 }
 423
 424 sal_Int32 SvxRectCtlChildAccessibleContext::getForeground(  )
 425 {
 426     ::SolarMutexGuard aSolarGuard;
 427     ::osl::MutexGuard   aGuard( m_aMutex );
 428
 429     //see SvxRectCtl::Paint
 430     const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
 431     return sal_Int32(rStyles.GetLabelTextColor());
 432 }
 433
 434 sal_Int32 SvxRectCtlChildAccessibleContext::getBackground(  )
 435 {
 436     ::SolarMutexGuard aSolarGuard;
 437     ::osl::MutexGuard   aGuard( m_aMutex );
 438
 439     //see SvxRectCtl::Paint
 440     const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
 441     return sal_Int32(rStyles.GetDialogColor());
 442 }
 443
 444 // XAccessibleContext
 445 sal_Int64 SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleChildCount()
 446 {
 447     return 0;
 448 }
 449
 450 Reference< XAccessible > SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleChild( sal_Int64 /*nIndex*/ )
 451 {
 452     throw lang::IndexOutOfBoundsException();
 453 }
 454
 455 Reference< XAccessible > SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleParent()
 456 {
 457     return mxParent;
 458 }
 459
 460 sal_Int16 SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleRole()
 461 {
 462     return AccessibleRole::RADIO_BUTTON;
 463 }
 464
 465 OUString SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleDescription()
 466 {
 467     return msDescription;
 468 }
 469
 470 OUString SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleName()
 471 {
 472     return msName;
 473 }
 474
 475 /** Return empty reference to indicate that the relation set is not
 476     supported.
 477 */
 478 Reference<XAccessibleRelationSet> SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleRelationSet()
 479 {
 480     rtl::Reference<utl::AccessibleRelationSetHelper> pRelationSetHelper = new utl::AccessibleRelationSetHelper;
 481     if( mxParent.is() )
 482     {
 483         uno::Sequence<uno::Reference<css::accessibility::XAccessible>> aSequence { mxParent };
 484         pRelationSetHelper->AddRelation(css::accessibility::AccessibleRelation(css::accessibility::AccessibleRelationType_MEMBER_OF, aSequence));
 485     }
 486
 487     return pRelationSetHelper;
 488 }
 489
 490 sal_Int64 SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleStateSet()
 491 {
 492     ::osl::MutexGuard                       aGuard( m_aMutex );
 493     sal_Int64 nStateSet = 0;
 494
 495     if (!rBHelper.bDisposed)
 496     {
 497         if( mbIsChecked )
 498         {
 499             nStateSet |= AccessibleStateType::CHECKED;
 500         }
 501
 502         nStateSet |= AccessibleStateType::ENABLED;
 503         nStateSet |= AccessibleStateType::SENSITIVE;
 504         nStateSet |= AccessibleStateType::OPAQUE;
 505         nStateSet |= AccessibleStateType::SELECTABLE;
 506         nStateSet |= AccessibleStateType::SHOWING;
 507         nStateSet |= AccessibleStateType::VISIBLE;
 508     }
 509     else
 510         nStateSet |= AccessibleStateType::DEFUNC;
 511
 512     return nStateSet;
 513 }
 514
 515 // XAccessibleValue
 516 Any SAL_CALL SvxRectCtlChildAccessibleContext::getCurrentValue()
 517 {
 518     Any aRet;
 519     aRet <<= ( mbIsChecked? 1.0 : 0.0 );
 520     return aRet;
 521 }
 522
 523 sal_Bool SAL_CALL SvxRectCtlChildAccessibleContext::setCurrentValue( const Any& /*aNumber*/ )
 524 {
 525     return false;
 526 }
 527
 528 Any SAL_CALL SvxRectCtlChildAccessibleContext::getMaximumValue()
 529 {
 530     Any aRet;
 531     aRet <<= 1.0;
 532     return aRet;
 533 }
 534
 535 Any SAL_CALL SvxRectCtlChildAccessibleContext::getMinimumValue()
 536 {
 537     Any aRet;
 538     aRet <<= 0.0;
 539     return aRet;
 540 }
 541
 542 Any SAL_CALL SvxRectCtlChildAccessibleContext::getMinimumIncrement()
 543 {
 544     Any aRet;
 545     aRet <<= 1.0;
 546     return aRet;
 547 }
 548
 549
 550 // XAccessibleAction
 551
 552
 553 sal_Int32 SvxRectCtlChildAccessibleContext::getAccessibleActionCount( )
 554 {
 555     return 1;
 556 }
 557
 558
 559 sal_Bool SvxRectCtlChildAccessibleContext::doAccessibleAction ( sal_Int32 nIndex )
 560 {
 561     ::osl::MutexGuard   aGuard( m_aMutex );
 562
 563     if ( nIndex < 0 || nIndex >= getAccessibleActionCount() )
 564         throw IndexOutOfBoundsException();
 565
 566     Reference<XAccessibleSelection> xSelection( mxParent, UNO_QUERY);
 567
 568     xSelection->selectAccessibleChild(mnIndexInParent);
 569
 570     return true;
 571 }
 572
 573
 574 OUString SvxRectCtlChildAccessibleContext::getAccessibleActionDescription ( sal_Int32 nIndex )
 575 {
 576     ::osl::MutexGuard   aGuard( m_aMutex );
 577
 578     if ( nIndex < 0 || nIndex >= getAccessibleActionCount() )
 579         throw IndexOutOfBoundsException();
 580
 581     return u"select"_ustr;
 582 }
 583
 584
 585 Reference< XAccessibleKeyBinding > SvxRectCtlChildAccessibleContext::getAccessibleActionKeyBinding( sal_Int32 nIndex )
 586 {
 587     ::osl::MutexGuard   aGuard( m_aMutex );
 588
 589     if ( nIndex < 0 || nIndex >= getAccessibleActionCount() )
 590         throw IndexOutOfBoundsException();
 591
 592     return Reference< XAccessibleKeyBinding >();
 593 }
 594
 595 void SAL_CALL SvxRectCtlChildAccessibleContext::disposing()
 596 {
 597     OAccessibleComponentHelper::disposing();
 598     mxParent.clear();
 599 }
 600
 601 awt::Rectangle SvxRectCtlChildAccessibleContext::implGetBounds(  )
 602 {
 603     // no guard necessary, because no one changes maBoundingBox after creating it
 604     return vcl::unohelper::ConvertToAWTRect(maBoundingBox);
 605 }
 606
 607 void SvxRectCtlChildAccessibleContext::setStateChecked( bool bChecked )
 608 {
 609     if( mbIsChecked == bChecked )
 610         return;
 611
 612     mbIsChecked = bChecked;
 613
 614     Any                             aOld;
 615     Any                             aNew;
 616     Any&                            rMod = bChecked? aNew : aOld;
 617
 618     //Send the STATE_CHANGED(Focused) event to accessible
 619     rMod <<= AccessibleStateType::FOCUSED;
 620     NotifyAccessibleEvent(AccessibleEventId::STATE_CHANGED, aOld, aNew);
 621
 622     rMod <<= AccessibleStateType::CHECKED;
 623
 624     NotifyAccessibleEvent(AccessibleEventId::STATE_CHANGED, aOld, aNew);
 625 }
 626
 627 void SvxRectCtlChildAccessibleContext::FireFocusEvent()
 628 {
 629     Any                             aOld;
 630     Any                             aNew;
 631     aNew <<= AccessibleStateType::FOCUSED;
 632     NotifyAccessibleEvent(AccessibleEventId::STATE_CHANGED, aOld, aNew);
 633 }
 634
 635 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */