/**************************************************************
 * 
 * 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() );
    if ( PARAGRAPH == m_accRole)
    {
    	::rtl::OUString emptyStr = ::rtl::OUString::createFromAscii("");
    	m_pIMAcc->Put_XAccName(emptyStr.getStr());
    }
    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:
    //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() );
		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;
}