diff options
Diffstat (limited to 'accessibility/source/standard')
35 files changed, 11810 insertions, 0 deletions
diff --git a/accessibility/source/standard/accessiblemenubasecomponent.cxx b/accessibility/source/standard/accessiblemenubasecomponent.cxx new file mode 100644 index 000000000..f28bf8ad0 --- /dev/null +++ b/accessibility/source/standard/accessiblemenubasecomponent.cxx @@ -0,0 +1,716 @@ +/* -*- 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 <standard/accessiblemenubasecomponent.hxx> +#include <standard/vclxaccessiblemenu.hxx> +#include <standard/vclxaccessiblemenuitem.hxx> +#include <standard/vclxaccessiblemenuseparator.hxx> +#include <toolkit/helper/convert.hxx> + +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <cppuhelper/supportsservice.hxx> +#include <o3tl/safeint.hxx> +#include <unotools/accessiblestatesethelper.hxx> +#include <vcl/menu.hxx> +#include <vcl/vclevent.hxx> + +#include <array> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::accessibility; +using namespace ::comphelper; + + +// OAccessibleMenuBaseComponent + + +OAccessibleMenuBaseComponent::OAccessibleMenuBaseComponent( Menu* pMenu ) + :m_pMenu( pMenu ) + ,m_bEnabled( false ) + ,m_bFocused( false ) + ,m_bVisible( false ) + ,m_bSelected( false ) + ,m_bChecked( false ) +{ + if ( m_pMenu ) + { + m_aAccessibleChildren.assign( m_pMenu->GetItemCount(), Reference< XAccessible >() ); + m_pMenu->AddEventListener( LINK( this, OAccessibleMenuBaseComponent, MenuEventListener ) ); + } +} + + +OAccessibleMenuBaseComponent::~OAccessibleMenuBaseComponent() +{ + if ( m_pMenu ) + m_pMenu->RemoveEventListener( LINK( this, OAccessibleMenuBaseComponent, MenuEventListener ) ); +} + + +bool OAccessibleMenuBaseComponent::IsEnabled() +{ + return false; +} + + +bool OAccessibleMenuBaseComponent::IsFocused() +{ + return false; +} + + +bool OAccessibleMenuBaseComponent::IsVisible() +{ + return false; +} + + +bool OAccessibleMenuBaseComponent::IsSelected() +{ + return false; +} + + +bool OAccessibleMenuBaseComponent::IsChecked() +{ + return false; +} + + +void OAccessibleMenuBaseComponent::SetStates() +{ + m_bEnabled = IsEnabled(); + m_bFocused = IsFocused(); + m_bVisible = IsVisible(); + m_bSelected = IsSelected(); + m_bChecked = IsChecked(); +} + + +void OAccessibleMenuBaseComponent::SetEnabled( bool bEnabled ) +{ + if ( m_bEnabled == bEnabled ) + return; + + sal_Int16 nStateType=AccessibleStateType::ENABLED; + if (IsMenuHideDisabledEntries()) + { + nStateType = AccessibleStateType::VISIBLE; + } + std::array<Any, 2> aOldValue, aNewValue; + if ( m_bEnabled ) + { + aOldValue[0] <<= AccessibleStateType::SENSITIVE; + aOldValue[1] <<= nStateType; + } + else + { + aNewValue[0] <<= nStateType; + aNewValue[1] <<= AccessibleStateType::SENSITIVE; + } + m_bEnabled = bEnabled; + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue[0], aNewValue[0] ); + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue[1], aNewValue[1] ); +} + + +void OAccessibleMenuBaseComponent::SetFocused( bool bFocused ) +{ + if ( m_bFocused != bFocused ) + { + Any aOldValue, aNewValue; + if ( m_bFocused ) + aOldValue <<= AccessibleStateType::FOCUSED; + else + aNewValue <<= AccessibleStateType::FOCUSED; + m_bFocused = bFocused; + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue ); + } +} + + +void OAccessibleMenuBaseComponent::SetVisible( bool bVisible ) +{ + if ( m_bVisible != bVisible ) + { + Any aOldValue, aNewValue; + if ( m_bVisible ) + aOldValue <<= AccessibleStateType::VISIBLE; + else + aNewValue <<= AccessibleStateType::VISIBLE; + m_bVisible = bVisible; + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue ); + } +} + + +void OAccessibleMenuBaseComponent::SetSelected( bool bSelected ) +{ + if ( m_bSelected != bSelected ) + { + Any aOldValue, aNewValue; + if ( m_bSelected ) + aOldValue <<= AccessibleStateType::SELECTED; + else + aNewValue <<= AccessibleStateType::SELECTED; + m_bSelected = bSelected; + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue ); + } +} + + +void OAccessibleMenuBaseComponent::SetChecked( bool bChecked ) +{ + if ( m_bChecked != bChecked ) + { + Any aOldValue, aNewValue; + if ( m_bChecked ) + aOldValue <<= AccessibleStateType::CHECKED; + else + aNewValue <<= AccessibleStateType::CHECKED; + m_bChecked = bChecked; + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue ); + } +} + + +void OAccessibleMenuBaseComponent::UpdateEnabled( sal_Int32 i, bool bEnabled ) +{ + if ( i >= 0 && o3tl::make_unsigned(i) < m_aAccessibleChildren.size() ) + { + Reference< XAccessible > xChild( m_aAccessibleChildren[i] ); + if ( xChild.is() ) + { + OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() ); + if ( pComp ) + pComp->SetEnabled( bEnabled ); + } + } +} + + +void OAccessibleMenuBaseComponent::UpdateFocused( sal_Int32 i, bool bFocused ) +{ + if ( i >= 0 && o3tl::make_unsigned(i) < m_aAccessibleChildren.size() ) + { + Reference< XAccessible > xChild( m_aAccessibleChildren[i] ); + if ( xChild.is() ) + { + OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() ); + if ( pComp ) + pComp->SetFocused( bFocused ); + } + } +} + + +void OAccessibleMenuBaseComponent::UpdateVisible() +{ + SetVisible( IsVisible() ); + for (const Reference<XAccessible>& xChild : m_aAccessibleChildren) + { + if ( xChild.is() ) + { + OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() ); + if ( pComp ) + pComp->SetVisible( pComp->IsVisible() ); + } + } +} + + +void OAccessibleMenuBaseComponent::UpdateSelected( sal_Int32 i, bool bSelected ) +{ + NotifyAccessibleEvent( AccessibleEventId::SELECTION_CHANGED, Any(), Any() ); + + if ( i >= 0 && o3tl::make_unsigned(i) < m_aAccessibleChildren.size() ) + { + Reference< XAccessible > xChild( m_aAccessibleChildren[i] ); + if ( xChild.is() ) + { + OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() ); + if ( pComp ) + pComp->SetSelected( bSelected ); + } + } +} + + +void OAccessibleMenuBaseComponent::UpdateChecked( sal_Int32 i, bool bChecked ) +{ + if ( i >= 0 && o3tl::make_unsigned(i) < m_aAccessibleChildren.size() ) + { + Reference< XAccessible > xChild( m_aAccessibleChildren[i] ); + if ( xChild.is() ) + { + OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() ); + if ( pComp ) + pComp->SetChecked( bChecked ); + } + } +} + + +void OAccessibleMenuBaseComponent::UpdateAccessibleName( sal_Int32 i ) +{ + if ( i >= 0 && o3tl::make_unsigned(i) < m_aAccessibleChildren.size() ) + { + Reference< XAccessible > xChild( m_aAccessibleChildren[i] ); + if ( xChild.is() ) + { + OAccessibleMenuItemComponent* pComp = static_cast< OAccessibleMenuItemComponent* >( xChild.get() ); + if ( pComp ) + pComp->SetAccessibleName( pComp->GetAccessibleName() ); + } + } +} + + +void OAccessibleMenuBaseComponent::UpdateItemText( sal_Int32 i ) +{ + if ( i >= 0 && o3tl::make_unsigned(i) < m_aAccessibleChildren.size() ) + { + Reference< XAccessible > xChild( m_aAccessibleChildren[i] ); + if ( xChild.is() ) + { + OAccessibleMenuItemComponent* pComp = static_cast< OAccessibleMenuItemComponent* >( xChild.get() ); + if ( pComp ) + pComp->SetItemText( pComp->GetItemText() ); + } + } +} + + +sal_Int32 OAccessibleMenuBaseComponent::GetChildCount() const +{ + return m_aAccessibleChildren.size(); +} + + +Reference< XAccessible > OAccessibleMenuBaseComponent::GetChild( sal_Int32 i ) +{ + Reference< XAccessible > xChild = m_aAccessibleChildren[i]; + if ( !xChild.is() ) + { + if ( m_pMenu ) + { + // create a new child + rtl::Reference<OAccessibleMenuBaseComponent> pChild; + + if ( m_pMenu->GetItemType( static_cast<sal_uInt16>(i) ) == MenuItemType::SEPARATOR ) + { + pChild = new VCLXAccessibleMenuSeparator( m_pMenu, static_cast<sal_uInt16>(i) ); + } + else + { + PopupMenu* pPopupMenu = m_pMenu->GetPopupMenu( m_pMenu->GetItemId( static_cast<sal_uInt16>(i) ) ); + if ( pPopupMenu ) + { + pChild = new VCLXAccessibleMenu( m_pMenu, static_cast<sal_uInt16>(i), pPopupMenu ); + pPopupMenu->SetAccessible( pChild ); + } + else + { + pChild = new VCLXAccessibleMenuItem( m_pMenu, static_cast<sal_uInt16>(i) ); + } + } + + // set states + pChild->SetStates(); + + xChild = pChild; + + // insert into menu item list + m_aAccessibleChildren[i] = xChild; + } + } + + return xChild; +} + + +Reference< XAccessible > OAccessibleMenuBaseComponent::GetChildAt( const awt::Point& rPoint ) +{ + Reference< XAccessible > xChild; + for ( sal_uInt32 i = 0, nCount = getAccessibleChildCount(); i < nCount; ++i ) + { + Reference< XAccessible > xAcc = getAccessibleChild( i ); + if ( xAcc.is() ) + { + Reference< XAccessibleComponent > xComp( xAcc->getAccessibleContext(), UNO_QUERY ); + if ( xComp.is() ) + { + tools::Rectangle aRect = VCLRectangle( xComp->getBounds() ); + Point aPos = VCLPoint( rPoint ); + if ( aRect.Contains( aPos ) ) + { + xChild = xAcc; + break; + } + } + } + } + + return xChild; +} + + +void OAccessibleMenuBaseComponent::InsertChild( sal_Int32 i ) +{ + if ( i < 0 ) + return; + + if ( o3tl::make_unsigned(i) > m_aAccessibleChildren.size() ) + i = m_aAccessibleChildren.size(); + + // insert entry in child list + m_aAccessibleChildren.insert( m_aAccessibleChildren.begin() + i, Reference< XAccessible >() ); + + // update item position of accessible children + for ( sal_uInt32 j = i, nCount = m_aAccessibleChildren.size(); j < nCount; ++j ) + { + Reference< XAccessible > xAcc( m_aAccessibleChildren[j] ); + if ( xAcc.is() ) + { + OAccessibleMenuItemComponent* pComp = static_cast< OAccessibleMenuItemComponent* >( xAcc.get() ); + if ( pComp ) + pComp->SetItemPos( static_cast<sal_uInt16>(j) ); + } + } + + // send accessible child event + Reference< XAccessible > xChild( GetChild( i ) ); + if ( xChild.is() ) + { + Any aOldValue, aNewValue; + aNewValue <<= xChild; + NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue ); + } +} + + +void OAccessibleMenuBaseComponent::RemoveChild( sal_Int32 i ) +{ + if ( i < 0 || o3tl::make_unsigned(i) >= m_aAccessibleChildren.size() ) + return; + + // keep the accessible of the removed item + Reference< XAccessible > xChild( m_aAccessibleChildren[i] ); + + // remove entry in child list + m_aAccessibleChildren.erase( m_aAccessibleChildren.begin() + i ); + + // update item position of accessible children + for ( sal_uInt32 j = i, nCount = m_aAccessibleChildren.size(); j < nCount; ++j ) + { + Reference< XAccessible > xAcc( m_aAccessibleChildren[j] ); + if ( xAcc.is() ) + { + OAccessibleMenuItemComponent* pComp = static_cast< OAccessibleMenuItemComponent* >( xAcc.get() ); + if ( pComp ) + pComp->SetItemPos( static_cast<sal_uInt16>(j) ); + } + } + + // send accessible child event + if ( xChild.is() ) + { + Any aOldValue, aNewValue; + aOldValue <<= xChild; + NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue ); + + Reference< XComponent > xComponent( xChild, UNO_QUERY ); + if ( xComponent.is() ) + xComponent->dispose(); + } +} + + +bool OAccessibleMenuBaseComponent::IsHighlighted() +{ + return false; +} + + +bool OAccessibleMenuBaseComponent::IsChildHighlighted() +{ + bool bChildHighlighted = false; + + for (const Reference<XAccessible>& xChild : m_aAccessibleChildren) + { + if ( xChild.is() ) + { + OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() ); + if ( pComp && pComp->IsHighlighted() ) + { + bChildHighlighted = true; + break; + } + } + } + + return bChildHighlighted; +} + + +void OAccessibleMenuBaseComponent::SelectChild( sal_Int32 i ) +{ + // open the menu + if ( getAccessibleRole() == AccessibleRole::MENU && !IsPopupMenuOpen() ) + Click(); + + // highlight the child + if ( m_pMenu ) + m_pMenu->HighlightItem( static_cast<sal_uInt16>(i) ); +} + + +void OAccessibleMenuBaseComponent::DeSelectAll() +{ + if ( m_pMenu ) + m_pMenu->DeHighlight(); +} + + +bool OAccessibleMenuBaseComponent::IsChildSelected( sal_Int32 i ) +{ + bool bSelected = false; + + if ( m_pMenu && m_pMenu->IsHighlighted( static_cast<sal_uInt16>(i) ) ) + bSelected = true; + + return bSelected; +} + + +void OAccessibleMenuBaseComponent::Click() +{ +} + + +bool OAccessibleMenuBaseComponent::IsPopupMenuOpen() +{ + return false; +} + + +IMPL_LINK( OAccessibleMenuBaseComponent, MenuEventListener, VclMenuEvent&, rEvent, void ) +{ + OSL_ENSURE( rEvent.GetMenu(), "OAccessibleMenuBaseComponent - Menu?" ); + ProcessMenuEvent( rEvent ); +} + + +void OAccessibleMenuBaseComponent::ProcessMenuEvent( const VclMenuEvent& rVclMenuEvent ) +{ + sal_uInt16 nItemPos = rVclMenuEvent.GetItemPos(); + + switch ( rVclMenuEvent.GetId() ) + { + case VclEventId::MenuShow: + case VclEventId::MenuHide: + { + UpdateVisible(); + } + break; + case VclEventId::MenuHighlight: + { + SetFocused( false ); + UpdateFocused( nItemPos, true ); + UpdateSelected( nItemPos, true ); + } + break; + case VclEventId::MenuDehighlight: + { + UpdateFocused( nItemPos, false ); + UpdateSelected( nItemPos, false ); + } + break; + case VclEventId::MenuSubmenuActivate: + { + } + break; + case VclEventId::MenuSubmenuDeactivate: + { + UpdateFocused( nItemPos, true ); + } + break; + case VclEventId::MenuEnable: + { + UpdateEnabled( nItemPos, true ); + } + break; + case VclEventId::MenuDisable: + { + UpdateEnabled( nItemPos, false ); + } + break; + case VclEventId::MenuSubmenuChanged: + { + RemoveChild( nItemPos ); + InsertChild( nItemPos ); + } + break; + case VclEventId::MenuInsertItem: + { + InsertChild( nItemPos ); + } + break; + case VclEventId::MenuRemoveItem: + { + RemoveChild( nItemPos ); + } + break; + case VclEventId::MenuAccessibleNameChanged: + { + UpdateAccessibleName( nItemPos ); + } + break; + case VclEventId::MenuItemTextChanged: + { + UpdateAccessibleName( nItemPos ); + UpdateItemText( nItemPos ); + } + break; + case VclEventId::MenuItemChecked: + { + UpdateChecked( nItemPos, true ); + } + break; + case VclEventId::MenuItemUnchecked: + { + UpdateChecked( nItemPos, false ); + } + break; + case VclEventId::ObjectDying: + { + if ( m_pMenu ) + { + m_pMenu->RemoveEventListener( LINK( this, OAccessibleMenuBaseComponent, MenuEventListener ) ); + + m_pMenu = nullptr; + + // dispose all menu items + for (const Reference<XAccessible>& i : m_aAccessibleChildren) + { + Reference< XComponent > xComponent( i, UNO_QUERY ); + if ( xComponent.is() ) + xComponent->dispose(); + } + m_aAccessibleChildren.clear(); + } + } + break; + default: + { + } + break; + } +} + + +// XInterface + + +IMPLEMENT_FORWARD_XINTERFACE2( OAccessibleMenuBaseComponent, OAccessibleExtendedComponentHelper, OAccessibleMenuBaseComponent_BASE ) + + +// XTypeProvider + + +IMPLEMENT_FORWARD_XTYPEPROVIDER2( OAccessibleMenuBaseComponent, OAccessibleExtendedComponentHelper, OAccessibleMenuBaseComponent_BASE ) + + +// XComponent + + +void OAccessibleMenuBaseComponent::disposing() +{ + OAccessibleExtendedComponentHelper::disposing(); + + if ( !m_pMenu ) + return; + + m_pMenu->RemoveEventListener( LINK( this, OAccessibleMenuBaseComponent, MenuEventListener ) ); + + m_pMenu = nullptr; + + // dispose all menu items + for (const Reference<XAccessible>& i : m_aAccessibleChildren) + { + Reference< XComponent > xComponent( i, UNO_QUERY ); + if ( xComponent.is() ) + xComponent->dispose(); + } + m_aAccessibleChildren.clear(); +} + + +// XServiceInfo + + +sal_Bool OAccessibleMenuBaseComponent::supportsService( const OUString& rServiceName ) +{ + return cppu::supportsService(this, rServiceName); +} + + +// XAccessible + + +Reference< XAccessibleContext > OAccessibleMenuBaseComponent::getAccessibleContext( ) +{ + OExternalLockGuard aGuard( this ); + + return this; +} + + +// XAccessibleContext + + +Reference< XAccessibleStateSet > OAccessibleMenuBaseComponent::getAccessibleStateSet( ) +{ + OExternalLockGuard aGuard( this ); + + rtl::Reference<utl::AccessibleStateSetHelper> pStateSetHelper = new utl::AccessibleStateSetHelper; + + if ( !rBHelper.bDisposed && !rBHelper.bInDispose ) + { + FillAccessibleStateSet( *pStateSetHelper ); + } + else + { + pStateSetHelper->AddState( AccessibleStateType::DEFUNC ); + } + + return pStateSetHelper; +} + + +bool OAccessibleMenuBaseComponent::IsMenuHideDisabledEntries() +{ + return false; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/accessiblemenucomponent.cxx b/accessibility/source/standard/accessiblemenucomponent.cxx new file mode 100644 index 000000000..be9b1e6f4 --- /dev/null +++ b/accessibility/source/standard/accessiblemenucomponent.cxx @@ -0,0 +1,423 @@ +/* -*- 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 <standard/accessiblemenucomponent.hxx> + +#include <toolkit/awt/vclxfont.hxx> +#include <toolkit/helper/convert.hxx> + +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/awt/XDevice.hpp> +#include <com/sun/star/awt/XWindowPeer.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <unotools/accessiblestatesethelper.hxx> +#include <unotools/accessiblerelationsethelper.hxx> +#include <vcl/svapp.hxx> +#include <vcl/window.hxx> +#include <vcl/menu.hxx> +#include <vcl/settings.hxx> +#include <i18nlangtag/languagetag.hxx> + +using namespace ::com::sun::star::accessibility; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star; +using namespace ::comphelper; + + + + +bool OAccessibleMenuComponent::IsEnabled() +{ + return true; +} + + +bool OAccessibleMenuComponent::IsVisible() +{ + bool bVisible = false; + + if ( m_pMenu ) + bVisible = m_pMenu->IsMenuVisible(); + + return bVisible; +} + + +void OAccessibleMenuComponent::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet ) +{ + if ( IsEnabled() ) + { + rStateSet.AddState( AccessibleStateType::ENABLED ); + rStateSet.AddState( AccessibleStateType::SENSITIVE ); + } + + rStateSet.AddState( AccessibleStateType::FOCUSABLE ); + + if ( IsFocused() ) + rStateSet.AddState( AccessibleStateType::FOCUSED ); + + if ( IsVisible() ) + { + rStateSet.AddState( AccessibleStateType::VISIBLE ); + rStateSet.AddState( AccessibleStateType::SHOWING ); + } + + rStateSet.AddState( AccessibleStateType::OPAQUE ); +} + + +// OCommonAccessibleComponent + + +awt::Rectangle OAccessibleMenuComponent::implGetBounds() +{ + awt::Rectangle aBounds( 0, 0, 0, 0 ); + + if ( m_pMenu ) + { + vcl::Window* pWindow = m_pMenu->GetWindow(); + if ( pWindow ) + { + // get bounding rectangle of the window in screen coordinates + tools::Rectangle aRect = pWindow->GetWindowExtentsRelative( nullptr ); + aBounds = AWTRectangle( aRect ); + + // get position of the accessible parent in screen coordinates + Reference< XAccessible > xParent = getAccessibleParent(); + if ( xParent.is() ) + { + Reference< XAccessibleComponent > xParentComponent( xParent->getAccessibleContext(), UNO_QUERY ); + if ( xParentComponent.is() ) + { + awt::Point aParentScreenLoc = xParentComponent->getLocationOnScreen(); + + // calculate position of the window relative to the accessible parent + aBounds.X -= aParentScreenLoc.X; + aBounds.Y -= aParentScreenLoc.Y; + } + } + } + } + + return aBounds; +} + + +// XInterface + + +IMPLEMENT_FORWARD_XINTERFACE2( OAccessibleMenuComponent, OAccessibleMenuBaseComponent, OAccessibleMenuComponent_BASE ) + + +// XTypeProvider + + +IMPLEMENT_FORWARD_XTYPEPROVIDER2( OAccessibleMenuComponent, OAccessibleMenuBaseComponent, OAccessibleMenuComponent_BASE ) + + +// XAccessibleContext + + +sal_Int32 OAccessibleMenuComponent::getAccessibleChildCount() +{ + OExternalLockGuard aGuard( this ); + + return GetChildCount(); +} + + +Reference< XAccessible > OAccessibleMenuComponent::getAccessibleChild( sal_Int32 i ) +{ + OExternalLockGuard aGuard( this ); + + if ( i < 0 || i >= GetChildCount() ) + throw IndexOutOfBoundsException(); + + return GetChild( i ); +} + + +Reference< XAccessible > OAccessibleMenuComponent::getAccessibleParent( ) +{ + OExternalLockGuard aGuard( this ); + + Reference< XAccessible > xParent; + + if ( m_pMenu ) + { + vcl::Window* pWindow = m_pMenu->GetWindow(); + if ( pWindow ) + { + vcl::Window* pParent = pWindow->GetAccessibleParentWindow(); + if ( pParent ) + xParent = pParent->GetAccessible(); + } + } + + return xParent; +} + + +sal_Int16 OAccessibleMenuComponent::getAccessibleRole( ) +{ + OExternalLockGuard aGuard( this ); + + return AccessibleRole::UNKNOWN; +} + + +OUString OAccessibleMenuComponent::getAccessibleDescription( ) +{ + OExternalLockGuard aGuard( this ); + + OUString sDescription; + if ( m_pMenu ) + { + vcl::Window* pWindow = m_pMenu->GetWindow(); + if ( pWindow ) + sDescription = pWindow->GetAccessibleDescription(); + } + + return sDescription; +} + + +OUString OAccessibleMenuComponent::getAccessibleName( ) +{ + OExternalLockGuard aGuard( this ); + + return OUString(); +} + + +Reference< XAccessibleRelationSet > OAccessibleMenuComponent::getAccessibleRelationSet( ) +{ + OExternalLockGuard aGuard( this ); + + return new utl::AccessibleRelationSetHelper; +} + + +Locale OAccessibleMenuComponent::getLocale( ) +{ + OExternalLockGuard aGuard( this ); + + return Application::GetSettings().GetLanguageTag().getLocale(); +} + + +// XAccessibleComponent + + +Reference< XAccessible > OAccessibleMenuComponent::getAccessibleAtPoint( const awt::Point& rPoint ) +{ + OExternalLockGuard aGuard( this ); + + return GetChildAt( rPoint ); +} + + +awt::Point OAccessibleMenuComponent::getLocationOnScreen( ) +{ + OExternalLockGuard aGuard( this ); + + awt::Point aPos; + + if ( m_pMenu ) + { + vcl::Window* pWindow = m_pMenu->GetWindow(); + if ( pWindow ) + { + tools::Rectangle aRect = pWindow->GetWindowExtentsRelative( nullptr ); + aPos = AWTPoint( aRect.TopLeft() ); + } + } + + return aPos; +} + + +void OAccessibleMenuComponent::grabFocus( ) +{ + OExternalLockGuard aGuard( this ); + + if ( m_pMenu ) + { + vcl::Window* pWindow = m_pMenu->GetWindow(); + if ( pWindow ) + pWindow->GrabFocus(); + } +} + + +sal_Int32 OAccessibleMenuComponent::getForeground( ) +{ + OExternalLockGuard aGuard( this ); + + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + Color nColor = rStyleSettings.GetMenuTextColor(); + + return sal_Int32(nColor); +} + + +sal_Int32 OAccessibleMenuComponent::getBackground( ) +{ + OExternalLockGuard aGuard( this ); + + return 0; +} + + +// XAccessibleExtendedComponent + + +Reference< awt::XFont > OAccessibleMenuComponent::getFont( ) +{ + OExternalLockGuard aGuard( this ); + + Reference< awt::XFont > xFont; + + if ( m_pMenu ) + { + vcl::Window* pWindow = m_pMenu->GetWindow(); + if ( pWindow ) + { + Reference< awt::XDevice > xDev( pWindow->GetComponentInterface(), UNO_QUERY ); + if ( xDev.is() ) + { + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + rtl::Reference<VCLXFont> pVCLXFont = new VCLXFont; + pVCLXFont->Init( *xDev, rStyleSettings.GetMenuFont() ); + xFont = pVCLXFont; + } + } + } + + return xFont; +} + + +OUString OAccessibleMenuComponent::getTitledBorderText( ) +{ + OExternalLockGuard aGuard( this ); + + return OUString(); +} + + +OUString OAccessibleMenuComponent::getToolTipText( ) +{ + OExternalLockGuard aGuard( this ); + + return OUString(); +} + + +// XAccessibleSelection + + +void OAccessibleMenuComponent::selectAccessibleChild( sal_Int32 nChildIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nChildIndex < 0 || nChildIndex >= GetChildCount() ) + throw IndexOutOfBoundsException(); + + SelectChild( nChildIndex ); +} + + +sal_Bool OAccessibleMenuComponent::isAccessibleChildSelected( sal_Int32 nChildIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nChildIndex < 0 || nChildIndex >= GetChildCount() ) + throw IndexOutOfBoundsException(); + + return IsChildSelected( nChildIndex ); +} + + +void OAccessibleMenuComponent::clearAccessibleSelection( ) +{ + OExternalLockGuard aGuard( this ); + + DeSelectAll(); +} + + +void OAccessibleMenuComponent::selectAllAccessibleChildren( ) +{ + // This method makes no sense in a menu, and so does nothing. +} + + +sal_Int32 OAccessibleMenuComponent::getSelectedAccessibleChildCount( ) +{ + OExternalLockGuard aGuard( this ); + + sal_Int32 nRet = 0; + + for ( sal_Int32 i = 0, nCount = GetChildCount(); i < nCount; i++ ) + { + if ( IsChildSelected( i ) ) + ++nRet; + } + + return nRet; +} + + +Reference< XAccessible > OAccessibleMenuComponent::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nSelectedChildIndex < 0 || nSelectedChildIndex >= getSelectedAccessibleChildCount() ) + throw IndexOutOfBoundsException(); + + Reference< XAccessible > xChild; + + for ( sal_Int32 i = 0, j = 0, nCount = GetChildCount(); i < nCount; i++ ) + { + if ( IsChildSelected( i ) && ( j++ == nSelectedChildIndex ) ) + { + xChild = GetChild( i ); + break; + } + } + + return xChild; +} + + +void OAccessibleMenuComponent::deselectAccessibleChild( sal_Int32 nChildIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nChildIndex < 0 || nChildIndex >= GetChildCount() ) + throw IndexOutOfBoundsException(); + + DeSelectAll(); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/accessiblemenuitemcomponent.cxx b/accessibility/source/standard/accessiblemenuitemcomponent.cxx new file mode 100644 index 000000000..e61c7452e --- /dev/null +++ b/accessibility/source/standard/accessiblemenuitemcomponent.cxx @@ -0,0 +1,472 @@ +/* -*- 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 <standard/accessiblemenuitemcomponent.hxx> + + +#include <toolkit/helper/convert.hxx> + +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <unotools/accessiblestatesethelper.hxx> +#include <unotools/accessiblerelationsethelper.hxx> +#include <comphelper/accessibletexthelper.hxx> +#include <vcl/svapp.hxx> +#include <vcl/window.hxx> +#include <vcl/menu.hxx> +#include <vcl/settings.hxx> +#include <i18nlangtag/languagetag.hxx> + +using namespace ::com::sun::star::accessibility; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star; +using namespace ::comphelper; + + + + +OAccessibleMenuItemComponent::OAccessibleMenuItemComponent( Menu* pParent, sal_uInt16 nItemPos, Menu* pMenu ) + :OAccessibleMenuBaseComponent( pMenu ) + ,m_pParent( pParent ) + ,m_nItemPos( nItemPos ) +{ + m_sAccessibleName = GetAccessibleName(); + m_sItemText = GetItemText(); +} + +OAccessibleMenuItemComponent::~OAccessibleMenuItemComponent() +{ +} + +bool OAccessibleMenuItemComponent::IsEnabled() +{ + OExternalLockGuard aGuard( this ); + + bool bEnabled = false; + if ( m_pParent ) + bEnabled = m_pParent->IsItemEnabled( m_pParent->GetItemId( m_nItemPos ) ); + + return bEnabled; +} + + +bool OAccessibleMenuItemComponent::IsVisible() +{ + bool bVisible = false; + + if ( m_pParent ) + bVisible = m_pParent->IsItemPosVisible( m_nItemPos ); + + return bVisible; +} + + +void OAccessibleMenuItemComponent::Select() +{ + // open the parent menu + Reference< XAccessible > xParent( getAccessibleParent() ); + if ( xParent.is() ) + { + OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xParent.get() ); + if ( pComp && pComp->getAccessibleRole() == AccessibleRole::MENU && !pComp->IsPopupMenuOpen() ) + pComp->Click(); + } + + // highlight the menu item + if ( m_pParent ) + m_pParent->HighlightItem( m_nItemPos ); +} + + +void OAccessibleMenuItemComponent::DeSelect() +{ + if ( m_pParent && IsSelected() ) + m_pParent->DeHighlight(); +} + + +void OAccessibleMenuItemComponent::Click() +{ + // open the parent menu + Reference< XAccessible > xParent( getAccessibleParent() ); + if ( xParent.is() ) + { + OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xParent.get() ); + if ( pComp && pComp->getAccessibleRole() == AccessibleRole::MENU && !pComp->IsPopupMenuOpen() ) + pComp->Click(); + } + + // click the menu item + if ( !m_pParent ) + return; + + vcl::Window* pWindow = m_pParent->GetWindow(); + if ( !pWindow ) + return; + + // #102438# Menu items are not selectable + // Popup menus are executed asynchronously, triggered by a timer. + // As Menu::SelectItem only works, if the corresponding menu window is + // already created, we have to set the menu delay to 0, so + // that the popup menus are executed synchronously. + AllSettings aSettings = pWindow->GetSettings(); + MouseSettings aMouseSettings = aSettings.GetMouseSettings(); + sal_Int32 nDelay = aMouseSettings.GetMenuDelay(); + aMouseSettings.SetMenuDelay( 0 ); + aSettings.SetMouseSettings( aMouseSettings ); + pWindow->SetSettings( aSettings ); + + m_pParent->SelectItem( m_pParent->GetItemId( m_nItemPos ) ); + + // meanwhile the window pointer may be invalid + pWindow = m_pParent->GetWindow(); + if ( pWindow ) + { + // set the menu delay back to the old value + aSettings = pWindow->GetSettings(); + aMouseSettings = aSettings.GetMouseSettings(); + aMouseSettings.SetMenuDelay( nDelay ); + aSettings.SetMouseSettings( aMouseSettings ); + pWindow->SetSettings( aSettings ); + } +} + + +void OAccessibleMenuItemComponent::SetItemPos( sal_uInt16 nItemPos ) +{ + m_nItemPos = nItemPos; +} + + +void OAccessibleMenuItemComponent::SetAccessibleName( const OUString& sAccessibleName ) +{ + if ( m_sAccessibleName != sAccessibleName ) + { + Any aOldValue, aNewValue; + aOldValue <<= m_sAccessibleName; + aNewValue <<= sAccessibleName; + m_sAccessibleName = sAccessibleName; + NotifyAccessibleEvent( AccessibleEventId::NAME_CHANGED, aOldValue, aNewValue ); + } +} + + +OUString OAccessibleMenuItemComponent::GetAccessibleName() +{ + OUString sName; + if ( m_pParent ) + { + sal_uInt16 nItemId = m_pParent->GetItemId( m_nItemPos ); + sName = m_pParent->GetAccessibleName( nItemId ); + if ( sName.isEmpty() ) + sName = m_pParent->GetItemText( nItemId ); + sName = OutputDevice::GetNonMnemonicString( sName ); +#if defined(_WIN32) + if ( m_pParent->GetAccelKey( nItemId ).GetName().getLength() ) + sName += "\t" + m_pParent->GetAccelKey(nItemId).GetName(); +#endif + } + + return sName; +} + + +void OAccessibleMenuItemComponent::SetItemText( const OUString& sItemText ) +{ + Any aOldValue, aNewValue; + if ( OCommonAccessibleText::implInitTextChangedEvent( m_sItemText, sItemText, aOldValue, aNewValue ) ) + { + m_sItemText = sItemText; + NotifyAccessibleEvent( AccessibleEventId::TEXT_CHANGED, aOldValue, aNewValue ); + } +} + + +OUString OAccessibleMenuItemComponent::GetItemText() +{ + OUString sText; + if ( m_pParent ) + sText = OutputDevice::GetNonMnemonicString( m_pParent->GetItemText( m_pParent->GetItemId( m_nItemPos ) ) ); + + return sText; +} + + +void OAccessibleMenuItemComponent::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet ) +{ + bool bEnabled = IsEnabled(); + if ( bEnabled ) + { + rStateSet.AddState( AccessibleStateType::ENABLED ); + rStateSet.AddState( AccessibleStateType::SENSITIVE ); + } + + if ( IsVisible() ) + { + rStateSet.AddState( AccessibleStateType::SHOWING ); + if( !IsMenuHideDisabledEntries() || bEnabled ) + rStateSet.AddState( AccessibleStateType::VISIBLE ); + } + rStateSet.AddState( AccessibleStateType::OPAQUE ); +} + + +// OCommonAccessibleComponent + + +awt::Rectangle OAccessibleMenuItemComponent::implGetBounds() +{ + awt::Rectangle aBounds( 0, 0, 0, 0 ); + + if ( m_pParent ) + { + // get bounding rectangle of the item relative to the containing window + aBounds = AWTRectangle( m_pParent->GetBoundingRectangle( m_nItemPos ) ); + + // get position of containing window in screen coordinates + vcl::Window* pWindow = m_pParent->GetWindow(); + if ( pWindow ) + { + tools::Rectangle aRect = pWindow->GetWindowExtentsRelative( nullptr ); + awt::Point aWindowScreenLoc = AWTPoint( aRect.TopLeft() ); + + // get position of accessible parent in screen coordinates + Reference< XAccessible > xParent = getAccessibleParent(); + if ( xParent.is() ) + { + Reference< XAccessibleComponent > xParentComponent( xParent->getAccessibleContext(), UNO_QUERY ); + if ( xParentComponent.is() ) + { + awt::Point aParentScreenLoc = xParentComponent->getLocationOnScreen(); + + // calculate bounding rectangle of the item relative to the accessible parent + aBounds.X += aWindowScreenLoc.X - aParentScreenLoc.X; + aBounds.Y += aWindowScreenLoc.Y - aParentScreenLoc.Y; + } + } + } + } + + return aBounds; +} + + +// XComponent + + +void SAL_CALL OAccessibleMenuItemComponent::disposing() +{ + OAccessibleMenuBaseComponent::disposing(); + + m_pParent = nullptr; + m_sAccessibleName.clear(); + m_sItemText.clear(); +} + + +// XAccessibleContext + + +sal_Int32 OAccessibleMenuItemComponent::getAccessibleChildCount() +{ + OExternalLockGuard aGuard( this ); + + return 0; +} + + +Reference< XAccessible > OAccessibleMenuItemComponent::getAccessibleChild( sal_Int32 i ) +{ + OExternalLockGuard aGuard( this ); + + if ( i < 0 || i >= getAccessibleChildCount() ) + throw IndexOutOfBoundsException(); + + return Reference< XAccessible >(); +} + + +Reference< XAccessible > OAccessibleMenuItemComponent::getAccessibleParent( ) +{ + OExternalLockGuard aGuard( this ); + + return m_pParent->GetAccessible(); +} + + +sal_Int32 OAccessibleMenuItemComponent::getAccessibleIndexInParent( ) +{ + OExternalLockGuard aGuard( this ); + + return m_nItemPos; +} + + +sal_Int16 OAccessibleMenuItemComponent::getAccessibleRole( ) +{ + OExternalLockGuard aGuard( this ); + + return AccessibleRole::UNKNOWN; +} + + +OUString OAccessibleMenuItemComponent::getAccessibleDescription( ) +{ + OExternalLockGuard aGuard( this ); + + OUString sDescription; + if ( m_pParent ) + sDescription = m_pParent->GetAccessibleDescription( m_pParent->GetItemId( m_nItemPos ) ); + + return sDescription; +} + + +OUString OAccessibleMenuItemComponent::getAccessibleName( ) +{ + OExternalLockGuard aGuard( this ); + + return m_sAccessibleName; +} + + +Reference< XAccessibleRelationSet > OAccessibleMenuItemComponent::getAccessibleRelationSet( ) +{ + OExternalLockGuard aGuard( this ); + + return new utl::AccessibleRelationSetHelper; +} + + +Locale OAccessibleMenuItemComponent::getLocale( ) +{ + OExternalLockGuard aGuard( this ); + + return Application::GetSettings().GetLanguageTag().getLocale(); +} + + +// XAccessibleComponent + + +Reference< XAccessible > OAccessibleMenuItemComponent::getAccessibleAtPoint( const awt::Point& ) +{ + OExternalLockGuard aGuard( this ); + + return Reference< XAccessible >(); +} + + +void OAccessibleMenuItemComponent::grabFocus( ) +{ + // no focus for items +} + + +sal_Int32 OAccessibleMenuItemComponent::getForeground( ) +{ + OExternalLockGuard aGuard( this ); + + sal_Int32 nColor = 0; + Reference< XAccessible > xParent = getAccessibleParent(); + if ( xParent.is() ) + { + Reference< XAccessibleComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY ); + if ( xParentComp.is() ) + nColor = xParentComp->getForeground(); + } + + return nColor; +} + + +sal_Int32 OAccessibleMenuItemComponent::getBackground( ) +{ + OExternalLockGuard aGuard( this ); + + sal_Int32 nColor = 0; + Reference< XAccessible > xParent = getAccessibleParent(); + if ( xParent.is() ) + { + Reference< XAccessibleComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY ); + if ( xParentComp.is() ) + nColor = xParentComp->getBackground(); + } + + return nColor; +} + + +// XAccessibleExtendedComponent + + +Reference< awt::XFont > OAccessibleMenuItemComponent::getFont( ) +{ + OExternalLockGuard aGuard( this ); + + Reference< awt::XFont > xFont; + Reference< XAccessible > xParent = getAccessibleParent(); + if ( xParent.is() ) + { + Reference< XAccessibleExtendedComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY ); + if ( xParentComp.is() ) + xFont = xParentComp->getFont(); + } + + return xFont; +} + + +OUString OAccessibleMenuItemComponent::getTitledBorderText( ) +{ + OExternalLockGuard aGuard( this ); + + return OUString(); +} + + +OUString OAccessibleMenuItemComponent::getToolTipText( ) +{ + OExternalLockGuard aGuard( this ); + + OUString sRet; + if ( m_pParent ) + sRet = m_pParent->GetTipHelpText( m_pParent->GetItemId( m_nItemPos ) ); + + return sRet; +} + + +bool OAccessibleMenuItemComponent::IsMenuHideDisabledEntries() +{ + if (m_pParent ) + { + if( m_pParent->GetMenuFlags() & MenuFlags::HideDisabledEntries) + { + return true; + } + } + return false; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/floatingwindowaccessible.cxx b/accessibility/source/standard/floatingwindowaccessible.cxx new file mode 100644 index 000000000..aa5ef41f6 --- /dev/null +++ b/accessibility/source/standard/floatingwindowaccessible.cxx @@ -0,0 +1,45 @@ +/* -*- 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 <floatingwindowaccessible.hxx> + +#include <com/sun/star/accessibility/AccessibleRelationType.hpp> +#include <unotools/accessiblerelationsethelper.hxx> +#include <vcl/window.hxx> + +namespace uno = ::com::sun::star::uno; + +using ::com::sun::star::accessibility::AccessibleRelation; +namespace AccessibleRelationType = ::com::sun::star::accessibility::AccessibleRelationType; + +void FloatingWindowAccessible::FillAccessibleRelationSet(utl::AccessibleRelationSetHelper& rRelationSet) +{ + VclPtr<vcl::Window> pWindow = GetWindow(); + if ( pWindow ) + { + vcl::Window* pParentWindow = pWindow->GetParent(); + if( pParentWindow ) + { + uno::Sequence< uno::Reference< uno::XInterface > > aSequence { pParentWindow->GetAccessible() }; + rRelationSet.AddRelation( AccessibleRelation( AccessibleRelationType::SUB_WINDOW_OF, aSequence ) ); + } + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/svtaccessiblenumericfield.cxx b/accessibility/source/standard/svtaccessiblenumericfield.cxx new file mode 100644 index 000000000..729966eb8 --- /dev/null +++ b/accessibility/source/standard/svtaccessiblenumericfield.cxx @@ -0,0 +1,105 @@ +/* -*- 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 <standard/svtaccessiblenumericfield.hxx> +#include <toolkit/awt/vclxwindows.hxx> + +#include <com/sun/star/accessibility/AccessibleRole.hpp> + +using namespace ::com::sun::star::accessibility; +using namespace ::comphelper; + +SVTXAccessibleNumericField::SVTXAccessibleNumericField(VCLXWindow* pVCLWindow) + : VCLXAccessibleEdit(pVCLWindow) +{ +} + +// XInterface +IMPLEMENT_FORWARD_XINTERFACE2(SVTXAccessibleNumericField, VCLXAccessibleTextComponent, + SVTXAccessibleNumericField_BASE) + +// XTypeProvider +IMPLEMENT_FORWARD_XTYPEPROVIDER2(SVTXAccessibleNumericField, VCLXAccessibleTextComponent, + SVTXAccessibleNumericField_BASE) + +sal_Int16 SVTXAccessibleNumericField::getAccessibleRole() { return AccessibleRole::SPIN_BOX; } + +css::uno::Any SAL_CALL SVTXAccessibleNumericField::getCurrentValue() +{ + OExternalLockGuard aGuard(this); + + double dValue = 0; + SVTXNumericField* pField = static_cast<SVTXNumericField*>(GetVCLXWindow()); + if (pField) + dValue = pField->getValue(); + + return css::uno::Any(dValue); +} + +sal_Bool SVTXAccessibleNumericField::setCurrentValue(const css::uno::Any& aNumber) +{ + OExternalLockGuard aGuard(this); + + SVTXNumericField* pField = static_cast<SVTXNumericField*>(GetVCLXWindow()); + if (!pField) + return false; + + double dValue = 0; + aNumber >>= dValue; + pField->setValue(dValue); + return true; +} + +css::uno::Any SAL_CALL SVTXAccessibleNumericField::getMaximumValue() +{ + OExternalLockGuard aGuard(this); + + double dValue = 0; + SVTXNumericField* pField = static_cast<SVTXNumericField*>(GetVCLXWindow()); + if (pField) + dValue = pField->getMax(); + + return css::uno::Any(dValue); +} + +css::uno::Any SAL_CALL SVTXAccessibleNumericField::getMinimumValue() +{ + OExternalLockGuard aGuard(this); + + double dValue = 0; + SVTXNumericField* pField = static_cast<SVTXNumericField*>(GetVCLXWindow()); + if (pField) + dValue = pField->getMin(); + + return css::uno::Any(dValue); +} + +css::uno::Any SAL_CALL SVTXAccessibleNumericField::getMinimumIncrement() +{ + OExternalLockGuard aGuard(this); + + double dValue = 0; + SVTXNumericField* pField = static_cast<SVTXNumericField*>(GetVCLXWindow()); + if (pField) + dValue = pField->getSpinSize(); + + return css::uno::Any(dValue); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessiblebox.cxx b/accessibility/source/standard/vclxaccessiblebox.cxx new file mode 100644 index 000000000..ce81c254c --- /dev/null +++ b/accessibility/source/standard/vclxaccessiblebox.cxx @@ -0,0 +1,525 @@ +/* -*- 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 <standard/vclxaccessiblebox.hxx> +#include <standard/vclxaccessibletextfield.hxx> +#include <standard/vclxaccessibleedit.hxx> +#include <standard/vclxaccessiblelist.hxx> + +#include <unotools/accessiblestatesethelper.hxx> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <vcl/svapp.hxx> +#include <vcl/toolkit/combobox.hxx> +#include <vcl/toolkit/lstbox.hxx> +#include <strings.hxx> + +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; + +VCLXAccessibleBox::VCLXAccessibleBox (VCLXWindow* pVCLWindow, BoxType aType, bool bIsDropDownBox) + : VCLXAccessibleComponent (pVCLWindow), + m_aBoxType (aType), + m_bIsDropDownBox (bIsDropDownBox) +{ + // Set up the flags that indicate which children this object has. + m_bHasListChild = true; + + // A text field is not present for non drop down list boxes. + if ((m_aBoxType==LISTBOX) && ! m_bIsDropDownBox) + m_bHasTextChild = false; + else + m_bHasTextChild = true; +} + +void VCLXAccessibleBox::ProcessWindowChildEvent( const VclWindowEvent& rVclWindowEvent ) +{ + uno::Any aOldValue, aNewValue; + + switch ( rVclWindowEvent.GetId() ) + { + case VclEventId::WindowShow: + case VclEventId::WindowHide: + { + vcl::Window* pChildWindow = static_cast<vcl::Window *>(rVclWindowEvent.GetData()); + // Just compare to the combo box text field. All other children + // are identical to this object in which case this object will + // be removed in a short time. + if (m_aBoxType==COMBOBOX) + { + VclPtr< ComboBox > pComboBox = GetAs< ComboBox >(); + if ( ( pComboBox != nullptr ) && ( pChildWindow != nullptr ) ) + if (pChildWindow == pComboBox->GetSubEdit()) + { + if (rVclWindowEvent.GetId() == VclEventId::WindowShow) + { + // Instantiate text field. + getAccessibleChild (0); + aNewValue <<= m_xText; + } + else + { + // Release text field. + aOldValue <<= m_xText; + m_xText = nullptr; + } + // Tell the listeners about the new/removed child. + NotifyAccessibleEvent ( + AccessibleEventId::CHILD, + aOldValue, aNewValue); + } + + } + } + break; + + default: + VCLXAccessibleComponent::ProcessWindowChildEvent (rVclWindowEvent); + } +} + +void VCLXAccessibleBox::ProcessWindowEvent (const VclWindowEvent& rVclWindowEvent) +{ + switch ( rVclWindowEvent.GetId() ) + { + case VclEventId::DropdownSelect: + case VclEventId::ListboxSelect: + { + // Forward the call to the list child. + VCLXAccessibleList* pList = static_cast<VCLXAccessibleList*>(m_xList.get()); + if ( pList == nullptr ) + { + getAccessibleChild ( m_bHasTextChild ? 1 : 0 ); + pList = static_cast<VCLXAccessibleList*>(m_xList.get()); + } + if ( pList != nullptr ) + { + pList->ProcessWindowEvent (rVclWindowEvent, m_bIsDropDownBox); +#if defined(_WIN32) + if (m_bIsDropDownBox) + { + NotifyAccessibleEvent(AccessibleEventId::VALUE_CHANGED, Any(), Any()); + } +#endif + } + break; + } + case VclEventId::DropdownOpen: + { + VCLXAccessibleList* pList = static_cast<VCLXAccessibleList*>(m_xList.get()); + if ( pList == nullptr ) + { + getAccessibleChild ( m_bHasTextChild ? 1 : 0 ); + pList = static_cast<VCLXAccessibleList*>(m_xList.get()); + } + if ( pList != nullptr ) + { + pList->ProcessWindowEvent (rVclWindowEvent); + pList->HandleDropOpen(); + } + break; + } + case VclEventId::DropdownClose: + { + VCLXAccessibleList* pList = static_cast<VCLXAccessibleList*>(m_xList.get()); + if ( pList == nullptr ) + { + getAccessibleChild ( m_bHasTextChild ? 1 : 0 ); + pList = static_cast<VCLXAccessibleList*>(m_xList.get()); + } + if ( pList != nullptr ) + { + pList->ProcessWindowEvent (rVclWindowEvent); + } + VclPtr<vcl::Window> pWindow = GetWindow(); + if( pWindow && (pWindow->HasFocus() || pWindow->HasChildPathFocus()) ) + { + Any aOldValue, aNewValue; + aNewValue <<= AccessibleStateType::FOCUSED; + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue ); + } + break; + } + case VclEventId::ComboboxSelect: + { + VCLXAccessibleList* pList = static_cast<VCLXAccessibleList*>(m_xList.get()); + if (pList != nullptr && m_xText.is()) + { + Reference<XAccessibleText> xText (m_xText->getAccessibleContext(), UNO_QUERY); + if ( xText.is() ) + { + OUString sText = xText->getSelectedText(); + if ( sText.isEmpty() ) + sText = xText->getText(); + pList->UpdateSelection_Acc(sText, m_bIsDropDownBox); +#if defined(_WIN32) + if (m_bIsDropDownBox || m_aBoxType==COMBOBOX) + NotifyAccessibleEvent(AccessibleEventId::VALUE_CHANGED, Any(), Any()); +#endif + } + } + break; + } + //case VclEventId::DropdownOpen: + //case VclEventId::DropdownClose: + case VclEventId::ListboxDoubleClick: + case VclEventId::ListboxScrolled: + //case VclEventId::ListboxSelect: + case VclEventId::ListboxItemAdded: + case VclEventId::ListboxItemRemoved: + case VclEventId::ComboboxItemAdded: + case VclEventId::ComboboxItemRemoved: + { + // Forward the call to the list child. + VCLXAccessibleList* pList = static_cast<VCLXAccessibleList*>(m_xList.get()); + if ( pList == nullptr ) + { + getAccessibleChild ( m_bHasTextChild ? 1 : 0 ); + pList = static_cast<VCLXAccessibleList*>(m_xList.get()); + } + if ( pList != nullptr ) + pList->ProcessWindowEvent (rVclWindowEvent); + break; + } + + //case VclEventId::ComboboxSelect: + case VclEventId::ComboboxDeselect: + { + // Selection is handled by VCLXAccessibleList which operates on + // the same VCL object as this box does. In case of the + // combobox, however, we have to help by providing the list with + // the text of the currently selected item. + VCLXAccessibleList* pList = static_cast<VCLXAccessibleList*>(m_xList.get()); + if (pList != nullptr && m_xText.is()) + { + Reference<XAccessibleText> xText (m_xText->getAccessibleContext(), UNO_QUERY); + if ( xText.is() ) + { + OUString sText = xText->getSelectedText(); + if ( sText.isEmpty() ) + sText = xText->getText(); + pList->UpdateSelection (sText); + } + } + break; + } + + case VclEventId::EditModify: + case VclEventId::EditSelectionChanged: + case VclEventId::EditCaretChanged: + // Modify/Selection events are handled by the combo box instead of + // directly by the edit field (Why?). Therefore, delegate this + // call to the edit field. + if (m_aBoxType==COMBOBOX) + { + if (m_xText.is()) + { + Reference<XAccessibleContext> xContext = m_xText->getAccessibleContext(); + VCLXAccessibleEdit* pEdit = static_cast<VCLXAccessibleEdit*>(xContext.get()); + if (pEdit != nullptr) + pEdit->ProcessWindowEvent (rVclWindowEvent); + } + } + break; + default: + VCLXAccessibleComponent::ProcessWindowEvent( rVclWindowEvent ); + } +} + +IMPLEMENT_FORWARD_XINTERFACE2(VCLXAccessibleBox, VCLXAccessibleComponent, VCLXAccessibleBox_BASE) +IMPLEMENT_FORWARD_XTYPEPROVIDER2(VCLXAccessibleBox, VCLXAccessibleComponent, VCLXAccessibleBox_BASE) + +//===== XAccessible ========================================================= + +Reference< XAccessibleContext > SAL_CALL VCLXAccessibleBox::getAccessibleContext( ) +{ + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + + return this; +} + +//===== XAccessibleContext ================================================== + +sal_Int32 VCLXAccessibleBox::getAccessibleChildCount() +{ + SolarMutexGuard aSolarGuard; + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + + return implGetAccessibleChildCount(); +} + +sal_Int32 VCLXAccessibleBox::implGetAccessibleChildCount() +{ + // Usually a box has a text field and a list of items as its children. + // Non drop down list boxes have no text field. Additionally check + // whether the object is valid. + sal_Int32 nCount = 0; + if (IsValid()) + nCount += (m_bHasTextChild?1:0) + (m_bHasListChild?1:0); + else + { + // Object not valid anymore. Release references to children. + m_bHasTextChild = false; + m_xText = nullptr; + m_bHasListChild = false; + m_xList = nullptr; + } + + return nCount; +} + +Reference<XAccessible> SAL_CALL VCLXAccessibleBox::getAccessibleChild (sal_Int32 i) +{ + SolarMutexGuard aSolarGuard; + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + + if (i<0 || i>=implGetAccessibleChildCount()) + throw IndexOutOfBoundsException(); + + Reference< XAccessible > xChild; + if (IsValid()) + { + if (i==1 || ! m_bHasTextChild) + { + // List. + if ( ! m_xList.is()) + { + rtl::Reference<VCLXAccessibleList> pList = new VCLXAccessibleList ( GetVCLXWindow(), + (m_aBoxType == LISTBOX ? VCLXAccessibleList::LISTBOX : VCLXAccessibleList::COMBOBOX), + this); + pList->SetIndexInParent (i); + m_xList = pList; + } + xChild = m_xList; + } + else + { + // Text Field. + if ( ! m_xText.is()) + { + if (m_aBoxType==COMBOBOX) + { + VclPtr< ComboBox > pComboBox = GetAs< ComboBox >(); + if (pComboBox!=nullptr && pComboBox->GetSubEdit()!=nullptr) + //Set the edit's acc name the same as parent + { + pComboBox->GetSubEdit()->SetAccessibleName(getAccessibleName()); + m_xText = pComboBox->GetSubEdit()->GetAccessible(); + } + } + else if (m_bIsDropDownBox) + m_xText = new VCLXAccessibleTextField (GetVCLXWindow(),this); + } + xChild = m_xText; + } + } + + return xChild; +} + +sal_Int16 SAL_CALL VCLXAccessibleBox::getAccessibleRole() +{ + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + + // Return the role <const>COMBO_BOX</const> for both VCL combo boxes and + // VCL list boxes in DropDown-Mode else <const>PANEL</const>. + // This way the Java bridge has not to handle both independently. + //return m_bIsDropDownBox ? AccessibleRole::COMBO_BOX : AccessibleRole::PANEL; + if (m_bIsDropDownBox || (m_aBoxType == COMBOBOX)) + return AccessibleRole::COMBO_BOX; + else + return AccessibleRole::PANEL; +} + +//===== XAccessibleAction =================================================== + +sal_Int32 SAL_CALL VCLXAccessibleBox::getAccessibleActionCount() +{ + ::osl::Guard< ::osl::Mutex> aGuard (GetMutex()); + + // There is one action for drop down boxes (toggle popup) and none for + // the other boxes. + return m_bIsDropDownBox ? 1 : 0; +} + +sal_Bool SAL_CALL VCLXAccessibleBox::doAccessibleAction (sal_Int32 nIndex) +{ + bool bNotify = false; + + { + SolarMutexGuard aSolarGuard; + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + + if (nIndex!=0 || !m_bIsDropDownBox) + throw css::lang::IndexOutOfBoundsException( + ("VCLXAccessibleBox::doAccessibleAction: index " + + OUString::number(nIndex) + " not among 0.." + + OUString::number(getAccessibleActionCount())), + static_cast<OWeakObject*>(this)); + + if (m_aBoxType == COMBOBOX) + { + VclPtr< ComboBox > pComboBox = GetAs< ComboBox >(); + if (pComboBox != nullptr) + { + pComboBox->ToggleDropDown(); + bNotify = true; + } + } + else if (m_aBoxType == LISTBOX) + { + VclPtr< ListBox > pListBox = GetAs< ListBox >(); + if (pListBox != nullptr) + { + pListBox->ToggleDropDown(); + bNotify = true; + } + } + } + + if (bNotify) + NotifyAccessibleEvent (AccessibleEventId::ACTION_CHANGED, Any(), Any()); + + return bNotify; +} + +OUString SAL_CALL VCLXAccessibleBox::getAccessibleActionDescription (sal_Int32 nIndex) +{ + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + if (nIndex!=0 || !m_bIsDropDownBox) + throw css::lang::IndexOutOfBoundsException(); + + return RID_STR_ACC_ACTION_TOGGLEPOPUP; +} + +Reference< XAccessibleKeyBinding > VCLXAccessibleBox::getAccessibleActionKeyBinding( sal_Int32 nIndex ) +{ + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + + Reference< XAccessibleKeyBinding > xRet; + + if (nIndex<0 || nIndex>=getAccessibleActionCount()) + throw css::lang::IndexOutOfBoundsException(); + + // ... which key? + return xRet; +} + +// ===== XAccessibleValue =============================================== +Any VCLXAccessibleBox::getCurrentValue( ) +{ + SolarMutexGuard aSolarGuard; + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + + Any aAny; + if( m_xList.is() && m_xText.is()) + { + // VCLXAccessibleList* pList = static_cast<VCLXAccessibleList*>(m_xList.get()); + Reference<XAccessibleText> xText (m_xText->getAccessibleContext(), UNO_QUERY); + if ( xText.is() ) + { + OUString sText = xText->getText(); + aAny <<= sText; + } + } + if (m_aBoxType == LISTBOX && m_bIsDropDownBox && m_xList.is() ) + { + + VCLXAccessibleList* pList = static_cast<VCLXAccessibleList*>(m_xList.get()); + if(pList->IsInDropDown()) + { + if(pList->getSelectedAccessibleChildCount()>0) + { + Reference<XAccessibleContext> xName (pList->getSelectedAccessibleChild(sal_Int32(0)), UNO_QUERY); + if(xName.is()) + { + aAny <<= xName->getAccessibleName(); + } + } + } + } + + return aAny; +} + +sal_Bool VCLXAccessibleBox::setCurrentValue( const Any& aNumber ) +{ + SolarMutexGuard aSolarGuard; + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + + OUString fValue; + bool bValid = (aNumber >>= fValue); + return bValid; + +} + +Any VCLXAccessibleBox::getMaximumValue( ) +{ + Any aAny; + return aAny; +} + +Any VCLXAccessibleBox::getMinimumValue( ) +{ + Any aAny; + return aAny; +} + +Any VCLXAccessibleBox::getMinimumIncrement( ) +{ + return Any(); +} + +// Set the INDETERMINATE state when there is no selected item for combobox +void VCLXAccessibleBox::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet ) +{ + VCLXAccessibleComponent::FillAccessibleStateSet(rStateSet); + if (m_aBoxType == COMBOBOX ) + { + OUString sText; + sal_Int32 nEntryCount = 0; + VclPtr< ComboBox > pComboBox = GetAs< ComboBox >(); + if (pComboBox != nullptr) + { + Edit* pSubEdit = pComboBox->GetSubEdit(); + if ( pSubEdit) + sText = pSubEdit->GetText(); + nEntryCount = pComboBox->GetEntryCount(); + } + if ( sText.isEmpty() && nEntryCount > 0 ) + rStateSet.AddState(AccessibleStateType::INDETERMINATE); + } + else if (m_aBoxType == LISTBOX && m_bIsDropDownBox) + { + VclPtr< ListBox > pListBox = GetAs< ListBox >(); + if (pListBox != nullptr && pListBox->GetEntryCount() > 0) + { + sal_Int32 nSelectedEntryCount = pListBox->GetSelectedEntryCount(); + if ( nSelectedEntryCount == 0) + rStateSet.AddState(AccessibleStateType::INDETERMINATE); + } + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessiblebutton.cxx b/accessibility/source/standard/vclxaccessiblebutton.cxx new file mode 100644 index 000000000..d5ffb68bb --- /dev/null +++ b/accessibility/source/standard/vclxaccessiblebutton.cxx @@ -0,0 +1,310 @@ +/* -*- 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 <standard/vclxaccessiblebutton.hxx> +#include <helper/accresmgr.hxx> +#include <strings.hrc> + +#include <unotools/accessiblestatesethelper.hxx> +#include <comphelper/accessiblekeybindinghelper.hxx> +#include <com/sun/star/awt/KeyModifier.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <strings.hxx> + +#include <vcl/toolkit/button.hxx> +#include <vcl/event.hxx> +#include <vcl/vclevent.hxx> + +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; +using namespace ::comphelper; + + +// VCLXAccessibleButton + + +void VCLXAccessibleButton::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent ) +{ + switch ( rVclWindowEvent.GetId() ) + { + case VclEventId::PushbuttonToggle: + { + Any aOldValue; + Any aNewValue; + + VclPtr< PushButton > pButton = GetAs< PushButton >(); + if ( pButton && pButton->GetState() == TRISTATE_TRUE ) + aNewValue <<= AccessibleStateType::CHECKED; + else + aOldValue <<= AccessibleStateType::CHECKED; + + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue ); + } + break; + default: + VCLXAccessibleTextComponent::ProcessWindowEvent( rVclWindowEvent ); + } +} + + +void VCLXAccessibleButton::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet ) +{ + VCLXAccessibleTextComponent::FillAccessibleStateSet( rStateSet ); + + VclPtr< PushButton > pButton = GetAs< PushButton >(); + if ( !pButton ) + return; + + rStateSet.AddState( AccessibleStateType::FOCUSABLE ); + + if ( pButton->GetState() == TRISTATE_TRUE ) + rStateSet.AddState( AccessibleStateType::CHECKED ); + + if ( pButton->IsPressed() ) + rStateSet.AddState( AccessibleStateType::PRESSED ); + + // IA2 CWS: if the button has a popup menu, it should has the state EXPANDABLE + if( pButton->GetType() == WindowType::MENUBUTTON ) + { + rStateSet.AddState( AccessibleStateType::EXPANDABLE ); + } + if( pButton->GetStyle() & WB_DEFBUTTON ) + { + rStateSet.AddState( AccessibleStateType::DEFAULT ); + } +} + + +// XInterface + + +IMPLEMENT_FORWARD_XINTERFACE2( VCLXAccessibleButton, VCLXAccessibleTextComponent, VCLXAccessibleButton_BASE ) + + +// XTypeProvider + + +IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXAccessibleButton, VCLXAccessibleTextComponent, VCLXAccessibleButton_BASE ) + + +// XServiceInfo + + +OUString VCLXAccessibleButton::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleButton"; +} + + +Sequence< OUString > VCLXAccessibleButton::getSupportedServiceNames() +{ + return { "com.sun.star.awt.AccessibleButton" }; +} + + +// XAccessibleContext + + +OUString VCLXAccessibleButton::getAccessibleName( ) +{ + OUString aName( VCLXAccessibleTextComponent::getAccessibleName() ); + sal_Int32 nLength = aName.getLength(); + + if ( nLength >= 3 && aName.match( "...", nLength - 3 ) ) + { + if ( nLength == 3 ) + { + // it's a browse button + aName = AccResId( RID_STR_ACC_NAME_BROWSEBUTTON ); + } + else + { + // remove the three trailing dots + aName = aName.copy( 0, nLength - 3 ); + } + } + else if ( nLength >= 3 && aName.match( "<< ", 0 ) ) + { + // remove the leading symbols + aName = aName.copy( 3, nLength - 3 ); + } + else if ( nLength >= 3 && aName.match( " >>", nLength - 3 ) ) + { + // remove the trailing symbols + aName = aName.copy( 0, nLength - 3 ); + } + + return aName; +} + + +// XAccessibleAction + + +sal_Int32 VCLXAccessibleButton::getAccessibleActionCount( ) +{ + OExternalLockGuard aGuard( this ); + + return 1; +} + + +sal_Bool VCLXAccessibleButton::doAccessibleAction ( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nIndex != 0 ) + throw IndexOutOfBoundsException(); + + VclPtr< PushButton > pButton = GetAs< PushButton >(); + if ( pButton ) + pButton->Click(); + + return true; +} + + +OUString VCLXAccessibleButton::getAccessibleActionDescription ( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nIndex != 0 ) + throw IndexOutOfBoundsException(); + + return RID_STR_ACC_ACTION_CLICK; +} + + +Reference< XAccessibleKeyBinding > VCLXAccessibleButton::getAccessibleActionKeyBinding( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nIndex != 0 ) + throw IndexOutOfBoundsException(); + + rtl::Reference<OAccessibleKeyBindingHelper> pKeyBindingHelper = new OAccessibleKeyBindingHelper(); + + VclPtr<vcl::Window> pWindow = GetWindow(); + if ( pWindow ) + { + KeyEvent aKeyEvent = pWindow->GetActivationKey(); + vcl::KeyCode aKeyCode = aKeyEvent.GetKeyCode(); + if ( aKeyCode.GetCode() != 0 ) + { + awt::KeyStroke aKeyStroke; + aKeyStroke.Modifiers = 0; + if ( aKeyCode.IsShift() ) + aKeyStroke.Modifiers |= awt::KeyModifier::SHIFT; + if ( aKeyCode.IsMod1() ) + aKeyStroke.Modifiers |= awt::KeyModifier::MOD1; + if ( aKeyCode.IsMod2() ) + aKeyStroke.Modifiers |= awt::KeyModifier::MOD2; + if ( aKeyCode.IsMod3() ) + aKeyStroke.Modifiers |= awt::KeyModifier::MOD3; + aKeyStroke.KeyCode = aKeyCode.GetCode(); + aKeyStroke.KeyChar = aKeyEvent.GetCharCode(); + aKeyStroke.KeyFunc = static_cast< sal_Int16 >( aKeyCode.GetFunction() ); + pKeyBindingHelper->AddKeyBinding( aKeyStroke ); + } + } + + return pKeyBindingHelper; +} + + +// XAccessibleValue + + +Any VCLXAccessibleButton::getCurrentValue( ) +{ + OExternalLockGuard aGuard( this ); + + Any aValue; + + VclPtr< PushButton > pButton = GetAs< PushButton >(); + if ( pButton ) + aValue <<= static_cast<sal_Int32>(pButton->IsPressed()); + + return aValue; +} + + +sal_Bool VCLXAccessibleButton::setCurrentValue( const Any& aNumber ) +{ + OExternalLockGuard aGuard( this ); + + bool bReturn = false; + + VclPtr< PushButton > pButton = GetAs< PushButton >(); + if ( pButton ) + { + sal_Int32 nValue = 0; + OSL_VERIFY( aNumber >>= nValue ); + + if ( nValue < 0 ) + nValue = 0; + else if ( nValue > 1 ) + nValue = 1; + + pButton->SetPressed( nValue == 1 ); + bReturn = true; + } + + return bReturn; +} + + +Any VCLXAccessibleButton::getMaximumValue( ) +{ + OExternalLockGuard aGuard( this ); + + Any aValue; + aValue <<= sal_Int32(1); + + return aValue; +} + + +Any VCLXAccessibleButton::getMinimumValue( ) +{ + OExternalLockGuard aGuard( this ); + + Any aValue; + aValue <<= sal_Int32(0); + + return aValue; +} + +Any VCLXAccessibleButton::getMinimumIncrement( ) +{ + OExternalLockGuard aGuard( this ); + + Any aValue; + aValue <<= sal_Int32(1); + + return aValue; +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessiblecheckbox.cxx b/accessibility/source/standard/vclxaccessiblecheckbox.cxx new file mode 100644 index 000000000..20cf2138b --- /dev/null +++ b/accessibility/source/standard/vclxaccessiblecheckbox.cxx @@ -0,0 +1,342 @@ +/* -*- 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 <standard/vclxaccessiblecheckbox.hxx> + +#include <toolkit/awt/vclxwindows.hxx> +#include <helper/accresmgr.hxx> +#include <strings.hrc> + +#include <unotools/accessiblestatesethelper.hxx> +#include <comphelper/accessiblekeybindinghelper.hxx> +#include <com/sun/star/awt/KeyModifier.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> + +#include <vcl/toolkit/button.hxx> +#include <vcl/event.hxx> +#include <vcl/vclevent.hxx> + +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; +using namespace ::comphelper; + + +// VCLXAccessibleCheckBox + + +VCLXAccessibleCheckBox::VCLXAccessibleCheckBox( VCLXWindow* pVCLWindow ) + :VCLXAccessibleTextComponent( pVCLWindow ) +{ + m_bChecked = IsChecked(); + m_bIndeterminate = IsIndeterminate(); +} + + +bool VCLXAccessibleCheckBox::IsChecked() const +{ + bool bChecked = false; + + VCLXCheckBox* pVCLXCheckBox = static_cast< VCLXCheckBox* >( GetVCLXWindow() ); + if ( pVCLXCheckBox && pVCLXCheckBox->getState() == sal_Int16(1) ) + bChecked = true; + + return bChecked; +} + + +bool VCLXAccessibleCheckBox::IsIndeterminate() const +{ + bool bIndeterminate = false; + + VCLXCheckBox* pVCLXCheckBox = static_cast< VCLXCheckBox* >( GetVCLXWindow() ); + if ( pVCLXCheckBox && pVCLXCheckBox->getState() == sal_Int16(2) ) + bIndeterminate = true; + + return bIndeterminate; +} + + +void VCLXAccessibleCheckBox::SetChecked( bool bChecked ) +{ + if ( m_bChecked != bChecked ) + { + Any aOldValue, aNewValue; + if ( m_bChecked ) + aOldValue <<= AccessibleStateType::CHECKED; + else + aNewValue <<= AccessibleStateType::CHECKED; + m_bChecked = bChecked; + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue ); + } +} + + +void VCLXAccessibleCheckBox::SetIndeterminate( bool bIndeterminate ) +{ + if ( m_bIndeterminate != bIndeterminate ) + { + Any aOldValue, aNewValue; + if ( m_bIndeterminate ) + aOldValue <<= AccessibleStateType::INDETERMINATE; + else + aNewValue <<= AccessibleStateType::INDETERMINATE; + m_bIndeterminate = bIndeterminate; + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue ); + } +} + + +void VCLXAccessibleCheckBox::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent ) +{ + switch ( rVclWindowEvent.GetId() ) + { + case VclEventId::CheckboxToggle: + { + SetChecked( IsChecked() ); + SetIndeterminate( IsIndeterminate() ); + } + break; + default: + VCLXAccessibleTextComponent::ProcessWindowEvent( rVclWindowEvent ); + } +} + + +void VCLXAccessibleCheckBox::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet ) +{ + VCLXAccessibleTextComponent::FillAccessibleStateSet( rStateSet ); + + rStateSet.AddState( AccessibleStateType::FOCUSABLE ); + + if ( IsChecked() ) + rStateSet.AddState( AccessibleStateType::CHECKED ); + + if ( IsIndeterminate() ) + rStateSet.AddState( AccessibleStateType::INDETERMINATE ); +} + + +// XInterface + + +IMPLEMENT_FORWARD_XINTERFACE2( VCLXAccessibleCheckBox, VCLXAccessibleTextComponent, VCLXAccessibleCheckBox_BASE ) + + +// XTypeProvider + + +IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXAccessibleCheckBox, VCLXAccessibleTextComponent, VCLXAccessibleCheckBox_BASE ) + + +// XServiceInfo + + +OUString VCLXAccessibleCheckBox::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleCheckBox"; +} + + +Sequence< OUString > VCLXAccessibleCheckBox::getSupportedServiceNames() +{ + return { "com.sun.star.awt.AccessibleCheckBox" }; +} + + +// XAccessibleAction + + +sal_Int32 VCLXAccessibleCheckBox::getAccessibleActionCount( ) +{ + OExternalLockGuard aGuard( this ); + + return 1; +} + + +sal_Bool VCLXAccessibleCheckBox::doAccessibleAction ( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nIndex != 0 ) + throw IndexOutOfBoundsException(); + + VclPtr< CheckBox > pCheckBox = GetAs< CheckBox >(); + VCLXCheckBox* pVCLXCheckBox = static_cast< VCLXCheckBox* >( GetVCLXWindow() ); + if ( pCheckBox && pVCLXCheckBox ) + { + sal_Int32 nValueMax = sal_Int32(1); + + if ( pCheckBox->IsTriStateEnabled() ) + nValueMax = sal_Int32(2); + + sal_Int32 nValue = static_cast<sal_Int32>(pVCLXCheckBox->getState()); + + ++nValue; + + if ( nValue > nValueMax ) + nValue = 0; + + pVCLXCheckBox->setState( static_cast<sal_Int16>(nValue) ); + } + + return true; +} + + +OUString VCLXAccessibleCheckBox::getAccessibleActionDescription ( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nIndex != 0 ) + throw IndexOutOfBoundsException(); + + if(IsChecked()) + return AccResId( RID_STR_ACC_ACTION_UNCHECK ); + else + return AccResId( RID_STR_ACC_ACTION_CHECK ); +} + + +Reference< XAccessibleKeyBinding > VCLXAccessibleCheckBox::getAccessibleActionKeyBinding( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nIndex != 0 ) + throw IndexOutOfBoundsException(); + + rtl::Reference<OAccessibleKeyBindingHelper> pKeyBindingHelper = new OAccessibleKeyBindingHelper(); + + VclPtr<vcl::Window> pWindow = GetWindow(); + if ( pWindow ) + { + KeyEvent aKeyEvent = pWindow->GetActivationKey(); + vcl::KeyCode aKeyCode = aKeyEvent.GetKeyCode(); + if ( aKeyCode.GetCode() != 0 ) + { + awt::KeyStroke aKeyStroke; + aKeyStroke.Modifiers = 0; + if ( aKeyCode.IsShift() ) + aKeyStroke.Modifiers |= awt::KeyModifier::SHIFT; + if ( aKeyCode.IsMod1() ) + aKeyStroke.Modifiers |= awt::KeyModifier::MOD1; + if ( aKeyCode.IsMod2() ) + aKeyStroke.Modifiers |= awt::KeyModifier::MOD2; + if ( aKeyCode.IsMod3() ) + aKeyStroke.Modifiers |= awt::KeyModifier::MOD3; + aKeyStroke.KeyCode = aKeyCode.GetCode(); + aKeyStroke.KeyChar = aKeyEvent.GetCharCode(); + aKeyStroke.KeyFunc = static_cast< sal_Int16 >( aKeyCode.GetFunction() ); + pKeyBindingHelper->AddKeyBinding( aKeyStroke ); + } + } + + return pKeyBindingHelper; +} + + +// XAccessibleValue + + +Any VCLXAccessibleCheckBox::getCurrentValue( ) +{ + OExternalLockGuard aGuard( this ); + + Any aValue; + + VCLXCheckBox* pVCLXCheckBox = static_cast< VCLXCheckBox* >( GetVCLXWindow() ); + if ( pVCLXCheckBox ) + aValue <<= static_cast<sal_Int32>(pVCLXCheckBox->getState()); + + return aValue; +} + + +sal_Bool VCLXAccessibleCheckBox::setCurrentValue( const Any& aNumber ) +{ + OExternalLockGuard aGuard( this ); + + bool bReturn = false; + + VCLXCheckBox* pVCLXCheckBox = static_cast< VCLXCheckBox* >( GetVCLXWindow() ); + if ( pVCLXCheckBox ) + { + sal_Int32 nValue = 0, nValueMin = 0, nValueMax = 0; + OSL_VERIFY( aNumber >>= nValue ); + nValueMax=implGetMaximumValue(); + + if ( nValue < nValueMin ) + nValue = nValueMin; + else if ( nValue > nValueMax ) + nValue = nValueMax; + + pVCLXCheckBox->setState( static_cast<sal_Int16>(nValue) ); + bReturn = true; + } + + return bReturn; +} + + +Any VCLXAccessibleCheckBox::getMaximumValue( ) +{ + OExternalLockGuard aGuard( this ); + + Any aValue; + aValue <<= implGetMaximumValue(); + + return aValue; +} + +sal_Int32 VCLXAccessibleCheckBox::implGetMaximumValue( ) +{ + VclPtr< CheckBox > pCheckBox = GetAs< CheckBox >(); + if ( pCheckBox && pCheckBox->IsTriStateEnabled() ) + return 2; + + return 1; +} + +Any VCLXAccessibleCheckBox::getMinimumValue( ) +{ + OExternalLockGuard aGuard( this ); + + Any aValue; + aValue <<= sal_Int32(0); + + return aValue; +} + +Any VCLXAccessibleCheckBox::getMinimumIncrement( ) +{ + OExternalLockGuard aGuard( this ); + + Any aValue; + aValue <<= sal_Int32(1); + + return aValue; +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessiblecombobox.cxx b/accessibility/source/standard/vclxaccessiblecombobox.cxx new file mode 100644 index 000000000..e537f7199 --- /dev/null +++ b/accessibility/source/standard/vclxaccessiblecombobox.cxx @@ -0,0 +1,54 @@ +/* -*- 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 <standard/vclxaccessiblecombobox.hxx> +#include <vcl/window.hxx> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::accessibility; + + +VCLXAccessibleComboBox::VCLXAccessibleComboBox (VCLXWindow* pVCLWindow) + : VCLXAccessibleBox (pVCLWindow, VCLXAccessibleBox::COMBOBOX, false) +{ +} + + +bool VCLXAccessibleComboBox::IsValid() const +{ + return GetWindow(); +} + +// XServiceInfo + +OUString VCLXAccessibleComboBox::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleComboBox"; +} + + +Sequence< OUString > VCLXAccessibleComboBox::getSupportedServiceNames() +{ + return comphelper::concatSequences(VCLXAccessibleBox::getSupportedServiceNames(), + Sequence<OUString>{"com.sun.star.accessibility.AccessibleComboBox"}); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessibledropdowncombobox.cxx b/accessibility/source/standard/vclxaccessibledropdowncombobox.cxx new file mode 100644 index 000000000..97fcebb04 --- /dev/null +++ b/accessibility/source/standard/vclxaccessibledropdowncombobox.cxx @@ -0,0 +1,73 @@ +/* -*- 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 <standard/vclxaccessibledropdowncombobox.hxx> + +#include <toolkit/awt/vclxwindow.hxx> +#include <vcl/vclevent.hxx> + + +using namespace ::com::sun::star; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::accessibility; + + +VCLXAccessibleDropDownComboBox::VCLXAccessibleDropDownComboBox (VCLXWindow* pVCLWindow) + : VCLXAccessibleBox (pVCLWindow, VCLXAccessibleBox::COMBOBOX, true) +{ +} + + +bool VCLXAccessibleDropDownComboBox::IsValid() const +{ + return GetWindow(); +} + +void VCLXAccessibleDropDownComboBox::ProcessWindowEvent (const VclWindowEvent& rVclWindowEvent) +{ + switch ( rVclWindowEvent.GetId() ) + { + case VclEventId::DropdownOpen: + case VclEventId::DropdownClose: + { + break; + } + + default: + VCLXAccessibleBox::ProcessWindowEvent( rVclWindowEvent ); + } +} + + +// XServiceInfo + +OUString VCLXAccessibleDropDownComboBox::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleDropDownComboBox"; +} + + +Sequence< OUString > VCLXAccessibleDropDownComboBox::getSupportedServiceNames() +{ + return comphelper::concatSequences(VCLXAccessibleBox::getSupportedServiceNames(), + Sequence<OUString>{"com.sun.star.accessibility.AccessibleDropDownComboBox"}); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessibledropdownlistbox.cxx b/accessibility/source/standard/vclxaccessibledropdownlistbox.cxx new file mode 100644 index 000000000..641c1bdc4 --- /dev/null +++ b/accessibility/source/standard/vclxaccessibledropdownlistbox.cxx @@ -0,0 +1,51 @@ +/* -*- 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 <standard/vclxaccessibledropdownlistbox.hxx> +#include <toolkit/awt/vclxwindow.hxx> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::accessibility; + + +VCLXAccessibleDropDownListBox::VCLXAccessibleDropDownListBox (VCLXWindow* pVCLWindow) + : VCLXAccessibleBox (pVCLWindow, VCLXAccessibleBox::LISTBOX, true) +{ +} + +bool VCLXAccessibleDropDownListBox::IsValid() const +{ + return GetWindow(); +} + +// XServiceInfo +OUString VCLXAccessibleDropDownListBox::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleDropDownListBox"; +} + +Sequence< OUString > VCLXAccessibleDropDownListBox::getSupportedServiceNames() +{ + return comphelper::concatSequences(VCLXAccessibleBox::getSupportedServiceNames(), + Sequence<OUString>{"com.sun.star.accessibility.AccessibleDropDownListBox"}); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessibleedit.cxx b/accessibility/source/standard/vclxaccessibleedit.cxx new file mode 100644 index 000000000..d41c29737 --- /dev/null +++ b/accessibility/source/standard/vclxaccessibleedit.cxx @@ -0,0 +1,608 @@ +/* -*- 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 <standard/vclxaccessibleedit.hxx> + +#include <toolkit/awt/vclxwindows.hxx> +#include <toolkit/helper/convert.hxx> + +#include <unotools/accessiblestatesethelper.hxx> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/datatransfer/clipboard/XClipboard.hpp> +#include <com/sun/star/accessibility/AccessibleTextType.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <comphelper/string.hxx> +#include <vcl/svapp.hxx> +#include <vcl/window.hxx> +#include <vcl/settings.hxx> +#include <vcl/toolkit/edit.hxx> +#include <vcl/toolkit/vclmedit.hxx> +#include <vcl/textdata.hxx> +#include <vcl/txtattr.hxx> +#include <vcl/xtextedt.hxx> +#include <sot/exchange.hxx> +#include <sot/formats.hxx> + +#include <algorithm> + +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; +using namespace ::comphelper; + + +// VCLXAccessibleEdit + + +VCLXAccessibleEdit::VCLXAccessibleEdit( VCLXWindow* pVCLWindow ) + :VCLXAccessibleTextComponent( pVCLWindow ) +{ + m_nCaretPosition = getCaretPosition(); +} + + +void VCLXAccessibleEdit::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent ) +{ + switch ( rVclWindowEvent.GetId() ) + { + case VclEventId::EditModify: + { + SetText( implGetText() ); + } + break; + case VclEventId::EditCaretChanged: + { + sal_Int32 nOldCaretPosition = m_nCaretPosition; + m_nCaretPosition = getCaretPosition(); + + VclPtr<vcl::Window> pWindow = GetWindow(); + if (pWindow && pWindow->HasChildPathFocus()) + { + if (m_nCaretPosition != nOldCaretPosition) + { + Any aOldValue, aNewValue; + aOldValue <<= nOldCaretPosition; + aNewValue <<= m_nCaretPosition; + NotifyAccessibleEvent( AccessibleEventId::CARET_CHANGED, aOldValue, aNewValue ); + } + } + } + break; + case VclEventId::EditSelectionChanged: + { + VclPtr<vcl::Window> pWindow = GetWindow(); + if (pWindow && pWindow->HasChildPathFocus()) + { + NotifyAccessibleEvent( AccessibleEventId::TEXT_SELECTION_CHANGED, Any(), Any() ); + } + } + break; + default: + VCLXAccessibleTextComponent::ProcessWindowEvent( rVclWindowEvent ); + } +} + + +void VCLXAccessibleEdit::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet ) +{ + VCLXAccessibleTextComponent::FillAccessibleStateSet( rStateSet ); + + VCLXEdit* pVCLXEdit = static_cast< VCLXEdit* >( GetVCLXWindow() ); + if ( pVCLXEdit ) + { + rStateSet.AddState( AccessibleStateType::FOCUSABLE ); + rStateSet.AddState( AccessibleStateType::SINGLE_LINE ); + if ( pVCLXEdit->isEditable() ) + rStateSet.AddState( AccessibleStateType::EDITABLE ); + } +} + + +// OCommonAccessibleText + + +OUString VCLXAccessibleEdit::implGetText() +{ + OUString aText; + + VclPtr< Edit > pEdit = GetAs< Edit >(); + if ( pEdit ) + { + aText = OutputDevice::GetNonMnemonicString( pEdit->GetText() ); + + if ( implGetAccessibleRole() == AccessibleRole::PASSWORD_TEXT ) + { + sal_Unicode cEchoChar = pEdit->GetEchoChar(); + if ( !cEchoChar ) + cEchoChar = '*'; + OUStringBuffer sTmp(aText.getLength()); + aText = comphelper::string::padToLength(sTmp, aText.getLength(), + cEchoChar).makeStringAndClear(); + } + } + + return aText; +} + + +void VCLXAccessibleEdit::implGetSelection( sal_Int32& nStartIndex, sal_Int32& nEndIndex ) +{ + awt::Selection aSelection; + VCLXEdit* pVCLXEdit = static_cast< VCLXEdit* >( GetVCLXWindow() ); + if ( pVCLXEdit ) + aSelection = pVCLXEdit->getSelection(); + + nStartIndex = aSelection.Min; + nEndIndex = aSelection.Max; +} + + +// XInterface + + +IMPLEMENT_FORWARD_XINTERFACE2( VCLXAccessibleEdit, VCLXAccessibleTextComponent, VCLXAccessibleEdit_BASE ) + + +// XTypeProvider + + +IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXAccessibleEdit, VCLXAccessibleTextComponent, VCLXAccessibleEdit_BASE ) + + +// XServiceInfo + + +OUString VCLXAccessibleEdit::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleEdit"; +} + + +Sequence< OUString > VCLXAccessibleEdit::getSupportedServiceNames() +{ + return { "com.sun.star.awt.AccessibleEdit" }; +} + + +// XAccessibleContext + + +sal_Int32 VCLXAccessibleEdit::getAccessibleChildCount() +{ + OExternalLockGuard aGuard( this ); + + return 0; +} + + +Reference< XAccessible > VCLXAccessibleEdit::getAccessibleChild( sal_Int32 ) +{ + throw IndexOutOfBoundsException(); +} + + +sal_Int16 VCLXAccessibleEdit::getAccessibleRole( ) +{ + OExternalLockGuard aGuard( this ); + + return implGetAccessibleRole(); +} + +sal_Int16 VCLXAccessibleEdit::implGetAccessibleRole( ) +{ + sal_Int16 nRole; + VclPtr< Edit > pEdit = GetAs< Edit >(); + if ( pEdit && ( pEdit->IsPassword() || pEdit->GetEchoChar() ) ) + nRole = AccessibleRole::PASSWORD_TEXT; + else if ( pEdit && ( pEdit->GetStyle() & WB_READONLY ) ) + nRole = AccessibleRole::STATIC; + else + nRole = AccessibleRole::TEXT; + + return nRole; +} + + +// XAccessibleAction + + +sal_Int32 VCLXAccessibleEdit::getAccessibleActionCount( ) +{ + OExternalLockGuard aGuard( this ); + + // There is one action: activate + return 1; +} + + +sal_Bool VCLXAccessibleEdit::doAccessibleAction ( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nIndex != 0 ) + throw IndexOutOfBoundsException(); + + bool bDoAction = false; + VclPtr<vcl::Window> pWindow = GetWindow(); + if ( pWindow ) + { + pWindow->GrabFocus(); + bDoAction = true; + } + + return bDoAction; +} + + +OUString VCLXAccessibleEdit::getAccessibleActionDescription ( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nIndex != 0) + throw IndexOutOfBoundsException(); + + return "activate"; +} + + +Reference< XAccessibleKeyBinding > VCLXAccessibleEdit::getAccessibleActionKeyBinding( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nIndex != 0 ) + throw IndexOutOfBoundsException(); + + return Reference< XAccessibleKeyBinding >(); +} + + +// XAccessibleText + + +sal_Int32 VCLXAccessibleEdit::getCaretPosition( ) +{ + return getSelectionEnd(); +} + + +sal_Bool VCLXAccessibleEdit::setCaretPosition( sal_Int32 nIndex ) +{ + return setSelection( nIndex, nIndex ); +} + + +sal_Unicode VCLXAccessibleEdit::getCharacter( sal_Int32 nIndex ) +{ + return VCLXAccessibleTextComponent::getCharacter( nIndex ); +} + + +Sequence< PropertyValue > VCLXAccessibleEdit::getCharacterAttributes( sal_Int32 nIndex, const Sequence< OUString >& aRequestedAttributes ) +{ + OExternalLockGuard aGuard( this ); + Sequence< PropertyValue > aProperties = VCLXAccessibleTextComponent::getCharacterAttributes( nIndex, aRequestedAttributes ); + auto aNonConstRange = asNonConstRange(aProperties); + + // Handle multiline edit character properties + VclPtr<VclMultiLineEdit> pMulitLineEdit = GetAsDynamic< VclMultiLineEdit >(); + if ( pMulitLineEdit ) + { + ExtTextEngine* pTextEngine = pMulitLineEdit->GetTextEngine(); + TextPaM aCursor( 0, nIndex ); + const TextAttribFontColor* pFontColor = static_cast<const TextAttribFontColor* >(pTextEngine->FindAttrib( aCursor, TEXTATTR_FONTCOLOR )); + if ( pFontColor ) + { + for (PropertyValue& aValue : aNonConstRange ) + { + if (aValue.Name == "CharColor") + { + aValue.Value <<= pFontColor->GetColor().GetRGBColor(); + break; + } + } + } + } + + // Set default character color if it is not set yet to a valid value + for (PropertyValue& aValue : aNonConstRange ) + { + if (aValue.Name == "CharColor") + { + if ( aValue.Value == sal_Int32(-1) ) + { + OutputDevice* pDev = Application::GetDefaultDevice(); + if ( pDev ) + { + aValue.Value <<= pDev->GetSettings().GetStyleSettings().GetFieldTextColor(); + } + } + break; + } + } + + return aProperties; +} + + +awt::Rectangle VCLXAccessibleEdit::getCharacterBounds( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + awt::Rectangle aBounds( 0, 0, 0, 0 ); + sal_Int32 nLength = implGetText().getLength(); + + if ( !implIsValidRange( nIndex, nIndex, nLength ) ) + throw IndexOutOfBoundsException(); + + VclPtr< Control > pControl = GetAs< Control >(); + if ( pControl ) + { + if ( nIndex == nLength ) + { + // #108914# calculate virtual bounding rectangle + for ( sal_Int32 i = 0; i < nLength; ++i ) + { + tools::Rectangle aRect = pControl->GetCharacterBounds( i ); + sal_Int32 nHeight = aRect.GetHeight(); + if ( aBounds.Height < nHeight ) + { + aBounds.Y = aRect.Top(); + aBounds.Height = nHeight; + } + if ( i == nLength - 1 ) + { + aBounds.X = aRect.Right() + 1; + aBounds.Width = 1; + } + } + } + else + { + aBounds = AWTRectangle( pControl->GetCharacterBounds( nIndex ) ); + } + } + + return aBounds; +} + + +sal_Int32 VCLXAccessibleEdit::getCharacterCount( ) +{ + return VCLXAccessibleTextComponent::getCharacterCount(); +} + + +sal_Int32 VCLXAccessibleEdit::getIndexAtPoint( const awt::Point& aPoint ) +{ + return VCLXAccessibleTextComponent::getIndexAtPoint( aPoint ); +} + + +OUString VCLXAccessibleEdit::getSelectedText( ) +{ + return VCLXAccessibleTextComponent::getSelectedText(); +} + + +sal_Int32 VCLXAccessibleEdit::getSelectionStart( ) +{ + return VCLXAccessibleTextComponent::getSelectionStart(); +} + + +sal_Int32 VCLXAccessibleEdit::getSelectionEnd( ) +{ + return VCLXAccessibleTextComponent::getSelectionEnd(); +} + + +sal_Bool VCLXAccessibleEdit::setSelection( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) +{ + OExternalLockGuard aGuard( this ); + + bool bReturn = false; + OUString sText( implGetText() ); + + if ( !implIsValidRange( nStartIndex, nEndIndex, sText.getLength() ) ) + throw IndexOutOfBoundsException(); + + VCLXEdit* pVCLXEdit = static_cast< VCLXEdit* >( GetVCLXWindow() ); + VclPtr< Edit > pEdit = GetAs< Edit >(); + if ( pVCLXEdit && pEdit && pEdit->IsEnabled() ) + { + pVCLXEdit->setSelection( awt::Selection( nStartIndex, nEndIndex ) ); + bReturn = true; + } + + return bReturn; +} + + +OUString VCLXAccessibleEdit::getText( ) +{ + return VCLXAccessibleTextComponent::getText(); +} + + +OUString VCLXAccessibleEdit::getTextRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) +{ + return VCLXAccessibleTextComponent::getTextRange( nStartIndex, nEndIndex ); +} + + +css::accessibility::TextSegment VCLXAccessibleEdit::getTextAtIndex( sal_Int32 nIndex, sal_Int16 aTextType ) +{ + OExternalLockGuard aGuard( this ); + // Override general text component behavior: MultiLineEdit can have more text portions + if ( aTextType == AccessibleTextType::ATTRIBUTE_RUN ) + { + VclPtr<VclMultiLineEdit> pMulitLineEdit = GetAsDynamic< VclMultiLineEdit >(); + if ( pMulitLineEdit ) + { + ExtTextEngine* pTextEngine = pMulitLineEdit->GetTextEngine(); + TextPaM aCursor( 0, nIndex ); + TextSegment aResult; + pTextEngine->GetTextPortionRange( aCursor, aResult.SegmentStart, aResult.SegmentEnd ); + return aResult; + } + } + + return VCLXAccessibleTextComponent::getTextAtIndex( nIndex, aTextType ); +} + + +css::accessibility::TextSegment VCLXAccessibleEdit::getTextBeforeIndex( sal_Int32 nIndex, sal_Int16 aTextType ) +{ + return VCLXAccessibleTextComponent::getTextBeforeIndex( nIndex, aTextType ); +} + + +css::accessibility::TextSegment VCLXAccessibleEdit::getTextBehindIndex( sal_Int32 nIndex, sal_Int16 aTextType ) +{ + return VCLXAccessibleTextComponent::getTextBehindIndex( nIndex, aTextType ); +} + + +sal_Bool VCLXAccessibleEdit::copyText( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) +{ + return VCLXAccessibleTextComponent::copyText( nStartIndex, nEndIndex ); +} + +sal_Bool VCLXAccessibleEdit::scrollSubstringTo( sal_Int32, sal_Int32, AccessibleScrollType ) +{ + return false; +} + +// XAccessibleEditableText + + +sal_Bool VCLXAccessibleEdit::cutText( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) +{ + return copyText( nStartIndex, nEndIndex ) && deleteText( nStartIndex, nEndIndex ); +} + + +sal_Bool VCLXAccessibleEdit::pasteText( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + bool bReturn = false; + + if ( GetWindow() ) + { + Reference< datatransfer::clipboard::XClipboard > xClipboard = GetWindow()->GetClipboard(); + if ( xClipboard.is() ) + { + Reference< datatransfer::XTransferable > xDataObj; + { + SolarMutexReleaser aReleaser; + xDataObj = xClipboard->getContents(); + } + if ( xDataObj.is() ) + { + datatransfer::DataFlavor aFlavor; + SotExchange::GetFormatDataFlavor( SotClipboardFormatId::STRING, aFlavor ); + if ( xDataObj->isDataFlavorSupported( aFlavor ) ) + { + Any aData = xDataObj->getTransferData( aFlavor ); + OUString sText; + aData >>= sText; + bReturn = replaceText( nIndex, nIndex, sText ); + } + } + } + } + + return bReturn; +} + + +sal_Bool VCLXAccessibleEdit::deleteText( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) +{ + return replaceText( nStartIndex, nEndIndex, OUString() ); +} + + +sal_Bool VCLXAccessibleEdit::insertText( const OUString& sText, sal_Int32 nIndex ) +{ + return replaceText( nIndex, nIndex, sText ); +} + + +sal_Bool VCLXAccessibleEdit::replaceText( sal_Int32 nStartIndex, sal_Int32 nEndIndex, const OUString& sReplacement ) +{ + OExternalLockGuard aGuard( this ); + + bool bReturn = false; + OUString sText( implGetText() ); + + if ( !implIsValidRange( nStartIndex, nEndIndex, sText.getLength() ) ) + throw IndexOutOfBoundsException(); + + sal_Int32 nMinIndex = std::min( nStartIndex, nEndIndex ); + sal_Int32 nMaxIndex = std::max( nStartIndex, nEndIndex ); + + VCLXEdit* pVCLXEdit = static_cast< VCLXEdit* >( GetVCLXWindow() ); + if ( pVCLXEdit && pVCLXEdit->isEditable() ) + { + pVCLXEdit->setText( sText.replaceAt( nMinIndex, nMaxIndex - nMinIndex, sReplacement ) ); + sal_Int32 nIndex = nMinIndex + sReplacement.getLength(); + setSelection( nIndex, nIndex ); + bReturn = true; + } + + return bReturn; +} + + +sal_Bool VCLXAccessibleEdit::setAttributes( sal_Int32 nStartIndex, sal_Int32 nEndIndex, const Sequence<PropertyValue>& ) +{ + OExternalLockGuard aGuard( this ); + + if ( !implIsValidRange( nStartIndex, nEndIndex, implGetText().getLength() ) ) + throw IndexOutOfBoundsException(); + + return false; // attributes cannot be set for an edit +} + + +sal_Bool VCLXAccessibleEdit::setText( const OUString& sText ) +{ + OExternalLockGuard aGuard( this ); + + bool bReturn = false; + + VCLXEdit* pVCLXEdit = static_cast< VCLXEdit* >( GetVCLXWindow() ); + if ( pVCLXEdit && pVCLXEdit->isEditable() ) + { + pVCLXEdit->setText( sText ); + sal_Int32 nSize = sText.getLength(); + pVCLXEdit->setSelection( awt::Selection( nSize, nSize ) ); + bReturn = true; + } + + return bReturn; +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessiblefixedhyperlink.cxx b/accessibility/source/standard/vclxaccessiblefixedhyperlink.cxx new file mode 100644 index 000000000..9e2874365 --- /dev/null +++ b/accessibility/source/standard/vclxaccessiblefixedhyperlink.cxx @@ -0,0 +1,38 @@ +/* -*- 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 <standard/vclxaccessiblefixedhyperlink.hxx> + +using namespace ::com::sun::star; + +// VCLXAccessibleFixedHyperlink + +// XServiceInfo + +OUString VCLXAccessibleFixedHyperlink::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleFixedHyperlink"; +} + +uno::Sequence<OUString> VCLXAccessibleFixedHyperlink::getSupportedServiceNames() +{ + return { "com.sun.star.awt.AccessibleFixedHyperlink" }; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessiblefixedtext.cxx b/accessibility/source/standard/vclxaccessiblefixedtext.cxx new file mode 100644 index 000000000..b62faded5 --- /dev/null +++ b/accessibility/source/standard/vclxaccessiblefixedtext.cxx @@ -0,0 +1,54 @@ +/* -*- 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 <standard/vclxaccessiblefixedtext.hxx> + +#include <unotools/accessiblestatesethelper.hxx> +#include <vcl/window.hxx> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> + +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; + +// VCLXAccessibleFixedText + +void VCLXAccessibleFixedText::FillAccessibleStateSet(utl::AccessibleStateSetHelper& rStateSet) +{ + VCLXAccessibleTextComponent::FillAccessibleStateSet(rStateSet); + + if (GetWindow() && GetWindow()->GetStyle() & WB_WORDBREAK) + rStateSet.AddState(AccessibleStateType::MULTI_LINE); +} + +// XServiceInfo + +OUString VCLXAccessibleFixedText::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleFixedText"; +} + +Sequence<OUString> VCLXAccessibleFixedText::getSupportedServiceNames() +{ + return { "com.sun.star.awt.AccessibleFixedText" }; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessibleheaderbar.cxx b/accessibility/source/standard/vclxaccessibleheaderbar.cxx new file mode 100644 index 000000000..de5208b35 --- /dev/null +++ b/accessibility/source/standard/vclxaccessibleheaderbar.cxx @@ -0,0 +1,130 @@ +/* -*- 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 <standard/vclxaccessibleheaderbar.hxx> +#include <standard/vclxaccessibleheaderbaritem.hxx> + +#include <o3tl/safeint.hxx> +#include <vcl/headbar.hxx> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <vcl/svapp.hxx> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::awt; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::accessibility; +using namespace ::comphelper; + +VCLXAccessibleHeaderBar::VCLXAccessibleHeaderBar(VCLXWindow* pVCLWindow) + : VCLXAccessibleComponent(pVCLWindow) +{ + m_pHeadBar = GetAs<HeaderBar>(); +} + +VCLXAccessibleHeaderBar::~VCLXAccessibleHeaderBar() {} + +// XServiceInfo + +OUString VCLXAccessibleHeaderBar::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleHeaderBar"; +} + +Sequence<OUString> VCLXAccessibleHeaderBar::getSupportedServiceNames() +{ + return { "com.sun.star.awt.AccessibleHeaderBar" }; +} + +// =======XAccessibleContext======= + +sal_Int32 SAL_CALL VCLXAccessibleHeaderBar::getAccessibleChildCount() +{ + SolarMutexGuard g; + + sal_Int32 nCount = 0; + if (m_pHeadBar) + nCount = m_pHeadBar->GetItemCount(); + + return nCount; +} +css::uno::Reference<css::accessibility::XAccessible> + SAL_CALL VCLXAccessibleHeaderBar::getAccessibleChild(sal_Int32 i) +{ + SolarMutexGuard g; + + if (i < 0 || i >= getAccessibleChildCount()) + throw IndexOutOfBoundsException(); + + Reference<XAccessible> xChild; + // search for the child + if (o3tl::make_unsigned(i) >= m_aAccessibleChildren.size()) + xChild = CreateChild(i); + else + { + xChild = m_aAccessibleChildren[i]; + if (!xChild.is()) + xChild = CreateChild(i); + } + return xChild; +} + +sal_Int16 SAL_CALL VCLXAccessibleHeaderBar::getAccessibleRole() +{ + return css::accessibility::AccessibleRole::LIST; +} + +void SAL_CALL VCLXAccessibleHeaderBar::disposing() +{ + SolarMutexGuard g; + + ListItems().swap(m_aAccessibleChildren); + VCLXAccessibleComponent::disposing(); +} + +css::uno::Reference<css::accessibility::XAccessible> +VCLXAccessibleHeaderBar::CreateChild(sal_Int32 i) +{ + Reference<XAccessible> xChild; + + sal_uInt16 nPos = static_cast<sal_uInt16>(i); + if (nPos >= m_aAccessibleChildren.size()) + { + m_aAccessibleChildren.resize(nPos + 1); + + // insert into the container + xChild = new VCLXAccessibleHeaderBarItem(m_pHeadBar, i); + m_aAccessibleChildren[nPos] = xChild; + } + else + { + xChild = m_aAccessibleChildren[nPos]; + // check if position is empty and can be used else we have to adjust all entries behind this + if (!xChild.is()) + { + xChild = new VCLXAccessibleHeaderBarItem(m_pHeadBar, i); + m_aAccessibleChildren[nPos] = xChild; + } + } + return xChild; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessibleheaderbaritem.cxx b/accessibility/source/standard/vclxaccessibleheaderbaritem.cxx new file mode 100644 index 000000000..5c9bf5c9a --- /dev/null +++ b/accessibility/source/standard/vclxaccessibleheaderbaritem.cxx @@ -0,0 +1,265 @@ +/* -*- 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 <standard/vclxaccessibleheaderbaritem.hxx> + +#include <vcl/headbar.hxx> + +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <cppuhelper/supportsservice.hxx> + +#include <unotools/accessiblestatesethelper.hxx> +#include <unotools/accessiblerelationsethelper.hxx> +#include <vcl/svapp.hxx> +#include <vcl/settings.hxx> +#include <toolkit/helper/convert.hxx> +#include <i18nlangtag/languagetag.hxx> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::accessibility; +using namespace ::comphelper; + + + + +VCLXAccessibleHeaderBarItem::VCLXAccessibleHeaderBarItem( HeaderBar* pHeadBar, sal_Int32 _nIndexInParent ) + :m_pHeadBar( pHeadBar ) + ,m_nIndexInParent(_nIndexInParent + 1) + +{ +} + +VCLXAccessibleHeaderBarItem::~VCLXAccessibleHeaderBarItem() +{ +} + +void VCLXAccessibleHeaderBarItem::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet ) +{ + if ( m_pHeadBar ) + { + if ( m_pHeadBar->IsEnabled() ) + rStateSet.AddState( AccessibleStateType::ENABLED ); + + if ( m_pHeadBar->IsVisible() ) + { + rStateSet.AddState( AccessibleStateType::VISIBLE ); + } + rStateSet.AddState( AccessibleStateType::SELECTABLE ); + rStateSet.AddState( AccessibleStateType::RESIZABLE ); + } +} + +// OCommonAccessibleComponent +awt::Rectangle VCLXAccessibleHeaderBarItem::implGetBounds() +{ + awt::Rectangle aBounds; + OExternalLockGuard aGuard( this ); + + if ( m_pHeadBar ) + aBounds = AWTRectangle( m_pHeadBar->GetItemRect( sal_uInt16( m_nIndexInParent ) ) ); + + return aBounds; +} + + +// XInterface + + +IMPLEMENT_FORWARD_XINTERFACE2( VCLXAccessibleHeaderBarItem, OAccessibleExtendedComponentHelper, VCLXAccessibleHeaderBarItem_BASE ) + + +// XTypeProvider + + +IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXAccessibleHeaderBarItem, OAccessibleExtendedComponentHelper, VCLXAccessibleHeaderBarItem_BASE ) + + +// XServiceInfo +OUString VCLXAccessibleHeaderBarItem::getImplementationName() +{ + return "com.sun.star.comp.svtools.AccessibleHeaderBarItem"; +} + +sal_Bool VCLXAccessibleHeaderBarItem::supportsService( const OUString& rServiceName ) +{ + return cppu::supportsService( this, rServiceName ); +} + +Sequence< OUString > VCLXAccessibleHeaderBarItem::getSupportedServiceNames() +{ + return { "com.sun.star.awt.AccessibleHeaderBarItem" }; +} + +// XAccessible +Reference< XAccessibleContext > VCLXAccessibleHeaderBarItem::getAccessibleContext() +{ + return this; +} + + +// XAccessibleContext + + +sal_Int32 VCLXAccessibleHeaderBarItem::getAccessibleChildCount() +{ + return 0; +} + + +Reference< XAccessible > VCLXAccessibleHeaderBarItem::getAccessibleChild( sal_Int32 i ) +{ + OExternalLockGuard aGuard( this ); + + if ( i < 0 || i >= getAccessibleChildCount() ) + throw IndexOutOfBoundsException(); + + return Reference< XAccessible >(); +} + + +Reference< XAccessible > VCLXAccessibleHeaderBarItem::getAccessibleParent() +{ + OExternalLockGuard aGuard( this ); + + Reference< XAccessible > xParent; + if ( m_pHeadBar ) + { + xParent = m_pHeadBar->GetAccessible(); + } + + return xParent; +} + + +sal_Int32 VCLXAccessibleHeaderBarItem::getAccessibleIndexInParent() +{ + OExternalLockGuard aGuard( this ); + return m_nIndexInParent - 1; +} + + +sal_Int16 VCLXAccessibleHeaderBarItem::getAccessibleRole() +{ + return AccessibleRole::COLUMN_HEADER; +} + + +OUString VCLXAccessibleHeaderBarItem::getAccessibleDescription() +{ + return OUString(); +} + + +OUString VCLXAccessibleHeaderBarItem::getAccessibleName() +{ + OExternalLockGuard aGuard( this ); + + OUString sName; + if(m_pHeadBar) + sName = m_pHeadBar->GetItemText( sal_uInt16( m_nIndexInParent ) ); + return sName; +} + + +Reference< XAccessibleRelationSet > VCLXAccessibleHeaderBarItem::getAccessibleRelationSet( ) +{ + OExternalLockGuard aGuard( this ); + + return new utl::AccessibleRelationSetHelper; +} + + +Reference< XAccessibleStateSet > VCLXAccessibleHeaderBarItem::getAccessibleStateSet( ) +{ + OExternalLockGuard aGuard( this ); + + rtl::Reference<utl::AccessibleStateSetHelper> pStateSetHelper = new utl::AccessibleStateSetHelper; + + if ( !rBHelper.bDisposed && !rBHelper.bInDispose ) + { + FillAccessibleStateSet( *pStateSetHelper ); + } + else + { + pStateSetHelper->AddState( AccessibleStateType::DEFUNC ); + } + + return pStateSetHelper; +} + + +css::lang::Locale VCLXAccessibleHeaderBarItem::getLocale() +{ + OExternalLockGuard aGuard( this ); + + return Application::GetSettings().GetLanguageTag().getLocale(); +} + + +// XAccessibleComponent + + +Reference< XAccessible > VCLXAccessibleHeaderBarItem::getAccessibleAtPoint( const awt::Point& ) +{ + return Reference< XAccessible >(); +} + + +sal_Int32 VCLXAccessibleHeaderBarItem::getForeground() +{ + return 0; +} + + +sal_Int32 VCLXAccessibleHeaderBarItem::getBackground() +{ + return 0; +} + + +// XAccessibleExtendedComponent + + +Reference< awt::XFont > VCLXAccessibleHeaderBarItem::getFont() +{ + return Reference< awt::XFont >(); +} + + +OUString VCLXAccessibleHeaderBarItem::getTitledBorderText() +{ + return OUString(); +} + + +OUString VCLXAccessibleHeaderBarItem::getToolTipText() +{ + OExternalLockGuard aGuard( this ); + + OUString sText; + if ( m_pHeadBar ) + sText = m_pHeadBar->GetQuickHelpText(); + + return sText; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessiblelist.cxx b/accessibility/source/standard/vclxaccessiblelist.cxx new file mode 100644 index 000000000..bb81350f5 --- /dev/null +++ b/accessibility/source/standard/vclxaccessiblelist.cxx @@ -0,0 +1,942 @@ +/* -*- 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 <standard/vclxaccessiblelist.hxx> +#include <standard/vclxaccessiblelistitem.hxx> +#include <helper/listboxhelper.hxx> + +#include <unotools/accessiblerelationsethelper.hxx> +#include <unotools/accessiblestatesethelper.hxx> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/accessibility/AccessibleRelationType.hpp> +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <o3tl/safeint.hxx> +#include <vcl/svapp.hxx> +#include <vcl/toolkit/combobox.hxx> +#include <vcl/toolkit/lstbox.hxx> +#include <toolkit/helper/convert.hxx> + +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; +using namespace ::accessibility; + +namespace +{ + /// @throws css::lang::IndexOutOfBoundsException + void checkSelection_Impl( sal_Int32 _nIndex, const IComboListBoxHelper& _rListBox, bool bSelected ) + { + sal_Int32 nCount = bSelected ? _rListBox.GetSelectedEntryCount() + : _rListBox.GetEntryCount(); + if ( _nIndex < 0 || _nIndex >= nCount ) + throw css::lang::IndexOutOfBoundsException(); + } +} + +VCLXAccessibleList::VCLXAccessibleList (VCLXWindow* pVCLWindow, BoxType aBoxType, + const Reference< XAccessible >& _xParent) + : VCLXAccessibleComponent (pVCLWindow), + m_aBoxType (aBoxType), + m_nVisibleLineCount (0), + m_nIndexInParent (DEFAULT_INDEX_IN_PARENT), + m_nLastTopEntry ( 0 ), + m_nLastSelectedPos ( LISTBOX_ENTRY_NOTFOUND ), + m_bDisableProcessEvent ( false ), + m_bVisible ( true ), + m_nCurSelectedPos ( LISTBOX_ENTRY_NOTFOUND ), + m_xParent ( _xParent ) +{ + // Because combo boxes and list boxes don't have a common interface for + // methods with identical signature we have to write down twice the + // same code. + switch (m_aBoxType) + { + case COMBOBOX: + { + VclPtr< ComboBox > pBox = GetAs< ComboBox >(); + if ( pBox ) + m_pListBoxHelper.reset( new VCLListBoxHelper<ComboBox> (*pBox) ); + break; + } + + case LISTBOX: + { + VclPtr< ListBox > pBox = GetAs< ListBox >(); + if ( pBox ) + m_pListBoxHelper.reset( new VCLListBoxHelper<ListBox> (*pBox) ); + break; + } + } + UpdateVisibleLineCount(); + if(m_pListBoxHelper) + { + m_nCurSelectedPos=m_pListBoxHelper->GetSelectedEntryPos(0); + } + sal_uInt16 nCount = static_cast<sal_uInt16>(getAccessibleChildCount()); + m_aAccessibleChildren.reserve(nCount); +} + + +void VCLXAccessibleList::SetIndexInParent (sal_Int32 nIndex) +{ + m_nIndexInParent = nIndex; +} + + +void SAL_CALL VCLXAccessibleList::disposing() +{ + VCLXAccessibleComponent::disposing(); + + // Dispose all items in the list. + m_aAccessibleChildren.clear(); + + m_pListBoxHelper.reset(); +} + + +void VCLXAccessibleList::FillAccessibleStateSet (utl::AccessibleStateSetHelper& rStateSet) +{ + SolarMutexGuard aSolarGuard; + + VCLXAccessibleComponent::FillAccessibleStateSet( rStateSet ); + // check if our list should be visible + if ( m_pListBoxHelper + && (m_pListBoxHelper->GetStyle() & WB_DROPDOWN ) == WB_DROPDOWN + && !m_pListBoxHelper->IsInDropDown() ) + { + rStateSet.RemoveState (AccessibleStateType::VISIBLE); + rStateSet.RemoveState (AccessibleStateType::SHOWING); + m_bVisible = false; + } + + // Both the combo box and list box are handled identical in the + // following but for some reason they don't have a common interface for + // the methods used. + if ( m_pListBoxHelper ) + { + if ( m_pListBoxHelper->IsMultiSelectionEnabled() ) + rStateSet.AddState( AccessibleStateType::MULTI_SELECTABLE); + rStateSet.AddState (AccessibleStateType::FOCUSABLE); + // All children are transient. + rStateSet.AddState (AccessibleStateType::MANAGES_DESCENDANTS); + } +} + +void VCLXAccessibleList::notifyVisibleStates(bool _bSetNew ) +{ + m_bVisible = _bSetNew; + Any aOldValue, aNewValue; + (_bSetNew ? aNewValue : aOldValue ) <<= AccessibleStateType::VISIBLE; + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue ); + (_bSetNew ? aNewValue : aOldValue ) <<= AccessibleStateType::SHOWING; + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue ); + + ListItems::iterator aIter = m_aAccessibleChildren.begin(); + UpdateVisibleLineCount(); + // adjust the index inside the VCLXAccessibleListItem + for ( ; aIter != m_aAccessibleChildren.end(); ) + { + Reference< XAccessible > xHold = *aIter; + if (!xHold.is()) + { + aIter = m_aAccessibleChildren.erase(aIter); + } + else + { + VCLXAccessibleListItem* pItem = static_cast<VCLXAccessibleListItem*>(xHold.get()); + const sal_Int32 nTopEntry = m_pListBoxHelper ? m_pListBoxHelper->GetTopEntry() : 0; + const sal_Int32 nPos = static_cast<sal_Int32>(aIter - m_aAccessibleChildren.begin()); + bool bVisible = ( nPos>=nTopEntry && nPos<( nTopEntry + m_nVisibleLineCount ) ); + pItem->SetVisible( m_bVisible && bVisible ); + ++aIter; + } + + } +} + +void VCLXAccessibleList::UpdateSelection_Acc (std::u16string_view /*sTextOfSelectedItem*/, bool b_IsDropDownList) +{ + if ( m_aBoxType != COMBOBOX ) + return; + + /* FIXME: is there something missing here? nIndex is unused. Looks like + * copy-paste from VCLXAccessibleList::UpdateSelection() */ + // VclPtr< ComboBox > pBox = GetAs< ComboBox >(); + // if ( pBox ) + // { + // // Find the index of the selected item inside the VCL control... + // sal_Int32 nIndex = pBox->GetEntryPos(sTextOfSelectedItem); + // // ...and then find the associated accessibility object. + // if ( nIndex == LISTBOX_ENTRY_NOTFOUND ) + // nIndex = 0; + UpdateSelection_Impl_Acc(b_IsDropDownList); + // } +} + + +void VCLXAccessibleList::UpdateSelection_Impl_Acc(bool bHasDropDownList) +{ + uno::Any aOldValue, aNewValue; + + { + SolarMutexGuard aSolarGuard; + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + Reference< XAccessible > xNewAcc; + if ( m_pListBoxHelper ) + { + sal_Int32 i=0; + m_nCurSelectedPos = LISTBOX_ENTRY_NOTFOUND; + for ( const auto& rChild : m_aAccessibleChildren ) + { + Reference< XAccessible > xHold = rChild; + if ( xHold.is() ) + { + VCLXAccessibleListItem* pItem = static_cast< VCLXAccessibleListItem* >( xHold.get() ); + // Retrieve the item's index from the list entry. + bool bNowSelected = m_pListBoxHelper->IsEntryPosSelected (i); + if (bNowSelected) + m_nCurSelectedPos = i; + + if ( bNowSelected && !pItem->IsSelected() ) + { + xNewAcc = rChild; + aNewValue <<= xNewAcc; + } + else if ( pItem->IsSelected() ) + m_nLastSelectedPos = i; + + pItem->SetSelected( bNowSelected ); + } + else + { // it could happen that a child was not created before + checkEntrySelected(i,aNewValue,xNewAcc); + } + ++i; + } + const sal_Int32 nCount = m_pListBoxHelper->GetEntryCount(); + if ( i < nCount ) // here we have to check the if any other listbox entry is selected + { + for (; i < nCount && !checkEntrySelected(i,aNewValue,xNewAcc) ;++i ) + ; + } + if ( xNewAcc.is() && GetWindow()->HasFocus() ) + { + if ( m_nLastSelectedPos != LISTBOX_ENTRY_NOTFOUND ) + aOldValue <<= getAccessibleChild( m_nLastSelectedPos ); + aNewValue <<= xNewAcc; + } + } + } + + if (m_aBoxType == COMBOBOX) + { + //VCLXAccessibleDropDownComboBox + //when in list is dropped down, xText = NULL + if (bHasDropDownList && m_pListBoxHelper && m_pListBoxHelper->IsInDropDown()) + { + if ( aNewValue.hasValue() || aOldValue.hasValue() ) + { + NotifyAccessibleEvent( + AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, + aOldValue, + aNewValue ); + + NotifyListItem(aNewValue); + } + } + else + { + //VCLXAccessibleComboBox + NotifyAccessibleEvent( AccessibleEventId::SELECTION_CHANGED, uno::Any(), uno::Any() ); + } + } + else if (m_aBoxType == LISTBOX) + { + if ( aNewValue.hasValue() || aOldValue.hasValue() ) + { + NotifyAccessibleEvent( + AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, + aOldValue, + aNewValue ); + + NotifyListItem(aNewValue); + } + } +} + +void VCLXAccessibleList::NotifyListItem(css::uno::Any const & val) +{ + Reference< XAccessible > xCurItem; + val >>= xCurItem; + if (xCurItem.is()) + { + VCLXAccessibleListItem* pCurItem = static_cast< VCLXAccessibleListItem* >(xCurItem.get()); + if (pCurItem) + { + pCurItem->NotifyAccessibleEvent(AccessibleEventId::SELECTION_CHANGED,Any(),Any()); + } + } +} + +void VCLXAccessibleList::ProcessWindowEvent (const VclWindowEvent& rVclWindowEvent, bool b_IsDropDownList) +{ + switch ( rVclWindowEvent.GetId() ) + { + case VclEventId::DropdownSelect: + case VclEventId::ListboxSelect: + if ( !m_bDisableProcessEvent ) + UpdateSelection_Impl_Acc(b_IsDropDownList); + break; + case VclEventId::WindowGetFocus: + break; + case VclEventId::ControlGetFocus: + { + VCLXAccessibleComponent::ProcessWindowEvent (rVclWindowEvent); + if (m_aBoxType == COMBOBOX && b_IsDropDownList) + { + //VCLXAccessibleDropDownComboBox + } + else if (m_aBoxType == LISTBOX && b_IsDropDownList) + { + } + else if ( m_aBoxType == LISTBOX && !b_IsDropDownList) + { + if ( m_pListBoxHelper ) + { + uno::Any aOldValue, + aNewValue; + sal_Int32 nPos = m_nCurSelectedPos; //m_pListBoxHelper->GetSelectedEntryPos(); + + if ( nPos == LISTBOX_ENTRY_NOTFOUND ) + nPos = m_pListBoxHelper->GetTopEntry(); + if ( nPos != LISTBOX_ENTRY_NOTFOUND ) + aNewValue <<= CreateChild(nPos); + NotifyAccessibleEvent( AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, + aOldValue, + aNewValue ); + } + } + } + break; + default: + break; + } + +} + +void VCLXAccessibleList::ProcessWindowEvent (const VclWindowEvent& rVclWindowEvent) +{ + // Create a reference to this object to prevent an early release of the + // listbox (VclEventId::ObjectDying). + Reference< XAccessible > xHoldAlive = this; + + switch ( rVclWindowEvent.GetId() ) + { + case VclEventId::DropdownOpen: + notifyVisibleStates(true); + break; + case VclEventId::DropdownClose: + notifyVisibleStates(false); + break; + case VclEventId::ListboxScrolled: + UpdateEntryRange_Impl(); + break; + + // The selection events VclEventId::ComboboxSelect and + // VclEventId::ComboboxDeselect are not handled here because here we + // have no access to the edit field. Its text is necessary to + // identify the currently selected item. + + case VclEventId::ObjectDying: + { + dispose(); + + VCLXAccessibleComponent::ProcessWindowEvent (rVclWindowEvent); + break; + } + + case VclEventId::ListboxItemRemoved: + case VclEventId::ComboboxItemRemoved: + case VclEventId::ListboxItemAdded: + case VclEventId::ComboboxItemAdded: + HandleChangedItemList(); + break; + case VclEventId::ControlGetFocus: + { + VCLXAccessibleComponent::ProcessWindowEvent (rVclWindowEvent); + // Added by IBM Symphony Acc team to handle the list item focus when List control get focus + bool b_IsDropDownList = true; + if (m_pListBoxHelper) + b_IsDropDownList = ((m_pListBoxHelper->GetStyle() & WB_DROPDOWN ) == WB_DROPDOWN); + if ( m_aBoxType == LISTBOX && !b_IsDropDownList ) + { + if ( m_pListBoxHelper ) + { + uno::Any aOldValue, + aNewValue; + sal_Int32 nPos = m_nCurSelectedPos; + + if ( nPos == LISTBOX_ENTRY_NOTFOUND ) + nPos = m_pListBoxHelper->GetTopEntry(); + if ( nPos != LISTBOX_ENTRY_NOTFOUND ) + aNewValue <<= CreateChild(nPos); + NotifyAccessibleEvent( AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, + aOldValue, + aNewValue ); + } + } + } + break; + + default: + VCLXAccessibleComponent::ProcessWindowEvent (rVclWindowEvent); + } +} + + void VCLXAccessibleList::FillAccessibleRelationSet( utl::AccessibleRelationSetHelper& rRelationSet ) +{ + VclPtr< ListBox > pBox = GetAs< ListBox >(); + if( m_aBoxType == LISTBOX ) + { + if (m_pListBoxHelper && (m_pListBoxHelper->GetStyle() & WB_DROPDOWN ) != WB_DROPDOWN) + { + uno::Sequence< uno::Reference< uno::XInterface > > aSequence { pBox->GetAccessible() }; + rRelationSet.AddRelation( com::sun::star::accessibility::AccessibleRelation( com::sun::star::accessibility::AccessibleRelationType::MEMBER_OF, aSequence ) ); + } + } + else + { + VCLXAccessibleComponent::FillAccessibleRelationSet(rRelationSet); + } +} + + +/** To find out which item is currently selected and to update the SELECTED + state of the associated accessibility objects accordingly we exploit the + fact that the +*/ +void VCLXAccessibleList::UpdateSelection (std::u16string_view sTextOfSelectedItem) +{ + if ( m_aBoxType != COMBOBOX ) + return; + + VclPtr< ComboBox > pBox = GetAs< ComboBox >(); + if ( pBox ) + { + // Find the index of the selected item inside the VCL control... + sal_Int32 nIndex = pBox->GetEntryPos(sTextOfSelectedItem); + // ...and then find the associated accessibility object. + if ( nIndex == LISTBOX_ENTRY_NOTFOUND ) + nIndex = 0; + UpdateSelection_Impl(nIndex); + } +} + + +Reference<XAccessible> VCLXAccessibleList::CreateChild (sal_Int32 nPos) +{ + Reference<XAccessible> xChild; + + if ( o3tl::make_unsigned(nPos) >= m_aAccessibleChildren.size() ) + { + m_aAccessibleChildren.resize(nPos + 1); + + // insert into the container + xChild = new VCLXAccessibleListItem(nPos, this); + m_aAccessibleChildren[nPos] = xChild; + } + else + { + xChild = m_aAccessibleChildren[nPos]; + // check if position is empty and can be used else we have to adjust all entries behind this + if (!xChild.is()) + { + xChild = new VCLXAccessibleListItem(nPos, this); + m_aAccessibleChildren[nPos] = xChild; + } + } + + if ( xChild.is() ) + { + // Just add the SELECTED state. + bool bNowSelected = false; + if ( m_pListBoxHelper ) + bNowSelected = m_pListBoxHelper->IsEntryPosSelected(nPos); + if (bNowSelected) + m_nCurSelectedPos = nPos; + VCLXAccessibleListItem* pItem = static_cast< VCLXAccessibleListItem* >(xChild.get()); + pItem->SetSelected( bNowSelected ); + + // Set the child's VISIBLE state. + UpdateVisibleLineCount(); + const sal_Int32 nTopEntry = m_pListBoxHelper ? m_pListBoxHelper->GetTopEntry() : 0; + bool bVisible = ( nPos>=nTopEntry && nPos<( nTopEntry + m_nVisibleLineCount ) ); + pItem->SetVisible( m_bVisible && bVisible ); + } + + return xChild; +} + + +void VCLXAccessibleList::HandleChangedItemList() +{ + m_aAccessibleChildren.clear(); + NotifyAccessibleEvent ( + AccessibleEventId::INVALIDATE_ALL_CHILDREN, + Any(), Any()); +} + + +IMPLEMENT_FORWARD_XINTERFACE2(VCLXAccessibleList, VCLXAccessibleComponent, VCLXAccessibleList_BASE) +IMPLEMENT_FORWARD_XTYPEPROVIDER2(VCLXAccessibleList, VCLXAccessibleComponent, VCLXAccessibleList_BASE) + +// XAccessible + +Reference<XAccessibleContext> SAL_CALL + VCLXAccessibleList::getAccessibleContext() +{ + return this; +} + + +// XAccessibleContext + +sal_Int32 SAL_CALL VCLXAccessibleList::getAccessibleChildCount() +{ + SolarMutexGuard aSolarGuard; + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + return implGetAccessibleChildCount(); +} + +sal_Int32 VCLXAccessibleList::implGetAccessibleChildCount() +{ + sal_Int32 nCount = 0; + if ( m_pListBoxHelper ) + nCount = m_pListBoxHelper->GetEntryCount(); + + return nCount; +} + +Reference<XAccessible> SAL_CALL VCLXAccessibleList::getAccessibleChild (sal_Int32 i) +{ + SolarMutexGuard aSolarGuard; + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + + if ( i < 0 || i >= getAccessibleChildCount() ) + throw IndexOutOfBoundsException(); + + Reference< XAccessible > xChild; + // search for the child + if ( o3tl::make_unsigned(i) >= m_aAccessibleChildren.size() ) + xChild = CreateChild (i); + else + { + xChild = m_aAccessibleChildren[i]; + if ( !xChild.is() ) + xChild = CreateChild (i); + } + OSL_ENSURE( xChild.is(), "VCLXAccessibleList::getAccessibleChild: returning empty child!" ); + return xChild; +} + +Reference< XAccessible > SAL_CALL VCLXAccessibleList::getAccessibleParent( ) +{ + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + + return m_xParent; +} + +sal_Int32 SAL_CALL VCLXAccessibleList::getAccessibleIndexInParent() +{ + if (m_nIndexInParent != DEFAULT_INDEX_IN_PARENT) + return m_nIndexInParent; + else + return VCLXAccessibleComponent::getAccessibleIndexInParent(); +} + +sal_Int16 SAL_CALL VCLXAccessibleList::getAccessibleRole() +{ + return AccessibleRole::LIST; +} + +// XServiceInfo +OUString VCLXAccessibleList::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleList"; +} + +Sequence< OUString > VCLXAccessibleList::getSupportedServiceNames() +{ + return comphelper::concatSequences(VCLXAccessibleComponent::getSupportedServiceNames(), + Sequence<OUString>{"com.sun.star.accessibility.AccessibleList"}); +} + +void VCLXAccessibleList::UpdateVisibleLineCount() +{ + if ( m_pListBoxHelper ) + { + if ( (m_pListBoxHelper->GetStyle() & WB_DROPDOWN ) == WB_DROPDOWN ) + m_nVisibleLineCount = m_pListBoxHelper->GetDisplayLineCount(); + else + { + sal_uInt16 nCols = 0, + nLines = 0; + m_pListBoxHelper->GetMaxVisColumnsAndLines (nCols, nLines); + m_nVisibleLineCount = nLines; + } + } +} + +void VCLXAccessibleList::UpdateEntryRange_Impl() +{ + SolarMutexGuard aSolarGuard; + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + + sal_Int32 nTop = m_nLastTopEntry; + + if ( m_pListBoxHelper ) + nTop = m_pListBoxHelper->GetTopEntry(); + if ( nTop != m_nLastTopEntry ) + { + UpdateVisibleLineCount(); + sal_Int32 nBegin = std::min( m_nLastTopEntry, nTop ); + sal_Int32 nEnd = std::max( m_nLastTopEntry + m_nVisibleLineCount, nTop + m_nVisibleLineCount ); + for (sal_Int32 i = nBegin; (i <= nEnd); ++i) + { + bool bVisible = ( i >= nTop && i < ( nTop + m_nVisibleLineCount ) ); + Reference< XAccessible > xHold; + if ( o3tl::make_unsigned(i) < m_aAccessibleChildren.size() ) + xHold = m_aAccessibleChildren[i]; + else if ( bVisible ) + xHold = CreateChild(i); + + if ( xHold.is() ) + static_cast< VCLXAccessibleListItem* >( xHold.get() )->SetVisible( m_bVisible && bVisible ); + } + } + + m_nLastTopEntry = nTop; +} + +bool VCLXAccessibleList::checkEntrySelected(sal_Int32 _nPos,Any& _rNewValue,Reference< XAccessible >& _rxNewAcc) +{ + OSL_ENSURE(m_pListBoxHelper,"Helper is not valid!"); + bool bNowSelected = false; + if ( m_pListBoxHelper ) + { + bNowSelected = m_pListBoxHelper->IsEntryPosSelected (_nPos); + if ( bNowSelected ) + { + _rxNewAcc = CreateChild(_nPos); + _rNewValue <<= _rxNewAcc; + } + } + return bNowSelected; +} + + +void VCLXAccessibleList::UpdateSelection_Impl(sal_Int32) +{ + uno::Any aOldValue, aNewValue; + + { + SolarMutexGuard aSolarGuard; + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + Reference< XAccessible > xNewAcc; + + if ( m_pListBoxHelper ) + { + sal_Int32 i=0; + m_nCurSelectedPos = LISTBOX_ENTRY_NOTFOUND; + for ( const auto& rChild : m_aAccessibleChildren ) + { + Reference< XAccessible > xHold = rChild; + if ( xHold.is() ) + { + VCLXAccessibleListItem* pItem = static_cast< VCLXAccessibleListItem* >( xHold.get() ); + // Retrieve the item's index from the list entry. + bool bNowSelected = m_pListBoxHelper->IsEntryPosSelected (i); + if (bNowSelected) + m_nCurSelectedPos = i; + + if ( bNowSelected && !pItem->IsSelected() ) + { + xNewAcc = rChild; + aNewValue <<= xNewAcc; + } + else if ( pItem->IsSelected() ) + m_nLastSelectedPos = i; + + pItem->SetSelected( bNowSelected ); + } + else + { // it could happen that a child was not created before + checkEntrySelected(i,aNewValue,xNewAcc); + } + ++i; + } + const sal_Int32 nCount = m_pListBoxHelper->GetEntryCount(); + if ( i < nCount ) // here we have to check the if any other listbox entry is selected + { + for (; i < nCount && !checkEntrySelected(i,aNewValue,xNewAcc) ;++i ) + ; + } + if ( xNewAcc.is() && GetWindow()->HasFocus() ) + { + if ( m_nLastSelectedPos != LISTBOX_ENTRY_NOTFOUND ) + aOldValue <<= getAccessibleChild( m_nLastSelectedPos ); + aNewValue <<= xNewAcc; + } + if (m_pListBoxHelper->IsInDropDown()) + { + if ( aNewValue.hasValue() || aOldValue.hasValue() ) + NotifyAccessibleEvent( + AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, + aOldValue, + aNewValue ); + //the SELECTION_CHANGED is not necessary + //NotifyAccessibleEvent( AccessibleEventId::SELECTION_CHANGED, Any(), Any() ); + } + } + } +} + + +// XAccessibleSelection + +void SAL_CALL VCLXAccessibleList::selectAccessibleChild( sal_Int32 nChildIndex ) +{ + bool bNotify = false; + + { + SolarMutexGuard aSolarGuard; + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + + if ( m_pListBoxHelper ) + { + checkSelection_Impl(nChildIndex,*m_pListBoxHelper,false); + + m_pListBoxHelper->SelectEntryPos( static_cast<sal_uInt16>(nChildIndex) ); + // call the select handler, don't handle events in this time + m_bDisableProcessEvent = true; + m_pListBoxHelper->Select(); + m_bDisableProcessEvent = false; + bNotify = true; + } + } + + if ( bNotify ) + UpdateSelection_Impl(); +} + +sal_Bool SAL_CALL VCLXAccessibleList::isAccessibleChildSelected( sal_Int32 nChildIndex ) +{ + SolarMutexGuard aSolarGuard; + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + + bool bRet = false; + if ( m_pListBoxHelper ) + { + checkSelection_Impl(nChildIndex,*m_pListBoxHelper,false); + + bRet = m_pListBoxHelper->IsEntryPosSelected( static_cast<sal_uInt16>(nChildIndex) ); + } + return bRet; +} + +void SAL_CALL VCLXAccessibleList::clearAccessibleSelection( ) +{ + bool bNotify = false; + + { + SolarMutexGuard aSolarGuard; + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + + if ( m_pListBoxHelper ) + { + m_pListBoxHelper->SetNoSelection(); + bNotify = true; + } + } + + if ( bNotify ) + UpdateSelection_Impl(); +} + +void SAL_CALL VCLXAccessibleList::selectAllAccessibleChildren( ) +{ + bool bNotify = false; + + { + SolarMutexGuard aSolarGuard; + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + + if ( m_pListBoxHelper ) + { + const sal_Int32 nCount = m_pListBoxHelper->GetEntryCount(); + for ( sal_Int32 i = 0; i < nCount; ++i ) + m_pListBoxHelper->SelectEntryPos( i ); + // call the select handler, don't handle events in this time + m_bDisableProcessEvent = true; + m_pListBoxHelper->Select(); + m_bDisableProcessEvent = false; + bNotify = true; + } + } + + if ( bNotify ) + UpdateSelection_Impl(); +} + +sal_Int32 SAL_CALL VCLXAccessibleList::getSelectedAccessibleChildCount( ) +{ + SolarMutexGuard aSolarGuard; + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + + sal_Int32 nCount = 0; + if ( m_pListBoxHelper ) + nCount = m_pListBoxHelper->GetSelectedEntryCount(); + return nCount; +} + +Reference< XAccessible > SAL_CALL VCLXAccessibleList::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex ) +{ + SolarMutexGuard aSolarGuard; + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + + if ( m_pListBoxHelper ) + { + checkSelection_Impl(nSelectedChildIndex,*m_pListBoxHelper,true); + return getAccessibleChild( m_pListBoxHelper->GetSelectedEntryPos( static_cast<sal_uInt16>(nSelectedChildIndex) ) ); + } + + return nullptr; +} + +void SAL_CALL VCLXAccessibleList::deselectAccessibleChild( sal_Int32 nSelectedChildIndex ) +{ + bool bNotify = false; + + { + SolarMutexGuard aSolarGuard; + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + + if ( m_pListBoxHelper ) + { + checkSelection_Impl(nSelectedChildIndex,*m_pListBoxHelper,false); + + m_pListBoxHelper->SelectEntryPos( static_cast<sal_uInt16>(nSelectedChildIndex), false ); + // call the select handler, don't handle events in this time + m_bDisableProcessEvent = true; + m_pListBoxHelper->Select(); + m_bDisableProcessEvent = false; + bNotify = true; + } + } + + if ( bNotify ) + UpdateSelection_Impl(); +} + +awt::Rectangle VCLXAccessibleList::implGetBounds() +{ + awt::Rectangle aBounds ( 0, 0, 0, 0 ); + if ( m_pListBoxHelper + && (m_pListBoxHelper->GetStyle() & WB_DROPDOWN ) == WB_DROPDOWN ) + { + if ( m_pListBoxHelper->IsInDropDown() ) + aBounds = AWTRectangle(m_pListBoxHelper->GetDropDownPosSizePixel()); + } + else + { + // a list has the same bounds as his parent but starts at (0,0) + aBounds = VCLXAccessibleComponent::implGetBounds(); + aBounds.X = 0; + aBounds.Y = 0; + if ( m_aBoxType == COMBOBOX ) + { + VclPtr< ComboBox > pBox = GetAs< ComboBox >(); + if ( pBox ) + { + Size aSize = pBox->GetSubEdit()->GetSizePixel(); + aBounds.Y += aSize.Height(); + aBounds.Height -= aSize.Height(); + } + } + } + return aBounds; +} + + +awt::Point VCLXAccessibleList::getLocationOnScreen( ) +{ + SolarMutexGuard aSolarGuard; + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + + awt::Point aPos; + if ( m_pListBoxHelper + && (m_pListBoxHelper->GetStyle() & WB_DROPDOWN ) == WB_DROPDOWN ) + { + if ( m_pListBoxHelper->IsInDropDown() ) + aPos = AWTPoint(m_pListBoxHelper->GetDropDownPosSizePixel().TopLeft()); + } + else + { + aPos = VCLXAccessibleComponent::getLocationOnScreen(); + if ( m_aBoxType == COMBOBOX ) + { + VclPtr< ComboBox > pBox = GetAs< ComboBox >(); + if ( pBox ) + { + aPos.Y += pBox->GetSubEdit()->GetSizePixel().Height(); + } + } + } + return aPos; +} + + +bool VCLXAccessibleList::IsInDropDown() const +{ + return m_pListBoxHelper->IsInDropDown(); +} + + +void VCLXAccessibleList::HandleDropOpen() +{ + if ( !m_bDisableProcessEvent ) + UpdateSelection_Impl(); + if (m_nCurSelectedPos != LISTBOX_ENTRY_NOTFOUND && + m_nLastSelectedPos != LISTBOX_ENTRY_NOTFOUND) + { + Reference< XAccessible > xChild = getAccessibleChild(m_nCurSelectedPos); + if(xChild.is()) + { + uno::Any aNewValue; + aNewValue <<= xChild; + NotifyAccessibleEvent(AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, uno::Any(), aNewValue ); + } + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessiblelistbox.cxx b/accessibility/source/standard/vclxaccessiblelistbox.cxx new file mode 100644 index 000000000..4b5ed9377 --- /dev/null +++ b/accessibility/source/standard/vclxaccessiblelistbox.cxx @@ -0,0 +1,53 @@ +/* -*- 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 <standard/vclxaccessiblelistbox.hxx> +#include <toolkit/awt/vclxwindow.hxx> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::accessibility; + +VCLXAccessibleListBox::VCLXAccessibleListBox (VCLXWindow* pVCLWindow) + : VCLXAccessibleBox (pVCLWindow, VCLXAccessibleBox::LISTBOX, false) +{ +} + + +bool VCLXAccessibleListBox::IsValid() const +{ + return GetWindow(); +} + +// XServiceInfo + +OUString VCLXAccessibleListBox::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleListBox"; +} + + +Sequence< OUString > VCLXAccessibleListBox::getSupportedServiceNames() +{ + return comphelper::concatSequences(VCLXAccessibleBox::getSupportedServiceNames(), + Sequence<OUString>{"com.sun.star.accessibility.AccessibleListBox"}); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessiblelistitem.cxx b/accessibility/source/standard/vclxaccessiblelistitem.cxx new file mode 100644 index 000000000..81a5cd1a2 --- /dev/null +++ b/accessibility/source/standard/vclxaccessiblelistitem.cxx @@ -0,0 +1,617 @@ +/* -*- 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 <standard/vclxaccessiblelistitem.hxx> +#include <toolkit/helper/convert.hxx> +#include <helper/IComboListBoxHelper.hxx> +#include <com/sun/star/awt/Rectangle.hpp> + +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/datatransfer/clipboard/XClipboard.hpp> +#include <com/sun/star/datatransfer/clipboard/XFlushableClipboard.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <cppuhelper/supportsservice.hxx> +#include <utility> +#include <vcl/svapp.hxx> +#include <vcl/toolkit/lstbox.hxx> +#include <vcl/unohelp2.hxx> +#include <vcl/settings.hxx> +#include <unotools/accessiblestatesethelper.hxx> +#include <unotools/accessiblerelationsethelper.hxx> +#include <comphelper/accessibleeventnotifier.hxx> +#include <i18nlangtag/languagetag.hxx> + +namespace +{ + /// @throws css::lang::IndexOutOfBoundsException + void checkIndex_Impl( sal_Int32 _nIndex, const OUString& _sText ) + { + if ( _nIndex < 0 || _nIndex > _sText.getLength() ) + throw css::lang::IndexOutOfBoundsException(); + } +} + +// class VCLXAccessibleListItem ------------------------------------------ + +using namespace ::com::sun::star::accessibility; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star; + + +// Ctor() and Dtor() + +VCLXAccessibleListItem::VCLXAccessibleListItem(sal_Int32 _nIndexInParent, rtl::Reference< VCLXAccessibleList > _xParent) + : VCLXAccessibleListItem_BASE(m_aMutex) + , m_nIndexInParent(_nIndexInParent) + , m_bSelected(false) + , m_bVisible(false) + , m_nClientId(0) + , m_xParent(std::move(_xParent)) +{ + assert(m_xParent.is()); + ::accessibility::IComboListBoxHelper* pListBoxHelper = m_xParent->getListBoxHelper(); + if (pListBoxHelper) + m_sEntryText = pListBoxHelper->GetEntry(static_cast<sal_uInt16>(_nIndexInParent)); +} + +void VCLXAccessibleListItem::SetSelected( bool _bSelected ) +{ + if ( m_bSelected != _bSelected ) + { + Any aOldValue; + Any aNewValue; + if ( m_bSelected ) + aOldValue <<= AccessibleStateType::SELECTED; + else + aNewValue <<= AccessibleStateType::SELECTED; + m_bSelected = _bSelected; + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue ); + } +} + +void VCLXAccessibleListItem::SetVisible( bool _bVisible ) +{ + if ( m_bVisible != _bVisible ) + { + Any aOldValue, aNewValue; + m_bVisible = _bVisible; + (_bVisible ? aNewValue : aOldValue ) <<= AccessibleStateType::VISIBLE; + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue ); + (_bVisible ? aNewValue : aOldValue ) <<= AccessibleStateType::SHOWING; + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue ); + } +} + +void VCLXAccessibleListItem::NotifyAccessibleEvent( sal_Int16 _nEventId, + const css::uno::Any& _aOldValue, + const css::uno::Any& _aNewValue ) +{ + AccessibleEventObject aEvt; + aEvt.Source = *this; + aEvt.EventId = _nEventId; + aEvt.OldValue = _aOldValue; + aEvt.NewValue = _aNewValue; + + if (m_nClientId) + comphelper::AccessibleEventNotifier::addEvent( m_nClientId, aEvt ); +} + +// OCommonAccessibleText + +OUString VCLXAccessibleListItem::implGetText() +{ + return m_sEntryText; +} + +Locale VCLXAccessibleListItem::implGetLocale() +{ + return Application::GetSettings().GetLanguageTag().getLocale(); +} + +void VCLXAccessibleListItem::implGetSelection( sal_Int32& nStartIndex, sal_Int32& nEndIndex ) +{ + nStartIndex = 0; + nEndIndex = 0; +} + +// XTypeProvider + +Sequence< sal_Int8 > VCLXAccessibleListItem::getImplementationId() +{ + return css::uno::Sequence<sal_Int8>(); +} + +// XComponent + +void SAL_CALL VCLXAccessibleListItem::disposing() +{ + comphelper::AccessibleEventNotifier::TClientId nId( 0 ); + Reference< XInterface > xEventSource; + { + ::osl::MutexGuard aGuard( m_aMutex ); + + VCLXAccessibleListItem_BASE::disposing(); + m_sEntryText.clear(); + m_xParent = nullptr; + + nId = m_nClientId; + m_nClientId = 0; + if ( nId ) + xEventSource = *this; + } + + // Send a disposing to all listeners. + if ( nId ) + comphelper::AccessibleEventNotifier::revokeClientNotifyDisposing( nId, *this ); +} + +// XServiceInfo + +OUString VCLXAccessibleListItem::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleListItem"; +} + +sal_Bool VCLXAccessibleListItem::supportsService( const OUString& rServiceName ) +{ + return cppu::supportsService(this, rServiceName); +} + +Sequence< OUString > VCLXAccessibleListItem::getSupportedServiceNames() +{ + return {"com.sun.star.accessibility.AccessibleContext", + "com.sun.star.accessibility.AccessibleComponent", + "com.sun.star.accessibility.AccessibleListItem"}; +} + +// XAccessible + +Reference< XAccessibleContext > SAL_CALL VCLXAccessibleListItem::getAccessibleContext( ) +{ + return this; +} + +// XAccessibleContext + +sal_Int32 SAL_CALL VCLXAccessibleListItem::getAccessibleChildCount( ) +{ + return 0; +} + +Reference< XAccessible > SAL_CALL VCLXAccessibleListItem::getAccessibleChild( sal_Int32 ) +{ + return Reference< XAccessible >(); +} + +Reference< XAccessible > SAL_CALL VCLXAccessibleListItem::getAccessibleParent( ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + + return m_xParent; +} + +sal_Int32 SAL_CALL VCLXAccessibleListItem::getAccessibleIndexInParent( ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + return m_nIndexInParent; +} + +sal_Int16 SAL_CALL VCLXAccessibleListItem::getAccessibleRole( ) +{ + return AccessibleRole::LIST_ITEM; + // return AccessibleRole::LABEL; +} + +OUString SAL_CALL VCLXAccessibleListItem::getAccessibleDescription( ) +{ + // no description for every item + return OUString(); +} + +OUString SAL_CALL VCLXAccessibleListItem::getAccessibleName( ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + + // entry text == accessible name + return m_sEntryText; +} + +Reference< XAccessibleRelationSet > SAL_CALL VCLXAccessibleListItem::getAccessibleRelationSet( ) +{ + return new utl::AccessibleRelationSetHelper; +} + +Reference< XAccessibleStateSet > SAL_CALL VCLXAccessibleListItem::getAccessibleStateSet( ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + + rtl::Reference<utl::AccessibleStateSetHelper> pStateSetHelper = new utl::AccessibleStateSetHelper; + + if ( !rBHelper.bDisposed && !rBHelper.bInDispose ) + { + pStateSetHelper->AddState( AccessibleStateType::TRANSIENT ); + + ::accessibility::IComboListBoxHelper* pListBoxHelper = m_xParent.is() ? m_xParent->getListBoxHelper() : nullptr; + if (pListBoxHelper && pListBoxHelper->IsEnabled()) + { + pStateSetHelper->AddState( AccessibleStateType::SELECTABLE ); + pStateSetHelper->AddState( AccessibleStateType::ENABLED ); + pStateSetHelper->AddState( AccessibleStateType::SENSITIVE ); + } + + if ( m_bSelected ) + pStateSetHelper->AddState( AccessibleStateType::SELECTED ); + if ( m_bVisible ) + { + pStateSetHelper->AddState( AccessibleStateType::VISIBLE ); + pStateSetHelper->AddState( AccessibleStateType::SHOWING ); + } + } + else + pStateSetHelper->AddState( AccessibleStateType::DEFUNC ); + + return pStateSetHelper; +} + +Locale SAL_CALL VCLXAccessibleListItem::getLocale( ) +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + return implGetLocale(); +} + +// XAccessibleComponent + +sal_Bool SAL_CALL VCLXAccessibleListItem::containsPoint( const awt::Point& _aPoint ) +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + bool bInside = false; + ::accessibility::IComboListBoxHelper* pListBoxHelper = m_xParent.is() ? m_xParent->getListBoxHelper() : nullptr; + if (pListBoxHelper) + { + tools::Rectangle aRect(pListBoxHelper->GetBoundingRectangle(static_cast<sal_uInt16>(m_nIndexInParent))); + aRect.Move(-aRect.Left(), -aRect.Top()); + bInside = aRect.Contains( VCLPoint( _aPoint ) ); + } + return bInside; +} + +Reference< XAccessible > SAL_CALL VCLXAccessibleListItem::getAccessibleAtPoint( const awt::Point& ) +{ + return Reference< XAccessible >(); +} + +awt::Rectangle SAL_CALL VCLXAccessibleListItem::getBounds( ) +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + awt::Rectangle aRect; + ::accessibility::IComboListBoxHelper* pListBoxHelper = m_xParent.is() ? m_xParent->getListBoxHelper() : nullptr; + if (pListBoxHelper) + aRect = AWTRectangle(pListBoxHelper->GetBoundingRectangle(static_cast<sal_uInt16>(m_nIndexInParent))); + + return aRect; +} + +awt::Point SAL_CALL VCLXAccessibleListItem::getLocation( ) +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + Point aPoint(0,0); + ::accessibility::IComboListBoxHelper* pListBoxHelper = m_xParent.is() ? m_xParent->getListBoxHelper() : nullptr; + if (pListBoxHelper) + { + tools::Rectangle aRect = pListBoxHelper->GetBoundingRectangle( static_cast<sal_uInt16>(m_nIndexInParent) ); + aPoint = aRect.TopLeft(); + } + return AWTPoint( aPoint ); +} + +awt::Point SAL_CALL VCLXAccessibleListItem::getLocationOnScreen( ) +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + Point aPoint(0,0); + ::accessibility::IComboListBoxHelper* pListBoxHelper = m_xParent.is() ? m_xParent->getListBoxHelper() : nullptr; + if (pListBoxHelper) + { + tools::Rectangle aRect = pListBoxHelper->GetBoundingRectangle(static_cast<sal_uInt16>(m_nIndexInParent)); + aPoint = aRect.TopLeft(); + aPoint += pListBoxHelper->GetWindowExtentsRelative().TopLeft(); + } + return AWTPoint( aPoint ); +} + +awt::Size SAL_CALL VCLXAccessibleListItem::getSize( ) +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + Size aSize; + ::accessibility::IComboListBoxHelper* pListBoxHelper = m_xParent.is() ? m_xParent->getListBoxHelper() : nullptr; + if (pListBoxHelper) + aSize = pListBoxHelper->GetBoundingRectangle( static_cast<sal_uInt16>(m_nIndexInParent) ).GetSize(); + + return AWTSize( aSize ); +} + +void SAL_CALL VCLXAccessibleListItem::grabFocus( ) +{ + // no focus for each item +} + +// XAccessibleText + +sal_Int32 SAL_CALL VCLXAccessibleListItem::getCaretPosition() +{ + return -1; +} + +sal_Bool SAL_CALL VCLXAccessibleListItem::setCaretPosition( sal_Int32 nIndex ) +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + if ( !implIsValidRange( nIndex, nIndex, m_sEntryText.getLength() ) ) + throw IndexOutOfBoundsException(); + + return false; +} + +sal_Unicode SAL_CALL VCLXAccessibleListItem::getCharacter( sal_Int32 nIndex ) +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + return OCommonAccessibleText::implGetCharacter( m_sEntryText, nIndex ); +} + +Sequence< PropertyValue > SAL_CALL VCLXAccessibleListItem::getCharacterAttributes( sal_Int32 nIndex, const Sequence< OUString >& ) +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + if ( !implIsValidIndex( nIndex, m_sEntryText.getLength() ) ) + throw IndexOutOfBoundsException(); + + return Sequence< PropertyValue >(); +} + +awt::Rectangle SAL_CALL VCLXAccessibleListItem::getCharacterBounds( sal_Int32 nIndex ) +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + if ( !implIsValidIndex( nIndex, m_sEntryText.getLength() ) ) + throw IndexOutOfBoundsException(); + + awt::Rectangle aBounds( 0, 0, 0, 0 ); + ::accessibility::IComboListBoxHelper* pListBoxHelper = m_xParent.is() ? m_xParent->getListBoxHelper() : nullptr; + if (pListBoxHelper) + { + tools::Rectangle aCharRect = pListBoxHelper->GetEntryCharacterBounds( m_nIndexInParent, nIndex ); + tools::Rectangle aItemRect = pListBoxHelper->GetBoundingRectangle( static_cast<sal_uInt16>(m_nIndexInParent) ); + aCharRect.Move( -aItemRect.Left(), -aItemRect.Top() ); + aBounds = AWTRectangle( aCharRect ); + } + + return aBounds; +} + +sal_Int32 SAL_CALL VCLXAccessibleListItem::getCharacterCount() +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + return m_sEntryText.getLength(); +} + +sal_Int32 SAL_CALL VCLXAccessibleListItem::getIndexAtPoint( const awt::Point& aPoint ) +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + sal_Int32 nIndex = -1; + ::accessibility::IComboListBoxHelper* pListBoxHelper = m_xParent.is() ? m_xParent->getListBoxHelper() : nullptr; + if (pListBoxHelper) + { + sal_Int32 nPos = LISTBOX_ENTRY_NOTFOUND; + tools::Rectangle aItemRect = pListBoxHelper->GetBoundingRectangle( static_cast<sal_uInt16>(m_nIndexInParent) ); + Point aPnt( VCLPoint( aPoint ) ); + aPnt += aItemRect.TopLeft(); + sal_Int32 nI = pListBoxHelper->GetIndexForPoint( aPnt, nPos ); + if ( nI != -1 && m_nIndexInParent == nPos ) + nIndex = nI; + } + return nIndex; +} + +OUString SAL_CALL VCLXAccessibleListItem::getSelectedText() +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + return OUString(); +} + +sal_Int32 SAL_CALL VCLXAccessibleListItem::getSelectionStart() +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + return 0; +} + +sal_Int32 SAL_CALL VCLXAccessibleListItem::getSelectionEnd() +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + return 0; +} + +sal_Bool SAL_CALL VCLXAccessibleListItem::setSelection( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + if ( !implIsValidRange( nStartIndex, nEndIndex, m_sEntryText.getLength() ) ) + throw IndexOutOfBoundsException(); + + return false; +} + +OUString SAL_CALL VCLXAccessibleListItem::getText() +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + return m_sEntryText; +} + +OUString SAL_CALL VCLXAccessibleListItem::getTextRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + return OCommonAccessibleText::implGetTextRange( m_sEntryText, nStartIndex, nEndIndex ); +} + +css::accessibility::TextSegment SAL_CALL VCLXAccessibleListItem::getTextAtIndex( sal_Int32 nIndex, sal_Int16 aTextType ) +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + return OCommonAccessibleText::getTextAtIndex( nIndex, aTextType ); +} + +css::accessibility::TextSegment SAL_CALL VCLXAccessibleListItem::getTextBeforeIndex( sal_Int32 nIndex, sal_Int16 aTextType ) +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + return OCommonAccessibleText::getTextBeforeIndex( nIndex, aTextType ); +} + +css::accessibility::TextSegment SAL_CALL VCLXAccessibleListItem::getTextBehindIndex( sal_Int32 nIndex, sal_Int16 aTextType ) +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + return OCommonAccessibleText::getTextBehindIndex( nIndex, aTextType ); +} + +sal_Bool SAL_CALL VCLXAccessibleListItem::copyText( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + checkIndex_Impl( nStartIndex, m_sEntryText ); + checkIndex_Impl( nEndIndex, m_sEntryText ); + + bool bRet = false; + ::accessibility::IComboListBoxHelper* pListBoxHelper = m_xParent.is() ? m_xParent->getListBoxHelper() : nullptr; + if (pListBoxHelper) + { + Reference< datatransfer::clipboard::XClipboard > xClipboard = pListBoxHelper->GetClipboard(); + if ( xClipboard.is() ) + { + OUString sText( getTextRange( nStartIndex, nEndIndex ) ); + rtl::Reference<vcl::unohelper::TextDataObject> pDataObj = new vcl::unohelper::TextDataObject( sText ); + + SolarMutexReleaser aReleaser; + xClipboard->setContents( pDataObj, nullptr ); + Reference< datatransfer::clipboard::XFlushableClipboard > xFlushableClipboard( xClipboard, uno::UNO_QUERY ); + if( xFlushableClipboard.is() ) + xFlushableClipboard->flushClipboard(); + + bRet = true; + } + } + + return bRet; +} + +sal_Bool VCLXAccessibleListItem::scrollSubstringTo( sal_Int32, sal_Int32, AccessibleScrollType ) +{ + return false; +} + +// XAccessibleEventBroadcaster + +void SAL_CALL VCLXAccessibleListItem::addAccessibleEventListener( const Reference< XAccessibleEventListener >& xListener ) +{ + if (xListener.is()) + { + if (!m_nClientId) + m_nClientId = comphelper::AccessibleEventNotifier::registerClient( ); + comphelper::AccessibleEventNotifier::addEventListener( m_nClientId, xListener ); + } +} + +void SAL_CALL VCLXAccessibleListItem::removeAccessibleEventListener( const Reference< XAccessibleEventListener >& xListener ) +{ + if ( !(xListener.is() && m_nClientId) ) + return; + + sal_Int32 nListenerCount = comphelper::AccessibleEventNotifier::removeEventListener( m_nClientId, xListener ); + if ( nListenerCount ) + return; + + // no listeners anymore + // -> revoke ourself. This may lead to the notifier thread dying (if we were the last client), + // and at least to us not firing any events anymore, in case somebody calls + // NotifyAccessibleEvent, again + if ( m_nClientId ) + { + comphelper::AccessibleEventNotifier::TClientId nId( m_nClientId ); + m_nClientId = 0; + comphelper::AccessibleEventNotifier::revokeClient( nId ); + } +} + + +// AF (Oct. 29 2002): Return black as constant foreground color. This is an +// initial implementation and has to be substituted by code that determines +// the color that is actually used. +sal_Int32 SAL_CALL VCLXAccessibleListItem::getForeground() +{ + return sal_Int32(COL_BLACK); +} + +// AF (Oct. 29 2002): Return white as constant background color. This is an +// initial implementation and has to be substituted by code that determines +// the color that is actually used. +sal_Int32 SAL_CALL VCLXAccessibleListItem::getBackground() +{ + return sal_Int32(COL_WHITE); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessiblemenu.cxx b/accessibility/source/standard/vclxaccessiblemenu.cxx new file mode 100644 index 000000000..a7e31094b --- /dev/null +++ b/accessibility/source/standard/vclxaccessiblemenu.cxx @@ -0,0 +1,233 @@ +/* -*- 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 <standard/vclxaccessiblemenu.hxx> + +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <vcl/menu.hxx> + + +using namespace ::com::sun::star; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::accessibility; +using namespace ::comphelper; + + +// VCLXAccessibleMenu + + +bool VCLXAccessibleMenu::IsFocused() +{ + bool bFocused = false; + + if ( IsHighlighted() && !IsChildHighlighted() ) + bFocused = true; + + return bFocused; +} + + +bool VCLXAccessibleMenu::IsPopupMenuOpen() +{ + bool bPopupMenuOpen = false; + + if ( m_pParent ) + { + PopupMenu* pPopupMenu = m_pParent->GetPopupMenu( m_pParent->GetItemId( m_nItemPos ) ); + if ( pPopupMenu && pPopupMenu->IsMenuVisible() ) + bPopupMenuOpen = true; + } + + return bPopupMenuOpen; +} + + +// XInterface + + +IMPLEMENT_FORWARD_XINTERFACE2( VCLXAccessibleMenu, VCLXAccessibleMenuItem, VCLXAccessibleMenu_BASE ) + + +// XTypeProvider + + +IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXAccessibleMenu, VCLXAccessibleMenuItem, VCLXAccessibleMenu_BASE ) + + +// XServiceInfo + + +OUString VCLXAccessibleMenu::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleMenu"; +} + + +Sequence< OUString > VCLXAccessibleMenu::getSupportedServiceNames() +{ + return { "com.sun.star.awt.AccessibleMenu" }; +} + + +// XAccessibleContext + + +sal_Int32 VCLXAccessibleMenu::getAccessibleChildCount( ) +{ + OExternalLockGuard aGuard( this ); + + return GetChildCount(); +} + + +Reference< XAccessible > VCLXAccessibleMenu::getAccessibleChild( sal_Int32 i ) +{ + OExternalLockGuard aGuard( this ); + + if ( i < 0 || i >= GetChildCount() ) + throw IndexOutOfBoundsException(); + + return GetChild( i ); +} + + +sal_Int16 VCLXAccessibleMenu::getAccessibleRole( ) +{ + OExternalLockGuard aGuard( this ); + + return AccessibleRole::MENU; +} + + +// XAccessibleComponent + + +Reference< XAccessible > VCLXAccessibleMenu::getAccessibleAtPoint( const awt::Point& rPoint ) +{ + OExternalLockGuard aGuard( this ); + + return GetChildAt( rPoint ); +} + + +// XAccessibleSelection + + +void VCLXAccessibleMenu::selectAccessibleChild( sal_Int32 nChildIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nChildIndex < 0 || nChildIndex >= GetChildCount() ) + throw IndexOutOfBoundsException(); + + SelectChild( nChildIndex ); +} + + +sal_Bool VCLXAccessibleMenu::isAccessibleChildSelected( sal_Int32 nChildIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nChildIndex < 0 || nChildIndex >= GetChildCount() ) + throw IndexOutOfBoundsException(); + + return IsChildSelected( nChildIndex ); +} + + +void VCLXAccessibleMenu::clearAccessibleSelection( ) +{ + OExternalLockGuard aGuard( this ); + + DeSelectAll(); +} + + +void VCLXAccessibleMenu::selectAllAccessibleChildren( ) +{ + // This method makes no sense in a menu, and so does nothing. +} + + +sal_Int32 VCLXAccessibleMenu::getSelectedAccessibleChildCount( ) +{ + OExternalLockGuard aGuard( this ); + + return implGetSelectedAccessibleChildCount(); +} + +sal_Int32 VCLXAccessibleMenu::implGetSelectedAccessibleChildCount( ) +{ + sal_Int32 nRet = 0; + + for ( sal_Int32 i = 0, nCount = GetChildCount(); i < nCount; i++ ) + { + if ( IsChildSelected( i ) ) + ++nRet; + } + + return nRet; +} + +Reference< XAccessible > VCLXAccessibleMenu::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nSelectedChildIndex < 0 || nSelectedChildIndex >= getSelectedAccessibleChildCount() ) + throw IndexOutOfBoundsException(); + + Reference< XAccessible > xChild; + + for ( sal_Int32 i = 0, j = 0, nCount = GetChildCount(); i < nCount; i++ ) + { + if ( IsChildSelected( i ) && ( j++ == nSelectedChildIndex ) ) + { + xChild = GetChild( i ); + break; + } + } + + return xChild; +} + + +void VCLXAccessibleMenu::deselectAccessibleChild( sal_Int32 nChildIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nChildIndex < 0 || nChildIndex >= GetChildCount() ) + throw IndexOutOfBoundsException(); + + DeSelectAll(); +} + + +OUString VCLXAccessibleMenu::getAccessibleActionDescription ( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nIndex < 0 || nIndex >= getAccessibleActionCount() ) + throw IndexOutOfBoundsException(); + + return OUString( ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessiblemenubar.cxx b/accessibility/source/standard/vclxaccessiblemenubar.cxx new file mode 100644 index 000000000..27a02607b --- /dev/null +++ b/accessibility/source/standard/vclxaccessiblemenubar.cxx @@ -0,0 +1,187 @@ +/* -*- 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 <standard/vclxaccessiblemenubar.hxx> + +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <vcl/svapp.hxx> +#include <vcl/window.hxx> +#include <vcl/menu.hxx> +#include <vcl/settings.hxx> + +using namespace ::com::sun::star::accessibility; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star; +using namespace ::comphelper; + + + + +VCLXAccessibleMenuBar::VCLXAccessibleMenuBar( Menu* pMenu ) + :OAccessibleMenuComponent( pMenu ) +{ + if ( pMenu ) + { + m_pWindow = pMenu->GetWindow(); + + if ( m_pWindow ) + m_pWindow->AddEventListener( LINK( this, VCLXAccessibleMenuBar, WindowEventListener ) ); + } +} + + +VCLXAccessibleMenuBar::~VCLXAccessibleMenuBar() +{ + if ( m_pWindow ) + m_pWindow->RemoveEventListener( LINK( this, VCLXAccessibleMenuBar, WindowEventListener ) ); +} + + +bool VCLXAccessibleMenuBar::IsFocused() +{ + bool bFocused = false; + + if ( m_pWindow && m_pWindow->HasFocus() && !IsChildHighlighted() ) + bFocused = true; + + return bFocused; +} + + +IMPL_LINK( VCLXAccessibleMenuBar, WindowEventListener, VclWindowEvent&, rEvent, void ) +{ + OSL_ENSURE( rEvent.GetWindow(), "VCLXAccessibleMenuBar::WindowEventListener: no window!" ); + if ( !rEvent.GetWindow()->IsAccessibilityEventsSuppressed() || ( rEvent.GetId() == VclEventId::ObjectDying ) ) + { + ProcessWindowEvent( rEvent ); + } +} + + +void VCLXAccessibleMenuBar::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent ) +{ + switch ( rVclWindowEvent.GetId() ) + { + case VclEventId::WindowGetFocus: + case VclEventId::WindowLoseFocus: + { + SetFocused( rVclWindowEvent.GetId() == VclEventId::WindowGetFocus ); + } + break; + case VclEventId::ObjectDying: + { + if ( m_pWindow ) + { + m_pWindow->RemoveEventListener( LINK( this, VCLXAccessibleMenuBar, WindowEventListener ) ); + m_pWindow = nullptr; + } + } + break; + default: + { + } + break; + } +} + + +// XComponent + + +void VCLXAccessibleMenuBar::disposing() +{ + OAccessibleMenuComponent::disposing(); + + if ( m_pWindow ) + { + m_pWindow->RemoveEventListener( LINK( this, VCLXAccessibleMenuBar, WindowEventListener ) ); + m_pWindow = nullptr; + } +} + + +// XServiceInfo + + +OUString VCLXAccessibleMenuBar::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleMenuBar"; +} + + +Sequence< OUString > VCLXAccessibleMenuBar::getSupportedServiceNames() +{ + return { "com.sun.star.awt.AccessibleMenuBar" }; +} + + +// XAccessibleContext + + +sal_Int32 VCLXAccessibleMenuBar::getAccessibleIndexInParent( ) +{ + OExternalLockGuard aGuard( this ); + + sal_Int32 nIndexInParent = -1; + + if ( m_pMenu ) + { + vcl::Window* pWindow = m_pMenu->GetWindow(); + if ( pWindow ) + { + vcl::Window* pParent = pWindow->GetAccessibleParentWindow(); + if ( pParent ) + { + for ( sal_uInt16 n = pParent->GetAccessibleChildWindowCount(); n; ) + { + vcl::Window* pChild = pParent->GetAccessibleChildWindow( --n ); + if ( pChild == pWindow ) + { + nIndexInParent = n; + break; + } + } + } + } + } + + return nIndexInParent; +} + + +sal_Int16 VCLXAccessibleMenuBar::getAccessibleRole( ) +{ + OExternalLockGuard aGuard( this ); + + return AccessibleRole::MENU_BAR; +} + + +// XAccessibleExtendedComponent + + +sal_Int32 VCLXAccessibleMenuBar::getBackground( ) +{ + OExternalLockGuard aGuard( this ); + + return sal_Int32(Application::GetSettings().GetStyleSettings().GetMenuBarColor()); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessiblemenuitem.cxx b/accessibility/source/standard/vclxaccessiblemenuitem.cxx new file mode 100644 index 000000000..96e31c007 --- /dev/null +++ b/accessibility/source/standard/vclxaccessiblemenuitem.cxx @@ -0,0 +1,579 @@ +/* -*- 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 <standard/vclxaccessiblemenuitem.hxx> +#include <toolkit/helper/convert.hxx> +#include <helper/characterattributeshelper.hxx> +#include <comphelper/accessiblekeybindinghelper.hxx> +#include <com/sun/star/awt/KeyModifier.hpp> + +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/datatransfer/clipboard/XClipboard.hpp> +#include <com/sun/star/datatransfer/clipboard/XFlushableClipboard.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <unotools/accessiblestatesethelper.hxx> +#include <comphelper/sequence.hxx> +#include <i18nlangtag/languagetag.hxx> +#include <vcl/event.hxx> +#include <vcl/svapp.hxx> +#include <vcl/window.hxx> +#include <vcl/menu.hxx> +#include <vcl/unohelp2.hxx> +#include <vcl/settings.hxx> +#include <strings.hxx> + +using namespace ::com::sun::star::accessibility; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star; +using namespace ::comphelper; + + + + +VCLXAccessibleMenuItem::VCLXAccessibleMenuItem( Menu* pParent, sal_uInt16 nItemPos, Menu* pMenu ) + :OAccessibleMenuItemComponent( pParent, nItemPos, pMenu ) +{ +} + + +bool VCLXAccessibleMenuItem::IsFocused() +{ + return IsHighlighted(); +} + + +bool VCLXAccessibleMenuItem::IsSelected() +{ + return IsHighlighted(); +} + + +bool VCLXAccessibleMenuItem::IsChecked() +{ + bool bChecked = false; + + if ( m_pParent ) + { + sal_uInt16 nItemId = m_pParent->GetItemId( m_nItemPos ); + if ( m_pParent->IsItemChecked( nItemId ) ) + bChecked = true; + } + + return bChecked; +} + + +bool VCLXAccessibleMenuItem::IsHighlighted() +{ + bool bHighlighted = false; + + if ( m_pParent && m_pParent->IsHighlighted( m_nItemPos ) ) + bHighlighted = true; + + return bHighlighted; +} + + +void VCLXAccessibleMenuItem::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet ) +{ + OAccessibleMenuItemComponent::FillAccessibleStateSet( rStateSet ); + + rStateSet.AddState( AccessibleStateType::FOCUSABLE ); + + if ( IsFocused() ) + rStateSet.AddState( AccessibleStateType::FOCUSED ); + + rStateSet.AddState( AccessibleStateType::SELECTABLE ); + + if ( IsSelected() ) + rStateSet.AddState( AccessibleStateType::SELECTED ); + + if ( IsChecked() ) + rStateSet.AddState( AccessibleStateType::CHECKED ); +} + + +// OCommonAccessibleText + + +OUString VCLXAccessibleMenuItem::implGetText() +{ + return m_sItemText; +} + + +Locale VCLXAccessibleMenuItem::implGetLocale() +{ + return Application::GetSettings().GetLanguageTag().getLocale(); +} + + +void VCLXAccessibleMenuItem::implGetSelection( sal_Int32& nStartIndex, sal_Int32& nEndIndex ) +{ + nStartIndex = 0; + nEndIndex = 0; +} + + +// XInterface + + +IMPLEMENT_FORWARD_XINTERFACE2( VCLXAccessibleMenuItem, OAccessibleMenuItemComponent, VCLXAccessibleMenuItem_BASE ) + + +// XTypeProvider + + +IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXAccessibleMenuItem, OAccessibleMenuItemComponent, VCLXAccessibleMenuItem_BASE ) + + +// XServiceInfo + + +OUString VCLXAccessibleMenuItem::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleMenuItem"; +} + + +Sequence< OUString > VCLXAccessibleMenuItem::getSupportedServiceNames() +{ + return { "com.sun.star.awt.AccessibleMenuItem" }; +} + + +// XAccessibleContext + + +sal_Int16 VCLXAccessibleMenuItem::getAccessibleRole( ) +{ + OExternalLockGuard aGuard( this ); + // IA2 CWS. MT: We had the additional roles in UAA for ever, but never used them anywhere. + // Looks reasonable, but need to verify in Orca and VoiceOver. + sal_Int16 nRole = AccessibleRole::MENU_ITEM; + if ( m_pParent ) + { + sal_uInt16 nItemId = m_pParent->GetItemId( m_nItemPos ); + MenuItemBits nItemBits = m_pParent->GetItemBits(nItemId); + if( nItemBits & MenuItemBits::RADIOCHECK) + nRole = AccessibleRole::RADIO_MENU_ITEM; + else if( nItemBits & MenuItemBits::CHECKABLE) + nRole = AccessibleRole::CHECK_MENU_ITEM; + } + return nRole; +} + + +// XAccessibleText + + +sal_Int32 VCLXAccessibleMenuItem::getCaretPosition() +{ + return -1; +} + + +sal_Bool VCLXAccessibleMenuItem::setCaretPosition( sal_Int32 nIndex ) +{ + + OExternalLockGuard aGuard( this ); + + if ( !implIsValidRange( nIndex, nIndex, m_sItemText.getLength() ) ) + throw IndexOutOfBoundsException(); + + return false; +} + + +sal_Unicode VCLXAccessibleMenuItem::getCharacter( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + return OCommonAccessibleText::implGetCharacter( implGetText(), nIndex ); +} + + +Sequence< PropertyValue > VCLXAccessibleMenuItem::getCharacterAttributes( sal_Int32 nIndex, const Sequence< OUString >& aRequestedAttributes ) +{ + OExternalLockGuard aGuard( this ); + + if ( !implIsValidIndex( nIndex, m_sItemText.getLength() ) ) + throw IndexOutOfBoundsException(); + + vcl::Font aFont = Application::GetSettings().GetStyleSettings().GetMenuFont(); + sal_Int32 nBackColor = getBackground(); + sal_Int32 nColor = getForeground(); + return CharacterAttributesHelper( aFont, nBackColor, nColor ) + .GetCharacterAttributes( aRequestedAttributes ); +} + + +awt::Rectangle VCLXAccessibleMenuItem::getCharacterBounds( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( !implIsValidIndex( nIndex, m_sItemText.getLength() ) ) + throw IndexOutOfBoundsException(); + + awt::Rectangle aBounds( 0, 0, 0, 0 ); + if ( m_pParent ) + { + sal_uInt16 nItemId = m_pParent->GetItemId( m_nItemPos ); + tools::Rectangle aItemRect = m_pParent->GetBoundingRectangle( m_nItemPos ); + tools::Rectangle aCharRect = m_pParent->GetCharacterBounds( nItemId, nIndex ); + aCharRect.Move( -aItemRect.Left(), -aItemRect.Top() ); + aBounds = AWTRectangle( aCharRect ); + } + + return aBounds; +} + + +sal_Int32 VCLXAccessibleMenuItem::getCharacterCount() +{ + OExternalLockGuard aGuard( this ); + + return m_sItemText.getLength(); +} + + +sal_Int32 VCLXAccessibleMenuItem::getIndexAtPoint( const awt::Point& aPoint ) +{ + OExternalLockGuard aGuard( this ); + + sal_Int32 nIndex = -1; + if ( m_pParent ) + { + sal_uInt16 nItemId = 0; + tools::Rectangle aItemRect = m_pParent->GetBoundingRectangle( m_nItemPos ); + Point aPnt( VCLPoint( aPoint ) ); + aPnt += aItemRect.TopLeft(); + sal_Int32 nI = m_pParent->GetIndexForPoint( aPnt, nItemId ); + if ( nI != -1 && m_pParent->GetItemId( m_nItemPos ) == nItemId ) + nIndex = nI; + } + + return nIndex; +} + + +OUString VCLXAccessibleMenuItem::getSelectedText() +{ + OExternalLockGuard aGuard( this ); + + return OUString(); +} + + +sal_Int32 VCLXAccessibleMenuItem::getSelectionStart() +{ + OExternalLockGuard aGuard( this ); + + return 0; +} + + +sal_Int32 VCLXAccessibleMenuItem::getSelectionEnd() +{ + OExternalLockGuard aGuard( this ); + + return 0; +} + + +sal_Bool VCLXAccessibleMenuItem::setSelection( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( !implIsValidRange( nStartIndex, nEndIndex, m_sItemText.getLength() ) ) + throw IndexOutOfBoundsException(); + + return false; +} + + +OUString VCLXAccessibleMenuItem::getText() +{ + OExternalLockGuard aGuard( this ); + + return m_sItemText; +} + + +OUString VCLXAccessibleMenuItem::getTextRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) +{ + OExternalLockGuard aGuard( this ); + + return OCommonAccessibleText::implGetTextRange( implGetText(), nStartIndex, nEndIndex ); +} + + +css::accessibility::TextSegment VCLXAccessibleMenuItem::getTextAtIndex( sal_Int32 nIndex, sal_Int16 aTextType ) +{ + OExternalLockGuard aGuard( this ); + + return OCommonAccessibleText::getTextAtIndex( nIndex, aTextType ); +} + + +css::accessibility::TextSegment VCLXAccessibleMenuItem::getTextBeforeIndex( sal_Int32 nIndex, sal_Int16 aTextType ) +{ + OExternalLockGuard aGuard( this ); + + return OCommonAccessibleText::getTextBeforeIndex( nIndex, aTextType ); +} + + +css::accessibility::TextSegment VCLXAccessibleMenuItem::getTextBehindIndex( sal_Int32 nIndex, sal_Int16 aTextType ) +{ + OExternalLockGuard aGuard( this ); + + return OCommonAccessibleText::getTextBehindIndex( nIndex, aTextType ); +} + + +sal_Bool VCLXAccessibleMenuItem::copyText( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) +{ + OExternalLockGuard aGuard( this ); + + bool bReturn = false; + + if ( m_pParent ) + { + vcl::Window* pWindow = m_pParent->GetWindow(); + if ( pWindow ) + { + Reference< datatransfer::clipboard::XClipboard > xClipboard = pWindow->GetClipboard(); + if ( xClipboard.is() ) + { + OUString sText( getTextRange( nStartIndex, nEndIndex ) ); + + rtl::Reference<vcl::unohelper::TextDataObject> pDataObj = new vcl::unohelper::TextDataObject( sText ); + + SolarMutexReleaser aReleaser; + xClipboard->setContents( pDataObj, nullptr ); + Reference< datatransfer::clipboard::XFlushableClipboard > xFlushableClipboard( xClipboard, uno::UNO_QUERY ); + if( xFlushableClipboard.is() ) + xFlushableClipboard->flushClipboard(); + + bReturn = true; + } + } + } + + return bReturn; +} + +sal_Bool VCLXAccessibleMenuItem::scrollSubstringTo( sal_Int32, sal_Int32, AccessibleScrollType ) +{ + return false; +} + + +// XAccessibleAction + + +sal_Int32 VCLXAccessibleMenuItem::getAccessibleActionCount( ) +{ + return 1; +} + + +sal_Bool VCLXAccessibleMenuItem::doAccessibleAction ( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nIndex != 0 ) + throw IndexOutOfBoundsException(); + + Click(); + + return true; +} + + +OUString VCLXAccessibleMenuItem::getAccessibleActionDescription ( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nIndex != 0 ) + throw IndexOutOfBoundsException(); + + return RID_STR_ACC_ACTION_SELECT; +} + + +Reference< XAccessibleKeyBinding > VCLXAccessibleMenuItem::getAccessibleActionKeyBinding( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nIndex != 0 ) + throw IndexOutOfBoundsException(); + + rtl::Reference<OAccessibleKeyBindingHelper> pKeyBindingHelper = new OAccessibleKeyBindingHelper(); + + if ( m_pParent ) + { + // create auto mnemonics + if (!(m_pParent->GetMenuFlags() & MenuFlags::NoAutoMnemonics)) + m_pParent->CreateAutoMnemonics(); + + // activation key + KeyEvent aKeyEvent = m_pParent->GetActivationKey( m_pParent->GetItemId( m_nItemPos ) ); + vcl::KeyCode aKeyCode = aKeyEvent.GetKeyCode(); + Sequence< awt::KeyStroke > aSeq1 + { + { + 0, // Modifiers + static_cast< sal_Int16 >(aKeyCode.GetCode()), + aKeyEvent.GetCharCode(), + static_cast< sal_Int16 >( aKeyCode.GetFunction()) + } + }; + Reference< XAccessible > xParent( getAccessibleParent() ); + if ( xParent.is() ) + { + Reference< XAccessibleContext > xParentContext( xParent->getAccessibleContext() ); + if ( xParentContext.is() && xParentContext->getAccessibleRole() == AccessibleRole::MENU_BAR ) + aSeq1.getArray()[0].Modifiers |= awt::KeyModifier::MOD2; + } + pKeyBindingHelper->AddKeyBinding( aSeq1 ); + + // complete menu activation key sequence + Sequence< awt::KeyStroke > aSeq; + if ( xParent.is() ) + { + Reference< XAccessibleContext > xParentContext( xParent->getAccessibleContext() ); + if ( xParentContext.is() && xParentContext->getAccessibleRole() == AccessibleRole::MENU ) + { + Reference< XAccessibleAction > xAction( xParentContext, UNO_QUERY ); + if ( xAction.is() && xAction->getAccessibleActionCount() > 0 ) + { + Reference< XAccessibleKeyBinding > xKeyB( xAction->getAccessibleActionKeyBinding( 0 ) ); + if ( xKeyB.is() && xKeyB->getAccessibleKeyBindingCount() > 1 ) + aSeq = xKeyB->getAccessibleKeyBinding( 1 ); + } + } + } + Sequence< awt::KeyStroke > aSeq2 = ::comphelper::concatSequences( aSeq, aSeq1 ); + pKeyBindingHelper->AddKeyBinding( aSeq2 ); + + // accelerator key + vcl::KeyCode aAccelKeyCode = m_pParent->GetAccelKey( m_pParent->GetItemId( m_nItemPos ) ); + if ( aAccelKeyCode.GetCode() != 0 ) + { + Sequence< awt::KeyStroke > aSeq3 + { + { + 0, // Modifiers + static_cast< sal_Int16 >(aAccelKeyCode.GetCode()), + aKeyEvent.GetCharCode(), + static_cast< sal_Int16 >(aAccelKeyCode.GetFunction()) + } + }; + if (aAccelKeyCode.GetModifier() != 0) + { + auto pSeq3 = aSeq3.getArray(); + if ( aAccelKeyCode.IsShift() ) + pSeq3[0].Modifiers |= awt::KeyModifier::SHIFT; + if ( aAccelKeyCode.IsMod1() ) + pSeq3[0].Modifiers |= awt::KeyModifier::MOD1; + if ( aAccelKeyCode.IsMod2() ) + pSeq3[0].Modifiers |= awt::KeyModifier::MOD2; + if ( aAccelKeyCode.IsMod3() ) + pSeq3[0].Modifiers |= awt::KeyModifier::MOD3; + } + pKeyBindingHelper->AddKeyBinding( aSeq3 ); + } + } + + return pKeyBindingHelper; +} + + +// XAccessibleValue + + +Any VCLXAccessibleMenuItem::getCurrentValue( ) +{ + OExternalLockGuard aGuard( this ); + + Any aValue; + if ( IsSelected() ) + aValue <<= sal_Int32(1); + else + aValue <<= sal_Int32(0); + + return aValue; +} + + +sal_Bool VCLXAccessibleMenuItem::setCurrentValue( const Any& aNumber ) +{ + OExternalLockGuard aGuard( this ); + + bool bReturn = false; + sal_Int32 nValue = 0; + OSL_VERIFY( aNumber >>= nValue ); + + if ( nValue <= 0 ) + { + DeSelect(); + bReturn = true; + } + else if ( nValue >= 1 ) + { + Select(); + bReturn = true; + } + + return bReturn; +} + + +Any VCLXAccessibleMenuItem::getMaximumValue( ) +{ + Any aValue; + aValue <<= sal_Int32(1); + + return aValue; +} + + +Any VCLXAccessibleMenuItem::getMinimumValue( ) +{ + Any aValue; + aValue <<= sal_Int32(0); + + return aValue; +} + +Any VCLXAccessibleMenuItem::getMinimumIncrement( ) +{ + Any aValue; + aValue <<= sal_Int32(1); + + return aValue; +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessiblemenuseparator.cxx b/accessibility/source/standard/vclxaccessiblemenuseparator.cxx new file mode 100644 index 000000000..50a70df01 --- /dev/null +++ b/accessibility/source/standard/vclxaccessiblemenuseparator.cxx @@ -0,0 +1,50 @@ +/* -*- 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 <standard/vclxaccessiblemenuseparator.hxx> + +#include <com/sun/star/accessibility/AccessibleRole.hpp> + +using namespace ::com::sun::star::accessibility; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star; +using namespace ::comphelper; + +VCLXAccessibleMenuSeparator::VCLXAccessibleMenuSeparator(Menu* pParent, sal_uInt16 nItemPos) + : OAccessibleMenuItemComponent(pParent, nItemPos, nullptr) +{ +} + +// XServiceInfo + +OUString VCLXAccessibleMenuSeparator::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleMenuSeparator"; +} + +Sequence<OUString> VCLXAccessibleMenuSeparator::getSupportedServiceNames() +{ + return { "com.sun.star.awt.AccessibleMenuSeparator" }; +} + +// XAccessibleContext + +sal_Int16 VCLXAccessibleMenuSeparator::getAccessibleRole() { return AccessibleRole::SEPARATOR; } + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessiblepopupmenu.cxx b/accessibility/source/standard/vclxaccessiblepopupmenu.cxx new file mode 100644 index 000000000..ad3e7441e --- /dev/null +++ b/accessibility/source/standard/vclxaccessiblepopupmenu.cxx @@ -0,0 +1,84 @@ +/* -*- 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 <standard/vclxaccessiblepopupmenu.hxx> + +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <vcl/svapp.hxx> +#include <vcl/settings.hxx> + +using namespace ::com::sun::star::accessibility; +using namespace ::com::sun::star::uno; +using namespace ::comphelper; + + + + +bool VCLXAccessiblePopupMenu::IsFocused() +{ + return !IsChildHighlighted(); +} + + +// XServiceInfo + + +OUString VCLXAccessiblePopupMenu::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessiblePopupMenu"; +} + + +Sequence< OUString > VCLXAccessiblePopupMenu::getSupportedServiceNames() +{ + return { "com.sun.star.awt.AccessiblePopupMenu" }; +} + + +// XAccessibleContext + + +sal_Int32 VCLXAccessiblePopupMenu::getAccessibleIndexInParent( ) +{ + OExternalLockGuard aGuard( this ); + + return 0; +} + + +sal_Int16 VCLXAccessiblePopupMenu::getAccessibleRole( ) +{ + OExternalLockGuard aGuard( this ); + + return AccessibleRole::POPUP_MENU; +} + + +// XAccessibleExtendedComponent + + +sal_Int32 VCLXAccessiblePopupMenu::getBackground( ) +{ + OExternalLockGuard aGuard( this ); + + return sal_Int32(Application::GetSettings().GetStyleSettings().GetMenuColor()); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessibleradiobutton.cxx b/accessibility/source/standard/vclxaccessibleradiobutton.cxx new file mode 100644 index 000000000..c1a23ede2 --- /dev/null +++ b/accessibility/source/standard/vclxaccessibleradiobutton.cxx @@ -0,0 +1,281 @@ +/* -*- 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 <standard/vclxaccessibleradiobutton.hxx> + +#include <toolkit/awt/vclxwindows.hxx> + +#include <unotools/accessiblerelationsethelper.hxx> +#include <unotools/accessiblestatesethelper.hxx> +#include <comphelper/accessiblekeybindinghelper.hxx> +#include <com/sun/star/awt/KeyModifier.hpp> +#include <com/sun/star/accessibility/AccessibleRelationType.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <vcl/window.hxx> +#include <vcl/toolkit/button.hxx> +#include <vcl/event.hxx> +#include <vcl/vclevent.hxx> +#include <strings.hxx> + +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; +using namespace ::comphelper; + + +// VCLXAccessibleRadioButton + + +void VCLXAccessibleRadioButton::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent ) +{ + switch ( rVclWindowEvent.GetId() ) + { + case VclEventId::RadiobuttonToggle: + { + Any aOldValue; + Any aNewValue; + + VCLXRadioButton* pVCLXRadioButton = static_cast< VCLXRadioButton* >( GetVCLXWindow() ); + if ( pVCLXRadioButton && pVCLXRadioButton->getState() ) + aNewValue <<= AccessibleStateType::CHECKED; + else + aOldValue <<= AccessibleStateType::CHECKED; + + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue ); + } + break; + default: + VCLXAccessibleTextComponent::ProcessWindowEvent( rVclWindowEvent ); + } +} + + +void VCLXAccessibleRadioButton::FillAccessibleRelationSet( utl::AccessibleRelationSetHelper& rRelationSet ) +{ + VCLXAccessibleTextComponent::FillAccessibleRelationSet( rRelationSet ); + + VclPtr< RadioButton > pRadioButton = GetAsDynamic< RadioButton >(); + if ( !pRadioButton ) + return; + + std::vector< VclPtr<RadioButton> > aGroup(pRadioButton->GetRadioButtonGroup()); + if (!aGroup.empty()) + { + std::vector< Reference< XInterface > > aVec; + aVec.reserve(aGroup.size()); + std::transform(aGroup.begin(), aGroup.end(), std::back_inserter(aVec), + [](const VclPtr<RadioButton>& rxItem) { return rxItem->GetAccessible(); }); + rRelationSet.AddRelation( AccessibleRelation( AccessibleRelationType::MEMBER_OF, + comphelper::containerToSequence(aVec) ) ); + } +} + + +void VCLXAccessibleRadioButton::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet ) +{ + VCLXAccessibleTextComponent::FillAccessibleStateSet( rStateSet ); + + VCLXRadioButton* pVCLXRadioButton = static_cast< VCLXRadioButton* >( GetVCLXWindow() ); + if ( pVCLXRadioButton ) + { + rStateSet.AddState( AccessibleStateType::FOCUSABLE ); + if ( pVCLXRadioButton->getState() ) + rStateSet.AddState( AccessibleStateType::CHECKED ); + } +} + + +// XInterface + + +IMPLEMENT_FORWARD_XINTERFACE2( VCLXAccessibleRadioButton, VCLXAccessibleTextComponent, VCLXAccessibleRadioButton_BASE ) + + +// XTypeProvider + + +IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXAccessibleRadioButton, VCLXAccessibleTextComponent, VCLXAccessibleRadioButton_BASE ) + + +// XServiceInfo + + +OUString VCLXAccessibleRadioButton::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleRadioButton"; +} + + +Sequence< OUString > VCLXAccessibleRadioButton::getSupportedServiceNames() +{ + return { "com.sun.star.awt.AccessibleRadioButton" }; +} + + +// XAccessibleAction + + +sal_Int32 VCLXAccessibleRadioButton::getAccessibleActionCount( ) +{ + OExternalLockGuard aGuard( this ); + + return 1; +} + + +sal_Bool VCLXAccessibleRadioButton::doAccessibleAction ( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nIndex != 0 ) + throw IndexOutOfBoundsException(); + + VCLXRadioButton* pVCLXRadioButton = static_cast< VCLXRadioButton* >( GetVCLXWindow() ); + if ( pVCLXRadioButton && !pVCLXRadioButton->getState() ) + pVCLXRadioButton->setState( true ); + + return true; +} + +OUString VCLXAccessibleRadioButton::getAccessibleActionDescription ( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nIndex != 0 ) + throw IndexOutOfBoundsException(); + + return RID_STR_ACC_ACTION_SELECT; +} + +Reference< XAccessibleKeyBinding > VCLXAccessibleRadioButton::getAccessibleActionKeyBinding( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nIndex != 0 ) + throw IndexOutOfBoundsException(); + + rtl::Reference<OAccessibleKeyBindingHelper> pKeyBindingHelper = new OAccessibleKeyBindingHelper(); + + VclPtr<vcl::Window> pWindow = GetWindow(); + if ( pWindow ) + { + KeyEvent aKeyEvent = pWindow->GetActivationKey(); + vcl::KeyCode aKeyCode = aKeyEvent.GetKeyCode(); + if ( aKeyCode.GetCode() != 0 ) + { + awt::KeyStroke aKeyStroke; + aKeyStroke.Modifiers = 0; + if ( aKeyCode.IsShift() ) + aKeyStroke.Modifiers |= awt::KeyModifier::SHIFT; + if ( aKeyCode.IsMod1() ) + aKeyStroke.Modifiers |= awt::KeyModifier::MOD1; + if ( aKeyCode.IsMod2() ) + aKeyStroke.Modifiers |= awt::KeyModifier::MOD2; + if ( aKeyCode.IsMod3() ) + aKeyStroke.Modifiers |= awt::KeyModifier::MOD3; + aKeyStroke.KeyCode = aKeyCode.GetCode(); + aKeyStroke.KeyChar = aKeyEvent.GetCharCode(); + aKeyStroke.KeyFunc = static_cast< sal_Int16 >( aKeyCode.GetFunction() ); + pKeyBindingHelper->AddKeyBinding( aKeyStroke ); + } + } + + return pKeyBindingHelper; +} + + +// XAccessibleValue + + +Any VCLXAccessibleRadioButton::getCurrentValue( ) +{ + OExternalLockGuard aGuard( this ); + + Any aValue; + + VCLXRadioButton* pVCLXRadioButton = static_cast< VCLXRadioButton* >( GetVCLXWindow() ); + if ( pVCLXRadioButton ) + aValue <<= static_cast<sal_Int32>(pVCLXRadioButton->getState()); + + return aValue; +} + + +sal_Bool VCLXAccessibleRadioButton::setCurrentValue( const Any& aNumber ) +{ + OExternalLockGuard aGuard( this ); + + bool bReturn = false; + + VCLXRadioButton* pVCLXRadioButton = static_cast< VCLXRadioButton* >( GetVCLXWindow() ); + if ( pVCLXRadioButton ) + { + sal_Int32 nValue = 0; + OSL_VERIFY( aNumber >>= nValue ); + + if ( nValue < 0 ) + nValue = 0; + else if ( nValue > 1 ) + nValue = 1; + + pVCLXRadioButton->setState( nValue == 1 ); + bReturn = true; + } + + return bReturn; +} + + +Any VCLXAccessibleRadioButton::getMaximumValue( ) +{ + OExternalLockGuard aGuard( this ); + + Any aValue; + aValue <<= sal_Int32(1); + + return aValue; +} + + +Any VCLXAccessibleRadioButton::getMinimumValue( ) +{ + OExternalLockGuard aGuard( this ); + + Any aValue; + aValue <<= sal_Int32(0); + + return aValue; +} + +Any VCLXAccessibleRadioButton::getMinimumIncrement( ) +{ + OExternalLockGuard aGuard( this ); + + Any aValue; + aValue <<= sal_Int32(1); + + return aValue; +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessiblescrollbar.cxx b/accessibility/source/standard/vclxaccessiblescrollbar.cxx new file mode 100644 index 000000000..9ddb5e12a --- /dev/null +++ b/accessibility/source/standard/vclxaccessiblescrollbar.cxx @@ -0,0 +1,272 @@ +/* -*- 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 <standard/vclxaccessiblescrollbar.hxx> + +#include <toolkit/awt/vclxwindows.hxx> +#include <helper/accresmgr.hxx> +#include <strings.hrc> + +#include <unotools/accessiblestatesethelper.hxx> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/awt/ScrollBarOrientation.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <vcl/scrbar.hxx> +#include <vcl/vclevent.hxx> +#include <strings.hxx> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::awt; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::accessibility; +using namespace ::comphelper; + + +// VCLXAccessibleScrollBar + + +void VCLXAccessibleScrollBar::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent ) +{ + switch ( rVclWindowEvent.GetId() ) + { + case VclEventId::ScrollbarScroll: + { + NotifyAccessibleEvent( AccessibleEventId::VALUE_CHANGED, Any(), Any() ); + } + break; + default: + VCLXAccessibleComponent::ProcessWindowEvent( rVclWindowEvent ); + } +} + + +void VCLXAccessibleScrollBar::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet ) +{ + VCLXAccessibleComponent::FillAccessibleStateSet( rStateSet ); + + VCLXScrollBar* pVCLXScrollBar = static_cast< VCLXScrollBar* >( GetVCLXWindow() ); + if ( pVCLXScrollBar ) + { + // IA2 CWS: scroll bar should not have FOCUSABLE state. + // rStateSet.AddState( AccessibleStateType::FOCUSABLE ); + if ( pVCLXScrollBar->getOrientation() == ScrollBarOrientation::HORIZONTAL ) + rStateSet.AddState( AccessibleStateType::HORIZONTAL ); + else if ( pVCLXScrollBar->getOrientation() == ScrollBarOrientation::VERTICAL ) + rStateSet.AddState( AccessibleStateType::VERTICAL ); + } +} + + +// XInterface + + +IMPLEMENT_FORWARD_XINTERFACE2( VCLXAccessibleScrollBar, VCLXAccessibleComponent, VCLXAccessibleScrollBar_BASE ) + + +// XTypeProvider + + +IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXAccessibleScrollBar, VCLXAccessibleComponent, VCLXAccessibleScrollBar_BASE ) + + +// XServiceInfo + + +OUString VCLXAccessibleScrollBar::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleScrollBar"; +} + + +Sequence< OUString > VCLXAccessibleScrollBar::getSupportedServiceNames() +{ + return { "com.sun.star.awt.AccessibleScrollBar" }; +} + + +// XAccessibleAction + +constexpr sal_Int32 ACCESSIBLE_ACTION_COUNT=4; + +sal_Int32 VCLXAccessibleScrollBar::getAccessibleActionCount( ) +{ + OExternalLockGuard aGuard( this ); + + return ACCESSIBLE_ACTION_COUNT; +} + + +sal_Bool VCLXAccessibleScrollBar::doAccessibleAction ( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nIndex < 0 || nIndex >= ACCESSIBLE_ACTION_COUNT ) + throw IndexOutOfBoundsException(); + + bool bReturn = false; + VclPtr< ScrollBar > pScrollBar = GetAs< ScrollBar >(); + if ( pScrollBar ) + { + ScrollType eScrollType; + switch ( nIndex ) + { + case 0: eScrollType = ScrollType::LineUp; break; + case 1: eScrollType = ScrollType::LineDown; break; + case 2: eScrollType = ScrollType::PageUp; break; + case 3: eScrollType = ScrollType::PageDown; break; + default: eScrollType = ScrollType::DontKnow; break; + } + if ( pScrollBar->DoScrollAction( eScrollType ) ) + bReturn = true; + } + + return bReturn; +} + + +OUString VCLXAccessibleScrollBar::getAccessibleActionDescription ( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nIndex < 0 || nIndex >= ACCESSIBLE_ACTION_COUNT ) + throw IndexOutOfBoundsException(); + + OUString sDescription; + + switch ( nIndex ) + { + case 0: sDescription = OUString(RID_STR_ACC_ACTION_DECLINE); break; + case 1: sDescription = OUString(RID_STR_ACC_ACTION_INCLINE); break; + case 2: sDescription = OUString(RID_STR_ACC_ACTION_DECBLOCK); break; + case 3: sDescription = OUString(RID_STR_ACC_ACTION_INCBLOCK); break; + default: break; + } + + return sDescription; +} + + +Reference< XAccessibleKeyBinding > VCLXAccessibleScrollBar::getAccessibleActionKeyBinding( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nIndex < 0 || nIndex >= ACCESSIBLE_ACTION_COUNT ) + throw IndexOutOfBoundsException(); + + return Reference< XAccessibleKeyBinding >(); +} + + +// XAccessibleValue + + +Any VCLXAccessibleScrollBar::getCurrentValue( ) +{ + OExternalLockGuard aGuard( this ); + + Any aValue; + + VCLXScrollBar* pVCLXScrollBar = static_cast< VCLXScrollBar* >( GetVCLXWindow() ); + if ( pVCLXScrollBar ) + aValue <<= pVCLXScrollBar->getValue(); + + return aValue; +} + + +sal_Bool VCLXAccessibleScrollBar::setCurrentValue( const Any& aNumber ) +{ + OExternalLockGuard aGuard( this ); + + bool bReturn = false; + + VCLXScrollBar* pVCLXScrollBar = static_cast< VCLXScrollBar* >( GetVCLXWindow() ); + if ( pVCLXScrollBar ) + { + sal_Int32 nValue = 0, nValueMin = 0, nValueMax = 0; + OSL_VERIFY( aNumber >>= nValue ); + OSL_VERIFY( getMinimumValue() >>= nValueMin ); + OSL_VERIFY( getMaximumValue() >>= nValueMax ); + + if ( nValue < nValueMin ) + nValue = nValueMin; + else if ( nValue > nValueMax ) + nValue = nValueMax; + + pVCLXScrollBar->setValue( nValue ); + bReturn = true; + } + + return bReturn; +} + + +Any VCLXAccessibleScrollBar::getMaximumValue( ) +{ + OExternalLockGuard aGuard( this ); + + Any aValue; + + VCLXScrollBar* pVCLXScrollBar = static_cast< VCLXScrollBar* >( GetVCLXWindow() ); + if ( pVCLXScrollBar ) + aValue <<= pVCLXScrollBar->getMaximum(); + + return aValue; +} + + +Any VCLXAccessibleScrollBar::getMinimumValue( ) +{ + OExternalLockGuard aGuard( this ); + + Any aValue; + aValue <<= sal_Int32(0); + + return aValue; +} + +Any VCLXAccessibleScrollBar::getMinimumIncrement( ) +{ + OExternalLockGuard aGuard( this ); + + return Any(); +} + + +OUString VCLXAccessibleScrollBar::getAccessibleName( ) +{ + OExternalLockGuard aGuard( this ); + + OUString aName; + VCLXScrollBar* pVCLXScrollBar = static_cast< VCLXScrollBar* >( GetVCLXWindow() ); + if ( pVCLXScrollBar ) + { + if ( pVCLXScrollBar->getOrientation() == ScrollBarOrientation::HORIZONTAL ) + aName = AccResId( RID_STR_ACC_SCROLLBAR_NAME_HORIZONTAL ); + else if ( pVCLXScrollBar->getOrientation() == ScrollBarOrientation::VERTICAL ) + aName = AccResId( RID_STR_ACC_SCROLLBAR_NAME_VERTICAL ); + } + return aName; +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessiblestatusbar.cxx b/accessibility/source/standard/vclxaccessiblestatusbar.cxx new file mode 100644 index 000000000..d6e3e0ef5 --- /dev/null +++ b/accessibility/source/standard/vclxaccessiblestatusbar.cxx @@ -0,0 +1,335 @@ +/* -*- 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 <standard/vclxaccessiblestatusbar.hxx> +#include <standard/vclxaccessiblestatusbaritem.hxx> +#include <toolkit/helper/convert.hxx> +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <o3tl/safeint.hxx> +#include <vcl/status.hxx> +#include <vcl/vclevent.hxx> + + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::accessibility; +using namespace ::comphelper; + + + + +VCLXAccessibleStatusBar::VCLXAccessibleStatusBar( VCLXWindow* pVCLXWindow ) + :VCLXAccessibleComponent( pVCLXWindow ) +{ + m_pStatusBar = GetAs<StatusBar>(); + + if ( m_pStatusBar ) + m_aAccessibleChildren.assign( m_pStatusBar->GetItemCount(), Reference< XAccessible >() ); +} + + +void VCLXAccessibleStatusBar::UpdateShowing( sal_Int32 i, bool bShowing ) +{ + if ( i >= 0 && o3tl::make_unsigned(i) < m_aAccessibleChildren.size() ) + { + Reference< XAccessible > xChild( m_aAccessibleChildren[i] ); + if ( xChild.is() ) + { + VCLXAccessibleStatusBarItem* pVCLXAccessibleStatusBarItem = static_cast< VCLXAccessibleStatusBarItem* >( xChild.get() ); + if ( pVCLXAccessibleStatusBarItem ) + pVCLXAccessibleStatusBarItem->SetShowing( bShowing ); + } + } +} + + +void VCLXAccessibleStatusBar::UpdateItemName( sal_Int32 i ) +{ + if ( i < 0 || o3tl::make_unsigned(i) >= m_aAccessibleChildren.size() ) + return; + + Reference< XAccessible > xChild( m_aAccessibleChildren[i] ); + if ( xChild.is() ) + { + VCLXAccessibleStatusBarItem* pVCLXAccessibleStatusBarItem = static_cast< VCLXAccessibleStatusBarItem* >( xChild.get() ); + if ( pVCLXAccessibleStatusBarItem ) + { + OUString sItemName = pVCLXAccessibleStatusBarItem->GetItemName(); + pVCLXAccessibleStatusBarItem->SetItemName( sItemName ); + } + } +} + + +void VCLXAccessibleStatusBar::UpdateItemText( sal_Int32 i ) +{ + if ( i < 0 || o3tl::make_unsigned(i) >= m_aAccessibleChildren.size() ) + return; + + Reference< XAccessible > xChild( m_aAccessibleChildren[i] ); + if ( xChild.is() ) + { + VCLXAccessibleStatusBarItem* pVCLXAccessibleStatusBarItem = static_cast< VCLXAccessibleStatusBarItem* >( xChild.get() ); + if ( pVCLXAccessibleStatusBarItem ) + { + OUString sItemText = pVCLXAccessibleStatusBarItem->GetItemText(); + pVCLXAccessibleStatusBarItem->SetItemText( sItemText ); + } + } +} + + +void VCLXAccessibleStatusBar::InsertChild( sal_Int32 i ) +{ + if ( i < 0 || o3tl::make_unsigned(i) > m_aAccessibleChildren.size() ) + return; + + // insert entry in child list + m_aAccessibleChildren.insert( m_aAccessibleChildren.begin() + i, Reference< XAccessible >() ); + + // send accessible child event + Reference< XAccessible > xChild( getAccessibleChild( i ) ); + if ( xChild.is() ) + { + Any aOldValue, aNewValue; + aNewValue <<= xChild; + NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue ); + } +} + + +void VCLXAccessibleStatusBar::RemoveChild( sal_Int32 i ) +{ + if ( i < 0 || o3tl::make_unsigned(i) >= m_aAccessibleChildren.size() ) + return; + + // get the accessible of the removed page + Reference< XAccessible > xChild( m_aAccessibleChildren[i] ); + + // remove entry in child list + m_aAccessibleChildren.erase( m_aAccessibleChildren.begin() + i ); + + // send accessible child event + if ( xChild.is() ) + { + Any aOldValue, aNewValue; + aOldValue <<= xChild; + NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue ); + + Reference< XComponent > xComponent( xChild, UNO_QUERY ); + if ( xComponent.is() ) + xComponent->dispose(); + } +} + + +void VCLXAccessibleStatusBar::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent ) +{ + switch ( rVclWindowEvent.GetId() ) + { + case VclEventId::StatusbarItemAdded: + { + if ( m_pStatusBar ) + { + sal_uInt16 nItemId = static_cast<sal_uInt16>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())); + sal_uInt16 nItemPos = m_pStatusBar->GetItemPos( nItemId ); + InsertChild( nItemPos ); + } + } + break; + case VclEventId::StatusbarItemRemoved: + { + if ( m_pStatusBar ) + { + sal_uInt16 nItemId = static_cast<sal_uInt16>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())); + for ( sal_Int32 i = 0, nCount = getAccessibleChildCount(); i < nCount; ++i ) + { + Reference< XAccessible > xChild( getAccessibleChild( i ) ); + if ( xChild.is() ) + { + VCLXAccessibleStatusBarItem* pVCLXAccessibleStatusBarItem = static_cast< VCLXAccessibleStatusBarItem* >( xChild.get() ); + if ( pVCLXAccessibleStatusBarItem && pVCLXAccessibleStatusBarItem->GetItemId() == nItemId ) + { + RemoveChild( i ); + break; + } + } + } + } + } + break; + case VclEventId::StatusbarAllItemsRemoved: + { + for ( sal_Int32 i = m_aAccessibleChildren.size() - 1; i >= 0; --i ) + RemoveChild( i ); + } + break; + case VclEventId::StatusbarShowItem: + case VclEventId::StatusbarHideItem: + { + if ( m_pStatusBar ) + { + sal_uInt16 nItemId = static_cast<sal_uInt16>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())); + sal_uInt16 nItemPos = m_pStatusBar->GetItemPos( nItemId ); + UpdateShowing( nItemPos, rVclWindowEvent.GetId() == VclEventId::StatusbarShowItem ); + } + } + break; + case VclEventId::StatusbarNameChanged: + { + if ( m_pStatusBar ) + { + sal_uInt16 nItemId = static_cast<sal_uInt16>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())); + sal_uInt16 nItemPos = m_pStatusBar->GetItemPos( nItemId ); + UpdateItemName( nItemPos ); + } + } + break; + case VclEventId::StatusbarDrawItem: + { + if ( m_pStatusBar ) + { + sal_uInt16 nItemId = static_cast<sal_uInt16>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())); + sal_uInt16 nItemPos = m_pStatusBar->GetItemPos( nItemId ); + UpdateItemText( nItemPos ); + } + } + break; + case VclEventId::ObjectDying: + { + if ( m_pStatusBar ) + { + m_pStatusBar = nullptr; + + // dispose all children + for (const Reference<XAccessible>& i : m_aAccessibleChildren) + { + Reference< XComponent > xComponent( i, UNO_QUERY ); + if ( xComponent.is() ) + xComponent->dispose(); + } + m_aAccessibleChildren.clear(); + } + + VCLXAccessibleComponent::ProcessWindowEvent( rVclWindowEvent ); + } + break; + default: + VCLXAccessibleComponent::ProcessWindowEvent( rVclWindowEvent ); + } +} + + +// XComponent + + +void VCLXAccessibleStatusBar::disposing() +{ + VCLXAccessibleComponent::disposing(); + + if ( !m_pStatusBar ) + return; + + m_pStatusBar = nullptr; + + // dispose all children + for (const Reference<XAccessible>& i : m_aAccessibleChildren) + { + Reference< XComponent > xComponent( i, UNO_QUERY ); + if ( xComponent.is() ) + xComponent->dispose(); + } + m_aAccessibleChildren.clear(); +} + + +// XServiceInfo + + +OUString VCLXAccessibleStatusBar::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleStatusBar"; +} + + +Sequence< OUString > VCLXAccessibleStatusBar::getSupportedServiceNames() +{ + return { "com.sun.star.awt.AccessibleStatusBar" }; +} + + +// XAccessibleContext + + +sal_Int32 VCLXAccessibleStatusBar::getAccessibleChildCount() +{ + OExternalLockGuard aGuard( this ); + + return m_aAccessibleChildren.size(); +} + + +Reference< XAccessible > VCLXAccessibleStatusBar::getAccessibleChild( sal_Int32 i ) +{ + OExternalLockGuard aGuard( this ); + + if ( i < 0 || o3tl::make_unsigned(i) >= m_aAccessibleChildren.size() ) + throw IndexOutOfBoundsException(); + + Reference< XAccessible > xChild = m_aAccessibleChildren[i]; + if ( !xChild.is() ) + { + if ( m_pStatusBar ) + { + sal_uInt16 nItemId = m_pStatusBar->GetItemId( static_cast<sal_uInt16>(i) ); + + xChild = new VCLXAccessibleStatusBarItem( m_pStatusBar, nItemId ); + + // insert into status bar item list + m_aAccessibleChildren[i] = xChild; + } + } + + return xChild; +} + + +// XAccessibleComponent + + +Reference< XAccessible > VCLXAccessibleStatusBar::getAccessibleAtPoint( const awt::Point& rPoint ) +{ + OExternalLockGuard aGuard( this ); + + Reference< XAccessible > xChild; + if ( m_pStatusBar ) + { + sal_uInt16 nItemId = m_pStatusBar->GetItemId( VCLPoint( rPoint ) ); + sal_Int32 nItemPos = m_pStatusBar->GetItemPos( nItemId ); + if ( nItemPos >= 0 && o3tl::make_unsigned(nItemPos) < m_aAccessibleChildren.size() ) + xChild = getAccessibleChild( nItemPos ); + } + + return xChild; +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessiblestatusbaritem.cxx b/accessibility/source/standard/vclxaccessiblestatusbaritem.cxx new file mode 100644 index 000000000..840674206 --- /dev/null +++ b/accessibility/source/standard/vclxaccessiblestatusbaritem.cxx @@ -0,0 +1,587 @@ +/* -*- 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 <standard/vclxaccessiblestatusbaritem.hxx> +#include <toolkit/helper/convert.hxx> +#include <helper/characterattributeshelper.hxx> + +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/datatransfer/clipboard/XClipboard.hpp> +#include <com/sun/star/datatransfer/clipboard/XFlushableClipboard.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <cppuhelper/supportsservice.hxx> +#include <unotools/accessiblestatesethelper.hxx> +#include <unotools/accessiblerelationsethelper.hxx> +#include <vcl/ctrl.hxx> +#include <vcl/svapp.hxx> +#include <vcl/unohelp2.hxx> +#include <vcl/status.hxx> +#include <vcl/settings.hxx> +#include <i18nlangtag/languagetag.hxx> + +using namespace ::com::sun::star::accessibility; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star; +using namespace ::comphelper; + + + + +VCLXAccessibleStatusBarItem::VCLXAccessibleStatusBarItem( StatusBar* pStatusBar, sal_uInt16 nItemId ) + :m_pStatusBar( pStatusBar ) + ,m_nItemId( nItemId ) +{ + + m_sItemName = GetItemName(); + m_sItemText = GetItemText(); + m_bShowing = IsShowing(); +} + + +bool VCLXAccessibleStatusBarItem::IsShowing() +{ + bool bShowing = false; + + if ( m_pStatusBar ) + bShowing = m_pStatusBar->IsItemVisible( m_nItemId ); + + return bShowing; +} + + +void VCLXAccessibleStatusBarItem::SetShowing( bool bShowing ) +{ + if ( m_bShowing != bShowing ) + { + Any aOldValue, aNewValue; + if ( m_bShowing ) + aOldValue <<= AccessibleStateType::SHOWING; + else + aNewValue <<= AccessibleStateType::SHOWING; + m_bShowing = bShowing; + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue ); + } +} + + +void VCLXAccessibleStatusBarItem::SetItemName( const OUString& sItemName ) +{ + if ( m_sItemName != sItemName ) + { + Any aOldValue, aNewValue; + aOldValue <<= m_sItemName; + aNewValue <<= sItemName; + m_sItemName = sItemName; + NotifyAccessibleEvent( AccessibleEventId::NAME_CHANGED, aOldValue, aNewValue ); + } +} + + +OUString VCLXAccessibleStatusBarItem::GetItemName() +{ + OUString sName; + if ( m_pStatusBar ) + sName = m_pStatusBar->GetAccessibleName( m_nItemId ); + + return sName; +} + + +void VCLXAccessibleStatusBarItem::SetItemText( const OUString& sItemText ) +{ + Any aOldValue, aNewValue; + if ( implInitTextChangedEvent( m_sItemText, sItemText, aOldValue, aNewValue ) ) + { + m_sItemText = sItemText; + NotifyAccessibleEvent( AccessibleEventId::TEXT_CHANGED, aOldValue, aNewValue ); + } +} + + +OUString VCLXAccessibleStatusBarItem::GetItemText() +{ + OUString sText; + if ( m_pStatusBar ) + sText = m_pStatusBar->GetItemText( m_nItemId ); + + return sText; +} + + +void VCLXAccessibleStatusBarItem::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet ) +{ + rStateSet.AddState( AccessibleStateType::ENABLED ); + rStateSet.AddState( AccessibleStateType::SENSITIVE ); + + rStateSet.AddState( AccessibleStateType::VISIBLE ); + + if ( IsShowing() ) + rStateSet.AddState( AccessibleStateType::SHOWING ); +} + + +// OCommonAccessibleComponent + + +awt::Rectangle VCLXAccessibleStatusBarItem::implGetBounds() +{ + awt::Rectangle aBounds( 0, 0, 0, 0 ); + + if ( m_pStatusBar ) + aBounds = AWTRectangle( m_pStatusBar->GetItemRect( m_nItemId ) ); + + return aBounds; +} + + +// OCommonAccessibleText + + +OUString VCLXAccessibleStatusBarItem::implGetText() +{ + return GetItemText(); +} + + +lang::Locale VCLXAccessibleStatusBarItem::implGetLocale() +{ + return Application::GetSettings().GetLanguageTag().getLocale(); +} + + +void VCLXAccessibleStatusBarItem::implGetSelection( sal_Int32& nStartIndex, sal_Int32& nEndIndex ) +{ + nStartIndex = 0; + nEndIndex = 0; +} + + +// XInterface + + +IMPLEMENT_FORWARD_XINTERFACE2( VCLXAccessibleStatusBarItem, AccessibleTextHelper_BASE, VCLXAccessibleStatusBarItem_BASE ) + + +// XTypeProvider + + +IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXAccessibleStatusBarItem, AccessibleTextHelper_BASE, VCLXAccessibleStatusBarItem_BASE ) + + +// XComponent + + +void VCLXAccessibleStatusBarItem::disposing() +{ + AccessibleTextHelper_BASE::disposing(); + + m_pStatusBar = nullptr; + m_sItemName.clear(); + m_sItemText.clear(); +} + + +// XServiceInfo + + +OUString VCLXAccessibleStatusBarItem::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleStatusBarItem"; +} + + +sal_Bool VCLXAccessibleStatusBarItem::supportsService( const OUString& rServiceName ) +{ + return cppu::supportsService(this, rServiceName); +} + + +Sequence< OUString > VCLXAccessibleStatusBarItem::getSupportedServiceNames() +{ + return { "com.sun.star.awt.AccessibleStatusBarItem" }; +} + + +// XAccessible + + +Reference< XAccessibleContext > VCLXAccessibleStatusBarItem::getAccessibleContext( ) +{ + OExternalLockGuard aGuard( this ); + + return this; +} + + +// XAccessibleContext + + +sal_Int32 VCLXAccessibleStatusBarItem::getAccessibleChildCount() +{ + OExternalLockGuard aGuard( this ); + + return 0; +} + + +Reference< XAccessible > VCLXAccessibleStatusBarItem::getAccessibleChild( sal_Int32 ) +{ + throw IndexOutOfBoundsException(); +} + + +Reference< XAccessible > VCLXAccessibleStatusBarItem::getAccessibleParent( ) +{ + OExternalLockGuard aGuard( this ); + + Reference< XAccessible > xParent; + if ( m_pStatusBar ) + xParent = m_pStatusBar->GetAccessible(); + + return xParent; +} + + +sal_Int32 VCLXAccessibleStatusBarItem::getAccessibleIndexInParent( ) +{ + OExternalLockGuard aGuard( this ); + + sal_Int32 nIndexInParent = -1; + if ( m_pStatusBar ) + nIndexInParent = m_pStatusBar->GetItemPos( m_nItemId ); + + return nIndexInParent; +} + + +sal_Int16 VCLXAccessibleStatusBarItem::getAccessibleRole( ) +{ + OExternalLockGuard aGuard( this ); + + return AccessibleRole::LABEL; +} + + +OUString VCLXAccessibleStatusBarItem::getAccessibleDescription( ) +{ + OExternalLockGuard aGuard( this ); + + OUString sDescription; + if ( m_pStatusBar ) + sDescription = m_pStatusBar->GetHelpText( m_nItemId ); + + return sDescription; +} + + +OUString VCLXAccessibleStatusBarItem::getAccessibleName( ) +{ + OExternalLockGuard aGuard( this ); + + return GetItemName(); +} + + +Reference< XAccessibleRelationSet > VCLXAccessibleStatusBarItem::getAccessibleRelationSet( ) +{ + OExternalLockGuard aGuard( this ); + + return new utl::AccessibleRelationSetHelper; +} + + +Reference< XAccessibleStateSet > VCLXAccessibleStatusBarItem::getAccessibleStateSet( ) +{ + OExternalLockGuard aGuard( this ); + + rtl::Reference<utl::AccessibleStateSetHelper> pStateSetHelper = new utl::AccessibleStateSetHelper; + + if ( !rBHelper.bDisposed && !rBHelper.bInDispose ) + { + FillAccessibleStateSet( *pStateSetHelper ); + } + else + { + pStateSetHelper->AddState( AccessibleStateType::DEFUNC ); + } + + return pStateSetHelper; +} + + +Locale VCLXAccessibleStatusBarItem::getLocale( ) +{ + OExternalLockGuard aGuard( this ); + + return Application::GetSettings().GetLanguageTag().getLocale(); +} + + +// XAccessibleComponent + + +Reference< XAccessible > VCLXAccessibleStatusBarItem::getAccessibleAtPoint( const awt::Point& ) +{ + OExternalLockGuard aGuard( this ); + + return Reference< XAccessible >(); +} + + +void VCLXAccessibleStatusBarItem::grabFocus( ) +{ + // no focus for status bar items +} + + +sal_Int32 VCLXAccessibleStatusBarItem::getForeground( ) +{ + OExternalLockGuard aGuard( this ); + + sal_Int32 nColor = 0; + Reference< XAccessible > xParent = getAccessibleParent(); + if ( xParent.is() ) + { + Reference< XAccessibleComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY ); + if ( xParentComp.is() ) + nColor = xParentComp->getForeground(); + } + + return nColor; +} + + +sal_Int32 VCLXAccessibleStatusBarItem::getBackground( ) +{ + OExternalLockGuard aGuard( this ); + + sal_Int32 nColor = 0; + Reference< XAccessible > xParent = getAccessibleParent(); + if ( xParent.is() ) + { + Reference< XAccessibleComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY ); + if ( xParentComp.is() ) + nColor = xParentComp->getBackground(); + } + + return nColor; +} + + +// XAccessibleExtendedComponent + + +Reference< awt::XFont > VCLXAccessibleStatusBarItem::getFont( ) +{ + OExternalLockGuard aGuard( this ); + + Reference< awt::XFont > xFont; + Reference< XAccessible > xParent = getAccessibleParent(); + if ( xParent.is() ) + { + Reference< XAccessibleExtendedComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY ); + if ( xParentComp.is() ) + xFont = xParentComp->getFont(); + } + + return xFont; +} + + +OUString VCLXAccessibleStatusBarItem::getTitledBorderText( ) +{ + OExternalLockGuard aGuard( this ); + + return GetItemText(); +} + + +OUString VCLXAccessibleStatusBarItem::getToolTipText( ) +{ + OExternalLockGuard aGuard( this ); + + return OUString(); +} + + +// XAccessibleText + +OUString VCLXAccessibleStatusBarItem::getText() +{ + OExternalLockGuard aGuard( this ); + + return GetItemText(); +} + +OUString VCLXAccessibleStatusBarItem::getTextRange(sal_Int32 nStartIndex, sal_Int32 nEndIndex) +{ + OExternalLockGuard aGuard( this ); + + return OCommonAccessibleText::implGetTextRange(GetItemText(), nStartIndex, nEndIndex); +} + + +sal_Int32 VCLXAccessibleStatusBarItem::getCharacterCount() +{ + OExternalLockGuard aGuard( this ); + + return GetItemText().getLength(); +} + +sal_Unicode VCLXAccessibleStatusBarItem::getCharacter( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + return OCommonAccessibleText::implGetCharacter( GetItemText(), nIndex ); +} + +sal_Int32 VCLXAccessibleStatusBarItem::getCaretPosition() +{ + OExternalLockGuard aGuard( this ); + + return -1; +} + + +sal_Bool VCLXAccessibleStatusBarItem::setCaretPosition( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( !implIsValidRange( nIndex, nIndex, GetItemText().getLength() ) ) + throw IndexOutOfBoundsException(); + + return false; +} + + +Sequence< PropertyValue > VCLXAccessibleStatusBarItem::getCharacterAttributes( sal_Int32 nIndex, const Sequence< OUString >& aRequestedAttributes ) +{ + OExternalLockGuard aGuard( this ); + + Sequence< PropertyValue > aValues; + OUString sText( implGetText() ); + + if ( !implIsValidIndex( nIndex, sText.getLength() ) ) + throw IndexOutOfBoundsException(); + + if ( m_pStatusBar ) + { + vcl::Font aFont = m_pStatusBar->GetFont(); + sal_Int32 nBackColor = getBackground(); + sal_Int32 nColor = getForeground(); + aValues = CharacterAttributesHelper( aFont, nBackColor, nColor ) + .GetCharacterAttributes( aRequestedAttributes ); + } + + return aValues; +} + + +awt::Rectangle VCLXAccessibleStatusBarItem::getCharacterBounds( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( !implIsValidIndex( nIndex, implGetText().getLength() ) ) + throw IndexOutOfBoundsException(); + + awt::Rectangle aBounds( 0, 0, 0, 0 ); + if ( m_pStatusBar ) + { + vcl::ControlLayoutData aLayoutData; + tools::Rectangle aItemRect = m_pStatusBar->GetItemRect( m_nItemId ); + m_pStatusBar->RecordLayoutData( &aLayoutData, aItemRect ); + tools::Rectangle aCharRect = aLayoutData.GetCharacterBounds( nIndex ); + aCharRect.Move( -aItemRect.Left(), -aItemRect.Top() ); + aBounds = AWTRectangle( aCharRect ); + } + + return aBounds; +} + + +sal_Int32 VCLXAccessibleStatusBarItem::getIndexAtPoint( const awt::Point& aPoint ) +{ + OExternalLockGuard aGuard( this ); + + sal_Int32 nIndex = -1; + if ( m_pStatusBar ) + { + vcl::ControlLayoutData aLayoutData; + tools::Rectangle aItemRect = m_pStatusBar->GetItemRect( m_nItemId ); + m_pStatusBar->RecordLayoutData( &aLayoutData, aItemRect ); + Point aPnt( VCLPoint( aPoint ) ); + aPnt += aItemRect.TopLeft(); + nIndex = aLayoutData.GetIndexForPoint( aPnt ); + } + + return nIndex; +} + + +sal_Bool VCLXAccessibleStatusBarItem::setSelection( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( !implIsValidRange( nStartIndex, nEndIndex, implGetText().getLength() ) ) + throw IndexOutOfBoundsException(); + + return false; +} + + +sal_Bool VCLXAccessibleStatusBarItem::copyText( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) +{ + OExternalLockGuard aGuard( this ); + + bool bReturn = false; + + if ( m_pStatusBar ) + { + Reference< datatransfer::clipboard::XClipboard > xClipboard = m_pStatusBar->GetClipboard(); + if ( xClipboard.is() ) + { + OUString sText( implGetTextRange( GetItemText(), nStartIndex, nEndIndex ) ); + + rtl::Reference<vcl::unohelper::TextDataObject> pDataObj = new vcl::unohelper::TextDataObject( sText ); + + SolarMutexReleaser aReleaser; + xClipboard->setContents( pDataObj, nullptr ); + + Reference< datatransfer::clipboard::XFlushableClipboard > xFlushableClipboard( xClipboard, uno::UNO_QUERY ); + if( xFlushableClipboard.is() ) + xFlushableClipboard->flushClipboard(); + + bReturn = true; + } + } + + return bReturn; +} + + +sal_Bool VCLXAccessibleStatusBarItem::scrollSubstringTo( sal_Int32, sal_Int32, AccessibleScrollType ) +{ + return false; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessibletabcontrol.cxx b/accessibility/source/standard/vclxaccessibletabcontrol.cxx new file mode 100644 index 000000000..c1ede9741 --- /dev/null +++ b/accessibility/source/standard/vclxaccessibletabcontrol.cxx @@ -0,0 +1,488 @@ +/* -*- 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 <standard/vclxaccessibletabcontrol.hxx> +#include <standard/vclxaccessibletabpage.hxx> + +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <o3tl/safeint.hxx> +#include <unotools/accessiblestatesethelper.hxx> +#include <vcl/tabctrl.hxx> +#include <vcl/tabpage.hxx> +#include <vcl/vclevent.hxx> + +#include <vector> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::accessibility; +using namespace ::comphelper; + + + + +VCLXAccessibleTabControl::VCLXAccessibleTabControl( VCLXWindow* pVCLXWindow ) + :VCLXAccessibleComponent( pVCLXWindow ) +{ + m_pTabControl = GetAs<TabControl>(); + if (!m_pTabControl) + return; + if (m_pTabControl->isDisposed()) + { + m_pTabControl.clear(); + return; + } + m_aAccessibleChildren.assign( m_pTabControl->GetPageCount(), Reference< XAccessible >() ); +} + + +void VCLXAccessibleTabControl::UpdateFocused() +{ + for (const Reference<XAccessible>& xChild : m_aAccessibleChildren) + { + if ( xChild.is() ) + { + VCLXAccessibleTabPage* pVCLXAccessibleTabPage = static_cast< VCLXAccessibleTabPage* >( xChild.get() ); + if ( pVCLXAccessibleTabPage ) + pVCLXAccessibleTabPage->SetFocused( pVCLXAccessibleTabPage->IsFocused() ); + } + } +} + + +void VCLXAccessibleTabControl::UpdateSelected( sal_Int32 i, bool bSelected ) +{ + if ( i >= 0 && o3tl::make_unsigned(i) < m_aAccessibleChildren.size() ) + { + Reference< XAccessible > xChild( m_aAccessibleChildren[i] ); + if ( xChild.is() ) + { + VCLXAccessibleTabPage* pVCLXAccessibleTabPage = static_cast< VCLXAccessibleTabPage* >( xChild.get() ); + if ( pVCLXAccessibleTabPage ) + pVCLXAccessibleTabPage->SetSelected( bSelected ); + } + } +} + + +void VCLXAccessibleTabControl::UpdatePageText( sal_Int32 i ) +{ + if ( i >= 0 && o3tl::make_unsigned(i) < m_aAccessibleChildren.size() ) + { + Reference< XAccessible > xChild( m_aAccessibleChildren[i] ); + if ( xChild.is() ) + { + VCLXAccessibleTabPage* pVCLXAccessibleTabPage = static_cast< VCLXAccessibleTabPage* >( xChild.get() ); + if ( pVCLXAccessibleTabPage ) + pVCLXAccessibleTabPage->SetPageText( pVCLXAccessibleTabPage->GetPageText() ); + } + } +} + + +void VCLXAccessibleTabControl::UpdateTabPage( sal_Int32 i, bool bNew ) +{ + if ( i >= 0 && o3tl::make_unsigned(i) < m_aAccessibleChildren.size() ) + { + Reference< XAccessible > xChild( m_aAccessibleChildren[i] ); + if ( xChild.is() ) + { + VCLXAccessibleTabPage* pVCLXAccessibleTabPage = static_cast< VCLXAccessibleTabPage* >( xChild.get() ); + if ( pVCLXAccessibleTabPage ) + pVCLXAccessibleTabPage->Update( bNew ); + } + } +} + + +void VCLXAccessibleTabControl::InsertChild( sal_Int32 i ) +{ + if ( i < 0 || o3tl::make_unsigned(i) > m_aAccessibleChildren.size() ) + return; + + // insert entry in child list + m_aAccessibleChildren.insert( m_aAccessibleChildren.begin() + i, Reference< XAccessible >() ); + + // send accessible child event + Reference< XAccessible > xChild( getAccessibleChild( i ) ); + if ( xChild.is() ) + { + Any aOldValue, aNewValue; + aNewValue <<= xChild; + NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue ); + } +} + + +void VCLXAccessibleTabControl::RemoveChild( sal_Int32 i ) +{ + if ( i < 0 || o3tl::make_unsigned(i) >= m_aAccessibleChildren.size() ) + return; + + // get the accessible of the removed page + Reference< XAccessible > xChild( m_aAccessibleChildren[i] ); + + // remove entry in child list + m_aAccessibleChildren.erase( m_aAccessibleChildren.begin() + i ); + + // send accessible child event + if ( xChild.is() ) + { + Any aOldValue, aNewValue; + aOldValue <<= xChild; + NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue ); + + Reference< XComponent > xComponent( xChild, UNO_QUERY ); + if ( xComponent.is() ) + xComponent->dispose(); + } +} + + +void VCLXAccessibleTabControl::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent ) +{ + switch ( rVclWindowEvent.GetId() ) + { + case VclEventId::TabpageActivate: + case VclEventId::TabpageDeactivate: + { + if ( m_pTabControl ) + { + sal_uInt16 nPageId = static_cast<sal_uInt16>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())); + sal_uInt16 nPagePos = m_pTabControl->GetPagePos( nPageId ); + UpdateFocused(); + UpdateSelected( nPagePos, rVclWindowEvent.GetId() == VclEventId::TabpageActivate ); + } + } + break; + case VclEventId::TabpagePageTextChanged: + { + if ( m_pTabControl ) + { + sal_uInt16 nPageId = static_cast<sal_uInt16>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())); + sal_uInt16 nPagePos = m_pTabControl->GetPagePos( nPageId ); + UpdatePageText( nPagePos ); + } + } + break; + case VclEventId::TabpageInserted: + { + if ( m_pTabControl ) + { + sal_uInt16 nPageId = static_cast<sal_uInt16>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())); + sal_uInt16 nPagePos = m_pTabControl->GetPagePos( nPageId ); + InsertChild( nPagePos ); + } + } + break; + case VclEventId::TabpageRemoved: + { + if ( m_pTabControl ) + { + sal_uInt16 nPageId = static_cast<sal_uInt16>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())); + for ( sal_Int32 i = 0, nCount = getAccessibleChildCount(); i < nCount; ++i ) + { + Reference< XAccessible > xChild( getAccessibleChild( i ) ); + if ( xChild.is() ) + { + VCLXAccessibleTabPage* pVCLXAccessibleTabPage = static_cast< VCLXAccessibleTabPage* >( xChild.get() ); + if ( pVCLXAccessibleTabPage && pVCLXAccessibleTabPage->GetPageId() == nPageId ) + { + RemoveChild( i ); + break; + } + } + } + } + } + break; + case VclEventId::TabpageRemovedAll: + { + for ( sal_Int32 i = m_aAccessibleChildren.size() - 1; i >= 0; --i ) + RemoveChild( i ); + } + break; + case VclEventId::WindowGetFocus: + case VclEventId::WindowLoseFocus: + { + UpdateFocused(); + } + break; + case VclEventId::ObjectDying: + { + if ( m_pTabControl ) + { + m_pTabControl = nullptr; + + // dispose all tab pages + for (const Reference<XAccessible>& i : m_aAccessibleChildren) + { + Reference< XComponent > xComponent( i, UNO_QUERY ); + if ( xComponent.is() ) + xComponent->dispose(); + } + m_aAccessibleChildren.clear(); + } + + VCLXAccessibleComponent::ProcessWindowEvent( rVclWindowEvent ); + } + break; + default: + VCLXAccessibleComponent::ProcessWindowEvent( rVclWindowEvent ); + } +} + + +void VCLXAccessibleTabControl::ProcessWindowChildEvent( const VclWindowEvent& rVclWindowEvent ) +{ + switch ( rVclWindowEvent.GetId() ) + { + case VclEventId::WindowShow: + case VclEventId::WindowHide: + { + if ( m_pTabControl ) + { + vcl::Window* pChild = static_cast< vcl::Window* >( rVclWindowEvent.GetData() ); + if ( pChild && pChild->GetType() == WindowType::TABPAGE ) + { + for ( sal_Int32 i = 0, nCount = m_pTabControl->GetPageCount(); i < nCount; ++i ) + { + sal_uInt16 nPageId = m_pTabControl->GetPageId( static_cast<sal_uInt16>(i) ); + TabPage* pTabPage = m_pTabControl->GetTabPage( nPageId ); + if ( pTabPage == static_cast<TabPage*>(pChild) ) + UpdateTabPage( i, rVclWindowEvent.GetId() == VclEventId::WindowShow ); + } + } + } + } + break; + default: + VCLXAccessibleComponent::ProcessWindowChildEvent( rVclWindowEvent ); + } +} + + +void VCLXAccessibleTabControl::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet ) +{ + VCLXAccessibleComponent::FillAccessibleStateSet( rStateSet ); + + if ( m_pTabControl ) + rStateSet.AddState( AccessibleStateType::FOCUSABLE ); +} + + +// XInterface + + +IMPLEMENT_FORWARD_XINTERFACE2( VCLXAccessibleTabControl, VCLXAccessibleComponent, VCLXAccessibleTabControl_BASE ) + + +// XTypeProvider + + +IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXAccessibleTabControl, VCLXAccessibleComponent, VCLXAccessibleTabControl_BASE ) + + +// XComponent + + +void VCLXAccessibleTabControl::disposing() +{ + VCLXAccessibleComponent::disposing(); + + if ( !m_pTabControl ) + return; + + m_pTabControl = nullptr; + + // dispose all tab pages + for (const Reference<XAccessible>& i : m_aAccessibleChildren) + { + Reference< XComponent > xComponent( i, UNO_QUERY ); + if ( xComponent.is() ) + xComponent->dispose(); + } + m_aAccessibleChildren.clear(); +} + + +// XServiceInfo + + +OUString VCLXAccessibleTabControl::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleTabControl"; +} + + +Sequence< OUString > VCLXAccessibleTabControl::getSupportedServiceNames() +{ + return { "com.sun.star.awt.AccessibleTabControl" }; +} + + +// XAccessibleContext + + +sal_Int32 VCLXAccessibleTabControl::getAccessibleChildCount() +{ + OExternalLockGuard aGuard( this ); + + return m_aAccessibleChildren.size(); +} + + +Reference< XAccessible > VCLXAccessibleTabControl::getAccessibleChild( sal_Int32 i ) +{ + OExternalLockGuard aGuard( this ); + + if ( i < 0 || o3tl::make_unsigned(i) >= m_aAccessibleChildren.size() ) + throw IndexOutOfBoundsException(); + + return implGetAccessibleChild( i ); +} + +Reference< XAccessible > VCLXAccessibleTabControl::implGetAccessibleChild( sal_Int32 i ) +{ + Reference< XAccessible > xChild = m_aAccessibleChildren[i]; + if ( !xChild.is() ) + { + sal_uInt16 nPageId = m_pTabControl ? m_pTabControl->GetPageId(static_cast<sal_uInt16>(i)) : 0; + if (nPageId) + { + xChild = new VCLXAccessibleTabPage( m_pTabControl, nPageId ); + + // insert into tab page list + m_aAccessibleChildren[i] = xChild; + } + } + + return xChild; +} + + +sal_Int16 VCLXAccessibleTabControl::getAccessibleRole( ) +{ + OExternalLockGuard aGuard( this ); + + return AccessibleRole::PAGE_TAB_LIST; +} + + +OUString VCLXAccessibleTabControl::getAccessibleName( ) +{ + OExternalLockGuard aGuard( this ); + + return OUString(); +} + + +// XAccessibleSelection + + +void VCLXAccessibleTabControl::selectAccessibleChild( sal_Int32 nChildIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nChildIndex < 0 || o3tl::make_unsigned(nChildIndex) >= m_aAccessibleChildren.size() ) + throw IndexOutOfBoundsException(); + + if ( m_pTabControl ) + m_pTabControl->SelectTabPage( m_pTabControl->GetPageId( static_cast<sal_uInt16>(nChildIndex) ) ); +} + + +sal_Bool VCLXAccessibleTabControl::isAccessibleChildSelected( sal_Int32 nChildIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nChildIndex < 0 || o3tl::make_unsigned(nChildIndex) >= m_aAccessibleChildren.size() ) + throw IndexOutOfBoundsException(); + + return implIsAccessibleChildSelected( nChildIndex ); +} + +bool VCLXAccessibleTabControl::implIsAccessibleChildSelected( sal_Int32 nChildIndex ) +{ + bool bSelected = false; + if ( m_pTabControl && m_pTabControl->GetCurPageId() == m_pTabControl->GetPageId( static_cast<sal_uInt16>(nChildIndex) ) ) + bSelected = true; + + return bSelected; +} + + +void VCLXAccessibleTabControl::clearAccessibleSelection( ) +{ + // This method makes no sense in a tab control, and so does nothing. +} + + +void VCLXAccessibleTabControl::selectAllAccessibleChildren( ) +{ + selectAccessibleChild( 0 ); +} + + +sal_Int32 VCLXAccessibleTabControl::getSelectedAccessibleChildCount( ) +{ + OExternalLockGuard aGuard( this ); + + return 1; +} + + +Reference< XAccessible > VCLXAccessibleTabControl::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nSelectedChildIndex != 0 ) + throw IndexOutOfBoundsException(); + + Reference< XAccessible > xChild; + + for ( std::size_t i = 0, nCount = m_aAccessibleChildren.size(); i < nCount; i++ ) + { + if ( implIsAccessibleChildSelected( i ) ) + { + xChild = implGetAccessibleChild( i ); + break; + } + } + + return xChild; +} + + +void VCLXAccessibleTabControl::deselectAccessibleChild( sal_Int32 nChildIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nChildIndex < 0 || o3tl::make_unsigned(nChildIndex) >= m_aAccessibleChildren.size() ) + throw IndexOutOfBoundsException(); + + // This method makes no sense in a tab control, and so does nothing. +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessibletabpage.cxx b/accessibility/source/standard/vclxaccessibletabpage.cxx new file mode 100644 index 000000000..8dd5a2419 --- /dev/null +++ b/accessibility/source/standard/vclxaccessibletabpage.cxx @@ -0,0 +1,675 @@ +/* -*- 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 <standard/vclxaccessibletabpage.hxx> +#include <toolkit/helper/convert.hxx> +#include <helper/characterattributeshelper.hxx> + +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/datatransfer/clipboard/XClipboard.hpp> +#include <com/sun/star/datatransfer/clipboard/XFlushableClipboard.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <cppuhelper/supportsservice.hxx> +#include <unotools/accessiblestatesethelper.hxx> +#include <unotools/accessiblerelationsethelper.hxx> +#include <vcl/svapp.hxx> +#include <vcl/unohelp2.hxx> +#include <vcl/tabctrl.hxx> +#include <vcl/tabpage.hxx> +#include <vcl/settings.hxx> +#include <i18nlangtag/languagetag.hxx> + +using namespace ::com::sun::star::accessibility; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star; +using namespace ::comphelper; + + + + +VCLXAccessibleTabPage::VCLXAccessibleTabPage( TabControl* pTabControl, sal_uInt16 nPageId ) + :m_pTabControl( pTabControl ) + ,m_nPageId( nPageId ) +{ + m_bFocused = IsFocused(); + m_bSelected = IsSelected(); + m_sPageText = GetPageText(); +} + + +VCLXAccessibleTabPage::~VCLXAccessibleTabPage() +{ +} + + +bool VCLXAccessibleTabPage::IsFocused() const +{ + bool bFocused = false; + + if ( m_pTabControl && m_pTabControl->HasFocus() && m_pTabControl->GetCurPageId() == m_nPageId ) + bFocused = true; + + return bFocused; +} + + +bool VCLXAccessibleTabPage::IsSelected() const +{ + bool bSelected = false; + + if ( m_pTabControl && m_pTabControl->GetCurPageId() == m_nPageId ) + bSelected = true; + + return bSelected; +} + + +void VCLXAccessibleTabPage::SetFocused( bool bFocused ) +{ + if ( m_bFocused != bFocused ) + { + Any aOldValue, aNewValue; + if ( m_bFocused ) + aOldValue <<= AccessibleStateType::FOCUSED; + else + aNewValue <<= AccessibleStateType::FOCUSED; + m_bFocused = bFocused; + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue ); + } +} + + +void VCLXAccessibleTabPage::SetSelected( bool bSelected ) +{ + if ( m_bSelected != bSelected ) + { + Any aOldValue, aNewValue; + if ( m_bSelected ) + aOldValue <<= AccessibleStateType::SELECTED; + else + aNewValue <<= AccessibleStateType::SELECTED; + m_bSelected = bSelected; + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue ); + } +} + + +void VCLXAccessibleTabPage::SetPageText( const OUString& sPageText ) +{ + Any aOldValue, aNewValue; + if ( OCommonAccessibleText::implInitTextChangedEvent( m_sPageText, sPageText, aOldValue, aNewValue ) ) + { + Any aOldName, aNewName; + aOldName <<= m_sPageText; + aNewName <<= sPageText; + m_sPageText = sPageText; + NotifyAccessibleEvent( AccessibleEventId::NAME_CHANGED, aOldName, aNewName ); + NotifyAccessibleEvent( AccessibleEventId::TEXT_CHANGED, aOldValue, aNewValue ); + } +} + + +OUString VCLXAccessibleTabPage::GetPageText() +{ + OUString sText; + if ( m_pTabControl ) + sText = OutputDevice::GetNonMnemonicString( m_pTabControl->GetPageText( m_nPageId ) ); + + return sText; +} + + +void VCLXAccessibleTabPage::Update( bool bNew ) +{ + if ( !m_pTabControl ) + return; + + TabPage* pTabPage = m_pTabControl->GetTabPage( m_nPageId ); + if ( !pTabPage ) + return; + + Reference< XAccessible > xChild( pTabPage->GetAccessible( bNew ) ); + if ( xChild.is() ) + { + Any aOldValue, aNewValue; + if ( bNew ) + aNewValue <<= xChild; + else + aOldValue <<= xChild; + NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue ); + } +} + + +void VCLXAccessibleTabPage::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet ) +{ + rStateSet.AddState( AccessibleStateType::ENABLED ); + rStateSet.AddState( AccessibleStateType::SENSITIVE ); + + rStateSet.AddState( AccessibleStateType::FOCUSABLE ); + + if ( IsFocused() ) + rStateSet.AddState( AccessibleStateType::FOCUSED ); + + rStateSet.AddState( AccessibleStateType::VISIBLE ); + + rStateSet.AddState( AccessibleStateType::SHOWING ); + + rStateSet.AddState( AccessibleStateType::SELECTABLE ); + + if ( IsSelected() ) + rStateSet.AddState( AccessibleStateType::SELECTED ); +} + + +// OCommonAccessibleComponent + + +awt::Rectangle VCLXAccessibleTabPage::implGetBounds() +{ + awt::Rectangle aBounds( 0, 0, 0, 0 ); + + if ( m_pTabControl ) + aBounds = AWTRectangle( m_pTabControl->GetTabBounds( m_nPageId ) ); + + return aBounds; +} + + +// OCommonAccessibleText + + +OUString VCLXAccessibleTabPage::implGetText() +{ + return GetPageText(); +} + + +lang::Locale VCLXAccessibleTabPage::implGetLocale() +{ + return Application::GetSettings().GetLanguageTag().getLocale(); +} + + +void VCLXAccessibleTabPage::implGetSelection( sal_Int32& nStartIndex, sal_Int32& nEndIndex ) +{ + nStartIndex = 0; + nEndIndex = 0; +} + + +// XInterface + + +IMPLEMENT_FORWARD_XINTERFACE2( VCLXAccessibleTabPage, AccessibleTextHelper_BASE, VCLXAccessibleTabPage_BASE ) + + +// XTypeProvider + + +IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXAccessibleTabPage, AccessibleTextHelper_BASE, VCLXAccessibleTabPage_BASE ) + + +// XComponent + + +void VCLXAccessibleTabPage::disposing() +{ + AccessibleTextHelper_BASE::disposing(); + + m_pTabControl = nullptr; + m_sPageText.clear(); +} + + +// XServiceInfo + + +OUString VCLXAccessibleTabPage::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleTabPage"; +} + + +sal_Bool VCLXAccessibleTabPage::supportsService( const OUString& rServiceName ) +{ + return cppu::supportsService(this, rServiceName); +} + + +Sequence< OUString > VCLXAccessibleTabPage::getSupportedServiceNames() +{ + return { "com.sun.star.awt.AccessibleTabPage" }; +} + + +// XAccessible + + +Reference< XAccessibleContext > VCLXAccessibleTabPage::getAccessibleContext( ) +{ + OExternalLockGuard aGuard( this ); + + return this; +} + + +// XAccessibleContext + + +sal_Int32 VCLXAccessibleTabPage::getAccessibleChildCount() +{ + OExternalLockGuard aGuard( this ); + return implGetAccessibleChildCount(); +} + +sal_Int32 VCLXAccessibleTabPage::implGetAccessibleChildCount() +{ + sal_Int32 nCount = 0; + if ( m_pTabControl ) + { + TabPage* pTabPage = m_pTabControl->GetTabPage( m_nPageId ); + if ( pTabPage && pTabPage->IsVisible() ) + nCount = 1; + } + + return nCount; +} + + +Reference< XAccessible > VCLXAccessibleTabPage::getAccessibleChild( sal_Int32 i ) +{ + OExternalLockGuard aGuard( this ); + + if ( i < 0 || i >= implGetAccessibleChildCount() ) + throw IndexOutOfBoundsException(); + + Reference< XAccessible > xChild; + if ( m_pTabControl ) + { + TabPage* pTabPage = m_pTabControl->GetTabPage( m_nPageId ); + if ( pTabPage && pTabPage->IsVisible() ) + xChild = pTabPage->GetAccessible(); + } + + return xChild; +} + + +Reference< XAccessible > VCLXAccessibleTabPage::getAccessibleParent( ) +{ + OExternalLockGuard aGuard( this ); + + Reference< XAccessible > xParent; + if ( m_pTabControl ) + xParent = m_pTabControl->GetAccessible(); + + return xParent; +} + + +sal_Int32 VCLXAccessibleTabPage::getAccessibleIndexInParent( ) +{ + OExternalLockGuard aGuard( this ); + + sal_Int32 nIndexInParent = -1; + if ( m_pTabControl ) + nIndexInParent = m_pTabControl->GetPagePos( m_nPageId ); + + return nIndexInParent; +} + +sal_Int16 VCLXAccessibleTabPage::getAccessibleRole() +{ + OExternalLockGuard aGuard( this ); + + return AccessibleRole::PAGE_TAB; +} + +OUString VCLXAccessibleTabPage::getAccessibleDescription() +{ + OExternalLockGuard aGuard( this ); + + OUString sDescription; + if ( m_pTabControl ) + sDescription = m_pTabControl->GetAccessibleDescription( m_nPageId ); + + return sDescription; +} + +OUString VCLXAccessibleTabPage::getAccessibleName() +{ + OExternalLockGuard aGuard( this ); + + OUString sName; + if ( m_pTabControl ) + sName = m_pTabControl->GetAccessibleName( m_nPageId ); + + return sName; +} + +Reference< XAccessibleRelationSet > VCLXAccessibleTabPage::getAccessibleRelationSet( ) +{ + OExternalLockGuard aGuard( this ); + + return new utl::AccessibleRelationSetHelper; +} + + +Reference< XAccessibleStateSet > VCLXAccessibleTabPage::getAccessibleStateSet( ) +{ + OExternalLockGuard aGuard( this ); + + rtl::Reference<utl::AccessibleStateSetHelper> pStateSetHelper = new utl::AccessibleStateSetHelper; + + if ( !rBHelper.bDisposed && !rBHelper.bInDispose ) + { + FillAccessibleStateSet( *pStateSetHelper ); + } + else + { + pStateSetHelper->AddState( AccessibleStateType::DEFUNC ); + } + + return pStateSetHelper; +} + + +Locale VCLXAccessibleTabPage::getLocale( ) +{ + OExternalLockGuard aGuard( this ); + + return Application::GetSettings().GetLanguageTag().getLocale(); +} + + +// XAccessibleComponent + + +Reference< XAccessible > VCLXAccessibleTabPage::getAccessibleAtPoint( const awt::Point& rPoint ) +{ + OExternalLockGuard aGuard( this ); + + Reference< XAccessible > xChild; + for ( sal_uInt32 i = 0, nCount = getAccessibleChildCount(); i < nCount; ++i ) + { + Reference< XAccessible > xAcc = getAccessibleChild( i ); + if ( xAcc.is() ) + { + Reference< XAccessibleComponent > xComp( xAcc->getAccessibleContext(), UNO_QUERY ); + if ( xComp.is() ) + { + tools::Rectangle aRect = VCLRectangle( xComp->getBounds() ); + Point aPos = VCLPoint( rPoint ); + if ( aRect.Contains( aPos ) ) + { + xChild = xAcc; + break; + } + } + } + } + + return xChild; +} + + +void VCLXAccessibleTabPage::grabFocus( ) +{ + OExternalLockGuard aGuard( this ); + + if ( m_pTabControl ) + { + m_pTabControl->SelectTabPage( m_nPageId ); + m_pTabControl->GrabFocus(); + } +} + + +sal_Int32 VCLXAccessibleTabPage::getForeground( ) +{ + OExternalLockGuard aGuard( this ); + + sal_Int32 nColor = 0; + Reference< XAccessible > xParent = getAccessibleParent(); + if ( xParent.is() ) + { + Reference< XAccessibleComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY ); + if ( xParentComp.is() ) + nColor = xParentComp->getForeground(); + } + + return nColor; +} + + +sal_Int32 VCLXAccessibleTabPage::getBackground( ) +{ + OExternalLockGuard aGuard( this ); + + sal_Int32 nColor = 0; + Reference< XAccessible > xParent = getAccessibleParent(); + if ( xParent.is() ) + { + Reference< XAccessibleComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY ); + if ( xParentComp.is() ) + nColor = xParentComp->getBackground(); + } + + return nColor; +} + + +// XAccessibleExtendedComponent + + +Reference< awt::XFont > VCLXAccessibleTabPage::getFont( ) +{ + OExternalLockGuard aGuard( this ); + + Reference< awt::XFont > xFont; + Reference< XAccessible > xParent = getAccessibleParent(); + if ( xParent.is() ) + { + Reference< XAccessibleExtendedComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY ); + if ( xParentComp.is() ) + xFont = xParentComp->getFont(); + } + + return xFont; +} + + +OUString VCLXAccessibleTabPage::getTitledBorderText( ) +{ + OExternalLockGuard aGuard( this ); + + return OUString(); +} + + +OUString VCLXAccessibleTabPage::getToolTipText( ) +{ + OExternalLockGuard aGuard( this ); + + return OUString(); +} + + +// XAccessibleText + +OUString VCLXAccessibleTabPage::getText() +{ + OExternalLockGuard aGuard( this ); + + return GetPageText(); +} + +OUString VCLXAccessibleTabPage::getTextRange(sal_Int32 nStartIndex, sal_Int32 nEndIndex) +{ + OExternalLockGuard aGuard( this ); + + return OCommonAccessibleText::implGetTextRange(GetPageText(), nStartIndex, nEndIndex); +} + +sal_Unicode VCLXAccessibleTabPage::getCharacter( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + return OCommonAccessibleText::implGetCharacter( GetPageText(), nIndex ); +} + +sal_Int32 VCLXAccessibleTabPage::getCharacterCount() +{ + return GetPageText().getLength(); +} + +sal_Int32 VCLXAccessibleTabPage::getCaretPosition() +{ + OExternalLockGuard aGuard( this ); + + return -1; +} + + +sal_Bool VCLXAccessibleTabPage::setCaretPosition( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( !implIsValidRange( nIndex, nIndex, GetPageText().getLength() ) ) + throw IndexOutOfBoundsException(); + + return false; +} + + +Sequence< PropertyValue > VCLXAccessibleTabPage::getCharacterAttributes( sal_Int32 nIndex, const Sequence< OUString >& aRequestedAttributes ) +{ + OExternalLockGuard aGuard( this ); + + Sequence< PropertyValue > aValues; + OUString sText( GetPageText() ); + + if ( !implIsValidIndex( nIndex, sText.getLength() ) ) + throw IndexOutOfBoundsException(); + + if ( m_pTabControl ) + { + vcl::Font aFont = m_pTabControl->GetFont(); + sal_Int32 nBackColor = getBackground(); + sal_Int32 nColor = getForeground(); + aValues = CharacterAttributesHelper( aFont, nBackColor, nColor ) + .GetCharacterAttributes( aRequestedAttributes ); + } + + return aValues; +} + + +awt::Rectangle VCLXAccessibleTabPage::getCharacterBounds( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( !implIsValidIndex( nIndex, GetPageText().getLength() ) ) + throw IndexOutOfBoundsException(); + + awt::Rectangle aBounds( 0, 0, 0, 0 ); + if ( m_pTabControl ) + { + tools::Rectangle aPageRect = m_pTabControl->GetTabBounds( m_nPageId ); + tools::Rectangle aCharRect = m_pTabControl->GetCharacterBounds( m_nPageId, nIndex ); + aCharRect.Move( -aPageRect.Left(), -aPageRect.Top() ); + aBounds = AWTRectangle( aCharRect ); + } + + return aBounds; +} + + +sal_Int32 VCLXAccessibleTabPage::getIndexAtPoint( const awt::Point& aPoint ) +{ + OExternalLockGuard aGuard( this ); + + sal_Int32 nIndex = -1; + if ( m_pTabControl ) + { + sal_uInt16 nPageId = 0; + tools::Rectangle aPageRect = m_pTabControl->GetTabBounds( m_nPageId ); + Point aPnt( VCLPoint( aPoint ) ); + aPnt += aPageRect.TopLeft(); + sal_Int32 nI = m_pTabControl->GetIndexForPoint( aPnt, nPageId ); + if ( nI != -1 && m_nPageId == nPageId ) + nIndex = nI; + } + + return nIndex; +} + + +sal_Bool VCLXAccessibleTabPage::setSelection( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( !implIsValidRange( nStartIndex, nEndIndex, GetPageText().getLength() ) ) + throw IndexOutOfBoundsException(); + + return false; +} + + +sal_Bool VCLXAccessibleTabPage::copyText( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) +{ + OExternalLockGuard aGuard( this ); + + bool bReturn = false; + + if ( m_pTabControl ) + { + Reference< datatransfer::clipboard::XClipboard > xClipboard = m_pTabControl->GetClipboard(); + if ( xClipboard.is() ) + { + OUString sText( implGetTextRange( GetPageText(), nStartIndex, nEndIndex ) ); + + rtl::Reference<vcl::unohelper::TextDataObject> pDataObj = new vcl::unohelper::TextDataObject( sText ); + + SolarMutexReleaser aReleaser; + xClipboard->setContents( pDataObj, nullptr ); + + Reference< datatransfer::clipboard::XFlushableClipboard > xFlushableClipboard( xClipboard, uno::UNO_QUERY ); + if( xFlushableClipboard.is() ) + xFlushableClipboard->flushClipboard(); + + bReturn = true; + } + } + + return bReturn; +} + +sal_Bool VCLXAccessibleTabPage::scrollSubstringTo( sal_Int32, sal_Int32, AccessibleScrollType ) +{ + return false; +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessibletabpagewindow.cxx b/accessibility/source/standard/vclxaccessibletabpagewindow.cxx new file mode 100644 index 000000000..c8408d24b --- /dev/null +++ b/accessibility/source/standard/vclxaccessibletabpagewindow.cxx @@ -0,0 +1,133 @@ +/* -*- 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 <standard/vclxaccessibletabpagewindow.hxx> +#include <toolkit/helper/convert.hxx> +#include <vcl/tabctrl.hxx> +#include <vcl/tabpage.hxx> +#include <sal/log.hxx> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::accessibility; +using namespace ::comphelper; + + + + +VCLXAccessibleTabPageWindow::VCLXAccessibleTabPageWindow( VCLXWindow* pVCLXWindow ) + :VCLXAccessibleComponent( pVCLXWindow ) +{ + m_pTabPage = GetAs<TabPage>(); + m_pTabControl = nullptr; + m_nPageId = 0; + if ( !m_pTabPage ) + return; + + vcl::Window* pParent = m_pTabPage->GetAccessibleParentWindow(); + if ( !(pParent && pParent->GetType() == WindowType::TABCONTROL) ) + return; + + m_pTabControl = static_cast< TabControl* >( pParent ); + if ( m_pTabControl ) + { + for ( sal_uInt16 i = 0, nCount = m_pTabControl->GetPageCount(); i < nCount; ++i ) + { + sal_uInt16 nPageId = m_pTabControl->GetPageId( i ); + if ( m_pTabControl->GetTabPage( nPageId ) == m_pTabPage.get() ) + m_nPageId = nPageId; + } + } +} + + +// OCommonAccessibleComponent + + +awt::Rectangle VCLXAccessibleTabPageWindow::implGetBounds() +{ + awt::Rectangle aBounds( 0, 0, 0, 0 ); + + if ( m_pTabControl ) + { + tools::Rectangle aPageRect = m_pTabControl->GetTabBounds( m_nPageId ); + if ( m_pTabPage ) + { + tools::Rectangle aRect( m_pTabPage->GetPosPixel(), m_pTabPage->GetSizePixel() ); + aRect.Move( -aPageRect.Left(), -aPageRect.Top() ); + aBounds = AWTRectangle( aRect ); + } + } + + return aBounds; +} + + +// XComponent + + +void VCLXAccessibleTabPageWindow::disposing() +{ + VCLXAccessibleComponent::disposing(); + + m_pTabControl = nullptr; + m_pTabPage = nullptr; +} + + +// XAccessibleContext + + +Reference< XAccessible > VCLXAccessibleTabPageWindow::getAccessibleParent( ) +{ + OExternalLockGuard aGuard( this ); + + Reference< XAccessible > xParent; + if ( m_pTabControl ) + { + Reference< XAccessible > xAcc( m_pTabControl->GetAccessible() ); + if ( xAcc.is() ) + { + Reference< XAccessibleContext > xCont( xAcc->getAccessibleContext() ); + if ( xCont.is() ) + { + sal_uInt16 const nPagePos(m_pTabControl->GetPagePos(m_nPageId)); + SAL_WARN_IF(nPagePos == TAB_PAGE_NOTFOUND, "accessibility", + "getAccessibleParent(): no tab page"); + if (nPagePos != TAB_PAGE_NOTFOUND) + { + xParent = xCont->getAccessibleChild(nPagePos); + } + } + } + } + + return xParent; +} + + +sal_Int32 VCLXAccessibleTabPageWindow::getAccessibleIndexInParent( ) +{ + OExternalLockGuard aGuard( this ); + + return 0; +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessibletextcomponent.cxx b/accessibility/source/standard/vclxaccessibletextcomponent.cxx new file mode 100644 index 000000000..c5dba0df9 --- /dev/null +++ b/accessibility/source/standard/vclxaccessibletextcomponent.cxx @@ -0,0 +1,376 @@ +/* -*- 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 <standard/vclxaccessibletextcomponent.hxx> +#include <toolkit/helper/convert.hxx> +#include <helper/characterattributeshelper.hxx> + +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/datatransfer/clipboard/XClipboard.hpp> +#include <com/sun/star/datatransfer/clipboard/XFlushableClipboard.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <vcl/window.hxx> +#include <vcl/svapp.hxx> +#include <vcl/unohelp2.hxx> +#include <vcl/ctrl.hxx> +#include <vcl/settings.hxx> +#include <i18nlangtag/languagetag.hxx> + +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; +using namespace ::comphelper; + + + + +VCLXAccessibleTextComponent::VCLXAccessibleTextComponent( VCLXWindow* pVCLXWindow ) + :VCLXAccessibleComponent( pVCLXWindow ) +{ + VclPtr<vcl::Window> pWindow = GetWindow(); + if ( pWindow ) + m_sText = OutputDevice::GetNonMnemonicString( pWindow->GetText() ); +} + + +void VCLXAccessibleTextComponent::SetText( const OUString& sText ) +{ + Any aOldValue, aNewValue; + if ( implInitTextChangedEvent( m_sText, sText, aOldValue, aNewValue ) ) + { + m_sText = sText; + NotifyAccessibleEvent( AccessibleEventId::TEXT_CHANGED, aOldValue, aNewValue ); + } +} + + +void VCLXAccessibleTextComponent::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent ) +{ + switch ( rVclWindowEvent.GetId() ) + { + case VclEventId::WindowFrameTitleChanged: + { + VCLXAccessibleComponent::ProcessWindowEvent( rVclWindowEvent ); + SetText( implGetText() ); + } + break; + default: + VCLXAccessibleComponent::ProcessWindowEvent( rVclWindowEvent ); + } +} + + +// OCommonAccessibleText + + +OUString VCLXAccessibleTextComponent::implGetText() +{ + OUString aText; + VclPtr<vcl::Window> pWindow = GetWindow(); + if ( pWindow ) + aText = OutputDevice::GetNonMnemonicString( pWindow->GetText() ); + + return aText; +} + + +lang::Locale VCLXAccessibleTextComponent::implGetLocale() +{ + return Application::GetSettings().GetLanguageTag().getLocale(); +} + + +void VCLXAccessibleTextComponent::implGetSelection( sal_Int32& nStartIndex, sal_Int32& nEndIndex ) +{ + nStartIndex = 0; + nEndIndex = 0; +} + + +// XComponent + + +void VCLXAccessibleTextComponent::disposing() +{ + VCLXAccessibleComponent::disposing(); + + m_sText.clear(); +} + + +// XInterface + + +IMPLEMENT_FORWARD_XINTERFACE2( VCLXAccessibleTextComponent, VCLXAccessibleComponent, VCLXAccessibleTextComponent_BASE ) + + +// XTypeProvider + + +IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXAccessibleTextComponent, VCLXAccessibleComponent, VCLXAccessibleTextComponent_BASE ) + + +// XAccessibleText + + +sal_Int32 VCLXAccessibleTextComponent::getCaretPosition() +{ + return -1; +} + + +sal_Bool VCLXAccessibleTextComponent::setCaretPosition( sal_Int32 nIndex ) +{ + return setSelection( nIndex, nIndex ); +} + + +sal_Unicode VCLXAccessibleTextComponent::getCharacter( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + return OCommonAccessibleText::implGetCharacter( implGetText(), nIndex ); +} + + +Sequence< PropertyValue > VCLXAccessibleTextComponent::getCharacterAttributes( sal_Int32 nIndex, const Sequence< OUString >& aRequestedAttributes ) +{ + OExternalLockGuard aGuard( this ); + + Sequence< PropertyValue > aValues; + OUString sText( implGetText() ); + + if ( !implIsValidIndex( nIndex, sText.getLength() ) ) + throw IndexOutOfBoundsException(); + + VclPtr<vcl::Window> pWindow = GetWindow(); + if ( pWindow ) + { + vcl::Font aFont = pWindow->GetControlFont(); + + Color nBackColor = pWindow->GetControlBackground(); + Color nColor = pWindow->GetControlForeground(); + + // MT: Code with default font was introduced with the IA2 CWS, but I am not convinced that this is the correct font... + // Decide what to do when we have a concrete issue. + /* + Font aDefaultVCLFont; + OutputDevice* pDev = Application::GetDefaultDevice(); + if ( pDev ) + { + aDefaultVCLFont = pDev->GetSettings().GetStyleSettings().GetAppFont(); + if ( !aFont.GetName().Len() ) + { + String aDefaultName = aDefaultVCLFont.GetName(); + aFont.SetName( aDefaultName ); + } + if ( !aFont.GetHeight() ) + { + aFont.SetHeight( aDefaultVCLFont.GetHeight() ); + } + if ( aFont.GetWeight() == WEIGHT_DONTKNOW ) + { + aFont.SetWeight( aDefaultVCLFont.GetWeight() ); + } + + //if nColor is -1, it may indicate that the default color black is using. + if ( nColor == -1) + { + nColor = aDefaultVCLFont.GetColor().GetColor(); + } + } + */ + + // MT: Adjustment stuff was introduced with the IA2 CWS, but adjustment is not a character attribute... + // In case we reintroduce it, use adjustment as extra parameter for the CharacterAttributesHelper... + /* + WinBits aBits = GetWindow()->GetStyle(); + sal_Int16 nAdjust = -1; + if ( aBits & WB_LEFT ) + { + nAdjust = style::ParagraphAdjust_LEFT; + } + else if ( aBits & WB_RIGHT ) + { + nAdjust = style::ParagraphAdjust_RIGHT; + } + else if ( aBits & WB_CENTER ) + { + nAdjust = style::ParagraphAdjust_CENTER; + } + */ + + aValues = CharacterAttributesHelper( aFont, sal_Int32(nBackColor), sal_Int32(nColor) ) + .GetCharacterAttributes( aRequestedAttributes ); + } + + return aValues; +} + + +awt::Rectangle VCLXAccessibleTextComponent::getCharacterBounds( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( !implIsValidIndex( nIndex, implGetText().getLength() ) ) + throw IndexOutOfBoundsException(); + + awt::Rectangle aRect; + VclPtr< Control > pControl = GetAs< Control >(); + if ( pControl ) + aRect = AWTRectangle( pControl->GetCharacterBounds( nIndex ) ); + + return aRect; +} + + +sal_Int32 VCLXAccessibleTextComponent::getCharacterCount() +{ + OExternalLockGuard aGuard( this ); + + return implGetText().getLength(); +} + + +sal_Int32 VCLXAccessibleTextComponent::getIndexAtPoint( const awt::Point& aPoint ) +{ + OExternalLockGuard aGuard( this ); + + sal_Int32 nIndex = -1; + VclPtr< Control > pControl = GetAs< Control >(); + if ( pControl ) + nIndex = pControl->GetIndexForPoint( VCLPoint( aPoint ) ); + + return nIndex; +} + + +OUString VCLXAccessibleTextComponent::getSelectedText() +{ + OExternalLockGuard aGuard( this ); + + return OCommonAccessibleText::getSelectedText(); +} + + +sal_Int32 VCLXAccessibleTextComponent::getSelectionStart() +{ + OExternalLockGuard aGuard( this ); + + return OCommonAccessibleText::getSelectionStart(); +} + + +sal_Int32 VCLXAccessibleTextComponent::getSelectionEnd() +{ + OExternalLockGuard aGuard( this ); + + return OCommonAccessibleText::getSelectionEnd(); +} + + +sal_Bool VCLXAccessibleTextComponent::setSelection( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( !implIsValidRange( nStartIndex, nEndIndex, implGetText().getLength() ) ) + throw IndexOutOfBoundsException(); + + return false; +} + + +OUString VCLXAccessibleTextComponent::getText() +{ + OExternalLockGuard aGuard( this ); + + return implGetText(); +} + + +OUString VCLXAccessibleTextComponent::getTextRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) +{ + OExternalLockGuard aGuard( this ); + + return OCommonAccessibleText::implGetTextRange( implGetText(), nStartIndex, nEndIndex ); +} + + +css::accessibility::TextSegment VCLXAccessibleTextComponent::getTextAtIndex( sal_Int32 nIndex, sal_Int16 aTextType ) +{ + OExternalLockGuard aGuard( this ); + + return OCommonAccessibleText::getTextAtIndex( nIndex, aTextType ); +} + + +css::accessibility::TextSegment VCLXAccessibleTextComponent::getTextBeforeIndex( sal_Int32 nIndex, sal_Int16 aTextType ) +{ + OExternalLockGuard aGuard( this ); + + return OCommonAccessibleText::getTextBeforeIndex( nIndex, aTextType ); +} + + +css::accessibility::TextSegment VCLXAccessibleTextComponent::getTextBehindIndex( sal_Int32 nIndex, sal_Int16 aTextType ) +{ + OExternalLockGuard aGuard( this ); + + return OCommonAccessibleText::getTextBehindIndex( nIndex, aTextType ); +} + + +sal_Bool VCLXAccessibleTextComponent::copyText( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) +{ + OExternalLockGuard aGuard( this ); + + bool bReturn = false; + + VclPtr<vcl::Window> pWindow = GetWindow(); + if ( pWindow ) + { + Reference< datatransfer::clipboard::XClipboard > xClipboard = pWindow->GetClipboard(); + if ( xClipboard.is() ) + { + OUString sText( OCommonAccessibleText::implGetTextRange( implGetText(), nStartIndex, nEndIndex ) ); + + rtl::Reference<vcl::unohelper::TextDataObject> pDataObj = new vcl::unohelper::TextDataObject( sText ); + + SolarMutexReleaser aReleaser; + xClipboard->setContents( pDataObj, nullptr ); + + Reference< datatransfer::clipboard::XFlushableClipboard > xFlushableClipboard( xClipboard, uno::UNO_QUERY ); + if( xFlushableClipboard.is() ) + xFlushableClipboard->flushClipboard(); + + bReturn = true; + } + } + + return bReturn; +} + +sal_Bool VCLXAccessibleTextComponent::scrollSubstringTo( sal_Int32, sal_Int32, AccessibleScrollType ) +{ + return false; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/accessibility/source/standard/vclxaccessibletextfield.cxx b/accessibility/source/standard/vclxaccessibletextfield.cxx new file mode 100644 index 000000000..c94e46e3d --- /dev/null +++ b/accessibility/source/standard/vclxaccessibletextfield.cxx @@ -0,0 +1,107 @@ +/* -*- 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 <standard/vclxaccessibletextfield.hxx> +#include <vcl/toolkit/lstbox.hxx> + +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> + +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; + + +VCLXAccessibleTextField::VCLXAccessibleTextField (VCLXWindow* pVCLWindow, const Reference< XAccessible >& _xParent) : + VCLXAccessibleTextComponent (pVCLWindow), + m_xParent( _xParent ) + +{ +} + + +OUString VCLXAccessibleTextField::implGetText() +{ + OUString aText; + VclPtr< ListBox > pListBox = GetAs< ListBox >(); + if (pListBox && !pListBox->IsInDropDown()) + aText = pListBox->GetSelectedEntry(); + + return aText; +} + +IMPLEMENT_FORWARD_XINTERFACE2(VCLXAccessibleTextField, VCLXAccessibleTextComponent, VCLXAccessible_BASE) +IMPLEMENT_FORWARD_XTYPEPROVIDER2(VCLXAccessibleTextField, VCLXAccessibleTextComponent, VCLXAccessible_BASE) + + +// XAccessible + +Reference<XAccessibleContext> SAL_CALL + VCLXAccessibleTextField::getAccessibleContext() +{ + return this; +} + + +// XAccessibleContext + +sal_Int32 SAL_CALL VCLXAccessibleTextField::getAccessibleChildCount() +{ + return 0; +} + + +Reference<XAccessible> SAL_CALL VCLXAccessibleTextField::getAccessibleChild (sal_Int32) +{ + throw IndexOutOfBoundsException(); +} + + +sal_Int16 SAL_CALL VCLXAccessibleTextField::getAccessibleRole() +{ + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + + return AccessibleRole::TEXT; +} + +Reference< XAccessible > SAL_CALL VCLXAccessibleTextField::getAccessibleParent( ) +{ + ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); + + return m_xParent; +} + + +// XServiceInfo + +OUString VCLXAccessibleTextField::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleTextField"; +} + + +Sequence< OUString > VCLXAccessibleTextField::getSupportedServiceNames() +{ + return comphelper::concatSequences(VCLXAccessibleTextComponent::getSupportedServiceNames(), + Sequence<OUString>{"com.sun.star.accessibility.AccessibleTextField"}); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ 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: */ diff --git a/accessibility/source/standard/vclxaccessibletoolboxitem.cxx b/accessibility/source/standard/vclxaccessibletoolboxitem.cxx new file mode 100644 index 000000000..dd2a44628 --- /dev/null +++ b/accessibility/source/standard/vclxaccessibletoolboxitem.cxx @@ -0,0 +1,734 @@ +/* -*- 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 <standard/vclxaccessibletoolboxitem.hxx> +#include <toolkit/helper/convert.hxx> +#include <helper/accresmgr.hxx> +#include <strings.hrc> +#include <com/sun/star/awt/Rectangle.hpp> + +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/datatransfer/clipboard/XClipboard.hpp> +#include <com/sun/star/datatransfer/clipboard/XFlushableClipboard.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <cppuhelper/supportsservice.hxx> +#include <vcl/svapp.hxx> +#include <vcl/toolbox.hxx> +#include <vcl/unohelp2.hxx> +#include <vcl/help.hxx> +#include <vcl/settings.hxx> +#include <unotools/accessiblestatesethelper.hxx> +#include <unotools/accessiblerelationsethelper.hxx> +#include <strings.hxx> +#include <sal/log.hxx> +#include <i18nlangtag/languagetag.hxx> + +#include <com/sun/star/accessibility/XAccessibleSelection.hpp> + +#include <array> + +// class VCLXAccessibleToolBoxItem ------------------------------------------ + +using namespace ::com::sun::star::accessibility; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star; +using namespace ::comphelper; + + +// Ctor() and Dtor() + +VCLXAccessibleToolBoxItem::VCLXAccessibleToolBoxItem( ToolBox* _pToolBox, sal_Int32 _nPos ) : + m_pToolBox ( _pToolBox ), + m_nIndexInParent( _nPos ), + m_nRole ( AccessibleRole::PUSH_BUTTON ), + m_nItemId ( 0 ), + m_bHasFocus ( false ), + m_bIsChecked ( false ), + m_bIndeterminate( false ) + +{ + OSL_ENSURE( m_pToolBox, "invalid toolbox" ); + m_nItemId = m_pToolBox->GetItemId( m_nIndexInParent ); + m_sOldName = GetText(); + m_bIsChecked = m_pToolBox->IsItemChecked( m_nItemId ); + m_bIndeterminate = ( m_pToolBox->GetItemState( m_nItemId ) == TRISTATE_INDET ); + ToolBoxItemType eType = m_pToolBox->GetItemType( m_nIndexInParent ); + switch ( eType ) + { + case ToolBoxItemType::BUTTON : + { + ToolBoxItemBits nBits = m_pToolBox->GetItemBits( m_nItemId ); + if ( + (( nBits & ToolBoxItemBits::DROPDOWN ) == ToolBoxItemBits::DROPDOWN) || + (( nBits & ToolBoxItemBits::DROPDOWNONLY ) == ToolBoxItemBits::DROPDOWNONLY) + ) + m_nRole = AccessibleRole::BUTTON_DROPDOWN; + else if ( + ( ( nBits & ToolBoxItemBits::CHECKABLE ) == ToolBoxItemBits::CHECKABLE ) || + ( ( nBits & ToolBoxItemBits::RADIOCHECK ) == ToolBoxItemBits::RADIOCHECK ) || + ( ( nBits & ToolBoxItemBits::AUTOCHECK ) == ToolBoxItemBits::AUTOCHECK ) + ) + m_nRole = AccessibleRole::TOGGLE_BUTTON; + else if ( m_pToolBox->GetItemWindow( m_nItemId ) ) + m_nRole = AccessibleRole::PANEL; + break; + } + + case ToolBoxItemType::SPACE : + m_nRole = AccessibleRole::FILLER; + break; + + case ToolBoxItemType::SEPARATOR : + case ToolBoxItemType::BREAK : + m_nRole = AccessibleRole::SEPARATOR; + break; + + default: + { + SAL_WARN( "accessibility", "unsupported toolbox itemtype" ); + } + } +} + +VCLXAccessibleToolBoxItem::~VCLXAccessibleToolBoxItem() +{ +} + +OUString VCLXAccessibleToolBoxItem::GetText() const +{ + OUString sRet; + // no text for separators and spaces + if ( m_pToolBox && m_nItemId > ToolBoxItemId(0) ) + { + sRet = m_pToolBox->GetItemText( m_nItemId ); + if (sRet.isEmpty()) + { + sRet = m_pToolBox->GetQuickHelpText( m_nItemId ); + if (sRet.isEmpty()) + { + vcl::Window* pItemWindow = m_pToolBox->GetItemWindow( m_nItemId ); + if ( m_nRole == AccessibleRole::PANEL && pItemWindow && pItemWindow->GetAccessible().is() && + pItemWindow->GetAccessible()->getAccessibleContext().is() ) + { + OUString sWinText = pItemWindow->GetAccessible()->getAccessibleContext()->getAccessibleName(); + if (!sWinText.isEmpty()) + sRet = sWinText; + } + } + } + + } + return sRet; +} + +void VCLXAccessibleToolBoxItem::SetFocus( bool _bFocus ) +{ + if ( m_bHasFocus != _bFocus ) + { + Any aOldValue; + Any aNewValue; + if ( m_bHasFocus ) + aOldValue <<= AccessibleStateType::FOCUSED; + else + aNewValue <<= AccessibleStateType::FOCUSED; + m_bHasFocus = _bFocus; + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue ); + } +} + +void VCLXAccessibleToolBoxItem::SetChecked( bool _bCheck ) +{ + if( m_nRole == AccessibleRole::PANEL) + return; + if ( m_bIsChecked != _bCheck ) + { + Any aOldValue; + Any aNewValue; + if ( m_bIsChecked ) + aOldValue <<= AccessibleStateType::CHECKED; + else + aNewValue <<= AccessibleStateType::CHECKED; + m_bIsChecked = _bCheck; + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue ); + } +} + +void VCLXAccessibleToolBoxItem::SetIndeterminate( bool _bIndeterminate ) +{ + if ( m_bIndeterminate != _bIndeterminate ) + { + Any aOldValue, aNewValue; + if ( m_bIndeterminate ) + aOldValue <<= AccessibleStateType::INDETERMINATE; + else + aNewValue <<= AccessibleStateType::INDETERMINATE; + m_bIndeterminate = _bIndeterminate; + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue ); + } +} + +void VCLXAccessibleToolBoxItem::NameChanged() +{ + OUString sNewName = implGetText(); + if ( sNewName != m_sOldName ) + { + Any aOldValue, aNewValue; + aOldValue <<= m_sOldName; + // save new name as old name for next change + m_sOldName = sNewName; + aNewValue <<= m_sOldName; + NotifyAccessibleEvent( AccessibleEventId::NAME_CHANGED, aOldValue, aNewValue ); + } +} + +void VCLXAccessibleToolBoxItem::SetChild( const Reference< XAccessible >& _xChild ) +{ + m_xChild = _xChild; +} + +void VCLXAccessibleToolBoxItem::NotifyChildEvent( const Reference< XAccessible >& _xChild, bool _bShow ) +{ + Any aOld = _bShow ? Any() : Any( _xChild ); + Any aNew = _bShow ? Any( _xChild ) : Any(); + NotifyAccessibleEvent( AccessibleEventId::CHILD, aOld, aNew ); +} + +void VCLXAccessibleToolBoxItem::ToggleEnableState() +{ + std::array<Any, 2> aOldValue, aNewValue; + if ( m_pToolBox->IsItemEnabled( m_nItemId ) ) + { + aNewValue[0] <<= AccessibleStateType::SENSITIVE; + aNewValue[1] <<= AccessibleStateType::ENABLED; + } + else + { + aOldValue[0] <<= AccessibleStateType::ENABLED; + aOldValue[1] <<= AccessibleStateType::SENSITIVE; + } + + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue[0], aNewValue[0] ); + NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue[1], aNewValue[1] ); +} + +awt::Rectangle VCLXAccessibleToolBoxItem::implGetBounds( ) +{ + awt::Rectangle aRect; + if ( m_pToolBox ) + aRect = AWTRectangle( m_pToolBox->GetItemPosRect( m_nIndexInParent ) ); + + return aRect; +} + +OUString VCLXAccessibleToolBoxItem::implGetText() +{ + return GetText(); +} + +Locale VCLXAccessibleToolBoxItem::implGetLocale() +{ + return Application::GetSettings().GetUILanguageTag().getLocale(); +} + +void VCLXAccessibleToolBoxItem::implGetSelection( sal_Int32& nStartIndex, sal_Int32& nEndIndex ) +{ + nStartIndex = 0; + nEndIndex = 0; +} + +// XInterface + +IMPLEMENT_FORWARD_REFCOUNT( VCLXAccessibleToolBoxItem, AccessibleTextHelper_BASE ) +Any SAL_CALL VCLXAccessibleToolBoxItem::queryInterface( const Type& _rType ) +{ + // #i33611# - toolbox buttons without text don't support XAccessibleText + if ( _rType == cppu::UnoType<XAccessibleText>::get() + && ( !m_pToolBox || m_pToolBox->GetButtonType() == ButtonType::SYMBOLONLY ) ) + return Any(); + + css::uno::Any aReturn = AccessibleTextHelper_BASE::queryInterface( _rType ); + if ( !aReturn.hasValue() ) + aReturn = VCLXAccessibleToolBoxItem_BASE::queryInterface( _rType ); + return aReturn; +} + +// XTypeProvider + +IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXAccessibleToolBoxItem, AccessibleTextHelper_BASE, VCLXAccessibleToolBoxItem_BASE ) + +// XComponent + +void SAL_CALL VCLXAccessibleToolBoxItem::disposing() +{ + AccessibleTextHelper_BASE::disposing(); + m_pToolBox = nullptr; +} + +// XServiceInfo + +OUString VCLXAccessibleToolBoxItem::getImplementationName() +{ + return "com.sun.star.comp.toolkit.AccessibleToolBoxItem"; +} + +sal_Bool VCLXAccessibleToolBoxItem::supportsService( const OUString& rServiceName ) +{ + return cppu::supportsService(this, rServiceName); +} + +Sequence< OUString > VCLXAccessibleToolBoxItem::getSupportedServiceNames() +{ + return {"com.sun.star.accessibility.AccessibleContext", + "com.sun.star.accessibility.AccessibleComponent", + "com.sun.star.accessibility.AccessibleExtendedComponent", + "com.sun.star.accessibility.AccessibleToolBoxItem"}; +} + +// XAccessible + +Reference< XAccessibleContext > SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleContext( ) +{ + return this; +} + +// XAccessibleContext + +sal_Int32 SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleChildCount( ) +{ + OContextEntryGuard aGuard( this ); + + return m_xChild.is() ? 1 : 0; +} + +Reference< XAccessible > SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleChild( sal_Int32 i ) +{ + OContextEntryGuard aGuard( this ); + + // no child -> so index is out of bounds + if ( !m_xChild.is() || i != 0 ) + throw IndexOutOfBoundsException(); + + return m_xChild; +} + +Reference< XAccessible > SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleParent( ) +{ + OContextEntryGuard aGuard( this ); + + return m_pToolBox->GetAccessible(); +} + +sal_Int32 SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleIndexInParent( ) +{ + OContextEntryGuard aGuard( this ); + + return m_nIndexInParent; +} + +sal_Int16 SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleRole( ) +{ + OContextEntryGuard aGuard( this ); + + return m_nRole; +} + +OUString SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleDescription( ) +{ + OExternalLockGuard aGuard( this ); + + if (m_nRole == AccessibleRole::PANEL && m_xChild.is()) + { + return AccResId( RID_STR_ACC_PANEL_DESCRIPTION ); + } + else + { + OUString sDescription; + if ( m_pToolBox ) + sDescription = m_pToolBox->GetHelpText( m_nItemId ); + return sDescription; + } +} + +OUString SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleName( ) +{ + OExternalLockGuard aGuard( this ); + + // entry text == accessible name + return GetText(); +} + +Reference< XAccessibleRelationSet > SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleRelationSet( ) +{ + OContextEntryGuard aGuard( this ); + + return new utl::AccessibleRelationSetHelper; +} + +Reference< XAccessibleStateSet > SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleStateSet( ) +{ + OExternalLockGuard aGuard( this ); + + rtl::Reference<utl::AccessibleStateSetHelper> pStateSetHelper = new utl::AccessibleStateSetHelper; + + if ( m_pToolBox && !rBHelper.bDisposed && !rBHelper.bInDispose ) + { + pStateSetHelper->AddState( AccessibleStateType::FOCUSABLE ); + if ( m_bIsChecked && m_nRole != AccessibleRole::PANEL ) + pStateSetHelper->AddState( AccessibleStateType::CHECKED ); + if ( m_bIndeterminate ) + pStateSetHelper->AddState( AccessibleStateType::INDETERMINATE ); + if ( m_pToolBox->IsEnabled() && m_pToolBox->IsItemEnabled( m_nItemId ) ) + { + pStateSetHelper->AddState( AccessibleStateType::ENABLED ); + pStateSetHelper->AddState( AccessibleStateType::SENSITIVE ); + } + if ( m_pToolBox->IsItemVisible( m_nItemId ) ) + pStateSetHelper->AddState( AccessibleStateType::VISIBLE ); + if ( m_pToolBox->IsItemReallyVisible( m_nItemId ) ) + pStateSetHelper->AddState( AccessibleStateType::SHOWING ); + if ( m_bHasFocus ) + pStateSetHelper->AddState( AccessibleStateType::FOCUSED ); + } + else + pStateSetHelper->AddState( AccessibleStateType::DEFUNC ); + + return pStateSetHelper; +} + +// XAccessibleText + +OUString VCLXAccessibleToolBoxItem::getText() +{ + OExternalLockGuard aGuard( this ); + + return GetText(); +} + +sal_Int32 VCLXAccessibleToolBoxItem::getCharacterCount() +{ + return GetText().getLength(); +} + +sal_Unicode VCLXAccessibleToolBoxItem::getCharacter( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + return OCommonAccessibleText::implGetCharacter( GetText(), nIndex ); +} + +OUString VCLXAccessibleToolBoxItem::getTextRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) +{ + OExternalLockGuard aGuard( this ); + + return OCommonAccessibleText::implGetTextRange( GetText(), nStartIndex, nEndIndex ); +} + +sal_Int32 SAL_CALL VCLXAccessibleToolBoxItem::getCaretPosition() +{ + return -1; +} + +sal_Bool SAL_CALL VCLXAccessibleToolBoxItem::setCaretPosition( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( !implIsValidRange( nIndex, nIndex, GetText().getLength() ) ) + throw IndexOutOfBoundsException(); + + return false; +} + +Sequence< PropertyValue > SAL_CALL VCLXAccessibleToolBoxItem::getCharacterAttributes( sal_Int32 nIndex, const Sequence< OUString >& ) +{ + OExternalLockGuard aGuard( this ); + + OUString sText( implGetText() ); + + if ( !implIsValidIndex( nIndex, sText.getLength() ) ) + throw IndexOutOfBoundsException(); + + return Sequence< PropertyValue >(); +} + +awt::Rectangle SAL_CALL VCLXAccessibleToolBoxItem::getCharacterBounds( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + OUString sText( implGetText() ); + + if ( !implIsValidIndex( nIndex, sText.getLength() ) ) + throw IndexOutOfBoundsException(); + + awt::Rectangle aBounds( 0, 0, 0, 0 ); + if ( m_pToolBox && m_pToolBox->GetButtonType() != ButtonType::SYMBOLONLY ) // symbol buttons have no character bounds + { + tools::Rectangle aCharRect = m_pToolBox->GetCharacterBounds( m_nItemId, nIndex ); + tools::Rectangle aItemRect = m_pToolBox->GetItemRect( m_nItemId ); + aCharRect.Move( -aItemRect.Left(), -aItemRect.Top() ); + aBounds = AWTRectangle( aCharRect ); + } + + return aBounds; +} + +sal_Int32 SAL_CALL VCLXAccessibleToolBoxItem::getIndexAtPoint( const awt::Point& aPoint ) +{ + OExternalLockGuard aGuard( this ); + + sal_Int32 nIndex = -1; + if ( m_pToolBox && m_pToolBox->GetButtonType() != ButtonType::SYMBOLONLY ) // symbol buttons have no character bounds + { + ToolBoxItemId nItemId; + tools::Rectangle aItemRect = m_pToolBox->GetItemRect( m_nItemId ); + Point aPnt( VCLPoint( aPoint ) ); + aPnt += aItemRect.TopLeft(); + sal_Int32 nIdx = m_pToolBox->GetIndexForPoint( aPnt, nItemId ); + if ( nIdx != -1 && nItemId == m_nItemId ) + nIndex = nIdx; + } + + return nIndex; +} + +sal_Bool SAL_CALL VCLXAccessibleToolBoxItem::setSelection( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( !implIsValidRange( nStartIndex, nEndIndex, implGetText().getLength() ) ) + throw IndexOutOfBoundsException(); + + return false; +} + +sal_Bool SAL_CALL VCLXAccessibleToolBoxItem::copyText( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( !implIsValidRange( nStartIndex, nEndIndex, implGetText().getLength() ) ) + throw IndexOutOfBoundsException(); + + bool bReturn = false; + + if ( m_pToolBox ) + { + Reference< datatransfer::clipboard::XClipboard > xClipboard = m_pToolBox->GetClipboard(); + if ( xClipboard.is() ) + { + OUString sText( OCommonAccessibleText::implGetTextRange( implGetText(), nStartIndex, nEndIndex ) ); + + rtl::Reference<vcl::unohelper::TextDataObject> pDataObj = new vcl::unohelper::TextDataObject( sText ); + + SolarMutexReleaser aReleaser; + xClipboard->setContents( pDataObj, nullptr ); + + Reference< datatransfer::clipboard::XFlushableClipboard > xFlushableClipboard( xClipboard, uno::UNO_QUERY ); + if( xFlushableClipboard.is() ) + xFlushableClipboard->flushClipboard(); + + bReturn = true; + } + } + + return bReturn; +} + +sal_Bool VCLXAccessibleToolBoxItem::scrollSubstringTo( sal_Int32, sal_Int32, AccessibleScrollType ) +{ + return false; +} + +// XAccessibleComponent + +Reference< XAccessible > SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleAtPoint( const awt::Point& ) +{ + return Reference< XAccessible >(); +} + +void SAL_CALL VCLXAccessibleToolBoxItem::grabFocus( ) +{ + Reference< XAccessible > xParent(getAccessibleParent()); + + if( xParent.is() ) + { + Reference< XAccessibleSelection > rxAccessibleSelection(xParent->getAccessibleContext(), UNO_QUERY); + + if ( rxAccessibleSelection.is() ) + { + rxAccessibleSelection -> selectAccessibleChild ( getAccessibleIndexInParent() ); + } + } +} + +sal_Int32 SAL_CALL VCLXAccessibleToolBoxItem::getForeground( ) +{ + OExternalLockGuard aGuard( this ); + + Color nColor; + if ( m_pToolBox ) + nColor = m_pToolBox->GetControlForeground(); + + return sal_Int32(nColor); +} + +sal_Int32 SAL_CALL VCLXAccessibleToolBoxItem::getBackground( ) +{ + OExternalLockGuard aGuard( this ); + + Color nColor; + if ( m_pToolBox ) + nColor = m_pToolBox->GetControlBackground(); + + return sal_Int32(nColor); +} + +// XAccessibleExtendedComponent +Reference< awt::XFont > SAL_CALL VCLXAccessibleToolBoxItem::getFont( ) +{ + return uno::Reference< awt::XFont >(); +} + +OUString SAL_CALL VCLXAccessibleToolBoxItem::getTitledBorderText( ) +{ + OExternalLockGuard aGuard( this ); + + OUString sRet; + if ( m_pToolBox ) + sRet = m_pToolBox->GetItemText( m_nItemId ); + + return sRet; +} + +OUString SAL_CALL VCLXAccessibleToolBoxItem::getToolTipText( ) +{ + OExternalLockGuard aGuard( this ); + + OUString sRet; + if ( m_pToolBox ) + { + if ( Help::IsExtHelpEnabled() ) + sRet = m_pToolBox->GetHelpText( m_nItemId ); + else + sRet = m_pToolBox->GetQuickHelpText( m_nItemId ); + if ( sRet.isEmpty() ) + // no help text set, so use item text + sRet = m_pToolBox->GetItemText( m_nItemId ); + } + return sRet; +} + +// XAccessibleAction + +sal_Int32 VCLXAccessibleToolBoxItem::getAccessibleActionCount( ) +{ + // only one action -> "Click" + return 1; +} + +sal_Bool VCLXAccessibleToolBoxItem::doAccessibleAction ( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nIndex != 0 ) + throw IndexOutOfBoundsException(); + + if ( m_pToolBox ) + m_pToolBox->TriggerItem( m_nItemId ); + + return true; +} + +OUString VCLXAccessibleToolBoxItem::getAccessibleActionDescription ( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if ( nIndex != 0 ) + throw IndexOutOfBoundsException(); + + return RID_STR_ACC_ACTION_CLICK; +} + +Reference< XAccessibleKeyBinding > VCLXAccessibleToolBoxItem::getAccessibleActionKeyBinding( sal_Int32 nIndex ) +{ + OContextEntryGuard aGuard( this ); + + if ( nIndex != 0 ) + throw IndexOutOfBoundsException(); + + return Reference< XAccessibleKeyBinding >(); +} + +// XAccessibleValue + +Any VCLXAccessibleToolBoxItem::getCurrentValue( ) +{ + OExternalLockGuard aGuard( this ); + + Any aValue; + if ( m_pToolBox ) + aValue <<= static_cast<sal_Int32>(m_pToolBox->IsItemChecked( m_nItemId )); + + if( m_nRole == AccessibleRole::PANEL ) + aValue <<= sal_Int32(0); + return aValue; +} + +sal_Bool VCLXAccessibleToolBoxItem::setCurrentValue( const Any& aNumber ) +{ + OExternalLockGuard aGuard( this ); + + bool bReturn = false; + + if ( m_pToolBox ) + { + sal_Int32 nValue = 0; + OSL_VERIFY( aNumber >>= nValue ); + + if ( nValue < 0 ) + nValue = 0; + else if ( nValue > 1 ) + nValue = 1; + + m_pToolBox->CheckItem( m_nItemId, nValue == 1 ); + bReturn = true; + } + + return bReturn; +} + +Any VCLXAccessibleToolBoxItem::getMaximumValue( ) +{ + return Any(sal_Int32(1)); +} + +Any VCLXAccessibleToolBoxItem::getMinimumValue( ) +{ + return Any(sal_Int32(0)); +} + +Any VCLXAccessibleToolBoxItem::getMinimumIncrement( ) +{ + return Any(sal_Int32(1)); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |