weld SvxTextAttrPage

with a a11y rework to be more like the insert special char a11y

also, route a11y questions about a custom widgets parent to the gtk toolkits
underlying default implementation, keeping only questions about ourself to
be handled by the XAccessible

focus rectangles in RectCtl work again, seems that got lost somewhere
along the way

Change-Id: I62237d45668f4438aec6031cc5a48c38de21bf98
Reviewed-on: https://gerrit.libreoffice.org/53767
Tested-by: Jenkins <ci@libreoffice.org>
Reviewed-by: Caolán McNamara <caolanm@redhat.com>
Tested-by: Caolán McNamara <caolanm@redhat.com>

5 files changed, 1270 insertions, 25 deletions

diff --git a/svx/source/accessibility/charmapacc.cxx b/svx/source/accessibility/charmapacc.cxx
index 8e6da5d0029e..bb560b9e820d 100644
--- a/svx/source/accessibility/charmapacc.cxx
+++ b/svx/source/accessibility/charmapacc.cxx
@@ -116,15 +116,18 @@ void SvxShowCharSetAcc::implSelect(sal_Int32 nAccessibleChildIndex, bool bSelect
 
 css::awt::Rectangle SvxShowCharSetAcc::implGetBounds()
 {
-    const Point   aOutPos;//( m_pParent->GetPosPixel() );
-    Size          aOutSize( m_pParent->GetSize());
-
     awt::Rectangle aRet;
 
-    aRet.X = aOutPos.X();
-    aRet.Y = aOutPos.Y();
-    aRet.Width = aOutSize.Width();
-    aRet.Height = aOutSize.Height();
+    if (m_pParent)
+    {
+        const Point   aOutPos;//( m_pParent->GetPosPixel() );
+        Size          aOutSize( m_pParent->GetSize());
+
+        aRet.X = aOutPos.X();
+        aRet.Y = aOutPos.Y();
+        aRet.Width = aOutSize.Width();
+        aRet.Height = aOutSize.Height();
+    }
 
     return aRet;
 }
@@ -136,11 +139,6 @@ sal_Int32 SAL_CALL SvxShowCharSetAcc::getAccessibleChildCount()
     return m_pParent->getMaxCharCount();
 }
 
-sal_Int32 SAL_CALL SvxShowCharSetAcc::getAccessibleIndexInParent()
-{
-    return 0;
-}
-
 uno::Reference< css::accessibility::XAccessible > SAL_CALL SvxShowCharSetAcc::getAccessibleChild( sal_Int32 i )
 {
     OExternalLockGuard aGuard( this );
@@ -162,7 +160,9 @@ uno::Reference< css::accessibility::XAccessible > SAL_CALL SvxShowCharSetAcc::ge
 {
     OExternalLockGuard aGuard( this );
 
-    return m_pParent->getAccessibleParent();
+    if (m_pParent)
+        return m_pParent->getAccessibleParent();
+    return uno::Reference<css::accessibility::XAccessible>();
 }
 
 sal_Int16 SAL_CALL SvxShowCharSetAcc::getAccessibleRole()
diff --git a/svx/source/accessibility/svxrectctaccessiblecontext.cxx b/svx/source/accessibility/svxrectctaccessiblecontext.cxx
index bc0d4501d60d..e6c0959d20d3 100644
--- a/svx/source/accessibility/svxrectctaccessiblecontext.cxx
+++ b/svx/source/accessibility/svxrectctaccessiblecontext.cxx
@@ -97,7 +97,6 @@ static long PointToIndex( RectPoint ePoint )
     return nRet;
 }
 
-
 SvxRectCtlAccessibleContext::SvxRectCtlAccessibleContext(
     const Reference< XAccessible >&     rxParent,
     SvxRectCtl&                         rRepr ) :
@@ -625,6 +624,309 @@ void SvxRectCtlAccessibleContext::ThrowExceptionIfNotAlive()
         throw lang::DisposedException();
 }
 
+RectCtlAccessibleContext::RectCtlAccessibleContext(RectCtl* pRepr)
+    : mpRepr(pRepr)
+    , mnSelectedChild(NOCHILDSELECTED)
+{
+    {
+        ::SolarMutexGuard aSolarGuard;
+        msName = SvxResId( RID_SVXSTR_RECTCTL_ACC_CORN_NAME );
+        msDescription = SvxResId( RID_SVXSTR_RECTCTL_ACC_CORN_DESCR );
+    }
+
+    mvChildren.resize(MAX_NUM_OF_CHILDREN);
+}
+
+RectCtlAccessibleContext::~RectCtlAccessibleContext()
+{
+    ensureDisposed();
+}
+
+IMPLEMENT_FORWARD_XINTERFACE2( RectCtlAccessibleContext, OAccessibleSelectionHelper, OAccessibleHelper_Base )
+IMPLEMENT_FORWARD_XTYPEPROVIDER2( RectCtlAccessibleContext, OAccessibleSelectionHelper, OAccessibleHelper_Base )
+
+Reference< XAccessible > SAL_CALL RectCtlAccessibleContext::getAccessibleAtPoint( const awt::Point& rPoint )
+{
+    ::osl::MutexGuard           aGuard( m_aMutex );
+
+    Reference< XAccessible >    xRet;
+
+    long nChild = mpRepr ? PointToIndex(mpRepr->GetApproxRPFromPixPt(rPoint)) : NOCHILDSELECTED;
+
+    if (nChild != NOCHILDSELECTED)
+        xRet = getAccessibleChild( nChild );
+
+    return xRet;
+}
+
+// XAccessibleContext
+sal_Int32 SAL_CALL RectCtlAccessibleContext::getAccessibleChildCount()
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+
+    return SvxRectCtl::NO_CHILDREN;
+}
+
+Reference< XAccessible > SAL_CALL RectCtlAccessibleContext::getAccessibleChild( sal_Int32 nIndex )
+{
+    checkChildIndex( nIndex );
+
+    Reference< XAccessible > xChild(mvChildren[ nIndex ].get());
+    if( !xChild.is() )
+    {
+        ::SolarMutexGuard aSolarGuard;
+
+        ::osl::MutexGuard   aGuard( m_aMutex );
+
+        xChild = mvChildren[ nIndex ].get();
+
+        if (!xChild.is() && mpRepr)
+        {
+            const ChildIndexToPointData*    p = IndexToPoint( nIndex );
+            OUString aName(SvxResId(p->pResIdName));
+            OUString aDescr(SvxResId(p->pResIdDescr));
+
+            tools::Rectangle       aFocusRect( mpRepr->CalculateFocusRectangle( p->ePoint ) );
+
+            RectCtlChildAccessibleContext*   pChild = new RectCtlChildAccessibleContext(this, aName,
+                    aDescr, aFocusRect, nIndex );
+            mvChildren[ nIndex ] = pChild;
+            xChild = pChild;
+
+            // set actual state
+            if( mnSelectedChild == nIndex )
+                pChild->setStateChecked( true );
+        }
+    }
+
+    return xChild;
+}
+
+Reference< XAccessible > SAL_CALL RectCtlAccessibleContext::getAccessibleParent()
+{
+    if (mpRepr)
+        return mpRepr->getAccessibleParent();
+    return uno::Reference<css::accessibility::XAccessible>();
+}
+
+sal_Int16 SAL_CALL RectCtlAccessibleContext::getAccessibleRole()
+{
+    return AccessibleRole::PANEL;
+}
+
+OUString SAL_CALL RectCtlAccessibleContext::getAccessibleDescription()
+{
+    ::osl::MutexGuard   aGuard( m_aMutex );
+    return msDescription + " Please use arrow key to selection.";
+}
+
+OUString SAL_CALL RectCtlAccessibleContext::getAccessibleName()
+{
+    ::osl::MutexGuard   aGuard( m_aMutex );
+    return msName;
+}
+
+/** Return empty reference to indicate that the relation set is not
+    supported.
+*/
+Reference< XAccessibleRelationSet > SAL_CALL RectCtlAccessibleContext::getAccessibleRelationSet()
+{
+    if (mpRepr)
+        return mpRepr->get_accessible_relation_set();
+    return uno::Reference<css::accessibility::XAccessibleRelationSet>();
+}
+
+Reference< XAccessibleStateSet > SAL_CALL RectCtlAccessibleContext::getAccessibleStateSet()
+{
+    ::osl::MutexGuard                       aGuard( m_aMutex );
+    utl::AccessibleStateSetHelper*          pStateSetHelper = new utl::AccessibleStateSetHelper;
+
+    if (mpRepr)
+    {
+        pStateSetHelper->AddState( AccessibleStateType::ENABLED );
+        pStateSetHelper->AddState( AccessibleStateType::FOCUSABLE );
+        if( mpRepr->HasFocus() )
+            pStateSetHelper->AddState( AccessibleStateType::FOCUSED );
+        pStateSetHelper->AddState( AccessibleStateType::OPAQUE );
+
+        pStateSetHelper->AddState( AccessibleStateType::SHOWING );
+
+        if( mpRepr->IsVisible() )
+            pStateSetHelper->AddState( AccessibleStateType::VISIBLE );
+    }
+    else
+        pStateSetHelper->AddState( AccessibleStateType::DEFUNC );
+
+    return pStateSetHelper;
+}
+
+void SAL_CALL RectCtlAccessibleContext::grabFocus()
+{
+    ::SolarMutexGuard aSolarGuard;
+    ::osl::MutexGuard   aGuard( m_aMutex );
+
+    if (mpRepr)
+        mpRepr->GrabFocus();
+}
+
+sal_Int32 RectCtlAccessibleContext::getForeground()
+{
+    ::SolarMutexGuard aSolarGuard;
+    ::osl::MutexGuard   aGuard( m_aMutex );
+
+    //see SvxRectCtl::Paint
+    const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
+    return sal_Int32(rStyles.GetLabelTextColor());
+}
+
+sal_Int32 RectCtlAccessibleContext::getBackground(  )
+{
+    ::SolarMutexGuard aSolarGuard;
+    ::osl::MutexGuard   aGuard( m_aMutex );
+
+    //see SvxRectCtl::Paint
+    const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
+    return sal_Int32(rStyles.GetDialogColor());
+}
+
+// XAccessibleSelection
+void RectCtlAccessibleContext::implSelect(sal_Int32 nIndex, bool bSelect)
+{
+    ::SolarMutexGuard aSolarGuard;
+
+    ::osl::MutexGuard   aGuard( m_aMutex );
+
+    checkChildIndex( nIndex );
+
+    const ChildIndexToPointData*    pData = IndexToPoint( nIndex );
+
+    DBG_ASSERT(pData, "RectCtlAccessibleContext::selectAccessibleChild(): this is an impossible state! Or at least should be...");
+
+    if (mpRepr)
+    {
+        if (bSelect)
+        {
+            // this does all what is needed, including the change of the child's state!
+            mpRepr->SetActualRP( pData->ePoint );
+        }
+        else
+        {
+            SAL_WARN( "svx", "RectCtlAccessibleContext::clearAccessibleSelection() is not possible!" );
+        }
+    }
+}
+
+bool RectCtlAccessibleContext::implIsSelected( sal_Int32 nIndex )
+{
+    ::osl::MutexGuard   aGuard( m_aMutex );
+
+    checkChildIndex( nIndex );
+
+    return nIndex == mnSelectedChild;
+}
+
+// internals
+void RectCtlAccessibleContext::checkChildIndex( long nIndex )
+{
+    if( nIndex < 0 || nIndex >= getAccessibleChildCount() )
+        throw lang::IndexOutOfBoundsException();
+}
+
+void RectCtlAccessibleContext::FireChildFocus( RectPoint eButton )
+{
+    ::osl::MutexGuard   aGuard( m_aMutex );
+    long nNew = PointToIndex( eButton );
+    long nNumOfChildren = getAccessibleChildCount();
+    if( nNew < nNumOfChildren )
+    {
+        // select new child
+        mnSelectedChild = nNew;
+        if( nNew != NOCHILDSELECTED )
+        {
+            if( mvChildren[ nNew ].is() )
+                mvChildren[ nNew ]->FireFocusEvent();
+        }
+        else
+        {
+            Any                             aOld;
+            Any                             aNew;
+            aNew <<= AccessibleStateType::FOCUSED;
+            NotifyAccessibleEvent(AccessibleEventId::STATE_CHANGED, aNew, aOld);
+        }
+    }
+    else
+        mnSelectedChild = NOCHILDSELECTED;
+}
+
+void RectCtlAccessibleContext::selectChild( long nNew )
+{
+    ::osl::MutexGuard   aGuard( m_aMutex );
+    if( nNew != mnSelectedChild )
+    {
+        long    nNumOfChildren = getAccessibleChildCount();
+        if( nNew < nNumOfChildren )
+        {   // valid index
+            RectCtlChildAccessibleContext*   pChild;
+            if( mnSelectedChild != NOCHILDSELECTED )
+            {   // deselect old selected child if one is selected
+                pChild = mvChildren[ mnSelectedChild ].get();
+                if( pChild )
+                    pChild->setStateChecked( false );
+            }
+
+            // select new child
+            mnSelectedChild = nNew;
+
+            if( nNew != NOCHILDSELECTED )
+            {
+                if( mvChildren[ nNew ].is() )
+                    mvChildren[ nNew ]->setStateChecked( true );
+            }
+        }
+        else
+            mnSelectedChild = NOCHILDSELECTED;
+    }
+}
+
+void RectCtlAccessibleContext::selectChild(RectPoint eButton )
+{
+    // no guard -> is done in next selectChild
+    selectChild(PointToIndex( eButton ));
+}
+
+void SAL_CALL RectCtlAccessibleContext::disposing()
+{
+    ::osl::MutexGuard aGuard(m_aMutex);
+    OAccessibleSelectionHelper::disposing();
+    for (auto & rxChild : mvChildren)
+    {
+        if( rxChild.is() )
+            rxChild->dispose();
+    }
+    mvChildren.clear();
+    mpRepr = nullptr;
+}
+
+awt::Rectangle RectCtlAccessibleContext::implGetBounds()
+{
+    ::SolarMutexGuard aSolarGuard;
+    ::osl::MutexGuard   aGuard( m_aMutex );
+
+    awt::Rectangle aRet;
+
+    if (mpRepr)
+    {
+        const Point   aOutPos;//( mpRepr->GetPosPixel() );
+        Size          aOutSize( mpRepr->GetSize());
+
+        aRet.X = aOutPos.X();
+        aRet.Y = aOutPos.Y();
+        aRet.Width = aOutSize.Width();
+        aRet.Height = aOutSize.Height();
+    }
+
+    return aRet;
+}
 
 SvxRectCtlChildAccessibleContext::SvxRectCtlChildAccessibleContext(
     const Reference<XAccessible>&   rxParent,
@@ -1022,4 +1324,244 @@ void SvxRectCtlChildAccessibleContext::FireFocusEvent()
     CommitChange( AccessibleEventObject( xSource, AccessibleEventId::STATE_CHANGED, aNew, aOld ) );
 }
 
+RectCtlChildAccessibleContext::RectCtlChildAccessibleContext(
+    const Reference<XAccessible>&   rxParent,
+    const OUString&              rName,
+    const OUString&              rDescription,
+    const tools::Rectangle& rBoundingBox,
+    long nIndexInParent )
+    : msDescription( rDescription )
+    , msName( rName )
+    , mxParent(rxParent)
+    , maBoundingBox( rBoundingBox )
+    , mnIndexInParent( nIndexInParent )
+    , mbIsChecked( false )
+{
+}
+
+RectCtlChildAccessibleContext::~RectCtlChildAccessibleContext()
+{
+    ensureDisposed();
+}
+
+Reference< XAccessible > SAL_CALL RectCtlChildAccessibleContext::getAccessibleAtPoint( const awt::Point& /*rPoint*/ )
+{
+    return Reference< XAccessible >();
+}
+
+void SAL_CALL RectCtlChildAccessibleContext::grabFocus()
+{
+}
+
+sal_Int32 RectCtlChildAccessibleContext::getForeground(  )
+{
+    ::SolarMutexGuard aSolarGuard;
+    ::osl::MutexGuard   aGuard( m_aMutex );
+
+    //see SvxRectCtl::Paint
+    const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
+    return sal_Int32(rStyles.GetLabelTextColor());
+}
+
+sal_Int32 RectCtlChildAccessibleContext::getBackground(  )
+{
+    ::SolarMutexGuard aSolarGuard;
+    ::osl::MutexGuard   aGuard( m_aMutex );
+
+    //see SvxRectCtl::Paint
+    const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
+    return sal_Int32(rStyles.GetDialogColor());
+}
+
+// XAccessibleContext
+sal_Int32 SAL_CALL RectCtlChildAccessibleContext::getAccessibleChildCount()
+{
+    return 0;
+}
+
+Reference< XAccessible > SAL_CALL RectCtlChildAccessibleContext::getAccessibleChild( sal_Int32 /*nIndex*/ )
+{
+    throw lang::IndexOutOfBoundsException();
+}
+
+Reference< XAccessible > SAL_CALL RectCtlChildAccessibleContext::getAccessibleParent()
+{
+    return mxParent;
+}
+
+sal_Int16 SAL_CALL RectCtlChildAccessibleContext::getAccessibleRole()
+{
+    return AccessibleRole::RADIO_BUTTON;
+}
+
+OUString SAL_CALL RectCtlChildAccessibleContext::getAccessibleDescription()
+{
+    ::osl::MutexGuard   aGuard( m_aMutex );
+    return msDescription;
+}
+
+OUString SAL_CALL RectCtlChildAccessibleContext::getAccessibleName()
+{
+    ::osl::MutexGuard   aGuard( m_aMutex );
+    return msName;
+}
+
+/** Return empty reference to indicate that the relation set is not
+    supported.
+*/
+Reference<XAccessibleRelationSet> SAL_CALL RectCtlChildAccessibleContext::getAccessibleRelationSet()
+{
+    utl::AccessibleRelationSetHelper* pRelationSetHelper = new utl::AccessibleRelationSetHelper;
+    uno::Reference< css::accessibility::XAccessibleRelationSet > xSet = pRelationSetHelper;
+    if( mxParent.is() )
+      {
+        uno::Sequence< uno::Reference< uno::XInterface > > aSequence { mxParent };
+        pRelationSetHelper->AddRelation( css::accessibility::AccessibleRelation( css::accessibility::AccessibleRelationType::MEMBER_OF, aSequence ) );
+
+    }
+
+    return xSet;
+}
+
+Reference< XAccessibleStateSet > SAL_CALL RectCtlChildAccessibleContext::getAccessibleStateSet()
+{
+    ::osl::MutexGuard                       aGuard( m_aMutex );
+    utl::AccessibleStateSetHelper*          pStateSetHelper = new utl::AccessibleStateSetHelper;
+
+    if (!rBHelper.bDisposed)
+    {
+        if( mbIsChecked )
+        {
+            pStateSetHelper->AddState( AccessibleStateType::CHECKED );
+        }
+
+        pStateSetHelper->AddState( AccessibleStateType::ENABLED );
+        pStateSetHelper->AddState( AccessibleStateType::SENSITIVE );
+        pStateSetHelper->AddState( AccessibleStateType::OPAQUE );
+        pStateSetHelper->AddState( AccessibleStateType::SELECTABLE );
+        pStateSetHelper->AddState( AccessibleStateType::SHOWING );
+        pStateSetHelper->AddState( AccessibleStateType::VISIBLE );
+    }
+    else
+        pStateSetHelper->AddState( AccessibleStateType::DEFUNC );
+
+    return pStateSetHelper;
+}
+
+// XAccessibleValue
+Any SAL_CALL RectCtlChildAccessibleContext::getCurrentValue()
+{
+    Any aRet;
+    aRet <<= ( mbIsChecked? 1.0 : 0.0 );
+    return aRet;
+}
+
+sal_Bool SAL_CALL RectCtlChildAccessibleContext::setCurrentValue( const Any& /*aNumber*/ )
+{
+    return false;
+}
+
+Any SAL_CALL RectCtlChildAccessibleContext::getMaximumValue()
+{
+    Any aRet;
+    aRet <<= 1.0;
+    return aRet;
+}
+
+Any SAL_CALL RectCtlChildAccessibleContext::getMinimumValue()
+{
+    Any aRet;
+    aRet <<= 0.0;
+    return aRet;
+}
+
+
+// XAccessibleAction
+
+
+sal_Int32 RectCtlChildAccessibleContext::getAccessibleActionCount( )
+{
+    return 1;
+}
+
+
+sal_Bool RectCtlChildAccessibleContext::doAccessibleAction ( sal_Int32 nIndex )
+{
+    ::osl::MutexGuard   aGuard( m_aMutex );
+
+    if ( nIndex < 0 || nIndex >= getAccessibleActionCount() )
+        throw IndexOutOfBoundsException();
+
+    Reference<XAccessibleSelection> xSelection( mxParent, UNO_QUERY);
+
+    xSelection->selectAccessibleChild(mnIndexInParent);
+
+    return true;
+}
+
+
+OUString RectCtlChildAccessibleContext::getAccessibleActionDescription ( sal_Int32 nIndex )
+{
+    ::osl::MutexGuard   aGuard( m_aMutex );
+
+    if ( nIndex < 0 || nIndex >= getAccessibleActionCount() )
+        throw IndexOutOfBoundsException();
+
+    return OUString("select");
+}
+
+
+Reference< XAccessibleKeyBinding > RectCtlChildAccessibleContext::getAccessibleActionKeyBinding( sal_Int32 nIndex )
+{
+    ::osl::MutexGuard   aGuard( m_aMutex );
+
+    if ( nIndex < 0 || nIndex >= getAccessibleActionCount() )
+        throw IndexOutOfBoundsException();
+
+    return Reference< XAccessibleKeyBinding >();
+}
+
+void SAL_CALL RectCtlChildAccessibleContext::disposing()
+{
+    OAccessibleComponentHelper::disposing();
+    mxParent.clear();
+}
+
+awt::Rectangle RectCtlChildAccessibleContext::implGetBounds(  )
+{
+    // no guard necessary, because no one changes maBoundingBox after creating it
+    return AWTRectangle(maBoundingBox);
+}
+
+void RectCtlChildAccessibleContext::setStateChecked( bool bChecked )
+{
+    if( mbIsChecked != bChecked )
+    {
+        mbIsChecked = bChecked;
+
+        Any                             aOld;
+        Any                             aNew;
+        Any&                            rMod = bChecked? aNew : aOld;
+
+        //Send the STATE_CHANGED(Focused) event to accessible
+        rMod <<= AccessibleStateType::FOCUSED;
+        NotifyAccessibleEvent(AccessibleEventId::STATE_CHANGED, aNew, aOld);
+
+        rMod <<= AccessibleStateType::CHECKED;
+
+        NotifyAccessibleEvent(AccessibleEventId::STATE_CHANGED, aNew, aOld);
+    }
+}
+
+void RectCtlChildAccessibleContext::FireFocusEvent()
+{
+    Any                             aOld;
+    Any                             aNew;
+    aNew <<= AccessibleStateType::FOCUSED;
+    NotifyAccessibleEvent(AccessibleEventId::STATE_CHANGED, aNew, aOld);
+}
+
+IMPLEMENT_FORWARD_XINTERFACE2( RectCtlChildAccessibleContext, OAccessibleComponentHelper, OAccessibleHelper_Base_3 )
+IMPLEMENT_FORWARD_XTYPEPROVIDER2( RectCtlChildAccessibleContext, OAccessibleComponentHelper, OAccessibleHelper_Base_3 )
+
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/dialog/dlgctrl.cxx b/svx/source/dialog/dlgctrl.cxx
index 7e2ffb67c0e3..a4d31925d242 100644
--- a/svx/source/dialog/dlgctrl.cxx
+++ b/svx/source/dialog/dlgctrl.cxx
@@ -353,7 +353,6 @@ void SvxRectCtl::DataChanged( const DataChangedEvent& rDCEvt )
 }
 
 // the control (rectangle with 9 circles)
-
 void SvxRectCtl::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&)
 {
     InitSettings(rRenderContext);
@@ -660,6 +659,526 @@ void SvxRectCtl::DoCompletelyDisable(bool bNew)
     Invalidate();
 }
 
+BitmapEx& RectCtl::GetRectBitmap()
+{
+    if( !pBitmap )
+        InitRectBitmap();
+
+    return *pBitmap;
+}
+
+RectCtl::RectCtl(weld::Builder& rBuilder, const OString& rDrawingId, SvxTabPage* pPage, RectPoint eRpt, sal_uInt16 nBorder, sal_uInt16 nCircle)
+    : m_pPage(pPage)
+    , nBorderWidth(Application::GetDefaultDevice()->LogicToPixel(Size(nBorder, 0), MapMode(MapUnit::Map100thMM)).Width())
+    , nRadius(Application::GetDefaultDevice()->LogicToPixel(Size(nCircle, 0), MapMode(MapUnit::Map100thMM)).Width())
+    , eDefRP(eRpt)
+    , pBitmap(nullptr)
+    , m_nState(CTL_STATE::NONE)
+    , mbCompleteDisable(false)
+{
+    m_xControl.reset(rBuilder.weld_drawing_area(rDrawingId, CreateAccessible()));
+    m_xControl->connect_style_updated(LINK(this, RectCtl, MarkToResetSettings));
+    m_xControl->connect_draw(LINK(this, RectCtl, DoPaint));
+    m_xControl->connect_size_allocate(LINK(this, RectCtl, DoResize));
+    m_xControl->connect_mouse_press(LINK(this, RectCtl, DoMouseButtonDown));
+    m_xControl->connect_key_press(LINK(this, RectCtl, DoKeyDown));
+    m_xControl->connect_focus_in(LINK(this, RectCtl, DoGetFocus));
+    m_xControl->connect_focus_out(LINK(this, RectCtl, DoLoseFocus));
+
+    m_xControl->set_size_request(m_xControl->get_approximate_digit_width() * 25, m_xControl->get_text_height() * 5);
+    Resize_Impl();
+}
+
+void RectCtl::SetControlSettings(RectPoint eRpt, sal_uInt16 nBorder, sal_uInt16 nCircle)
+{
+    nBorderWidth = Application::GetDefaultDevice()->LogicToPixel(Size(nBorder, 0), MapMode(MapUnit::Map100thMM)).Width();
+    nRadius = Application::GetDefaultDevice()->LogicToPixel(Size(nCircle, 0), MapMode(MapUnit::Map100thMM)).Width();
+    eDefRP = eRpt;
+    Resize_Impl();
+}
+
+RectCtl::~RectCtl()
+{
+    delete pBitmap;
+
+    pAccContext.clear();
+}
+
+IMPL_LINK(RectCtl, DoResize, const Size&, rSize, void)
+{
+    m_aSize = rSize;
+    Resize_Impl();
+}
+
+void RectCtl::Resize_Impl()
+{
+    aPtLT = Point( 0 + nBorderWidth,  0 + nBorderWidth );
+    aPtMT = Point( m_aSize.Width() / 2, 0 + nBorderWidth );
+    aPtRT = Point( m_aSize.Width() - nBorderWidth, 0 + nBorderWidth );
+
+    aPtLM = Point( 0 + nBorderWidth,  m_aSize.Height() / 2 );
+    aPtMM = Point( m_aSize.Width() / 2, m_aSize.Height() / 2 );
+    aPtRM = Point( m_aSize.Width() - nBorderWidth, m_aSize.Height() / 2 );
+
+    aPtLB = Point( 0 + nBorderWidth,    m_aSize.Height() - nBorderWidth );
+    aPtMB = Point( m_aSize.Width() / 2,   m_aSize.Height() - nBorderWidth );
+    aPtRB = Point( m_aSize.Width() - nBorderWidth, m_aSize.Height() - nBorderWidth );
+
+    Reset();
+    MarkToResetSettings(*m_xControl);
+    m_xControl->queue_draw();
+}
+
+void RectCtl::InitRectBitmap()
+{
+    delete pBitmap;
+
+    const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
+    svtools::ColorConfig aColorConfig;
+
+    pBitmap = new BitmapEx(RID_SVXCTRL_RECTBTNS);
+
+    // set bitmap-colors
+    Color aColorAry1[7];
+    Color aColorAry2[7];
+    aColorAry1[0] = Color( 0xC0, 0xC0, 0xC0 );  // light-gray
+    aColorAry1[1] = Color( 0xFF, 0xFF, 0x00 );  // yellow
+    aColorAry1[2] = Color( 0xFF, 0xFF, 0xFF );  // white
+    aColorAry1[3] = Color( 0x80, 0x80, 0x80 );  // dark-gray
+    aColorAry1[4] = Color( 0x00, 0x00, 0x00 );  // black
+    aColorAry1[5] = Color( 0x00, 0xFF, 0x00 );  // green
+    aColorAry1[6] = Color( 0x00, 0x00, 0xFF );  // blue
+    aColorAry2[0] = rStyles.GetDialogColor();       // background
+    aColorAry2[1] = rStyles.GetWindowColor();
+    aColorAry2[2] = rStyles.GetLightColor();
+    aColorAry2[3] = rStyles.GetShadowColor();
+    aColorAry2[4] = rStyles.GetDarkShadowColor();
+    aColorAry2[5] = aColorConfig.GetColorValue( svtools::FONTCOLOR ).nColor;
+    aColorAry2[6] = rStyles.GetDialogColor();
+
+#ifdef DBG_UTIL
+    static bool     bModify = false;
+    bool&           rModify = bModify;
+    if( rModify )
+    {
+        static int      n = 0;
+        static sal_uInt8    r = 0xFF;
+        static sal_uInt8    g = 0x00;
+        static sal_uInt8    b = 0xFF;
+        int&            rn = n;
+        sal_uInt8&          rr = r;
+        sal_uInt8&          rg = g;
+        sal_uInt8&          rb = b;
+        aColorAry2[ rn ] = Color( rr, rg, rb );
+    }
+#endif
+
+    pBitmap->Replace( aColorAry1, aColorAry2, 7 );
+}
+
+IMPL_LINK_NOARG(RectCtl, MarkToResetSettings, weld::Widget&, void)
+{
+    delete pBitmap;
+    pBitmap = nullptr; // forces new creating of bitmap
+}
+
+void RectCtl::InitSettings(vcl::RenderContext& rRenderContext)
+{
+    svtools::ColorConfig aColorConfig;
+    Color aTextColor(aColorConfig.GetColorValue(svtools::FONTCOLOR).nColor);
+    rRenderContext.SetTextColor(aTextColor);
+    const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
+    rRenderContext.SetBackground(rStyleSettings.GetWindowColor());
+}
+
+// The clicked rectangle (3 x 3) is determined and the parent (dialog)
+// is notified that the item was changed
+IMPL_LINK(RectCtl, DoMouseButtonDown, const MouseEvent&, rMEvt, void)
+{
+    // CompletelyDisabled() added to have a disabled state for RectCtl
+    if(!IsCompletelyDisabled())
+    {
+        aPtNew = GetApproxLogPtFromPixPt( rMEvt.GetPosPixel() );
+        eRP = GetRPFromPoint( aPtNew );
+        SetActualRP( eRP );
+
+        if (m_pPage)
+            m_pPage->PointChanged(m_xControl.get(), eRP);
+    }
+}
+
+IMPL_LINK(RectCtl, DoKeyDown, const KeyEvent&, rKeyEvt, bool)
+{
+    // CompletelyDisabled() added to have a disabled state for RectCtl
+    if (IsCompletelyDisabled())
+        return false;
+
+    RectPoint eNewRP = eRP;
+
+    switch( rKeyEvt.GetKeyCode().GetCode() )
+    {
+        case KEY_DOWN:
+        {
+            if( !(m_nState & CTL_STATE::NOVERT) )
+                switch( eNewRP )
+                {
+                    case RectPoint::LT: eNewRP = RectPoint::LM; break;
+                    case RectPoint::MT: eNewRP = RectPoint::MM; break;
+                    case RectPoint::RT: eNewRP = RectPoint::RM; break;
+                    case RectPoint::LM: eNewRP = RectPoint::LB; break;
+                    case RectPoint::MM: eNewRP = RectPoint::MB; break;
+                    case RectPoint::RM: eNewRP = RectPoint::RB; break;
+                    default: ; //prevent warning
+                }
+        }
+        break;
+        case KEY_UP:
+        {
+            if( !(m_nState & CTL_STATE::NOVERT) )
+                switch( eNewRP )
+                {
+                    case RectPoint::LM: eNewRP = RectPoint::LT; break;
+                    case RectPoint::MM: eNewRP = RectPoint::MT; break;
+                    case RectPoint::RM: eNewRP = RectPoint::RT; break;
+                    case RectPoint::LB: eNewRP = RectPoint::LM; break;
+                    case RectPoint::MB: eNewRP = RectPoint::MM; break;
+                    case RectPoint::RB: eNewRP = RectPoint::RM; break;
+                    default: ; //prevent warning
+                }
+        }
+        break;
+        case KEY_LEFT:
+        {
+            if( !(m_nState & CTL_STATE::NOHORZ) )
+                switch( eNewRP )
+                {
+                    case RectPoint::MT: eNewRP = RectPoint::LT; break;
+                    case RectPoint::RT: eNewRP = RectPoint::MT; break;
+                    case RectPoint::MM: eNewRP = RectPoint::LM; break;
+                    case RectPoint::RM: eNewRP = RectPoint::MM; break;
+                    case RectPoint::MB: eNewRP = RectPoint::LB; break;
+                    case RectPoint::RB: eNewRP = RectPoint::MB; break;
+                    default: ; //prevent warning
+                }
+        }
+        break;
+        case KEY_RIGHT:
+        {
+            if( !(m_nState & CTL_STATE::NOHORZ) )
+                switch( eNewRP )
+                {
+                    case RectPoint::LT: eNewRP = RectPoint::MT; break;
+                    case RectPoint::MT: eNewRP = RectPoint::RT; break;
+                    case RectPoint::LM: eNewRP = RectPoint::MM; break;
+                    case RectPoint::MM: eNewRP = RectPoint::RM; break;
+                    case RectPoint::LB: eNewRP = RectPoint::MB; break;
+                    case RectPoint::MB: eNewRP = RectPoint::RB; break;
+                    default: ; //prevent warning
+                }
+        }
+        break;
+        default:
+            return false;
+    }
+    if( eNewRP != eRP )
+    {
+        SetActualRP( eNewRP );
+
+        if (m_pPage)
+            m_pPage->PointChanged(m_xControl.get(), eRP);
+    }
+    return true;
+}
+
+// the control (rectangle with 9 circles)
+IMPL_LINK(RectCtl, DoPaint, weld::DrawingArea::draw_args, aPayload, void)
+{
+    vcl::RenderContext& rRenderContext = aPayload.first;
+
+    InitSettings(rRenderContext);
+
+    Point aPtDiff(1, 1);
+
+    const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
+
+    rRenderContext.SetLineColor(rStyles.GetDialogColor());
+    rRenderContext.SetFillColor(rStyles.GetDialogColor());
+    rRenderContext.DrawRect(tools::Rectangle(Point(0,0), rRenderContext.GetOutputSize()));
+
+    if (m_xControl->get_sensitive())
+        rRenderContext.SetLineColor(rStyles.GetLabelTextColor());
+    else
+        rRenderContext.SetLineColor(rStyles.GetShadowColor());
+
+    rRenderContext.SetFillColor();
+
+    if (!m_xControl->get_sensitive())
+    {
+        Color aOldCol = rRenderContext.GetLineColor();
+        rRenderContext.SetLineColor(rStyles.GetLightColor());
+        rRenderContext.DrawRect(tools::Rectangle(aPtLT + aPtDiff, aPtRB + aPtDiff));
+        rRenderContext.SetLineColor(aOldCol);
+    }
+    rRenderContext.DrawRect(tools::Rectangle(aPtLT, aPtRB));
+
+    rRenderContext.SetFillColor(rRenderContext.GetBackground().GetColor());
+
+    Size aBtnSize(11, 11);
+    Size aDstBtnSize(aBtnSize);
+    Point aToCenter(aDstBtnSize.Width() >> 1, aDstBtnSize.Height() >> 1);
+    Point aBtnPnt1(m_xControl->get_sensitive() ? 0 : 22, 0);
+    Point aBtnPnt2(11, 0);
+    Point aBtnPnt3(22, 0);
+
+    bool bNoHorz = bool(m_nState & CTL_STATE::NOHORZ);
+    bool bNoVert = bool(m_nState & CTL_STATE::NOVERT);
+
+    BitmapEx& rBitmap = GetRectBitmap();
+
+    // CompletelyDisabled() added to have a disabled state for SvxRectCtl
+    if (IsCompletelyDisabled())
+    {
+        rRenderContext.DrawBitmap(aPtLT - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap.GetBitmap());
+        rRenderContext.DrawBitmap(aPtMT - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap.GetBitmap());
+        rRenderContext.DrawBitmap(aPtRT - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap.GetBitmap());
+        rRenderContext.DrawBitmap(aPtLM - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap.GetBitmap());
+        rRenderContext.DrawBitmap(aPtMM - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap.GetBitmap());
+        rRenderContext.DrawBitmap(aPtRM - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap.GetBitmap());
+        rRenderContext.DrawBitmap(aPtLB - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap.GetBitmap());
+        rRenderContext.DrawBitmap(aPtMB - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap.GetBitmap());
+        rRenderContext.DrawBitmap(aPtRB - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap.GetBitmap());
+    }
+    else
+    {
+        rRenderContext.DrawBitmap(aPtLT - aToCenter, aDstBtnSize, (bNoHorz || bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap.GetBitmap());
+        rRenderContext.DrawBitmap(aPtMT - aToCenter, aDstBtnSize, bNoVert?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap.GetBitmap());
+        rRenderContext.DrawBitmap(aPtRT - aToCenter, aDstBtnSize, (bNoHorz || bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap.GetBitmap());
+        rRenderContext.DrawBitmap(aPtLM - aToCenter, aDstBtnSize, bNoHorz?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap.GetBitmap());
+
+        // Center for rectangle and line
+        rRenderContext.DrawBitmap(aPtMM - aToCenter, aDstBtnSize, aBtnPnt1, aBtnSize, rBitmap.GetBitmap());
+
+        rRenderContext.DrawBitmap(aPtRM - aToCenter, aDstBtnSize, bNoHorz?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap.GetBitmap());
+        rRenderContext.DrawBitmap(aPtLB - aToCenter, aDstBtnSize, (bNoHorz || bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap.GetBitmap());
+        rRenderContext.DrawBitmap(aPtMB - aToCenter, aDstBtnSize, bNoVert?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap.GetBitmap());
+        rRenderContext.DrawBitmap(aPtRB - aToCenter, aDstBtnSize, (bNoHorz || bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap.GetBitmap());
+    }
+
+    // draw active button, avoid center pos for angle
+    // CompletelyDisabled() added to have a disabled state for SvxRectCtl
+    if (!IsCompletelyDisabled())
+    {
+        if (m_xControl->get_sensitive())
+        {
+            Point aCenterPt(aPtNew);
+            aCenterPt -= aToCenter;
+
+            rRenderContext.DrawBitmap(aCenterPt, aDstBtnSize, aBtnPnt2, aBtnSize, rBitmap.GetBitmap());
+        }
+    }
+
+    if (m_xControl->has_focus())
+    {
+        tools::Rectangle aFocusRect(CalculateFocusRectangle());
+        rRenderContext.Invert(aFocusRect, InvertFlags(0xffff));
+    }
+}
+
+// Convert RectPoint Point
+
+const Point& RectCtl::GetPointFromRP( RectPoint _eRP) const
+{
+    switch( _eRP )
+    {
+        case RectPoint::LT: return aPtLT;
+        case RectPoint::MT: return aPtMT;
+        case RectPoint::RT: return aPtRT;
+        case RectPoint::LM: return aPtLM;
+        case RectPoint::MM: return aPtMM;
+        case RectPoint::RM: return aPtRM;
+        case RectPoint::LB: return aPtLB;
+        case RectPoint::MB: return aPtMB;
+        case RectPoint::RB: return aPtRB;
+    }
+    return aPtMM; // default
+}
+
+Point RectCtl::SetActualRPWithoutInvalidate( RectPoint eNewRP )
+{
+    Point aPtLast = aPtNew;
+    aPtNew = GetPointFromRP( eNewRP );
+
+    if( m_nState & CTL_STATE::NOHORZ )
+        aPtNew.setX( aPtMM.X() );
+
+    if( m_nState & CTL_STATE::NOVERT )
+        aPtNew.setY( aPtMM.Y() );
+
+    // fdo#74751 this fix reverse base point on RTL UI.
+    bool bRTL = AllSettings::GetLayoutRTL();
+    eNewRP = GetRPFromPoint( aPtNew, bRTL );
+
+    eDefRP = eNewRP;
+    eRP = eNewRP;
+
+    return aPtLast;
+}
+
+IMPL_LINK_NOARG(RectCtl, DoGetFocus, weld::Widget&, void)
+{
+    m_xControl->queue_draw();
+
+    // Send accessibility event.
+    if (pAccContext.is())
+    {
+        pAccContext->FireChildFocus(GetActualRP());
+    }
+}
+
+IMPL_LINK_NOARG(RectCtl, DoLoseFocus, weld::Widget&, void)
+{
+    m_xControl->queue_draw();
+}
+
+Point RectCtl::GetApproxLogPtFromPixPt( const Point& rPt ) const
+{
+    Point   aPt = rPt;
+    long    x;
+    long    y;
+
+    if( !( m_nState & CTL_STATE::NOHORZ ) )
+    {
+        if( aPt.X() < m_aSize.Width() / 3 )
+            x = aPtLT.X();
+        else if( aPt.X() < m_aSize.Width() * 2 / 3 )
+            x = aPtMM.X();
+        else
+            x = aPtRB.X();
+    }
+    else
+        x = aPtMM.X();
+
+    if( !( m_nState & CTL_STATE::NOVERT ) )
+    {
+        if( aPt.Y() < m_aSize.Height() / 3 )
+            y = aPtLT.Y();
+        else if( aPt.Y() < m_aSize.Height() * 2 / 3 )
+            y = aPtMM.Y();
+        else
+            y = aPtRB.Y();
+    }
+    else
+            y = aPtMM.Y();
+
+    return Point( x, y );
+}
+
+
+// Converts Point in RectPoint
+
+RectPoint RectCtl::GetRPFromPoint( Point aPt, bool bRTL ) const
+{
+    RectPoint rPoint = RectPoint::MM;  // default
+
+    if (aPt == aPtLT) rPoint = bRTL ? RectPoint::RT : RectPoint::LT;
+    else if( aPt == aPtMT) rPoint = RectPoint::MT;
+    else if( aPt == aPtRT) rPoint = bRTL ? RectPoint::LT : RectPoint::RT;
+    else if( aPt == aPtLM) rPoint = bRTL ? RectPoint::RM : RectPoint::LM;
+    else if( aPt == aPtRM) rPoint = bRTL ? RectPoint::LM : RectPoint::RM;
+    else if( aPt == aPtLB) rPoint = bRTL ? RectPoint::RB : RectPoint::LB;
+    else if( aPt == aPtMB) rPoint = RectPoint::MB;
+    else if( aPt == aPtRB) rPoint = bRTL ? RectPoint::LB : RectPoint::RB;
+
+    return rPoint;
+}
+
+// Resets to the original state of the control
+
+void RectCtl::Reset()
+{
+    aPtNew = GetPointFromRP( eDefRP );
+    eRP = eDefRP;
+    m_xControl->queue_draw();
+}
+
+// Returns the currently selected RectPoint
+
+
+void RectCtl::SetActualRP( RectPoint eNewRP )
+{
+    SetActualRPWithoutInvalidate(eNewRP);
+
+    m_xControl->queue_draw();
+
+    // notify accessibility object about change
+    if (pAccContext.is())
+        pAccContext->selectChild( eNewRP /* MT, bFireFocus */ );
+}
+
+void RectCtl::SetState( CTL_STATE nState )
+{
+    m_nState = nState;
+
+    Point aPtLast( GetPointFromRP( eRP ) );
+    Point _aPtNew( aPtLast );
+
+    if( m_nState & CTL_STATE::NOHORZ )
+        _aPtNew.setX( aPtMM.X() );
+
+    if( m_nState & CTL_STATE::NOVERT)
+        _aPtNew.setY( aPtMM.Y() );
+
+    eRP = GetRPFromPoint( _aPtNew );
+    m_xControl->queue_draw();
+
+    if (m_pPage)
+        m_pPage->PointChanged(m_xControl.get(), eRP);
+}
+
+tools::Rectangle RectCtl::CalculateFocusRectangle() const
+{
+    Size        aDstBtnSize(15, 15);
+    return tools::Rectangle( aPtNew - Point( aDstBtnSize.Width() >> 1, aDstBtnSize.Height() >> 1 ), aDstBtnSize );
+}
+
+tools::Rectangle RectCtl::CalculateFocusRectangle( RectPoint eRectPoint ) const
+{
+    tools::Rectangle   aRet;
+    RectPoint  eOldRectPoint = GetActualRP();
+
+    if( eOldRectPoint == eRectPoint )
+        aRet = CalculateFocusRectangle();
+    else
+    {
+        RectCtl* pThis = const_cast<RectCtl*>(this);
+
+        pThis->SetActualRPWithoutInvalidate( eRectPoint );      // no invalidation because it's only temporary!
+        aRet = CalculateFocusRectangle();
+
+        pThis->SetActualRPWithoutInvalidate( eOldRectPoint );   // no invalidation because nothing has changed!
+    }
+
+    return aRet;
+}
+
+Reference< XAccessible > RectCtl::CreateAccessible()
+{
+    pAccContext = new RectCtlAccessibleContext(this);
+    return pAccContext.get();
+}
+
+RectPoint RectCtl::GetApproxRPFromPixPt( const css::awt::Point& r ) const
+{
+    return GetRPFromPoint( GetApproxLogPtFromPixPt( Point( r.X, r.Y ) ) );
+}
+
+// CompletelyDisabled() added to have a disabled state for RectCtl
+void RectCtl::DoCompletelyDisable(bool bNew)
+{
+    mbCompleteDisable = bNew;
+    m_xControl->queue_draw();
+}
+
 // Control for editing bitmaps
 
 css::uno::Reference< css::accessibility::XAccessible > SvxPixelCtl::CreateAccessible()
diff --git a/svx/source/inc/charmapacc.hxx b/svx/source/inc/charmapacc.hxx
index 346add7aec3b..d594f390495e 100644
--- a/svx/source/inc/charmapacc.hxx
+++ b/svx/source/inc/charmapacc.hxx
@@ -85,7 +85,6 @@ namespace svx
 
         //OAccessibleContextHelper
         // XAccessibleContext - still waiting to be overwritten
-        virtual sal_Int32 SAL_CALL getAccessibleIndexInParent() override;
         virtual sal_Int32 SAL_CALL getAccessibleChildCount() override;
         virtual css::uno::Reference< css::accessibility::XAccessible > SAL_CALL getAccessibleChild( sal_Int32 i ) override;
         virtual css::uno::Reference< css::accessibility::XAccessible > SAL_CALL getAccessibleParent(  ) override;
diff --git a/svx/source/inc/svxrectctaccessiblecontext.hxx b/svx/source/inc/svxrectctaccessiblecontext.hxx
index 35e11bef8684..347e7f4c82ad 100644
--- a/svx/source/inc/svxrectctaccessiblecontext.hxx
+++ b/svx/source/inc/svxrectctaccessiblecontext.hxx
@@ -41,7 +41,9 @@
 #include <cppuhelper/interfacecontainer.h>
 #include <cppuhelper/compbase6.hxx>
 #include <cppuhelper/compbase7.hxx>
+#include <cppuhelper/compbase3.hxx>
 #include <cppuhelper/basemutex.hxx>
+#include <comphelper/accessibleselectionhelper.hxx>
 #include <comphelper/servicehelper.hxx>
 #include <svx/rectenum.hxx>
 #include <vcl/vclptr.hxx>
@@ -56,11 +58,12 @@ namespace com { namespace sun { namespace star { namespace awt {
 } } } }
 
 namespace tools { class Rectangle; }
+class RectCtl;
 class SvxRectCtl;
+class RectCtlChildAccessibleContext;
 class SvxRectCtlChildAccessibleContext;
 namespace vcl { class Window; }
 
-
 typedef ::cppu::WeakAggComponentImplHelper6<
             css::accessibility::XAccessible,
             css::accessibility::XAccessibleComponent,
@@ -230,7 +233,10 @@ private:
     virtual void SAL_CALL disposing() override;
 
     /// @returns true if it's disposed or in disposing
-    inline bool IsAlive() const;
+    bool IsAlive() const
+    {
+        return !rBHelper.bDisposed && !rBHelper.bInDispose;
+    }
 
     /// @throws css::lang::DisposedException if it's not alive
     void ThrowExceptionIfNotAlive();
@@ -261,10 +267,93 @@ private:
     long                                mnSelectedChild;
 };
 
-inline bool SvxRectCtlAccessibleContext::IsAlive() const
+typedef ::cppu::ImplHelper1<css::accessibility::XAccessible> OAccessibleHelper_Base;
+
+class RectCtlAccessibleContext final : public ::comphelper::OAccessibleSelectionHelper,
+                                       public OAccessibleHelper_Base
 {
-    return !rBHelper.bDisposed && !rBHelper.bInDispose;
-}
+public:
+    // internal
+    RectCtlAccessibleContext(RectCtl* pRepresentation);
+
+    DECLARE_XINTERFACE( )
+    DECLARE_XTYPEPROVIDER( )
+
+    // XAccessibleComponent
+    virtual void SAL_CALL grabFocus() override;
+    virtual css::uno::Reference< css::accessibility::XAccessible > SAL_CALL getAccessibleAtPoint(const css::awt::Point& rPoint) override;
+
+    // XAccessible
+    // XAccessibleContext
+    virtual sal_Int32 SAL_CALL getAccessibleChildCount() override;
+    virtual css::uno::Reference< css::accessibility::XAccessible> SAL_CALL getAccessibleChild(sal_Int32 nIndex) override;
+    virtual css::uno::Reference< css::accessibility::XAccessible> SAL_CALL getAccessibleParent() override;
+    virtual sal_Int16 SAL_CALL getAccessibleRole() override;
+    virtual OUString SAL_CALL getAccessibleDescription() override;
+    virtual OUString SAL_CALL getAccessibleName() override;
+    virtual css::uno::Reference< css::accessibility::XAccessibleRelationSet > SAL_CALL getAccessibleRelationSet() override;
+    virtual css::uno::Reference< css::accessibility::XAccessibleStateSet > SAL_CALL getAccessibleStateSet() override;
+
+    virtual css::uno::Reference< css::accessibility::XAccessibleContext> SAL_CALL getAccessibleContext() override { return this; }
+    virtual sal_Int32 SAL_CALL getForeground() override;
+    virtual sal_Int32 SAL_CALL getBackground() override;
+
+    /** Selects a new child by point.
+
+        <p>If the child was not selected before, the state of the child will
+        be updated. If the point is not invalid, the index will internally set to NOCHILDSELECTED</p>
+
+        @param eButton
+            Button which belongs to the child which should be selected.
+    */
+    void selectChild( RectPoint ePoint );
+    void FireChildFocus( RectPoint eButton );
+
+private:
+    virtual ~RectCtlAccessibleContext() override;
+
+    // OCommonAccessibleSelection
+    // return if the specified child is visible => watch for special ChildIndexes (ACCESSIBLE_SELECTION_CHILD_xxx)
+    virtual bool implIsSelected(sal_Int32 nAccessibleChildIndex) override;
+
+    // select the specified child => watch for special ChildIndexes (ACCESSIBLE_SELECTION_CHILD_xxx)
+    virtual void implSelect(sal_Int32 nAccessibleChildIndex, bool bSelect) override;
+
+    // OCommonAccessibleComponent
+    virtual css::awt::Rectangle implGetBounds() override;
+
+    virtual void SAL_CALL disposing() override;
+
+    void checkChildIndex(long nIndex);
+
+    /** Selects a new child by index.
+
+        <p>If the child was not selected before, the state of the child will
+        be updated. If the index is invalid, the index will internally set to NOCHILDSELECTED</p>
+
+        @param nIndexOfChild
+            Index of the new child which should be selected.
+    */
+    void selectChild( long nIndexOfChild );
+
+    /** Description of this object.  This is not a constant because it can
+        be set from the outside.
+    */
+    OUString                     msDescription;
+
+    /** Name of this object.
+    */
+    OUString                     msName;
+
+    /// pointer to internal representation
+    RectCtl*                  mpRepr;
+
+    /// array for all possible children
+    std::vector<rtl::Reference<RectCtlChildAccessibleContext>>  mvChildren;
+
+    /// actual selected child
+    long                                mnSelectedChild;
+};
 
 typedef ::cppu::WeakAggComponentImplHelper7<
             css::accessibility::XAccessible,
@@ -408,7 +497,10 @@ protected:
     virtual void SAL_CALL disposing() override;
 
     /// @returns true if it's disposed or in disposing
-    inline bool IsAlive() const;
+    bool IsAlive() const
+    {
+        return !rBHelper.bDisposed && !rBHelper.bInDispose;
+    }
 
     /// @throws css::lang::DisposedException if it's not alive
     void ThrowExceptionIfNotAlive();
@@ -449,10 +541,103 @@ private:
     bool                            mbIsChecked;
 };
 
-inline bool SvxRectCtlChildAccessibleContext::IsAlive() const
+typedef ::cppu::ImplHelper3 <   css::accessibility::XAccessible,
+                                css::accessibility::XAccessibleValue,
+                                css::accessibility::XAccessibleAction
+                            >   OAccessibleHelper_Base_3;
+
+class RectCtlChildAccessibleContext : public ::comphelper::OAccessibleComponentHelper,
+                                      public OAccessibleHelper_Base_3
 {
-    return !rBHelper.bDisposed && !rBHelper.bInDispose;
-}
+public:
+    RectCtlChildAccessibleContext(
+        const css::uno::Reference< css::accessibility::XAccessible>& rxParent,
+        const OUString& rName, const OUString& rDescription,
+        const tools::Rectangle& rBoundingBox,
+        long nIndexInParent );
+protected:
+    virtual ~RectCtlChildAccessibleContext() override;
+
+    // OCommonAccessibleComponent
+    /// implements the calculation of the bounding rectangle - still waiting to be overwritten
+    virtual css::awt::Rectangle implGetBounds(  ) override;
+public:
+
+    DECLARE_XINTERFACE( )
+    DECLARE_XTYPEPROVIDER( )
+
+    // XAccessibleComponent
+    virtual void SAL_CALL grabFocus() override;
+    virtual css::uno::Reference< css::accessibility::XAccessible > SAL_CALL getAccessibleAtPoint( const css::awt::Point& rPoint ) override;
+
+    // XAccessibleContext
+    virtual sal_Int32 SAL_CALL getAccessibleChildCount() override;
+    virtual css::uno::Reference< css::accessibility::XAccessible > SAL_CALL getAccessibleChild( sal_Int32 nIndex ) override;
+    virtual css::uno::Reference< css::accessibility::XAccessible > SAL_CALL getAccessibleParent() override;
+    virtual sal_Int16 SAL_CALL getAccessibleRole() override;
+    virtual OUString SAL_CALL getAccessibleDescription() override;
+    virtual OUString SAL_CALL getAccessibleName() override;
+    virtual css::uno::Reference< css::accessibility::XAccessibleRelationSet > SAL_CALL getAccessibleRelationSet() override;
+    virtual css::uno::Reference< css::accessibility::XAccessibleStateSet > SAL_CALL getAccessibleStateSet() override;
+
+    virtual css::uno::Reference< css::accessibility::XAccessibleContext> SAL_CALL getAccessibleContext() override { return this; }
+
+    virtual sal_Int32 SAL_CALL getForeground() override;
+    virtual sal_Int32 SAL_CALL getBackground() override;
+
+    // XAccessibleValue
+    virtual css::uno::Any SAL_CALL
+        getCurrentValue() override;
+
+    virtual sal_Bool SAL_CALL
+        setCurrentValue( const css::uno::Any& aNumber ) override;
+
+    virtual css::uno::Any SAL_CALL
+        getMaximumValue() override;
+
+    virtual css::uno::Any SAL_CALL
+        getMinimumValue() override;
+
+    // XAccessibleAction
+    virtual sal_Int32 SAL_CALL getAccessibleActionCount( ) override;
+    virtual sal_Bool SAL_CALL doAccessibleAction ( sal_Int32 nIndex ) override;
+    virtual ::rtl::OUString SAL_CALL getAccessibleActionDescription ( sal_Int32 nIndex ) override;
+    virtual css::uno::Reference< css::accessibility::XAccessibleKeyBinding > SAL_CALL getAccessibleActionKeyBinding( sal_Int32 nIndex ) override;
+
+    // internal
+    /// Sets the checked status
+    void setStateChecked(bool bChecked);
+    void FireFocusEvent();
+
+protected:
+    virtual void SAL_CALL disposing() override;
+
+private:
+
+    /** Description of this object.  This is not a constant because it can
+        be set from the outside.  Furthermore, it changes according to the
+        draw page's display mode.
+    */
+    OUString                     msDescription;
+
+    /** Name of this object.  It changes according the draw page's
+        display mode.
+    */
+    OUString                     msName;
+
+    /// Reference to the parent object.
+    css::uno::Reference< css::accessibility::XAccessible >
+                                        mxParent;
+
+    /// Bounding box
+    tools::Rectangle                         maBoundingBox;
+
+    /// index of child in parent
+    long                                mnIndexInParent;
+
+    /// Indicates, if object is checked
+    bool                            mbIsChecked;
+};
 
 
 #endif