root/dwt/accessibility/Accessible.d

/*******************************************************************************
 * Copyright (c) 2000, 2008 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 * Port to the D programming language:
 *     Frank Benoit <benoit@tionex.de>
 *******************************************************************************/
module dwt.accessibility.Accessible;

import dwt.DWT;
import dwt.DWTException;
import dwt.internal.ole.win32.COM;
import dwt.internal.ole.win32.OAIDL;
import dwt.internal.ole.win32.ifs;
import dwt.internal.ole.win32.extras;
import dwt.internal.win32.OS;
import dwt.internal.DWTEventListener;
import dwt.ole.win32.OLE;
import dwt.ole.win32.Variant;
import dwt.widgets.Control;
import dwt.widgets.Table;
import dwt.widgets.TableItem;
import dwt.widgets.Tree;
import dwt.widgets.TreeItem;
import dwt.widgets.Widget;

import dwt.accessibility.ACC;
import dwt.accessibility.AccessibleControlListener;
import dwt.accessibility.AccessibleListener;
import dwt.accessibility.AccessibleTextListener;
import dwt.accessibility.AccessibleControlEvent;
import dwt.accessibility.AccessibleEvent;

import dwt.dwthelper.utils;
import tango.core.Array;
import tango.core.Thread;

/**
 * Instances of this class provide a bridge between application
 * code and assistive technology clients. Many platforms provide
 * default accessible behavior for most widgets, and this class
 * allows that default behavior to be overridden. Applications
 * can get the default Accessible object for a control by sending
 * it <code>getAccessible</code>, and then add an accessible listener
 * to override simple items like the name and help string, or they
 * can add an accessible control listener to override complex items.
 * As a rule of thumb, an application would only want to use the
 * accessible control listener to implement accessibility for a
 * custom control.
 *
 * @see Control#getAccessible
 * @see AccessibleListener
 * @see AccessibleEvent
 * @see AccessibleControlListener
 * @see AccessibleControlEvent
 * @see <a href="http://www.eclipse.org/swt/snippets/#accessibility">Accessibility snippets</a>
 * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a>
 *
 * @since 2.0
 */
public class Accessible {
    int refCount = 0, enumIndex = 0;
    _IAccessibleImpl objIAccessible;
    _IEnumVARIANTImpl objIEnumVARIANT;
    IAccessible iaccessible;
    DWTEventListener[] accessibleListeners;
    DWTEventListener[] accessibleControlListeners;
    DWTEventListener[] textListeners;
    Object[] variants;
    Control control;

    this(Control control) {
        this.control = control;
        int /*long*/[] ppvObject = new int /*long*/[1];
        /* CreateStdAccessibleObject([in] hwnd, [in] idObject, [in] riidInterface, [out] ppvObject).
         * AddRef has already been called on ppvObject by the callee and must be released by the caller.
         */
        HRESULT result = COM.CreateStdAccessibleObject(control.handle, COM.OBJID_CLIENT, &COM.IIDIAccessible, cast(void**)&iaccessible);
        /* The object needs to be checked, because if the CreateStdAccessibleObject()
         * symbol is not found, the return value is S_OK.
         */
        if (iaccessible is null) return;
        if (result !is COM.S_OK) OLE.error(OLE.ERROR_CANNOT_CREATE_OBJECT, result);

        objIAccessible = new _IAccessibleImpl(this);

//PORTING_FIXME: i don't understand this...
/+
        int /*long*/ ppVtable = objIAccessible.ppVtable;
        int /*long*/[] pVtable = new int /*long*/[1];
        COM.MoveMemory(pVtable, ppVtable, OS.PTR_SIZEOF);
        int /*long*/[] funcs = new int /*long*/[28];
        COM.MoveMemory(funcs, pVtable[0], OS.PTR_SIZEOF * funcs.length);
        funcs[9] = COM.get_accChild_CALLBACK(funcs[9]);
        funcs[10] = COM.get_accName_CALLBACK(funcs[10]);
        funcs[11] = COM.get_accValue_CALLBACK(funcs[11]);
        funcs[12] = COM.get_accDescription_CALLBACK(funcs[12]);
        funcs[13] = COM.get_accRole_CALLBACK(funcs[13]);
        funcs[14] = COM.get_accState_CALLBACK(funcs[14]);
        funcs[15] = COM.get_accHelp_CALLBACK(funcs[15]);
        funcs[16] = COM.get_accHelpTopic_CALLBACK(funcs[16]);
        funcs[17] = COM.get_accKeyboardShortcut_CALLBACK(funcs[17]);
        funcs[20] = COM.get_accDefaultAction_CALLBACK(funcs[20]);
        funcs[21] = COM.accSelect_CALLBACK(funcs[21]);
        funcs[22] = COM.accLocation_CALLBACK(funcs[22]);
        funcs[23] = COM.accNavigate_CALLBACK(funcs[23]);
        funcs[25] = COM.accDoDefaultAction_CALLBACK(funcs[25]);
        funcs[26] = COM.put_accName_CALLBACK(funcs[26]);
        funcs[27] = COM.put_accValue_CALLBACK(funcs[27]);
        COM.MoveMemory(pVtable[0], funcs, OS.PTR_SIZEOF * funcs.length);
+/

        objIEnumVARIANT = new _IEnumVARIANTImpl(this) ;
        AddRef();
    }

    /**
     * Invokes platform specific functionality to allocate a new accessible object.
     * <p>
     * <b>IMPORTANT:</b> This method is <em>not</em> part of the public
     * API for <code>Accessible</code>. It is marked public only so that it
     * can be shared within the packages provided by DWT. It is not
     * available on all platforms, and should never be called from
     * application code.
     * </p>
     *
     * @param control the control to get the accessible object for
     * @return the platform specific accessible object
     */
    public static Accessible internal_new_Accessible(Control control) {
        return new Accessible(control);
    }

    /**
     * Adds the listener to the collection of listeners who will
     * be notified when an accessible client asks for certain strings,
     * such as name, description, help, or keyboard shortcut. The
     * listener is notified by sending it one of the messages defined
     * in the <code>AccessibleListener</code> interface.
     *
     * @param listener the listener that should be notified when the receiver
     * is asked for a name, description, help, or keyboard shortcut string
     *
     * @exception IllegalArgumentException <ul>
     *    <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
     * </ul>
     * @exception DWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver's control has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver's control</li>
     * </ul>
     *
     * @see AccessibleListener
     * @see #removeAccessibleListener
     */
    public void addAccessibleListener(AccessibleListener listener) {
        checkWidget();
        if (listener is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NULL_ARGUMENT);
        accessibleListeners ~= listener;
    }

    /**
     * Adds the listener to the collection of listeners who will
     * be notified when an accessible client asks for custom control
     * specific information. The listener is notified by sending it
     * one of the messages defined in the <code>AccessibleControlListener</code>
     * interface.
     *
     * @param listener the listener that should be notified when the receiver
     * is asked for custom control specific information
     *
     * @exception IllegalArgumentException <ul>
     *    <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
     * </ul>
     * @exception DWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver's control has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver's control</li>
     * </ul>
     *
     * @see AccessibleControlListener
     * @see #removeAccessibleControlListener
     */
    public void addAccessibleControlListener(AccessibleControlListener listener) {
        checkWidget();
        if (listener is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NULL_ARGUMENT);
        accessibleControlListeners ~= listener;
    }

    /**
     * Adds the listener to the collection of listeners who will
     * be notified when an accessible client asks for custom text control
     * specific information. The listener is notified by sending it
     * one of the messages defined in the <code>AccessibleTextListener</code>
     * interface.
     *
     * @param listener the listener that should be notified when the receiver
     * is asked for custom text control specific information
     *
     * @exception IllegalArgumentException <ul>
     *    <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
     * </ul>
     * @exception DWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver's control has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver's control</li>
     * </ul>
     *
     * @see AccessibleTextListener
     * @see #removeAccessibleTextListener
     *
     * @since 3.0
     */
    public void addAccessibleTextListener (AccessibleTextListener listener) {
        checkWidget ();
        if (listener is null) DWT.error (DWT.ERROR_NULL_ARGUMENT);
        textListeners ~= listener;
    }

    /**
     * Returns the control for this Accessible object.
     *
     * @return the receiver's control
     * @since 3.0
     */
    public Control getControl() {
        return control;
    }

    /**
     * Invokes platform specific functionality to dispose an accessible object.
     * <p>
     * <b>IMPORTANT:</b> This method is <em>not</em> part of the public
     * API for <code>Accessible</code>. It is marked public only so that it
     * can be shared within the packages provided by DWT. It is not
     * available on all platforms, and should never be called from
     * application code.
     * </p>
     */
    public void internal_dispose_Accessible() {
        if (iaccessible !is null) {
            iaccessible.Release();
        }
        iaccessible = null;
        Release();
    }

    /**
     * Invokes platform specific functionality to handle a window message.
     * <p>
     * <b>IMPORTANT:</b> This method is <em>not</em> part of the public
     * API for <code>Accessible</code>. It is marked public only so that it
     * can be shared within the packages provided by DWT. It is not
     * available on all platforms, and should never be called from
     * application code.
     * </p>
     */
    public int /*long*/ internal_WM_GETOBJECT (int /*long*/ wParam, int /*long*/ lParam) {
        if (objIAccessible is null) return 0;
        if (lParam is COM.OBJID_CLIENT) {
            /* LresultFromObject([in] riid, [in] wParam, [in] pAcc)
             * The argument pAcc is owned by the caller so reference count does not
             * need to be incremented.
             */
            return COM.LresultFromObject(&COM.IIDIAccessible, wParam, cast(IAccessible)objIAccessible);
        }
        return 0;
    }

    /**
     * Removes the listener from the collection of listeners who will
     * be notified when an accessible client asks for certain strings,
     * such as name, description, help, or keyboard shortcut.
     *
     * @param listener the listener that should no longer be notified when the receiver
     * is asked for a name, description, help, or keyboard shortcut string
     *
     * @exception IllegalArgumentException <ul>
     *    <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
     * </ul>
     * @exception DWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver's control has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver's control</li>
     * </ul>
     *
     * @see AccessibleListener
     * @see #addAccessibleListener
     */
    public void removeAccessibleListener(AccessibleListener listener) {
        checkWidget();
        if (listener is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NULL_ARGUMENT);
        accessibleListeners.length = accessibleListeners.remove(listener);
    }

    /**
     * Removes the listener from the collection of listeners who will
     * be notified when an accessible client asks for custom control
     * specific information.
     *
     * @param listener the listener that should no longer be notified when the receiver
     * is asked for custom control specific information
     *
     * @exception IllegalArgumentException <ul>
     *    <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
     * </ul>
     * @exception DWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver's control has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver's control</li>
     * </ul>
     *
     * @see AccessibleControlListener
     * @see #addAccessibleControlListener
     */
    public void removeAccessibleControlListener(AccessibleControlListener listener) {
        checkWidget();
        if (listener is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NULL_ARGUMENT);
        accessibleControlListeners.length = accessibleControlListeners.remove(listener);
    }

    /**
     * Removes the listener from the collection of listeners who will
     * be notified when an accessible client asks for custom text control
     * specific information.
     *
     * @param listener the listener that should no longer be notified when the receiver
     * is asked for custom text control specific information
     *
     * @exception IllegalArgumentException <ul>
     *    <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
     * </ul>
     * @exception DWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver's control has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver's control</li>
     * </ul>
     *
     * @see AccessibleTextListener
     * @see #addAccessibleTextListener
     *
     * @since 3.0
     */
    public void removeAccessibleTextListener (AccessibleTextListener listener) {
        checkWidget ();
        if (listener is null) DWT.error (DWT.ERROR_NULL_ARGUMENT);
        textListeners.length = textListeners.remove (listener);
    }

    /**
     * Sends a message to accessible clients that the child selection
     * within a custom container control has changed.
     *
     * @exception DWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver's control has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver's control</li>
     * </ul>
     *
     * @since 3.0
     */
    public void selectionChanged () {
        checkWidget();
        COM.NotifyWinEvent (COM.EVENT_OBJECT_SELECTIONWITHIN, control.handle, COM.OBJID_CLIENT, COM.CHILDID_SELF);
    }

    /**
     * Sends a message to accessible clients indicating that the focus
     * has changed within a custom control.
     *
     * @param childID an identifier specifying a child of the control
     *
     * @exception DWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver's control has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver's control</li>
     * </ul>
     */
    public void setFocus(int childID) {
        checkWidget();
        COM.NotifyWinEvent (COM.EVENT_OBJECT_FOCUS, control.handle, COM.OBJID_CLIENT, childIDToOs(childID));
    }

    /**
     * Sends a message to accessible clients that the text
     * caret has moved within a custom control.
     *
     * @param index the new caret index within the control
     *
     * @exception DWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver's control has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver's control</li>
     * </ul>
     *
     * @since 3.0
     */
    public void textCaretMoved (int index) {
        checkWidget();
        COM.NotifyWinEvent (COM.EVENT_OBJECT_LOCATIONCHANGE, control.handle, COM.OBJID_CARET, COM.CHILDID_SELF);
    }

    /**
     * Sends a message to accessible clients that the text
     * within a custom control has changed.
     *
     * @param type the type of change, one of <code>ACC.NOTIFY_TEXT_INSERT</code>
     * or <code>ACC.NOTIFY_TEXT_DELETE</code>
     * @param startIndex the text index within the control where the insertion or deletion begins
     * @param length the non-negative length in characters of the insertion or deletion
     *
     * @exception DWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver's control has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver's control</li>
     * </ul>
     *
     * @see ACC#TEXT_INSERT
     * @see ACC#TEXT_DELETE
     *
     * @since 3.0
     */
    public void textChanged (int type, int startIndex, int length) {
        checkWidget();
        COM.NotifyWinEvent (COM.EVENT_OBJECT_VALUECHANGE, control.handle, COM.OBJID_CLIENT, COM.CHILDID_SELF);
    }

    /**
     * Sends a message to accessible clients that the text
     * selection has changed within a custom control.
     *
     * @exception DWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver's control has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver's control</li>
     * </ul>
     *
     * @since 3.0
     */
    public void textSelectionChanged () {
        checkWidget();
        // not an MSAA event
    }

    /* QueryInterface([in] iid, [out] ppvObject)
     * Ownership of ppvObject transfers from callee to caller so reference count on ppvObject
     * must be incremented before returning.  Caller is responsible for releasing ppvObject.
     */
    HRESULT QueryInterface(REFIID riid, void** ppvObject) {
        if (iaccessible is null) return COM.CO_E_OBJNOTCONNECTED;

        if (COM.IsEqualGUID(riid, &COM.IIDIUnknown)) {
            *ppvObject = cast(void*)cast(IUnknown)  objIAccessible;
            AddRef();
            return COM.S_OK;
        }

        if (COM.IsEqualGUID(riid, &COM.IIDIDispatch)) {
            *ppvObject = cast(void*)cast(IDispatch) objIAccessible;
            AddRef();
            return COM.S_OK;
        }

        if (COM.IsEqualGUID(riid, &COM.IIDIAccessible)) {
            *ppvObject = cast(void*)cast(IAccessible) objIAccessible;
            AddRef();
            return COM.S_OK;
        }

        if (COM.IsEqualGUID(riid, &COM.IIDIEnumVARIANT)) {
            *ppvObject = cast(void*)cast(IEnumVARIANT) objIEnumVARIANT;
            AddRef();
            enumIndex = 0;
            return COM.S_OK;
        }

        HRESULT result = iaccessible.QueryInterface(riid, ppvObject);
        return result;
    }

    ULONG AddRef() {
        refCount++;
        return refCount;
    }

    ULONG Release() {
        refCount--;

        if (refCount is 0) {
            objIAccessible = null;
            objIEnumVARIANT = null;
        }
        return refCount;
    }

    HRESULT accDoDefaultAction(VARIANT variant) {
        if (iaccessible is null) return COM.CO_E_OBJNOTCONNECTED;
        // Currently, we don't let the application override this. Forward to the proxy.
        int code = iaccessible.accDoDefaultAction(variant);
        if (code is COM.E_INVALIDARG) code = COM.S_FALSE; // proxy doesn't know about app childID
        return code;
    }

    HRESULT accHitTest(LONG xLeft, LONG yTop, VARIANT* pvarChild) {
        if (iaccessible is null) return COM.CO_E_OBJNOTCONNECTED;
        if (accessibleControlListeners.length is 0) {
            return iaccessible.accHitTest(xLeft, yTop, pvarChild);
        }

        AccessibleControlEvent event = new AccessibleControlEvent(this);
        event.childID = ACC.CHILDID_NONE;
        event.x = xLeft;
        event.y = yTop;
        for (int i = 0; i < accessibleControlListeners.length; i++) {
            AccessibleControlListener listener = cast(AccessibleControlListener) accessibleControlListeners[i];
            listener.getChildAtPoint(event);
        }
        int childID = event.childID;
        if (childID is ACC.CHILDID_NONE) {
            return iaccessible.accHitTest(xLeft, yTop, pvarChild);
        }
        //TODO - use VARIANT structure
        pvarChild.vt = COM.VT_I4;
        pvarChild.lVal = childIDToOs(childID);
        return COM.S_OK;
    }

    HRESULT accLocation(LONG* pxLeft, LONG* pyTop, LONG* pcxWidth, LONG* pcyHeight, VARIANT variant) {
        if (iaccessible is null) return COM.CO_E_OBJNOTCONNECTED;
        VARIANT* v = &variant;
        //COM.MoveMemory(v, variant, VARIANT.sizeof);
        if ((v.vt & 0xFFFF) !is COM.VT_I4) return COM.E_INVALIDARG;

        /* Get the default location from the OS. */
        int osLeft = 0, osTop = 0, osWidth = 0, osHeight = 0;
        int code = iaccessible.accLocation(pxLeft, pyTop, pcxWidth, pcyHeight, variant);
        if (code is COM.E_INVALIDARG) code = COM.S_FALSE; // proxy doesn't know about app childID
        if (accessibleControlListeners.length is 0) return code;
        if (code is COM.S_OK) {
            int[1] pLeft, pTop, pWidth, pHeight;
            COM.MoveMemory(pLeft.ptr, pxLeft, 4);
            COM.MoveMemory(pTop.ptr, pyTop, 4);
            COM.MoveMemory(pWidth.ptr, pcxWidth, 4);
            COM.MoveMemory(pHeight.ptr, pcyHeight, 4);
            osLeft = pLeft[0]; osTop = pTop[0]; osWidth = pWidth[0]; osHeight = pHeight[0];
        }

        AccessibleControlEvent event = new AccessibleControlEvent(this);
        event.childID = osToChildID(v.lVal);
        event.x = osLeft;
        event.y = osTop;
        event.width = osWidth;
        event.height = osHeight;
        for (int i = 0; i < accessibleControlListeners.length; i++) {
            AccessibleControlListener listener = cast(AccessibleControlListener) accessibleControlListeners[i];
            listener.getLocation(event);
        }
        OS.MoveMemory(pxLeft, &event.x, 4);
        OS.MoveMemory(pyTop, &event.y, 4);
        OS.MoveMemory(pcxWidth, &event.width, 4);
        OS.MoveMemory(pcyHeight, &event.height, 4);
        return COM.S_OK;
    }

    HRESULT accNavigate(LONG navDir, VARIANT variant, VARIANT* pvarEndUpAt) {
        if (iaccessible is null) return COM.CO_E_OBJNOTCONNECTED;
        // Currently, we don't let the application override this. Forward to the proxy.
        int code = iaccessible.accNavigate(navDir, variant, pvarEndUpAt);
        if (code is COM.E_INVALIDARG) code = COM.S_FALSE; // proxy doesn't know about app childID
        return code;
    }

    HRESULT accSelect(LONG flagsSelect, VARIANT variant) {
        if (iaccessible is null) return COM.CO_E_OBJNOTCONNECTED;
        // Currently, we don't let the application override this. Forward to the proxy.
        int code = iaccessible.accSelect(flagsSelect, variant);
        if (code is COM.E_INVALIDARG) code = COM.S_FALSE; // proxy doesn't know about app childID
        return code;
    }

    /* get_accChild([in] varChild, [out] ppdispChild)
     * Ownership of ppdispChild transfers from callee to caller so reference count on ppdispChild
     * must be incremented before returning.  The caller is responsible for releasing ppdispChild.
     */
    HRESULT get_accChild(VARIANT variant, LPDISPATCH* ppdispChild) {
        if (iaccessible is null) return COM.CO_E_OBJNOTCONNECTED;
        VARIANT* v = &variant;
        //COM.MoveMemory(v, variant, VARIANT.sizeof);
        if ((v.vt & 0xFFFF) !is COM.VT_I4) return COM.E_INVALIDARG;
        if (accessibleControlListeners.length is 0) {
            int code = iaccessible.get_accChild(variant, ppdispChild);
            if (code is COM.E_INVALIDARG) code = COM.S_FALSE; // proxy doesn't know about app childID
            return code;
        }

        AccessibleControlEvent event = new AccessibleControlEvent(this);
        event.childID = osToChildID(v.lVal);
        for (int i = 0; i < accessibleControlListeners.length; i++) {
            AccessibleControlListener listener = cast(AccessibleControlListener) accessibleControlListeners[i];
            listener.getChild(event);
        }
        Accessible accessible = event.accessible;
        if (accessible !is null) {
            accessible.AddRef();
            *ppdispChild = accessible.objIAccessible;
            return COM.S_OK;
        }
        return COM.S_FALSE;
    }

    HRESULT get_accChildCount(LONG* pcountChildren) {
        if (iaccessible is null) return COM.CO_E_OBJNOTCONNECTED;

        /* Get the default child count from the OS. */
        int osChildCount = 0;
        int code = iaccessible.get_accChildCount(pcountChildren);
        if (accessibleControlListeners.length is 0) return code;
        if (code is COM.S_OK) {
            int[1] pChildCount;
            COM.MoveMemory(pChildCount.ptr, pcountChildren, 4);
            osChildCount = pChildCount[0];
        }

        AccessibleControlEvent event = new AccessibleControlEvent(this);
        event.childID = ACC.CHILDID_SELF;
        event.detail