2001-09-25 00:48:50 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
2004-04-17 21:52:36 +00:00
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
2001-03-04 02:31:28 +00:00
|
|
|
*
|
2004-04-17 21:52:36 +00:00
|
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
|
|
* 1.1 (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.mozilla.org/MPL/
|
2001-03-04 02:31:28 +00:00
|
|
|
*
|
2001-09-25 00:48:50 +00:00
|
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* License.
|
2001-03-04 02:31:28 +00:00
|
|
|
*
|
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
2004-04-17 21:52:36 +00:00
|
|
|
* The Initial Developer of the Original Code is
|
2001-09-25 00:48:50 +00:00
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
2001-03-04 02:31:28 +00:00
|
|
|
*
|
2001-09-25 00:48:50 +00:00
|
|
|
* Contributor(s):
|
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
2004-04-17 21:52:36 +00:00
|
|
|
* either of the GNU General Public License Version 2 or later (the "GPL"),
|
|
|
|
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
2001-09-25 00:48:50 +00:00
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
2004-04-17 21:52:36 +00:00
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
2001-09-25 00:48:50 +00:00
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
2004-04-17 21:52:36 +00:00
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
2001-09-25 00:48:50 +00:00
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
2001-03-04 02:31:28 +00:00
|
|
|
|
2003-03-20 08:27:31 +00:00
|
|
|
// NOTE: alphabetically ordered
|
|
|
|
#include "nsAccessibilityService.h"
|
|
|
|
#include "nsAccessibleEventData.h"
|
2003-07-09 07:01:46 +00:00
|
|
|
#include "nsCaretAccessible.h"
|
2003-03-20 08:27:31 +00:00
|
|
|
#include "nsHTMLSelectAccessible.h"
|
|
|
|
#include "nsIAccessibleCaret.h"
|
2003-06-26 08:49:18 +00:00
|
|
|
#include "nsIChromeEventHandler.h"
|
2001-04-17 23:06:38 +00:00
|
|
|
#include "nsIDOMElement.h"
|
2001-09-25 08:34:42 +00:00
|
|
|
#include "nsIDOMEventListener.h"
|
2003-03-20 08:27:31 +00:00
|
|
|
#include "nsIDOMEventTarget.h"
|
|
|
|
#include "nsIDOMHTMLAnchorElement.h"
|
|
|
|
#include "nsIDOMHTMLInputElement.h"
|
|
|
|
#include "nsIDOMHTMLSelectElement.h"
|
|
|
|
#include "nsIDOMNSEvent.h"
|
2003-06-26 08:49:18 +00:00
|
|
|
#include "nsIDOMWindow.h"
|
2005-03-02 18:59:41 +00:00
|
|
|
#include "nsIDOMXULMenuListElement.h"
|
2004-06-08 13:59:11 +00:00
|
|
|
#include "nsIDOMXULMultSelectCntrlEl.h"
|
2003-03-20 08:27:31 +00:00
|
|
|
#include "nsIDOMXULSelectCntrlItemEl.h"
|
|
|
|
#include "nsIDocument.h"
|
2005-05-13 14:47:48 +00:00
|
|
|
#include "nsIEventListenerManager.h"
|
2004-10-20 20:22:45 +00:00
|
|
|
#include "nsIHTMLDocument.h"
|
2005-02-18 14:34:30 +00:00
|
|
|
#include "nsIFocusController.h"
|
2003-03-20 08:27:31 +00:00
|
|
|
#include "nsIFrame.h"
|
2001-09-25 08:34:42 +00:00
|
|
|
#include "nsIInterfaceRequestorUtils.h"
|
2001-10-26 23:47:52 +00:00
|
|
|
#include "nsIScriptGlobalObject.h"
|
2002-05-08 20:21:03 +00:00
|
|
|
#include "nsIScrollableView.h"
|
2003-03-20 08:27:31 +00:00
|
|
|
#include "nsIServiceManager.h"
|
|
|
|
#include "nsIViewManager.h"
|
|
|
|
#include "nsLayoutAtoms.h"
|
2003-06-26 08:49:18 +00:00
|
|
|
#include "nsPIDOMWindow.h"
|
2003-03-20 08:27:31 +00:00
|
|
|
#include "nsReadableUtils.h"
|
|
|
|
#include "nsRootAccessible.h"
|
2005-02-01 08:50:50 +00:00
|
|
|
#include "nsIDocShell.h"
|
|
|
|
#include "nsIDocShellTreeItem.h"
|
|
|
|
#include "nsIDocShellTreeOwner.h"
|
|
|
|
#include "nsIBaseWindow.h"
|
|
|
|
|
2003-04-11 00:56:27 +00:00
|
|
|
#ifdef MOZ_XUL
|
2003-03-20 08:27:31 +00:00
|
|
|
#include "nsXULTreeAccessible.h"
|
2003-04-11 00:56:27 +00:00
|
|
|
#include "nsIXULDocument.h"
|
|
|
|
#endif
|
|
|
|
#include "nsAccessibilityService.h"
|
|
|
|
#include "nsISelectionPrivate.h"
|
|
|
|
#include "nsICaret.h"
|
|
|
|
#include "nsIDOMHTMLInputElement.h"
|
|
|
|
#include "nsAccessibleEventData.h"
|
2003-04-15 08:45:55 +00:00
|
|
|
#include "nsIDOMDocument.h"
|
2001-04-17 23:06:38 +00:00
|
|
|
|
2003-04-22 07:38:18 +00:00
|
|
|
#ifdef MOZ_ACCESSIBILITY_ATK
|
|
|
|
#include "nsIAccessibleHyperText.h"
|
|
|
|
#endif
|
|
|
|
|
2001-04-17 23:06:38 +00:00
|
|
|
NS_INTERFACE_MAP_BEGIN(nsRootAccessible)
|
2001-05-11 21:11:38 +00:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIDOMFocusListener)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIDOMFormListener)
|
2001-05-17 21:28:37 +00:00
|
|
|
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMFormListener)
|
|
|
|
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsIDOMEventListener, nsIDOMFormListener)
|
2003-04-01 20:02:51 +00:00
|
|
|
NS_INTERFACE_MAP_END_INHERITING(nsDocAccessible)
|
2001-04-17 23:06:38 +00:00
|
|
|
|
2003-09-07 21:37:51 +00:00
|
|
|
NS_IMPL_ADDREF_INHERITED(nsRootAccessible, nsDocAccessible)
|
|
|
|
NS_IMPL_RELEASE_INHERITED(nsRootAccessible, nsDocAccessible)
|
2001-03-04 02:31:28 +00:00
|
|
|
|
Bug 109851, bug 108629, bug 109921, bug 109977, bug 109153, bug 109187, bug 109213, bug 109221. Check in latest XUL accessibility support - menus, <colorpicker>, <progressmeter>, <groupbox>, mixed states for checkboxes, buttons that can be 'checked' ie pressed down, fixes extra MSAA events being generated, couldn't see HTML content
2001-11-20 02:05:26 +00:00
|
|
|
|
2001-03-04 02:31:28 +00:00
|
|
|
//-----------------------------------------------------
|
|
|
|
// construction
|
|
|
|
//-----------------------------------------------------
|
2003-04-01 20:02:51 +00:00
|
|
|
nsRootAccessible::nsRootAccessible(nsIDOMNode *aDOMNode, nsIWeakReference* aShell):
|
|
|
|
nsDocAccessibleWrap(aDOMNode, aShell),
|
2003-04-15 08:45:55 +00:00
|
|
|
mAccService(do_GetService("@mozilla.org/accessibilityService;1"))
|
2001-03-04 02:31:28 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------
|
|
|
|
// destruction
|
|
|
|
//-----------------------------------------------------
|
|
|
|
nsRootAccessible::~nsRootAccessible()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
// helpers
|
2005-02-01 08:50:50 +00:00
|
|
|
/* readonly attribute AString name; */
|
|
|
|
NS_IMETHODIMP nsRootAccessible::GetName(nsAString& aName)
|
|
|
|
{
|
|
|
|
if (!mDocument) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2005-06-01 14:03:38 +00:00
|
|
|
if (mRoleMapEntry) {
|
|
|
|
nsAccessible::GetName(aName);
|
|
|
|
if (!aName.IsEmpty()) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-02-01 08:50:50 +00:00
|
|
|
nsIScriptGlobalObject *globalScript = mDocument->GetScriptGlobalObject();
|
|
|
|
nsIDocShell *docShell = nsnull;
|
|
|
|
if (globalScript) {
|
|
|
|
docShell = globalScript->GetDocShell();
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> docShellAsItem(do_QueryInterface(docShell));
|
|
|
|
if(!docShellAsItem)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDocShellTreeOwner> treeOwner;
|
|
|
|
docShellAsItem->GetTreeOwner(getter_AddRefs(treeOwner));
|
|
|
|
|
|
|
|
nsCOMPtr<nsIBaseWindow> baseWindow(do_QueryInterface(treeOwner));
|
|
|
|
if (baseWindow) {
|
|
|
|
nsXPIDLString title;
|
|
|
|
baseWindow->GetTitle(getter_Copies(title));
|
|
|
|
aName.Assign(title);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2001-05-11 21:11:38 +00:00
|
|
|
/* readonly attribute nsIAccessible accParent; */
|
2003-07-31 08:09:39 +00:00
|
|
|
NS_IMETHODIMP nsRootAccessible::GetParent(nsIAccessible * *aParent)
|
2001-03-04 02:31:28 +00:00
|
|
|
{
|
2003-07-31 08:09:39 +00:00
|
|
|
*aParent = nsnull;
|
2001-03-04 02:31:28 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2001-05-11 21:11:38 +00:00
|
|
|
/* readonly attribute unsigned long accRole; */
|
2003-07-31 08:09:39 +00:00
|
|
|
NS_IMETHODIMP nsRootAccessible::GetRole(PRUint32 *aRole)
|
2001-03-04 02:31:28 +00:00
|
|
|
{
|
2003-04-15 08:45:55 +00:00
|
|
|
if (!mDocument) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2005-06-01 13:54:08 +00:00
|
|
|
// If it's a <dialog> or <wizard>, use ROLE_DIALOG instead
|
2003-10-22 06:09:48 +00:00
|
|
|
nsIContent *rootContent = mDocument->GetRootContent();
|
2002-03-10 05:12:39 +00:00
|
|
|
if (rootContent) {
|
|
|
|
nsCOMPtr<nsIDOMElement> rootElement(do_QueryInterface(rootContent));
|
|
|
|
if (rootElement) {
|
|
|
|
nsAutoString name;
|
|
|
|
rootElement->GetLocalName(name);
|
2005-06-01 13:54:08 +00:00
|
|
|
if (name.EqualsLiteral("dialog") || name.EqualsLiteral("wizard")) {
|
|
|
|
*aRole = ROLE_DIALOG; // Always at the root
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2002-03-10 05:12:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-06-01 13:54:08 +00:00
|
|
|
return nsDocAccessibleWrap::GetRole(aRole);
|
2001-03-04 02:31:28 +00:00
|
|
|
}
|
2001-04-17 23:06:38 +00:00
|
|
|
|
2004-06-15 02:31:20 +00:00
|
|
|
NS_IMETHODIMP nsRootAccessible::GetState(PRUint32 *aState)
|
|
|
|
{
|
|
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
|
|
if (mDOMNode) {
|
|
|
|
rv = nsDocAccessibleWrap::GetState(aState);
|
|
|
|
}
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_ASSERTION(mDocument, "mDocument should not be null unless mDOMNode is");
|
|
|
|
if (gLastFocusedNode) {
|
|
|
|
nsCOMPtr<nsIDOMDocument> rootAccessibleDoc(do_QueryInterface(mDocument));
|
|
|
|
nsCOMPtr<nsIDOMDocument> focusedDoc;
|
|
|
|
gLastFocusedNode->GetOwnerDocument(getter_AddRefs(focusedDoc));
|
|
|
|
if (rootAccessibleDoc == focusedDoc) {
|
|
|
|
*aState |= STATE_FOCUSED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2003-06-26 08:49:18 +00:00
|
|
|
void
|
|
|
|
nsRootAccessible::GetChromeEventHandler(nsIDOMEventTarget **aChromeTarget)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMWindow> domWin;
|
|
|
|
GetWindow(getter_AddRefs(domWin));
|
|
|
|
nsCOMPtr<nsPIDOMWindow> privateDOMWindow(do_QueryInterface(domWin));
|
|
|
|
nsCOMPtr<nsIChromeEventHandler> chromeEventHandler;
|
|
|
|
if (privateDOMWindow) {
|
2004-05-03 21:48:36 +00:00
|
|
|
chromeEventHandler = privateDOMWindow->GetChromeEventHandler();
|
2003-06-26 08:49:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMEventTarget> target(do_QueryInterface(chromeEventHandler));
|
|
|
|
|
|
|
|
*aChromeTarget = target;
|
|
|
|
NS_IF_ADDREF(*aChromeTarget);
|
|
|
|
}
|
|
|
|
|
2003-07-22 14:55:22 +00:00
|
|
|
nsresult nsRootAccessible::AddEventListeners()
|
2002-05-08 20:21:03 +00:00
|
|
|
{
|
2001-09-25 08:34:42 +00:00
|
|
|
// use AddEventListener from the nsIDOMEventTarget interface
|
Bug 109851, bug 108629, bug 109921, bug 109977, bug 109153, bug 109187, bug 109213, bug 109221. Check in latest XUL accessibility support - menus, <colorpicker>, <progressmeter>, <groupbox>, mixed states for checkboxes, buttons that can be 'checked' ie pressed down, fixes extra MSAA events being generated, couldn't see HTML content
2001-11-20 02:05:26 +00:00
|
|
|
nsCOMPtr<nsIDOMEventTarget> target(do_QueryInterface(mDocument));
|
2001-09-25 08:34:42 +00:00
|
|
|
if (target) {
|
|
|
|
// capture DOM focus events
|
|
|
|
nsresult rv = target->AddEventListener(NS_LITERAL_STRING("focus"), NS_STATIC_CAST(nsIDOMFocusListener*, this), PR_TRUE);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "failed to register listener");
|
|
|
|
|
|
|
|
// capture Form change events
|
2002-10-25 02:00:18 +00:00
|
|
|
rv = target->AddEventListener(NS_LITERAL_STRING("select"), NS_STATIC_CAST(nsIDOMFormListener*, this), PR_TRUE);
|
2001-09-25 08:34:42 +00:00
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "failed to register listener");
|
2002-02-18 07:35:10 +00:00
|
|
|
|
2004-06-02 04:06:28 +00:00
|
|
|
// capture ValueChange events (fired whenever value changes, immediately after, whether focus moves or not)
|
|
|
|
rv = target->AddEventListener(NS_LITERAL_STRING("ValueChange"), NS_STATIC_CAST(nsIDOMXULListener*, this), PR_TRUE);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "failed to register listener");
|
|
|
|
|
2005-03-15 15:00:44 +00:00
|
|
|
// capture AlertActive events (fired whenever alert pops up)
|
|
|
|
rv = target->AddEventListener(NS_LITERAL_STRING("AlertActive"), NS_STATIC_CAST(nsIDOMXULListener*, this), PR_TRUE);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "failed to register listener");
|
|
|
|
|
2004-06-23 19:44:43 +00:00
|
|
|
// add ourself as a OpenStateChange listener (custom event fired in tree.xml)
|
|
|
|
rv = target->AddEventListener(NS_LITERAL_STRING("OpenStateChange"), NS_STATIC_CAST(nsIDOMXULListener*, this), PR_TRUE);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "failed to register listener");
|
|
|
|
|
2001-09-25 08:34:42 +00:00
|
|
|
// add ourself as a CheckboxStateChange listener (custom event fired in nsHTMLInputElement.cpp)
|
2002-12-19 09:35:00 +00:00
|
|
|
rv = target->AddEventListener(NS_LITERAL_STRING("CheckboxStateChange"), NS_STATIC_CAST(nsIDOMXULListener*, this), PR_TRUE);
|
2001-09-25 08:34:42 +00:00
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "failed to register listener");
|
2002-02-18 07:35:10 +00:00
|
|
|
|
|
|
|
// add ourself as a RadioStateChange Listener ( custom event fired in in nsHTMLInputElement.cpp & radio.xml)
|
2002-12-19 09:35:00 +00:00
|
|
|
rv = target->AddEventListener(NS_LITERAL_STRING("RadioStateChange"), NS_STATIC_CAST(nsIDOMXULListener*, this), PR_TRUE);
|
2001-09-25 08:34:42 +00:00
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "failed to register listener");
|
|
|
|
|
2005-02-11 13:18:40 +00:00
|
|
|
rv = target->AddEventListener(NS_LITERAL_STRING("popupshown"), NS_STATIC_CAST(nsIDOMXULListener*, this), PR_TRUE);
|
Bug 109851, bug 108629, bug 109921, bug 109977, bug 109153, bug 109187, bug 109213, bug 109221. Check in latest XUL accessibility support - menus, <colorpicker>, <progressmeter>, <groupbox>, mixed states for checkboxes, buttons that can be 'checked' ie pressed down, fixes extra MSAA events being generated, couldn't see HTML content
2001-11-20 02:05:26 +00:00
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "failed to register listener");
|
|
|
|
|
2005-02-18 14:34:30 +00:00
|
|
|
rv = target->AddEventListener(NS_LITERAL_STRING("popuphiding"), NS_STATIC_CAST(nsIDOMXULListener*, this), PR_TRUE);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "failed to register listener");
|
|
|
|
|
2005-02-11 13:18:40 +00:00
|
|
|
rv = target->AddEventListener(NS_LITERAL_STRING("DOMMenuInactive"), NS_STATIC_CAST(nsIDOMXULListener*, this), PR_TRUE);
|
Bug 109851, bug 108629, bug 109921, bug 109977, bug 109153, bug 109187, bug 109213, bug 109221. Check in latest XUL accessibility support - menus, <colorpicker>, <progressmeter>, <groupbox>, mixed states for checkboxes, buttons that can be 'checked' ie pressed down, fixes extra MSAA events being generated, couldn't see HTML content
2001-11-20 02:05:26 +00:00
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "failed to register listener");
|
|
|
|
|
|
|
|
rv = target->AddEventListener(NS_LITERAL_STRING("DOMMenuItemActive"), NS_STATIC_CAST(nsIDOMXULListener*, this), PR_TRUE);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "failed to register listener");
|
|
|
|
|
2002-07-03 16:38:15 +00:00
|
|
|
rv = target->AddEventListener(NS_LITERAL_STRING("DOMMenuBarActive"), NS_STATIC_CAST(nsIDOMXULListener*, this), PR_TRUE);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "failed to register listener");
|
|
|
|
|
|
|
|
rv = target->AddEventListener(NS_LITERAL_STRING("DOMMenuBarInactive"), NS_STATIC_CAST(nsIDOMXULListener*, this), PR_TRUE);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "failed to register listener");
|
2001-09-25 08:34:42 +00:00
|
|
|
}
|
2003-06-26 08:49:18 +00:00
|
|
|
|
|
|
|
GetChromeEventHandler(getter_AddRefs(target));
|
|
|
|
NS_ASSERTION(target, "No chrome event handler for document");
|
|
|
|
if (target) {
|
|
|
|
// onunload doesn't fire unless we use chrome event handler for target
|
|
|
|
target->AddEventListener(NS_LITERAL_STRING("unload"),
|
|
|
|
NS_STATIC_CAST(nsIDOMXULListener*, this),
|
|
|
|
PR_TRUE);
|
2004-10-20 20:22:45 +00:00
|
|
|
target->AddEventListener(NS_LITERAL_STRING("load"),
|
|
|
|
NS_STATIC_CAST(nsIDOMXULListener*, this),
|
|
|
|
PR_TRUE);
|
2003-06-26 08:49:18 +00:00
|
|
|
}
|
|
|
|
|
2003-04-15 08:45:55 +00:00
|
|
|
if (!mCaretAccessible)
|
2003-07-09 07:01:46 +00:00
|
|
|
mCaretAccessible = new nsCaretAccessible(mDOMNode, mWeakShell, this);
|
2002-06-25 22:54:23 +00:00
|
|
|
|
2005-06-01 14:14:29 +00:00
|
|
|
// Fire accessible focus event for pre-existing focus, but wait until all internal
|
|
|
|
// focus events are finished for window initialization.
|
|
|
|
mFireFocusTimer = do_CreateInstance("@mozilla.org/timer;1");
|
|
|
|
if (mFireFocusTimer) {
|
|
|
|
mFireFocusTimer->InitWithFuncCallback(FireFocusCallback, this,
|
|
|
|
0, nsITimer::TYPE_ONE_SHOT);
|
|
|
|
}
|
|
|
|
|
2003-07-22 14:55:22 +00:00
|
|
|
return nsDocAccessible::AddEventListeners();
|
2001-04-17 23:06:38 +00:00
|
|
|
}
|
|
|
|
|
2003-07-22 14:55:22 +00:00
|
|
|
nsresult nsRootAccessible::RemoveEventListeners()
|
2001-04-17 23:06:38 +00:00
|
|
|
{
|
2003-04-15 08:45:55 +00:00
|
|
|
nsCOMPtr<nsIDOMEventTarget> target(do_QueryInterface(mDocument));
|
|
|
|
if (target) {
|
|
|
|
target->RemoveEventListener(NS_LITERAL_STRING("focus"), NS_STATIC_CAST(nsIDOMFocusListener*, this), PR_TRUE);
|
|
|
|
target->RemoveEventListener(NS_LITERAL_STRING("select"), NS_STATIC_CAST(nsIDOMFormListener*, this), PR_TRUE);
|
2004-06-09 12:48:54 +00:00
|
|
|
target->RemoveEventListener(NS_LITERAL_STRING("ValueChange"), NS_STATIC_CAST(nsIDOMXULListener*, this), PR_TRUE);
|
2005-03-15 15:00:44 +00:00
|
|
|
target->RemoveEventListener(NS_LITERAL_STRING("AlertActive"), NS_STATIC_CAST(nsIDOMXULListener*, this), PR_TRUE);
|
2004-06-23 19:44:43 +00:00
|
|
|
target->RemoveEventListener(NS_LITERAL_STRING("OpenStateChange"), NS_STATIC_CAST(nsIDOMXULListener*, this), PR_TRUE);
|
2003-04-15 08:45:55 +00:00
|
|
|
target->RemoveEventListener(NS_LITERAL_STRING("CheckboxStateChange"), NS_STATIC_CAST(nsIDOMXULListener*, this), PR_TRUE);
|
|
|
|
target->RemoveEventListener(NS_LITERAL_STRING("RadioStateChange"), NS_STATIC_CAST(nsIDOMXULListener*, this), PR_TRUE);
|
2005-02-11 13:18:40 +00:00
|
|
|
target->RemoveEventListener(NS_LITERAL_STRING("popupshown"), NS_STATIC_CAST(nsIDOMXULListener*, this), PR_TRUE);
|
2005-02-18 14:34:30 +00:00
|
|
|
target->RemoveEventListener(NS_LITERAL_STRING("popuphiding"), NS_STATIC_CAST(nsIDOMXULListener*, this), PR_TRUE);
|
2005-02-11 13:18:40 +00:00
|
|
|
target->RemoveEventListener(NS_LITERAL_STRING("DOMMenuInactive"), NS_STATIC_CAST(nsIDOMXULListener*, this), PR_TRUE);
|
2003-04-15 08:45:55 +00:00
|
|
|
target->RemoveEventListener(NS_LITERAL_STRING("DOMMenuItemActive"), NS_STATIC_CAST(nsIDOMXULListener*, this), PR_TRUE);
|
|
|
|
target->RemoveEventListener(NS_LITERAL_STRING("DOMMenuBarActive"), NS_STATIC_CAST(nsIDOMXULListener*, this), PR_TRUE);
|
|
|
|
target->RemoveEventListener(NS_LITERAL_STRING("DOMMenuBarInactive"), NS_STATIC_CAST(nsIDOMXULListener*, this), PR_TRUE);
|
|
|
|
}
|
2002-05-08 20:21:03 +00:00
|
|
|
|
2003-06-26 08:49:18 +00:00
|
|
|
GetChromeEventHandler(getter_AddRefs(target));
|
|
|
|
if (target) {
|
|
|
|
target->RemoveEventListener(NS_LITERAL_STRING("unload"),
|
|
|
|
NS_STATIC_CAST(nsIDOMXULListener*, this),
|
|
|
|
PR_TRUE);
|
2004-10-20 20:22:45 +00:00
|
|
|
target->RemoveEventListener(NS_LITERAL_STRING("load"),
|
|
|
|
NS_STATIC_CAST(nsIDOMXULListener*, this),
|
|
|
|
PR_TRUE);
|
2003-06-26 08:49:18 +00:00
|
|
|
}
|
2003-04-15 08:45:55 +00:00
|
|
|
|
2002-06-25 22:54:23 +00:00
|
|
|
if (mCaretAccessible) {
|
|
|
|
mCaretAccessible->RemoveSelectionListener();
|
|
|
|
mCaretAccessible = nsnull;
|
|
|
|
}
|
2003-02-13 22:56:18 +00:00
|
|
|
|
|
|
|
mAccService = nsnull;
|
|
|
|
|
2003-07-22 14:55:22 +00:00
|
|
|
return nsDocAccessible::RemoveEventListeners();
|
2002-06-25 22:54:23 +00:00
|
|
|
}
|
|
|
|
|
2003-07-22 14:55:22 +00:00
|
|
|
NS_IMETHODIMP nsRootAccessible::GetCaretAccessible(nsIAccessible **aCaretAccessible)
|
2002-06-25 22:54:23 +00:00
|
|
|
{
|
2003-11-15 00:47:12 +00:00
|
|
|
*aCaretAccessible = nsnull;
|
|
|
|
if (mCaretAccessible) {
|
|
|
|
CallQueryInterface(mCaretAccessible, aCaretAccessible);
|
|
|
|
}
|
|
|
|
|
2001-04-17 23:06:38 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2005-02-07 19:43:45 +00:00
|
|
|
void nsRootAccessible::FireAccessibleFocusEvent(nsIAccessible *aAccessible, nsIDOMNode *aNode)
|
Bug 109851, bug 108629, bug 109921, bug 109977, bug 109153, bug 109187, bug 109213, bug 109221. Check in latest XUL accessibility support - menus, <colorpicker>, <progressmeter>, <groupbox>, mixed states for checkboxes, buttons that can be 'checked' ie pressed down, fixes extra MSAA events being generated, couldn't see HTML content
2001-11-20 02:05:26 +00:00
|
|
|
{
|
2005-02-07 19:43:45 +00:00
|
|
|
NS_ASSERTION(aAccessible, "Attempted to fire focus event for no accessible");
|
|
|
|
PRUint32 role = ROLE_NOTHING;
|
|
|
|
aAccessible->GetFinalRole(&role);
|
|
|
|
|
|
|
|
// Fire focus if it changes, but always fire focus events for menu items
|
2005-03-02 18:59:41 +00:00
|
|
|
if (gLastFocusedNode == aNode && role != ROLE_MENUITEM) {
|
|
|
|
return;
|
|
|
|
}
|
2005-02-07 19:43:45 +00:00
|
|
|
|
2005-04-04 01:51:50 +00:00
|
|
|
// Special dynamic content handling
|
|
|
|
PRUint32 naturalRole; // The natural role is the role that this type of element normally has
|
|
|
|
aAccessible->GetRole(&naturalRole);
|
|
|
|
if (role != naturalRole) { // xhtml2:role is being used to override element's natural role
|
2005-02-07 19:43:45 +00:00
|
|
|
FireDHTMLFocusRelatedEvents(aAccessible, role);
|
|
|
|
}
|
2005-03-17 18:33:50 +00:00
|
|
|
|
|
|
|
NS_IF_RELEASE(gLastFocusedNode);
|
|
|
|
gLastFocusedNode = aNode;
|
|
|
|
NS_IF_ADDREF(gLastFocusedNode);
|
|
|
|
|
|
|
|
nsCOMPtr<nsPIAccessible> privateAccessible =
|
|
|
|
do_QueryInterface(aAccessible);
|
|
|
|
privateAccessible->FireToolkitEvent(nsIAccessibleEvent::EVENT_FOCUS,
|
|
|
|
aAccessible, nsnull);
|
|
|
|
if (mCaretAccessible)
|
|
|
|
mCaretAccessible->AttachNewSelectionListener(aNode);
|
|
|
|
}
|
|
|
|
|
|
|
|
void nsRootAccessible::FireDHTMLMenuBarEvents(nsIAccessible *aAccessible, PRUint32 aEvent)
|
|
|
|
{
|
|
|
|
// Will fire EVENT_MENUSTART or EVENT_MENUEND if we're in a menubar
|
|
|
|
PRUint32 containerRole;
|
|
|
|
while (aAccessible) {
|
|
|
|
aAccessible->GetFinalRole(&containerRole);
|
|
|
|
if (containerRole == ROLE_MENUBAR) {
|
|
|
|
nsCOMPtr<nsPIAccessible> privateAccessible = do_QueryInterface(aAccessible);
|
|
|
|
privateAccessible->FireToolkitEvent(aEvent, aAccessible, nsnull);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else if (containerRole != ROLE_MENUPOPUP) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
nsCOMPtr<nsIAccessible> nextParent;
|
|
|
|
aAccessible->GetParent(getter_AddRefs(nextParent));
|
|
|
|
aAccessible = nextParent;
|
|
|
|
}
|
2005-02-07 19:43:45 +00:00
|
|
|
}
|
|
|
|
|
2005-03-17 18:33:50 +00:00
|
|
|
|
2005-02-07 19:43:45 +00:00
|
|
|
void nsRootAccessible::FireDHTMLFocusRelatedEvents(nsIAccessible *aAccessible, PRUint32 aRole)
|
|
|
|
{
|
|
|
|
// Rule set 1: special menu events
|
|
|
|
// Use focus events on DHTML menuitems to indicate when to fire menustart and
|
|
|
|
// menuend for menubars, as well as menupopupstart and menupopupend for popups
|
|
|
|
|
|
|
|
// How menupopupstart/menupopupend events are computed for firing:
|
|
|
|
// We keep track of the last popup the user was in mMenuAccessible.
|
|
|
|
// Store null there if the last thing that was focused was not a menuitem.
|
|
|
|
// If there's a menuitem focus it checks to see if you're still in that menu.
|
|
|
|
// If the new menu != mMenuAccessible, then a menupopupstart is fired
|
|
|
|
// Once something else besides a menuitem is focused, menupopupend is fired,.
|
|
|
|
// the menustart/menuend events are for a menubar.
|
|
|
|
|
|
|
|
// How menustart/menuend events (for menubars) are computed for firing:
|
|
|
|
// Starting from mMenuAccessible, walk up from its chain of menupopup parents
|
|
|
|
// until we're no longer in a menupopup. If that ancestor is a menubar, then fire
|
|
|
|
// a menustart or menuend event, depending on whether we're now focusing a menuitem
|
|
|
|
// or something else.
|
|
|
|
|
2005-03-17 18:33:50 +00:00
|
|
|
nsCOMPtr<nsIAccessible> newMenuAccessible;
|
|
|
|
PRUint32 newMenuRole;
|
2005-02-07 19:43:45 +00:00
|
|
|
if (aRole == ROLE_MENUITEM) {
|
2005-03-17 18:33:50 +00:00
|
|
|
aAccessible->GetParent(getter_AddRefs(newMenuAccessible));
|
|
|
|
if (newMenuAccessible) {
|
|
|
|
newMenuAccessible->GetFinalRole(&newMenuRole);
|
|
|
|
if (newMenuRole != ROLE_MENUPOPUP && newMenuRole != ROLE_MENUBAR) {
|
|
|
|
newMenuAccessible = nsnull; // Menuitem not in a menu
|
|
|
|
}
|
2005-02-07 19:43:45 +00:00
|
|
|
}
|
|
|
|
}
|
2005-03-17 18:33:50 +00:00
|
|
|
if (newMenuAccessible != mMenuAccessible) {
|
|
|
|
if (mMenuAccessible) {
|
|
|
|
// We must synthesize a menupopupend event when a menu was focused and
|
|
|
|
// apparently loses focus (something else gets focus)
|
|
|
|
PRUint32 currentMenuRole;
|
|
|
|
mMenuAccessible->GetFinalRole(¤tMenuRole);
|
|
|
|
if (currentMenuRole == ROLE_MENUPOPUP) {
|
|
|
|
nsCOMPtr<nsPIAccessible> privateAccessible = do_QueryInterface(mMenuAccessible);
|
|
|
|
privateAccessible->FireToolkitEvent(nsIAccessibleEvent::EVENT_MENUPOPUPEND,
|
|
|
|
mMenuAccessible, nsnull);
|
2005-02-07 19:43:45 +00:00
|
|
|
}
|
2005-03-17 18:33:50 +00:00
|
|
|
if (!newMenuAccessible) { // No longer in a menu
|
|
|
|
FireDHTMLMenuBarEvents(mMenuAccessible, nsIAccessibleEvent::EVENT_MENUEND);
|
2005-02-07 19:43:45 +00:00
|
|
|
}
|
|
|
|
}
|
2005-03-17 18:33:50 +00:00
|
|
|
if (newMenuAccessible) {
|
|
|
|
// We must synthesize a menupopupstart event for DHTML when a menu item gets focused
|
|
|
|
// This could be a DHTML menu in which case there will be no DOMMenuActive event to help do this
|
|
|
|
if (!mMenuAccessible) { // Was not in menu
|
|
|
|
FireDHTMLMenuBarEvents(newMenuAccessible, nsIAccessibleEvent::EVENT_MENUSTART);
|
|
|
|
}
|
|
|
|
if (newMenuRole == ROLE_MENUPOPUP) {
|
|
|
|
nsCOMPtr<nsPIAccessible> privateAccessible = do_QueryInterface(newMenuAccessible);
|
|
|
|
privateAccessible->FireToolkitEvent(nsIAccessibleEvent::EVENT_MENUPOPUPSTART,
|
|
|
|
newMenuAccessible, nsnull);
|
|
|
|
}
|
2005-02-07 19:43:45 +00:00
|
|
|
}
|
2005-03-17 18:33:50 +00:00
|
|
|
mMenuAccessible = newMenuAccessible;
|
2005-02-07 19:43:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Rule set 2: selection events that mirror focus events
|
|
|
|
// Mirror selection events to focus, but only for widgets that are selectable
|
|
|
|
// but not a descendent of a multi-selectable widget
|
|
|
|
PRUint32 state;
|
|
|
|
aAccessible->GetFinalState(&state);
|
|
|
|
PRBool isMultiSelectOn = PR_TRUE;
|
|
|
|
if (state & STATE_SELECTABLE) {
|
|
|
|
nsCOMPtr<nsIAccessible> container = aAccessible;
|
2005-03-17 18:33:50 +00:00
|
|
|
PRUint32 containerRole;
|
2005-02-07 19:43:45 +00:00
|
|
|
while (0 == (state & STATE_MULTISELECTABLE)) {
|
|
|
|
nsIAccessible *current = container;
|
|
|
|
current->GetParent(getter_AddRefs(container));
|
|
|
|
if (!container || (NS_SUCCEEDED(container->GetFinalRole(&containerRole)) &&
|
|
|
|
containerRole == ROLE_PANE)) {
|
|
|
|
isMultiSelectOn = PR_FALSE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
container->GetFinalState(&state);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!isMultiSelectOn) {
|
2005-03-17 18:33:50 +00:00
|
|
|
nsCOMPtr<nsPIAccessible> privateAccessible = do_QueryInterface(aAccessible);
|
2005-02-07 19:43:45 +00:00
|
|
|
privateAccessible->FireToolkitEvent(nsIAccessibleEvent::EVENT_SELECTION,
|
|
|
|
aAccessible, nsnull);
|
2002-10-25 02:53:45 +00:00
|
|
|
}
|
Bug 109851, bug 108629, bug 109921, bug 109977, bug 109153, bug 109187, bug 109213, bug 109221. Check in latest XUL accessibility support - menus, <colorpicker>, <progressmeter>, <groupbox>, mixed states for checkboxes, buttons that can be 'checked' ie pressed down, fixes extra MSAA events being generated, couldn't see HTML content
2001-11-20 02:05:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-02-18 14:34:30 +00:00
|
|
|
void nsRootAccessible::FireCurrentFocusEvent()
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMWindow> domWin;
|
|
|
|
GetWindow(getter_AddRefs(domWin));
|
|
|
|
nsCOMPtr<nsPIDOMWindow> privateDOMWindow(do_QueryInterface(domWin));
|
|
|
|
if (!privateDOMWindow) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
nsIFocusController *focusController = privateDOMWindow->GetRootFocusController();
|
|
|
|
if (!focusController) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
nsCOMPtr<nsIDOMElement> focusedElement;
|
|
|
|
focusController->GetFocusedElement(getter_AddRefs(focusedElement));
|
|
|
|
nsCOMPtr<nsIDOMNode> focusedNode(do_QueryInterface(focusedElement));
|
|
|
|
if (!focusedNode) {
|
|
|
|
// Document itself may have focus
|
|
|
|
nsCOMPtr<nsIDOMWindowInternal> focusedWinInternal;
|
|
|
|
focusController->GetFocusedWindow(getter_AddRefs(focusedWinInternal));
|
|
|
|
if (focusedWinInternal) {
|
|
|
|
nsCOMPtr<nsIDOMDocument> focusedDOMDocument;
|
|
|
|
focusedWinInternal->GetDocument(getter_AddRefs(focusedDOMDocument));
|
|
|
|
focusedNode = do_QueryInterface(focusedDOMDocument);
|
|
|
|
}
|
|
|
|
if (!focusedNode) {
|
|
|
|
return; // Could not get a focused document either
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-05-13 14:47:48 +00:00
|
|
|
// Simulate a focus event so that we can reuse code that fires focus for container children like treeitems
|
|
|
|
nsIContent *rootContent = mDocument->GetRootContent();
|
|
|
|
nsPresContext *presContext = GetPresContext();
|
|
|
|
if (rootContent && presContext) {
|
|
|
|
nsCOMPtr<nsIDOMEvent> event;
|
|
|
|
nsCOMPtr<nsIEventListenerManager> manager;
|
|
|
|
rootContent->GetListenerManager(getter_AddRefs(manager));
|
|
|
|
if (manager && NS_SUCCEEDED(manager->CreateEvent(presContext, nsnull,
|
|
|
|
NS_LITERAL_STRING("Events"),
|
|
|
|
getter_AddRefs(event))) &&
|
|
|
|
NS_SUCCEEDED(event->InitEvent(NS_LITERAL_STRING("focus"), PR_TRUE, PR_TRUE))) {
|
|
|
|
HandleEvent(event);
|
|
|
|
}
|
2005-02-18 14:34:30 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-05-11 21:11:38 +00:00
|
|
|
// --------------- nsIDOMEventListener Methods (3) ------------------------
|
2001-04-17 23:06:38 +00:00
|
|
|
|
Landing the XPCDOM_20010329_BRANCH branch, changes mostly done by jband@netscape.com and jst@netscape.com, also some changes done by shaver@mozilla.org, peterv@netscape.com and markh@activestate.com. r= and sr= by vidur@netscape.com, jband@netscape.com, jst@netscpae.com, danm@netscape.com, hyatt@netscape.com, shaver@mozilla.org, dbradley@netscape.com, rpotts@netscape.com.
2001-05-08 16:46:42 +00:00
|
|
|
NS_IMETHODIMP nsRootAccessible::HandleEvent(nsIDOMEvent* aEvent)
|
2001-04-17 23:06:38 +00:00
|
|
|
{
|
2004-06-08 13:59:11 +00:00
|
|
|
// Turn DOM events in accessibility events
|
|
|
|
|
|
|
|
// Get info about event and target
|
2005-02-07 23:11:30 +00:00
|
|
|
nsCOMPtr<nsIDOMNode> targetNode;
|
2003-04-15 08:45:55 +00:00
|
|
|
GetTargetNode(aEvent, getter_AddRefs(targetNode));
|
|
|
|
if (!targetNode)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2004-06-02 04:06:28 +00:00
|
|
|
nsAutoString eventType;
|
|
|
|
aEvent->GetType(eventType);
|
2004-06-08 13:59:11 +00:00
|
|
|
nsAutoString localName;
|
|
|
|
targetNode->GetLocalName(localName);
|
2004-06-02 04:06:28 +00:00
|
|
|
#ifdef DEBUG_aleventhal
|
|
|
|
// Very useful for debugging, please leave this here.
|
2004-06-17 00:13:25 +00:00
|
|
|
if (eventType.LowerCaseEqualsLiteral("dommenuitemactive")) {
|
2004-11-08 02:28:12 +00:00
|
|
|
printf("\ndebugging dommenuitemactive events for %s", NS_ConvertUCS2toUTF8(localName).get());
|
2004-06-02 04:06:28 +00:00
|
|
|
}
|
2004-06-08 13:59:11 +00:00
|
|
|
if (localName.EqualsIgnoreCase("tree")) {
|
2004-11-08 02:28:12 +00:00
|
|
|
printf("\ndebugging events in tree, event is %s", NS_ConvertUCS2toUTF8(eventType).get());
|
2004-06-08 13:59:11 +00:00
|
|
|
}
|
2004-06-02 04:06:28 +00:00
|
|
|
#endif
|
|
|
|
|
2005-04-04 17:26:57 +00:00
|
|
|
nsCOMPtr<nsIPresShell> eventShell = GetPresShellFor(targetNode);
|
2003-09-14 12:56:21 +00:00
|
|
|
|
2003-03-20 08:27:31 +00:00
|
|
|
#ifdef MOZ_ACCESSIBILITY_ATK
|
2003-04-15 08:45:55 +00:00
|
|
|
nsCOMPtr<nsIDOMHTMLAnchorElement> anchorElement(do_QueryInterface(targetNode));
|
|
|
|
if (anchorElement) {
|
|
|
|
nsCOMPtr<nsIDOMNode> blockNode;
|
|
|
|
// For ATK, we don't create any individual object for hyperlink, use its parent who has block frame instead
|
2003-09-14 12:56:21 +00:00
|
|
|
if (NS_SUCCEEDED(nsAccessible::GetParentBlockNode(eventShell, targetNode, getter_AddRefs(blockNode))))
|
|
|
|
targetNode = blockNode;
|
2003-04-15 08:45:55 +00:00
|
|
|
}
|
2003-03-20 08:27:31 +00:00
|
|
|
#endif
|
|
|
|
|
2004-11-08 02:29:47 +00:00
|
|
|
if (!eventShell) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (eventType.LowerCaseEqualsLiteral("unload")) {
|
|
|
|
// Only get cached accessible for unload -- so that we don't create it
|
|
|
|
// just to destroy it.
|
|
|
|
nsCOMPtr<nsIWeakReference> weakShell(do_GetWeakReference(eventShell));
|
2005-04-04 17:26:57 +00:00
|
|
|
nsCOMPtr<nsIAccessibleDocument> accessibleDoc =
|
|
|
|
nsAccessNode::GetDocAccessibleFor(weakShell);
|
2004-11-08 02:29:47 +00:00
|
|
|
nsCOMPtr<nsPIAccessibleDocument> privateAccDoc = do_QueryInterface(accessibleDoc);
|
|
|
|
if (privateAccDoc) {
|
|
|
|
privateAccDoc->Destroy();
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2003-04-28 10:24:52 +00:00
|
|
|
nsCOMPtr<nsIAccessible> accessible;
|
2004-11-08 02:29:47 +00:00
|
|
|
if (NS_FAILED(mAccService->GetAccessibleInShell(targetNode, eventShell,
|
2003-04-15 08:45:55 +00:00
|
|
|
getter_AddRefs(accessible))))
|
|
|
|
return NS_OK;
|
|
|
|
|
2003-04-11 00:56:27 +00:00
|
|
|
#ifdef MOZ_XUL
|
2003-04-15 08:45:55 +00:00
|
|
|
// If it's a tree element, need the currently selected item
|
|
|
|
nsCOMPtr<nsIAccessible> treeItemAccessible;
|
2004-06-08 13:59:11 +00:00
|
|
|
if (localName.EqualsLiteral("tree")) {
|
|
|
|
nsCOMPtr<nsIDOMXULMultiSelectControlElement> multiSelect =
|
|
|
|
do_QueryInterface(targetNode);
|
|
|
|
if (multiSelect) {
|
|
|
|
PRInt32 treeIndex = -1;
|
|
|
|
multiSelect->GetCurrentIndex(&treeIndex);
|
|
|
|
if (treeIndex >= 0) {
|
2004-06-16 06:19:12 +00:00
|
|
|
nsCOMPtr<nsIAccessibleTreeCache> treeCache(do_QueryInterface(accessible));
|
|
|
|
if (!treeCache ||
|
|
|
|
NS_FAILED(treeCache->GetCachedTreeitemAccessible(
|
|
|
|
treeIndex,
|
|
|
|
nsnull,
|
|
|
|
getter_AddRefs(treeItemAccessible))) ||
|
2004-06-23 19:44:43 +00:00
|
|
|
!treeItemAccessible) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
accessible = treeItemAccessible;
|
2002-09-17 03:51:40 +00:00
|
|
|
}
|
2002-05-13 07:19:43 +00:00
|
|
|
}
|
2003-04-15 08:45:55 +00:00
|
|
|
}
|
2003-04-11 00:56:27 +00:00
|
|
|
#endif
|
2002-05-13 07:19:43 +00:00
|
|
|
|
2003-07-09 07:01:46 +00:00
|
|
|
nsCOMPtr<nsPIAccessible> privAcc(do_QueryInterface(accessible));
|
2001-05-11 21:11:38 +00:00
|
|
|
|
2002-07-05 06:20:15 +00:00
|
|
|
#ifndef MOZ_ACCESSIBILITY_ATK
|
2003-04-11 00:56:27 +00:00
|
|
|
#ifdef MOZ_XUL
|
2003-04-15 08:45:55 +00:00
|
|
|
// tree event
|
2005-05-13 14:47:48 +00:00
|
|
|
if (treeItemAccessible) {
|
|
|
|
if (eventType.LowerCaseEqualsLiteral("focus")) {
|
|
|
|
FireAccessibleFocusEvent(accessible, targetNode); // Tree has focus
|
|
|
|
}
|
|
|
|
else if (eventType.LowerCaseEqualsLiteral("dommenuitemactive") ||
|
|
|
|
eventType.LowerCaseEqualsLiteral("select")) {
|
|
|
|
if (gLastFocusedNode == targetNode) {
|
|
|
|
privAcc->FireToolkitEvent(nsIAccessibleEvent::EVENT_FOCUS,
|
|
|
|
treeItemAccessible, nsnull);
|
|
|
|
}
|
|
|
|
privAcc->FireToolkitEvent(nsIAccessibleEvent::EVENT_SELECTION,
|
|
|
|
treeItemAccessible, nsnull);
|
|
|
|
}
|
2003-04-15 08:45:55 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2005-04-26 16:14:00 +00:00
|
|
|
else
|
2003-04-11 00:56:27 +00:00
|
|
|
#endif
|
2005-04-26 16:14:00 +00:00
|
|
|
if (eventType.LowerCaseEqualsLiteral("dommenuitemactive")) {
|
2005-02-07 23:11:30 +00:00
|
|
|
nsCOMPtr<nsIAccessible> containerAccessible = accessible;
|
|
|
|
PRUint32 containerState = 0;
|
|
|
|
do {
|
|
|
|
nsIAccessible *tempAccessible = containerAccessible;
|
|
|
|
tempAccessible->GetParent(getter_AddRefs(containerAccessible));
|
|
|
|
if (!containerAccessible) {
|
|
|
|
break;
|
2002-02-18 07:35:10 +00:00
|
|
|
}
|
2005-02-07 23:11:30 +00:00
|
|
|
containerAccessible->GetFinalState(&containerState);
|
2002-09-17 03:51:40 +00:00
|
|
|
}
|
2005-02-07 23:11:30 +00:00
|
|
|
while ((containerState & STATE_HASPOPUP) == 0);
|
|
|
|
|
|
|
|
// Only fire focus event for DOMMenuItemActive is not inside collapsed popup
|
|
|
|
if (0 == (containerState & STATE_COLLAPSED)) {
|
2003-04-15 08:45:55 +00:00
|
|
|
FireAccessibleFocusEvent(accessible, targetNode);
|
2005-02-07 23:11:30 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (eventType.LowerCaseEqualsLiteral("focus")) {
|
2005-03-02 18:59:41 +00:00
|
|
|
nsCOMPtr<nsIDOMXULSelectControlElement> selectControl =
|
|
|
|
do_QueryInterface(targetNode);
|
|
|
|
// Send focus to individual radio button or selected item
|
|
|
|
if (selectControl) {
|
|
|
|
nsCOMPtr<nsIDOMXULMenuListElement> menuList =
|
|
|
|
do_QueryInterface(targetNode);
|
|
|
|
if (!menuList) {
|
|
|
|
// Don't do this for menu lists, the items only get focused
|
|
|
|
// when the list is open, based on DOMMenuitemActive events
|
|
|
|
nsCOMPtr<nsIDOMXULSelectControlItemElement> selectedItem;
|
|
|
|
selectControl->GetSelectedItem(getter_AddRefs(selectedItem));
|
2005-06-01 14:03:38 +00:00
|
|
|
if (selectedItem) {
|
|
|
|
targetNode = do_QueryInterface(selectedItem);
|
|
|
|
}
|
2005-03-02 18:59:41 +00:00
|
|
|
|
|
|
|
if (!targetNode ||
|
|
|
|
NS_FAILED(mAccService->GetAccessibleInShell(targetNode, eventShell,
|
|
|
|
getter_AddRefs(accessible)))) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-02-07 23:11:30 +00:00
|
|
|
FireAccessibleFocusEvent(accessible, targetNode);
|
2003-04-15 08:45:55 +00:00
|
|
|
}
|
2004-06-17 00:13:25 +00:00
|
|
|
else if (eventType.LowerCaseEqualsLiteral("valuechange")) {
|
2004-06-02 04:06:28 +00:00
|
|
|
privAcc->FireToolkitEvent(nsIAccessibleEvent::EVENT_VALUE_CHANGE,
|
|
|
|
accessible, nsnull);
|
|
|
|
}
|
2005-03-15 15:00:44 +00:00
|
|
|
else if (eventType.EqualsLiteral("AlertActive")) {
|
|
|
|
privAcc->FireToolkitEvent(nsIAccessibleEvent::EVENT_ALERT,
|
|
|
|
accessible, nsnull);
|
|
|
|
}
|
2004-06-23 19:44:43 +00:00
|
|
|
else if (eventType.LowerCaseEqualsLiteral("checkboxstatechange") ||
|
|
|
|
eventType.LowerCaseEqualsLiteral("openstatechange")) {
|
|
|
|
privAcc->FireToolkitEvent(nsIAccessibleEvent::EVENT_STATE_CHANGE,
|
|
|
|
accessible, nsnull);
|
|
|
|
}
|
2004-06-17 00:13:25 +00:00
|
|
|
else if (eventType.LowerCaseEqualsLiteral("radiostatechange") ) {
|
2003-04-15 08:45:55 +00:00
|
|
|
// first the XUL radio buttons
|
|
|
|
if (targetNode &&
|
|
|
|
NS_SUCCEEDED(mAccService->GetAccessibleInShell(targetNode, eventShell,
|
|
|
|
getter_AddRefs(accessible)))) {
|
2003-07-22 14:55:22 +00:00
|
|
|
privAcc->FireToolkitEvent(nsIAccessibleEvent::EVENT_STATE_CHANGE,
|
2003-07-09 07:01:46 +00:00
|
|
|
accessible, nsnull);
|
2003-04-15 08:45:55 +00:00
|
|
|
FireAccessibleFocusEvent(accessible, targetNode);
|
2002-09-17 03:51:40 +00:00
|
|
|
}
|
2003-04-15 08:45:55 +00:00
|
|
|
else { // for the html radio buttons -- apparently the focus code just works. :-)
|
2003-07-22 14:55:22 +00:00
|
|
|
privAcc->FireToolkitEvent(nsIAccessibleEvent::EVENT_STATE_CHANGE,
|
2003-07-09 07:01:46 +00:00
|
|
|
accessible, nsnull);
|
2002-09-17 03:51:40 +00:00
|
|
|
}
|
2003-04-15 08:45:55 +00:00
|
|
|
}
|
2004-06-17 00:13:25 +00:00
|
|
|
else if (eventType.LowerCaseEqualsLiteral("dommenubaractive"))
|
2003-07-22 14:55:22 +00:00
|
|
|
privAcc->FireToolkitEvent(nsIAccessibleEvent::EVENT_MENUSTART, accessible, nsnull);
|
2004-06-17 00:13:25 +00:00
|
|
|
else if (eventType.LowerCaseEqualsLiteral("dommenubarinactive")) {
|
2003-07-22 14:55:22 +00:00
|
|
|
privAcc->FireToolkitEvent(nsIAccessibleEvent::EVENT_MENUEND, accessible, nsnull);
|
2005-02-18 14:34:30 +00:00
|
|
|
FireCurrentFocusEvent();
|
|
|
|
}
|
|
|
|
else if (eventType.LowerCaseEqualsLiteral("popuphiding")) {
|
|
|
|
// If accessible focus was inside popup that closes,
|
|
|
|
// then restore it to true current focus.
|
|
|
|
// This is the case when we've been getting DOMMenuItemActive events
|
|
|
|
// inside of a combo box that closes. The real focus is on the combo box.
|
|
|
|
if (!gLastFocusedNode) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
nsCOMPtr<nsIDOMNode> parentOfFocus;
|
|
|
|
gLastFocusedNode->GetParentNode(getter_AddRefs(parentOfFocus));
|
|
|
|
if (parentOfFocus != targetNode) {
|
|
|
|
return NS_OK;
|
2002-09-17 03:51:40 +00:00
|
|
|
}
|
2005-02-18 14:34:30 +00:00
|
|
|
// Focus was inside of popup that's being hidden
|
|
|
|
FireCurrentFocusEvent();
|
2003-04-15 08:45:55 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
// Menu popup events
|
|
|
|
PRUint32 menuEvent = 0;
|
2005-02-11 13:18:40 +00:00
|
|
|
if (eventType.LowerCaseEqualsLiteral("popupshown")) {
|
2003-07-22 14:55:22 +00:00
|
|
|
menuEvent = nsIAccessibleEvent::EVENT_MENUPOPUPSTART;
|
2005-02-11 13:18:40 +00:00
|
|
|
}
|
|
|
|
else if (eventType.EqualsLiteral("DOMMenuInactive")) {
|
2003-07-22 14:55:22 +00:00
|
|
|
menuEvent = nsIAccessibleEvent::EVENT_MENUPOPUPEND;
|
2005-02-11 13:18:40 +00:00
|
|
|
}
|
2003-04-15 08:45:55 +00:00
|
|
|
if (menuEvent) {
|
|
|
|
PRUint32 role = ROLE_NOTHING;
|
2003-07-31 08:09:39 +00:00
|
|
|
accessible->GetRole(&role);
|
2003-04-15 08:45:55 +00:00
|
|
|
if (role == ROLE_MENUPOPUP)
|
2003-07-09 07:01:46 +00:00
|
|
|
privAcc->FireToolkitEvent(menuEvent, accessible, nsnull);
|
2002-10-25 02:50:24 +00:00
|
|
|
}
|
2003-04-15 08:45:55 +00:00
|
|
|
}
|
2002-07-05 06:20:15 +00:00
|
|
|
#else
|
2003-04-15 08:45:55 +00:00
|
|
|
AtkStateChange stateData;
|
2004-11-08 02:29:47 +00:00
|
|
|
if (eventType.EqualsIgnoreCase("load")) {
|
2004-10-20 20:22:45 +00:00
|
|
|
nsCOMPtr<nsIHTMLDocument> htmlDoc(do_QueryInterface(targetNode));
|
|
|
|
if (htmlDoc) {
|
|
|
|
privAcc->FireToolkitEvent(nsIAccessibleEvent::EVENT_REORDER,
|
|
|
|
accessible, nsnull);
|
|
|
|
}
|
|
|
|
}
|
2004-06-17 00:13:25 +00:00
|
|
|
else if (eventType.LowerCaseEqualsLiteral("focus") ||
|
|
|
|
eventType.LowerCaseEqualsLiteral("dommenuitemactive")) {
|
2003-07-09 07:01:46 +00:00
|
|
|
if (treeItemAccessible) { // use focused treeitem
|
|
|
|
privAcc = do_QueryInterface(treeItemAccessible);
|
2003-07-22 14:55:22 +00:00
|
|
|
privAcc->FireToolkitEvent(nsIAccessibleEvent::EVENT_FOCUS,
|
2003-07-09 07:01:46 +00:00
|
|
|
treeItemAccessible, nsnull);
|
|
|
|
}
|
2003-04-15 08:45:55 +00:00
|
|
|
else if (anchorElement) {
|
|
|
|
nsCOMPtr<nsIAccessibleHyperText> hyperText(do_QueryInterface(accessible));
|
|
|
|
if (hyperText) {
|
|
|
|
PRInt32 selectedLink;
|
|
|
|
hyperText->GetSelectedLinkIndex(&selectedLink);
|
2003-07-22 14:55:22 +00:00
|
|
|
privAcc->FireToolkitEvent(nsIAccessibleEvent::EVENT_ATK_LINK_SELECTED, accessible, &selectedLink);
|
2003-03-20 08:48:19 +00:00
|
|
|
}
|
2002-09-17 03:51:40 +00:00
|
|
|
}
|
2003-04-15 08:45:55 +00:00
|
|
|
else
|
2002-09-17 03:51:40 +00:00
|
|
|
FireAccessibleFocusEvent(accessible, targetNode);
|
2003-04-15 08:45:55 +00:00
|
|
|
}
|
2004-06-17 00:13:25 +00:00
|
|
|
else if (eventType.LowerCaseEqualsLiteral("select")) {
|
2004-06-08 13:59:11 +00:00
|
|
|
if (treeItemAccessible) { // it's a XUL <tree>
|
2003-04-15 08:45:55 +00:00
|
|
|
// use EVENT_FOCUS instead of EVENT_ATK_SELECTION_CHANGE
|
2003-07-09 07:01:46 +00:00
|
|
|
privAcc = do_QueryInterface(treeItemAccessible);
|
2003-07-22 14:55:22 +00:00
|
|
|
privAcc->FireToolkitEvent(nsIAccessibleEvent::EVENT_FOCUS,
|
2003-07-09 07:01:46 +00:00
|
|
|
treeItemAccessible, nsnull);
|
2004-06-17 00:13:25 +00:00
|
|
|
}
|
2003-04-15 08:45:55 +00:00
|
|
|
}
|
2004-06-02 04:06:28 +00:00
|
|
|
#if 0
|
|
|
|
// XXX todo: value change events for ATK are done with
|
|
|
|
// AtkPropertyChange, PROP_VALUE. Need the old and new value.
|
|
|
|
// Not sure how we'll get the old value.
|
2005-02-07 23:11:30 +00:00
|
|
|
// Aaron: I think this is a problem with the ATK API -- it's much harder to
|
|
|
|
// grab the old value for all the application developers than it is for
|
|
|
|
// AT's to cache old values when they need to (when would that be!?)
|
2004-06-17 00:13:25 +00:00
|
|
|
else if (eventType.LowerCaseEqualsLiteral("valuechange")) {
|
2004-06-02 04:06:28 +00:00
|
|
|
privAcc->FireToolkitEvent(nsIAccessibleEvent::EVENT_VALUE_CHANGE,
|
|
|
|
accessible, nsnull);
|
|
|
|
}
|
|
|
|
#endif
|
2004-06-17 00:13:25 +00:00
|
|
|
else if (eventType.LowerCaseEqualsLiteral("checkboxstatechange") || // it's a XUL <checkbox>
|
|
|
|
eventType.LowerCaseEqualsLiteral("radiostatechange")) { // it's a XUL <radio>
|
2005-01-28 04:21:05 +00:00
|
|
|
accessible->GetFinalState(&stateData.state);
|
2003-04-15 08:45:55 +00:00
|
|
|
stateData.enable = (stateData.state & STATE_CHECKED) != 0;
|
|
|
|
stateData.state = STATE_CHECKED;
|
2003-07-22 14:55:22 +00:00
|
|
|
privAcc->FireToolkitEvent(nsIAccessibleEvent::EVENT_STATE_CHANGE, accessible, &stateData);
|
2004-06-17 00:13:25 +00:00
|
|
|
if (eventType.LowerCaseEqualsLiteral("radiostatechange")) {
|
2002-09-17 03:51:40 +00:00
|
|
|
FireAccessibleFocusEvent(accessible, targetNode);
|
2003-04-15 08:45:55 +00:00
|
|
|
}
|
2001-05-11 21:11:38 +00:00
|
|
|
}
|
2004-06-23 19:44:43 +00:00
|
|
|
else if (eventType.LowerCaseEqualsLiteral("openstatechange")) { // collapsed/expanded changed
|
2005-01-28 04:21:05 +00:00
|
|
|
accessible->GetFinalState(&stateData.state);
|
2004-06-23 19:44:43 +00:00
|
|
|
stateData.enable = (stateData.state & STATE_EXPANDED) != 0;
|
|
|
|
stateData.state = STATE_EXPANDED;
|
|
|
|
privAcc->FireToolkitEvent(nsIAccessibleEvent::EVENT_STATE_CHANGE, accessible, &stateData);
|
|
|
|
}
|
2005-02-18 14:34:30 +00:00
|
|
|
else if (eventType.LowerCaseEqualsLiteral("popuphiding")) {
|
|
|
|
// If accessible focus was inside popup that closes,
|
|
|
|
// then restore it to true current focus.
|
|
|
|
// This is the case when we've been getting DOMMenuItemActive events
|
|
|
|
// inside of a combo box that closes. The real focus is on the combo box.
|
|
|
|
if (!gLastFocusedNode) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
nsCOMPtr<nsIDOMNode> parentOfFocus;
|
|
|
|
gLastFocusedNode->GetParentNode(getter_AddRefs(parentOfFocus));
|
|
|
|
if (parentOfFocus != targetNode) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
// Focus was inside of popup that's being hidden
|
|
|
|
FireCurrentFocusEvent();
|
|
|
|
}
|
2005-02-11 13:18:40 +00:00
|
|
|
else if (eventType.LowerCaseEqualsLiteral("popupshown")) {
|
2003-04-15 08:45:55 +00:00
|
|
|
FireAccessibleFocusEvent(accessible, targetNode);
|
2003-09-14 12:56:21 +00:00
|
|
|
}
|
2005-02-11 13:18:40 +00:00
|
|
|
else if (eventType.EqualsLiteral("DOMMenuInactive")) {
|
|
|
|
//FireAccessibleFocusEvent(accessible, targetNode); // Not yet used in ATK
|
2003-09-14 12:56:21 +00:00
|
|
|
}
|
2003-04-15 08:45:55 +00:00
|
|
|
#endif
|
2001-05-11 21:11:38 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2001-04-17 23:06:38 +00:00
|
|
|
|
2003-04-01 20:02:51 +00:00
|
|
|
void nsRootAccessible::GetTargetNode(nsIDOMEvent *aEvent, nsIDOMNode **aTargetNode)
|
2001-08-14 06:01:48 +00:00
|
|
|
{
|
2003-04-01 20:02:51 +00:00
|
|
|
*aTargetNode = nsnull;
|
|
|
|
|
2001-12-06 06:57:03 +00:00
|
|
|
nsCOMPtr<nsIDOMNSEvent> nsevent(do_QueryInterface(aEvent));
|
|
|
|
|
|
|
|
if (nsevent) {
|
2003-11-15 00:47:12 +00:00
|
|
|
nsCOMPtr<nsIDOMEventTarget> domEventTarget;
|
2001-12-06 06:57:03 +00:00
|
|
|
nsevent->GetOriginalTarget(getter_AddRefs(domEventTarget));
|
2004-06-02 04:06:28 +00:00
|
|
|
nsCOMPtr<nsIContent> content(do_QueryInterface(domEventTarget));
|
2004-06-15 02:31:20 +00:00
|
|
|
nsIContent *bindingParent;
|
|
|
|
if (content && content->IsContentOfType(nsIContent::eHTML) &&
|
|
|
|
(bindingParent = content->GetBindingParent()) != nsnull) {
|
|
|
|
// Use binding parent when the event occurs in
|
|
|
|
// anonymous HTML content.
|
|
|
|
// This gets the following important cases correct:
|
2004-06-02 04:06:28 +00:00
|
|
|
// 1. Inserted <dialog> buttons like OK, Cancel, Help.
|
|
|
|
// 2. XUL menulists and comboboxes.
|
|
|
|
// 3. The focused radio button in a group.
|
2004-06-15 02:31:20 +00:00
|
|
|
CallQueryInterface(bindingParent, aTargetNode);
|
|
|
|
NS_ASSERTION(*aTargetNode, "No target node for binding parent of anonymous event target");
|
|
|
|
return;
|
2004-06-02 04:06:28 +00:00
|
|
|
}
|
2003-11-15 00:47:12 +00:00
|
|
|
if (domEventTarget) {
|
|
|
|
CallQueryInterface(domEventTarget, aTargetNode);
|
|
|
|
}
|
2001-12-06 06:57:03 +00:00
|
|
|
}
|
2001-08-14 06:01:48 +00:00
|
|
|
}
|
|
|
|
|
2005-06-01 14:14:29 +00:00
|
|
|
void nsRootAccessible::FireFocusCallback(nsITimer *aTimer, void *aClosure)
|
|
|
|
{
|
|
|
|
nsRootAccessible *rootAccessible = NS_STATIC_CAST(nsRootAccessible*, aClosure);
|
|
|
|
NS_ASSERTION(rootAccessible, "How did we get here without a root accessible?");
|
|
|
|
rootAccessible->FireCurrentFocusEvent();
|
|
|
|
}
|
|
|
|
|
2001-06-30 00:25:09 +00:00
|
|
|
// ------- nsIDOMFocusListener Methods (1) -------------
|
2001-05-17 21:28:37 +00:00
|
|
|
|
2001-05-11 21:11:38 +00:00
|
|
|
NS_IMETHODIMP nsRootAccessible::Focus(nsIDOMEvent* aEvent)
|
|
|
|
{
|
|
|
|
return HandleEvent(aEvent);
|
|
|
|
}
|
2001-04-17 23:06:38 +00:00
|
|
|
|
2002-06-25 05:04:17 +00:00
|
|
|
NS_IMETHODIMP nsRootAccessible::Blur(nsIDOMEvent* aEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2001-04-17 23:06:38 +00:00
|
|
|
|
2001-05-11 21:11:38 +00:00
|
|
|
// ------- nsIDOMFormListener Methods (5) -------------
|
2001-05-17 21:28:37 +00:00
|
|
|
|
2002-06-25 05:04:17 +00:00
|
|
|
NS_IMETHODIMP nsRootAccessible::Submit(nsIDOMEvent* aEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2001-04-17 23:06:38 +00:00
|
|
|
|
2002-06-25 05:04:17 +00:00
|
|
|
NS_IMETHODIMP nsRootAccessible::Reset(nsIDOMEvent* aEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2001-04-17 23:06:38 +00:00
|
|
|
|
2001-05-11 21:11:38 +00:00
|
|
|
NS_IMETHODIMP nsRootAccessible::Change(nsIDOMEvent* aEvent)
|
|
|
|
{
|
|
|
|
// get change events when the form elements changes its state, checked->not,
|
2003-04-15 08:45:55 +00:00
|
|
|
// deleted text, new text, change in selection for list/combo boxes
|
2001-05-17 21:28:37 +00:00
|
|
|
// this may be the event that we have the individual Accessible objects
|
2003-04-15 08:45:55 +00:00
|
|
|
// handle themselves -- have list/combos figure out the change in selection
|
|
|
|
// have textareas and inputs fire a change of state etc...
|
2002-10-25 02:00:18 +00:00
|
|
|
return NS_OK; // Ignore form change events in MSAA
|
2001-04-17 23:06:38 +00:00
|
|
|
}
|
|
|
|
|
2001-05-17 21:28:37 +00:00
|
|
|
// gets Select events when text is selected in a textarea or input
|
2002-05-13 07:19:43 +00:00
|
|
|
NS_IMETHODIMP nsRootAccessible::Select(nsIDOMEvent* aEvent)
|
|
|
|
{
|
|
|
|
return HandleEvent(aEvent);
|
|
|
|
}
|
2001-05-11 21:11:38 +00:00
|
|
|
|
2001-05-17 21:28:37 +00:00
|
|
|
// gets Input events when text is entered or deleted in a textarea or input
|
2002-06-25 05:04:17 +00:00
|
|
|
NS_IMETHODIMP nsRootAccessible::Input(nsIDOMEvent* aEvent)
|
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2001-05-11 21:11:38 +00:00
|
|
|
|
Bug 109851, bug 108629, bug 109921, bug 109977, bug 109153, bug 109187, bug 109213, bug 109221. Check in latest XUL accessibility support - menus, <colorpicker>, <progressmeter>, <groupbox>, mixed states for checkboxes, buttons that can be 'checked' ie pressed down, fixes extra MSAA events being generated, couldn't see HTML content
2001-11-20 02:05:26 +00:00
|
|
|
// ------- nsIDOMXULListener Methods (8) ---------------
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsRootAccessible::PopupShowing(nsIDOMEvent* aEvent) { return NS_OK; }
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsRootAccessible::PopupShown(nsIDOMEvent* aEvent) { return NS_OK; }
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsRootAccessible::PopupHiding(nsIDOMEvent* aEvent) { return NS_OK; }
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsRootAccessible::PopupHidden(nsIDOMEvent* aEvent) { return NS_OK; }
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsRootAccessible::Close(nsIDOMEvent* aEvent) { return NS_OK; }
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsRootAccessible::Command(nsIDOMEvent* aEvent) { return NS_OK; }
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsRootAccessible::Broadcast(nsIDOMEvent* aEvent) { return NS_OK; }
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsRootAccessible::CommandUpdate(nsIDOMEvent* aEvent) { return NS_OK; }
|
|
|
|
|
2003-04-01 20:02:51 +00:00
|
|
|
NS_IMETHODIMP nsRootAccessible::Shutdown()
|
2001-06-30 00:25:09 +00:00
|
|
|
{
|
2003-04-01 20:02:51 +00:00
|
|
|
// Called manually or by nsAccessNode::~nsAccessNode()
|
2003-04-15 08:45:55 +00:00
|
|
|
if (!mWeakShell) {
|
|
|
|
return NS_OK; // Already shutdown
|
2001-10-02 21:36:38 +00:00
|
|
|
}
|
2005-02-07 19:43:45 +00:00
|
|
|
mMenuAccessible = nsnull;
|
2003-04-15 08:45:55 +00:00
|
|
|
mCaretAccessible = nsnull;
|
|
|
|
mAccService = nsnull;
|
2005-06-01 14:14:29 +00:00
|
|
|
if (mFireEventTimer) {
|
|
|
|
mFireFocusTimer->Cancel();
|
|
|
|
mFireFocusTimer = nsnull;
|
|
|
|
}
|
2001-06-30 00:25:09 +00:00
|
|
|
|
2003-04-01 20:02:51 +00:00
|
|
|
return nsDocAccessibleWrap::Shutdown();
|
2001-06-30 00:25:09 +00:00
|
|
|
}
|
|
|
|
|