accessible/src/base/nsAccessNode.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 2003
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   Original Author: Aaron Leventhal (aaronl@netscape.com)
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either of the GNU General Public License Version 2 or later (the "GPL"),
  27  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 #include "nsAccessNode.h"
  40 #include "nsIAccessible.h"
  41 #include "nsAccessibilityAtoms.h"
  42 #include "nsHashtable.h"
  43 #include "nsIAccessibilityService.h"
  44 #include "nsIAccessibleDocument.h"
  45 #include "nsPIAccessibleDocument.h"
  46 #include "nsIDocShell.h"
  47 #include "nsIDocShellTreeItem.h"
  48 #include "nsIDocument.h"
  49 #include "nsIDOMCSSStyleDeclaration.h"
  50 #include "nsIDOMCSSPrimitiveValue.h"
  51 #include "nsIDOMDocument.h"
  52 #include "nsIDOMElement.h"
  53 #include "nsIDOMHTMLDocument.h"
  54 #include "nsIDOMHTMLElement.h"
  55 #include "nsIDOMNSDocument.h"
  56 #include "nsIDOMNSHTMLElement.h"
  57 #include "nsIDOMWindow.h"
  58 #include "nsPIDOMWindow.h"
  59 #include "nsIInterfaceRequestorUtils.h"
  60 #include "nsIFrame.h"
  61 #include "nsIPrefService.h"
  62 #include "nsIPrefBranch.h"
  63 #include "nsPresContext.h"
  64 #include "nsIPresShell.h"
  65 #include "nsIServiceManager.h"
  66 #include "nsIStringBundle.h"
  67 #include "nsITimer.h"
  68 #include "nsRootAccessible.h"
  69 #include "nsIFocusController.h"
  70 #include "nsIObserverService.h"
  71
  72 #ifdef MOZ_ACCESSIBILITY_ATK
  73 #include "nsAppRootAccessible.h"
  74 #else
  75 #include "nsApplicationAccessibleWrap.h"
  76 #endif
  77
  78 /* For documentation of the accessibility architecture,
  79  * see http://lxr.mozilla.org/seamonkey/source/accessible/accessible-docs.html
  80  */
  81
  82 nsIStringBundle *nsAccessNode::gStringBundle = 0;
  83 nsIStringBundle *nsAccessNode::gKeyStringBundle = 0;
  84 nsITimer *nsAccessNode::gDoCommandTimer = 0;
  85 nsIDOMNode *nsAccessNode::gLastFocusedNode = 0;
  86 PRBool nsAccessNode::gIsAccessibilityActive = PR_FALSE;
  87 PRBool nsAccessNode::gIsShuttingDownApp = PR_FALSE;
  88 PRBool nsAccessNode::gIsCacheDisabled = PR_FALSE;
  89 PRBool nsAccessNode::gIsFormFillEnabled = PR_FALSE;
  90 nsAccessNodeHashtable nsAccessNode::gGlobalDocAccessibleCache;
  91
  92 nsApplicationAccessibleWrap *nsAccessNode::gApplicationAccessible = nsnull;
  93
  94 nsIAccessibilityService *nsAccessNode::sAccService = nsnull;
  95 nsIAccessibilityService *nsAccessNode::GetAccService()
  96 {
  97   if (!gIsAccessibilityActive)
  98     return nsnull;
  99
 100   if (!sAccService) {
 101     nsresult rv = CallGetService("@mozilla.org/accessibilityService;1",
 102                                  &sAccService);
 103     NS_ASSERTION(NS_SUCCEEDED(rv), "No accessibility service");
 104   }
 105
 106   return sAccService;
 107 }
 108
 109 /*
 110  * Class nsAccessNode
 111  */
 112
 113 ////////////////////////////////////////////////////////////////////////////////
 114 // nsAccessible. nsISupports
 115
 116 NS_IMPL_CYCLE_COLLECTION_0(nsAccessNode)
 117
 118 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsAccessNode)
 119   NS_INTERFACE_MAP_ENTRY(nsIAccessNode)
 120   NS_INTERFACE_MAP_ENTRY(nsAccessNode)
 121   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIAccessNode)
 122 NS_INTERFACE_MAP_END
 123
 124 NS_IMPL_CYCLE_COLLECTING_ADDREF_AMBIGUOUS(nsAccessNode, nsIAccessNode)
 125 NS_IMPL_CYCLE_COLLECTING_RELEASE_FULL(nsAccessNode, nsIAccessNode,
 126                                       LastRelease())
 127
 128 ////////////////////////////////////////////////////////////////////////////////
 129 // nsAccessible. Constructor
 130
 131 nsAccessNode::nsAccessNode(nsIDOMNode *aNode, nsIWeakReference* aShell):
 132   mDOMNode(aNode), mWeakShell(aShell)
 133 {
 134 #ifdef DEBUG_A11Y
 135   mIsInitialized = PR_FALSE;
 136 #endif
 137 }
 138
 139 //-----------------------------------------------------
 140 // destruction
 141 //-----------------------------------------------------
 142 nsAccessNode::~nsAccessNode()
 143 {
 144   NS_ASSERTION(!mWeakShell, "LastRelease was never called!?!");
 145 }
 146
 147 void nsAccessNode::LastRelease()
 148 {
 149   // First cleanup if needed...
 150   if (mWeakShell) {
 151     Shutdown();
 152     NS_ASSERTION(!mWeakShell, "A Shutdown() impl forgot to call its parent's Shutdown?");
 153   }
 154   // ... then die.
 155   NS_DELETEXPCOM(this);
 156 }
 157
 158 nsresult
 159 nsAccessNode::Init()
 160 {
 161   // We have to put this here, instead of constructor, otherwise
 162   // we don't have the virtual GetUniqueID() method for the hash key.
 163   // We need that for accessibles that don't have DOM nodes
 164
 165 #ifdef DEBUG_A11Y
 166   NS_ASSERTION(!mIsInitialized, "Initialized twice!");
 167 #endif
 168   nsCOMPtr<nsIAccessibleDocument> docAccessible(GetDocAccessible());
 169   if (!docAccessible) {
 170     // No doc accessible yet for this node's document.
 171     // There was probably an accessible event fired before the
 172     // current document was ever asked for by the assistive technology.
 173     // Create a doc accessible so we can cache this node
 174     nsCOMPtr<nsIPresShell> presShell(do_QueryReferent(mWeakShell));
 175     if (presShell) {
 176       nsCOMPtr<nsIDOMNode> docNode(do_QueryInterface(presShell->GetDocument()));
 177       if (docNode) {
 178         nsIAccessibilityService *accService = GetAccService();
 179         if (accService) {
 180           nsCOMPtr<nsIAccessible> accessible;
 181           accService->GetAccessibleInShell(docNode, presShell,
 182                                            getter_AddRefs(accessible));
 183           docAccessible = do_QueryInterface(accessible);
 184         }
 185       }
 186     }
 187     NS_ASSERTION(docAccessible, "Cannot cache new nsAccessNode");
 188     if (!docAccessible) {
 189       return NS_ERROR_FAILURE;
 190     }
 191   }
 192
 193   void* uniqueID;
 194   GetUniqueID(&uniqueID);
 195   nsCOMPtr<nsPIAccessibleDocument> privateDocAccessible =
 196     do_QueryInterface(docAccessible);
 197   NS_ASSERTION(privateDocAccessible, "No private docaccessible for docaccessible");
 198   privateDocAccessible->CacheAccessNode(uniqueID, this);
 199
 200   // Make sure an ancestor in real content is cached
 201   // so that nsDocAccessible::RefreshNodes() can find the anonymous subtree to release when
 202   // the root node goes away
 203   nsCOMPtr<nsIContent> content = do_QueryInterface(mDOMNode);
 204   if (content && content->IsInAnonymousSubtree()) {
 205     // Specific examples of where this is used: <input type="file"> and <xul:findbar>
 206     nsCOMPtr<nsIAccessible> parentAccessible;
 207     docAccessible->GetAccessibleInParentChain(mDOMNode, PR_TRUE, getter_AddRefs(parentAccessible));
 208     if (parentAccessible) {
 209       PRInt32 childCountUnused;
 210       parentAccessible->GetChildCount(&childCountUnused);
 211     }
 212   }
 213
 214 #ifdef DEBUG_A11Y
 215   mIsInitialized = PR_TRUE;
 216 #endif
 217
 218   return NS_OK;
 219 }
 220
 221
 222 nsresult
 223 nsAccessNode::Shutdown()
 224 {
 225   mDOMNode = nsnull;
 226   mWeakShell = nsnull;
 227
 228   return NS_OK;
 229 }
 230
 231 NS_IMETHODIMP nsAccessNode::GetUniqueID(void **aUniqueID)
 232 {
 233   *aUniqueID = static_cast<void*>(mDOMNode);
 234   return NS_OK;
 235 }
 236
 237 NS_IMETHODIMP nsAccessNode::GetOwnerWindow(void **aWindow)
 238 {
 239   *aWindow = nsnull;
 240   nsCOMPtr<nsIAccessibleDocument> docAccessible(GetDocAccessible());
 241   if (!docAccessible)
 242     return NS_ERROR_FAILURE; // This node or doc accessible is shut down
 243   return docAccessible->GetWindowHandle(aWindow);
 244 }
 245
 246 already_AddRefed<nsApplicationAccessibleWrap>
 247 nsAccessNode::GetApplicationAccessible()
 248 {
 249   if (!gIsAccessibilityActive) {
 250     return nsnull;
 251   }
 252
 253   if (!gApplicationAccessible) {
 254     nsApplicationAccessibleWrap::PreCreate();
 255
 256     gApplicationAccessible = new nsApplicationAccessibleWrap();
 257     if (!gApplicationAccessible)
 258       return nsnull;
 259
 260     // Addref on create. Will Release in ShutdownXPAccessibility()
 261     NS_ADDREF(gApplicationAccessible);
 262
 263     nsresult rv = gApplicationAccessible->Init();
 264     if (NS_FAILED(rv)) {
 265       NS_RELEASE(gApplicationAccessible);
 266       gApplicationAccessible = nsnull;
 267       return nsnull;
 268     }
 269   }
 270
 271   NS_ADDREF(gApplicationAccessible);   // Addref because we're a getter
 272   return gApplicationAccessible;
 273 }
 274
 275 void nsAccessNode::InitXPAccessibility()
 276 {
 277   if (gIsAccessibilityActive) {
 278     return;
 279   }
 280
 281   nsCOMPtr<nsIStringBundleService> stringBundleService =
 282     do_GetService(NS_STRINGBUNDLE_CONTRACTID);
 283   if (stringBundleService) {
 284     // Static variables are released in ShutdownAllXPAccessibility();
 285     stringBundleService->CreateBundle(ACCESSIBLE_BUNDLE_URL,
 286                                       &gStringBundle);
 287     stringBundleService->CreateBundle(PLATFORM_KEYS_BUNDLE_URL,
 288                                       &gKeyStringBundle);
 289   }
 290
 291   nsAccessibilityAtoms::AddRefAtoms();
 292
 293   gGlobalDocAccessibleCache.Init(4);
 294
 295   nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID));
 296   if (prefBranch) {
 297     prefBranch->GetBoolPref("accessibility.disablecache", &gIsCacheDisabled);
 298     prefBranch->GetBoolPref("browser.formfill.enable", &gIsFormFillEnabled);
 299   }
 300
 301   gIsAccessibilityActive = PR_TRUE;
 302   NotifyA11yInitOrShutdown();
 303 }
 304
 305 void nsAccessNode::NotifyA11yInitOrShutdown()
 306 {
 307   nsCOMPtr<nsIObserverService> obsService =
 308     do_GetService("@mozilla.org/observer-service;1");
 309   NS_ASSERTION(obsService, "No observer service to notify of a11y init/shutdown");
 310   if (obsService) {
 311     static const PRUnichar kInitIndicator[] = { '1', 0 };
 312     static const PRUnichar kShutdownIndicator[] = { '0', 0 };
 313     obsService->NotifyObservers(nsnull, "a11y-init-or-shutdown",
 314                                 gIsAccessibilityActive ? kInitIndicator  : kShutdownIndicator);
 315   }
 316 }
 317
 318 void nsAccessNode::ShutdownXPAccessibility()
 319 {
 320   // Called by nsAccessibilityService::Shutdown()
 321   // which happens when xpcom is shutting down
 322   // at exit of program
 323
 324   if (!gIsAccessibilityActive) {
 325     return;
 326   }
 327   gIsShuttingDownApp = PR_TRUE;
 328
 329   NS_IF_RELEASE(gStringBundle);
 330   NS_IF_RELEASE(gKeyStringBundle);
 331   NS_IF_RELEASE(gDoCommandTimer);
 332   NS_IF_RELEASE(gLastFocusedNode);
 333   NS_IF_RELEASE(sAccService);
 334
 335   nsApplicationAccessibleWrap::Unload();
 336   ClearCache(gGlobalDocAccessibleCache);
 337
 338   // Release gApplicationAccessible after everything else is shutdown
 339   // so we don't accidently create it again while tearing down root accessibles
 340   NS_IF_RELEASE(gApplicationAccessible);
 341   gApplicationAccessible = nsnull;
 342
 343   gIsAccessibilityActive = PR_FALSE;
 344   NotifyA11yInitOrShutdown();
 345 }
 346
 347 already_AddRefed<nsIPresShell> nsAccessNode::GetPresShell()
 348 {
 349   nsIPresShell *presShell = nsnull;
 350   if (mWeakShell)
 351     CallQueryReferent(mWeakShell.get(), &presShell);
 352   if (!presShell) {
 353     if (mWeakShell) {
 354       // If our pres shell has died, but we're still holding onto
 355       // a weak reference, our accessibles are no longer relevant
 356       // and should be shut down
 357       Shutdown();
 358     }
 359     return nsnull;
 360   }
 361   return presShell;
 362 }
 363
 364 nsPresContext* nsAccessNode::GetPresContext()
 365 {
 366   nsCOMPtr<nsIPresShell> presShell(GetPresShell());
 367   if (!presShell) {
 368     return nsnull;
 369   }
 370   return presShell->GetPresContext();
 371 }
 372
 373 already_AddRefed<nsIAccessibleDocument> nsAccessNode::GetDocAccessible()
 374 {
 375   return GetDocAccessibleFor(mWeakShell); // Addref'd
 376 }
 377
 378 already_AddRefed<nsRootAccessible> nsAccessNode::GetRootAccessible()
 379 {
 380   nsCOMPtr<nsIDocShellTreeItem> docShellTreeItem =
 381     nsCoreUtils::GetDocShellTreeItemFor(mDOMNode);
 382   NS_ASSERTION(docShellTreeItem, "No docshell tree item for mDOMNode");
 383   if (!docShellTreeItem) {
 384     return nsnull;
 385   }
 386   nsCOMPtr<nsIDocShellTreeItem> root;
 387   docShellTreeItem->GetRootTreeItem(getter_AddRefs(root));
 388   NS_ASSERTION(root, "No root content tree item");
 389   if (!root) {
 390     return nsnull;
 391   }
 392
 393   nsCOMPtr<nsIAccessibleDocument> accDoc = GetDocAccessibleFor(root);
 394   if (!accDoc) {
 395     return nsnull;
 396   }
 397
 398   // nsRootAccessible has a special QI
 399   // that let us get that concrete type directly.
 400   nsRootAccessible* rootAccessible;
 401   accDoc->QueryInterface(NS_GET_IID(nsRootAccessible), (void**)&rootAccessible); // addrefs
 402   return rootAccessible;
 403 }
 404
 405 nsIFrame*
 406 nsAccessNode::GetFrame()
 407 {
 408   nsCOMPtr<nsIPresShell> shell(do_QueryReferent(mWeakShell));
 409   if (!shell)
 410     return nsnull;
 411
 412   nsCOMPtr<nsIContent> content(do_QueryInterface(mDOMNode));
 413   return content ? shell->GetPrimaryFrameFor(content) : nsnull;
 414 }
 415
 416 NS_IMETHODIMP
 417 nsAccessNode::GetDOMNode(nsIDOMNode **aNode)
 418 {
 419   NS_IF_ADDREF(*aNode = mDOMNode);
 420   return NS_OK;
 421 }
 422
 423 NS_IMETHODIMP
 424 nsAccessNode::GetNumChildren(PRInt32 *aNumChildren)
 425 {
 426   nsCOMPtr<nsIContent> content(do_QueryInterface(mDOMNode));
 427
 428   if (!content) {
 429     *aNumChildren = 0;
 430
 431     return NS_ERROR_NULL_POINTER;
 432   }
 433
 434   *aNumChildren = content->GetChildCount();
 435
 436   return NS_OK;
 437 }
 438
 439 NS_IMETHODIMP
 440 nsAccessNode::GetAccessibleDocument(nsIAccessibleDocument **aDocAccessible)
 441 {
 442   *aDocAccessible = GetDocAccessibleFor(mWeakShell).get();
 443   return NS_OK;
 444 }
 445
 446 NS_IMETHODIMP
 447 nsAccessNode::GetInnerHTML(nsAString& aInnerHTML)
 448 {
 449   aInnerHTML.Truncate();
 450
 451   nsCOMPtr<nsIDOMNSHTMLElement> domNSElement(do_QueryInterface(mDOMNode));
 452   NS_ENSURE_TRUE(domNSElement, NS_ERROR_NULL_POINTER);
 453
 454   return domNSElement->GetInnerHTML(aInnerHTML);
 455 }
 456
 457 NS_IMETHODIMP
 458 nsAccessNode::ScrollTo(PRUint32 aScrollType)
 459 {
 460   if (IsDefunct())
 461     return NS_ERROR_FAILURE;
 462
 463   nsCOMPtr<nsIPresShell> shell(GetPresShell());
 464   NS_ENSURE_TRUE(shell, NS_ERROR_FAILURE);
 465
 466   nsIFrame *frame = GetFrame();
 467   NS_ENSURE_TRUE(frame, NS_ERROR_FAILURE);
 468
 469   nsCOMPtr<nsIContent> content = frame->GetContent();
 470   NS_ENSURE_TRUE(content, NS_ERROR_FAILURE);
 471
 472   PRInt16 vPercent, hPercent;
 473   nsCoreUtils::ConvertScrollTypeToPercents(aScrollType, &vPercent, &hPercent);
 474   return shell->ScrollContentIntoView(content, vPercent, hPercent);
 475 }
 476
 477 NS_IMETHODIMP
 478 nsAccessNode::ScrollToPoint(PRUint32 aCoordinateType, PRInt32 aX, PRInt32 aY)
 479 {
 480   nsIFrame *frame = GetFrame();
 481   if (!frame)
 482     return NS_ERROR_FAILURE;
 483
 484   nsIntPoint coords;
 485   nsresult rv = nsAccUtils::ConvertToScreenCoords(aX, aY, aCoordinateType,
 486                                                   this, &coords);
 487   NS_ENSURE_SUCCESS(rv, rv);
 488
 489   nsIFrame *parentFrame = frame;
 490   while ((parentFrame = parentFrame->GetParent()))
 491     nsCoreUtils::ScrollFrameToPoint(parentFrame, frame, coords);
 492
 493   return NS_OK;
 494 }
 495
 496 nsresult
 497 nsAccessNode::MakeAccessNode(nsIDOMNode *aNode, nsIAccessNode **aAccessNode)
 498 {
 499   *aAccessNode = nsnull;
 500
 501   nsIAccessibilityService *accService = GetAccService();
 502   NS_ENSURE_TRUE(accService, NS_ERROR_FAILURE);
 503
 504   nsCOMPtr<nsIAccessNode> accessNode;
 505   accService->GetCachedAccessNode(aNode, mWeakShell, getter_AddRefs(accessNode));
 506
 507   if (!accessNode) {
 508     nsCOMPtr<nsIAccessible> accessible;
 509     accService->GetAccessibleInWeakShell(aNode, mWeakShell,
 510                                          getter_AddRefs(accessible));
 511
 512     accessNode = do_QueryInterface(accessible);
 513   }
 514
 515   if (accessNode) {
 516     NS_ADDREF(*aAccessNode = accessNode);
 517     return NS_OK;
 518   }
 519
 520   nsAccessNode *newAccessNode = new nsAccessNode(aNode, mWeakShell);
 521   if (!newAccessNode) {
 522     return NS_ERROR_OUT_OF_MEMORY;
 523   }
 524
 525   NS_ADDREF(*aAccessNode = newAccessNode);
 526   newAccessNode->Init();
 527
 528   return NS_OK;
 529 }
 530
 531 NS_IMETHODIMP
 532 nsAccessNode::GetFirstChildNode(nsIAccessNode **aAccessNode)
 533 {
 534   NS_ENSURE_ARG_POINTER(aAccessNode);
 535   *aAccessNode = nsnull;
 536   NS_ENSURE_TRUE(mDOMNode, NS_ERROR_NULL_POINTER);
 537
 538   nsCOMPtr<nsIDOMNode> domNode;
 539   mDOMNode->GetFirstChild(getter_AddRefs(domNode));
 540
 541   return domNode ? MakeAccessNode(domNode, aAccessNode) : NS_OK;
 542 }
 543
 544 NS_IMETHODIMP
 545 nsAccessNode::GetLastChildNode(nsIAccessNode **aAccessNode)
 546 {
 547   NS_ENSURE_ARG_POINTER(aAccessNode);
 548   *aAccessNode = nsnull;
 549   NS_ENSURE_TRUE(mDOMNode, NS_ERROR_NULL_POINTER);
 550
 551   nsCOMPtr<nsIDOMNode> domNode;
 552   mDOMNode->GetLastChild(getter_AddRefs(domNode));
 553
 554   return domNode ? MakeAccessNode(domNode, aAccessNode) : NS_OK;
 555 }
 556
 557 NS_IMETHODIMP
 558 nsAccessNode::GetParentNode(nsIAccessNode **aAccessNode)
 559 {
 560   NS_ENSURE_ARG_POINTER(aAccessNode);
 561   *aAccessNode = nsnull;
 562   NS_ENSURE_TRUE(mDOMNode, NS_ERROR_NULL_POINTER);
 563
 564   nsCOMPtr<nsIDOMNode> domNode;
 565   mDOMNode->GetParentNode(getter_AddRefs(domNode));
 566
 567   return domNode ? MakeAccessNode(domNode, aAccessNode) : NS_OK;
 568 }
 569
 570 NS_IMETHODIMP
 571 nsAccessNode::GetPreviousSiblingNode(nsIAccessNode **aAccessNode)
 572 {
 573   NS_ENSURE_ARG_POINTER(aAccessNode);
 574   *aAccessNode = nsnull;
 575   NS_ENSURE_TRUE(mDOMNode, NS_ERROR_NULL_POINTER);
 576
 577   nsCOMPtr<nsIDOMNode> domNode;
 578   mDOMNode->GetPreviousSibling(getter_AddRefs(domNode));
 579
 580   return domNode ? MakeAccessNode(domNode, aAccessNode) : NS_OK;
 581 }
 582
 583 NS_IMETHODIMP
 584 nsAccessNode::GetNextSiblingNode(nsIAccessNode **aAccessNode)
 585 {
 586   NS_ENSURE_ARG_POINTER(aAccessNode);
 587   *aAccessNode = nsnull;
 588   NS_ENSURE_TRUE(mDOMNode, NS_ERROR_NULL_POINTER);
 589
 590   nsCOMPtr<nsIDOMNode> domNode;
 591   mDOMNode->GetNextSibling(getter_AddRefs(domNode));
 592
 593   return domNode ? MakeAccessNode(domNode, aAccessNode) : NS_OK;
 594 }
 595
 596 NS_IMETHODIMP
 597 nsAccessNode::GetChildNodeAt(PRInt32 aChildNum, nsIAccessNode **aAccessNode)
 598 {
 599   NS_ENSURE_ARG_POINTER(aAccessNode);
 600   *aAccessNode = nsnull;
 601
 602   nsCOMPtr<nsIContent> content(do_QueryInterface(mDOMNode));
 603   NS_ENSURE_TRUE(content, NS_ERROR_NULL_POINTER);
 604
 605   nsCOMPtr<nsIDOMNode> domNode =
 606     do_QueryInterface(content->GetChildAt(aChildNum));
 607
 608   return domNode ? MakeAccessNode(domNode, aAccessNode) : NS_OK;
 609 }
 610
 611 NS_IMETHODIMP
 612 nsAccessNode::GetComputedStyleValue(const nsAString& aPseudoElt,
 613                                     const nsAString& aPropertyName,
 614                                     nsAString& aValue)
 615 {
 616   if (IsDefunct())
 617     return NS_ERROR_FAILURE;
 618
 619   nsCOMPtr<nsIDOMCSSStyleDeclaration> styleDecl;
 620   nsCoreUtils::GetComputedStyleDeclaration(aPseudoElt, mDOMNode,
 621                                            getter_AddRefs(styleDecl));
 622   NS_ENSURE_TRUE(styleDecl, NS_ERROR_FAILURE);
 623
 624   return styleDecl->GetPropertyValue(aPropertyName, aValue);
 625 }
 626
 627 NS_IMETHODIMP
 628 nsAccessNode::GetComputedStyleCSSValue(const nsAString& aPseudoElt,
 629                                        const nsAString& aPropertyName,
 630                                        nsIDOMCSSPrimitiveValue **aCSSValue)
 631 {
 632   NS_ENSURE_ARG_POINTER(aCSSValue);
 633   *aCSSValue = nsnull;
 634
 635   if (IsDefunct())
 636     return NS_ERROR_FAILURE;
 637
 638   nsCOMPtr<nsIDOMCSSStyleDeclaration> styleDecl;
 639   nsCoreUtils::GetComputedStyleDeclaration(aPseudoElt, mDOMNode,
 640                                            getter_AddRefs(styleDecl));
 641   NS_ENSURE_STATE(styleDecl);
 642
 643   nsCOMPtr<nsIDOMCSSValue> cssValue;
 644   styleDecl->GetPropertyCSSValue(aPropertyName, getter_AddRefs(cssValue));
 645   NS_ENSURE_TRUE(cssValue, NS_ERROR_FAILURE);
 646
 647   return CallQueryInterface(cssValue, aCSSValue);
 648 }
 649
 650 /***************** Hashtable of nsIAccessNode's *****************/
 651
 652 already_AddRefed<nsIAccessibleDocument>
 653 nsAccessNode::GetDocAccessibleFor(nsIDocument *aDocument)
 654 {
 655   if (!aDocument) {
 656     return nsnull;
 657   }
 658
 659   nsIAccessibleDocument *docAccessible = nsnull;
 660   nsCOMPtr<nsIAccessNode> accessNode;
 661   gGlobalDocAccessibleCache.Get(static_cast<void*>(aDocument),
 662                                 getter_AddRefs(accessNode));
 663   if (accessNode) {
 664     CallQueryInterface(accessNode, &docAccessible);
 665   }
 666   return docAccessible;
 667 }
 668
 669 already_AddRefed<nsIAccessibleDocument>
 670 nsAccessNode::GetDocAccessibleFor(nsIWeakReference *aWeakShell)
 671 {
 672   nsCOMPtr<nsIPresShell> presShell(do_QueryReferent(aWeakShell));
 673   if (!presShell) {
 674     return nsnull;
 675   }
 676
 677   return nsAccessNode::GetDocAccessibleFor(presShell->GetDocument());
 678 }
 679
 680 already_AddRefed<nsIAccessibleDocument>
 681 nsAccessNode::GetDocAccessibleFor(nsIDocShellTreeItem *aContainer,
 682                                   PRBool aCanCreate)
 683 {
 684   if (!aCanCreate) {
 685     nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(aContainer));
 686     NS_ASSERTION(docShell, "This method currently only supports docshells");
 687     nsCOMPtr<nsIPresShell> presShell;
 688     docShell->GetPresShell(getter_AddRefs(presShell));
 689     return presShell ? GetDocAccessibleFor(presShell->GetDocument()) : nsnull;
 690   }
 691
 692   nsCOMPtr<nsIDOMNode> node = nsCoreUtils::GetDOMNodeForContainer(aContainer);
 693   if (!node) {
 694     return nsnull;
 695   }
 696
 697   nsCOMPtr<nsIAccessible> accessible;
 698   GetAccService()->GetAccessibleFor(node, getter_AddRefs(accessible));
 699   nsIAccessibleDocument *docAccessible = nsnull;
 700   if (accessible) {
 701     CallQueryInterface(accessible, &docAccessible);
 702   }
 703   return docAccessible;
 704 }
 705
 706 already_AddRefed<nsIAccessibleDocument>
 707 nsAccessNode::GetDocAccessibleFor(nsIDOMNode *aNode)
 708 {
 709   nsCOMPtr<nsIPresShell> eventShell = nsCoreUtils::GetPresShellFor(aNode);
 710   if (eventShell) {
 711     return GetDocAccessibleFor(eventShell->GetDocument());
 712   }
 713
 714   nsCOMPtr<nsIDocument> doc(do_QueryInterface(aNode));
 715   if (doc) {
 716     return GetDocAccessibleFor(doc);
 717   }
 718
 719   return nsnull;
 720 }
 721
 722 void
 723 nsAccessNode::PutCacheEntry(nsAccessNodeHashtable& aCache,
 724                             void* aUniqueID,
 725                             nsIAccessNode *aAccessNode)
 726 {
 727 #ifdef DEBUG_A11Y
 728   nsCOMPtr<nsIAccessNode> oldAccessNode;
 729   GetCacheEntry(aCache, aUniqueID, getter_AddRefs(oldAccessNode));
 730   NS_ASSERTION(!oldAccessNode, "This cache entry shouldn't exist already");
 731 #endif
 732   aCache.Put(aUniqueID, aAccessNode);
 733 }
 734
 735 void
 736 nsAccessNode::GetCacheEntry(nsAccessNodeHashtable& aCache,
 737                             void* aUniqueID,
 738                             nsIAccessNode **aAccessNode)
 739 {
 740   aCache.Get(aUniqueID, aAccessNode);  // AddRefs for us
 741 }
 742
 743 PLDHashOperator nsAccessNode::ClearCacheEntry(const void* aKey, nsCOMPtr<nsIAccessNode>& aAccessNode, void* aUserArg)
 744 {
 745   NS_ASSERTION(aAccessNode, "Calling ClearCacheEntry with a NULL pointer!");
 746   if (aAccessNode) {
 747     nsRefPtr<nsAccessNode> accessNode =
 748       nsAccUtils::QueryAccessNode(aAccessNode);
 749     accessNode->Shutdown();
 750   }
 751
 752   return PL_DHASH_REMOVE;
 753 }
 754
 755 void
 756 nsAccessNode::ClearCache(nsAccessNodeHashtable& aCache)
 757 {
 758   aCache.Enumerate(ClearCacheEntry, nsnull);
 759 }
 760
 761 already_AddRefed<nsIDOMNode> nsAccessNode::GetCurrentFocus()
 762 {
 763   nsCOMPtr<nsIPresShell> shell = nsCoreUtils::GetPresShellFor(mDOMNode);
 764   NS_ENSURE_TRUE(shell, nsnull);
 765   nsCOMPtr<nsIDocument> doc = shell->GetDocument();
 766   NS_ENSURE_TRUE(doc, nsnull);
 767
 768   nsCOMPtr<nsPIDOMWindow> privateDOMWindow(do_QueryInterface(doc->GetWindow()));
 769   if (!privateDOMWindow) {
 770     return nsnull;
 771   }
 772   nsIFocusController *focusController = privateDOMWindow->GetRootFocusController();
 773   if (!focusController) {
 774     return nsnull;
 775   }
 776   nsCOMPtr<nsIDOMElement> focusedElement;
 777   focusController->GetFocusedElement(getter_AddRefs(focusedElement));
 778   nsIDOMNode *focusedNode = nsnull;
 779   if (!focusedElement) {
 780     // Document itself has focus
 781     nsCOMPtr<nsIDOMWindowInternal> focusedWinInternal;
 782     focusController->GetFocusedWindow(getter_AddRefs(focusedWinInternal));
 783     if (!focusedWinInternal) {
 784       return nsnull;
 785     }
 786     nsCOMPtr<nsIDOMDocument> focusedDOMDocument;
 787     focusedWinInternal->GetDocument(getter_AddRefs(focusedDOMDocument));
 788     if (!focusedDOMDocument) {
 789       return nsnull;
 790     }
 791     focusedDOMDocument->QueryInterface(NS_GET_IID(nsIDOMNode), (void**)&focusedNode);
 792   }
 793   else {
 794     focusedElement->QueryInterface(NS_GET_IID(nsIDOMNode), (void**)&focusedNode);
 795   }
 796
 797   return focusedNode;
 798 }
 799
 800 NS_IMETHODIMP
 801 nsAccessNode::GetLanguage(nsAString& aLanguage)
 802 {
 803   aLanguage.Truncate();
 804   nsCOMPtr<nsIContent> content(do_QueryInterface(mDOMNode));
 805   if (!content) {
 806     // For documents make sure we look for lang attribute on
 807     // document element
 808     nsCOMPtr<nsIDOMDocument> domDoc(do_QueryInterface(mDOMNode));
 809     if (domDoc) {
 810       nsCOMPtr<nsIDOMHTMLDocument> htmlDoc(do_QueryInterface(mDOMNode));
 811       if (htmlDoc) {
 812         // Make sure we look for lang attribute on HTML <body>
 813         nsCOMPtr<nsIDOMHTMLElement> bodyElement;
 814         htmlDoc->GetBody(getter_AddRefs(bodyElement));
 815         content = do_QueryInterface(bodyElement);
 816       }
 817       if (!content) {
 818         nsCOMPtr<nsIDOMElement> docElement;
 819         domDoc->GetDocumentElement(getter_AddRefs(docElement));
 820         content = do_QueryInterface(docElement);
 821       }
 822     }
 823     if (!content) {
 824       return NS_ERROR_FAILURE;
 825     }
 826   }
 827
 828   nsCoreUtils::GetLanguageFor(content, nsnull, aLanguage);
 829
 830   if (aLanguage.IsEmpty()) { // Nothing found, so use document's language
 831     nsIDocument *doc = content->GetOwnerDoc();
 832     if (doc) {
 833       doc->GetHeaderData(nsAccessibilityAtoms::headerContentLanguage, aLanguage);
 834     }
 835   }
 836
 837   return NS_OK;
 838 }
 839