LCOV - code coverage report
Current view: directory - accessible/src/xforms - nsXFormsAccessible.cpp (source / functions) Found Hit Coverage
Test: app.info Lines: 290 0 0.0 %
Date: 2012-06-02 Functions: 31 0 0.0 %

       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                 :  * Mozilla Foundation.
      19                 :  * Portions created by the Initial Developer are Copyright (C) 2006
      20                 :  * the Initial Developer. All Rights Reserved.
      21                 :  *
      22                 :  * Contributor(s):
      23                 :  *   Alexander Surkov <surkov.alexander@gmail.com> (original author)
      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 "nsXFormsAccessible.h"
      40                 : 
      41                 : #include "nsAccessibilityService.h"
      42                 : #include "nsAccUtils.h"
      43                 : #include "nsDocAccessible.h"
      44                 : #include "nsTextEquivUtils.h"
      45                 : #include "Role.h"
      46                 : #include "States.h"
      47                 : #include "Statistics.h"
      48                 : 
      49                 : #include "nscore.h"
      50                 : #include "nsServiceManagerUtils.h"
      51                 : #include "nsIDOMElement.h"
      52                 : #include "nsIDOMNodeList.h"
      53                 : #include "nsIEditor.h"
      54                 : #include "nsIMutableArray.h"
      55                 : #include "nsIXFormsUtilityService.h"
      56                 : #include "nsIPlaintextEditor.h"
      57                 : #include "nsINodeList.h"
      58                 : 
      59                 : using namespace mozilla::a11y;
      60                 : 
      61                 : ////////////////////////////////////////////////////////////////////////////////
      62                 : // nsXFormsAccessibleBase
      63                 : ////////////////////////////////////////////////////////////////////////////////
      64                 : 
      65                 : nsIXFormsUtilityService *nsXFormsAccessibleBase::sXFormsService = nsnull;
      66                 : 
      67               0 : nsXFormsAccessibleBase::nsXFormsAccessibleBase()
      68                 : {
      69               0 :   if (!sXFormsService) {
      70                 :     nsresult rv = CallGetService("@mozilla.org/xforms-utility-service;1",
      71               0 :                                  &sXFormsService);
      72               0 :     if (NS_FAILED(rv))
      73               0 :       NS_WARNING("No XForms utility service.");
      74                 :   }
      75               0 :   statistics::XFormsAccessibleUsed();
      76               0 : }
      77                 : 
      78                 : ////////////////////////////////////////////////////////////////////////////////
      79                 : // nsXFormsAccessible
      80                 : ////////////////////////////////////////////////////////////////////////////////
      81                 : 
      82               0 : nsXFormsAccessible::
      83                 :   nsXFormsAccessible(nsIContent* aContent, nsDocAccessible* aDoc) :
      84               0 :   nsHyperTextAccessibleWrap(aContent, aDoc)
      85                 : {
      86               0 : }
      87                 : 
      88                 : nsresult
      89               0 : nsXFormsAccessible::GetBoundChildElementValue(const nsAString& aTagName,
      90                 :                                               nsAString& aValue)
      91                 : {
      92               0 :   NS_ENSURE_TRUE(sXFormsService, NS_ERROR_FAILURE);
      93               0 :   if (IsDefunct())
      94               0 :     return NS_ERROR_FAILURE;
      95                 : 
      96               0 :   nsINodeList* nodes = mContent->GetChildNodesList();
      97               0 :   NS_ENSURE_STATE(nodes);
      98                 : 
      99                 :   PRUint32 length;
     100               0 :   nsresult rv = nodes->GetLength(&length);
     101               0 :   NS_ENSURE_SUCCESS(rv, rv);
     102                 : 
     103               0 :   for (PRUint32 index = 0; index < length; index++) {
     104               0 :     nsIContent* content = nodes->GetNodeAt(index);
     105               0 :     if (content->NodeInfo()->Equals(aTagName) &&
     106               0 :         content->NodeInfo()->NamespaceEquals(NS_LITERAL_STRING(NS_NAMESPACE_XFORMS))) {
     107               0 :       nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(content));
     108               0 :       return sXFormsService->GetValue(DOMNode, aValue);
     109                 :     }
     110                 :   }
     111                 : 
     112               0 :   aValue.Truncate();
     113               0 :   return NS_OK;
     114                 : }
     115                 : 
     116                 : void
     117               0 : nsXFormsAccessible::CacheSelectChildren(nsIDOMNode *aContainerNode)
     118                 : {
     119               0 :   nsCOMPtr<nsIDOMNode> container(aContainerNode);
     120               0 :   if (!container)
     121               0 :     container = do_QueryInterface(mContent);
     122                 : 
     123               0 :   nsCOMPtr<nsIDOMNodeList> children;
     124               0 :   sXFormsService->GetSelectChildrenFor(container, getter_AddRefs(children));
     125                 : 
     126               0 :   if (!children)
     127                 :     return;
     128                 : 
     129               0 :   PRUint32 length = 0;
     130               0 :   children->GetLength(&length);
     131                 : 
     132               0 :   for (PRUint32 index = 0; index < length; index++) {
     133               0 :     nsCOMPtr<nsIDOMNode> DOMChild;
     134               0 :     children->Item(index, getter_AddRefs(DOMChild));
     135               0 :     if (!DOMChild)
     136               0 :       continue;
     137                 : 
     138               0 :     nsCOMPtr<nsIContent> child(do_QueryInterface(DOMChild));
     139                 :     nsAccessible* accessible =
     140               0 :       GetAccService()->GetOrCreateAccessible(child, mDoc);
     141               0 :     if (!accessible)
     142               0 :       continue;
     143                 : 
     144               0 :     AppendChild(accessible);
     145                 :   }
     146                 : }
     147                 : 
     148                 : // nsIAccessible
     149                 : 
     150                 : NS_IMETHODIMP
     151               0 : nsXFormsAccessible::GetValue(nsAString& aValue)
     152                 : {
     153               0 :   NS_ENSURE_TRUE(sXFormsService, NS_ERROR_FAILURE);
     154               0 :   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
     155               0 :   return sXFormsService->GetValue(DOMNode, aValue);
     156                 : }
     157                 : 
     158                 : PRUint64
     159               0 : nsXFormsAccessible::NativeState()
     160                 : {
     161               0 :   NS_ENSURE_TRUE(sXFormsService, 0);
     162                 : 
     163               0 :   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
     164                 : 
     165               0 :   bool isRelevant = false;
     166               0 :   nsresult rv = sXFormsService->IsRelevant(DOMNode, &isRelevant);
     167               0 :   NS_ENSURE_SUCCESS(rv, 0);
     168                 : 
     169               0 :   bool isReadonly = false;
     170               0 :   rv = sXFormsService->IsReadonly(DOMNode, &isReadonly);
     171               0 :   NS_ENSURE_SUCCESS(rv, 0);
     172                 : 
     173               0 :   bool isRequired = false;
     174               0 :   rv = sXFormsService->IsRequired(DOMNode, &isRequired);
     175               0 :   NS_ENSURE_SUCCESS(rv, 0);
     176                 : 
     177               0 :   bool isValid = false;
     178               0 :   rv = sXFormsService->IsValid(DOMNode, &isValid);
     179               0 :   NS_ENSURE_SUCCESS(rv, 0);
     180                 : 
     181               0 :   PRUint64 states = nsHyperTextAccessibleWrap::NativeState();
     182                 : 
     183               0 :   if (!isRelevant)
     184               0 :     states |= states::UNAVAILABLE;
     185                 : 
     186               0 :   if (isReadonly)
     187               0 :     states |= states::READONLY;
     188                 : 
     189               0 :   if (isRequired)
     190               0 :     states |= states::REQUIRED;
     191                 : 
     192               0 :   if (!isValid)
     193               0 :     states |= states::INVALID;
     194                 : 
     195               0 :   return states;
     196                 : }
     197                 : 
     198                 : nsresult
     199               0 : nsXFormsAccessible::GetNameInternal(nsAString& aName)
     200                 : {
     201                 :   // search the xforms:label element
     202               0 :   return GetBoundChildElementValue(NS_LITERAL_STRING("label"), aName);
     203                 : }
     204                 : 
     205                 : void
     206               0 : nsXFormsAccessible::Description(nsString& aDescription)
     207                 : {
     208                 :   nsTextEquivUtils::
     209                 :     GetTextEquivFromIDRefs(this, nsGkAtoms::aria_describedby,
     210               0 :                            aDescription);
     211                 : 
     212               0 :   if (aDescription.IsEmpty())
     213               0 :     GetBoundChildElementValue(NS_LITERAL_STRING("hint"), aDescription);
     214               0 : }
     215                 : 
     216                 : bool
     217               0 : nsXFormsAccessible::CanHaveAnonChildren()
     218                 : {
     219               0 :   return false;
     220                 : }
     221                 : 
     222                 : 
     223                 : ////////////////////////////////////////////////////////////////////////////////
     224                 : // nsXFormsContainerAccessible
     225                 : ////////////////////////////////////////////////////////////////////////////////
     226                 : 
     227               0 : nsXFormsContainerAccessible::
     228                 :   nsXFormsContainerAccessible(nsIContent* aContent, nsDocAccessible* aDoc) :
     229               0 :   nsXFormsAccessible(aContent, aDoc)
     230                 : {
     231               0 : }
     232                 : 
     233                 : role
     234               0 : nsXFormsContainerAccessible::NativeRole()
     235                 : {
     236               0 :   return roles::GROUPING;
     237                 : }
     238                 : 
     239                 : bool
     240               0 : nsXFormsContainerAccessible::CanHaveAnonChildren()
     241                 : {
     242               0 :   return true;
     243                 : }
     244                 : 
     245                 : 
     246                 : ////////////////////////////////////////////////////////////////////////////////
     247                 : // nsXFormsEditableAccessible
     248                 : ////////////////////////////////////////////////////////////////////////////////
     249                 : 
     250               0 : nsXFormsEditableAccessible::
     251                 :   nsXFormsEditableAccessible(nsIContent* aContent, nsDocAccessible* aDoc) :
     252               0 :   nsXFormsAccessible(aContent, aDoc)
     253                 : {
     254               0 : }
     255                 : 
     256                 : PRUint64
     257               0 : nsXFormsEditableAccessible::NativeState()
     258                 : {
     259               0 :   PRUint64 state = nsXFormsAccessible::NativeState();
     260                 : 
     261               0 :   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
     262                 : 
     263               0 :   bool isReadonly = false;
     264               0 :   nsresult rv = sXFormsService->IsReadonly(DOMNode, &isReadonly);
     265               0 :   NS_ENSURE_SUCCESS(rv, state);
     266                 : 
     267               0 :   if (!isReadonly) {
     268               0 :     bool isRelevant = false;
     269               0 :     rv = sXFormsService->IsRelevant(DOMNode, &isRelevant);
     270               0 :     NS_ENSURE_SUCCESS(rv, state);
     271               0 :     if (isRelevant) {
     272               0 :       state |= states::EDITABLE | states::SELECTABLE_TEXT;
     273                 :     }
     274                 :   }
     275                 : 
     276               0 :   nsCOMPtr<nsIEditor> editor = GetEditor();
     277               0 :   NS_ENSURE_TRUE(editor, state);
     278                 :   PRUint32 flags;
     279               0 :   editor->GetFlags(&flags);
     280               0 :   if (flags & nsIPlaintextEditor::eEditorSingleLineMask)
     281               0 :     state |= states::SINGLE_LINE;
     282                 :   else
     283               0 :     state |= states::MULTI_LINE;
     284                 : 
     285               0 :   return state;
     286                 : }
     287                 : 
     288                 : already_AddRefed<nsIEditor>
     289               0 : nsXFormsEditableAccessible::GetEditor() const
     290                 : {
     291               0 :   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
     292                 : 
     293               0 :   nsCOMPtr<nsIEditor> editor;
     294               0 :   sXFormsService->GetEditor(DOMNode, getter_AddRefs(editor));
     295               0 :   return editor.forget();
     296                 : }
     297                 : 
     298                 : ////////////////////////////////////////////////////////////////////////////////
     299                 : // nsXFormsSelectableAccessible
     300                 : ////////////////////////////////////////////////////////////////////////////////
     301                 : 
     302               0 : nsXFormsSelectableAccessible::
     303                 :   nsXFormsSelectableAccessible(nsIContent* aContent, nsDocAccessible* aDoc) :
     304               0 :   nsXFormsEditableAccessible(aContent, aDoc), mIsSelect1Element(nsnull)
     305                 : {
     306                 :   mIsSelect1Element =
     307               0 :     mContent->NodeInfo()->Equals(nsGkAtoms::select1);
     308               0 : }
     309                 : 
     310                 : bool
     311               0 : nsXFormsSelectableAccessible::IsSelect()
     312                 : {
     313               0 :   return true;
     314                 : }
     315                 : 
     316                 : already_AddRefed<nsIArray>
     317               0 : nsXFormsSelectableAccessible::SelectedItems()
     318                 : {
     319                 :   nsCOMPtr<nsIMutableArray> selectedItems =
     320               0 :     do_CreateInstance(NS_ARRAY_CONTRACTID);
     321               0 :   if (!selectedItems)
     322               0 :     return nsnull;
     323                 : 
     324                 :   nsresult rv;
     325               0 :   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
     326                 : 
     327               0 :   if (mIsSelect1Element) {
     328               0 :     nsCOMPtr<nsIDOMNode> itemDOMNode;
     329                 :     rv = sXFormsService->GetSelectedItemForSelect1(DOMNode,
     330               0 :                                                    getter_AddRefs(itemDOMNode));
     331               0 :     if (NS_FAILED(rv) || !itemDOMNode || !mDoc)
     332               0 :       return nsnull;
     333                 : 
     334               0 :     nsCOMPtr<nsINode> itemNode(do_QueryInterface(itemDOMNode));
     335               0 :     nsIAccessible* item = mDoc->GetAccessible(itemNode);
     336               0 :     if (item)
     337               0 :       selectedItems->AppendElement(item, false);
     338                 : 
     339               0 :     nsIMutableArray* items = nsnull;
     340               0 :     selectedItems.forget(&items);
     341               0 :     return items;
     342                 :   }
     343                 : 
     344               0 :   nsCOMPtr<nsIDOMNodeList> itemNodeList;
     345                 :   rv = sXFormsService->GetSelectedItemsForSelect(DOMNode,
     346               0 :                                                  getter_AddRefs(itemNodeList));
     347               0 :   if (NS_FAILED(rv) || !itemNodeList || !mDoc)
     348               0 :     return nsnull;
     349                 : 
     350               0 :   PRUint32 length = 0;
     351               0 :   itemNodeList->GetLength(&length);
     352                 : 
     353               0 :   for (PRUint32 index = 0; index < length; index++) {
     354               0 :     nsCOMPtr<nsIDOMNode> itemDOMNode;
     355               0 :     itemNodeList->Item(index, getter_AddRefs(itemDOMNode));
     356               0 :     if (!itemDOMNode)
     357               0 :       return nsnull;
     358                 : 
     359               0 :     nsCOMPtr<nsINode> itemNode(do_QueryInterface(itemDOMNode));
     360               0 :     nsIAccessible* item = mDoc->GetAccessible(itemNode);
     361               0 :     if (item)
     362               0 :       selectedItems->AppendElement(item, false);
     363                 :   }
     364                 : 
     365               0 :   nsIMutableArray* items = nsnull;
     366               0 :   selectedItems.forget(&items);
     367               0 :   return items;
     368                 : }
     369                 : 
     370                 : PRUint32
     371               0 : nsXFormsSelectableAccessible::SelectedItemCount()
     372                 : {
     373                 :   nsresult rv;
     374               0 :   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
     375                 : 
     376               0 :   if (mIsSelect1Element) {
     377               0 :     nsCOMPtr<nsIDOMNode> item;
     378                 :     rv = sXFormsService->GetSelectedItemForSelect1(DOMNode,
     379               0 :                                                    getter_AddRefs(item));
     380               0 :     return NS_SUCCEEDED(rv) && item ? 1 : 0;
     381                 :   }
     382                 : 
     383               0 :   nsCOMPtr<nsIDOMNodeList> itemNodeList;
     384                 :   rv = sXFormsService->GetSelectedItemsForSelect(DOMNode,
     385               0 :                                                  getter_AddRefs(itemNodeList));
     386               0 :   if (NS_FAILED(rv) || !itemNodeList)
     387               0 :     return 0;
     388                 : 
     389               0 :   PRUint32 length = 0;
     390               0 :   itemNodeList->GetLength(&length);
     391               0 :   return length;
     392                 : }
     393                 : 
     394                 : bool
     395               0 : nsXFormsSelectableAccessible::AddItemToSelection(PRUint32 aIndex)
     396                 : {
     397               0 :   nsCOMPtr<nsIDOMNode> itemDOMNode(do_QueryInterface(GetItemByIndex(&aIndex)));
     398               0 :   if (!itemDOMNode)
     399               0 :     return false;
     400                 : 
     401               0 :   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
     402               0 :   if (mIsSelect1Element)
     403               0 :     sXFormsService->SetSelectedItemForSelect1(DOMNode, itemDOMNode);
     404                 :   else
     405               0 :     sXFormsService->AddItemToSelectionForSelect(DOMNode, itemDOMNode);
     406                 : 
     407               0 :   return true;
     408                 : }
     409                 : 
     410                 : bool
     411               0 : nsXFormsSelectableAccessible::RemoveItemFromSelection(PRUint32 aIndex)
     412                 : {
     413               0 :   nsCOMPtr<nsIDOMNode> itemDOMNode(do_QueryInterface(GetItemByIndex(&aIndex)));
     414               0 :   if (!itemDOMNode)
     415               0 :     return false;
     416                 : 
     417               0 :   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
     418               0 :   if (mIsSelect1Element) {
     419               0 :     nsCOMPtr<nsIDOMNode> selItemDOMNode;
     420                 :     sXFormsService->GetSelectedItemForSelect1(DOMNode,
     421               0 :                                               getter_AddRefs(selItemDOMNode));
     422               0 :     if (selItemDOMNode == itemDOMNode)
     423               0 :       sXFormsService->SetSelectedItemForSelect1(DOMNode, nsnull);
     424                 : 
     425               0 :     return true;
     426                 :   }
     427                 : 
     428               0 :   sXFormsService->RemoveItemFromSelectionForSelect(DOMNode, itemDOMNode);
     429               0 :   return true;
     430                 : }
     431                 : 
     432                 : nsAccessible*
     433               0 : nsXFormsSelectableAccessible::GetSelectedItem(PRUint32 aIndex)
     434                 : {
     435               0 :   if (!mDoc)
     436               0 :     return nsnull;
     437                 : 
     438                 :   nsresult rv;
     439               0 :   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
     440               0 :   if (mIsSelect1Element) {
     441               0 :     if (aIndex != 0)
     442               0 :       return nsnull;
     443                 : 
     444               0 :     nsCOMPtr<nsIDOMNode> itemDOMNode;
     445                 :     rv = sXFormsService->GetSelectedItemForSelect1(DOMNode,
     446               0 :                                                    getter_AddRefs(itemDOMNode));
     447               0 :     if (NS_SUCCEEDED(rv) && itemDOMNode) {
     448               0 :       nsCOMPtr<nsINode> itemNode(do_QueryInterface(itemDOMNode));
     449               0 :       return mDoc->GetAccessible(itemNode);
     450                 :     }
     451               0 :     return nsnull;
     452                 :   }
     453                 : 
     454               0 :   nsCOMPtr<nsIDOMNodeList> itemNodeList;
     455                 :   rv = sXFormsService->GetSelectedItemsForSelect(DOMNode,
     456               0 :                                                  getter_AddRefs(itemNodeList));
     457               0 :   if (NS_FAILED(rv) || !itemNodeList)
     458               0 :     return nsnull;
     459                 : 
     460               0 :   nsCOMPtr<nsIDOMNode> itemDOMNode;
     461               0 :   itemNodeList->Item(aIndex, getter_AddRefs(itemDOMNode));
     462                 : 
     463               0 :   nsCOMPtr<nsINode> itemNode(do_QueryInterface(itemDOMNode));
     464               0 :   return mDoc->GetAccessible(itemNode);
     465                 : }
     466                 : 
     467                 : bool
     468               0 : nsXFormsSelectableAccessible::IsItemSelected(PRUint32 aIndex)
     469                 : {
     470               0 :   nsCOMPtr<nsIDOMNode> itemDOMNode(do_QueryInterface(GetItemByIndex(&aIndex)));
     471               0 :   if (!itemDOMNode)
     472               0 :     return false;
     473                 : 
     474               0 :   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
     475               0 :   if (mIsSelect1Element) {
     476               0 :     nsCOMPtr<nsIDOMNode> selItemDOMNode;
     477                 :     sXFormsService->GetSelectedItemForSelect1(DOMNode,
     478               0 :                                               getter_AddRefs(selItemDOMNode));
     479               0 :     return selItemDOMNode == itemDOMNode;
     480                 :   }
     481                 : 
     482               0 :   bool isSelected = false;
     483               0 :   sXFormsService->IsSelectItemSelected(DOMNode, itemDOMNode, &isSelected);
     484               0 :   return isSelected;
     485                 : }
     486                 : 
     487                 : bool
     488               0 : nsXFormsSelectableAccessible::UnselectAll()
     489                 : {
     490               0 :   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
     491               0 :   if (mIsSelect1Element)
     492               0 :     sXFormsService->SetSelectedItemForSelect1(DOMNode, nsnull);
     493                 : 
     494               0 :   sXFormsService->ClearSelectionForSelect(DOMNode);
     495               0 :   return true;
     496                 : }
     497                 : 
     498                 : bool
     499               0 : nsXFormsSelectableAccessible::SelectAll()
     500                 : {
     501               0 :   if (mIsSelect1Element)
     502               0 :     return false;
     503                 : 
     504               0 :   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
     505               0 :   sXFormsService->SelectAllItemsForSelect(DOMNode);
     506               0 :   return true;
     507                 : }
     508                 : 
     509                 : nsIContent*
     510               0 : nsXFormsSelectableAccessible::GetItemByIndex(PRUint32* aIndex,
     511                 :                                              nsAccessible* aAccessible)
     512                 : {
     513               0 :   nsAccessible* accessible = aAccessible ? aAccessible : this;
     514               0 :   PRInt32 childCount = accessible->GetChildCount();
     515               0 :   for (PRInt32 childIdx = 0; childIdx < childCount; childIdx++) {
     516               0 :     nsAccessible *child = accessible->GetChildAt(childIdx);
     517               0 :     nsIContent* childContent = child->GetContent();
     518               0 :     nsINodeInfo *nodeInfo = childContent->NodeInfo();
     519               0 :     if (nodeInfo->NamespaceEquals(NS_LITERAL_STRING(NS_NAMESPACE_XFORMS))) {
     520               0 :       if (nodeInfo->Equals(nsGkAtoms::item)) {
     521               0 :         if (!*aIndex)
     522               0 :           return childContent;
     523                 : 
     524               0 :         --*aIndex;
     525               0 :       } else if (nodeInfo->Equals(nsGkAtoms::choices)) {
     526               0 :         nsIContent* itemContent = GetItemByIndex(aIndex, child);
     527               0 :         if (itemContent)
     528               0 :           return itemContent;
     529                 :       }
     530                 :     }
     531                 :   }
     532                 : 
     533               0 :   return nsnull;
     534                 : }
     535                 : 
     536                 : 
     537                 : ////////////////////////////////////////////////////////////////////////////////
     538                 : // nsXFormsSelectableItemAccessible
     539                 : ////////////////////////////////////////////////////////////////////////////////
     540                 : 
     541               0 : nsXFormsSelectableItemAccessible::
     542                 :   nsXFormsSelectableItemAccessible(nsIContent* aContent,
     543                 :                                    nsDocAccessible* aDoc) :
     544               0 :   nsXFormsAccessible(aContent, aDoc)
     545                 : {
     546               0 : }
     547                 : 
     548                 : NS_IMETHODIMP
     549               0 : nsXFormsSelectableItemAccessible::GetValue(nsAString& aValue)
     550                 : {
     551               0 :   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
     552               0 :   return sXFormsService->GetValue(DOMNode, aValue);
     553                 : }
     554                 : 
     555                 : PRUint8
     556               0 : nsXFormsSelectableItemAccessible::ActionCount()
     557                 : {
     558               0 :   return 1;
     559                 : }
     560                 : 
     561                 : NS_IMETHODIMP
     562               0 : nsXFormsSelectableItemAccessible::DoAction(PRUint8 aIndex)
     563                 : {
     564               0 :   if (aIndex != eAction_Click)
     565               0 :     return NS_ERROR_INVALID_ARG;
     566                 : 
     567               0 :   DoCommand();
     568               0 :   return NS_OK;
     569                 : }
     570                 : 
     571                 : bool
     572               0 : nsXFormsSelectableItemAccessible::IsSelected()
     573                 : {
     574                 :   nsresult rv;
     575                 : 
     576               0 :   nsINode* parent = mContent;
     577               0 :   while ((parent = parent->GetNodeParent())) {
     578               0 :     nsCOMPtr<nsIContent> content(do_QueryInterface(parent));
     579               0 :     if (!content)
     580               0 :       return false;
     581                 : 
     582               0 :     nsCOMPtr<nsINodeInfo> nodeinfo = content->NodeInfo();
     583               0 :     if (!nodeinfo->NamespaceEquals(NS_LITERAL_STRING(NS_NAMESPACE_XFORMS)))
     584               0 :       continue;
     585                 : 
     586               0 :     nsCOMPtr<nsIDOMNode> select(do_QueryInterface(parent));
     587               0 :     if (!select)
     588               0 :       continue;
     589                 : 
     590               0 :     nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
     591               0 :     if (nodeinfo->Equals(nsGkAtoms::select)) {
     592               0 :       bool isSelected = false;
     593               0 :       rv = sXFormsService->IsSelectItemSelected(select, DOMNode, &isSelected);
     594               0 :       return NS_SUCCEEDED(rv) && isSelected;
     595                 :     }
     596                 : 
     597               0 :     if (nodeinfo->Equals(nsGkAtoms::select1)) {
     598               0 :       nsCOMPtr<nsIDOMNode> selitem;
     599                 :       rv = sXFormsService->GetSelectedItemForSelect1(select,
     600               0 :                                                      getter_AddRefs(selitem));
     601               0 :       return NS_SUCCEEDED(rv) && (selitem == DOMNode);
     602                 :     }
     603                 :   }
     604                 : 
     605               0 :   return false;
     606                 : }
     607                 : 

Generated by: LCOV version 1.7