xref: /AOO41X/main/toolkit/source/controls/accessiblecontrolcontext.cxx (revision b0724fc6948542b2496e16ea247f985ee5987cfe)

/**************************************************************
 *
 * 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_toolkit.hxx"
#include <toolkit/controls/accessiblecontrolcontext.hxx>
#include <unotools/accessiblestatesethelper.hxx>
#include <com/sun/star/awt/XControl.hpp>
#include <com/sun/star/awt/XWindow.hpp>
#include <vcl/svapp.hxx>
#include <com/sun/star/accessibility/AccessibleStateType.hpp>
#include <com/sun/star/accessibility/AccessibleRole.hpp>
#include <toolkit/helper/vclunohelper.hxx>
#include <vcl/window.hxx>

//........................................................................
namespace toolkit
{
//........................................................................

	using ::comphelper::OContextEntryGuard;
	using namespace ::com::sun::star;
	using namespace ::com::sun::star::uno;
	using namespace ::com::sun::star::lang;
	using namespace ::com::sun::star::beans;
	using namespace ::com::sun::star::accessibility;

	//====================================================================
	//= OAccessibleControlContext
	//====================================================================
	//--------------------------------------------------------------------
	OAccessibleControlContext::OAccessibleControlContext()
		:OAccessibleControlContext_Base( )
	{
		// nothing to do here, we have a late ctor
	}

	//--------------------------------------------------------------------
	OAccessibleControlContext::~OAccessibleControlContext()
	{
		ensureDisposed();
	}

	//--------------------------------------------------------------------
	IMPLEMENT_FORWARD_XINTERFACE3( OAccessibleControlContext, OAccessibleControlContext_Base, OAccessibleImplementationAccess, OAccessibleControlContext_IBase )
	IMPLEMENT_FORWARD_XTYPEPROVIDER3( OAccessibleControlContext, OAccessibleControlContext_Base, OAccessibleImplementationAccess, OAccessibleControlContext_IBase )
		// (order matters: the first is the class name, the second is the class doing the ref counting)

	//--------------------------------------------------------------------
	void OAccessibleControlContext::Init( const Reference< XAccessible >& _rxCreator ) SAL_THROW( ( Exception ) )
	{
		OContextEntryGuard aGuard( this );

		// retrieve the model of the control
		OSL_ENSURE( !m_xControlModel.is(), "OAccessibleControlContext::Init: already know a control model....!???" );

		Reference< awt::XControl > xControl( _rxCreator, UNO_QUERY );
		if ( xControl.is() )
			m_xControlModel = m_xControlModel.query( xControl->getModel() );
		OSL_ENSURE( m_xControlModel.is(), "OAccessibleControlContext::Init: invalid creator (no control, or control without model!" );
		if ( !m_xControlModel.is() )
			throw DisposedException();	// caught by the caller (the create method)

		// start listening at the model
		startModelListening();

		// announce the XAccessible to our base class
		OAccessibleControlContext_Base::lateInit( _rxCreator );
	}

	//--------------------------------------------------------------------
	OAccessibleControlContext* OAccessibleControlContext::create( const Reference< XAccessible >& _rxCreator ) SAL_THROW( ( ) )
	{
		OAccessibleControlContext* pNew = NULL;
		try
		{
			pNew = new OAccessibleControlContext;
			pNew->Init( _rxCreator );
		}
		catch( const Exception& )
		{
			OSL_ENSURE( sal_False, "OAccessibleControlContext::create: caught an exception from the late ctor!" );
		}
		return pNew;
	}

	//--------------------------------------------------------------------
	void OAccessibleControlContext::startModelListening( ) SAL_THROW( ( Exception ) )
	{
		Reference< XComponent > xModelComp( m_xControlModel, UNO_QUERY );
		OSL_ENSURE( xModelComp.is(), "OAccessibleControlContext::startModelListening: invalid model!" );
		if ( xModelComp.is() )
			xModelComp->addEventListener( this );
	}

	//--------------------------------------------------------------------
	void OAccessibleControlContext::stopModelListening( ) SAL_THROW( ( Exception ) )
	{
		Reference< XComponent > xModelComp( m_xControlModel, UNO_QUERY );
		OSL_ENSURE( xModelComp.is(), "OAccessibleControlContext::stopModelListening: invalid model!" );
		if ( xModelComp.is() )
			xModelComp->removeEventListener( this );
	}

	//--------------------------------------------------------------------
	sal_Int32 SAL_CALL OAccessibleControlContext::getAccessibleChildCount(  ) throw (RuntimeException)
	{
		// we do not have children
		return 0;
	}

	//--------------------------------------------------------------------
	Reference< XAccessible > SAL_CALL OAccessibleControlContext::getAccessibleChild( sal_Int32 ) throw (IndexOutOfBoundsException, RuntimeException)
	{
		// we do not have children
		throw IndexOutOfBoundsException();
	}

	//--------------------------------------------------------------------
	Reference< XAccessible > SAL_CALL OAccessibleControlContext::getAccessibleParent(  ) throw (RuntimeException)
	{
		OContextEntryGuard aGuard( this );
		OSL_ENSURE( implGetForeignControlledParent().is(), "OAccessibleControlContext::getAccessibleParent: somebody forgot to set a parent!" );
			// this parent of us is foreign controlled - somebody has to set it using the OAccessibleImplementationAccess
			// class, before integrating our instance into an AccessibleDocumentModel
		return implGetForeignControlledParent();
	}

	//--------------------------------------------------------------------
	sal_Int16 SAL_CALL OAccessibleControlContext::getAccessibleRole(  ) throw (RuntimeException)
	{
		return AccessibleRole::SHAPE;
	}

	//--------------------------------------------------------------------
	::rtl::OUString SAL_CALL OAccessibleControlContext::getAccessibleDescription(  ) throw (RuntimeException)
	{
		OContextEntryGuard aGuard( this );
		return getModelStringProperty( "HelpText" );
	}

	//--------------------------------------------------------------------
	::rtl::OUString SAL_CALL OAccessibleControlContext::getAccessibleName(  ) throw (RuntimeException)
	{
		OContextEntryGuard aGuard( this );
		return getModelStringProperty( "Name" );
	}

	//--------------------------------------------------------------------
	Reference< XAccessibleRelationSet > SAL_CALL OAccessibleControlContext::getAccessibleRelationSet(  ) throw (RuntimeException)
	{
		return NULL;
	}

	//--------------------------------------------------------------------
	Reference< XAccessibleStateSet > SAL_CALL OAccessibleControlContext::getAccessibleStateSet(  ) throw (RuntimeException)
	{
		::osl::MutexGuard aGuard( GetMutex() );
			// no OContextEntryGuard here, as we do not want to throw an exception in case we're not alive anymore

		::utl::AccessibleStateSetHelper* pStateSet = NULL;
		if ( isAlive() )
		{
			// no own states, only the ones which are foreign controlled
			pStateSet = new ::utl::AccessibleStateSetHelper( implGetForeignControlledStates() );
		}
		else
		{	// only the DEFUNC state if we're already disposed
			pStateSet = new ::utl::AccessibleStateSetHelper;
			pStateSet->AddState( AccessibleStateType::DEFUNC );
		}
		return pStateSet;
	}

	//--------------------------------------------------------------------
	void SAL_CALL OAccessibleControlContext::disposing( const EventObject&
    #if OSL_DEBUG_LEVEL > 0
    _rSource
    #endif
    ) throw ( RuntimeException )
	{
		OSL_ENSURE( Reference< XPropertySet >( _rSource.Source, UNO_QUERY ).get() == m_xControlModel.get(),
			"OAccessibleControlContext::disposing: where did this come from?" );

		stopModelListening( );
		m_xControlModel.clear();
		m_xModelPropsInfo.clear();

		OAccessibleControlContext_Base::disposing();
	}

	//--------------------------------------------------------------------
	::rtl::OUString	OAccessibleControlContext::getModelStringProperty( const sal_Char* _pPropertyName )
	{
		::rtl::OUString sReturn;
		try
		{
			if ( !m_xModelPropsInfo.is() && m_xControlModel.is() )
				m_xModelPropsInfo = m_xControlModel->getPropertySetInfo();

			::rtl::OUString sPropertyName( ::rtl::OUString::createFromAscii( _pPropertyName ) );
			if ( m_xModelPropsInfo.is() && m_xModelPropsInfo->hasPropertyByName( sPropertyName ) )
				m_xControlModel->getPropertyValue( sPropertyName ) >>= sReturn;
		}
		catch( const Exception& )
		{
			OSL_ENSURE( sal_False, "OAccessibleControlContext::getModelStringProperty: caught an exception!" );
		}
		return sReturn;
	}

	//--------------------------------------------------------------------
	Window*	OAccessibleControlContext::implGetWindow( Reference< awt::XWindow >* _pxUNOWindow ) const
	{
		Reference< awt::XControl > xControl( getAccessibleCreator(), UNO_QUERY );
		Reference< awt::XWindow > xWindow;
		if ( xControl.is() )
			xWindow = xWindow.query( xControl->getPeer() );

		Window* pWindow = xWindow.is() ? VCLUnoHelper::GetWindow( xWindow ) : NULL;

		if ( _pxUNOWindow )
			*_pxUNOWindow = xWindow;
		return pWindow;
	}

	//--------------------------------------------------------------------
	awt::Rectangle SAL_CALL OAccessibleControlContext::implGetBounds(  ) throw (RuntimeException)
	{
		::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
			// want to do some VCL stuff here ...
		OContextEntryGuard aGuard( this );

		OSL_ENSURE( sal_False, "OAccessibleControlContext::implGetBounds: performance issue: forced to calc the size myself!" );
		// In design mode (and this is what this class is for), the surrounding shape (if any) should handle this call
		// The problem is that in design mode, our size may not be correct (in the drawing layer, controls are
		// positioned/sized for painting only), and that calculation of our position is expensive

		// what we know (or can obtain from somewhere):
		// * the PosSize of our peer, relative to it's parent window
		// * the parent window which the PosSize is relative to
		// * our foreign controlled accessible parent
		// from this info, we can determine the the position of our peer relative to the foreign parent

		// our control
		Reference< awt::XWindow > xWindow;
		Window* pVCLWindow = implGetWindow( &xWindow );

		awt::Rectangle aBounds( 0, 0, 0, 0 );
		if ( xWindow.is() )
		{
			// ugly, but .... though the XWindow has a getPosSize, it is impossible to determine the
			// parent which this position/size is relative to. This means we must tunnel UNO and ask the
			// implementation
			Window* pVCLParent = pVCLWindow ? pVCLWindow->GetParent() : NULL;

			// the relative location of the window
			::Point aWindowRelativePos( 0, 0);
			if ( pVCLWindow )
				aWindowRelativePos = pVCLWindow->GetPosPixel();

			// the screnn position of the "window parent" of the control
			::Point aVCLParentScreenPos( 0, 0 );
			if ( pVCLParent )
				aVCLParentScreenPos = pVCLParent->GetPosPixel();

			// the screen position of the "accessible parent" of the control
			Reference< XAccessible > xParentAcc( implGetForeignControlledParent() );
			Reference< XAccessibleComponent > xParentAccComponent;
			if ( xParentAcc.is() )
				xParentAccComponent = xParentAccComponent.query( xParentAcc->getAccessibleContext() );
			awt::Point aAccParentScreenPos( 0, 0 );
			if ( xParentAccComponent.is() )
				aAccParentScreenPos = xParentAccComponent->getLocationOnScreen();

			// now the size of the control
			aBounds = xWindow->getPosSize();

			// correct the pos
			aBounds.X = aWindowRelativePos.X() + aVCLParentScreenPos.X() - aAccParentScreenPos.X;
			aBounds.Y = aWindowRelativePos.Y() + aVCLParentScreenPos.Y() - aAccParentScreenPos.Y;
		}

		return aBounds;
	}

	//--------------------------------------------------------------------
	Reference< XAccessible > SAL_CALL OAccessibleControlContext::getAccessibleAtPoint( const awt::Point& /* _rPoint */ ) throw (RuntimeException)
	{
		// no children at all
		return NULL;
	}

	//--------------------------------------------------------------------
	void SAL_CALL OAccessibleControlContext::grabFocus(  ) throw (RuntimeException)
	{
		OSL_ENSURE( sal_False, "OAccessibleControlContext::grabFocus: !isFocusTraversable, but grabFocus!" );
	}

	//--------------------------------------------------------------------
	Any SAL_CALL OAccessibleControlContext::getAccessibleKeyBinding(  ) throw (RuntimeException)
	{
		// we do not have any key bindings to activate a UNO control in design mode
		return Any();
	}

	//--------------------------------------------------------------------
	sal_Int32 SAL_CALL OAccessibleControlContext::getForeground(  ) throw (::com::sun::star::uno::RuntimeException)
	{
		::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
			// want to do some VCL stuff here ...
		OContextEntryGuard aGuard( this );

		Window* pWindow = implGetWindow( );
		sal_Int32 nColor = 0;
		if ( pWindow )
		{
			if ( pWindow->IsControlForeground() )
				nColor = pWindow->GetControlForeground().GetColor();
			else
			{
				Font aFont;
				if ( pWindow->IsControlFont() )
					aFont = pWindow->GetControlFont();
				else
					aFont = pWindow->GetFont();
				nColor = aFont.GetColor().GetColor();
			}
		}
		return nColor;
	}

	//--------------------------------------------------------------------
	sal_Int32 SAL_CALL OAccessibleControlContext::getBackground(  ) throw (::com::sun::star::uno::RuntimeException)
	{
		::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
			// want to do some VCL stuff here ...
		OContextEntryGuard aGuard( this );

		Window* pWindow = implGetWindow( );
		sal_Int32 nColor = 0;
		if ( pWindow )
		{
			if ( pWindow->IsControlBackground() )
				nColor = pWindow->GetControlBackground().GetColor();
			else
				nColor = pWindow->GetBackground().GetColor().GetColor();
		}

		return nColor;
	}

//........................................................................
}	//namespace toolkit
//........................................................................