openoffice-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From stev...@apache.org
Subject svn commit: r1463840 [5/6] - in /openoffice/branches/ia2/main: cui/source/customize/ cui/source/dialogs/ cui/source/inc/ cui/source/tabpages/ editeng/inc/editeng/ editeng/source/accessibility/ editeng/source/editeng/ editeng/source/misc/ editeng/source...
Date Wed, 03 Apr 2013 07:04:22 GMT
Added: openoffice/branches/ia2/main/svx/source/accessibility/svxpixelctlaccessiblecontext.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/ia2/main/svx/source/accessibility/svxpixelctlaccessiblecontext.cxx?rev=1463840&view=auto
==============================================================================
--- openoffice/branches/ia2/main/svx/source/accessibility/svxpixelctlaccessiblecontext.cxx (added)
+++ openoffice/branches/ia2/main/svx/source/accessibility/svxpixelctlaccessiblecontext.cxx Wed Apr  3 07:04:20 2013
@@ -0,0 +1,1281 @@
+/**************************************************************
+ * 
+ * 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 <com/sun/star/accessibility/AccessibleRole.hpp>
+#endif
+#ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLEEVENTID_HPP_
+#include <com/sun/star/accessibility/AccessibleEventId.hpp>
+#endif
+#ifndef _UTL_ACCESSIBLESTATESETHELPER_HXX_
+#include <unotools/accessiblestatesethelper.hxx>
+#endif
+#ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLESTATETYPE_HPP_
+#include <com/sun/star/accessibility/AccessibleStateType.hpp>
+#endif
+
+#ifndef	_COM_SUN_STAR_BEANS_PROPERTYCHANGEEVENT_HPP_
+#include <com/sun/star/beans/PropertyChangeEvent.hpp>
+#endif
+
+#ifndef _COM_SUN_STAR_AWT_XWINDOW_HPP_
+#include <com/sun/star/awt/XWindow.hpp>
+#endif
+
+#ifndef _CPPUHELPER_TYPEPROVIDER_HXX_
+#include <cppuhelper/typeprovider.hxx>
+#endif
+
+#ifndef _TOOLKIT_HELPER_VCLUNOHELPER_HXX_
+#include <toolkit/helper/vclunohelper.hxx>
+#endif
+#ifndef _TOOLKIT_HELPER_CONVERT_HXX_
+#include <toolkit/helper/convert.hxx>
+#endif
+
+#ifndef _SV_SVAPP_HXX
+#include <vcl/svapp.hxx>
+#endif
+
+#ifndef _OSL_MUTEX_HXX_
+#include <osl/mutex.hxx>
+#endif
+#ifndef _RTL_UUID_H_
+#include <rtl/uuid.h>
+#endif
+#ifndef _TOOLS_DEBUG_HXX
+#include <tools/debug.hxx>
+#endif
+#ifndef _SV_GEN_HXX
+#include <tools/gen.hxx>
+#endif
+
+#include <svx/dialogs.hrc>
+#include "accessibility.hrc"
+#include <svx/dlgctrl.hxx>
+
+#ifndef _SVX_DIALMGR_HXX
+#include <svx/dialmgr.hxx>
+#endif
+#ifndef COMPHELPER_ACCESSIBLE_EVENT_NOTIFIER
+#include <comphelper/accessibleeventnotifier.hxx>
+#endif
+
+#include <unotools/accessiblerelationsethelper.hxx>
+
+#ifndef _SVXPIXELACCESSIBLECONTEXT_HXX
+#include "svxpixelctlaccessiblecontext.hxx"
+#endif
+#ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLERELATIONTYPE_HPP_
+#include <com/sun/star/accessibility/AccessibleRelationType.hpp>
+#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 <XAccessible> 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<XAccessible > SAL_CALL SvxPixelCtlAccessible::getAccessibleAtPoint (
+        const awt::Point& aPoint) 
+    throw (uno::RuntimeException)
+{
+	::osl::MutexGuard	aGuard( m_aMutex );
+	ensureIsAlive();
+	uno::Reference <XAccessible> 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<SvxPixelCtlAccessibleChild*>(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 <XAccessible> xNewChild =CreateChild(nIndex, pPixelCtl->IndexToPoint(nIndex));
+	SvxPixelCtlAccessibleChild *pNewChild= static_cast<SvxPixelCtlAccessibleChild*>(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<XAccessible> 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<XAccessible> 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<XAccessible>&	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<XAccessibleRelationSet> 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 );
+			}
+			//IAccessibility2 Implementation 2009-----
+			if (mrParentWindow->GetBitmapPixel(sal_uInt16(mnIndexInParent)))
+			//-----IAccessibility2 Implementation 2009
+			{
+				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 neccessary, 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;
+}

Modified: openoffice/branches/ia2/main/svx/source/accessibility/svxrectctaccessiblecontext.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/ia2/main/svx/source/accessibility/svxrectctaccessiblecontext.cxx?rev=1463840&r1=1463839&r2=1463840&view=diff
==============================================================================
--- openoffice/branches/ia2/main/svx/source/accessibility/svxrectctaccessiblecontext.cxx (original)
+++ openoffice/branches/ia2/main/svx/source/accessibility/svxrectctaccessiblecontext.cxx Wed Apr  3 07:04:20 2013
@@ -46,7 +46,14 @@
 #include <svx/dlgctrl.hxx>
 #include <svx/dialmgr.hxx>
 #include <comphelper/accessibleeventnotifier.hxx>
-
+//IAccessibility2 Implementation 2009-----
+#ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLERELATIONTYPE_HPP_
+#include <com/sun/star/accessibility/AccessibleRelationType.hpp>
+#endif
+#ifndef _UTL_ACCESSIBLERELATIONSETHELPER_HXX_
+#include <unotools/accessiblerelationsethelper.hxx>
+#endif
+//-----IAccessibility2 Implementation 2009
 
 using namespace ::cppu;
 using namespace ::osl;
@@ -54,6 +61,9 @@ using namespace	::com::sun::star;
 using namespace	::com::sun::star::uno;
 using namespace	::com::sun::star::accessibility;
 
+//IAccessibility2 Implementation 2009-----
+using namespace ::com::sun::star::lang;
+//-----IAccessibility2 Implementation 2009
 
 #define MAX_NUM_OF_CHILDS	9
 #define NOCHILDSELECTED		-1
@@ -354,13 +364,19 @@ sal_Int32 SAL_CALL SvxRectCtlAccessibleC
 
 sal_Int16 SAL_CALL SvxRectCtlAccessibleContext::getAccessibleRole( void ) throw( RuntimeException )
 {
+//IAccessibility2 Implementation 2009-----
+	//return AccessibleRole::GROUP_BOX;
 	return AccessibleRole::PANEL;
+//-----IAccessibility2 Implementation 2009
 }
 
 ::rtl::OUString SAL_CALL SvxRectCtlAccessibleContext::getAccessibleDescription( void ) throw( RuntimeException )
 {
 	::osl::MutexGuard	aGuard( m_aMutex );
-	return msDescription;
+	//IAccessibility2 Implementation 2009-----
+	//return msDescription;
+	return msDescription +::rtl::OUString::createFromAscii(" Please use arrow key to selection.");
+	//-----IAccessibility2 Implementation 2009
 }
 
 ::rtl::OUString SAL_CALL SvxRectCtlAccessibleContext::getAccessibleName( void ) throw( RuntimeException )
@@ -374,9 +390,40 @@ sal_Int16 SAL_CALL SvxRectCtlAccessibleC
 */
 Reference< XAccessibleRelationSet > SAL_CALL SvxRectCtlAccessibleContext::getAccessibleRelationSet( void ) throw( RuntimeException )
 {
-	return Reference< XAccessibleRelationSet >();
+//IAccessibility2 Implementation 2009-----
+	//return Reference< XAccessibleRelationSet >();
+	utl::AccessibleRelationSetHelper* pRelationSetHelper = new utl::AccessibleRelationSetHelper;
+	uno::Reference< accessibility::XAccessibleRelationSet > xSet = pRelationSetHelper;
+	Window* pWindow = mpRepr;
+	if ( pWindow )
+	{
+		// Window *pLabeledBy = pWindow->GetAccRelationLabeledBy();
+		Window *pLabeledBy = pWindow->GetAccessibleRelationLabeledBy();
+		if ( pLabeledBy && pLabeledBy != pWindow )
+		{
+			uno::Sequence< uno::Reference< uno::XInterface > > aSequence(1);
+			aSequence[0] = pLabeledBy->GetAccessible();
+			pRelationSetHelper->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();
+			pRelationSetHelper->AddRelation( accessibility::AccessibleRelation( accessibility::AccessibleRelationType::MEMBER_OF, aSequence ) );
+		}
+	}
+	return xSet;
+	//-----IAccessibility2 Implementation 2009
+}
+//IAccessibility2 Implementation 2009-----
+//Solution:Add the event handling method
+void SvxRectCtlAccessibleContext::FireAccessibleEvent (short nEventId, const ::com::sun::star::uno::Any& rOld, const ::com::sun::star::uno::Any& rNew)
+{
+	const Reference< XInterface >	xSource( *this );
+	CommitChange( AccessibleEventObject( xSource, nEventId, rNew,rOld ) );
 }
-
+//-----IAccessibility2 Implementation 2009	
 Reference< XAccessibleStateSet > SAL_CALL SvxRectCtlAccessibleContext::getAccessibleStateSet( void ) throw( RuntimeException )
 {
 	::osl::MutexGuard						aGuard( m_aMutex );
@@ -384,8 +431,10 @@ Reference< XAccessibleStateSet > SAL_CAL
 
 	if( IsAlive() )
 	{
-		// pStateSetHelper->AddState( AccessibleStateType::ENABLED );
+//IAccessibility2 Implementation 2009-----
+		pStateSetHelper->AddState( AccessibleStateType::ENABLED );
         // pStateSetHelper->AddState( AccessibleStateType::SENSITIVE );
+//-----IAccessibility2 Implementation 2009
 		pStateSetHelper->AddState( AccessibleStateType::FOCUSABLE );
 		if( mpRepr->HasFocus() )
 			pStateSetHelper->AddState( AccessibleStateType::FOCUSED );
@@ -634,8 +683,38 @@ void SvxRectCtlAccessibleContext::checkC
 		// in our case only for the first (0) _selected_ child this is a valid request
 		throw lang::IndexOutOfBoundsException();
 }
-
-void SvxRectCtlAccessibleContext::selectChild( long nNew )
+// IAccessibility2 implementation 2009.  ------
+void SvxRectCtlAccessibleContext::FireChildFocus( RECT_POINT eButton )
+{
+	::osl::MutexGuard	aGuard( m_aMutex );
+	long nNew = PointToIndex( eButton, mbAngleMode );
+	long	nNumOfChilds = getAccessibleChildCount();
+	if( nNew < nNumOfChilds )
+	{
+		// select new child
+		SvxRectCtlChildAccessibleContext*	pChild;
+		mnSelectedChild = nNew;
+		if( nNew != NOCHILDSELECTED )
+		{
+			pChild = mpChilds[ nNew ];
+			if( pChild )
+			{
+				pChild->FireFocusEvent();
+			}
+		}
+		else
+		{
+			const Reference< XInterface >	xSource( *this );
+			Any 							aOld;
+			Any 							aNew;
+			aNew <<= AccessibleStateType::FOCUSED;
+			CommitChange( AccessibleEventObject( xSource, AccessibleEventId::STATE_CHANGED, aNew, aOld ) );
+		}
+	}
+	else
+		mnSelectedChild = NOCHILDSELECTED;
+}
+void SvxRectCtlAccessibleContext::selectChild( long nNew, sal_Bool bFireFocus )
 {
 	::osl::MutexGuard	aGuard( m_aMutex );
 	if( nNew != mnSelectedChild )
@@ -648,7 +727,7 @@ void SvxRectCtlAccessibleContext::select
 			{	// deselect old selected child if one is selected
 				pChild = mpChilds[ mnSelectedChild ];
 				if( pChild )
-					pChild->setStateChecked( sal_False );
+					pChild->setStateChecked( sal_False, bFireFocus );
 			}
 
 			// select new child
@@ -658,7 +737,7 @@ void SvxRectCtlAccessibleContext::select
 			{
 				pChild = mpChilds[ nNew ];
 				if( pChild )
-					pChild->setStateChecked( sal_True );
+					pChild->setStateChecked( sal_True, bFireFocus );
 			}
 		}
 		else
@@ -666,12 +745,12 @@ void SvxRectCtlAccessibleContext::select
 	}
 }
 
-void SvxRectCtlAccessibleContext::selectChild( RECT_POINT eButton )
+void SvxRectCtlAccessibleContext::selectChild( RECT_POINT eButton , sal_Bool bFireFocus)
 {
 	// no guard -> is done in next selectChild
-	selectChild( PointToIndex( eButton, mbAngleMode ) );
+	selectChild( PointToIndex( eButton, mbAngleMode ) , bFireFocus);
 }
-
+// ------ IAccessibility2 implementation 2009.
 void SvxRectCtlAccessibleContext::setName( const ::rtl::OUString& rName )
 {
 	Any						aPreVal, aPostVal;
@@ -976,7 +1055,20 @@ sal_Int16 SAL_CALL SvxRectCtlChildAccess
 */
 Reference<XAccessibleRelationSet> SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleRelationSet( void ) throw( RuntimeException )
 {
-	return Reference< XAccessibleRelationSet >();
+	//return Reference< XAccessibleRelationSet >();
+	//IAccessibility2 Implementation 2009-----
+	utl::AccessibleRelationSetHelper* pRelationSetHelper = new utl::AccessibleRelationSetHelper;
+	uno::Reference< accessibility::XAccessibleRelationSet > xSet = pRelationSetHelper;	
+	if( mxParent.is() )
+      {
+		uno::Sequence< uno::Reference< uno::XInterface > > aSequence(1);
+		aSequence[0] = mxParent;
+		pRelationSetHelper->AddRelation( accessibility::AccessibleRelation( accessibility::AccessibleRelationType::MEMBER_OF, aSequence ) );
+		
+	}
+	
+	return xSet;
+	//-----IAccessibility2 Implementation 2009
 }
 
 Reference< XAccessibleStateSet > SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleStateSet( void ) throw( RuntimeException )
@@ -1085,6 +1177,59 @@ Any SAL_CALL SvxRectCtlChildAccessibleCo
 	return aRet;
 }
 
+//IAccessibility2 Implementation 2009-----
+// -----------------------------------------------------------------------------
+// XAccessibleAction
+// -----------------------------------------------------------------------------
+
+sal_Int32 SvxRectCtlChildAccessibleContext::getAccessibleActionCount( ) throw (RuntimeException)
+{
+	::osl::MutexGuard	aGuard( maMutex );
+
+	return 1;	
+}
+
+// -----------------------------------------------------------------------------
+
+sal_Bool SvxRectCtlChildAccessibleContext::doAccessibleAction ( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException)
+{
+	::osl::MutexGuard	aGuard( maMutex );
+
+	if ( nIndex < 0 || nIndex >= getAccessibleActionCount() )
+        throw IndexOutOfBoundsException();
+
+	Reference<XAccessibleSelection> xSelection( mxParent, UNO_QUERY);
+
+	xSelection->selectAccessibleChild(mnIndexInParent);
+	
+	return sal_True;
+}
+
+// -----------------------------------------------------------------------------
+
+::rtl::OUString SvxRectCtlChildAccessibleContext::getAccessibleActionDescription ( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException)
+{
+	::osl::MutexGuard	aGuard( maMutex );
+
+	if ( nIndex < 0 || nIndex >= getAccessibleActionCount() )
+        throw IndexOutOfBoundsException();
+	return ::rtl::OUString::createFromAscii("select");
+}
+
+// -----------------------------------------------------------------------------
+
+Reference< XAccessibleKeyBinding > SvxRectCtlChildAccessibleContext::getAccessibleActionKeyBinding( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException)
+{
+    ::osl::MutexGuard	aGuard( maMutex );
+
+    if ( nIndex < 0 || nIndex >= getAccessibleActionCount() )
+        throw IndexOutOfBoundsException();
+	
+    return Reference< XAccessibleKeyBinding >();
+}
+
+//-----IAccessibility2 Implementation 2009
+
 //=====  XServiceInfo  ========================================================
 
 ::rtl::OUString SAL_CALL SvxRectCtlChildAccessibleContext::getImplementationName( void ) throw( RuntimeException )
@@ -1181,8 +1326,8 @@ Rectangle SvxRectCtlChildAccessibleConte
 
 	return *mpBoundingBox;
 }
-
-void SvxRectCtlChildAccessibleContext::setStateChecked( sal_Bool bChecked )
+// IAccessibility2 implementation 2009. ------
+void SvxRectCtlChildAccessibleContext::setStateChecked( sal_Bool bChecked, sal_Bool bFireFocus )
 {
 	if( mbIsChecked != bChecked )
 	{
@@ -1193,10 +1338,24 @@ void SvxRectCtlChildAccessibleContext::s
 		Any								aOld;
 		Any								aNew;
 		Any&							rMod = bChecked? aNew : aOld;
-
+		if( bFireFocus )
+		{
+			//Solution: Send the STATE_CHANGED(Focused) event to accessible
+			rMod <<= AccessibleStateType::FOCUSED;
+			CommitChange( AccessibleEventObject( xSource, AccessibleEventId::STATE_CHANGED, aNew, aOld ) );
+		}
 		rMod <<= AccessibleStateType::CHECKED;
 
 		CommitChange( AccessibleEventObject( xSource, AccessibleEventId::STATE_CHANGED, aNew, aOld ) );
 	}
 }
 
+void SvxRectCtlChildAccessibleContext::FireFocusEvent()
+{
+	const Reference< XInterface >	xSource( *this );
+	Any								aOld;
+	Any								aNew;
+	aNew <<= AccessibleStateType::FOCUSED;
+	CommitChange( AccessibleEventObject( xSource, AccessibleEventId::STATE_CHANGED, aNew, aOld ) );
+}
+// ------ IAccessibility2 implementation 2009.

Modified: openoffice/branches/ia2/main/svx/source/customshapes/EnhancedCustomShapeTypeNames.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/ia2/main/svx/source/customshapes/EnhancedCustomShapeTypeNames.cxx?rev=1463840&r1=1463839&r2=1463840&view=diff
==============================================================================
--- openoffice/branches/ia2/main/svx/source/customshapes/EnhancedCustomShapeTypeNames.cxx (original)
+++ openoffice/branches/ia2/main/svx/source/customshapes/EnhancedCustomShapeTypeNames.cxx Wed Apr  3 07:04:20 2013
@@ -316,3 +316,250 @@ rtl::OUString EnhancedCustomShapeTypeNam
 		? rtl::OUString::createFromAscii( pNameTypeTableArray[ eShapeType ].pS )
 		: rtl::OUString();
 }
+//IAccessibility2 Implementation 2009-----
+typedef std::hash_map< const char*, const char*, std::hash<const char*>, TCheck> TypeACCNameHashMap;
+static TypeACCNameHashMap* pACCHashMap = NULL;
+struct ACCNameTypeTable
+{
+	const char*	pS;
+	const char*	pE;
+};
+static const ACCNameTypeTable pACCNameTypeTableArray[] = 
+{
+	{ "non-primitive", "Non Primitive Shape" },
+	{ "rectangle", "Rectangle" },
+	{ "round-rectangle", "Rounded Rectangle" },
+	{ "ellipse", "Ellipse" },
+	{ "diamond", "Diamond" },
+	{ "isosceles-triangle", "Triangle" },
+	{ "right-triangle", "Right Triangle" },
+	{ "parallelogram", "Parallelogram" },
+	{ "trapezoid", "Trapezoid" },
+	{ "hexagon", "Hexagon" },
+	{ "octagon", "Octagon" },
+	{ "cross", "Cross" },
+	{ "star5", "5-Point Star" },
+	{ "right-arrow", "Right Arrow" },
+	//{ "mso-spt14", mso_sptThickArrow },
+	{ "pentagon-right", "Pentagon" },
+	{ "cube", "Cube" },
+	{ "mso-spt21", "Doorplate" },
+	/*{ "mso-spt17", mso_sptBalloon },
+	{ "mso-spt18", mso_sptSeal },
+	{ "mso-spt19", mso_sptArc },
+	{ "mso-spt20", mso_sptLine },
+	{ "mso-spt21", mso_sptPlaque },
+	{ "can", mso_sptCan },*/
+	{ "ring", "Ring" },
+	/*{ "mso-spt24", mso_sptTextSimple },
+	{ "mso-spt25", mso_sptTextOctagon },
+	{ "mso-spt26", mso_sptTextHexagon },
+	{ "mso-spt27", mso_sptTextCurve },
+	{ "mso-spt28", mso_sptTextWave },
+	{ "mso-spt29", mso_sptTextRing },
+	{ "mso-spt30", mso_sptTextOnCurve },
+	{ "mso-spt31", mso_sptTextOnRing },
+	{ "mso-spt32", mso_sptStraightConnector1 },
+	{ "mso-spt33", mso_sptBentConnector2 },
+	{ "mso-spt34", mso_sptBentConnector3 },
+	{ "mso-spt35", mso_sptBentConnector4 },
+	{ "mso-spt36", mso_sptBentConnector5 },
+	{ "mso-spt37", mso_sptCurvedConnector2 },
+	{ "mso-spt38", mso_sptCurvedConnector3 },
+	{ "mso-spt39", mso_sptCurvedConnector4 },
+	{ "mso-spt40", mso_sptCurvedConnector5 },
+	{ "mso-spt41", mso_sptCallout1 },
+	{ "mso-spt42", mso_sptCallout2 },
+	{ "mso-spt43", mso_sptCallout3 },
+	{ "mso-spt44", mso_sptAccentCallout1 },
+	{ "mso-spt45", mso_sptAccentCallout2 },
+	{ "mso-spt46", mso_sptAccentCallout3 },*/
+	{ "line-callout-1", "Line Callout 1" },
+	{ "line-callout-2", "Line Callout 2" },
+	/*{ "mso-spt49", mso_sptBorderCallout3 },
+	{ "mso-spt50", mso_sptAccentBorderCallout1 },
+	{ "mso-spt51", mso_sptAccentBorderCallout2 },
+	{ "mso-spt52", mso_sptAccentBorderCallout3 },
+	{ "mso-spt53", mso_sptRibbon },
+	{ "mso-spt54", mso_sptRibbon2 },*/
+	{ "chevron", "Chevron" },
+	{ "pentagon", "Regular Pentagon" },
+	{ "forbidden", "'No' Symbol" },
+	{ "star8", "8-Point Star" },
+	/*{ "mso-spt59", mso_sptSeal16 },
+	{ "mso-spt60", mso_sptSeal32 },*/
+	{ "rectangular-callout", "Rectangular Callout" },
+	{ "round-rectangular-callout", "Rounded Rectangular Callout" },
+	{ "round-callout", "Round Callout" },
+	//{ "mso-spt64", mso_sptWave },
+	{ "paper", "Folded Corner" },
+	{ "left-arrow", "Left Arrow" },
+	{ "down-arrow", "Down Arrow" },
+	{ "up-arrow", "Up Arrow" },
+	{ "left-right-arrow", "Left and Right Arrow" },
+	{ "up-down-arrow", "Up and Down Arrow" },
+	//{ "mso-spt71", mso_sptIrregularSeal1 },
+	{ "bang", "Explosion" },
+	{ "lightning", "Lighting Bolt" },
+	{ "heart", "Heart" },
+	//{ "mso-spt75", mso_sptPictureFrame },
+	{ "quad-arrow", "4-Way Arrow" },
+	{ "left-arrow-callout", "Left Arrow Callout" },
+	{ "right-arrow-callout", "Right Arrow Callout" },
+	{ "up-arrow-callout", "Up Arrow Callout" },
+	{ "down-arrow-callout", "Down Arrow Callout" },
+	{ "left-right-arrow-callout", "Left and Right Arrow Callout" },
+	{ "up-down-arrow-callout", "Up and Down Arrow Callout" },
+	{ "quad-arrow-callout", "4-Way Arrow Callout" },
+	{ "quad-bevel", "Square Bevel" },
+	{ "left-bracket", "Left Bracket" },
+	{ "right-bracket", "Right Bracket" },
+	{ "left-brace", "Left Brace" },
+	{ "right-brace", "Right Brace" },
+	{ "mso-spt89", "Up and Left Arrow" },
+	//{ "mso-spt90", mso_sptBentUpArrow },
+	//{ "mso-spt91", mso_sptBentArrow },
+	{ "star24", "24-Point Star" },
+	{ "striped-right-arrow", "Striped Right Arrow" },
+	{ "notched-right-arrow", "Notched Right Arrow" },
+	{ "block-arc", "Block Arc" },
+	{ "smiley", "Smile Face" },
+	{ "vertical-scroll", "Vertical Scroll" },
+	{ "horizontal-scroll", "Horizontal Scroll" },
+	{ "circular-arrow", "Circular Arrow" },
+	{ "mso-spt100", "Notched Circular Arrow" },
+	/*
+	{ "mso-spt101", mso_sptUturnArrow },
+	{ "mso-spt102", mso_sptCurvedRightArrow },
+	{ "mso-spt103", mso_sptCurvedLeftArrow },
+	{ "mso-spt104", mso_sptCurvedUpArrow },
+	{ "mso-spt105", mso_sptCurvedDownArrow },*/
+	{ "cloud-callout", "Cloud Callout" },
+	/*{ "mso-spt107", mso_sptEllipseRibbon },
+	{ "mso-spt108", mso_sptEllipseRibbon2 },*/
+	{ "flowchart-process", "Flowchart:Process" },
+	{ "flowchart-decision", "Flowchart:Decision" },
+	{ "flowchart-data", "Flowchart:Data" },
+	{ "flowchart-predefined-process", "Flowchart:Predefined Process" },
+	{ "flowchart-internal-storage", "Flowchart:Internal Storage" },
+	{ "flowchart-document", "Flowchart:Document" },
+	{ "flowchart-multidocument", "Flowchart:Multidocument" },
+	{ "flowchart-terminator", "Flowchart:Terminator" },
+	{ "flowchart-preparation", "Flowchart:Preparation" },
+	{ "flowchart-manual-input", "Flowchart:Manual Input" },
+	{ "flowchart-manual-operation", "Flowchart:Manual Operation" },
+	{ "flowchart-connector", "Flowchart:Connector" },
+	{ "flowchart-card", "Flowchart:Card" },
+	{ "flowchart-punched-tape", "Flowchart:Punched Tape" },
+	{ "flowchart-summing-junction", "Flowchart:Summing Junction" },
+	{ "flowchart-or", "Flowchart:Or" },
+	{ "flowchart-collate", "Flowchart:Collate" },
+	{ "flowchart-sort", "Flowchart:Sort" },
+	{ "flowchart-extract", "Flowchart:Extract" },
+	{ "flowchart-merge", "Flowchart:Merge" },
+	//{ "mso-spt129", mso_sptFlowChartOfflineStorage },
+	{ "flowchart-stored-data", "Flowchart:Stored Data" },
+	{ "flowchart-sequential-access", "drawingbar.fc.25=Flowchart:Sequential Access" },
+	{ "flowchart-magnetic-disk", "Flowchart:Magnetic Disk" },
+	{ "flowchart-direct-access-storage", "Flowchart:Direct Access Storage" },
+	{ "flowchart-display", "Flowchart:Display" },
+	{ "flowchart-delay", "Flowchart:Delay" },
+	/*{ "fontwork-plain-text", mso_sptTextPlainText },
+	{ "fontwork-stop", mso_sptTextStop },
+	{ "fontwork-triangle-up", mso_sptTextTriangle },
+	{ "fontwork-triangle-down", mso_sptTextTriangleInverted },
+	{ "fontwork-chevron-up", mso_sptTextChevron },
+	{ "fontwork-chevron-down", mso_sptTextChevronInverted },
+	{ "mso-spt142", mso_sptTextRingInside },
+	{ "mso-spt143", mso_sptTextRingOutside },
+	{ "fontwork-arch-up-curve", mso_sptTextArchUpCurve },
+	{ "fontwork-arch-down-curve", mso_sptTextArchDownCurve },
+	{ "fontwork-circle-curve", mso_sptTextCircleCurve },
+	{ "fontwork-open-circle-curve", mso_sptTextButtonCurve },
+	{ "fontwork-arch-up-pour", mso_sptTextArchUpPour },
+	{ "fontwork-arch-down-pour", mso_sptTextArchDownPour },
+	{ "fontwork-circle-pour", mso_sptTextCirclePour },
+	{ "fontwork-open-circle-pour", mso_sptTextButtonPour },
+	{ "fontwork-curve-up", mso_sptTextCurveUp },
+	{ "fontwork-curve-down", mso_sptTextCurveDown },
+	{ "fontwork-fade-up-and-right", mso_sptTextCascadeUp },
+	{ "fontwork-fade-up-and-left", mso_sptTextCascadeDown },
+	{ "fontwork-wave", mso_sptTextWave1 },
+	{ "mso-spt157", mso_sptTextWave2 },
+	{ "mso-spt158", mso_sptTextWave3 },
+	{ "mso-spt159", mso_sptTextWave4 },
+	{ "fontwork-inflate", mso_sptTextInflate },
+	{ "mso-spt161", mso_sptTextDeflate },
+	{ "mso-spt162", mso_sptTextInflateBottom },
+	{ "mso-spt163", mso_sptTextDeflateBottom },
+	{ "mso-spt164", mso_sptTextInflateTop },
+	{ "mso-spt165", mso_sptTextDeflateTop },
+	{ "mso-spt166", mso_sptTextDeflateInflate },
+	{ "mso-spt167", mso_sptTextDeflateInflateDeflate },
+	{ "fontwork-fade-right", mso_sptTextFadeRight },
+	{ "fontwork-fade-left", mso_sptTextFadeLeft },
+	{ "fontwork-fade-up", mso_sptTextFadeUp },
+	{ "fontwork-fade-down", mso_sptTextFadeDown },
+	{ "fontwork-slant-up", mso_sptTextSlantUp },
+	{ "fontwork-slant-down", mso_sptTextSlantDown },
+	{ "mso-spt174", mso_sptTextCanUp },
+	{ "mso-spt175", mso_sptTextCanDown },*/
+	{ "flowchart-alternate-process", "Flowchart:Alternate Process " },
+	{ "flowchart-off-page-connector", "Flowchart:Off-page Connector" },
+	/*{ "mso-spt178", mso_sptCallout90 },
+	{ "mso-spt179", mso_sptAccentCallout90 },
+	{ "mso-spt180", mso_sptBorderCallout90 },*/
+	{ "line-callout-3", "Line Callout 3" },
+	//{ "mso-spt182", mso_sptLeftRightUpArrow },
+	{ "sun", "Sun" },
+	{ "moon", "Moon" },
+	{ "bracket-pair", "Double Bracket" },
+	{ "brace-pair", "Double Brace" },
+	{ "star4", "4-Point Star" },
+	/*{ "mso-spt188", mso_sptDoubleWave },
+	{ "mso-spt189", mso_sptActionButtonBlank },
+	{ "mso-spt190", mso_sptActionButtonHome },
+	{ "mso-spt191", mso_sptActionButtonHelp },
+	{ "mso-spt192", mso_sptActionButtonInformation },
+	{ "mso-spt193", mso_sptActionButtonForwardNext },
+	{ "mso-spt194", mso_sptActionButtonBackPrevious },
+	{ "mso-spt195", mso_sptActionButtonEnd },
+	{ "mso-spt196", mso_sptActionButtonBeginning },
+	{ "mso-spt197", mso_sptActionButtonReturn },
+	{ "mso-spt198", mso_sptActionButtonDocument },
+	{ "mso-spt199", mso_sptActionButtonSound },
+	{ "mso-spt200", mso_sptActionButtonMovie },
+	{ "mso-spt201", mso_sptHostControl },
+	{ "mso-spt202", mso_sptTextBox },*/
+	{ "frame", "Frame" },
+	{ "col-60da8460", "Octagon Bevel" },
+	{ "col-502ad400", "Diamond Bevel" }
+};
+rtl::OUString EnhancedCustomShapeTypeNames::GetAccName( const rtl::OUString& rShapeType )
+{
+	if ( !pACCHashMap )
+	{	// init hash map
+		::osl::MutexGuard aGuard( getHashMapMutex() );
+		if ( !pACCHashMap )
+		{
+			TypeACCNameHashMap* pH = new TypeACCNameHashMap;
+			const ACCNameTypeTable* pPtr = pACCNameTypeTableArray;
+			const ACCNameTypeTable* pEnd = pPtr + ( sizeof( pACCNameTypeTableArray ) / sizeof( ACCNameTypeTable ) );
+			for ( ; pPtr < pEnd; pPtr++ )
+				(*pH)[ pPtr->pS ] = pPtr->pE;
+			pACCHashMap = pH;
+		}
+	}
+	rtl::OUString sRetValue;
+	int i, nLen = rShapeType.getLength();
+	char* pBuf = new char[ nLen + 1 ];
+	for ( i = 0; i < nLen; i++ )
+		pBuf[ i ] = (char)rShapeType[ i ];
+	pBuf[ i ] = 0;
+	TypeACCNameHashMap::iterator aHashIter( pACCHashMap->find( pBuf ) );
+	delete[] pBuf;
+	if ( aHashIter != pACCHashMap->end() )
+		sRetValue = rtl::OUString::createFromAscii( (*aHashIter).second );
+	return sRetValue;
+}
+//-----IAccessibility2 Implementation 2009

Modified: openoffice/branches/ia2/main/svx/source/dialog/_bmpmask.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/ia2/main/svx/source/dialog/_bmpmask.cxx?rev=1463840&r1=1463839&r2=1463840&view=diff
==============================================================================
--- openoffice/branches/ia2/main/svx/source/dialog/_bmpmask.cxx (original)
+++ openoffice/branches/ia2/main/svx/source/dialog/_bmpmask.cxx Wed Apr  3 07:04:20 2013
@@ -137,6 +137,9 @@ void MaskSet::Select()
 
 void MaskSet::GetFocus()
 {
+	//IAccessibility2 Implementation 2009-----
+	ValueSet::GetFocus();
+	//-----IAccessibility2 Implementation 2009
 	SelectItem( 1 );
 	pSvxBmpMask->onSelect( this );
 }
@@ -327,10 +330,13 @@ IMPL_LINK( MaskData, CbxTransHdl, CheckB
 
 IMPL_LINK( MaskData, FocusLbHdl, ColorLB*, pLb )
 {
-	pMask->pQSet1->SelectItem( pLb == &( pMask->aLbColor1 ) ? 1 : 0 );
-	pMask->pQSet2->SelectItem( pLb == &( pMask->aLbColor2 ) ? 1 : 0 );
-	pMask->pQSet3->SelectItem( pLb == &( pMask->aLbColor3 ) ? 1 : 0 );
-	pMask->pQSet4->SelectItem( pLb == &( pMask->aLbColor4 ) ? 1 : 0 );
+	//IAccessibility2 Implementation 2009-----
+	// MT: bFireFox as API parameter is ugly, find better solution????
+	pMask->pQSet1->SelectItem( pLb == &( pMask->aLbColor1 ) ? 1 : 0 /* , false */ );
+	pMask->pQSet2->SelectItem( pLb == &( pMask->aLbColor2 ) ? 1 : 0 /* , false */ );
+	pMask->pQSet3->SelectItem( pLb == &( pMask->aLbColor3 ) ? 1 : 0 /* , false */ );
+	pMask->pQSet4->SelectItem( pLb == &( pMask->aLbColor4 ) ? 1 : 0 /* , false */ );
+	//-----IAccessibility2 Implementation 2009
 
 	return 0;
 }
@@ -477,35 +483,57 @@ SvxBmpMask::SvxBmpMask( SfxBindings *pBi
 	pQSet1->SetColCount( 1 );
 	pQSet1->SetLineCount( 1 );
 //	pQSet1->SetExtraSpacing( 1 );
-	pQSet1->InsertItem( 1, aPipetteColor );
+	//-----IAccessibility2 Implementation 2009
+	String sColorPalette (BMP_RESID( RID_SVXDLG_BMPMASK_STR_PALETTE));
+    String sColorPaletteN;
+    sColorPaletteN = sColorPalette;
+    sColorPaletteN.AppendAscii (RTL_CONSTASCII_STRINGPARAM (" 1"));
+	//pQSet1->InsertItem( 1, aPipetteColor );
+	pQSet1->InsertItem( 1, aPipetteColor, sColorPaletteN);
+	//IAccessibility2 Implementation 2009-----
 	pQSet1->SelectItem( 1 );
 
 	pQSet2->SetStyle( pQSet2->GetStyle() | WB_DOUBLEBORDER | WB_ITEMBORDER );
 	pQSet2->SetColCount( 1 );
 	pQSet2->SetLineCount( 1 );
 //	pQSet2->SetExtraSpacing( 1 );
-	pQSet2->InsertItem( 1, aPipetteColor );
+	//IAccessibility2 Implementation 2009-----
+	sColorPaletteN = sColorPalette;
+    sColorPaletteN.AppendAscii (RTL_CONSTASCII_STRINGPARAM (" 2"));
+	//pQSet2->InsertItem( 1, aPipetteColor );
+	pQSet2->InsertItem( 1, aPipetteColor, sColorPaletteN);
+	//-----IAccessibility2 Implementation 2009
 	pQSet2->SelectItem( 0 );
 
 	pQSet3->SetStyle( pQSet3->GetStyle() | WB_DOUBLEBORDER | WB_ITEMBORDER );
 	pQSet3->SetColCount( 1 );
 	pQSet3->SetLineCount( 1 );
 //	pQSet3->SetExtraSpacing( 1 );
-	pQSet3->InsertItem( 1, aPipetteColor );
+	//IAccessibility2 Implementation 2009-----
+	sColorPaletteN = sColorPalette;
+ 	sColorPaletteN.AppendAscii (RTL_CONSTASCII_STRINGPARAM (" 3"));
+	pQSet3->InsertItem( 1, aPipetteColor, sColorPaletteN);
+	//pQSet3->InsertItem( 1, aPipetteColor );
+	//-----IAccessibility2 Implementation 2009
 	pQSet3->SelectItem( 0 );
 
 	pQSet4->SetStyle( pQSet4->GetStyle() | WB_DOUBLEBORDER | WB_ITEMBORDER );
 	pQSet4->SetColCount( 1 );
 	pQSet4->SetLineCount( 1 );
 //	pQSet4->SetExtraSpacing( 1 );
-	pQSet4->InsertItem( 1, aPipetteColor );
+	//IAccessibility2 Implementation 2009-----
+	sColorPaletteN = sColorPalette;
+    sColorPaletteN.AppendAscii (RTL_CONSTASCII_STRINGPARAM (" 4"));
+	pQSet4->InsertItem( 1, aPipetteColor, sColorPaletteN);
+	//pQSet4->InsertItem( 1, aPipetteColor );
+	//-----IAccessibility2 Implementation 2009
 	pQSet4->SelectItem( 0 );
 
 	pQSet1->Show();
 	pQSet2->Show();
 	pQSet3->Show();
 	pQSet4->Show();
-
+	//IAccessibility2 Implementation 2009-----
 	aCbx1.SetAccessibleRelationMemberOf( &aGrpQ );
 	pQSet1->SetAccessibleRelationMemberOf( &aGrpQ );
 	aSp1.SetAccessibleRelationMemberOf( &aGrpQ );
@@ -541,6 +569,7 @@ SvxBmpMask::SvxBmpMask( SfxBindings *pBi
 	aLbColorTrans.SetAccessibleRelationLabeledBy( &aCbxTrans );
 	aLbColorTrans.SetAccessibleRelationMemberOf( &aGrpQ );
 	aCbxTrans.SetAccessibleRelationMemberOf( &aGrpQ );
+	//-----IAccessibility2 Implementation 2009
 }
 
 //-------------------------------------------------------------------------
@@ -1271,4 +1300,51 @@ void SvxBmpMask::SetAccessibleNames (voi
     sSourceColorN = sSourceColor;
     sSourceColorN.AppendAscii (RTL_CONSTASCII_STRINGPARAM (" 4"));
     aCbx4.SetAccessibleName (sSourceColorN);
+	//IAccessibility2 Implementation 2009-----
+	// set the accessible name for valueset
+	String sColorPalette (BMP_RESID( RID_SVXDLG_BMPMASK_STR_PALETTE));
+    String sColorPaletteN;
+    sColorPaletteN = sColorPalette;
+    sColorPaletteN.AppendAscii (RTL_CONSTASCII_STRINGPARAM (" 1"));
+    pQSet1->SetText (sColorPaletteN);
+    sColorPaletteN = sColorPalette;
+    sColorPaletteN.AppendAscii (RTL_CONSTASCII_STRINGPARAM (" 2"));
+    pQSet2->SetText (sColorPaletteN);
+    sColorPaletteN = sColorPalette;
+    sColorPaletteN.AppendAscii (RTL_CONSTASCII_STRINGPARAM (" 3"));
+    pQSet3->SetText (sColorPaletteN);
+    sColorPaletteN = sColorPalette;
+    sColorPaletteN.AppendAscii (RTL_CONSTASCII_STRINGPARAM (" 4"));
+    pQSet4->SetText (sColorPaletteN);
+    // set the accessible for replace with spin boxes.
+	String sTolerance(BMP_RESID( RID_SVXDLG_BMPMASK_STR_TOLERANCE));
+    String sToleranceN;
+    sToleranceN = sTolerance;
+    sToleranceN.AppendAscii (RTL_CONSTASCII_STRINGPARAM (" 1"));
+    aSp1.SetAccessibleName (sToleranceN);
+    sToleranceN = sTolerance;
+    sToleranceN.AppendAscii (RTL_CONSTASCII_STRINGPARAM (" 2"));
+    aSp2.SetAccessibleName (sToleranceN);
+    sToleranceN = sTolerance;
+    sToleranceN.AppendAscii (RTL_CONSTASCII_STRINGPARAM (" 3"));
+    aSp3.SetAccessibleName (sToleranceN);
+    sToleranceN = sTolerance;
+    sToleranceN.AppendAscii (RTL_CONSTASCII_STRINGPARAM (" 4"));
+    aSp4.SetAccessibleName (sToleranceN);
+    // set the accessible for replace with combo boxes.
+   	String sReplaceWith(BMP_RESID( RID_SVXDLG_BMPMASK_STR_REPLACEWITH));
+    String sReplaceWithN;
+    sReplaceWithN = sReplaceWith;
+    sReplaceWithN.AppendAscii (RTL_CONSTASCII_STRINGPARAM (" 1"));
+    aLbColor1.SetAccessibleName (sReplaceWithN);
+    sReplaceWithN = sReplaceWith;
+    sReplaceWithN.AppendAscii (RTL_CONSTASCII_STRINGPARAM (" 2"));
+    aLbColor2.SetAccessibleName (sReplaceWithN);
+    sReplaceWithN = sReplaceWith;
+    sReplaceWithN.AppendAscii (RTL_CONSTASCII_STRINGPARAM (" 3"));
+    aLbColor3.SetAccessibleName (sReplaceWithN);
+    sReplaceWithN = sReplaceWith;
+    sReplaceWithN.AppendAscii (RTL_CONSTASCII_STRINGPARAM (" 4"));
+    aLbColor4.SetAccessibleName (sReplaceWithN); 
+	//-----IAccessibility2 Implementation 2009
 }

Modified: openoffice/branches/ia2/main/svx/source/dialog/charmap.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/ia2/main/svx/source/dialog/charmap.cxx?rev=1463840&r1=1463839&r2=1463840&view=diff
==============================================================================
--- openoffice/branches/ia2/main/svx/source/dialog/charmap.cxx (original)
+++ openoffice/branches/ia2/main/svx/source/dialog/charmap.cxx Wed Apr  3 07:04:20 2013
@@ -136,7 +136,8 @@ void SvxShowCharSet::MouseButtonDown( co
             CaptureMouse();
 
             int nIndex = PixelToMapIndex( rMEvt.GetPosPixel() );
-            SelectIndex( nIndex );
+	    // Fire the focus event
+            SelectIndex( nIndex , sal_True);
         }
 
         if ( !(rMEvt.GetClicks() % 2) )
@@ -177,7 +178,8 @@ void SvxShowCharSet::MouseMove( const Mo
             aPos.Y() = aSize.Height()-5;
 
         int nIndex = PixelToMapIndex( aPos );
-        SelectIndex( nIndex );
+	// Fire the focus event. 
+        SelectIndex( nIndex , sal_True );
     }
 }
 
@@ -585,12 +587,18 @@ void SvxShowCharSet::SelectIndex( int nN
 		if( m_pAccessible )
 		{
 			::svx::SvxShowCharSetItem* pItem = ImplGetItem(nSelectedIndex);
-			m_pAccessible->fireEvent( AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, Any(), makeAny(pItem->GetAccessible()) ); // this call asures that m_pItem is set
+			// Don't fire the focus event. 
+			if ( bFocus )
+				m_pAccessible->fireEvent( AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, Any(), makeAny(pItem->GetAccessible()) ); // this call asures that m_pItem is set
+			else
+				m_pAccessible->fireEvent( AccessibleEventId::ACTIVE_DESCENDANT_CHANGED_NOFOCUS, Any(), makeAny(pItem->GetAccessible()) ); // this call asures that m_pItem is set
 
 			OSL_ENSURE(pItem->m_pItem,"No accessible created!");
 			Any aOldAny, aNewAny;
 			aNewAny <<= AccessibleStateType::FOCUSED;
-			pItem->m_pItem->fireEvent( AccessibleEventId::STATE_CHANGED, aOldAny, aNewAny );
+			// Don't fire the focus event. 
+			if ( bFocus )
+				pItem->m_pItem->fireEvent( AccessibleEventId::STATE_CHANGED, aOldAny, aNewAny );
 
 			aNewAny <<= AccessibleStateType::SELECTED;
 			pItem->m_pItem->fireEvent( AccessibleEventId::STATE_CHANGED, aOldAny, aNewAny );

Modified: openoffice/branches/ia2/main/svx/source/dialog/ctredlin.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/ia2/main/svx/source/dialog/ctredlin.cxx?rev=1463840&r1=1463839&r2=1463840&view=diff
==============================================================================
--- openoffice/branches/ia2/main/svx/source/dialog/ctredlin.cxx (original)
+++ openoffice/branches/ia2/main/svx/source/dialog/ctredlin.cxx Wed Apr  3 07:04:20 2013
@@ -1345,6 +1345,29 @@ void SvxTPFilter::Disable( bool bChild)
 	Enable( false, bChild );
 }
 
+//IAccessibility2 Implementation 2009-----
+void SvxTPFilter::SetAccessibleRelationMemberOf( Window* pWin )
+{
+	aCbDate.SetAccessibleRelationMemberOf(pWin);
+	aLbDate.SetAccessibleRelationMemberOf(pWin);
+	aDfDate.SetAccessibleRelationMemberOf(pWin);
+	aTfDate.SetAccessibleRelationMemberOf(pWin);
+	aIbClock.SetAccessibleRelationMemberOf(pWin);
+	aFtDate2.SetAccessibleRelationMemberOf(pWin);
+	aDfDate2.SetAccessibleRelationMemberOf(pWin);
+	aTfDate2.SetAccessibleRelationMemberOf(pWin);
+	aIbClock2.SetAccessibleRelationMemberOf(pWin);
+	aCbAuthor.SetAccessibleRelationMemberOf(pWin);
+	aLbAuthor.SetAccessibleRelationMemberOf(pWin);
+	aCbRange.SetAccessibleRelationMemberOf(pWin);
+	aEdRange.SetAccessibleRelationMemberOf(pWin);
+	aBtnRange.SetAccessibleRelationMemberOf(pWin);
+	aLbAction.SetAccessibleRelationMemberOf(pWin);
+	aCbComment.SetAccessibleRelationMemberOf(pWin);
+	aEdComment.SetAccessibleRelationMemberOf(pWin);
+}
+//-----IAccessibility2 Implementation 2009
+
 IMPL_LINK( SvxTPFilter, ModifyDate, void*,pTF)
 {
 

Modified: openoffice/branches/ia2/main/svx/source/dialog/ctredlin.src
URL: http://svn.apache.org/viewvc/openoffice/branches/ia2/main/svx/source/dialog/ctredlin.src?rev=1463840&r1=1463839&r2=1463840&view=diff
==============================================================================
--- openoffice/branches/ia2/main/svx/source/dialog/ctredlin.src (original)
+++ openoffice/branches/ia2/main/svx/source/dialog/ctredlin.src Wed Apr  3 07:04:20 2013
@@ -277,6 +277,10 @@ TabPage SID_REDLIN_FILTER_PAGE
 	{
 		Text [ en-US ] = "End Time" ;
 	};
+	String STR_TREE
+	{
+		Text [ en-US ] = "Changes" ;
+	};
 	/*-----IAccessibility2 Implementation 2009*/
 };
 TabPage SID_REDLIN_VIEW_PAGE
@@ -354,10 +358,6 @@ TabPage SID_REDLIN_VIEW_PAGE
 	{
 		Text [ en-US ] = "Comment" ;
 	};
-	String STR_TREE
-	{
-		Text [ en-US ] = "Changes" ;
-	};
 };
 
 

Modified: openoffice/branches/ia2/main/svx/source/dialog/dlgctrl.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/ia2/main/svx/source/dialog/dlgctrl.cxx?rev=1463840&r1=1463839&r2=1463840&view=diff
==============================================================================
--- openoffice/branches/ia2/main/svx/source/dialog/dlgctrl.cxx (original)
+++ openoffice/branches/ia2/main/svx/source/dialog/dlgctrl.cxx Wed Apr  3 07:04:20 2013
@@ -37,6 +37,18 @@
 #include <vcl/region.hxx>
 #include <vcl/gradient.hxx>
 #include <vcl/hatch.hxx>
+// IAccessibility2 implementation 2009. ------
+#ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLEEVENTOBJECT_HPP_
+#include <com/sun/star/accessibility/AccessibleEventObject.hpp>
+#endif
+#ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLEEVENTID_HPP_
+#include <com/sun/star/accessibility/AccessibleEventId.hpp>
+#endif
+#ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLESTATETYPE_HPP_
+#include <com/sun/star/accessibility/AccessibleStateType.hpp>
+#endif
+#include "svxpixelctlaccessiblecontext.hxx"
+// ------ IAccessibility2 implementation 2009.
 #include <svtools/colorcfg.hxx>
 #include <svxrectctaccessiblecontext.hxx>
 #include <com/sun/star/lang/XUnoTunnel.hpp>
@@ -564,6 +576,15 @@ Point SvxRectCtl::SetActualRPWithoutInva
 void SvxRectCtl::GetFocus()
 {
 	SetFocusRect();
+	// IAccessibility2 implementation 2009. ------
+	//Solution: Send the accessible focused event
+	Control::GetFocus();
+	// Send accessibility event.
+	if(pAccContext)
+	{
+		pAccContext->FireChildFocus(GetActualRP());		
+	}
+	// ------ IAccessibility2 implementation 2009.
 }
 
 
@@ -657,9 +678,10 @@ RECT_POINT SvxRectCtl::GetActualRP() con
 |*	Gibt den aktuell ausgewaehlten RECT_POINT zur�ck
 |*
 \************************************************************************/
-
-void SvxRectCtl::SetActualRP( RECT_POINT eNewRP )
+// IAccessibility2 implementation 2009. ------
+void SvxRectCtl::SetActualRP( RECT_POINT eNewRP /* MT: , sal_Bool bFireFocus */ )
 {
+	// MT: bFireFox as API parameter is ugly...
 	Point aPtLast( SetActualRPWithoutInvalidate( eNewRP ) );
 
 	Invalidate( Rectangle( aPtLast - Point( nRadius, nRadius ), aPtLast + Point( nRadius, nRadius ) ) );
@@ -667,9 +689,9 @@ void SvxRectCtl::SetActualRP( RECT_POINT
 
 	// notify accessibility object about change
 	if( pAccContext )
-		pAccContext->selectChild( eNewRP );
+		pAccContext->selectChild( eNewRP /* MT, bFireFocus */ );
 }
-
+// ------ IAccessibility2 implementation 2009.
 void SvxRectCtl::SetState( CTL_STATE nState )
 {
 	m_nState = nState;
@@ -864,11 +886,74 @@ void SvxAngleCtl::Paint( const Rectangle
 |*	Control zum Editieren von Bitmaps
 |*
 \************************************************************************/
+// IAccessibility2 implementation 2009. ------
+
+::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > SvxPixelCtl::CreateAccessible()
+{
+    if(!m_xAccess.is())
+	{
+		m_xAccess = m_pAccess =  new SvxPixelCtlAccessible(*this);	
+	}	
+    return m_xAccess;
+}
+
+//Logic Pixel
+long SvxPixelCtl::PointToIndex(const Point &aPt) const 
+{
+	sal_uInt16	nX, nY;
+
+	nX = (sal_uInt16) ( aPt.X() * nLines / aRectSize.Width() );
+	nY = (sal_uInt16) ( aPt.Y() * nLines / aRectSize.Height() );
+
+	return nX + nY * nLines ;
+}
+Point SvxPixelCtl::IndexToPoint(long nIndex) const 
+{
+	DBG_ASSERT(nIndex >= 0 && nIndex < nSquares ," Check Index");
+
+	sal_uInt16 nXIndex = nIndex % nLines ;
+	sal_uInt16 nYIndex = sal_uInt16(nIndex / nLines) ;
+	
+	Point aPtTl;
+	aPtTl.Y() = aRectSize.Height() * nYIndex / nLines + 1;
+	aPtTl.X() = aRectSize.Width() * nXIndex / nLines + 1;
+
+	return aPtTl;
+}
+long SvxPixelCtl::GetFoucsPosIndex() const 
+{
+	return aFocusPosition.getX() + aFocusPosition.getY() * nLines ;
+}
+long SvxPixelCtl::ShowPosition( const Point &pt)
+{
+	Point aPt = PixelToLogic( pt );
+	
+	sal_uInt16	nX, nY;
+	nX = (sal_uInt16) ( aPt.X() * nLines / aRectSize.Width() );
+	nY = (sal_uInt16) ( aPt.Y() * nLines / aRectSize.Height() );
+
+	ChangePixel( nX + nY * nLines );
+
+	//Solution:Set new focus position and repaint
+	//Invalidate( Rectangle( aPtTl, aPtBr ) );
+	aFocusPosition.setX(nX);
+	aFocusPosition.setY(nY);
+	Invalidate(Rectangle(Point(0,0),aRectSize));
+
+	if( WINDOW_TABPAGE == GetParent()->GetType() )
+		( (SvxTabPage*) GetParent() )->PointChanged( this, RP_MM ); // RectPoint ist dummy
+
+	return GetFoucsPosIndex();
 
+}
+// ------ IAccessibility2 implementation 2009.
 SvxPixelCtl::SvxPixelCtl( Window* pParent, const ResId& rResId, sal_uInt16 nNumber ) :
 						Control		( pParent, rResId ),
 						nLines		( nNumber ),
 						bPaintable	( sal_True )
+						// IAccessibility2 implementation 2009. ------
+						//Solution:Initialize it's value to Point(0,0)
+						,aFocusPosition(0,0)
 {
 	// SetMapMode( MAP_100TH_MM );
 	aRectSize = GetOutputSize();
@@ -880,6 +965,8 @@ SvxPixelCtl::SvxPixelCtl( Window* pParen
 	nSquares = nLines * nLines;
 	pPixel = new sal_uInt16[ nSquares ];
 	rtl_zeroMemory(pPixel, nSquares * sizeof(sal_uInt16));
+	// IAccessibility2 implementation 2009. ------
+	m_pAccess=NULL;
 }
 
 /*************************************************************************
@@ -915,24 +1002,37 @@ void SvxPixelCtl::ChangePixel( sal_uInt1
 
 void SvxPixelCtl::MouseButtonDown( const MouseEvent& rMEvt )
 {
-	Point aPt = PixelToLogic( rMEvt.GetPosPixel() );
-	Point aPtTl, aPtBr;
-	sal_uInt16	nX, nY;
+	// IAccessibility2 implementation 2009. ------
+	//Point aPt = PixelToLogic( rMEvt.GetPosPixel() );
+	//Point aPtTl, aPtBr;
+	//sal_uInt16	nX, nY;
 
-	nX = (sal_uInt16) ( aPt.X() * nLines / aRectSize.Width() );
-	nY = (sal_uInt16) ( aPt.Y() * nLines / aRectSize.Height() );
+	//nX = (sal_uInt16) ( aPt.X() * nLines / aRectSize.Width() );
+	//nY = (sal_uInt16) ( aPt.Y() * nLines / aRectSize.Height() );
 
-	ChangePixel( nX + nY * nLines );
+	//ChangePixel( nX + nY * nLines );
 
-	aPtTl.X() = aRectSize.Width() * nX / nLines + 1;
-	aPtBr.X() = aRectSize.Width() * (nX + 1) / nLines - 1;
-	aPtTl.Y() = aRectSize.Height() * nY / nLines + 1;
-	aPtBr.Y() = aRectSize.Height() * (nY + 1) / nLines - 1;
+	//aPtTl.X() = aRectSize.Width() * nX / nLines + 1;
+	//aPtBr.X() = aRectSize.Width() * (nX + 1) / nLines - 1;
+	//aPtTl.Y() = aRectSize.Height() * nY / nLines + 1;
+	//aPtBr.Y() = aRectSize.Height() * (nY + 1) / nLines - 1;
 
-	Invalidate( Rectangle( aPtTl, aPtBr ) );
+	//Invalidate( Rectangle( aPtTl, aPtBr ) );
 
-	if( WINDOW_TABPAGE == GetParent()->GetType() )
-		( (SvxTabPage*) GetParent() )->PointChanged( this, RP_MM ); // RectPoint ist dummy
+	//if( WINDOW_TABPAGE == GetParent()->GetType() )
+	//	( (SvxTabPage*) GetParent() )->PointChanged( this, RP_MM ); // RectPoint ist dummy
+	//Solution:Grab focus when click in window
+	if( !HasFocus() )
+	{		
+		GrabFocus();
+	}
+	long nIndex = ShowPosition(rMEvt.GetPosPixel());
+
+	if(m_pAccess)
+	{
+		m_pAccess->NotifyChild(nIndex,sal_True,sal_True);
+	}
+	// ------ IAccessibility2 implementation 2009.
 }
 
 /*************************************************************************
@@ -983,6 +1083,13 @@ void SvxPixelCtl::Paint( const Rectangle
 				DrawRect( Rectangle( aPtTl, aPtBr ) );
 			}
 		}
+		// IAccessibility2 implementation 2009. ------
+		//Solution:Draw visual focus when has focus
+		if( HasFocus() )
+		{
+			ShowFocus(implCalFocusRect(aFocusPosition));	
+		}
+		// ------ IAccessibility2 implementation 2009.
 	} // bPaintable
 	else
 	{
@@ -992,6 +1099,130 @@ void SvxPixelCtl::Paint( const Rectangle
 		DrawLine( Point( 0, aRectSize.Height() ), Point( aRectSize.Width(), 0 ) );
 	}
 }
+// IAccessibility2 implementation 2009. ------
+//Solution:Caculate visual focus rectangle via focus position
+Rectangle SvxPixelCtl::implCalFocusRect( const Point& aPosition )
+{
+	long nLeft,nTop,nRight,nBottom;
+	long i,j;
+	i = aPosition.Y();
+	j = aPosition.X();
+	nLeft = aRectSize.Width() * j / nLines + 1;
+	nRight = aRectSize.Width() * (j + 1) / nLines - 1;
+	nTop = aRectSize.Height() * i / nLines + 1;
+	nBottom = aRectSize.Height() * (i + 1) / nLines - 1;
+	return Rectangle(nLeft,nTop,nRight,nBottom);
+}
+
+//Solution:Keyboard fucntion
+void SvxPixelCtl::KeyInput( const KeyEvent& rKEvt )
+{
+	KeyCode aKeyCode = rKEvt.GetKeyCode();
+	sal_uInt16 nCode = aKeyCode.GetCode();
+	sal_Bool bIsMod = aKeyCode.IsShift() || aKeyCode.IsMod1() || aKeyCode.IsMod2();
+						
+	if( !bIsMod )
+	{
+		Point pRepaintPoint( aRectSize.Width() *( aFocusPosition.getX() - 1)/ nLines - 1,
+		                     aRectSize.Height() *( aFocusPosition.getY() - 1)/ nLines -1
+		                    );
+		Size  mRepaintSize( aRectSize.Width() *3/ nLines + 2,aRectSize.Height() *3/ nLines + 2);
+		Rectangle mRepaintRect( pRepaintPoint, mRepaintSize );			
+		sal_Bool bFocusPosChanged=sal_False;
+		switch(nCode)
+		{
+			case KEY_LEFT:
+				if((aFocusPosition.getX() >= 1))
+				{
+					aFocusPosition.setX( aFocusPosition.getX() - 1 );
+					Invalidate(mRepaintRect);
+					bFocusPosChanged=sal_True;
+				}
+				break;
+			case KEY_RIGHT:
+				if( aFocusPosition.getX() < (nLines - 1) )
+				{
+					aFocusPosition.setX( aFocusPosition.getX() + 1 );
+					Invalidate(mRepaintRect);
+					bFocusPosChanged=sal_True;
+				}
+				break;					
+			case KEY_UP:
+				if((aFocusPosition.getY() >= 1))
+				{
+					aFocusPosition.setY( aFocusPosition.getY() - 1 );
+					Invalidate(mRepaintRect);
+					bFocusPosChanged=sal_True;
+				}
+				break;
+			case KEY_DOWN:
+				if( aFocusPosition.getY() < ( nLines - 1 ) )
+				{
+					aFocusPosition.setY( aFocusPosition.getY() + 1 );
+					Invalidate(mRepaintRect);
+					bFocusPosChanged=sal_True;
+				}
+				break;
+			case KEY_SPACE:
+				ChangePixel( sal_uInt16(aFocusPosition.getX() + aFocusPosition.getY() * nLines) );
+				Invalidate( implCalFocusRect(aFocusPosition) );
+				break;
+			default:
+				Control::KeyInput( rKEvt );		
+				return;
+		}
+		if(m_xAccess.is())
+		{
+			long nIndex = GetFoucsPosIndex();
+			switch(nCode)
+			{
+			case KEY_LEFT:
+			case KEY_RIGHT:
+			case KEY_UP:
+			case KEY_DOWN:
+				if (bFocusPosChanged)
+				{
+					m_pAccess->NotifyChild(nIndex,sal_False,sal_False);
+				}				
+				break;
+			case KEY_SPACE:
+				m_pAccess->NotifyChild(nIndex,sal_False,sal_True);
+				break;
+			default:
+				break;
+			}
+		}
+	}
+	else
+	{
+		Control::KeyInput( rKEvt );
+	}
+}
+
+//Draw focus when get focus
+void SvxPixelCtl::GetFocus()
+{
+	Invalidate(implCalFocusRect(aFocusPosition));
+	
+	if(m_pAccess)
+	{
+		m_pAccess->NotifyChild(GetFoucsPosIndex(),sal_True,sal_False);
+	}
+
+	Control::GetFocus();
+}
+
+//Hide focus when lose focus
+void SvxPixelCtl::LoseFocus()
+{
+	HideFocus();
+	if (m_pAccess)
+	{
+		m_pAccess->LoseFocus();
+	}
+	Control::LoseFocus();
+}
+// ------ IAccessibility2 implementation 2009.
 
 /*************************************************************************
 |*



Mime
View raw message