/**************************************************************
 * 
 * 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
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_accessibility.hxx"

// includes --------------------------------------------------------------
#include <accessibility/standard/vclxaccessibletoolbox.hxx>
#include <accessibility/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/XUnoTunnel.hpp>
#include <com/sun/star/lang/XUnoTunnel.hpp>
#include <tools/debug.hxx>
#include <vcl/toolbox.hxx>
#include <comphelper/accessiblewrapper.hxx>
#include <comphelper/processfactory.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 : public OAccessibleContextWrapper
	{
		sal_Int32 m_nIndexInParent;
	public:
		OToolBoxWindowItemContext(sal_Int32 _nIndexInParent,
			const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& _rxORB,
			const ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext >& _rxInnerAccessibleContext,
			const ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible >& _rxOwningAccessible,
			const ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible >& _rxParentAccessible
			) : OAccessibleContextWrapper(
			_rxORB,
			_rxInnerAccessibleContext,
			_rxOwningAccessible,
			_rxParentAccessible		)
			,m_nIndexInParent(_nIndexInParent)
		{
		}
		virtual sal_Int32 SAL_CALL getAccessibleIndexInParent(  ) throw (::com::sun::star::uno::RuntimeException);
	};

	// -------------------------------------------------------------------------
	sal_Int32 SAL_CALL OToolBoxWindowItemContext::getAccessibleIndexInParent(  ) throw (::com::sun::star::uno::RuntimeException)
	{
		::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:
		inline sal_Int32	getIndexInParent() const					{ return m_nIndexInParent; }
		inline void			setIndexInParent( sal_Int32 _nNewIndex )	{ m_nIndexInParent = _nNewIndex; }

        static	sal_Bool	isWindowItem( const Reference< XAccessible >& _rxAcc, OToolBoxWindowItem** /* [out] */ _ppImplementation = NULL );

	public:
		OToolBoxWindowItem(sal_Int32 _nIndexInParent,
			const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& _rxORB,
			const ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible >& _rxInnerAccessible,
			const ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible >& _rxParentAccessible
			) : OAccessibleWrapper(
			_rxORB,
			_rxInnerAccessible,
			_rxParentAccessible)
			,m_nIndexInParent(_nIndexInParent)
		{
		}

	protected:
		// XInterface
		DECLARE_XINTERFACE( )
		DECLARE_XTYPEPROVIDER( )

		// OAccessibleWrapper
		virtual OAccessibleContextWrapper* createAccessibleContext(
				const ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext >& _rxInnerContext
			);

		// XUnoTunnel
		virtual sal_Int64 SAL_CALL getSomething( const Sequence< sal_Int8 >& aIdentifier ) throw (RuntimeException);
		static Sequence< sal_Int8 > getUnoTunnelImplementationId();
	};

	// -------------------------------------------------------------------------
	IMPLEMENT_FORWARD_XINTERFACE2( OToolBoxWindowItem, OAccessibleWrapper, OToolBoxWindowItem_Base )
	IMPLEMENT_FORWARD_XTYPEPROVIDER2( OToolBoxWindowItem, OAccessibleWrapper, OToolBoxWindowItem_Base )

	// -------------------------------------------------------------------------
	OAccessibleContextWrapper* OToolBoxWindowItem::createAccessibleContext(
			const Reference< XAccessibleContext >& _rxInnerContext )
	{
		return new OToolBoxWindowItemContext( m_nIndexInParent,getORB(), _rxInnerContext, this, getParent() );
	}

	//--------------------------------------------------------------------
	sal_Bool OToolBoxWindowItem::isWindowItem( const Reference< XAccessible >& _rxAcc, OToolBoxWindowItem** /* [out] */ _ppImplementation )
	{
		OToolBoxWindowItem* pImplementation = NULL;

		Reference< XUnoTunnel > xTunnel( _rxAcc, UNO_QUERY );
		if ( xTunnel.is() )
			pImplementation = reinterpret_cast< OToolBoxWindowItem* >( xTunnel->getSomething( getUnoTunnelImplementationId() ) );

		if ( _ppImplementation )
			*_ppImplementation = pImplementation;

		return NULL != pImplementation;
	}

	//--------------------------------------------------------------------
	Sequence< sal_Int8 > OToolBoxWindowItem::getUnoTunnelImplementationId()
	{
		static ::cppu::OImplementationId * pId = 0;
		if (! pId)
		{
			::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
			if (! pId)
			{
				static ::cppu::OImplementationId aId;
				pId = &aId;
			}
		}
		return pId->getImplementationId();
	}

	//--------------------------------------------------------------------
	sal_Int64 SAL_CALL OToolBoxWindowItem::getSomething( const Sequence< sal_Int8 >& _rId ) throw (RuntimeException)
	{
		if	(	( 16 == _rId.getLength() )
			&&	( 0 == rtl_compareMemory( getUnoTunnelImplementationId().getConstArray(),  _rId.getConstArray(), 16 ) )
			)
			return reinterpret_cast< sal_Int64>( this );

		return 0;
	}
}

DBG_NAME(VCLXAccessibleToolBox)

// -----------------------------------------------------------------------------
// VCLXAccessibleToolBox
// -----------------------------------------------------------------------------
VCLXAccessibleToolBox::VCLXAccessibleToolBox( VCLXWindow* pVCLXWindow ) :

	VCLXAccessibleComponent( pVCLXWindow )

{
	DBG_CTOR(VCLXAccessibleToolBox,NULL);
}
// -----------------------------------------------------------------------------
VCLXAccessibleToolBox::~VCLXAccessibleToolBox()
{
	DBG_DTOR(VCLXAccessibleToolBox,NULL);
}
// -----------------------------------------------------------------------------
VCLXAccessibleToolBoxItem* VCLXAccessibleToolBox::GetItem_Impl( sal_Int32 _nPos, bool _bMustHaveFocus )
{
	VCLXAccessibleToolBoxItem* pItem = NULL;
    ToolBox* pToolBox = static_cast< ToolBox* >( GetWindow() );
    if ( pToolBox && ( !_bMustHaveFocus || pToolBox->HasFocus() ) )
	{
		ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.find( _nPos );
		// 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()
{
    ToolBox* pToolBox = static_cast< ToolBox* >( GetWindow() );
    if( !pToolBox )
        return;

    // submit events only if toolbox has the focus to avoid sending events due to mouse move
    sal_Bool bHasFocus = sal_False;
    if ( pToolBox->HasFocus() )
        bHasFocus = sal_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 = sal_True;
    }

    if ( bHasFocus )
	{
		sal_uInt16 nHighlightItemId = pToolBox->GetHighlightItemId();
		sal_uInt16 nFocusCount = 0;
        for ( ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.begin();
			  aIter != m_aAccessibleChildren.end(); ++aIter )
		{
            sal_uInt16 nItemId = pToolBox->GetItemId( (sal_uInt16)aIter->first );

            if ( aIter->second.is() )
            {
                VCLXAccessibleToolBoxItem* pItem =
                    static_cast< VCLXAccessibleToolBoxItem* >( aIter->second.get() );
                if ( pItem->HasFocus() && nItemId != nHighlightItemId )
                {
                    // reset the old focused item
                    pItem->SetFocus( sal_False );
                    nFocusCount++;
                }
                if ( nItemId == nHighlightItemId )
                {
                    // set the new focused item
                    pItem->SetFocus( sal_True );
                    nFocusCount++;
                }
            }
        // both items changed?
        if ( nFocusCount > 1 )
            break;
        }
	}
}
// -----------------------------------------------------------------------------
void VCLXAccessibleToolBox::ReleaseFocus_Impl( sal_Int32 _nPos )
{
    ToolBox* pToolBox = static_cast< ToolBox* >( GetWindow() );
    if ( pToolBox ) // #107124#, do not check for focus because this message is also handled in losefocus
	{
        ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.find( _nPos );
        if ( aIter != m_aAccessibleChildren.end() && aIter->second.is() )
        {
            VCLXAccessibleToolBoxItem* pItem =
                static_cast< VCLXAccessibleToolBoxItem* >( aIter->second.get() );
            if ( pItem->HasFocus() )
                pItem->SetFocus( sal_False );
        }
	}
}
// -----------------------------------------------------------------------------
void VCLXAccessibleToolBox::UpdateChecked_Impl( sal_Int32 _nPos )
{
    ToolBox* pToolBox = static_cast< ToolBox* >( GetWindow() );
    if ( pToolBox )
	{
		sal_uInt16 nFocusId = pToolBox->GetItemId( (sal_uInt16)_nPos );
		VCLXAccessibleToolBoxItem* pFocusItem = NULL;

	    for ( ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.begin();
			  aIter != m_aAccessibleChildren.end(); ++aIter )
		{
				sal_uInt16 nItemId = pToolBox->GetItemId( (sal_uInt16)aIter->first );

                VCLXAccessibleToolBoxItem* pItem =
                    static_cast< VCLXAccessibleToolBoxItem* >( aIter->second.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 && (sal_uInt16)_nPos != TOOLBOX_ITEM_NOTFOUND )
			pFocusItem->SetFocus( sal_True );
	}
}
// -----------------------------------------------------------------------------
void VCLXAccessibleToolBox::UpdateIndeterminate_Impl( sal_Int32 _nPos )
{
    ToolBox* pToolBox = static_cast< ToolBox* >( GetWindow() );
    if ( pToolBox )
	{
		sal_uInt16 nItemId = pToolBox->GetItemId( (sal_uInt16)_nPos );

        ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.find( _nPos );
        if ( aIter != m_aAccessibleChildren.end() && aIter->second.is() )
        {
            VCLXAccessibleToolBoxItem* pItem =
                static_cast< VCLXAccessibleToolBoxItem* >( aIter->second.get() );
            if ( pItem )
                pItem->SetIndeterminate( pToolBox->GetItemState( nItemId ) == STATE_DONTKNOW );
        }
	}
}
// -----------------------------------------------------------------------------
void VCLXAccessibleToolBox::implReleaseToolboxItem( ToolBoxItemsMap::iterator& _rMapPos,
		bool _bNotifyRemoval, bool _bDispose )
{
	Reference< XAccessible > xItemAcc( _rMapPos->second );
	if ( !xItemAcc.is() )
		return;

	if ( _bNotifyRemoval )
	{
		NotifyAccessibleEvent( AccessibleEventId::CHILD, makeAny( xItemAcc ), Any() );
	}

    OToolBoxWindowItem* pWindowItem = NULL;
    if ( !OToolBoxWindowItem::isWindowItem( xItemAcc, &pWindowItem ) )
	{
		static_cast< VCLXAccessibleToolBoxItem* >( xItemAcc.get() )->ReleaseToolBox();
		if ( _bDispose )
			::comphelper::disposeComponent( xItemAcc );
	}
	else
	{
		if ( _bDispose )
		{
			if ( pWindowItem )
			{
				Reference< XAccessibleContext > xContext( pWindowItem->getContextNoCreate() );
				::comphelper::disposeComponent( xContext );
			}
		}
	}
}

// -----------------------------------------------------------------------------
void VCLXAccessibleToolBox::UpdateItem_Impl( sal_Int32 _nPos, sal_Bool _bItemAdded )
{
    if ( _nPos < sal_Int32( m_aAccessibleChildren.size() ) )
    {
        UpdateAllItems_Impl();
        return;
    }

    ToolBox* pToolBox = static_cast< ToolBox* >( GetWindow() );
    if ( pToolBox )
	{
		if ( !_bItemAdded )
		{	// the item was removed
			// -> destroy the old item
			ToolBoxItemsMap::iterator aItemPos = m_aAccessibleChildren.find( _nPos );
			if ( m_aAccessibleChildren.end() != aItemPos )
			{
				implReleaseToolboxItem( aItemPos, true, true );
				m_aAccessibleChildren.erase( aItemPos );
			}
		}

		// adjust the "index-in-parent"s
		ToolBoxItemsMap::iterator aIndexAdjust = m_aAccessibleChildren.upper_bound( _nPos );
		while ( m_aAccessibleChildren.end() != aIndexAdjust )
		{
			Reference< XAccessible > xItemAcc( aIndexAdjust->second );

            OToolBoxWindowItem* pWindowItem = NULL;
            if ( !OToolBoxWindowItem::isWindowItem( xItemAcc, &pWindowItem ) )
			{
				VCLXAccessibleToolBoxItem* pItem = static_cast< VCLXAccessibleToolBoxItem* >( xItemAcc.get() );
				if ( pItem )
				{
					sal_Int32 nIndex = pItem->getIndexInParent( );
					nIndex += _bItemAdded ? +1 : -1;
					pItem->setIndexInParent( nIndex );
				}
			}
			else
			{
				if ( pWindowItem )
				{
					sal_Int32 nIndex = pWindowItem->getIndexInParent( );
					nIndex += _bItemAdded ? +1 : -1;
					pWindowItem->setIndexInParent( nIndex );
				}
			}

			++aIndexAdjust;
		}

        if ( _bItemAdded )
		{
			// TODO: we should make this dependent on the existence of event listeners
			// with the current implementation, we always create accessible object
			Any aNewChild = makeAny( getAccessibleChild( (sal_Int32)_nPos ) );
			NotifyAccessibleEvent( AccessibleEventId::CHILD, Any(), aNewChild );
		}
	}
}
// -----------------------------------------------------------------------------
void VCLXAccessibleToolBox::UpdateAllItems_Impl()
{
    ToolBox* pToolBox = static_cast< ToolBox* >( GetWindow() );
    if ( pToolBox )
	{
		// deregister the old items
    	for ( ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.begin();
		  	  aIter != m_aAccessibleChildren.end(); ++aIter )
		{
			implReleaseToolboxItem( aIter, true, true );
		}
		m_aAccessibleChildren.clear();

		// register the new items
	    sal_uInt16 i, nCount = pToolBox->GetItemCount();
		for ( i = 0; i < nCount; ++i )
		{
			Any aNewValue;
			aNewValue <<= getAccessibleChild( (sal_Int32)i );;
			NotifyAccessibleEvent( AccessibleEventId::CHILD, Any(), aNewValue );
		}
	}
}

// -----------------------------------------------------------------------------

void VCLXAccessibleToolBox::UpdateCustomPopupItemp_Impl( Window* pWindow, bool bOpen )
{
    ToolBox* pToolBox = static_cast< ToolBox* >( GetWindow() );
	if( pWindow && pToolBox )
	{
		Reference< XAccessible > xChild( pWindow->GetAccessible() );
        if( xChild.is() )
		{
			Reference< XAccessible > xChildItem( getAccessibleChild( static_cast< sal_Int32 >( pToolBox->GetItemPos( pToolBox->GetDownItemId() ) ) ) );
            VCLXAccessibleToolBoxItem* pItem = static_cast< VCLXAccessibleToolBoxItem* >( xChildItem.get() );

            pItem->SetChild( xChild );
            pItem->NotifyChildEvent( xChild, bOpen );
		}
	}
}

// -----------------------------------------------------------------------------
void VCLXAccessibleToolBox::UpdateItemName_Impl( sal_Int32 _nPos )
{
	VCLXAccessibleToolBoxItem* pItem = GetItem_Impl( _nPos, false );
	if ( pItem )
		pItem->NameChanged();
}
// -----------------------------------------------------------------------------
void VCLXAccessibleToolBox::UpdateItemEnabled_Impl( sal_Int32 _nPos )
{
	VCLXAccessibleToolBoxItem* pItem = GetItem_Impl( _nPos, false );
	if ( pItem )
		pItem->ToggleEnableState();
}
// -----------------------------------------------------------------------------
void VCLXAccessibleToolBox::HandleSubToolBarEvent( const VclWindowEvent& rVclWindowEvent, bool _bShow )
{
    Window* pChildWindow = (Window *) rVclWindowEvent.GetData();
    ToolBox* pToolBox = static_cast< ToolBox* >( GetWindow() );
    if ( pChildWindow
        && pToolBox
        && pToolBox == pChildWindow->GetParent()
        && pChildWindow->GetType() == WINDOW_TOOLBOX )
    {
        sal_Int32 nIndex = pToolBox->GetItemPos( pToolBox->GetCurItemId() );
        Reference< XAccessible > xItem = getAccessibleChild( nIndex );
        if ( xItem.is() )
        {
            Reference< XAccessible > xChild = pChildWindow->GetAccessible();
            VCLXAccessibleToolBoxItem* pItem =
                static_cast< VCLXAccessibleToolBoxItem* >( xItem.get() );
            pItem->SetChild( xChild );
            pItem->NotifyChildEvent( xChild, _bShow );
        }
    }
}
// -----------------------------------------------------------------------------
void VCLXAccessibleToolBox::ReleaseSubToolBox( ToolBox* _pSubToolBox )
{
    ToolBox* pToolBox = static_cast< ToolBox* >( GetWindow() );
    if ( pToolBox )
    {
        sal_Int32 nIndex = pToolBox->GetItemPos( pToolBox->GetCurItemId() );
        Reference< XAccessible > xItem = getAccessibleChild( nIndex );
        if ( xItem.is() )
        {
            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 );

    ToolBox* pToolBox = static_cast< ToolBox* >( GetWindow() );
    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 (VCLEVENT_OBJECT_DYING)
	Reference< XAccessibleContext > xTemp = this;

	ToolBox* pToolBox = static_cast< ToolBox* >( GetWindow() ); 
	switch ( rVclWindowEvent.GetId() )
	{
		case VCLEVENT_TOOLBOX_CLICK:
		case VCLEVENT_TOOLBOX_SELECT: 
        {
			if ( rVclWindowEvent.GetData() )
            {
                UpdateChecked_Impl( (sal_Int32)(sal_IntPtr)rVclWindowEvent.GetData() );
                UpdateIndeterminate_Impl( (sal_Int32)(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 VCLEVENT_TOOLBOX_DOUBLECLICK:
		case VCLEVENT_TOOLBOX_ACTIVATE:
		case VCLEVENT_TOOLBOX_DEACTIVATE:
    	//case VCLEVENT_TOOLBOX_SELECT:
			break;
		// IA2 CWS. MT: Still using VCLEVENT_TOOLBOX_CLICK, see comment in vcl/source/window/toolbox2.cxx
		/*
		case VCLEVENT_TOOLBOX_ITEMUPDATED:
		{
	    	if ( rVclWindowEvent.GetData() )
	        {
				UpdateChecked_Impl( TOOLBOX_ITEM_NOTFOUND );
	            UpdateIndeterminate_Impl( (sal_Int32)rVclWindowEvent.GetData() );
	        }	
		break;
		}
		*/
		case VCLEVENT_TOOLBOX_HIGHLIGHT:
			UpdateFocus_Impl();
			break;

		case VCLEVENT_TOOLBOX_HIGHLIGHTOFF:
            ReleaseFocus_Impl( (sal_Int32)(sal_IntPtr)rVclWindowEvent.GetData() );
			break;

		case VCLEVENT_TOOLBOX_ITEMADDED :
//            UpdateItem_Impl( (sal_Int32)(sal_IntPtr)rVclWindowEvent.GetData(), VCLEVENT_TOOLBOX_ITEMADDED == rVclWindowEvent.GetId() );
            UpdateItem_Impl( (sal_Int32)(sal_IntPtr)rVclWindowEvent.GetData(), sal_True );
			break;

        case VCLEVENT_TOOLBOX_ITEMREMOVED :
		case VCLEVENT_TOOLBOX_ALLITEMSCHANGED :
		{
			UpdateAllItems_Impl();
			break;
		}

        case VCLEVENT_TOOLBOX_ITEMWINDOWCHANGED:
		{
            sal_Int32 nPos = (sal_Int32)(sal_IntPtr)rVclWindowEvent.GetData();
			ToolBoxItemsMap::iterator aAccessiblePos( m_aAccessibleChildren.find( nPos ) );
			if ( m_aAccessibleChildren.end() != aAccessiblePos )
            {
				implReleaseToolboxItem( aAccessiblePos, false, true );
                m_aAccessibleChildren.erase (aAccessiblePos);
            }

			Any aNewValue;
			aNewValue <<= getAccessibleChild(nPos);
			NotifyAccessibleEvent( AccessibleEventId::CHILD, Any(), aNewValue );
			break;
		}
		case VCLEVENT_TOOLBOX_ITEMTEXTCHANGED :
            UpdateItemName_Impl( (sal_Int32)(sal_IntPtr)rVclWindowEvent.GetData() );
			break;

		case VCLEVENT_TOOLBOX_ITEMENABLED :
		case VCLEVENT_TOOLBOX_ITEMDISABLED :
		{
            UpdateItemEnabled_Impl( (sal_Int32)(sal_IntPtr)rVclWindowEvent.GetData() );
			break;
		}

		case VCLEVENT_DROPDOWN_OPEN:
		case VCLEVENT_DROPDOWN_CLOSE:
		{
			UpdateCustomPopupItemp_Impl( static_cast< Window* >( rVclWindowEvent.GetData() ), rVclWindowEvent.GetId() == VCLEVENT_DROPDOWN_OPEN );
			break;
		}

		case VCLEVENT_OBJECT_DYING :
		{
            // if this toolbox is a subtoolbox, we have to relese it from its parent
            ToolBox* pToolBox = static_cast< ToolBox* >( GetWindow() );
            if ( pToolBox && pToolBox->GetParent() &&
                 pToolBox->GetParent()->GetType() == WINDOW_TOOLBOX )
            {
                VCLXAccessibleToolBox* pParent = static_cast< VCLXAccessibleToolBox* >(
                    pToolBox->GetParent()->GetAccessible()->getAccessibleContext().get() );
                if ( pParent )
                    pParent->ReleaseSubToolBox( pToolBox );
            }

            // dispose all items
    		for ( ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.begin();
				  aIter != m_aAccessibleChildren.end(); ++aIter )
			{
				implReleaseToolboxItem( aIter, false, true );
			}
			m_aAccessibleChildren.clear();

			//!!! no break to call base class
		}

		default:
			VCLXAccessibleComponent::ProcessWindowEvent( rVclWindowEvent );
	}
}
// -----------------------------------------------------------------------------
void VCLXAccessibleToolBox::ProcessWindowChildEvent( const VclWindowEvent& rVclWindowEvent )
{
	switch ( rVclWindowEvent.GetId() )
	{
        case VCLEVENT_WINDOW_SHOW:  // send create on show for direct accessible children
        {
            Reference< XAccessible > xReturn = GetItemWindowAccessible(rVclWindowEvent);
            if ( xReturn.is() )
                NotifyAccessibleEvent( AccessibleEventId::CHILD, Any(), makeAny(xReturn) );
            else
                HandleSubToolBarEvent( rVclWindowEvent, true );
        }
        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, true );
	}
	m_aAccessibleChildren.clear();
}
// -----------------------------------------------------------------------------
// XServiceInfo
// -----------------------------------------------------------------------------
::rtl::OUString VCLXAccessibleToolBox::getImplementationName() throw (RuntimeException)
{
	return ::rtl::OUString::createFromAscii( "com.sun.star.comp.toolkit.AccessibleToolBox" );
}
// -----------------------------------------------------------------------------
Sequence< ::rtl::OUString > VCLXAccessibleToolBox::getSupportedServiceNames() throw (RuntimeException)
{
	Sequence< ::rtl::OUString > aNames = VCLXAccessibleComponent::getSupportedServiceNames();
	sal_Int32 nLength = aNames.getLength();
	aNames.realloc( nLength + 1 );
	aNames[nLength] = ::rtl::OUString::createFromAscii( "com.sun.star.accessibility.AccessibleToolBox" );
	return aNames;
}
// -----------------------------------------------------------------------------
// XAccessibleContext
// -----------------------------------------------------------------------------
sal_Int32 SAL_CALL VCLXAccessibleToolBox::getAccessibleChildCount(  ) throw (RuntimeException)
{
	comphelper::OExternalLockGuard aGuard( this );

	sal_Int32 nCount = 0;
    ToolBox* pToolBox = static_cast< ToolBox* >( GetWindow() );
    if ( pToolBox )
    	nCount = pToolBox->GetItemCount();

    return nCount;
}
// -----------------------------------------------------------------------------
Reference< XAccessible > SAL_CALL VCLXAccessibleToolBox::getAccessibleChild( sal_Int32 i ) throw (IndexOutOfBoundsException, RuntimeException)
{
	if ( i < 0 || i >= getAccessibleChildCount() )
		throw IndexOutOfBoundsException();

	comphelper::OExternalLockGuard aGuard( this );

    ToolBox* pToolBox = static_cast< ToolBox* >( GetWindow() );
    if ( pToolBox )
	{
		Reference< XAccessible > xChild;
		// search for the child
		ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.find(i);
		if ( m_aAccessibleChildren.end() == aIter )
        {
			sal_uInt16 nItemId = pToolBox->GetItemId( (sal_uInt16)i );
            sal_uInt16 nHighlightItemId = pToolBox->GetHighlightItemId();
			Window* pItemWindow = pToolBox->GetItemWindow( nItemId );
			// not found -> create a new child
    		VCLXAccessibleToolBoxItem* pChild = new VCLXAccessibleToolBoxItem( pToolBox, i );
			Reference< XAccessible> xParent = pChild;
			if ( pItemWindow )
			{
				xChild = new OToolBoxWindowItem(0,::comphelper::getProcessServiceFactory(),pItemWindow->GetAccessible(),xParent);
				pItemWindow->SetAccessible(xChild);
                pChild->SetChild( xChild );
			}
			xChild = pChild;
			if ( nHighlightItemId > 0 && nItemId == nHighlightItemId )
				pChild->SetFocus( sal_True );
			if ( pToolBox->IsItemChecked( nItemId ) )
				pChild->SetChecked( sal_True );
            if ( pToolBox->GetItemState( nItemId ) == STATE_DONTKNOW )
                pChild->SetIndeterminate( true );
			m_aAccessibleChildren.insert( ToolBoxItemsMap::value_type( i, xChild ) );
		}
		else
		{
			// found it
			xChild = aIter->second;
		}
		return xChild;
	}

    return NULL;
}
// -----------------------------------------------------------------------------
Reference< XAccessible > SAL_CALL VCLXAccessibleToolBox::getAccessibleAtPoint( const awt::Point& _rPoint ) throw (RuntimeException)
{
	comphelper::OExternalLockGuard aGuard( this );

	Reference< XAccessible > xAccessible;
    ToolBox* pToolBox = static_cast< ToolBox* >( GetWindow() );
    if ( pToolBox )
	{
		sal_uInt16 nItemPos = pToolBox->GetItemPos( VCLPoint( _rPoint ) );
		if ( nItemPos != TOOLBOX_ITEM_NOTFOUND )
			xAccessible = getAccessibleChild( nItemPos );
	}

	return xAccessible;
}
// -----------------------------------------------------------------------------
Reference< XAccessible > VCLXAccessibleToolBox::GetItemWindowAccessible( const VclWindowEvent& rVclWindowEvent )
{
    Reference< XAccessible > xReturn;
	Window* pChildWindow = (Window *) rVclWindowEvent.GetData();
	ToolBox* pToolBox = static_cast< ToolBox* >( GetWindow() );
    if ( pChildWindow && pToolBox )
	{
		sal_uInt16 nCount = pToolBox->GetItemCount();
		for (sal_uInt16 i = 0 ; i < nCount && !xReturn.is() ; ++i)
		{
			sal_uInt16 nItemId = pToolBox->GetItemId( i );
			Window* pItemWindow = pToolBox->GetItemWindow( nItemId );
			if ( pItemWindow == pChildWindow )
				xReturn = getAccessibleChild(i);
		}
	}
	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 ) throw (IndexOutOfBoundsException, RuntimeException)
{
    OExternalLockGuard aGuard( this );
    if ( nChildIndex < 0 || nChildIndex >= getAccessibleChildCount() )
        throw IndexOutOfBoundsException();
    ToolBox * pToolBox = static_cast < ToolBox * > ( GetWindow() );
    sal_uInt16 nPos = static_cast < sal_uInt16 > (nChildIndex);
    pToolBox->ChangeHighlight( nPos );
}
// -----------------------------------------------------------------------------
sal_Bool VCLXAccessibleToolBox::isAccessibleChildSelected( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
{
    OExternalLockGuard aGuard( this );
    if ( nChildIndex < 0 || nChildIndex >= getAccessibleChildCount() )
        throw IndexOutOfBoundsException();
    ToolBox * pToolBox = static_cast < ToolBox * > ( GetWindow() );
    sal_uInt16 nPos = static_cast < sal_uInt16 > (nChildIndex);
    if ( pToolBox != NULL && pToolBox->GetHighlightItemId() == pToolBox->GetItemId( nPos ) )
        return sal_True;
    else
        return sal_False;
}
// -----------------------------------------------------------------------------
void VCLXAccessibleToolBox::clearAccessibleSelection(  ) throw (RuntimeException)
{
    OExternalLockGuard aGuard( this );
    ToolBox * pToolBox = static_cast < ToolBox * > ( GetWindow() );
    pToolBox -> LoseFocus();
}
// -----------------------------------------------------------------------------
void VCLXAccessibleToolBox::selectAllAccessibleChildren(  ) throw (RuntimeException)
{
    OExternalLockGuard aGuard( this );
    // intentionally empty. makes no sense for a toolbox
}
// -----------------------------------------------------------------------------
sal_Int32 VCLXAccessibleToolBox::getSelectedAccessibleChildCount(  ) throw (RuntimeException)
{
    OExternalLockGuard aGuard( this );
    sal_Int32 nRet = 0;
    for ( sal_Int32 i = 0, nCount = getAccessibleChildCount(); i < nCount; i++ )
    {
        if ( isAccessibleChildSelected( i ) )
        {
            nRet = 1;
            break; // a toolbox can only have (n)one selected child
        }
    }
    return nRet;
}
// -----------------------------------------------------------------------------
Reference< XAccessible > VCLXAccessibleToolBox::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
{
    OExternalLockGuard aGuard( this );
    if ( nSelectedChildIndex < 0 || nSelectedChildIndex >= getSelectedAccessibleChildCount() )
        throw IndexOutOfBoundsException();
    Reference< XAccessible > xChild;
    for ( sal_Int32 i = 0, j = 0, nCount = getAccessibleChildCount(); i < nCount; i++ )
    {
        if ( isAccessibleChildSelected( i ) && ( j++ == nSelectedChildIndex ) )
        {
            xChild = getAccessibleChild( i );
            break;
        }
    }
    return xChild;
}
// -----------------------------------------------------------------------------
void VCLXAccessibleToolBox::deselectAccessibleChild( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
{
    OExternalLockGuard aGuard( this );
    if ( nChildIndex < 0 || nChildIndex >= getAccessibleChildCount() )
        throw IndexOutOfBoundsException();
    clearAccessibleSelection(); // a toolbox can only have (n)one selected child
}
// -----------------------------------------------------------------------------