/************************************************************** * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_svx.hxx" #ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLEROLE_HPP_ #include #endif #ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLEEVENTID_HPP_ #include #endif #ifndef _UTL_ACCESSIBLESTATESETHELPER_HXX_ #include #endif #ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLESTATETYPE_HPP_ #include #endif #ifndef _COM_SUN_STAR_BEANS_PROPERTYCHANGEEVENT_HPP_ #include #endif #ifndef _COM_SUN_STAR_AWT_XWINDOW_HPP_ #include #endif #ifndef _CPPUHELPER_TYPEPROVIDER_HXX_ #include #endif #ifndef _TOOLKIT_HELPER_VCLUNOHELPER_HXX_ #include #endif #ifndef _TOOLKIT_HELPER_CONVERT_HXX_ #include #endif #ifndef _SV_SVAPP_HXX #include #endif #ifndef _OSL_MUTEX_HXX_ #include #endif #ifndef _RTL_UUID_H_ #include #endif #ifndef _TOOLS_DEBUG_HXX #include #endif #ifndef _SV_GEN_HXX #include #endif #include #include "accessibility.hrc" #include #ifndef _SVX_DIALMGR_HXX #include #endif #ifndef COMPHELPER_ACCESSIBLE_EVENT_NOTIFIER #include #endif #include #ifndef _SVXPIXELACCESSIBLECONTEXT_HXX #include "svxpixelctlaccessiblecontext.hxx" #endif #ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLERELATIONTYPE_HPP_ #include #endif using namespace ::cppu; using namespace ::osl; using namespace ::rtl; using namespace ::com::sun::star; using namespace ::com::sun::star::uno; using namespace ::com::sun::star::accessibility; SvxPixelCtlAccessible::SvxPixelCtlAccessible( SvxPixelCtl& rControl) : SvxPixelCtlAccessible_BASE(m_aMutex), pPixelCtl(&rControl), mnClientId(0) { //FreeResource(); } SvxPixelCtlAccessible::~SvxPixelCtlAccessible() { // DBG_DTOR( SvxPixelCtlAccessible, NULL ); if( IsAlive() ) { osl_incrementInterlockedCount( &m_refCount ); dispose(); // set mpRepr = NULL & release all childs } } /*-- 04.02.2002 14:11:55--------------------------------------------------- -----------------------------------------------------------------------*/ uno::Reference< XAccessibleContext > SvxPixelCtlAccessible::getAccessibleContext( ) throw (uno::RuntimeException) { return this; } sal_Int32 SvxPixelCtlAccessible::getAccessibleChildCount( ) throw (uno::RuntimeException) { ::osl::MutexGuard aGuard( m_aMutex ); IsValid(); if(pPixelCtl) { return pPixelCtl->GetSquares(); } else return 0; } /*-- 04.02.2002 14:11:56--------------------------------------------------- -----------------------------------------------------------------------*/ uno::Reference< XAccessible > SvxPixelCtlAccessible::getAccessibleChild( sal_Int32 i ) throw (uno::RuntimeException) { ::osl::MutexGuard aGuard( m_aMutex ); IsValid(); if ( i < 0 || i >= getAccessibleChildCount()) throw lang::IndexOutOfBoundsException(); uno::Reference xAcc; if(pPixelCtl) { return CreateChild(i, pPixelCtl->IndexToPoint(i)); } else return xAcc; /* throw lang::IndexOutOfBoundsException ( ::rtl::OUString::createFromAscii ("no child with index " + i), NULL); */ } uno::Reference< XAccessible > SvxPixelCtlAccessible::getAccessibleParent( ) throw (uno::RuntimeException) { ::osl::MutexGuard aGuard( m_aMutex ); IsValid(); uno::Reference< XAccessible > xRet; if(pPixelCtl) xRet = pPixelCtl->GetParent()->GetAccessible( sal_True ); return xRet; } sal_Int32 SvxPixelCtlAccessible::getAccessibleIndexInParent( ) throw (uno::RuntimeException) { ::osl::MutexGuard aGuard( m_aMutex ); IsValid(); sal_uInt16 nIdx = 0; if(pPixelCtl) { Window* pTabPage = pPixelCtl->GetParent(); sal_uInt16 nChildren = pTabPage->GetChildCount(); for(nIdx = 0; nIdx < nChildren; nIdx++) if(pTabPage->GetChild( nIdx ) == pPixelCtl) break; } return nIdx; } /*-- 04.02.2002 14:11:57--------------------------------------------------- -----------------------------------------------------------------------*/ sal_Int16 SvxPixelCtlAccessible::getAccessibleRole( ) throw (uno::RuntimeException) { return AccessibleRole::LIST; } ::rtl::OUString SvxPixelCtlAccessible::getAccessibleDescription( ) throw (uno::RuntimeException) { ::osl::MutexGuard aGuard( m_aMutex ); IsValid(); if(pPixelCtl) return pPixelCtl->GetAccessibleDescription(); else return String(); } ::rtl::OUString SvxPixelCtlAccessible::getAccessibleName( ) throw (uno::RuntimeException) { ::osl::MutexGuard aGuard( m_aMutex ); IsValid(); if(pPixelCtl) return pPixelCtl->GetAccessibleName(); else return String(); } uno::Reference< XAccessibleRelationSet > SvxPixelCtlAccessible::getAccessibleRelationSet( ) throw (uno::RuntimeException) { ::osl::MutexGuard aGuard( m_aMutex ); IsValid(); Window* pWindow = (Window*)pPixelCtl; utl::AccessibleRelationSetHelper* rRelationSet = new utl::AccessibleRelationSetHelper; uno::Reference< accessibility::XAccessibleRelationSet > rSet = rRelationSet; if ( pWindow ) { Window *pLabeledBy = pWindow->GetAccessibleRelationLabeledBy(); if ( pLabeledBy && pLabeledBy != pWindow ) { uno::Sequence< uno::Reference< uno::XInterface > > aSequence(1); aSequence[0] = pLabeledBy->GetAccessible(); rRelationSet->AddRelation( accessibility::AccessibleRelation( accessibility::AccessibleRelationType::LABELED_BY, aSequence ) ); } Window* pMemberOf = pWindow->GetAccessibleRelationMemberOf(); if ( pMemberOf && pMemberOf != pWindow ) { uno::Sequence< uno::Reference< uno::XInterface > > aSequence(1); aSequence[0] = pMemberOf->GetAccessible(); rRelationSet->AddRelation( accessibility::AccessibleRelation( accessibility::AccessibleRelationType::MEMBER_OF, aSequence ) ); } return rSet; } return new utl::AccessibleRelationSetHelper; } uno::Reference< XAccessibleStateSet > SvxPixelCtlAccessible::getAccessibleStateSet( ) throw (uno::RuntimeException) { ::osl::MutexGuard aGuard( m_aMutex ); utl::AccessibleStateSetHelper* pStateSetHelper = new utl::AccessibleStateSetHelper; uno::Reference< XAccessibleStateSet > xRet = pStateSetHelper; if(!pPixelCtl) pStateSetHelper->AddState(AccessibleStateType::DEFUNC); else { const sal_Int16 aStandardStates[] = { AccessibleStateType::FOCUSABLE, AccessibleStateType::SELECTABLE, AccessibleStateType::SHOWING, AccessibleStateType::VISIBLE, AccessibleStateType::OPAQUE, 0}; sal_Int16 nState = 0; while(aStandardStates[nState]) { pStateSetHelper->AddState(aStandardStates[nState++]); } if(pPixelCtl->IsEnabled()) pStateSetHelper->AddState(AccessibleStateType::ENABLED); if(pPixelCtl->HasFocus()) pStateSetHelper->AddState(AccessibleStateType::FOCUSED); pStateSetHelper->AddState(AccessibleStateType::MANAGES_DESCENDANTS); } return xRet; } com::sun::star::lang::Locale SvxPixelCtlAccessible::getLocale( ) throw (IllegalAccessibleComponentStateException, uno::RuntimeException) { ::osl::MutexGuard aGuard( m_aMutex ); if( getAccessibleParent().is() ) { uno::Reference< XAccessibleContext > xParentContext( getAccessibleParent()->getAccessibleContext() ); if( xParentContext.is() ) return xParentContext->getLocale(); } // No locale and no parent. Therefore throw exception to indicate this // cluelessness. throw IllegalAccessibleComponentStateException(); } sal_Bool SvxPixelCtlAccessible::containsPoint( const awt::Point& aPt ) throw (uno::RuntimeException) { ::osl::MutexGuard aGuard( m_aMutex ); IsValid(); Point aPoint(aPt.X, aPt.Y); if(pPixelCtl) return (aPoint.X() >= 0) && (aPoint.X() < pPixelCtl->GetSizePixel().getWidth()) && (aPoint.Y() >= 0) && (aPoint.Y() < pPixelCtl->GetSizePixel().getHeight()); else return sal_False; } uno::Reference SAL_CALL SvxPixelCtlAccessible::getAccessibleAtPoint ( const awt::Point& aPoint) throw (uno::RuntimeException) { ::osl::MutexGuard aGuard( m_aMutex ); ensureIsAlive(); uno::Reference xAcc; Point childPoint; childPoint.X() = aPoint.X; childPoint.Y() = aPoint.Y; if(pPixelCtl) { Point pt= pPixelCtl->PixelToLogic(childPoint); long nIndex = pPixelCtl->PointToIndex(pt); return CreateChild(nIndex,pPixelCtl->IndexToPoint(nIndex)); } else return xAcc; } awt::Rectangle SvxPixelCtlAccessible::getBounds( ) throw (uno::RuntimeException) { ::osl::MutexGuard aGuard( m_aMutex ); IsValid(); Size aSz; Point aPos(0,0); awt::Rectangle aRet; if(pPixelCtl) { aSz = pPixelCtl->GetSizePixel(); aPos = pPixelCtl->GetPosPixel(); aRet.X = aPos.X(); aRet.Y = aPos.Y(); aRet.Width = aSz.Width(); aRet.Height = aSz.Height(); } return aRet; } awt::Point SvxPixelCtlAccessible::getLocation( ) throw (uno::RuntimeException) { ::osl::MutexGuard aGuard( m_aMutex ); IsValid(); Point aPos; aPos = pPixelCtl->GetPosPixel(); awt::Point aRet(aPos.X(), aPos.Y()); return aRet; } awt::Point SvxPixelCtlAccessible::getLocationOnScreen( ) throw (uno::RuntimeException) { ::osl::MutexGuard aGuard( m_aMutex ); IsValid(); Rectangle rect; rect = pPixelCtl->GetWindowExtentsRelative(NULL); awt::Point aRet(rect.Left(),rect.Top() ); return aRet; } awt::Size SvxPixelCtlAccessible::getSize( ) throw (uno::RuntimeException) { ::osl::MutexGuard aGuard( m_aMutex ); IsValid(); Size aSz; aSz = pPixelCtl->GetSizePixel(); awt::Size aRet(aSz.Width(),aSz.Height()); return aRet; } void SvxPixelCtlAccessible::grabFocus( ) throw (uno::RuntimeException) { ::osl::MutexGuard aGuard( m_aMutex ); IsValid(); if(pPixelCtl) pPixelCtl->GrabFocus(); } sal_Int32 SvxPixelCtlAccessible::getForeground( ) throw (::com::sun::star::uno::RuntimeException) { uno::Any aRet; ::osl::MutexGuard aGuard( m_aMutex ); IsValid(); return pPixelCtl->GetControlForeground().GetColor(); } sal_Int32 SvxPixelCtlAccessible::getBackground( ) throw (::com::sun::star::uno::RuntimeException) { uno::Any aRet; ::osl::MutexGuard aGuard( m_aMutex ); IsValid(); return pPixelCtl->GetControlBackground().GetColor(); } ::rtl::OUString SvxPixelCtlAccessible::getImplementationName( ) throw (uno::RuntimeException) { return rtl::OUString::createFromAscii("SvxPixelCtlAccessible"); } /*-- 04.02.2002 14:12:05--------------------------------------------------- -----------------------------------------------------------------------*/ const sal_Char sAccessible[] = "Accessible"; const sal_Char sAccessibleContext[] = "AccessibleContext"; const sal_Char sAccessibleComponent[] = "AccessibleComponent"; //const sal_Char sAccessibleTable[] = "AccessibleTable"; sal_Bool SvxPixelCtlAccessible::supportsService( const ::rtl::OUString& rServiceName ) throw (uno::RuntimeException) { return rServiceName.equalsAsciiL( sAccessible , sizeof(sAccessible )-1 ) || rServiceName.equalsAsciiL( sAccessibleContext , sizeof(sAccessibleContext )-1 ) || rServiceName.equalsAsciiL( sAccessibleComponent, sizeof(sAccessibleComponent)-1 );// || // rServiceName.equalsAsciiL( sAccessibleTable, sizeof(sAccessibleTable)-1 ); } /*-- 04.02.2002 14:12:05--------------------------------------------------- -----------------------------------------------------------------------*/ uno::Sequence< ::rtl::OUString > SvxPixelCtlAccessible::getSupportedServiceNames( ) throw (uno::RuntimeException) { uno::Sequence< OUString > aRet(2); OUString* pArray = aRet.getArray(); pArray[0] = OUString( RTL_CONSTASCII_USTRINGPARAM(sAccessible ) ); pArray[1] = OUString( RTL_CONSTASCII_USTRINGPARAM(sAccessibleContext ) ); pArray[2] = OUString( RTL_CONSTASCII_USTRINGPARAM(sAccessibleComponent) ); // pArray[3] = OUString( RTL_CONSTASCII_USTRINGPARAM(sAccessibleTable) ); return aRet; } // ----------------------------------------------------------------------------- // XAccessibleSelection // ----------------------------------------------------------------------------- void SAL_CALL SvxPixelCtlAccessible::selectAccessibleChild( sal_Int32 nChildIndex ) throw (lang::IndexOutOfBoundsException, RuntimeException) { ::osl::MutexGuard aGuard( m_aMutex ); IsValid(); if ( nChildIndex < 0 || nChildIndex >= getAccessibleChildCount()) throw lang::IndexOutOfBoundsException(); long nIndex = pPixelCtl->ShowPosition(pPixelCtl->IndexToPoint(nChildIndex)); NotifyChild(nIndex,sal_True,sal_False); } // ----------------------------------------------------------------------------- sal_Bool SAL_CALL SvxPixelCtlAccessible::isAccessibleChildSelected( sal_Int32 nChildIndex ) throw (lang::IndexOutOfBoundsException, RuntimeException) { ::osl::MutexGuard aGuard( m_aMutex ); IsValid(); return pPixelCtl->GetFoucsPosIndex() == nChildIndex; } // ----------------------------------------------------------------------------- void SAL_CALL SvxPixelCtlAccessible::clearAccessibleSelection( ) throw (RuntimeException) { ::osl::MutexGuard aGuard( m_aMutex ); IsValid(); } // ----------------------------------------------------------------------------- void SAL_CALL SvxPixelCtlAccessible::selectAllAccessibleChildren( ) throw (RuntimeException) { ::osl::MutexGuard aGuard( m_aMutex ); IsValid(); } // ----------------------------------------------------------------------------- sal_Int32 SAL_CALL SvxPixelCtlAccessible::getSelectedAccessibleChildCount( ) throw (RuntimeException) { ::osl::MutexGuard aGuard( m_aMutex ); IsValid(); return 1; } // ----------------------------------------------------------------------------- uno::Reference< XAccessible > SAL_CALL SvxPixelCtlAccessible::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex ) throw (lang::IndexOutOfBoundsException, RuntimeException) { ::osl::MutexGuard aGuard( m_aMutex ); IsValid(); if ( nSelectedChildIndex >= 1) throw lang::IndexOutOfBoundsException(); uno::Reference< XAccessible > xChild; if(pPixelCtl) { if(m_xCurChild.is()) { xChild = m_xCurChild; } } return xChild; } // ----------------------------------------------------------------------------- void SAL_CALL SvxPixelCtlAccessible::deselectAccessibleChild( sal_Int32 ) throw (lang::IndexOutOfBoundsException, RuntimeException) { ::osl::MutexGuard aGuard( m_aMutex ); IsValid(); } // Added by lq void SvxPixelCtlAccessible::ensureIsAlive() const throw ( lang::DisposedException ) { if( !IsAlive() ) throw lang::DisposedException(); } void SvxPixelCtlAccessible::ensureIsValidRow( sal_Int32 nRow ) throw ( lang::IndexOutOfBoundsException ) { if( nRow >= pPixelCtl->GetHeight() || nRow <0) throw lang::IndexOutOfBoundsException( OUString( RTL_CONSTASCII_USTRINGPARAM( "row index is invalid" ) ), *this ); } void SvxPixelCtlAccessible::ensureIsValidColumn( sal_Int32 nColumn ) throw ( lang::IndexOutOfBoundsException ) { if( nColumn >= pPixelCtl->GetWidth() || nColumn <0 ) throw lang::IndexOutOfBoundsException( OUString( RTL_CONSTASCII_USTRINGPARAM("column index is invalid") ), *this ); } void SvxPixelCtlAccessible::ensureIsValidAddress( sal_Int32 nRow, sal_Int32 nColumn ) throw ( lang::IndexOutOfBoundsException ) { ensureIsValidRow( nRow ); ensureIsValidColumn( nColumn ); } void SvxPixelCtlAccessible::ensureIsValidIndex( sal_Int32 nChildIndex ) throw ( lang::IndexOutOfBoundsException ) { if( nChildIndex >= pPixelCtl->GetSquares()) throw lang::IndexOutOfBoundsException( OUString( RTL_CONSTASCII_USTRINGPARAM("child index is invalid") ), *this ); } // XAccessibleTable ----------------------------------------------------------- /* sal_Int32 SAL_CALL SvxPixelCtlAccessible::getAccessibleRowCount() throw ( uno::RuntimeException ) { ::osl::MutexGuard aGuard( m_aMutex ); ensureIsAlive(); return pPixelCtl->GetLineCount(); } sal_Int32 SAL_CALL SvxPixelCtlAccessible::getAccessibleColumnCount() throw ( uno::RuntimeException ) { ::osl::MutexGuard aGuard( m_aMutex ); ensureIsAlive(); return pPixelCtl->GetLineCount(); } sal_Int32 SAL_CALL SvxPixelCtlAccessible::getAccessibleRowExtentAt( sal_Int32 nRow, sal_Int32 nColumn ) throw ( lang::IndexOutOfBoundsException, uno::RuntimeException ) { ::osl::MutexGuard aGuard( m_aMutex ); ensureIsAlive(); return 1; // merged cells not supported } sal_Int32 SAL_CALL SvxPixelCtlAccessible::getAccessibleColumnExtentAt( sal_Int32 nRow, sal_Int32 nColumn ) throw ( lang::IndexOutOfBoundsException, uno::RuntimeException ) { ::osl::MutexGuard aGuard( m_aMutex ); ensureIsAlive(); return 1; // merged cells not supported } uno::Reference< XAccessible > SAL_CALL SvxPixelCtlAccessible::getAccessibleCaption() throw ( uno::RuntimeException ) { uno::Reference< XAccessible > xAccessble; ensureIsAlive(); return xAccessble; // not supported } uno::Reference< XAccessible > SAL_CALL SvxPixelCtlAccessible::getAccessibleSummary() throw ( uno::RuntimeException ) { uno::Reference< XAccessible > xAccessble; ensureIsAlive(); return xAccessble; // not supported } sal_Int32 SAL_CALL SvxPixelCtlAccessible::getAccessibleIndex( sal_Int32 nRow, sal_Int32 nColumn ) throw ( lang::IndexOutOfBoundsException, uno::RuntimeException ) { ::osl::MutexGuard aGuard( m_aMutex ); ensureIsAlive(); ensureIsValidAddress(nRow,nColumn); return nRow + nColumn * pPixelCtl->GetLineCount() ; } sal_Int32 SAL_CALL SvxPixelCtlAccessible::getAccessibleRow( sal_Int32 nChildIndex ) throw ( lang::IndexOutOfBoundsException, uno::RuntimeException ) { ::osl::MutexGuard aGuard( m_aMutex ); ensureIsAlive(); ensureIsValidIndex( nChildIndex ); return nChildIndex/pPixelCtl->GetLineCount(); } sal_Int32 SAL_CALL SvxPixelCtlAccessible::getAccessibleColumn( sal_Int32 nChildIndex ) throw ( lang::IndexOutOfBoundsException, uno::RuntimeException ) { ::osl::MutexGuard aGuard( m_aMutex ); ensureIsAlive(); ensureIsValidIndex( nChildIndex ); return nChildIndex%pPixelCtl->GetLineCount(); } ::rtl::OUString SAL_CALL SvxPixelCtlAccessible::getAccessibleRowDescription( sal_Int32 nRow ) throw ( lang::IndexOutOfBoundsException, uno::RuntimeException ) { ::osl::MutexGuard aGuard( m_aMutex ); ensureIsAlive(); ensureIsValidRow( nRow ); return ::rtl::OUString::createFromAscii (""); } ::rtl::OUString SAL_CALL SvxPixelCtlAccessible::getAccessibleColumnDescription( sal_Int32 nColumn ) throw ( lang::IndexOutOfBoundsException, uno::RuntimeException ) { ::osl::MutexGuard aGuard( m_aMutex ); ensureIsAlive(); ensureIsValidColumn( nColumn ); return ::rtl::OUString::createFromAscii (""); } uno::Reference< XAccessibleTable > SAL_CALL SvxPixelCtlAccessible::getAccessibleRowHeaders() throw ( uno::RuntimeException ) { ::osl::MutexGuard aGuard( m_aMutex ); uno::Reference< XAccessibleTable > xAccessble; ensureIsAlive(); return xAccessble; } uno::Reference< XAccessibleTable > SAL_CALL SvxPixelCtlAccessible::getAccessibleColumnHeaders() throw ( uno::RuntimeException ) { ::osl::MutexGuard aGuard( m_aMutex ); uno::Reference< XAccessibleTable > xAccessble; ensureIsAlive(); return xAccessble; } Sequence< sal_Int32 > SAL_CALL SvxPixelCtlAccessible::getSelectedAccessibleRows() throw ( uno::RuntimeException ) { ::osl::MutexGuard aGuard( m_aMutex ); Sequence< sal_Int32 > accRows; ensureIsAlive(); return accRows; } Sequence< sal_Int32 > SAL_CALL SvxPixelCtlAccessible::getSelectedAccessibleColumns() throw ( uno::RuntimeException ) { ::osl::MutexGuard aGuard( m_aMutex ); Sequence< sal_Int32 > accColumns; ensureIsAlive(); return accColumns; } sal_Bool SAL_CALL SvxPixelCtlAccessible::isAccessibleRowSelected( sal_Int32 nRow ) throw ( lang::IndexOutOfBoundsException, uno::RuntimeException ) { ::osl::MutexGuard aGuard( m_aMutex ); ensureIsAlive(); ensureIsValidRow( nRow ); return sal_False; } sal_Bool SAL_CALL SvxPixelCtlAccessible::isAccessibleColumnSelected( sal_Int32 nColumn ) throw ( lang::IndexOutOfBoundsException, uno::RuntimeException ) { ::osl::MutexGuard aGuard( m_aMutex ); ensureIsAlive(); ensureIsValidColumn( nColumn ); return sal_False; } uno::Reference< XAccessible > SAL_CALL SvxPixelCtlAccessible::getAccessibleCellAt( sal_Int32 nRow, sal_Int32 nColumn ) throw ( lang::IndexOutOfBoundsException, uno::RuntimeException ) { ::osl::MutexGuard aGuard( m_aMutex ); ensureIsAlive(); ensureIsValidAddress( nRow, nColumn ); return getAccessibleChild(nRow*pPixelCtl->GetLineCount()+nColumn); } sal_Bool SAL_CALL SvxPixelCtlAccessible::isAccessibleSelected( sal_Int32 nRow, sal_Int32 nColumn ) throw ( lang::IndexOutOfBoundsException, uno::RuntimeException ) { ::osl::MutexGuard aGuard( m_aMutex ); ensureIsAlive(); ensureIsValidAddress( nRow, nColumn ); return isAccessibleChildSelected(nRow*pPixelCtl->GetLineCount()+nColumn); } // Added by lq end */ //XAccessibleEventBroadcaster void SAL_CALL SvxPixelCtlAccessible::addEventListener( const uno::Reference< XAccessibleEventListener >& xListener ) throw( RuntimeException ) { if (xListener.is()) { ::osl::MutexGuard aGuard( m_aMutex ); if (!mnClientId) mnClientId = comphelper::AccessibleEventNotifier::registerClient( ); comphelper::AccessibleEventNotifier::addEventListener( mnClientId, xListener ); } } void SAL_CALL SvxPixelCtlAccessible::removeEventListener( const uno::Reference< XAccessibleEventListener >& xListener ) throw( RuntimeException ) { if (xListener.is()) { ::osl::MutexGuard aGuard( m_aMutex ); sal_Int32 nListenerCount = comphelper::AccessibleEventNotifier::removeEventListener( mnClientId, xListener ); if ( !nListenerCount ) { comphelper::AccessibleEventNotifier::revokeClient( mnClientId ); mnClientId = 0; } } } void SvxPixelCtlAccessible::CommitChange( const AccessibleEventObject& rEvent ) { if (mnClientId) comphelper::AccessibleEventNotifier::addEvent( mnClientId, rEvent ); } //Solution:Add the event handling method void SvxPixelCtlAccessible::FireAccessibleEvent (short nEventId, const ::com::sun::star::uno::Any& rOld, const ::com::sun::star::uno::Any& rNew) { const uno::Reference< XInterface > xSource( *this ); CommitChange( AccessibleEventObject( xSource, nEventId, rNew,rOld ) ); } void SAL_CALL SvxPixelCtlAccessible::disposing() { if( !rBHelper.bDisposed ) { { ::osl::MutexGuard aGuard( m_aMutex ); if ( mnClientId ) { comphelper::AccessibleEventNotifier::revokeClientNotifyDisposing( mnClientId, *this ); mnClientId = 0; } } //mxParent = uno::Reference< XAccessible >(); } } void SvxPixelCtlAccessible::Invalidate() { pPixelCtl = 0; } void SvxPixelCtlAccessible::ThrowExceptionIfNotAlive( void ) throw( lang::DisposedException ) { if( IsNotAlive() ) throw lang::DisposedException(); } void SvxPixelCtlAccessible::IsValid() throw (uno::RuntimeException) { if(!pPixelCtl) throw uno::RuntimeException(); } void SvxPixelCtlAccessible::NotifyChild(long nIndex,sal_Bool bSelect ,sal_Bool bCheck) { DBG_ASSERT( !(!bSelect && !bCheck),"" );//non is false SvxPixelCtlAccessibleChild *pChild= NULL; if (m_xCurChild.is()) { pChild= static_cast(m_xCurChild.get()); DBG_ASSERT(pChild,"Child Must be Valid"); if (pChild->getAccessibleIndexInParent() == nIndex ) { if (bSelect) { pChild->SelectChild(sal_True); } if (bCheck) { pChild->ChangePixelColorOrBG(sal_Bool(pPixelCtl->GetBitmapPixel(sal_uInt16(nIndex)))); pChild->CheckChild(); } return ; } } uno::Reference xNewChild =CreateChild(nIndex, pPixelCtl->IndexToPoint(nIndex)); SvxPixelCtlAccessibleChild *pNewChild= static_cast(xNewChild.get()); DBG_ASSERT(pNewChild,"Child Must be Valid"); Any aNewValue,aOldValue; aNewValue<<= xNewChild; FireAccessibleEvent( AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, aOldValue, aNewValue ); if (bSelect) { if (pChild) { pChild->SelectChild(sal_False); } pNewChild->SelectChild(sal_True); } if (bCheck) { pNewChild->CheckChild(); } m_xCurChild= xNewChild; } uno::Reference SvxPixelCtlAccessible::CreateChild (long nIndex,Point mPoint) { long nX = mPoint.X(); long nY = mPoint.Y(); if( Application::GetSettings().GetLayoutRTL()) { nX = (sal_uInt16) pPixelCtl->GetWidth() - 1 - nX; } sal_Bool bPixelColorOrBG= sal_Bool(pPixelCtl->GetBitmapPixel(sal_uInt16(nIndex))); Size size(pPixelCtl->GetWidth() / pPixelCtl->GetLineCount(),pPixelCtl->GetHeight() / pPixelCtl->GetLineCount()); uno::Reference xChild; xChild = new SvxPixelCtlAccessibleChild(pPixelCtl, bPixelColorOrBG, Point(nX,nY), Rectangle(mPoint,size), this, nIndex); return xChild; } void SvxPixelCtlAccessible::LoseFocus() { m_xCurChild = uno::Reference< XAccessible >() ; } void SvxPixelCtlAccessibleChild::CheckChild() { Any aChecked; aChecked <<= AccessibleStateType::CHECKED; if (m_bPixelColorOrBG)//Current Child State { FireAccessibleEvent( AccessibleEventId::STATE_CHANGED, Any(), aChecked); } else { FireAccessibleEvent( AccessibleEventId::STATE_CHANGED, aChecked, Any() ); } } void SvxPixelCtlAccessibleChild::SelectChild( sal_Bool bSelect) { Any aSelected; aSelected <<= AccessibleStateType::SELECTED; if (bSelect) { FireAccessibleEvent( AccessibleEventId::STATE_CHANGED, Any(), aSelected); } else { FireAccessibleEvent( AccessibleEventId::STATE_CHANGED, aSelected, Any()); } } void SvxPixelCtlAccessibleChild::FireAccessibleEvent ( short nEventId, const ::com::sun::star::uno::Any& rOld, const ::com::sun::star::uno::Any& rNew) { const uno::Reference< XInterface > xSource( *this ); CommitChange( AccessibleEventObject( xSource, nEventId, rNew,rOld ) ); } DBG_NAME( SvxPixelCtlAccessibleChild ) SvxPixelCtlAccessibleChild::SvxPixelCtlAccessibleChild( SvxPixelCtl* rWindow, sal_Bool bPixelColorOrBG, const Point &aPoint, const Rectangle& rBoundingBox, const uno::Reference& rxParent, long nIndexInParent ) : SvxPixelCtlAccessibleChild_BASE( m_aMutex ), mrParentWindow( rWindow ), mxParent(rxParent), m_bPixelColorOrBG(bPixelColorOrBG), maPoint(aPoint), mpBoundingBox( new Rectangle( rBoundingBox ) ), mnIndexInParent( nIndexInParent ), mnClientId( 0 ) { DBG_CTOR( SvxPixelCtlAccessibleChild, NULL ); } SvxPixelCtlAccessibleChild::~SvxPixelCtlAccessibleChild() { DBG_DTOR( SvxPixelCtlAccessibleChild, NULL ); if( IsAlive() ) { osl_incrementInterlockedCount( &m_refCount ); dispose(); // set mpRepr = NULL & release all childs } } //===== XAccessible ========================================================= uno::Reference< XAccessibleContext> SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleContext( void ) throw( RuntimeException ) { return this; } //===== XAccessibleComponent ================================================ sal_Bool SAL_CALL SvxPixelCtlAccessibleChild::containsPoint( const awt::Point& rPoint ) throw( RuntimeException ) { // no guard -> done in getBounds() // return GetBoundingBox().IsInside( VCLPoint( rPoint ) ); return Rectangle( Point( 0, 0 ), GetBoundingBox().GetSize() ).IsInside( VCLPoint( rPoint ) ); } uno::Reference< XAccessible > SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleAtPoint( const awt::Point& ) throw( RuntimeException ) { return uno::Reference< XAccessible >(); } awt::Rectangle SAL_CALL SvxPixelCtlAccessibleChild::getBounds() throw( RuntimeException ) { // no guard -> done in getBoundingBox() //Modified by lq, 09/26 //return AWTRectangle( GetBoundingBox() ); awt::Rectangle rect = AWTRectangle( GetBoundingBox() ); rect.X = rect.X + mrParentWindow->GetClientWindowExtentsRelative(NULL).Left()-mrParentWindow->GetWindowExtentsRelative(NULL).Left(); rect.Y = rect.Y + mrParentWindow->GetClientWindowExtentsRelative(NULL).Top()-mrParentWindow->GetWindowExtentsRelative(NULL).Top(); return rect; // End } awt::Point SAL_CALL SvxPixelCtlAccessibleChild::getLocation() throw( RuntimeException ) { // no guard -> done in getBoundingBox() return AWTPoint( GetBoundingBox().TopLeft() ); } awt::Point SAL_CALL SvxPixelCtlAccessibleChild::getLocationOnScreen() throw( RuntimeException ) { // no guard -> done in getBoundingBoxOnScreen() return AWTPoint( GetBoundingBoxOnScreen().TopLeft() ); } awt::Size SAL_CALL SvxPixelCtlAccessibleChild::getSize() throw( RuntimeException ) { // no guard -> done in getBoundingBox() return AWTSize( GetBoundingBox().GetSize() ); } void SAL_CALL SvxPixelCtlAccessibleChild::grabFocus() throw( RuntimeException ) { } sal_Int32 SvxPixelCtlAccessibleChild::getForeground( ) throw (::com::sun::star::uno::RuntimeException) { //::vos::OGuard aSolarGuard( Application::GetSolarMutex() ); ::osl::MutexGuard aGuard( m_aMutex ); ThrowExceptionIfNotAlive(); return mrParentWindow->GetControlForeground().GetColor(); } sal_Int32 SvxPixelCtlAccessibleChild::getBackground( ) throw (::com::sun::star::uno::RuntimeException) { //::vos::OGuard aSolarGuard( Application::GetSolarMutex() ); ::osl::MutexGuard aGuard( m_aMutex ); ThrowExceptionIfNotAlive(); return mrParentWindow->GetControlBackground().GetColor(); } //===== XAccessibleContext ================================================== sal_Int32 SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleChildCount( void ) throw( RuntimeException ) { return 0; } uno::Reference< XAccessible > SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleChild( sal_Int32 ) throw ( RuntimeException ) { throw lang::IndexOutOfBoundsException(); } uno::Reference< XAccessible > SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleParent( void ) throw( RuntimeException ) { return mxParent; } sal_Int32 SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleIndexInParent( void ) throw( RuntimeException ) { return mnIndexInParent; } sal_Int16 SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleRole( void ) throw( RuntimeException ) { return AccessibleRole::CHECK_BOX; } OUString SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleDescription( void ) throw( RuntimeException ) { ::osl::MutexGuard aGuard( m_aMutex ); return GetName(); } OUString SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleName( void ) throw( RuntimeException ) { ::osl::MutexGuard aGuard( m_aMutex ); return GetName(); } /** Return empty uno::Reference to indicate that the relation set is not supported. */ uno::Reference SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleRelationSet( void ) throw( RuntimeException ) { return uno::Reference< XAccessibleRelationSet >(); } uno::Reference< XAccessibleStateSet > SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleStateSet( void ) throw( RuntimeException ) { ::osl::MutexGuard aGuard( m_aMutex ); utl::AccessibleStateSetHelper* pStateSetHelper = new utl::AccessibleStateSetHelper; if( IsAlive() ) { pStateSetHelper->AddState( AccessibleStateType::TRANSIENT ); pStateSetHelper->AddState( AccessibleStateType::ENABLED ); pStateSetHelper->AddState( AccessibleStateType::OPAQUE ); pStateSetHelper->AddState( AccessibleStateType::SELECTABLE ); pStateSetHelper->AddState( AccessibleStateType::SHOWING ); pStateSetHelper->AddState( AccessibleStateType::VISIBLE ); if (mrParentWindow ) { long nIndex = mrParentWindow->GetFoucsPosIndex(); if ( nIndex == mnIndexInParent) { pStateSetHelper->AddState( AccessibleStateType::SELECTED ); } if (mrParentWindow->GetBitmapPixel(sal_uInt16(mnIndexInParent))) { pStateSetHelper->AddState( AccessibleStateType::CHECKED ); } } } else pStateSetHelper->AddState( AccessibleStateType::DEFUNC ); return pStateSetHelper; } lang::Locale SAL_CALL SvxPixelCtlAccessibleChild::getLocale( void ) throw( IllegalAccessibleComponentStateException, RuntimeException ) { ::osl::MutexGuard aGuard( m_aMutex ); if( mxParent.is() ) { uno::Reference< XAccessibleContext > xParentContext( mxParent->getAccessibleContext() ); if( xParentContext.is() ) return xParentContext->getLocale(); } // No locale and no parent. Therefore throw exception to indicate this // cluelessness. throw IllegalAccessibleComponentStateException(); } void SAL_CALL SvxPixelCtlAccessibleChild::addEventListener( const uno::Reference< XAccessibleEventListener >& xListener ) throw( RuntimeException ) { if (xListener.is()) { ::osl::MutexGuard aGuard( m_aMutex ); if (!mnClientId) mnClientId = comphelper::AccessibleEventNotifier::registerClient( ); comphelper::AccessibleEventNotifier::addEventListener( mnClientId, xListener ); } } void SAL_CALL SvxPixelCtlAccessibleChild::removeEventListener( const uno::Reference< XAccessibleEventListener >& xListener ) throw( RuntimeException ) { if (xListener.is()) { ::osl::MutexGuard aGuard( m_aMutex ); sal_Int32 nListenerCount = comphelper::AccessibleEventNotifier::removeEventListener( mnClientId, xListener ); if ( !nListenerCount ) { // 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 comphelper::AccessibleEventNotifier::revokeClient( mnClientId ); mnClientId = 0; } } } //===== XServiceInfo ======================================================== OUString SAL_CALL SvxPixelCtlAccessibleChild::getImplementationName( void ) throw( RuntimeException ) { return OUString( RTL_CONSTASCII_USTRINGPARAM( "SvxPixelCtlAccessibleChild" ) ); } sal_Bool SAL_CALL SvxPixelCtlAccessibleChild::supportsService( const OUString& rServiceName ) throw( RuntimeException ) { return rServiceName.equalsAsciiL( sAccessible , sizeof(sAccessible )-1 ) || rServiceName.equalsAsciiL( sAccessibleContext , sizeof(sAccessibleContext )-1 ) || rServiceName.equalsAsciiL( sAccessibleComponent, sizeof(sAccessibleComponent)-1 ); } Sequence< OUString > SAL_CALL SvxPixelCtlAccessibleChild::getSupportedServiceNames( void ) throw( RuntimeException ) { uno::Sequence< OUString > aRet(3); OUString* pArray = aRet.getArray(); pArray[0] = OUString( RTL_CONSTASCII_USTRINGPARAM(sAccessible ) ); pArray[1] = OUString( RTL_CONSTASCII_USTRINGPARAM(sAccessibleContext ) ); pArray[2] = OUString( RTL_CONSTASCII_USTRINGPARAM(sAccessibleComponent) ); return aRet; } //===== internal ============================================================ void SvxPixelCtlAccessibleChild::CommitChange( const AccessibleEventObject& rEvent ) { if (mnClientId) comphelper::AccessibleEventNotifier::addEvent( mnClientId, rEvent ); } void SAL_CALL SvxPixelCtlAccessibleChild::disposing() { if( !rBHelper.bDisposed ) { ::osl::MutexGuard aGuard( m_aMutex ); // Send a disposing to all listeners. if ( mnClientId ) { comphelper::AccessibleEventNotifier::revokeClientNotifyDisposing( mnClientId, *this ); mnClientId = 0; } mxParent = uno::Reference< XAccessible >(); delete mpBoundingBox; } } void SvxPixelCtlAccessibleChild::ThrowExceptionIfNotAlive( void ) throw( lang::DisposedException ) { if( IsNotAlive() ) throw lang::DisposedException(); } Rectangle SvxPixelCtlAccessibleChild::GetBoundingBoxOnScreen( void ) throw( RuntimeException ) { ::osl::MutexGuard aGuard( m_aMutex ); // no ThrowExceptionIfNotAlive() because its done in GetBoundingBox() Rectangle aRect( GetBoundingBox() ); return Rectangle( mrParentWindow->OutputToAbsoluteScreenPixel( aRect.TopLeft() ), aRect.GetSize() ); } Rectangle SvxPixelCtlAccessibleChild::GetBoundingBox( void ) throw( RuntimeException ) { // no guard necessary, because no one changes mpBoundingBox after creating it ThrowExceptionIfNotAlive(); return *mpBoundingBox; } ::rtl::OUString SvxPixelCtlAccessibleChild::GetName() { sal_Int32 nXIndex = mnIndexInParent % mrParentWindow->GetLineCount(); sal_Int32 nYIndex = mnIndexInParent / mrParentWindow->GetLineCount(); OUString str; str += OUString::createFromAscii("("); str += OUString::valueOf(nXIndex); str += OUString::createFromAscii(","); str += OUString::valueOf(nYIndex); // str += OUString::createFromAscii(","); // str += OUString::valueOf(m_bPixelColorOrBG); str += OUString::createFromAscii(")"); return str; }