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 :
|