Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 866 insertions, 0 deletions

diff --git a/accessibility/source/standard/vclxaccessibletoolbox.cxx b/accessibility/source/standard/vclxaccessibletoolbox.cxx
new file mode 100644
index 000000000..4e2059b61
--- /dev/null
+++ b/accessibility/source/standard/vclxaccessibletoolbox.cxx
@@ -0,0 +1,866 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#include <string.h>
+
+#include <standard/vclxaccessibletoolbox.hxx>
+#include <standard/vclxaccessibletoolboxitem.hxx>
+#include <toolkit/helper/convert.hxx>
+
+#include <unotools/accessiblestatesethelper.hxx>
+#include <com/sun/star/accessibility/AccessibleEventId.hpp>
+#include <com/sun/star/accessibility/AccessibleStateType.hpp>
+#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
+#include <com/sun/star/lang/XUnoTunnel.hpp>
+#include <o3tl/safeint.hxx>
+#include <vcl/toolbox.hxx>
+#include <vcl/vclevent.hxx>
+#include <comphelper/accessiblewrapper.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/servicehelper.hxx>
+#include <comphelper/types.hxx>
+
+using namespace ::comphelper;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::accessibility;
+
+namespace
+{
+
+    // = OToolBoxWindowItemContext
+
+    /** XAccessibleContext implementation for a toolbox item which is represented by a VCL Window
+    */
+    class OToolBoxWindowItemContext final : public OAccessibleContextWrapper
+    {
+        sal_Int32 m_nIndexInParent;
+    public:
+        OToolBoxWindowItemContext(sal_Int32 _nIndexInParent,
+            const css::uno::Reference< css::uno::XComponentContext >& _rxContext,
+            const css::uno::Reference< css::accessibility::XAccessibleContext >& _rxInnerAccessibleContext,
+            const css::uno::Reference< css::accessibility::XAccessible >& _rxOwningAccessible,
+            const css::uno::Reference< css::accessibility::XAccessible >& _rxParentAccessible
+            ) : OAccessibleContextWrapper(
+            _rxContext,
+            _rxInnerAccessibleContext,
+            _rxOwningAccessible,
+            _rxParentAccessible     )
+            ,m_nIndexInParent(_nIndexInParent)
+        {
+        }
+        virtual sal_Int32 SAL_CALL getAccessibleIndexInParent(  ) override;
+    };
+
+
+    sal_Int32 SAL_CALL OToolBoxWindowItemContext::getAccessibleIndexInParent(  )
+    {
+        ::osl::MutexGuard aGuard( m_aMutex );
+        return m_nIndexInParent;
+    }
+
+
+    // = OToolBoxWindowItem
+
+    typedef ::cppu::ImplHelper1 <   XUnoTunnel
+                                >   OToolBoxWindowItem_Base;
+
+    /** XAccessible implementation for a toolbox item which is represented by a VCL Window
+    */
+    class OToolBoxWindowItem
+            :public OAccessibleWrapper
+            ,public OToolBoxWindowItem_Base
+    {
+    private:
+        sal_Int32 m_nIndexInParent;
+
+    public:
+        sal_Int32    getIndexInParent() const                    { return m_nIndexInParent; }
+        void         setIndexInParent( sal_Int32 _nNewIndex )    { m_nIndexInParent = _nNewIndex; }
+
+        static const Sequence< sal_Int8 > & getUnoTunnelId();
+
+    public:
+        OToolBoxWindowItem(sal_Int32 _nIndexInParent,
+            const css::uno::Reference< css::uno::XComponentContext >& _rxContext,
+            const css::uno::Reference< css::accessibility::XAccessible >& _rxInnerAccessible,
+            const css::uno::Reference< css::accessibility::XAccessible >& _rxParentAccessible
+            ) : OAccessibleWrapper(
+            _rxContext,
+            _rxInnerAccessible,
+            _rxParentAccessible)
+            ,m_nIndexInParent(_nIndexInParent)
+        {
+        }
+
+    protected:
+        // XInterface
+        DECLARE_XINTERFACE( )
+        DECLARE_XTYPEPROVIDER( )
+
+        // OAccessibleWrapper
+        virtual rtl::Reference<OAccessibleContextWrapper> createAccessibleContext(
+                const css::uno::Reference< css::accessibility::XAccessibleContext >& _rxInnerContext
+            ) override;
+
+        // XUnoTunnel
+        virtual sal_Int64 SAL_CALL getSomething( const Sequence< sal_Int8 >& aIdentifier ) override;
+    };
+
+    IMPLEMENT_FORWARD_XINTERFACE2( OToolBoxWindowItem, OAccessibleWrapper, OToolBoxWindowItem_Base )
+    IMPLEMENT_FORWARD_XTYPEPROVIDER2( OToolBoxWindowItem, OAccessibleWrapper, OToolBoxWindowItem_Base )
+
+    rtl::Reference<OAccessibleContextWrapper> OToolBoxWindowItem::createAccessibleContext(
+            const Reference< XAccessibleContext >& _rxInnerContext )
+    {
+        return new OToolBoxWindowItemContext( m_nIndexInParent, getComponentContext(), _rxInnerContext, this, getParent() );
+    }
+
+    const Sequence< sal_Int8 > & OToolBoxWindowItem::getUnoTunnelId()
+    {
+        static const comphelper::UnoIdInit implId;
+        return implId.getSeq();
+    }
+
+    sal_Int64 SAL_CALL OToolBoxWindowItem::getSomething( const Sequence< sal_Int8 >& _rId )
+    {
+        return comphelper::getSomethingImpl(_rId, this);
+    }
+}
+
+// VCLXAccessibleToolBox
+
+VCLXAccessibleToolBox::VCLXAccessibleToolBox( VCLXWindow* pVCLXWindow ) :
+
+    VCLXAccessibleComponent( pVCLXWindow )
+
+{
+}
+
+VCLXAccessibleToolBox::~VCLXAccessibleToolBox()
+{
+}
+
+VCLXAccessibleToolBoxItem* VCLXAccessibleToolBox::GetItem_Impl( ToolBox::ImplToolItems::size_type _nPos )
+{
+    VCLXAccessibleToolBoxItem* pItem = nullptr;
+    VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
+    if ( pToolBox )
+    {
+        ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.find( _nPos );
+            //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
+        // returns only toolbox buttons, not windows
+        if ( aIter != m_aAccessibleChildren.end()  && aIter->second.is())
+            pItem = static_cast< VCLXAccessibleToolBoxItem* >( aIter->second.get() );
+    }
+
+    return pItem;
+}
+
+void VCLXAccessibleToolBox::UpdateFocus_Impl()
+{
+    VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
+    if( !pToolBox )
+        return;
+
+    // submit events only if toolbox has the focus to avoid sending events due to mouse move
+    bool bHasFocus = false;
+    if ( pToolBox->HasFocus() )
+        bHasFocus = true;
+    else
+    {
+        // check for subtoolbar, i.e. check if our parent is a toolbar
+        ToolBox* pToolBoxParent = dynamic_cast< ToolBox* >( pToolBox->GetParent() );
+        // subtoolbars never get the focus as key input is just forwarded, so check if the parent toolbar has it
+        if ( pToolBoxParent && pToolBoxParent->HasFocus() )
+            bHasFocus = true;
+    }
+
+    if ( !bHasFocus )
+        return;
+
+    ToolBoxItemId nHighlightItemId = pToolBox->GetHighlightItemId();
+    sal_uInt16 nFocusCount = 0;
+    for ( const auto& [rPos, rxChild] : m_aAccessibleChildren )
+    {
+        ToolBoxItemId nItemId = pToolBox->GetItemId( rPos );
+
+        if ( rxChild.is() )
+        {
+            VCLXAccessibleToolBoxItem* pItem =
+                static_cast< VCLXAccessibleToolBoxItem* >( rxChild.get() );
+            if ( pItem->HasFocus() && nItemId != nHighlightItemId )
+            {
+                // reset the old focused item
+                pItem->SetFocus( false );
+                nFocusCount++;
+            }
+            if ( nItemId == nHighlightItemId )
+            {
+                // set the new focused item
+                pItem->SetFocus( true );
+                nFocusCount++;
+            }
+        }
+        // both items changed?
+        if ( nFocusCount > 1 )
+            break;
+    }
+}
+
+void VCLXAccessibleToolBox::ReleaseFocus_Impl( ToolBox::ImplToolItems::size_type _nPos )
+{
+    VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
+    if ( pToolBox ) // #107124#, do not check for focus because this message is also handled in losefocus
+    {
+        ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.find( _nPos );
+            //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
+        if ( aIter != m_aAccessibleChildren.end() && aIter->second.is() )
+        {
+            VCLXAccessibleToolBoxItem* pItem =
+                static_cast< VCLXAccessibleToolBoxItem* >( aIter->second.get() );
+            if ( pItem->HasFocus() )
+                pItem->SetFocus( false );
+        }
+    }
+}
+
+void VCLXAccessibleToolBox::UpdateChecked_Impl( ToolBox::ImplToolItems::size_type _nPos )
+{
+    VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
+    if ( !pToolBox )
+        return;
+
+    ToolBoxItemId nFocusId = pToolBox->GetItemId( _nPos );
+    VCLXAccessibleToolBoxItem* pFocusItem = nullptr;
+
+    for ( const auto& [rPos, rxChild] : m_aAccessibleChildren )
+    {
+            ToolBoxItemId nItemId = pToolBox->GetItemId( rPos );
+
+            VCLXAccessibleToolBoxItem* pItem =
+                static_cast< VCLXAccessibleToolBoxItem* >( rxChild.get() );
+            pItem->SetChecked( pToolBox->IsItemChecked( nItemId ) );
+            if ( nItemId == nFocusId )
+                pFocusItem = pItem;
+    }
+    //Solution:If the position is not a child item,the focus should not be called
+    if ( pFocusItem && _nPos != ToolBox::ITEM_NOTFOUND )
+        pFocusItem->SetFocus( true );
+}
+
+void VCLXAccessibleToolBox::UpdateIndeterminate_Impl( ToolBox::ImplToolItems::size_type _nPos )
+{
+    VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
+    if ( !pToolBox )
+        return;
+
+    ToolBoxItemId nItemId = pToolBox->GetItemId( _nPos );
+
+    ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.find( _nPos );
+        //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
+    if ( aIter != m_aAccessibleChildren.end() && aIter->second.is() )
+    {
+        VCLXAccessibleToolBoxItem* pItem =
+            static_cast< VCLXAccessibleToolBoxItem* >( aIter->second.get() );
+        if ( pItem )
+            pItem->SetIndeterminate( pToolBox->GetItemState( nItemId ) == TRISTATE_INDET );
+    }
+}
+
+void VCLXAccessibleToolBox::implReleaseToolboxItem( ToolBoxItemsMap::iterator const & _rMapPos,
+        bool _bNotifyRemoval )
+{
+    Reference< XAccessible > xItemAcc( _rMapPos->second );
+    if ( !xItemAcc.is() )
+        return;
+
+    if ( _bNotifyRemoval )
+    {
+        NotifyAccessibleEvent( AccessibleEventId::CHILD, Any( xItemAcc ), Any() );
+    }
+
+    auto pWindowItem = comphelper::getFromUnoTunnel<OToolBoxWindowItem>(xItemAcc);
+    if ( !pWindowItem )
+    {
+        static_cast< VCLXAccessibleToolBoxItem* >( xItemAcc.get() )->ReleaseToolBox();
+        ::comphelper::disposeComponent( xItemAcc );
+    }
+    else
+    {
+        Reference< XAccessibleContext > xContext( pWindowItem->getContextNoCreate() );
+        ::comphelper::disposeComponent( xContext );
+    }
+}
+
+void VCLXAccessibleToolBox::UpdateItem_Impl( ToolBox::ImplToolItems::size_type _nPos)
+{
+    if ( _nPos < m_aAccessibleChildren.size() )
+    {
+        UpdateAllItems_Impl();
+        return;
+    }
+
+    VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
+    if ( !pToolBox )
+        return;
+
+    // adjust the "index-in-parent"s
+    ToolBoxItemsMap::iterator aIndexAdjust = m_aAccessibleChildren.upper_bound( _nPos );
+        //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
+    while ( m_aAccessibleChildren.end() != aIndexAdjust )
+    {
+        Reference< XAccessible > xItemAcc( aIndexAdjust->second );
+
+        auto pWindowItem = comphelper::getFromUnoTunnel<OToolBoxWindowItem>(xItemAcc);
+        if ( !pWindowItem )
+        {
+            VCLXAccessibleToolBoxItem* pItem = static_cast< VCLXAccessibleToolBoxItem* >( xItemAcc.get() );
+            if ( pItem )
+            {
+                sal_Int32 nIndex = pItem->getIndexInParent( );
+                nIndex++;
+                pItem->setIndexInParent( nIndex );
+            }
+        }
+        else
+        {
+            sal_Int32 nIndex = pWindowItem->getIndexInParent( );
+            nIndex++;
+            pWindowItem->setIndexInParent( nIndex );
+        }
+
+        ++aIndexAdjust;
+    }
+
+    // TODO: we should make this dependent on the existence of event listeners
+    // with the current implementation, we always create accessible object
+    Any aNewChild( getAccessibleChild( static_cast<sal_Int32>(_nPos) ) );
+        //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
+    NotifyAccessibleEvent( AccessibleEventId::CHILD, Any(), aNewChild );
+}
+
+void VCLXAccessibleToolBox::UpdateAllItems_Impl()
+{
+    VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
+    if ( !pToolBox )
+        return;
+
+    // deregister the old items
+    for ( ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.begin();
+            aIter != m_aAccessibleChildren.end(); ++aIter )
+    {
+        implReleaseToolboxItem( aIter, true );
+    }
+    m_aAccessibleChildren.clear();
+
+    // register the new items
+    ToolBox::ImplToolItems::size_type i, nCount = pToolBox->GetItemCount();
+    for ( i = 0; i < nCount; ++i )
+    {
+        Any aNewValue;
+        aNewValue <<= getAccessibleChild( static_cast<sal_Int32>(i) );
+            //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
+        NotifyAccessibleEvent( AccessibleEventId::CHILD, Any(), aNewValue );
+    }
+}
+
+void VCLXAccessibleToolBox::UpdateCustomPopupItemp_Impl( vcl::Window* pWindow, bool bOpen )
+{
+    VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
+    if( !(pWindow && pToolBox) )
+        return;
+
+    const ToolBoxItemId nDownItem = pToolBox->GetDownItemId();
+    if ( !nDownItem )
+        // No item is currently in down state.
+        // Moreover, calling GetItemPos with 0 will find a separator if there is any.
+        return;
+
+    Reference< XAccessible > xChild( pWindow->GetAccessible() );
+    if( xChild.is() )
+    {
+        Reference< XAccessible > xChildItem( getAccessibleChild( static_cast< sal_Int32 >( pToolBox->GetItemPos( nDownItem ) ) ) );
+            //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
+        VCLXAccessibleToolBoxItem* pItem = static_cast< VCLXAccessibleToolBoxItem* >( xChildItem.get() );
+
+        pItem->SetChild( xChild );
+        pItem->NotifyChildEvent( xChild, bOpen );
+    }
+}
+
+void VCLXAccessibleToolBox::UpdateItemName_Impl( ToolBox::ImplToolItems::size_type _nPos )
+{
+    VCLXAccessibleToolBoxItem* pItem = GetItem_Impl( _nPos );
+    if ( pItem )
+        pItem->NameChanged();
+}
+
+void VCLXAccessibleToolBox::UpdateItemEnabled_Impl( ToolBox::ImplToolItems::size_type _nPos )
+{
+    VCLXAccessibleToolBoxItem* pItem = GetItem_Impl( _nPos );
+    if ( pItem )
+        pItem->ToggleEnableState();
+}
+
+void VCLXAccessibleToolBox::HandleSubToolBarEvent( const VclWindowEvent& rVclWindowEvent )
+{
+    vcl::Window* pChildWindow = static_cast<vcl::Window *>(rVclWindowEvent.GetData());
+    VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
+    if ( !(pChildWindow
+        && pToolBox
+        && pToolBox == pChildWindow->GetParent()
+        && pChildWindow->GetType() == WindowType::TOOLBOX) )
+        return;
+
+    const ToolBoxItemId nCurItemId( pToolBox->GetCurItemId() );
+    if ( !nCurItemId )
+        // No item is currently active (might happen when opening the overflow popup).
+        // Moreover, calling GetItemPos with 0 will find a separator if there is any.
+        return;
+
+    ToolBox::ImplToolItems::size_type nIndex = pToolBox->GetItemPos( nCurItemId );
+    Reference< XAccessible > xItem = getAccessibleChild( nIndex );
+        //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
+    if ( xItem.is() )
+    {
+        Reference< XAccessible > xChild = pChildWindow->GetAccessible();
+        VCLXAccessibleToolBoxItem* pItem =
+            static_cast< VCLXAccessibleToolBoxItem* >( xItem.get() );
+        pItem->SetChild( xChild );
+        pItem->NotifyChildEvent( xChild, true/*_bShow*/ );
+    }
+}
+
+void VCLXAccessibleToolBox::ReleaseSubToolBox( ToolBox* _pSubToolBox )
+{
+    VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
+    if ( !pToolBox )
+        return;
+
+    ToolBox::ImplToolItems::size_type nIndex = pToolBox->GetItemPos( pToolBox->GetCurItemId() );
+    if ( nIndex == ToolBox::ITEM_NOTFOUND )
+        return; // not found
+
+    Reference< XAccessible > xItem = getAccessibleChild( nIndex );
+        //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
+    if ( !xItem.is() )
+        return;
+
+    Reference< XAccessible > xChild = _pSubToolBox->GetAccessible();
+    VCLXAccessibleToolBoxItem* pItem =
+        static_cast< VCLXAccessibleToolBoxItem* >( xItem.get() );
+    if ( pItem->GetChild() == xChild )
+    {
+        pItem->SetChild( Reference< XAccessible >() );
+        pItem->NotifyChildEvent( xChild, false );
+    }
+}
+
+void VCLXAccessibleToolBox::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet )
+{
+    VCLXAccessibleComponent::FillAccessibleStateSet( rStateSet );
+
+    VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
+    if ( pToolBox )
+    {
+        rStateSet.AddState( AccessibleStateType::FOCUSABLE );
+        if ( pToolBox->IsHorizontal() )
+            rStateSet.AddState( AccessibleStateType::HORIZONTAL );
+        else
+            rStateSet.AddState( AccessibleStateType::VERTICAL );
+    }
+}
+
+void VCLXAccessibleToolBox::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
+{
+    // to prevent an early release of the toolbox (VclEventId::ObjectDying)
+    Reference< XAccessibleContext > xHoldAlive = this;
+
+    switch ( rVclWindowEvent.GetId() )
+    {
+        case VclEventId::ToolboxClick:
+        case VclEventId::ToolboxSelect:
+        {
+            VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
+            if ( rVclWindowEvent.GetData() )
+            {
+                UpdateChecked_Impl( static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())) );
+                UpdateIndeterminate_Impl( static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())) );
+            }
+            else if( pToolBox->GetItemPos(pToolBox->GetCurItemId()) != ToolBox::ITEM_NOTFOUND )
+            {
+                UpdateChecked_Impl( pToolBox->GetItemPos(pToolBox->GetCurItemId()) );
+                UpdateIndeterminate_Impl( pToolBox->GetItemPos(pToolBox->GetCurItemId()) );
+            }
+            break;
+        }
+        case VclEventId::ToolboxDoubleClick:
+        case VclEventId::ToolboxActivate:
+        case VclEventId::ToolboxDeactivate:
+        //case VclEventId::ToolboxSelect:
+            break;
+
+        case VclEventId::ToolboxItemUpdated:
+        {
+            if ( rVclWindowEvent.GetData() )
+            {
+                UpdateChecked_Impl( ToolBox::ITEM_NOTFOUND );
+                UpdateIndeterminate_Impl( static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())) );
+            }
+            break;
+        }
+
+        case VclEventId::ToolboxHighlight:
+            UpdateFocus_Impl();
+            break;
+
+        case VclEventId::ToolboxHighlightOff:
+            ReleaseFocus_Impl( static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())) );
+            break;
+
+        case VclEventId::ToolboxItemAdded :
+            UpdateItem_Impl( static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())) );
+            break;
+
+        case VclEventId::ToolboxItemRemoved :
+        case VclEventId::ToolboxAllItemsChanged :
+        {
+            UpdateAllItems_Impl();
+            break;
+        }
+
+        case VclEventId::ToolboxItemWindowChanged:
+        {
+            auto nPos = static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData()));
+            ToolBoxItemsMap::iterator aAccessiblePos( m_aAccessibleChildren.find( nPos ) );
+                //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
+            if ( m_aAccessibleChildren.end() != aAccessiblePos )
+            {
+                implReleaseToolboxItem( aAccessiblePos, false );
+                m_aAccessibleChildren.erase (aAccessiblePos);
+            }
+
+            Any aNewValue;
+            aNewValue <<= getAccessibleChild(nPos);
+                //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
+            NotifyAccessibleEvent( AccessibleEventId::CHILD, Any(), aNewValue );
+            break;
+        }
+        case VclEventId::ToolboxItemTextChanged :
+            UpdateItemName_Impl( static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())) );
+            break;
+
+        case VclEventId::ToolboxItemEnabled :
+        case VclEventId::ToolboxItemDisabled :
+        {
+            UpdateItemEnabled_Impl( static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())) );
+            break;
+        }
+
+        case VclEventId::DropdownOpen:
+        case VclEventId::DropdownClose:
+        {
+            UpdateCustomPopupItemp_Impl( static_cast< vcl::Window* >( rVclWindowEvent.GetData() ), rVclWindowEvent.GetId() == VclEventId::DropdownOpen );
+            break;
+        }
+
+        case VclEventId::ObjectDying :
+        {
+            // if this toolbox is a subtoolbox, we have to release it from its parent
+            VclPtr< vcl::Window > pWin = GetAs< vcl::Window >();
+            if ( pWin && pWin->GetParent() &&
+                 pWin->GetParent()->GetType() == WindowType::TOOLBOX )
+            {
+                auto pParentAccContext = pWin->GetParent()->GetAccessible()->getAccessibleContext();
+                VCLXAccessibleToolBox* pParent = static_cast< VCLXAccessibleToolBox* >( pParentAccContext.get() );
+                if ( pParent )
+                    pParent->ReleaseSubToolBox(static_cast<ToolBox *>(pWin.get()));
+            }
+
+            // dispose all items
+            for ( ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.begin();
+                  aIter != m_aAccessibleChildren.end(); ++aIter )
+            {
+                implReleaseToolboxItem( aIter, false );
+            }
+            m_aAccessibleChildren.clear();
+
+            [[fallthrough]]; // call base class
+        }
+
+        default:
+            VCLXAccessibleComponent::ProcessWindowEvent( rVclWindowEvent );
+    }
+}
+
+void VCLXAccessibleToolBox::ProcessWindowChildEvent( const VclWindowEvent& rVclWindowEvent )
+{
+    switch ( rVclWindowEvent.GetId() )
+    {
+        case VclEventId::WindowShow:  // send create on show for direct accessible children
+        {
+            Reference< XAccessible > xReturn = GetItemWindowAccessible(rVclWindowEvent);
+            if ( xReturn.is() )
+                NotifyAccessibleEvent( AccessibleEventId::CHILD, Any(), Any(xReturn) );
+            else
+                HandleSubToolBarEvent( rVclWindowEvent );
+        }
+        break;
+
+        default:
+           VCLXAccessibleComponent::ProcessWindowChildEvent( rVclWindowEvent );
+
+    }
+}
+
+// XInterface
+IMPLEMENT_FORWARD_XINTERFACE2( VCLXAccessibleToolBox, VCLXAccessibleComponent, VCLXAccessibleToolBox_BASE )
+
+// XTypeProvider
+IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXAccessibleToolBox, VCLXAccessibleComponent, VCLXAccessibleToolBox_BASE )
+
+// XComponent
+void SAL_CALL VCLXAccessibleToolBox::disposing()
+{
+    VCLXAccessibleComponent::disposing();
+
+    // release the items
+    for ( ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.begin();
+          aIter != m_aAccessibleChildren.end(); ++aIter )
+    {
+        implReleaseToolboxItem( aIter, false );
+    }
+    m_aAccessibleChildren.clear();
+}
+
+// XServiceInfo
+OUString VCLXAccessibleToolBox::getImplementationName()
+{
+    return "com.sun.star.comp.toolkit.AccessibleToolBox";
+}
+
+Sequence< OUString > VCLXAccessibleToolBox::getSupportedServiceNames()
+{
+    return comphelper::concatSequences(VCLXAccessibleComponent::getSupportedServiceNames(),
+                                       Sequence<OUString>{"com.sun.star.accessibility.AccessibleToolBox"});
+}
+
+// XAccessibleContext
+sal_Int32 SAL_CALL VCLXAccessibleToolBox::getAccessibleChildCount(  )
+{
+    comphelper::OExternalLockGuard aGuard( this );
+    return implGetAccessibleChildCount();
+}
+
+ sal_Int32 VCLXAccessibleToolBox::implGetAccessibleChildCount(  )
+ {
+    sal_Int32 nCount = 0;
+    VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
+    if ( pToolBox )
+        nCount = pToolBox->GetItemCount();
+            //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
+
+    return nCount;
+}
+
+Reference< XAccessible > SAL_CALL VCLXAccessibleToolBox::getAccessibleChild( sal_Int32 i )
+{
+    comphelper::OExternalLockGuard aGuard( this );
+
+    VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
+    if ( (!pToolBox) || i < 0 || o3tl::make_unsigned(i) >= pToolBox->GetItemCount() )
+        throw IndexOutOfBoundsException();
+
+    Reference< XAccessible > xChild;
+    // search for the child
+    ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.find(i);
+    if ( m_aAccessibleChildren.end() == aIter )
+    {
+        ToolBoxItemId nItemId = pToolBox->GetItemId( i );
+        ToolBoxItemId nHighlightItemId = pToolBox->GetHighlightItemId();
+        vcl::Window* pItemWindow = pToolBox->GetItemWindow( nItemId );
+        // not found -> create a new child
+        rtl::Reference<VCLXAccessibleToolBoxItem> pChild = new VCLXAccessibleToolBoxItem( pToolBox, i );
+        Reference< XAccessible> xParent = pChild;
+        if ( pItemWindow )
+        {
+            xChild = new OToolBoxWindowItem(0,::comphelper::getProcessComponentContext(),pItemWindow->GetAccessible(),xParent);
+            pItemWindow->SetAccessible(xChild);
+            pChild->SetChild( xChild );
+        }
+        xChild = pChild;
+        if ( nHighlightItemId > ToolBoxItemId(0) && nItemId == nHighlightItemId )
+            pChild->SetFocus( true );
+        if ( pToolBox->IsItemChecked( nItemId ) )
+            pChild->SetChecked( true );
+        if ( pToolBox->GetItemState( nItemId ) == TRISTATE_INDET )
+            pChild->SetIndeterminate( true );
+        m_aAccessibleChildren.emplace( i, xChild );
+    }
+    else
+    {
+        // found it
+        xChild = aIter->second;
+    }
+    return xChild;
+}
+
+Reference< XAccessible > SAL_CALL VCLXAccessibleToolBox::getAccessibleAtPoint( const awt::Point& _rPoint )
+{
+    comphelper::OExternalLockGuard aGuard( this );
+
+    Reference< XAccessible > xAccessible;
+    VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
+    if ( pToolBox )
+    {
+        ToolBox::ImplToolItems::size_type nItemPos = pToolBox->GetItemPos( VCLPoint( _rPoint ) );
+        if ( nItemPos != ToolBox::ITEM_NOTFOUND )
+            xAccessible = getAccessibleChild( nItemPos );
+                //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
+    }
+
+    return xAccessible;
+}
+
+Reference< XAccessible > VCLXAccessibleToolBox::GetItemWindowAccessible( const VclWindowEvent& rVclWindowEvent )
+{
+    Reference< XAccessible > xReturn;
+    vcl::Window* pChildWindow = static_cast<vcl::Window *>(rVclWindowEvent.GetData());
+    VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
+    if ( pChildWindow && pToolBox )
+    {
+        ToolBox::ImplToolItems::size_type nCount = pToolBox->GetItemCount();
+        for (ToolBox::ImplToolItems::size_type i = 0 ; i < nCount && !xReturn.is() ; ++i)
+        {
+            ToolBoxItemId nItemId = pToolBox->GetItemId( i );
+            vcl::Window* pItemWindow = pToolBox->GetItemWindow( nItemId );
+            if ( pItemWindow == pChildWindow )
+                xReturn = getAccessibleChild(i);
+                    //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
+        }
+    }
+    return xReturn;
+}
+
+Reference< XAccessible > VCLXAccessibleToolBox::GetChildAccessible( const VclWindowEvent& rVclWindowEvent )
+{
+    Reference< XAccessible > xReturn = GetItemWindowAccessible(rVclWindowEvent);
+
+    if ( !xReturn.is() )
+        xReturn = VCLXAccessibleComponent::GetChildAccessible(rVclWindowEvent);
+    return xReturn;
+}
+
+// XAccessibleSelection
+void VCLXAccessibleToolBox::selectAccessibleChild( sal_Int32 nChildIndex )
+{
+    OExternalLockGuard aGuard( this );
+
+    VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
+    if ( (!pToolBox) || nChildIndex < 0 || o3tl::make_unsigned(nChildIndex) >= pToolBox->GetItemCount() )
+        throw IndexOutOfBoundsException();
+
+    pToolBox->ChangeHighlight( nChildIndex );
+}
+
+sal_Bool VCLXAccessibleToolBox::isAccessibleChildSelected( sal_Int32 nChildIndex )
+{
+    OExternalLockGuard aGuard( this );
+    VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
+    if ( (!pToolBox) || nChildIndex < 0 || o3tl::make_unsigned(nChildIndex) >= pToolBox->GetItemCount() )
+        throw IndexOutOfBoundsException();
+
+    if ( pToolBox->GetHighlightItemId() == pToolBox->GetItemId( nChildIndex ) )
+        return true;
+    else
+        return false;
+}
+
+void VCLXAccessibleToolBox::clearAccessibleSelection(  )
+{
+    OExternalLockGuard aGuard( this );
+    VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
+    pToolBox -> LoseFocus();
+}
+
+void VCLXAccessibleToolBox::selectAllAccessibleChildren(  )
+{
+    OExternalLockGuard aGuard( this );
+    // intentionally empty. makes no sense for a toolbox
+}
+
+sal_Int32 VCLXAccessibleToolBox::getSelectedAccessibleChildCount(  )
+{
+    OExternalLockGuard aGuard( this );
+
+    sal_Int32 nRet = 0;
+    VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
+    if (pToolBox)
+    {
+        ToolBoxItemId nHighlightItemId = pToolBox->GetHighlightItemId();
+        for ( size_t i = 0, nCount = pToolBox->GetItemCount(); i < nCount; i++ )
+        {
+            if ( nHighlightItemId == pToolBox->GetItemId( i ) )
+            {
+                nRet = 1;
+                break; // a toolbox can only have (n)one selected child
+            }
+        }
+    }
+
+    return nRet;
+}
+
+Reference< XAccessible > VCLXAccessibleToolBox::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex )
+{
+    OExternalLockGuard aGuard( this );
+    if ( nSelectedChildIndex != 0 )
+        throw IndexOutOfBoundsException();
+
+    Reference< XAccessible > xChild;
+    VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
+    if (pToolBox)
+    {
+        ToolBoxItemId nHighlightItemId = pToolBox->GetHighlightItemId();
+        for ( sal_Int32 i = 0, nCount = pToolBox->GetItemCount(); i < nCount; i++ )
+        {
+            if ( nHighlightItemId == pToolBox->GetItemId( i ) )
+            {
+                xChild = getAccessibleChild( i );
+                break;
+            }
+        }
+    }
+
+    if (!xChild)
+        throw IndexOutOfBoundsException();
+
+    return xChild;
+}
+
+void VCLXAccessibleToolBox::deselectAccessibleChild( sal_Int32 nChildIndex )
+{
+    OExternalLockGuard aGuard( this );
+    if ( nChildIndex < 0 || nChildIndex >= implGetAccessibleChildCount() )
+        throw IndexOutOfBoundsException();
+    clearAccessibleSelection(); // a toolbox can only have (n)one selected child
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */