openoffice-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From j...@apache.org
Subject svn commit: r1546358 [8/9] - in /openoffice/branches/capstone2013/main: vcl/inc/win/ winaccessibility/source/UAccCOM/ winaccessibility/source/UAccCOMIDL/ winaccessibility/source/service/
Date Thu, 28 Nov 2013 12:54:23 GMT
Added: openoffice/branches/capstone2013/main/winaccessibility/source/service/AccObject.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/capstone2013/main/winaccessibility/source/service/AccObject.cxx?rev=1546358&view=auto
==============================================================================
--- openoffice/branches/capstone2013/main/winaccessibility/source/service/AccObject.cxx (added)
+++ openoffice/branches/capstone2013/main/winaccessibility/source/service/AccObject.cxx Thu Nov 28 12:54:21 2013
@@ -0,0 +1,1109 @@
+/**************************************************************
+ * 
+ * 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.
+ * 
+ *************************************************************/
+
+#include <com/sun/star/uno/Sequence.h>
+#include <com/sun/star/accessibility/AccessibleStateType.hpp>
+#include <com/sun/star/accessibility/AccessibleRole.hpp>
+#include <com/sun/star/accessibility/XAccessibleValue.hpp>
+#include <com/sun/star/accessibility/XAccessibleComponent.hpp>
+#include <com/sun/star/accessibility/XAccessibleText.hpp>
+
+#include <stdlib.h>
+#include <memory.h>
+#include <stdio.h>
+#include <memory.h>
+#include <algorithm>
+#include <assert.h>
+
+#include "AccObject.hxx"
+#include "AccEventListener.hxx"
+#include "UAccCOM_i.c"
+#include "AccResource.hxx"
+
+#include "act.hxx"
+
+using namespace std;
+using namespace com::sun::star::uno;
+using namespace com::sun::star::accessibility;
+using namespace com::sun::star::accessibility::AccessibleRole;
+using namespace com::sun::star::accessibility::AccessibleStateType;
+
+
+/**
+   * Constructor.
+   * @param pXAcc Uno XAccessible interface of control.
+   * @param Agent The agent kept in all listeners,it's the sole interface by which
+   *              listener communicate with windows manager.
+   * @param listener listener that registers in UNO system.
+   * @return.
+   */
+AccObject::AccObject(XAccessible* pAcc,AccObjectManagerAgent* pAgent ,AccEventListener* listener) :
+        m_pIMAcc	(NULL),
+        m_resID		(NULL),
+        m_pParantID	(NULL),
+        m_pParentObj(NULL),
+        m_accListener (listener),
+        m_bShouldDestroy(sal_False),
+        m_xAccRef( pAcc )
+{
+    sal_Bool bRet = ImplInitilizeCreateObj();
+
+    m_xAccContextRef = m_xAccRef->getAccessibleContext();
+    m_xAccActionRef = Reference< XAccessibleAction > (m_xAccContextRef,UNO_QUERY);
+    m_accRole = m_xAccContextRef -> getAccessibleRole();
+    if( m_pIMAcc )
+    {
+        m_pIMAcc->SetXAccessible((long) m_xAccRef.get());
+        m_pIMAcc->Put_XAccAgent((long)pAgent);
+        m_pIMAcc->SetDefaultAction((long)m_xAccActionRef.get());
+    }
+}
+/**
+   * Destructor.
+   * @param
+   * @return
+   */
+AccObject::~AccObject()
+{
+    m_pIMAcc = NULL;
+    m_xAccRef = NULL;
+    m_xAccActionRef = NULL;
+    m_xAccContextRef = NULL;
+}
+
+
+
+/**
+   * Insert a child element.
+   * @param pChild Child element that should be inserted into child list.
+   * @param pos Insert postion.
+   * @return
+   */
+void AccObject::InsertChild( AccObject* pChild,short pos )
+{
+
+    std::vector<AccObject*>::iterator iter;
+    iter = std::find(m_childrenList.begin(),m_childrenList.end(),pChild);
+    if(iter!=m_childrenList.end())
+        return;
+    if(LAST_CHILD==pos)
+    {
+        m_childrenList.push_back(pChild);
+    }
+    else
+    {
+        std::vector<AccObject*>::iterator iter=m_childrenList.begin()+pos;
+        m_childrenList.insert(iter,pChild);
+    }
+
+    pChild->SetParentObj(this);
+}
+
+/**
+   * Delete a child element
+   * @param pChild Child element that should be inserted into child list.
+   * @param pos Insert postion.
+   * @return
+   */
+void AccObject::DeleteChild( AccObject* pChild )
+{
+    std::vector<AccObject*>::iterator iter;
+    iter = std::find(m_childrenList.begin(),m_childrenList.end(),pChild);
+    if(iter!=m_childrenList.end())
+    {
+        m_childrenList.erase(iter);
+        if(m_pIMAcc)
+            pChild->SetParentObj(NULL);
+    }
+}
+
+/**
+   * In order to windows API WindowFromAccessibleObject,we sometimes to set a pure
+   * top window accessible object created by windows system as top ancestor.
+   * @param.
+   * @return
+   */
+void AccObject::UpdateValidWindow()
+{
+    if(m_pIMAcc)
+        m_pIMAcc->Put_XAccWindowHandle(m_pParantID);
+}
+
+/**
+   * Translate all UNO basic information into MSAA com information.
+   * @param
+   * @return If the method is correctly processed.
+   */
+sal_Bool AccObject::ImplInitilizeCreateObj()
+{
+	ActivateActContext();
+	HRESULT hr = CoCreateInstance( CLSID_MAccessible, NULL, CLSCTX_ALL ,
+                                   IID_IMAccessible,
+                                   (void **)&m_pIMAcc);
+	DeactivateActContext();
+
+    if ( S_OK != hr )
+    {
+        return sal_False;
+    }
+
+    return sal_True;
+}
+
+/**
+   * Update name property to com object.
+   * @param
+   * @return
+   */
+void  AccObject::UpdateName( )
+{
+    if (!m_pIMAcc)
+    {
+        return;
+    }
+
+    if( ( TEXT_FRAME == m_accRole   ) && ( m_pParentObj !=NULL )&& ( SCROLL_PANE == m_pParentObj -> m_accRole ) )
+        m_pIMAcc->Put_XAccName( m_pParentObj->m_xAccContextRef->getAccessibleName().getStr() );
+	//IAccessibility2 Implementation 2009-----
+    if ( PARAGRAPH == m_accRole)
+    {
+    	::rtl::OUString emptyStr = ::rtl::OUString::createFromAscii("");
+    	m_pIMAcc->Put_XAccName(emptyStr.getStr());
+    }
+	//-----IAccessibility2 Implementation 2009
+    else
+        m_pIMAcc->Put_XAccName(m_xAccContextRef->getAccessibleName().getStr());
+
+    return ;
+}
+/**
+   * Update description property to com object.
+   * no content for update description
+   * @param
+   * @return
+   */
+void AccObject::UpdateDescription()
+{
+    if (!m_pIMAcc)
+    {
+        return;
+    }
+
+    m_pIMAcc->Put_XAccDescription(m_xAccContextRef->getAccessibleDescription().getStr());
+    return ;
+}
+
+/**
+   * Update default action property to com object.
+   * @param
+   * @return
+   */
+void  AccObject::UpdateAction()
+{
+    m_xAccActionRef = Reference< XAccessibleAction > (m_xAccContextRef,UNO_QUERY);
+
+    if( m_xAccActionRef.is() && m_pIMAcc )
+    {
+        if( m_xAccActionRef->getAccessibleActionCount() > 0 )
+        {
+            UpdateDefaultAction( );
+            m_pIMAcc->SetDefaultAction((long)m_xAccActionRef.get());
+        }
+    }
+}
+
+/**
+   * Update value property to com object.
+   * @param
+   * @return
+   */
+void AccObject::UpdateValue()
+{
+    if( NULL == m_pIMAcc  || !m_xAccContextRef.is() )
+    {
+        assert(false);
+        return ;
+    }
+
+    Reference< XAccessibleValue > pRValue(m_xAccContextRef.get(),UNO_QUERY);
+    Any pAny;
+    if( pRValue.is() )
+    {
+        pAny = pRValue->getCurrentValue();
+    }
+
+    SetValue( pAny );
+}
+
+/**
+   * Set special default action description string via UNO role.
+   * @param Role UNO role
+   * @return
+   */
+void AccObject::UpdateDefaultAction( )
+{
+    if(!m_xAccActionRef.is())
+        return ;
+
+    switch(m_accRole)
+    {
+    case PUSH_BUTTON:
+    case TOGGLE_BUTTON:
+    case RADIO_BUTTON:
+    case MENU_ITEM:
+    case RADIO_MENU_ITEM:
+    case CHECK_MENU_ITEM:
+    case LIST_ITEM:
+    case CHECK_BOX:
+    case TREE_ITEM:
+    case BUTTON_DROPDOWN:
+        m_pIMAcc->Put_ActionDescription( m_xAccActionRef->getAccessibleActionDescription((sal_Int32)0).getStr() );
+        return;
+    }
+}
+
+/**
+   * Set value property via pAny.
+   * @param pAny New value.
+   * @return
+   */
+void  AccObject::SetValue( Any pAny )
+{
+    unsigned short pUNumberString[100];
+    memset( pUNumberString, 0 , sizeof( pUNumberString) );
+
+    if( NULL == m_pIMAcc || !m_xAccContextRef.is() )
+    {
+        assert(false);
+        return ;
+    }
+    Reference< XAccessibleText > pRText(m_xAccContextRef,UNO_QUERY);
+    ::rtl::OUString val;
+    int index = 0 ;
+    switch(m_accRole)
+    {
+    case SPIN_BOX:
+        // 3. date editor's msaa value should be the same as spinbox
+    case DATE_EDITOR:
+    case TEXT:
+    case PARAGRAPH:
+    case HEADING:
+
+        if(pRText.get())
+        {
+            val = pRText->getText();
+        }
+        m_pIMAcc->Put_XAccValue( val.getStr() );
+        break;
+    case TREE_ITEM:
+	//IAccessibility2 Implementation 2009-----
+    //case CHECK_BOX:	//Commented by Li Xing to disable the value for general checkbox
+    case COMBO_BOX:
+    case TABLE_CELL:
+    case NOTE:
+    case SCROLL_BAR:
+        m_pIMAcc->Put_XAccValue( GetMAccessibleValueFromAny(pAny).getStr() );
+        break ;
+	// Added by Li Xing, only the checkbox in tree should have the value. 
+	case CHECK_BOX:
+		if( ( m_pParentObj !=NULL ) && (TREE == m_pParentObj->m_accRole || TREE_ITEM == m_pParentObj->m_accRole ))
+	        m_pIMAcc->Put_XAccValue( GetMAccessibleValueFromAny(pAny).getStr() );
+	//-----IAccessibility2 Implementation 2009
+		break;
+    default:
+        break;
+    }
+
+    return;
+
+
+}
+::rtl::OUString AccObject::GetMAccessibleValueFromAny(Any pAny)
+{
+    ::rtl::OUString strValue;
+
+    if(NULL == m_pIMAcc)
+        return strValue;
+
+    if(pAny.getValueType() == getCppuType( (sal_uInt16 *)0 ) )
+    {
+        sal_uInt16 val;
+        if (pAny >>= val)
+        {
+            strValue=::rtl::OUString::valueOf((sal_Int32)val);
+
+        }
+    }
+    else if(pAny.getValueType() == getCppuType( (::rtl::OUString *)0 ) )
+    {
+
+        pAny >>= strValue ;
+
+    }
+    else if(pAny.getValueType() == getCppuType( (Sequence< ::rtl::OUString > *)0 ) )
+    {
+        Sequence< ::rtl::OUString > val;
+        if (pAny >>= val)
+        {
+
+            int count = val.getLength();
+
+            for( int iIndex = 0;iIndex < count;iIndex++ )
+            {
+                strValue += val[iIndex];
+            }
+
+        }
+    }
+    else if(pAny.getValueType() == getCppuType( (double *)0 ) )
+    {
+        double val;
+        if (pAny >>= val)
+        {
+            strValue=::rtl::OUString::valueOf(val);
+        }
+    }
+    else if(pAny.getValueType() == getCppuType( (sal_Int32 *)0 ) )
+    {
+        sal_Int32 val;
+        if (pAny >>= val)
+        {
+            strValue=::rtl::OUString::valueOf(val);
+        }
+    }
+    else if (pAny.getValueType() == getCppuType( (com::sun::star::accessibility::TextSegment *)0 ) )
+    {
+        com::sun::star::accessibility::TextSegment val;
+        if (pAny >>= val)
+        {
+            ::rtl::OUString realVal(val.SegmentText);
+            strValue = realVal;
+
+        }
+    }
+
+    return strValue;
+}
+/**
+   * Set name property via pAny.
+   * @param pAny New accessible name.
+   * @return
+   */
+void  AccObject::SetName( Any pAny)
+{
+    if( NULL == m_pIMAcc )
+        return ;
+
+    m_pIMAcc->Put_XAccName( GetMAccessibleValueFromAny(pAny).getStr() );
+
+}
+
+/**
+   * Set description property via pAny.
+   * @param pAny New accessible description.
+   * @return
+   */
+void  AccObject::SetDescription( Any pAny )
+{
+    if( NULL == m_pIMAcc )
+        return ;
+    m_pIMAcc->Put_XAccDescription( GetMAccessibleValueFromAny(pAny).getStr() );
+}
+
+/**
+   * Set role property via pAny
+   * @param Role New accessible role.
+   * @return
+   */
+void  AccObject::SetRole( short Role )
+{
+    if( NULL == m_pIMAcc )
+        return ;
+    m_pIMAcc->Put_XAccRole( Role );
+}
+
+/**
+* Get role property via pAny
+* @param
+* @return accessible role
+*/
+short AccObject::GetRole() const
+{
+    return m_accRole;
+}
+
+/**
+   * Get MSAA state from UNO state
+   * @Role xState UNO state.
+   * @return
+   */
+DWORD AccObject::GetMSAAStateFromUNO(short xState)
+{
+    DWORD IState = UNO_MSAA_UNMAPPING;
+
+    if( !m_xAccContextRef.is() )
+    {
+        assert(false);
+        return IState;
+    }
+    short Role = m_accRole;
+
+    switch( xState )
+    {
+    case  BUSY:
+        IState = STATE_SYSTEM_BUSY;
+        break;
+    case  CHECKED:
+        if( Role == PUSH_BUTTON || Role == TOGGLE_BUTTON )
+        {
+            IState = STATE_SYSTEM_PRESSED;
+        }
+        else
+            IState = STATE_SYSTEM_CHECKED;
+        break;
+    case  DEFUNC:
+        IState = STATE_SYSTEM_UNAVAILABLE;
+        break;
+    case  EXPANDED:
+        IState = STATE_SYSTEM_EXPANDED;
+        break;
+    case  FOCUSABLE:
+        IState = STATE_SYSTEM_FOCUSABLE;
+        break;
+    case  FOCUSED:
+        IState = STATE_SYSTEM_FOCUSED;
+        break;
+    case  INDETERMINATE:
+        IState = STATE_SYSTEM_MIXED;
+        break;
+    case  MULTI_SELECTABLE:
+        IState = STATE_SYSTEM_MULTISELECTABLE;
+        break;
+    case  PRESSED:
+        IState = STATE_SYSTEM_PRESSED;
+        break;
+    case  RESIZABLE:
+        IState = STATE_SYSTEM_SIZEABLE;
+        break;
+    case  SELECTABLE:
+        if( m_accRole == MENU || m_accRole == MENU_ITEM)
+        {
+            IState = UNO_MSAA_UNMAPPING;
+        }
+        else
+        {
+            IState = STATE_SYSTEM_SELECTABLE;
+        }
+        break;
+    case  SELECTED:
+        if( m_accRole == MENU || m_accRole == MENU_ITEM )
+        {
+            IState = UNO_MSAA_UNMAPPING;
+        }
+        else
+        {
+            IState = STATE_SYSTEM_SELECTED;
+        }
+        break;
+    case  ARMED:
+        IState = STATE_SYSTEM_FOCUSED;
+        break;
+    case  EXPANDABLE:
+        {
+            sal_Bool isExpanded = sal_True;
+            sal_Bool isExpandable = sal_True;
+            if( Role == PUSH_BUTTON || Role == TOGGLE_BUTTON  || BUTTON_DROPDOWN == Role )
+            {
+                IState = STATE_SYSTEM_HASPOPUP;
+            }
+            else
+            {
+                GetExpandedState(&isExpandable,&isExpanded);
+                if(!isExpanded)
+                    IState = STATE_SYSTEM_COLLAPSED;
+            }
+        }
+        break;
+	//Remove the SENSITIVE state mapping. There is no corresponding MSAA state. 
+    //case  SENSITIVE:
+    //    IState = STATE_SYSTEM_PROTECTED;
+    case EDITABLE:
+        if( m_pIMAcc )
+        {
+            m_pIMAcc->DecreaseState( STATE_SYSTEM_READONLY );
+        }
+        break;
+    case OFFSCREEN:
+        IState = STATE_SYSTEM_OFFSCREEN;
+        break;
+    case MOVEABLE:
+        IState = STATE_SYSTEM_MOVEABLE;
+        break;
+    case COLLAPSE:
+        IState = STATE_SYSTEM_COLLAPSED;
+        break;
+    case DEFAULT:
+        IState = STATE_SYSTEM_DEFAULT;
+        break;
+    default:
+        break;
+    }
+
+    return IState;
+}
+
+/**
+   * Decrease state of com object
+   * @param xState The lost state.
+   * @return
+   */
+void  AccObject::DecreaseState( short xState )
+{
+    if( NULL == m_pIMAcc )
+    {
+        return;
+    }
+
+    if( xState == FOCUSABLE)
+    {
+        short Role = m_accRole ;
+        if(Role == MENU_ITEM
+                || Role == RADIO_MENU_ITEM
+                || Role == CHECK_MENU_ITEM)
+            return;
+        else
+        {
+            if (Role == TOGGLE_BUTTON || Role == PUSH_BUTTON || BUTTON_DROPDOWN == Role)
+            {
+                if( ( m_pParentObj !=NULL ) && (TOOL_BAR == m_pParentObj->m_accRole ) )
+                    return;
+            }
+        }
+    }
+
+    else if( xState == AccessibleStateType::VISIBLE  )
+    {
+        m_pIMAcc->IncreaseState( STATE_SYSTEM_INVISIBLE );
+    }
+    else if( xState == AccessibleStateType::SHOWING )
+    {
+        m_pIMAcc->IncreaseState( STATE_SYSTEM_OFFSCREEN );
+    }
+
+    DWORD msState = GetMSAAStateFromUNO(xState);
+    if(msState!=UNO_MSAA_UNMAPPING)
+        m_pIMAcc->DecreaseState(msState);
+}
+
+/**
+   * Increase state of com object
+   * @param xState The new state.
+   * @return
+   */
+void AccObject::IncreaseState( short xState )
+{
+    if( NULL == m_pIMAcc )
+    {
+        assert(false);
+        return;
+    }
+
+
+    if( xState == AccessibleStateType::VISIBLE  )
+    {
+        m_pIMAcc->DecreaseState( STATE_SYSTEM_INVISIBLE );
+    }
+    else if( xState == AccessibleStateType::SHOWING )
+    {
+        m_pIMAcc->DecreaseState( STATE_SYSTEM_OFFSCREEN );
+    }
+
+
+    DWORD msState = GetMSAAStateFromUNO(xState);
+    if(msState!=UNO_MSAA_UNMAPPING)
+        m_pIMAcc->IncreaseState( msState );
+}
+
+/**
+   * Get next child element
+   * @param
+   * @return AccObject Object interface.
+   */
+AccObject* AccObject::NextChild()
+{
+    IAccChildList::iterator pInd = m_childrenList.begin();
+    if( pInd != m_childrenList.end() )
+        return 	*pInd;
+    return NULL;
+}
+/**
+   * update action desciption desc
+   * @param
+   * @return 
+   */
+void AccObject::UpdateActionDesc()
+{
+    if (!m_pIMAcc)
+    {
+        return;
+    }
+
+    ::rtl::OUString	pXString = m_xAccContextRef->getAccessibleDescription();
+    m_pIMAcc->Put_XAccDescription(pXString.getStr());
+    long Role = m_accRole;
+
+    if(  Role == PUSH_BUTTON || Role == RADIO_BUTTON || Role == MENU_ITEM ||
+            Role == LIST_ITEM || Role == CHECK_BOX || Role == TREE_ITEM ||
+            Role == CHECK_MENU_ITEM || Role == RADIO_MENU_ITEM )
+    {
+        UpdateDefaultAction(  );
+    }
+    else
+    {
+
+        if( m_xAccActionRef.is() )
+        {
+            if( m_xAccActionRef->getAccessibleActionCount() > 0 )
+            {
+				if (!(Role == SPIN_BOX || Role == COMBO_BOX || Role == DATE_EDITOR ||
+					  Role == EDIT_BAR || Role == PASSWORD_TEXT || Role == TEXT))
+				{
+					pXString = m_xAccActionRef->getAccessibleActionDescription( 0 );
+					//Solution:If string length is more than zero,action will will be set.
+					if( pXString.getLength() > 0)
+						m_pIMAcc->Put_ActionDescription( pXString.getStr() );
+				}                
+            }
+        }
+    }
+
+}
+/**
+   * update role information from uno to com
+   * @param
+   * @return 
+   */
+void AccObject::UpdateRole()
+{
+    if (!m_pIMAcc)
+    {
+        return;
+    }
+
+    XAccessibleContext* pContext  = m_xAccContextRef.get();
+    m_pIMAcc->Put_XAccRole( ROLE_SYSTEM_WINDOW  );
+    short iRoleIndex = pContext->getAccessibleRole();
+    if (( 0 <= iRoleIndex) && ( iRoleIndex <= (sizeof(ROLE_TABLE)/(sizeof(short)*2))))
+    {
+        short iIA2Role = ROLE_TABLE[iRoleIndex][1] ;
+        m_pIMAcc->Put_XAccRole( iIA2Role  );
+    }
+
+}
+/**
+   * update state information from uno to com
+   * @param
+   * @return 
+   */
+void AccObject::UpdateState()
+{
+    if (!m_pIMAcc)
+    {
+        return;
+    }
+
+    XAccessibleContext* pContext  = m_xAccContextRef.get();
+    Reference< XAccessibleStateSet > pRState = pContext->getAccessibleStateSet();
+    if( !pRState.is() )
+    {
+        assert(false);
+        return ;
+    }
+
+    m_pIMAcc->SetState(0L);
+
+    if ( m_accRole == POPUP_MENU )
+    {
+        return;
+    }
+
+    Sequence<short> pStates = pRState->getStates();
+    int count = pStates.getLength();
+
+    sal_Bool isEnable = sal_False;
+    sal_Bool isShowing = sal_False;
+    sal_Bool isEditable = sal_False;
+    sal_Bool isVisible = sal_False;
+    sal_Bool isFocusable = sal_False;
+
+    for( int iIndex = 0;iIndex < count;iIndex++ )
+    {
+        if( pStates[iIndex] == ENABLED )
+            isEnable = sal_True;
+        else if( pStates[iIndex] == SHOWING)
+            isShowing = sal_True;
+        else if( pStates[iIndex] == VISIBLE)
+            isVisible = sal_True;
+        else if( pStates[iIndex] == EDITABLE )
+            isEditable = sal_True;
+        else if (pStates[iIndex] == FOCUSABLE)
+            isFocusable = sal_True;
+        IncreaseState( pStates[iIndex]);
+    }
+    sal_Bool bIsMenuItem = m_accRole == MENU_ITEM || m_accRole == RADIO_MENU_ITEM || m_accRole == CHECK_MENU_ITEM;
+
+    if(bIsMenuItem)
+    {
+        if(!(isShowing && isVisible) )
+        {
+            m_pIMAcc->IncreaseState( STATE_SYSTEM_INVISIBLE );
+            m_pIMAcc->DecreaseState( STATE_SYSTEM_FOCUSABLE );
+        }
+    }
+    else
+    {
+        if(!(isShowing || isVisible) )
+            m_pIMAcc->IncreaseState( STATE_SYSTEM_INVISIBLE );
+    }
+
+    short Role = m_accRole;
+
+    if( m_pIMAcc )
+    {
+        switch(m_accRole)
+        {
+        case LABEL:
+            m_pIMAcc->IncreaseState( STATE_SYSTEM_READONLY );
+            break;
+        case TEXT:
+            // 2. editable combobox -> readonly ------ bridge
+        case EMBEDDED_OBJECT:
+        case END_NOTE:
+        case FOOTER:
+        case FOOTNOTE:
+        case GRAPHIC:
+        case HEADER:
+        case HEADING:
+
+            //Image Map
+        case PARAGRAPH:
+        case PASSWORD_TEXT:
+        case SHAPE:
+        case SPIN_BOX:
+        case TABLE:
+        case TABLE_CELL:
+        case TEXT_FRAME:
+        case DATE_EDITOR:
+        case DOCUMENT:
+        case COLUMN_HEADER:
+            {
+                if(!isEditable)
+                    m_pIMAcc->IncreaseState( STATE_SYSTEM_READONLY );
+            }
+            break;
+        default:
+            break;
+        }
+    }
+
+    if( isEnable )
+    {
+
+        if(!(Role == FILLER || Role == END_NOTE || Role == FOOTER || Role == FOOTNOTE || Role == GROUP_BOX || Role == RULER
+                || Role == HEADER || Role == ICON || Role == INTERNAL_FRAME || Role == LABEL || Role == LAYERED_PANE
+                || Role == SCROLL_BAR || Role == SCROLL_PANE || Role == SPLIT_PANE || Role == STATUS_BAR || Role == TOOL_TIP))
+        {
+            if( SEPARATOR == Role  )
+            {
+                if( ( m_pParentObj != NULL ) && ( MENU == m_pParentObj->m_accRole  || POPUP_MENU == m_pParentObj->m_accRole ))
+                    IncreaseState( FOCUSABLE );
+            }
+
+            else if (TABLE_CELL == Role || TABLE == Role || PANEL == Role || OPTION_PANE == Role ||
+                     COLUMN_HEADER == Role)
+            {
+                if (isFocusable)
+                    IncreaseState( FOCUSABLE );
+            }
+            else
+            {
+                if(bIsMenuItem)
+                {
+                    if ( isShowing && isVisible)
+                    {
+                        IncreaseState( FOCUSABLE );
+                    }
+                }
+                else
+                {
+                    IncreaseState( FOCUSABLE );
+                }
+            }
+        }
+    }
+    else
+    {
+        m_pIMAcc->IncreaseState( STATE_SYSTEM_UNAVAILABLE );
+        sal_Bool isDecreaseFocusable = sal_False;
+        if( !((Role == MENU_ITEM) ||
+                (Role == RADIO_MENU_ITEM) ||
+                (Role == CHECK_MENU_ITEM)) )
+        {
+            if  ( Role == TOGGLE_BUTTON || Role == PUSH_BUTTON || BUTTON_DROPDOWN == Role)
+            {
+                if(( m_pParentObj != NULL )&& (TOOL_BAR ==  m_pParentObj->m_accRole ) )
+                    IncreaseState( FOCUSABLE );
+                else
+                    DecreaseState( FOCUSABLE );
+            }
+            else
+                DecreaseState( FOCUSABLE );
+        }
+        else if( isShowing || isVisible )
+        {
+            IncreaseState( FOCUSABLE );
+        }
+    }
+
+    if( m_pIMAcc )
+    {
+        switch(m_accRole)
+        {
+        case POPUP_MENU:
+        case MENU:
+            if( pContext->getAccessibleChildCount() > 0 )
+                m_pIMAcc->IncreaseState( STATE_SYSTEM_HASPOPUP );
+            break;
+        case PASSWORD_TEXT:
+            m_pIMAcc->IncreaseState( STATE_SYSTEM_PROTECTED );
+            break;
+        default:
+            break;
+        }
+    }
+
+}
+/**
+   * update location information from uno to com
+   * @param
+   * @return 
+   */
+void AccObject::UpdateLocation()
+{
+    if (!m_pIMAcc)
+    {
+        return;
+    }
+    XAccessibleContext* pContext  = m_xAccContextRef.get();
+
+    Reference< XAccessibleComponent > pRComponent(pContext,UNO_QUERY);
+    if( pRComponent.is() )
+    {
+        ::com::sun::star::awt::Point pCPoint = pRComponent->getLocationOnScreen();
+        ::com::sun::star::awt::Size pCSize = pRComponent->getSize();
+        Location tempLocation;
+        tempLocation.m_dLeft = pCPoint.X;
+        tempLocation.m_dTop =  pCPoint.Y;
+        tempLocation.m_dWidth = pCSize.Width;
+        tempLocation.m_dHeight = pCSize.Height;
+        m_pIMAcc->Put_XAccLocation( tempLocation );
+    }
+
+}
+
+
+/**
+   * Public method to mapping information between MSAA and UNO.
+   * @param
+   * @return If the method is correctly processed.
+   */
+sal_Bool AccObject:: UpdateAccessibleInfoFromUnoToMSAA ( )
+{
+    if( NULL == m_pIMAcc || !m_xAccContextRef.is()  )
+    {
+        assert(false);
+        return sal_False;
+    }
+
+    UpdateName();
+
+    UpdateValue();
+
+    UpdateActionDesc();
+
+    UpdateRole();
+
+    UpdateLocation();
+
+    UpdateState();
+
+    return sal_True;
+}
+
+/*
+   * Add a child selected element.
+   * @param pAccObj Child object pointer.
+   * @return
+   */
+void AccObject::AddSelect( long index, AccObject* accObj)
+{
+    m_selectionList.insert(IAccSelectionList::value_type(index,accObj));
+}
+
+IAccSelectionList& AccObject::GetSelection()
+{
+    return m_selectionList;
+}
+
+
+/**
+   * Set self to focus object in parant child list
+   * @param
+   * @return
+   */
+void AccObject::setFocus()
+{
+    if(m_pIMAcc)
+    {
+        IncreaseState(FOCUSED);
+        m_pIMAcc->Put_XAccFocus(CHILDID_SELF);
+
+        UpdateRole();
+    }
+}
+
+/**
+   * Unset self from focus object in parant child list.
+   * @param
+   * @return
+   */
+void AccObject::unsetFocus()
+{
+    if(m_pIMAcc)
+    {
+        DecreaseState( FOCUSED );
+        m_pIMAcc->Put_XAccFocus(UACC_NO_FOCUS);
+    }
+}
+
+void AccObject::GetExpandedState( sal_Bool* isExpandable, sal_Bool* isExpanded)
+{
+    *isExpanded = sal_False;
+    *isExpandable = sal_False;
+
+    if( !m_xAccContextRef.is() )
+    {
+        return;
+    }
+    Reference< XAccessibleStateSet > pRState = m_xAccContextRef->getAccessibleStateSet();
+    if( !pRState.is() )
+    {
+        return;
+    }
+
+    Sequence<short> pStates = pRState->getStates();
+    int count = pStates.getLength();
+
+    for( int iIndex = 0;iIndex < count;iIndex++ )
+    {
+        if( EXPANDED == pStates[iIndex]  )
+        {
+            *isExpanded = sal_True;
+        }
+        else if( EXPANDABLE == pStates[iIndex]  )
+        {
+            *isExpandable = sal_True;
+        }
+    }
+}
+
+void AccObject::NotifyDestroy(sal_Bool ifDelete)
+{
+    m_bShouldDestroy=ifDelete;
+    if(m_pIMAcc)
+        m_pIMAcc->NotifyDestroy(m_bShouldDestroy);
+}
+
+void AccObject::SetParentObj(AccObject* pParentAccObj)
+{
+    m_pParentObj = pParentAccObj;
+
+    if(m_pIMAcc)
+    {
+        if(m_pParentObj)
+        {
+            m_pIMAcc->Put_XAccParent(m_pParentObj->GetIMAccessible());
+        }
+        else
+        {
+            m_pIMAcc->Put_XAccParent(NULL);
+        }
+    }
+}
+//ResID means ChildID in MSAA
+void AccObject::SetResID(long id)
+{
+    m_resID = id;
+    if(m_pIMAcc)
+        m_pIMAcc->Put_XAccChildID(m_resID);
+}
+//return COM interface in acc object
+IMAccessible*  AccObject::GetIMAccessible()
+{
+    return m_pIMAcc;
+}
+
+Reference < XAccessible > AccObject::GetXAccessible()
+{
+    return m_xAccRef;
+}
+
+void AccObject::SetParentHWND(HWND hWnd)
+{
+    m_pParantID = hWnd;
+}
+void AccObject::SetListener( AccEventListener* Listener )
+{
+    m_accListener = Listener;
+}
+AccEventListener* AccObject::getListener()
+{
+    return m_accListener;
+}
+
+long AccObject::GetResID()
+{
+    return m_resID;
+}
+
+HWND AccObject::GetParentHWND()
+{
+    return m_pParantID;
+}
+
+AccObject* AccObject::GetParentObj()
+{
+    return m_pParentObj;
+}
+sal_Bool  AccObject::ifShouldDestroy()
+{
+    return m_bShouldDestroy;
+}

Propchange: openoffice/branches/capstone2013/main/winaccessibility/source/service/AccObject.cxx
------------------------------------------------------------------------------
    svn:executable = *

Added: openoffice/branches/capstone2013/main/winaccessibility/source/service/AccObjectContainerEventListener.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/capstone2013/main/winaccessibility/source/service/AccObjectContainerEventListener.cxx?rev=1546358&view=auto
==============================================================================
--- openoffice/branches/capstone2013/main/winaccessibility/source/service/AccObjectContainerEventListener.cxx (added)
+++ openoffice/branches/capstone2013/main/winaccessibility/source/service/AccObjectContainerEventListener.cxx Thu Nov 28 12:54:21 2013
@@ -0,0 +1,72 @@
+/**************************************************************
+ * 
+ * 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.
+ * 
+ *************************************************************/
+
+// AccObjectContainerEventListener.cpp: implementation of the AccContainerEventListener class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#include <com/sun/star/accessibility/XAccessible.hpp>
+#include <com/sun/star/accessibility/AccessibleStateType.hpp>
+#include <com/sun/star/accessibility/AccessibleEventId.hpp>
+#include <com/sun/star/accessibility/AccessibleRole.hpp>
+#include <com/sun/star/accessibility/XAccessibleEventBroadcaster.hpp>
+
+#include "AccObjectContainerEventListener.hxx"
+#include "AccObjectManagerAgent.hxx"
+#include "unomsaaevent.hxx"
+
+using namespace com::sun::star::uno;
+using namespace com::sun::star::accessibility;
+
+AccObjectContainerEventListener::AccObjectContainerEventListener(com::sun::star::accessibility::XAccessible* pAcc, AccObjectManagerAgent* Agent)
+        :AccContainerEventListener(pAcc, Agent)
+{}
+AccObjectContainerEventListener::~AccObjectContainerEventListener()
+{
+}
+
+/**
+ *	handle the STATE_CHANGED event
+ */
+void AccObjectContainerEventListener::handleStateChangedEvent(Any oldValue, Any newValue)
+{
+    //set the accessible name before process for there is no NAME_CHANGED event when change
+    //the text in drawing objects.
+    short newV;
+    if( newValue >>= newV)
+    {
+        if (newV == AccessibleStateType::FOCUSED)
+        {
+            pAgent->UpdateAccName(pAccessible);
+
+            pAgent->UpdateDescription(pAccessible);
+        }
+    }
+    AccContainerEventListener::handleStateChangedEvent(oldValue, newValue);
+}
+/**
+ *	handle the VISIBLE_DATA_CHANGED event
+ *  For SHAPES, the visiable_data_changed event should be mapped to LOCATION_CHANGED event
+  */
+void AccObjectContainerEventListener::handleVisibleDataChangedEvent()
+{
+    AccContainerEventListener::handleBoundrectChangedEvent();
+}

Propchange: openoffice/branches/capstone2013/main/winaccessibility/source/service/AccObjectContainerEventListener.cxx
------------------------------------------------------------------------------
    svn:executable = *

Added: openoffice/branches/capstone2013/main/winaccessibility/source/service/AccObjectManagerAgent.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/capstone2013/main/winaccessibility/source/service/AccObjectManagerAgent.cxx?rev=1546358&view=auto
==============================================================================
--- openoffice/branches/capstone2013/main/winaccessibility/source/service/AccObjectManagerAgent.cxx (added)
+++ openoffice/branches/capstone2013/main/winaccessibility/source/service/AccObjectManagerAgent.cxx Thu Nov 28 12:54:21 2013
@@ -0,0 +1,386 @@
+/**************************************************************
+ * 
+ * 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.
+ * 
+ *************************************************************/
+
+#include "AccObjectManagerAgent.hxx"
+#include "AccObjectWinManager.hxx"
+
+#include "UAccCOM2.h"
+
+using namespace com::sun::star::uno;
+using namespace com::sun::star::accessibility;
+
+/**
+   * Construction/Destruction.
+   * @param 
+   * @return
+   */
+AccObjectManagerAgent::AccObjectManagerAgent():
+        pWinManager(NULL)
+{
+    if( pWinManager == NULL )
+    {
+        pWinManager = AccObjectWinManager::CreateAccObjectWinManagerInstance(this);
+    }
+}
+
+AccObjectManagerAgent::~AccObjectManagerAgent()
+{
+    delete pWinManager;
+    pWinManager = NULL;
+}
+
+/**
+   * Interface of updating MSAA name when UNO name_changed event occurs.
+   * @param pXAcc Uno XAccessible interface of control.
+   * @return
+   */
+void  AccObjectManagerAgent::UpdateAccName( XAccessible* pXAcc )
+{
+    if( pWinManager )
+        pWinManager->UpdateAccName( pXAcc );
+}
+
+/**
+   * Interface of updating MSAA name when UNO action changed event occurs.
+   * @param pXAcc Uno XAccessible interface of control.
+   * @return
+   */
+void  AccObjectManagerAgent::UpdateAction( XAccessible* pXAcc )
+{
+    if( pWinManager )
+        pWinManager->UpdateAction( pXAcc );
+}
+
+/**
+   * Interface of updating MSAA value when UNO value_changed event occurs.
+   * @param pXAcc Uno XAccessible interface of control.
+   * @param pAny New value.
+   * @return
+   */
+void  AccObjectManagerAgent::UpdateValue( XAccessible* pXAcc, Any pAny )
+{
+    if( pWinManager )
+        pWinManager->SetValue( pXAcc, pAny );
+}
+
+/**
+   * Interface of updating MSAA value when UNO value_changed event occurs.If we can not
+   * find new value,we'll get new value from pXAcc to update com value.
+   * @param pXAcc Uno XAccessible interface of control.
+   * @return
+   */
+void  AccObjectManagerAgent::UpdateValue( XAccessible* pXAcc )
+{
+    if( pWinManager )
+        pWinManager->UpdateValue( pXAcc );
+}
+
+/**
+   * Interface of updating MSAA name when UNO name_changed event occurs.
+   * @param pXAcc Uno XAccessible interface of control.
+   * @param newName New UNO accessible name.
+   * @return
+   */
+void  AccObjectManagerAgent::UpdateAccName( XAccessible* pXAcc, Any newName)
+{
+    if( pWinManager )
+        pWinManager->SetAccName( pXAcc, newName );
+}
+
+
+/**
+   * Interface of updating MSAA location when UNO location_changed event occurs.
+   * @param pXAcc Uno XAccessible interface of control.
+   * @param pXAcc Uno The top position of new location.
+   * @param pXAcc Uno The left position of new location.
+   * @param pXAcc Uno The width of new location.
+   * @param pXAcc Uno The width of new location.
+   * @return
+   */
+void  AccObjectManagerAgent::UpdateLocation( XAccessible* /* pXAcc */, long /*top*/, long /*left*/, long /*width*/, long /*height*/ )
+{
+#ifdef _IMPL_WIN
+    if( pWinManager )
+        pWinManager->SetLocation( pXAcc, top, left, width, height );
+#endif
+}
+
+/**
+   * Interface of updating MSAA name when UNO description_changed event occurs.
+   * @param pXAcc Uno XAccessible interface of control.
+   * @param newDesc New UNO accessible description.
+   * @return
+   */
+void  AccObjectManagerAgent::UpdateDescription( XAccessible* pXAcc, Any newDesc )
+{
+    if( pWinManager )
+        pWinManager->SetDescription( pXAcc, newDesc );
+}
+
+/**
+   * When a new UNO XAccessible object is found by listener,we'll create a corresponding
+   * com object and insert it to our manager list.
+   * @param pXAcc Uno XAccessible interface of control.
+   * @param pWnd The top window handle containing control.
+   * @return If the method is correctly processed.
+   */
+unsigned char AccObjectManagerAgent::InsertAccObj( XAccessible* pXAcc,XAccessible* pParentXAcc,long pWnd)
+{
+    if( pWinManager )
+        return (unsigned char)pWinManager->InsertAccObj( pXAcc, pParentXAcc,HWND((void*)pWnd) );
+
+    return sal_False;
+}
+
+/**
+   * save the pair <topwindowhandle, XAccessible>
+   * @param hWnd, top window handle
+   * @param pXAcc XAccessible interface for top window
+   * @return void
+   */
+void AccObjectManagerAgent::SaveTopWindowHandle(long hWnd, com::sun::star::accessibility::XAccessible* pXAcc)
+{
+    if( pWinManager )
+        pWinManager->SaveTopWindowHandle( HWND((void*)hWnd), pXAcc );
+}
+
+
+/**
+   * When a UNO XAccessible object's new children are found by listener,we'll create
+   * corresponding com objects and insert them to our manager list.
+   * @param pXAcc Uno XAccessible interface of control.
+   * @param pWnd The top window handle containing control.
+   * @return If the method is correctly processed.
+   */
+unsigned char AccObjectManagerAgent::InsertChildrenAccObj( XAccessible* pXAcc,
+        long pWnd)
+{
+    if( pWinManager )
+        return (unsigned char)pWinManager->InsertChildrenAccObj( pXAcc, HWND((void*)pWnd) );
+
+    return sal_False;
+}
+
+/**
+   * When a new UNO XAccessible object is destroied,we'll delete its corresponding
+   * com object and remove it from our manager list.
+   * @param pXAcc Uno XAccessible interface of control.
+   * @return 
+   */
+void AccObjectManagerAgent::DeleteAccObj( XAccessible* pXAcc )
+{
+    if( pWinManager )
+        pWinManager->DeleteAccObj( pXAcc );
+}
+
+/**
+   * When new UNO children XAccessible objects are destroyed,we'll delete their
+   * corresponding com objects and remove them from our manager list.
+   * @param pXAcc Uno XAccessible interface of control.
+   * @return 
+   */
+void AccObjectManagerAgent::DeleteChildrenAccObj( XAccessible* pXAcc )
+{
+    if( pWinManager )
+        pWinManager->DeleteChildrenAccObj( pXAcc );
+}
+
+/**
+   * Interface of decreasing MSAA state when some UNO state is decreased.
+   * @param pXAcc Uno XAccessible interface of control.
+   * @param pState The lost state of control.
+   * @return
+   */
+void AccObjectManagerAgent::DecreaseState( XAccessible* pXAcc,unsigned short pState )
+{
+    if(pWinManager)
+    {
+        pWinManager->DecreaseState( pXAcc,  pState );
+    }
+}
+
+/**
+   * Interface of increasing MSAA name when some UNO state is increased.
+   * @param pXAcc Uno XAccessible interface of control.
+   * @param pState The new state of control.
+   * @return
+   */
+void AccObjectManagerAgent::IncreaseState( XAccessible* pXAcc,unsigned short pState )
+{
+    if(pWinManager)
+    {
+        pWinManager->IncreaseState( pXAcc,  pState );
+    }
+}
+
+void  AccObjectManagerAgent::UpdateState( com::sun::star::accessibility::XAccessible* pXAcc )
+{
+    if(pWinManager)
+        pWinManager->UpdateState(pXAcc);
+}
+
+/**
+   * Interface of notify MSAA event when some UNO event occured.
+   * @param pXAcc Uno XAccessible interface of control.
+   * @param pEvent UNO event ID.
+   * @return If the method is correctly processed.
+   */
+unsigned char AccObjectManagerAgent::NotifyAccEvent( short pEvent,XAccessible* pXAcc )
+{
+    if(pWinManager)
+        return (unsigned char)pWinManager->NotifyAccEvent(pXAcc,pEvent);
+
+    return sal_False;
+}
+
+/**
+   * Judge whether a XAccessible object is a container object.
+   * @param pXAcc Uno XAccessible interface of control.
+   * @return If the method is correctly processed.
+   */
+unsigned short AccObjectManagerAgent::IsContainer( XAccessible* pXAcc )
+{
+    if(pWinManager)
+        return (unsigned char)pWinManager->IsContainer(pXAcc);
+
+    return sal_False;
+}
+
+/**
+   * Return com object interface by querying XAccessible interface.
+   * @param pXAcc Uno XAccessible interface of control.
+   * @return Com interface.
+   */
+IMAccessible* AccObjectManagerAgent::GetIMAccByXAcc(XAccessible* pXAcc)
+{
+    if(pWinManager)
+        return pWinManager->GetIMAccByXAcc(pXAcc);
+
+    return NULL;
+}
+
+/**
+   * Notify manger when a XAccessible object is destroying.
+   * @param pXAcc Uno XAccessible interface of control.
+   * @return.
+   */
+void  AccObjectManagerAgent::NotifyDestroy(XAccessible* pXAcc)
+{
+    if(pWinManager)
+        pWinManager->NotifyDestroy(pXAcc);
+}
+
+/**
+   * Return com object interface by querying child id.
+   * @param pXAcc Uno XAccessible interface of control.
+   * @return Com interface.
+   */
+void AccObjectManagerAgent::GetIAccessibleFromResID(long childID,IMAccessible** pIMAcc)
+{
+    if(pWinManager)
+        *pIMAcc = pWinManager->GetIAccessibleFromResID(childID);
+}
+
+/**
+   * Return object interface by querying interface.
+   * @param pXAcc Uno XAccessible interface of control.
+   * @return Com interface.
+   */
+unsigned char AccObjectManagerAgent::GetIAccessibleFromXAccessible(XAccessible* pXAcc, IAccessible** ppXI)
+{
+    if(pWinManager)
+    {
+        *ppXI = (IAccessible*)pWinManager->GetIMAccByXAcc(pXAcc);
+        if(*ppXI)
+            return sal_True;
+    }
+    return sal_False;
+}
+
+XAccessible* AccObjectManagerAgent::GetParentXAccessible( XAccessible* pXAcc )
+{
+    if(pWinManager)
+        return pWinManager->GetParentXAccessible( pXAcc );
+
+    return NULL;
+}
+
+short AccObjectManagerAgent::GetParentRole( XAccessible* pXAcc )
+{
+    if(pWinManager)
+        return pWinManager->GetParentRole( pXAcc );
+
+    return -1;
+}
+
+void AccObjectManagerAgent::UpdateDescription( XAccessible* pXAcc )
+{
+    if(pWinManager)
+        pWinManager->UpdateDescription( pXAcc );
+}
+
+void AccObjectManagerAgent::UpdateChildState(com::sun::star::accessibility::XAccessible* pXAcc)
+{
+    if(pWinManager)
+        pWinManager->UpdateChildState( pXAcc );
+}
+
+
+bool AccObjectManagerAgent::IsSpecialToolboItem(com::sun::star::accessibility::XAccessible* pXAcc)
+{
+    if(pWinManager)
+        return pWinManager->IsSpecialToolboItem( pXAcc );
+
+    return false;
+}
+
+short AccObjectManagerAgent::GetRole(com::sun::star::accessibility::XAccessible* pXAcc)
+{
+    if(pWinManager)
+        return pWinManager->GetRole( pXAcc );
+
+    return -1;
+}
+
+XAccessible* AccObjectManagerAgent::GetAccDocByAccTopWin( XAccessible* pXAcc )
+{
+    if (pWinManager)
+    {
+        return pWinManager->GetAccDocByAccTopWin( pXAcc );
+    }
+    return NULL;
+}
+bool AccObjectManagerAgent::IsTopWinAcc( com::sun::star::accessibility::XAccessible* pXAcc )
+{
+    if (pWinManager)
+    {
+        return pWinManager->IsTopWinAcc( pXAcc );
+    }
+    return NULL;
+}
+
+bool AccObjectManagerAgent::IsStateManageDescendant(com::sun::star::accessibility::XAccessible* pXAcc)
+{
+    if(pWinManager)
+        return pWinManager->IsStateManageDescendant( pXAcc );
+
+    return sal_False;
+}

Propchange: openoffice/branches/capstone2013/main/winaccessibility/source/service/AccObjectManagerAgent.cxx
------------------------------------------------------------------------------
    svn:executable = *

Added: openoffice/branches/capstone2013/main/winaccessibility/source/service/AccObjectWinManager.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/capstone2013/main/winaccessibility/source/service/AccObjectWinManager.cxx?rev=1546358&view=auto
==============================================================================
--- openoffice/branches/capstone2013/main/winaccessibility/source/service/AccObjectWinManager.cxx (added)
+++ openoffice/branches/capstone2013/main/winaccessibility/source/service/AccObjectWinManager.cxx Thu Nov 28 12:54:21 2013
@@ -0,0 +1,1321 @@
+/**************************************************************
+ * 
+ * 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.
+ * 
+ *************************************************************/
+
+#include <cassert>
+
+#include <com/sun/star/accessibility/XAccessibleEventBroadcaster.hpp>
+#include <com/sun/star/accessibility/XAccessibleEventListener.hpp>
+#include <com/sun/star/accessibility/XAccessibleComponent.hpp>
+#include <com/sun/star/accessibility/AccessibleStateType.hpp>
+
+#include <oleacc.h>
+#ifndef _SV_AccObjectWinManager_HXX
+#include "AccObjectWinManager.hxx"
+#endif
+#include "AccEventListener.hxx"
+#include "AccComponentEventListener.hxx"
+#include "AccContainerEventListener.hxx"
+#include "AccDialogEventListener.hxx"
+#include "AccWindowEventListener.hxx"
+#include "AccFrameEventListener.hxx"
+#include "AccMenuEventListener.hxx"
+#include "AccObjectContainerEventListener.hxx"
+#include "AccParagraphEventListener.hxx"
+#include "AccTextComponentEventListener.hxx"
+#include "AccListEventListener.hxx"
+#include "AccTreeEventListener.hxx"
+#include "AccTableEventListener.hxx"
+#include "AccObject.hxx"
+#include "unomsaaevent.hxx"
+#include "checkmt.hxx"
+
+#define CHILDID_SELF             0
+
+
+using namespace std;
+using namespace com::sun::star::accessibility;
+using namespace com::sun::star::uno;
+
+AccObjectWinManager* g_acc_manager = NULL;
+AccObjectWinManager* AccObjectWinManager::me = NULL;
+
+/**
+   * Implementation of interface XMSAAService's method getAccObjectPtr() that return the
+   * corresponding com interface with the MS event.
+   *
+   * @param   
+   * @return  Com interface.
+   */
+long GetMSComPtr(long hWnd, long lParam, long wParam)
+{
+    if( g_acc_manager )
+        return (long)g_acc_manager->Get_ToATInterface(HWND((void*)hWnd),lParam,wParam );
+    return NULL;
+}
+
+/**
+   * constructor
+   * @param   Agent The agent kept in all listeners,it's the sole interface by which
+   *                listener communicate with windows manager.
+   *          pEventAccObj The present event accobject.
+   *          oldFocus     Last focused object.
+   *          isSelectionChanged flag that identifies if there is selection changed.
+   *		  selectionChildObj  Selected object.
+   *          dChildID	Chile resource ID.
+   *          hAcc TopWindowHWND
+   * @return  
+   */
+AccObjectWinManager::AccObjectWinManager( AccObjectManagerAgent* Agent ):
+        pAgent( Agent ),
+        oldFocus( NULL )
+{
+}
+
+/**
+   * Public method to produce manager
+   * @param   Agent The agent kept in all listeners,it's the sole interface by which
+   *          listener communicate with windows manager.
+   * @return  
+   */
+AccObjectWinManager* AccObjectWinManager::CreateAccObjectWinManagerInstance( AccObjectManagerAgent* Agent )
+{
+    if( me == NULL )
+    {
+        me = new AccObjectWinManager( Agent );
+        g_acc_manager = me;
+        return me;
+    }
+
+    return me;
+}
+
+
+/**
+   * Destructor,clear all resource.
+   * @param   
+   * @return  
+   */
+AccObjectWinManager::~AccObjectWinManager()
+{
+    XIdAccList.clear();
+    HwndXAcc.clear();
+    XResIdAccList.clear();
+    XHWNDDocList.clear();
+#ifdef ACC_DEBUG
+
+    fclose( pFile );
+#endif
+}
+
+
+/**
+   * Get valid com object interface when notifying some MSAA event
+   * @param pWND The top window handle that contains that event control.
+   * @param wParam Windows system interface. 
+   * @return Com interface with event. 
+   */
+
+long AccObjectWinManager::Get_ToATInterface( HWND hWnd, long lParam, long wParam)
+{
+    vos::OGuard localGuard(maATInterfaceMutex);//
+
+    IMAccessible* pRetIMAcc = NULL;
+
+    if(lParam == OBJID_CLIENT )
+    {
+        AccObject* topWindowAccObj = GetTopWindowAccObj(hWnd);
+        if(topWindowAccObj)
+        {
+            pRetIMAcc = topWindowAccObj->GetIMAccessible();
+            if(pRetIMAcc)
+                pRetIMAcc->AddRef();//increase COM reference count
+        }
+    }
+
+    if ( pRetIMAcc && lParam == OBJID_CLIENT )
+    {
+        IAccessible* pTemp = dynamic_cast<IAccessible*>( pRetIMAcc );
+        HRESULT result = LresultFromObject(IID_IAccessible, wParam, pTemp);
+        pTemp->Release();
+        return result;
+    }
+    return 0;
+}
+
+/**
+   * Search AccObject by XAccessible pointer from our container.
+   * @param pXAcc XAccessible interface.
+   * @return Pointer of accObject that is found. 
+   */
+AccObject* AccObjectWinManager::GetAccObjByXAcc( XAccessible* pXAcc)
+{
+    if( pXAcc == NULL)
+        return NULL;
+
+    XIdToAccObjHash::iterator pIndTemp = XIdAccList.find( (void*)pXAcc );
+    if ( pIndTemp == XIdAccList.end() )
+        return NULL;
+
+    return &(pIndTemp->second);
+}
+
+/**
+   * Search XAccessible by AccObject pointer from our container.
+   * @param pAccObj AccObject pointer.
+   * @return Pointer of XAccessible Interface. 
+   */
+XAccessible* AccObjectWinManager::GetXAccByAccObj(AccObject* pAccObj)
+{
+    XIdToAccObjHash::iterator iter = XIdAccList.begin();
+    while(iter!=XIdAccList.end())
+    {
+        AccObject* tmp = &(iter->second);
+        if(tmp== pAccObj)
+            return (XAccessible*)(iter->first);
+        iter++;
+    }
+    return NULL;
+}
+
+/**
+   * get acc object of top window by its handle
+   * @param hWnd, top window handle
+   * @return pointer to AccObject
+   */
+AccObject* AccObjectWinManager::GetTopWindowAccObj(HWND hWnd)
+{
+    XHWNDToXAccHash::iterator iterResult =HwndXAcc.find(hWnd);
+    if(iterResult == HwndXAcc.end())
+        return NULL;
+    XAccessible* pXAcc = (XAccessible*)(iterResult->second);
+    return GetAccObjByXAcc(pXAcc);
+}
+
+/**
+   * Simulate MSAA event via XAccessible interface and event type.
+   * @param pXAcc XAccessible interface.
+   * @param state Customize Interface   
+   * @return The terminate result that identifies if the call is successful. 
+   */
+sal_Bool AccObjectWinManager::NotifyAccEvent(XAccessible* pXAcc,short state)
+{
+    vos::OGuard aGuard(aNotifyMutex);
+
+    if (!IsInMainThread())
+    {
+        return sal_False;
+    }
+
+    Reference< XAccessibleContext > pRContext;
+
+    if( pXAcc == NULL)
+        return sal_False;
+
+
+    pRContext = pXAcc->getAccessibleContext();
+    if( !pRContext.is() )
+        return sal_False;
+
+
+    AccObject* selfAccObj= GetAccObjByXAcc(pXAcc);
+
+    if(selfAccObj==NULL)
+        return sal_False;
+
+    int selectNum =0;
+
+    long dChildID = selfAccObj->GetResID();
+    HWND hAcc = selfAccObj->GetParentHWND();
+
+    switch(state)
+    {
+    case UM_EVENT_STATE_FOCUSED:
+        {
+            UpdateAccFocus(pXAcc);
+            if( selfAccObj )
+                selfAccObj->UpdateDefaultAction( );
+            UpdateValue(pXAcc);
+            NotifyWinEvent( EVENT_OBJECT_FOCUS,hAcc, OBJID_CLIENT,dChildID  );
+            break;
+        }
+    case UM_EVENT_STATE_BUSY:
+        NotifyWinEvent( EVENT_OBJECT_STATECHANGE,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_STATE_CHECKED:
+        NotifyWinEvent( EVENT_OBJECT_STATECHANGE,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_STATE_PRESSED:
+        NotifyWinEvent( EVENT_OBJECT_STATECHANGE,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+
+    //Removed fire out selected event
+    //case UM_EVENT_STATE_SELECTED:
+    //	NotifyWinEvent( EVENT_OBJECT_STATECHANGE,hAcc, OBJID_CLIENT,dChildID  );
+    //	break;
+    case UM_EVENT_STATE_ARMED:
+        UpdateAccFocus(pXAcc);
+        NotifyWinEvent( EVENT_OBJECT_FOCUS,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_MENU_START:
+        NotifyWinEvent( EVENT_SYSTEM_MENUSTART,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_MENU_END:
+        NotifyWinEvent( EVENT_SYSTEM_MENUEND,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_MENUPOPUPSTART:
+        NotifyWinEvent( EVENT_SYSTEM_MENUPOPUPSTART,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_MENUPOPUPEND:
+        NotifyWinEvent( EVENT_SYSTEM_MENUPOPUPEND,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_SELECTION_CHANGED:
+        NotifyWinEvent( EVENT_OBJECT_SELECTION,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_SELECTION_CHANGED_ADD:
+       	NotifyWinEvent( EVENT_OBJECT_SELECTIONADD,hAcc, OBJID_CLIENT,dChildID  );
+       	break;
+    case UM_EVENT_SELECTION_CHANGED_REMOVE:
+       	NotifyWinEvent( EVENT_OBJECT_SELECTIONREMOVE,hAcc, OBJID_CLIENT,dChildID  );
+       	break;
+    case UM_EVENT_SELECTION_CHANGED_WITHIN:
+       	NotifyWinEvent( EVENT_OBJECT_SELECTIONWITHIN,hAcc, OBJID_CLIENT,dChildID  );
+       	break;
+    case UM_EVENT_OBJECT_VALUECHANGE:
+        UpdateValue(pXAcc);
+        NotifyWinEvent( EVENT_OBJECT_VALUECHANGE,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_OBJECT_NAMECHANGE:
+        NotifyWinEvent( EVENT_OBJECT_NAMECHANGE,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_OBJECT_DESCRIPTIONCHANGE:
+        NotifyWinEvent( EVENT_OBJECT_DESCRIPTIONCHANGE,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_OBJECT_DEFACTIONCHANGE:
+        NotifyWinEvent( IA2_EVENT_ACTION_CHANGED,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_OBJECT_CARETCHANGE:
+        NotifyWinEvent( IA2_EVENT_TEXT_CARET_MOVED,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_OBJECT_TEXTCHANGE:
+        NotifyWinEvent( IA2_EVENT_TEXT_CHANGED,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_ACTIVE_DESCENDANT_CHANGED:
+        UpdateAccFocus(pXAcc);
+        NotifyWinEvent( EVENT_OBJECT_FOCUS,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_BOUNDRECT_CHANGED:
+        NotifyWinEvent( EVENT_OBJECT_LOCATIONCHANGE,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_VISIBLE_DATA_CHANGED:
+        NotifyWinEvent( IA2_EVENT_VISIBLE_DATA_CHANGED,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_SHOW :
+        NotifyWinEvent( EVENT_OBJECT_SHOW,hAcc, OBJID_CLIENT,dChildID  );
+        NotifyWinEvent( EVENT_SYSTEM_FOREGROUND,hAcc, OBJID_CLIENT,dChildID  );
+	break;
+    case UM_EVENT_TABLE_CAPTION_CHANGED:
+        NotifyWinEvent( IA2_EVENT_TABLE_CAPTION_CHANGED,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_TABLE_COLUMN_DESCRIPTION_CHANGED:
+        NotifyWinEvent( IA2_EVENT_TABLE_COLUMN_DESCRIPTION_CHANGED,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_TABLE_COLUMN_HEADER_CHANGED:
+        NotifyWinEvent( IA2_EVENT_TABLE_COLUMN_HEADER_CHANGED,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_TABLE_MODEL_CHANGED:
+        NotifyWinEvent( IA2_EVENT_TABLE_MODEL_CHANGED,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_TABLE_ROW_HEADER_CHANGED:
+        NotifyWinEvent( IA2_EVENT_TABLE_ROW_HEADER_CHANGED,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_TABLE_SUMMARY_CHANGED:
+        NotifyWinEvent( IA2_EVENT_TABLE_SUMMARY_CHANGED,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_TABLE_ROW_DESCRIPTION_CHANGED:
+        NotifyWinEvent( IA2_EVENT_TABLE_ROW_DESCRIPTION_CHANGED,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_OBJECT_REORDER:
+        NotifyWinEvent( EVENT_OBJECT_REORDER,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_PAGE_CHANGED:
+        NotifyWinEvent( IA2_EVENT_PAGE_CHANGED,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_CHILD_REMOVED:
+        NotifyWinEvent( EVENT_OBJECT_DESTROY,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_CHILD_ADDED:
+        NotifyWinEvent( EVENT_OBJECT_CREATE ,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_OBJECT_PAGECHANGED:
+        NotifyWinEvent( IA2_EVENT_PAGE_CHANGED ,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_TEXT_SELECTION_CHANGED:
+        NotifyWinEvent( IA2_EVENT_TEXT_SELECTION_CHANGED ,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_SECTION_CHANGED:
+        NotifyWinEvent( IA2_EVENT_SECTION_CHANGED ,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    case UM_EVENT_COLUMN_CHANGED:
+        NotifyWinEvent( IA2_EVENT_TEXT_COLUMN_CHANGED ,hAcc, OBJID_CLIENT,dChildID  );
+        break;
+    default:
+        break;
+    }
+
+    return sal_True;
+}
+
+/**
+   * Get Parent XAccessible interface by XAccessible interface.
+   * @param pXAcc XAccessible interface.
+   * @return Parent XAccessible interface.
+   */
+XAccessible* AccObjectWinManager::GetParentXAccessible( XAccessible* pXAcc )
+{
+    AccObject* pObj= GetAccObjByXAcc(pXAcc);
+    if( pObj ==NULL )
+        return NULL;
+    if(pObj->GetParentObj())
+    {
+        pObj = pObj->GetParentObj();
+        return pObj->GetXAccessible().get();
+    }
+    return NULL;
+}
+
+/**
+   * Get Parent role by XAccessible interface.
+   * @param pXAcc XAccessible interface.
+   * @return Parent role.
+   */
+short AccObjectWinManager::GetParentRole( XAccessible* pXAcc )
+{
+    AccObject* pObj= GetAccObjByXAcc(pXAcc);
+    if( pObj ==NULL )
+        return -1;
+    if(pObj->GetParentObj())
+    {
+        pObj = pObj->GetParentObj();
+        if(pObj->GetXAccessible().is())
+        {
+            XAccessible* pXAcc = pObj->GetXAccessible().get();
+            Reference< XAccessibleContext > pRContext = pXAcc->getAccessibleContext();
+            if(pRContext.is())
+                return pRContext->getAccessibleRole();
+        }
+    }
+    return -1;
+}
+
+/**
+   * Update focus objcet by new focused XAccessible interface.
+   * @param newFocus New XAccessible interface that gets focus.
+   * @return 
+   */
+void AccObjectWinManager::UpdateAccFocus(XAccessible* newFocus)
+{
+    AccObject* pAccObjNew = GetAccObjByXAcc(newFocus);
+    if(pAccObjNew)
+    {
+        AccObject* pAccObjOld = GetAccObjByXAcc(oldFocus);
+        oldFocus = newFocus;
+        pAccObjNew->setFocus();
+        //if old == new, the pAccObjNew will be without focused state
+        if (pAccObjOld && pAccObjOld != pAccObjNew)
+            pAccObjOld->unsetFocus();
+    }
+}
+
+/**
+   * Update selected objcet by new focused XAccessible interface.
+   * @param pXAcc XAccessible interface that has selected child changed.
+   * @return Selected children count.
+   */
+int AccObjectWinManager::UpdateAccSelection(XAccessible* pXAcc)
+{
+    XAccessibleSelection* pSelection = NULL;
+    Reference< XAccessibleContext > pRContext;
+
+    if( pXAcc == NULL)
+        return sal_False;
+
+    pRContext = pXAcc->getAccessibleContext();
+    if( !pRContext.is() )
+        return sal_False;
+
+    Reference< XAccessibleSelection > pRSelection(pRContext,UNO_QUERY);
+    if( !pRSelection.is() )
+        return sal_False;
+
+    AccObject* pAccObj = GetAccObjByXAcc(pXAcc);
+    if(pAccObj==NULL)
+        return sal_False;
+
+    Reference<XAccessible> pRChild = NULL;
+    AccObject* pAccChildObj = NULL;
+    int selectNum= pRSelection->getSelectedAccessibleChildCount();
+
+    IAccSelectionList oldSelection = pAccObj->GetSelection();
+
+    if(selectNum > 4)//for selected.
+        return selectNum;
+    if(selectNum == 1 && oldSelection.size() == 0)
+        return 1;
+
+    for (int i=0;i<selectNum;i++)
+    {
+        pRChild = pRSelection->getSelectedAccessibleChild(i);
+        if(!pRChild.is())
+        {
+            continue;
+        }
+        Reference<XAccessibleContext> pRChildContext = pRChild->getAccessibleContext();
+        if(!pRChildContext.is())
+        {
+            continue;
+        }
+        long index = pRChildContext->getAccessibleIndexInParent();
+        IAccSelectionList::iterator temp = oldSelection.find(index);
+        if ( temp != oldSelection.end() )
+        {
+            oldSelection.erase(index);
+            continue;
+        }
+
+        pAccChildObj = NULL;
+        pAccChildObj = GetAccObjByXAcc(pRChild.get());
+        if(!pAccChildObj)
+        {
+            InsertAccObj(pRChild.get(), pXAcc,pAccObj->GetParentHWND());
+            pAccChildObj = GetAccObjByXAcc(pRChild.get());
+        }
+
+        pAccObj->AddSelect(index, pAccChildObj);
+
+        if(pAccChildObj != NULL)
+            NotifyWinEvent(EVENT_OBJECT_SELECTIONADD,pAccObj->GetParentHWND(), OBJID_CLIENT,pAccChildObj->GetResID());
+    }
+
+    IAccSelectionList::iterator iter = oldSelection.begin();
+    while(iter!=oldSelection.end())
+    {
+        pAccObj->GetSelection().erase(iter->first);
+        pAccChildObj = (AccObject*)(iter->second);
+        if(pAccChildObj != NULL)
+            NotifyWinEvent(EVENT_OBJECT_SELECTIONREMOVE,pAccObj->GetParentHWND(), OBJID_CLIENT,pAccChildObj->GetResID());
+        iter++;
+    }
+    return 0;
+
+}
+
+/**
+   * Delete child element from children list.
+   * @param pObj Child element that should be removed from parant child list.
+   * @return 
+   */
+void AccObjectWinManager::DeleteAccChildNode( AccObject* pObj )
+{
+    AccObject *parentAccObj = pObj->GetParentObj();
+    if( parentAccObj )
+        parentAccObj->DeleteChild( pObj );
+}
+
+/**
+   * Delete XAccessible items in top window handle hashtable
+   * @param pXAcc XAccessible interface.
+   * @return 
+   */
+void AccObjectWinManager::DeleteFromHwndXAcc(XAccessible* pXAcc )
+{
+    XHWNDToXAccHash::iterator iter = HwndXAcc.begin();
+    while(iter!=HwndXAcc.end())
+    {
+        if(iter->second == pXAcc )
+        {
+            HwndXAcc.erase(iter);
+            return;
+        }
+        iter++;
+    }
+}
+
+/**
+   * Delete Delete all children with the tree root of XAccessible pointer
+   * @param pXAcc Tree root XAccessible interface.
+   * @return 
+   */
+void AccObjectWinManager::DeleteChildrenAccObj(XAccessible* pXAcc)
+{
+    vos::OGuard aGuard( aDeleteMutex );
+    AccObject* currentObj=NULL;
+    AccObject* childObj=NULL;
+    XAccessible* pTmpXAcc=NULL;
+
+    currentObj =  GetAccObjByXAcc( pXAcc);
+    if(currentObj)
+    {
+        childObj = currentObj->NextChild();
+        while(childObj)
+        {
+            pTmpXAcc = GetXAccByAccObj(childObj);
+            if(pTmpXAcc)
+            {
+                DeleteChildrenAccObj(pTmpXAcc);
+                DeleteAccObj(pTmpXAcc);
+            }
+            childObj = currentObj->NextChild();
+        }
+    }
+}
+
+/**
+   * Delete Delete Acc object self.
+   * @param pXAcc The XAccessible interface.
+   * @return 
+   */
+void AccObjectWinManager::DeleteAccObj( XAccessible* pXAcc )
+{
+    vos::OGuard aGuard( aDeleteMutex );
+    if( pXAcc == NULL )
+        return;
+    XIdToAccObjHash::iterator temp = XIdAccList.find(pXAcc);
+    if( temp != XIdAccList.end() )
+    {
+        ResIdGen.SetSub( temp->second.GetResID() );
+    }
+    else
+    {
+        return;
+    }
+
+    AccObject& accObj = temp->second;
+    DeleteAccChildNode( &accObj );
+    DeleteAccListener( &accObj );
+    if( accObj.GetIMAccessible() )
+    {
+        accObj.GetIMAccessible()->Release();
+    }
+    XIdAccList.erase( pXAcc );
+    XResIdAccList.erase( accObj.GetResID() );
+    DeleteFromHwndXAcc(pXAcc);
+}
+
+/**
+   * Delete listener that inspects some XAccessible object
+   * @param pAccObj Accobject pointer.
+   * @return 
+   */
+void AccObjectWinManager::DeleteAccListener( AccObject*  pAccObj )
+{
+    AccEventListener* listener = pAccObj->getListener();
+    if( listener==NULL )
+        return;
+    listener->removeMeFromBroadcaster();
+    pAccObj->SetListener(NULL);
+}
+
+/**
+   * Generate a child ID, which is used for AT
+   * @param 
+   * @return New resource ID.
+   */
+inline long AccObjectWinManager::ImpleGenerateResID()
+{
+    return ResIdGen.GenerateNewResID();
+}
+
+/**
+   * Insert all children of the current acc object
+   * @param pXAcc XAccessible interface
+   * @param pWnd  Top Window handle
+   * @return The calling result.
+   */
+sal_Bool AccObjectWinManager::InsertChildrenAccObj( com::sun::star::accessibility::XAccessible* pXAcc,
+        HWND pWnd)
+{
+    if(!IsContainer(pXAcc))
+        return sal_False;
+
+    Reference< XAccessibleContext > pRContext;
+
+    if( pXAcc == NULL)
+        return sal_False;
+    pRContext = pXAcc->getAccessibleContext();
+    if( !pRContext.is() )
+        return sal_False;
+
+    short role = pRContext->getAccessibleRole();
+
+    if(com::sun::star::accessibility::AccessibleRole::DOCUMENT == role )
+    {
+        if(IsStateManageDescendant(pXAcc))
+        {
+            return sal_True;
+        }
+    }
+
+    int count = pRContext->getAccessibleChildCount();
+    for (int i=0;i<count;i++)
+    {
+        Reference<XAccessible> mxAccessible
+        = pRContext->getAccessibleChild(i);
+        XAccessible* mpAccessible = mxAccessible.get();
+        if(mpAccessible != NULL)
+        {
+            InsertAccObj( mpAccessible,pXAcc,pWnd );
+            InsertChildrenAccObj(mpAccessible,pWnd);
+        }
+    }
+
+    return sal_True;
+}
+
+/**
+   * Insert child object.
+   * @param pCurObj The child object
+   * @param pParentObj The parant object
+   * @param pWnd Top window handle.
+   * @return 
+   */
+void AccObjectWinManager::InsertAccChildNode( AccObject* pCurObj, AccObject* pParentObj, HWND /* pWnd */ )
+{
+    if(pCurObj)
+    {
+        if(pParentObj)
+        {
+            pParentObj->InsertChild(pCurObj);
+        }
+        else
+        {
+            pCurObj->UpdateValidWindow();
+        }
+    }
+}
+
+/**
+   * Insert child object.
+   * @param pCurObj The child object
+   * @param pParentObj The parant object
+   * @param pWnd Top window handle.
+   * @return 
+   */
+sal_Bool AccObjectWinManager::InsertAccObj( XAccessible* pXAcc,XAccessible* pParentXAcc,HWND pWnd )
+{
+    XIdToAccObjHash::iterator itXacc = XIdAccList.find( (void*)pXAcc );
+    if (itXacc != XIdAccList.end() )
+    {
+        short nCurRole =GetRole(pXAcc);
+        if (AccessibleRole::SHAPE == nCurRole)
+        {
+            AccObject &objXacc = itXacc->second;
+            AccObject *pObjParent = objXacc.GetParentObj();
+            if (pObjParent &&
+                    pObjParent->GetXAccessible().is() &&
+                    pObjParent->GetXAccessible().get() != pParentXAcc)
+            {
+                XIdToAccObjHash::iterator itXaccParent  = XIdAccList.find( (void*)pParentXAcc );
+                if(itXaccParent != XIdAccList.end())
+                {
+                    objXacc.SetParentObj(&(itXaccParent->second));
+                }
+            }
+        }
+        return sal_False;
+    }
+
+
+    Reference< XAccessibleContext > pRContext;
+
+    if( pXAcc == NULL)
+        return sal_False;
+
+    pRContext = pXAcc->getAccessibleContext();
+    if( !pRContext.is() )
+        return sal_False;
+
+    if( pWnd == NULL )
+    {
+        if(pParentXAcc)
+        {
+            AccObject* pObj = GetAccObjByXAcc(pParentXAcc);
+            if(pObj)
+                pWnd = pObj->GetParentHWND();
+        }
+        if( pWnd == NULL )
+            return sal_False;
+    }
+
+    AccObject pObj( pXAcc,pAgent );
+    if( pObj.GetIMAccessible() == NULL )
+        return sal_False;
+    pObj.SetResID( this->ImpleGenerateResID());
+    pObj.SetParentHWND( pWnd );
+
+    //for file name support
+    if ( pObj.GetRole() == DOCUMENT )
+    {
+        XHWNDToDocumentHash::iterator aIter = XHWNDDocList.find( (long)pWnd );
+        if ( aIter != XHWNDDocList.end() )
+        {
+            XHWNDDocList.erase( aIter );
+        }
+        XHWNDDocList.insert( XHWNDToDocumentHash::value_type( (long)pWnd, pXAcc ) );
+
+    }
+    //end of file name
+
+    AccEventListener* listener = createAccEventListener(pXAcc, pAgent);
+    if(listener==NULL)
+        return sal_False;
+    Reference<XAccessibleComponent> xComponent(pRContext,UNO_QUERY);
+    Reference<XAccessibleEventBroadcaster> broadcaster(xComponent,UNO_QUERY);
+    if (broadcaster.is())
+    {
+        Reference <XAccessibleEventListener> pp (
+            static_cast< XAccessibleEventListener* >(listener),UNO_QUERY );
+        if(pp.is())
+        {
+            broadcaster->addEventListener(pp);
+        }
+        else
+        {
+            delete listener;
+            return sal_False;
+        }
+    }
+    else
+        return sal_False;
+
+    XIdAccList.insert( XIdToAccObjHash::value_type( (void*)pXAcc, pObj ));
+    XIdToAccObjHash::iterator pIndTemp = XIdAccList.find( (void*)pXAcc );
+    XResIdAccList.insert(XResIdToAccObjHash::value_type(pObj.GetResID(),&(pIndTemp->second)));
+
+    AccObject* pCurObj = GetAccObjByXAcc(pXAcc);
+    if( pCurObj )
+    {
+        pCurObj->SetListener( listener );
+        if(listener != NULL)
+            listener->acquire();
+    }
+
+    AccObject* pParentObj = GetAccObjByXAcc(pParentXAcc);
+    InsertAccChildNode(pCurObj,pParentObj,pWnd);
+    if( pCurObj )
+        pCurObj->UpdateAccessibleInfoFromUnoToMSAA();
+    return sal_True;
+}
+
+
+/**
+   * save the pair <topwindowhandle, XAccessible>
+   * @param hWnd, top window handle
+   * @param pXAcc XAccessible interface for top window
+   * @return void
+   */
+void AccObjectWinManager::SaveTopWindowHandle(HWND hWnd, com::sun::star::accessibility::XAccessible* pXAcc)
+{
+    HwndXAcc.insert( XHWNDToXAccHash::value_type( hWnd,(void*)pXAcc ) );
+}
+
+
+/**
+   * create the corresponding listener.
+   * @param pXAcc XAccessible interface.
+   * @param Agent The agent kept in all listeners,it's the sole interface by which
+   *        listener communicate with windows manager.
+   * @return 
+   */
+AccEventListener* AccObjectWinManager::createAccEventListener(XAccessible* pXAcc, AccObjectManagerAgent* /* Agent */ )
+{
+    AccEventListener* listener = NULL;
+    Reference<XAccessibleContext> xContext(pXAcc->getAccessibleContext(),UNO_QUERY);
+    if(xContext.is())
+    {
+        switch( xContext->getAccessibleRole() )
+        {
+        case /*AccessibleRole::*/DIALOG:
+            listener = new AccDialogEventListener(pXAcc,pAgent);
+            break;
+        case /*AccessibleRole::*/FRAME:
+            listener = new AccFrameEventListener(pXAcc,pAgent);
+            break;
+        case /*AccessibleRole::*/WINDOW:
+            listener = new AccWindowEventListener(pXAcc,pAgent);
+            break;
+        case /*AccessibleRole::*/ROOT_PANE:
+            listener = new AccFrameEventListener(pXAcc,pAgent);
+            break;
+            //Container
+        case /*AccessibleRole::*/CANVAS:
+        case /*AccessibleRole::*/COMBO_BOX:
+        case /*AccessibleRole::*/DOCUMENT:
+        case /*AccessibleRole::*/END_NOTE:
+        case /*AccessibleRole::*/FILLER:
+        case /*AccessibleRole::*/FOOTNOTE:
+        case /*AccessibleRole::*/FOOTER:
+        case /*AccessibleRole::*/HEADER:
+        case /*AccessibleRole::*/LAYERED_PANE:
+        case /*AccessibleRole::*/MENU_BAR:
+        case /*AccessibleRole::*/POPUP_MENU:
+        case /*AccessibleRole::*/OPTION_PANE:
+        case /*AccessibleRole::*/PAGE_TAB:
+        case /*AccessibleRole::*/PAGE_TAB_LIST:
+        case /*AccessibleRole::*/PANEL:
+        case /*AccessibleRole::*/SCROLL_PANE:
+        case /*AccessibleRole::*/SPLIT_PANE:
+        case /*AccessibleRole::*/STATUS_BAR:
+        case /*AccessibleRole::*/TABLE_CELL:
+        case /*AccessibleRole::*/TOOL_BAR:
+        case /*AccessibleRole::*/VIEW_PORT:
+            listener = new AccContainerEventListener(pXAcc,pAgent);
+            break;
+        case /*AccessibleRole::*/PARAGRAPH:
+        case /*AccessibleRole::*/HEADING:
+            listener = new AccParagraphEventListener(pXAcc,pAgent);
+            break;
+            //Component
+        case /*AccessibleRole::*/CHECK_BOX:
+        case /*AccessibleRole::*/ICON:
+        case /*AccessibleRole::*/LABEL:
+        case /*AccessibleRole::*/MENU_ITEM:
+        case /*AccessibleRole::*/CHECK_MENU_ITEM:
+        case /*AccessibleRole::*/RADIO_MENU_ITEM:
+        case /*AccessibleRole::*/PUSH_BUTTON:
+        case /*AccessibleRole::*/RADIO_BUTTON:
+        case /*AccessibleRole::*/SCROLL_BAR:
+        case /*AccessibleRole::*/SEPARATOR:
+        case /*AccessibleRole::*/TOGGLE_BUTTON:
+        case /*AccessibleRole::*/BUTTON_DROPDOWN:
+        case /*AccessibleRole::*/TOOL_TIP:
+        case /*AccessibleRole::*/SPIN_BOX:
+        case DATE_EDITOR:
+            listener = new AccComponentEventListener(pXAcc,pAgent);
+            break;
+            //text component
+        case /*AccessibleRole::*/TEXT:
+            listener = new AccTextComponentEventListener(pXAcc,pAgent);
+            break;
+            //menu
+        case /*AccessibleRole::*/MENU:
+            listener = new AccMenuEventListener(pXAcc,pAgent);
+            break;
+            //object container
+        case /*AccessibleRole::*/SHAPE:
+
+        case /*AccessibleRole::*/EMBEDDED_OBJECT:
+        case /*AccessibleRole::*/GRAPHIC:
+        case /*AccessibleRole::*/TEXT_FRAME:
+            listener = new AccObjectContainerEventListener(pXAcc,pAgent);
+            break;
+            //descendmanager
+        case /*AccessibleRole::*/LIST:
+            listener = new AccListEventListener(pXAcc,pAgent);
+            break;
+        case /*AccessibleRole::*/TREE:
+            listener = new AccTreeEventListener(pXAcc,pAgent);
+            break;
+            //special
+        case /*AccessibleRole::*/COLUMN_HEADER:
+        case /*AccessibleRole::*/TABLE:
+            listener = new AccTableEventListener(pXAcc,pAgent);
+            break;
+        default:
+            listener = new AccContainerEventListener(pXAcc,pAgent);
+            break;
+        }
+    }
+
+    return listener;
+}
+
+/**
+   * state is a combination integer, each bit of which represents a single state,
+   * such as focused,1 for the state on,0 for the state off. Here call COM interface
+   * to modify the state value, including DecreaseState.
+   * @param pXAcc XAccessible interface.
+   * @param pState Changed state.
+   * @return 
+   */
+void AccObjectWinManager::DecreaseState( XAccessible* pXAcc,unsigned short pState )
+{
+    AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
+    if( pAccObj )
+        pAccObj->DecreaseState( pState );
+}
+
+/**
+   * state is a combination integer, each bit of which represents a single state,such as focused,1 for
+   * the state on,0 for the state off. Here call COM interface to modify the state value, including 
+   * IncreaseState.
+   * @param pXAcc XAccessible interface.
+   * @param pState Changed state.
+   * @return 
+   */
+void AccObjectWinManager::IncreaseState( XAccessible* pXAcc,unsigned short pState )
+{
+    AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
+    if( pAccObj )
+        pAccObj->IncreaseState( pState );
+}
+
+void  AccObjectWinManager::UpdateState( com::sun::star::accessibility::XAccessible* pXAcc )
+{
+    AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
+    if( pAccObj )
+        pAccObj->UpdateState( );
+}
+
+/**
+   * Set corresponding com object's accessible name via XAccessilbe interface and new
+   * name
+   * @param pXAcc XAccessible interface.
+   * @return 
+   */
+void  AccObjectWinManager::UpdateAccName( XAccessible* pXAcc )
+{
+    AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
+    if( pAccObj )
+        pAccObj->UpdateName();
+}
+
+void  AccObjectWinManager::UpdateAction( XAccessible* pXAcc )
+{
+    AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
+    if( pAccObj )
+        pAccObj->UpdateAction();
+}
+
+void AccObjectWinManager::UpdateDescription( XAccessible* pXAcc )
+{
+    AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
+    if ( pAccObj )
+        pAccObj->UpdateDescription();
+}
+
+/**
+   * Set corresponding com object's accessible location via XAccessilbe interface and new
+   * location.
+   * @param pXAcc XAccessible interface.
+   * @return 
+   */
+void  AccObjectWinManager::SetLocation( XAccessible* pXAcc, long /*top*/, long /*left*/, long /*width*/, long /*height*/ )
+{
+    AccObject* pObj = GetAccObjByXAcc( pXAcc );
+    //get the location from XComponent.
+    Reference< XAccessibleContext > pRContext = pXAcc->getAccessibleContext();
+    if( pObj )
+        pObj->UpdateLocation();
+}
+
+/**
+   * Set corresponding com object's value  via XAccessilbe interface and new value.
+   * @param pXAcc XAccessible interface.
+   * @param pAny new value.
+   * @return 
+   */
+void  AccObjectWinManager::SetValue( XAccessible* pXAcc, Any pAny )
+{
+    AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
+    if( pAccObj )
+        pAccObj->SetValue( pAny );
+}
+
+/**
+   * Set corresponding com object's value  via XAccessilbe interface.
+   * @param pXAcc XAccessible interface.
+   * @return 
+   */
+void  AccObjectWinManager::UpdateValue( XAccessible* pXAcc )
+{
+    AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
+    if( pAccObj )
+        pAccObj->UpdateValue();
+}
+
+/**
+   * Set corresponding com object's name via XAccessilbe interface and new name.
+   * @param pXAcc XAccessible interface.
+   * @param newName new name
+   * @return 
+   */
+void  AccObjectWinManager::SetAccName( XAccessible* pXAcc, Any newName)
+{
+    AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
+    if( pAccObj )
+        pAccObj->SetName( newName );
+}
+
+/**
+   * Set corresponding com object's description via XAccessilbe interface and new description.
+   * @param pXAcc XAccessible interface.
+   * @param newDesc new description
+   * @return 
+   */
+void  AccObjectWinManager::SetDescription( XAccessible* pXAcc, Any newDesc )
+{
+    AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
+    if( pAccObj )
+        pAccObj->SetDescription( newDesc );
+}
+
+/**
+   * Set corresponding com object's role via XAccessilbe interface and new role.
+   * @param pXAcc XAccessible interface.
+   * @param Role new role
+   * @return 
+   */
+void  AccObjectWinManager::SetRole( XAccessible* pXAcc, long Role )
+{
+    AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
+    if( pAccObj )
+        pAccObj->SetRole( (short)Role );
+}
+
+/**
+   * Judge if a XAccessible object is a container object.
+   * @param pAccessible XAccessible interface.
+   * @return If XAccessible object is container.
+   */
+sal_Bool AccObjectWinManager::IsContainer(XAccessible* pAccessible)
+{
+    try
+    {
+        if(pAccessible)
+        {
+            Reference<XAccessibleContext> xContext(pAccessible->getAccessibleContext(),UNO_QUERY);
+            if(xContext.is())
+            {
+                switch( xContext->getAccessibleRole() )
+                {
+                case /*AccessibleRole::*/DIALOG:
+                case /*AccessibleRole::*/FRAME:
+                case /*AccessibleRole::*/WINDOW:
+                case /*AccessibleRole::*/ROOT_PANE:
+                case /*AccessibleRole::*/CANVAS:
+                case /*AccessibleRole::*/COMBO_BOX:
+                case /*AccessibleRole::*/DOCUMENT:
+                case /*AccessibleRole::*/EMBEDDED_OBJECT:
+                case /*AccessibleRole::*/END_NOTE:
+                case /*AccessibleRole::*/FILLER:
+                case /*AccessibleRole::*/FOOTNOTE:
+                case /*AccessibleRole::*/FOOTER:
+                case /*AccessibleRole::*/GRAPHIC:
+                case /*AccessibleRole::*/GROUP_BOX:
+                case /*AccessibleRole::*/HEADER:
+                case /*AccessibleRole::*/LAYERED_PANE:
+                case /*AccessibleRole::*/MENU_BAR:
+                case /*AccessibleRole::*/POPUP_MENU:
+                case /*AccessibleRole::*/OPTION_PANE:
+                case /*AccessibleRole::*/PAGE_TAB:
+                case /*AccessibleRole::*/PAGE_TAB_LIST:
+                case /*AccessibleRole::*/PANEL:
+                case /*AccessibleRole::*/SCROLL_PANE:
+                case /*AccessibleRole::*/SPLIT_PANE:
+                case /*AccessibleRole::*/STATUS_BAR:
+                case /*AccessibleRole::*/TABLE_CELL:
+                case /*AccessibleRole::*/TEXT_FRAME:
+                case /*AccessibleRole::*/TOOL_BAR:
+                case /*AccessibleRole::*/VIEW_PORT:
+                case /*AccessibleRole::*/SHAPE:
+                    return sal_True;
+                    break;
+                case /*AccessibleRole::*/COLUMN_HEADER:
+                case /*AccessibleRole::*/TABLE:
+                    if(!IsStateManageDescendant(pAccessible))
+                        return sal_True;
+                    break;
+                case /*AccessibleRole::*/MENU:
+                    return sal_True;
+                    break;
+                default:
+                    return sal_False;
+                }
+            }
+        }
+    }
+    catch(...)
+    {
+        return sal_False;
+    }
+    return sal_False;
+}
+
+/**
+   * Judge if a XAccessible object has ManageDescendant event.
+   * @param pAccessible XAccessible interface.
+   * @return If XAccessible object is managedescendant.
+   */
+bool AccObjectWinManager::IsStateManageDescendant(XAccessible* pAccessible)
+{
+    if(pAccessible)
+    {
+        Reference<XAccessibleContext> xContext(pAccessible->getAccessibleContext(),UNO_QUERY);
+        if(xContext.is())
+        {
+            Reference< XAccessibleStateSet > pRState = xContext->getAccessibleStateSet();
+            if( !pRState.is() )
+                return sal_False;
+
+            Sequence<short> pStates = pRState->getStates();
+            int count = pStates.getLength();
+            for( int iIndex = 0;iIndex < count;iIndex++ )
+            {
+                if(pStates[iIndex] == /*AccessibleStateType::*/MANAGES_DESCENDANTS)
+                    return sal_True;
+            }
+        }
+    }
+    return sal_False;
+}
+
+/**
+   * Query and get IAccessible interface by XAccessible interface from list.
+   * @param pXAcc XAccessible interface.
+   * @return Com accobject interface.
+   */
+IMAccessible* AccObjectWinManager::GetIMAccByXAcc(XAccessible* pXAcc)
+{
+    AccObject* pAccObj = GetAccObjByXAcc(pXAcc);
+    if(pAccObj)
+    {
+        return pAccObj->GetIMAccessible();
+    }
+    else
+    {
+        return NULL;
+    }
+}
+
+/**
+   * Query and get IAccessible interface by child id from list.
+   * @param resID, childID.
+   * @return Com accobject interface.
+   */
+IMAccessible * AccObjectWinManager::GetIAccessibleFromResID(long resID)
+{
+    XResIdToAccObjHash::iterator pIndTemp = XResIdAccList.find( resID );
+    if ( pIndTemp == XResIdAccList.end() )
+        return NULL;
+
+    AccObject* pObj = pIndTemp->second;
+
+    if(pObj->GetIMAccessible())
+        return pObj->GetIMAccessible();
+    return NULL;
+}
+/**
+   * Notify some object will be destroyed.
+   * @param pXAcc XAccessible interface.
+   * @return Com accobject interface.
+   */
+void AccObjectWinManager::NotifyDestroy(XAccessible* pXAcc)
+{
+    AccObject* accObj = GetAccObjByXAcc(pXAcc);
+    if(accObj)
+    {
+        accObj->NotifyDestroy(sal_True);
+    }
+}
+
+
+void AccObjectWinManager::UpdateChildState(com::sun::star::accessibility::XAccessible* pAccSubMenu)
+{
+    Reference<com::sun::star::accessibility::XAccessibleContext> xContext(pAccSubMenu,UNO_QUERY);
+    if (!xContext.is())
+    {
+        return;
+    }
+    sal_Int32 nCount = xContext->getAccessibleChildCount();
+    for (sal_Int32 i = 0 ; i < nCount ; ++i)
+    {
+        Reference<com::sun::star::accessibility::XAccessible> xChild = xContext->getAccessibleChild(i);
+        if (xChild.is())
+        {
+            AccObject *pObj =  GetAccObjByXAcc(xChild.get());
+            if (pObj)
+            {
+                pObj->UpdateState();
+            }
+        }
+    }
+}
+
+
+bool AccObjectWinManager::IsSpecialToolboItem(com::sun::star::accessibility::XAccessible* pXAcc)
+{
+    if (pXAcc && oldFocus != pXAcc)
+    {
+        if(GetParentRole(pXAcc) == TOOL_BAR)
+        {
+            Reference< XAccessibleContext > pRContext(pXAcc->getAccessibleContext());
+            if (pRContext.is())
+            {
+                if(pRContext->getAccessibleRole() == TOGGLE_BUTTON)
+                {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+
+short AccObjectWinManager::GetRole(com::sun::star::accessibility::XAccessible* pXAcc)
+{
+    assert(pXAcc != NULL);
+    Reference<com::sun::star::accessibility::XAccessibleContext> xContext(pXAcc->getAccessibleContext(),UNO_QUERY);
+    if(xContext.is())
+    {
+        return xContext->getAccessibleRole();
+    }
+    return -1;
+}
+
+XAccessible* AccObjectWinManager::GetAccDocByHWND( long pWnd )
+{
+    XHWNDToDocumentHash::iterator aIter;
+    aIter = XHWNDDocList.find( pWnd );
+    if ( aIter != XHWNDDocList.end() )
+    {
+        return aIter->second;
+    }
+
+    return NULL;
+}
+
+XAccessible* AccObjectWinManager::GetAccDocByAccTopWin( XAccessible* pXAcc )
+{
+    AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
+    long pWnd = (long)( pAccObj->GetParentHWND() );
+    return GetAccDocByHWND( pWnd );
+}
+
+bool AccObjectWinManager::IsTopWinAcc( com::sun::star::accessibility::XAccessible* pXAcc )
+{
+    bool bRet = false;
+    AccObject* pAccObj = GetAccObjByXAcc( pXAcc );
+    if ( pAccObj )
+    {
+        bRet = ( pAccObj->GetParentObj() == NULL );
+    }
+    return bRet;
+}
\ No newline at end of file

Propchange: openoffice/branches/capstone2013/main/winaccessibility/source/service/AccObjectWinManager.cxx
------------------------------------------------------------------------------
    svn:executable = *



Mime
View raw message