/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "nsAccUtils.h"

#include "Accessible-inl.h"

#include "ARIAMap.h"

#include "nsAccessibilityService.h"

#include "nsCoreUtils.h"

#include "DocAccessible.h"

#include "HyperTextAccessible.h"

#include "nsIAccessibleTypes.h"

#include "Role.h"

#include "States.h"

#include "TextLeafAccessible.h"

#include "nsIDOMXULContainerElement.h"

#include "nsIPersistentProperties2.h"

#include "mozilla/dom/Element.h"

using namespace mozilla;

using namespace mozilla::a11y;

void

nsAccUtils::GetAccAttr(nsIPersistentProperties *aAttributes,

                       nsAtom *aAttrName, nsAString& aAttrValue)

{

  aAttrValue.Truncate();

  aAttributes->GetStringProperty(nsAtomCString(aAttrName), aAttrValue);

}

void

nsAccUtils::SetAccAttr(nsIPersistentProperties *aAttributes,

                       nsAtom *aAttrName, const nsAString& aAttrValue)

{

  nsAutoString oldValue;

  aAttributes->SetStringProperty(nsAtomCString(aAttrName), aAttrValue, oldValue);

}

void

nsAccUtils::SetAccAttr(nsIPersistentProperties *aAttributes,

                       nsAtom* aAttrName, nsAtom* aAttrValue)

{

  nsAutoString oldValue;

  aAttributes->SetStringProperty(nsAtomCString(aAttrName),

                                 nsAtomString(aAttrValue), oldValue);

}

void

nsAccUtils::SetAccGroupAttrs(nsIPersistentProperties *aAttributes,

                             int32_t aLevel, int32_t aSetSize,

                             int32_t aPosInSet)

{

  nsAutoString value;

  if (aLevel) {

    value.AppendInt(aLevel);

    SetAccAttr(aAttributes, nsGkAtoms::level, value);

  }

  if (aSetSize && aPosInSet) {

    value.Truncate();

    value.AppendInt(aPosInSet);

    SetAccAttr(aAttributes, nsGkAtoms::posinset, value);

    value.Truncate();

    value.AppendInt(aSetSize);

    SetAccAttr(aAttributes, nsGkAtoms::setsize, value);

  }

}

int32_t

nsAccUtils::GetDefaultLevel(const Accessible* aAccessible)

{

  roles::Role role = aAccessible->Role();

  if (role == roles::OUTLINEITEM)

    return 1;

  if (role == roles::ROW) {

    Accessible* parent = aAccessible->Parent();

    // It is a row inside flatten treegrid. Group level is always 1 until it

    // is overriden by aria-level attribute.

    if (parent && parent->Role() == roles::TREE_TABLE)

      return 1;

  }

  return 0;

}

int32_t

nsAccUtils::GetARIAOrDefaultLevel(const Accessible* aAccessible)

{

  int32_t level = 0;

  nsCoreUtils::GetUIntAttr(aAccessible->GetContent(),

                           nsGkAtoms::aria_level, &level);

  if (level != 0)

    return level;

  return GetDefaultLevel(aAccessible);

}

int32_t

nsAccUtils::GetLevelForXULContainerItem(nsIContent *aContent)

{

  nsCOMPtr<nsIDOMXULContainerItemElement> item(do_QueryInterface(aContent));

  if (!item)

    return 0;

  nsCOMPtr<nsIDOMXULContainerElement> container;

  item->GetParentContainer(getter_AddRefs(container));

  if (!container)

    return 0;

  // Get level of the item.

  int32_t level = -1;

  while (container) {

    level++;

    nsCOMPtr<nsIDOMXULContainerElement> parentContainer;

    container->GetParentContainer(getter_AddRefs(parentContainer));

    parentContainer.swap(container);

  }

  return level;

}

void

nsAccUtils::SetLiveContainerAttributes(nsIPersistentProperties *aAttributes,

                                       nsIContent* aStartContent,

                                       dom::Element* aTopEl)

{

  nsAutoString live, relevant, busy;

  nsIContent* ancestor = aStartContent;

  while (ancestor) {

    // container-relevant attribute

    if (relevant.IsEmpty() &&

        HasDefinedARIAToken(ancestor, nsGkAtoms::aria_relevant) &&

        ancestor->AsElement()->GetAttr(kNameSpaceID_None,

                                       nsGkAtoms::aria_relevant, relevant))

      SetAccAttr(aAttributes, nsGkAtoms::containerRelevant, relevant);

    // container-live, and container-live-role attributes

    if (live.IsEmpty()) {

      const nsRoleMapEntry* role = nullptr;

      if (ancestor->IsElement()) {

        role = aria::GetRoleMap(ancestor->AsElement());

      }

      if (HasDefinedARIAToken(ancestor, nsGkAtoms::aria_live)) {

        ancestor->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::aria_live, live);

      } else if (role) {

        GetLiveAttrValue(role->liveAttRule, live);

      }

      if (!live.IsEmpty()) {

        SetAccAttr(aAttributes, nsGkAtoms::containerLive, live);

        if (role) {

          SetAccAttr(aAttributes, nsGkAtoms::containerLiveRole,

                     role->ARIARoleString());

        }

      }

    }

    // container-atomic attribute

    if (ancestor->IsElement() &&

        ancestor->AsElement()->AttrValueIs(kNameSpaceID_None,

                                           nsGkAtoms::aria_atomic,

                                           nsGkAtoms::_true, eCaseMatters)) {

      SetAccAttr(aAttributes, nsGkAtoms::containerAtomic,

                 NS_LITERAL_STRING("true"));

    }

    // container-busy attribute

    if (busy.IsEmpty() &&

        HasDefinedARIAToken(ancestor, nsGkAtoms::aria_busy) &&

        ancestor->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::aria_busy, busy))

      SetAccAttr(aAttributes, nsGkAtoms::containerBusy, busy);

    if (ancestor == aTopEl)

      break;

    ancestor = ancestor->GetParent();

    if (!ancestor)

      ancestor = aTopEl; // Use <body>/<frameset>

  }

}

bool

nsAccUtils::HasDefinedARIAToken(nsIContent *aContent, nsAtom *aAtom)

{

  NS_ASSERTION(aContent, "aContent is null in call to HasDefinedARIAToken!");

  if (!aContent->IsElement())

    return false;

  Element* element = aContent->AsElement();

  if (!element->HasAttr(kNameSpaceID_None, aAtom) ||

      element->AttrValueIs(kNameSpaceID_None, aAtom, nsGkAtoms::_empty,

                           eCaseMatters) ||

      element->AttrValueIs(kNameSpaceID_None, aAtom, nsGkAtoms::_undefined,

                           eCaseMatters)) {

        return false;

  }

  return true;

}

nsAtom*

nsAccUtils::GetARIAToken(dom::Element* aElement, nsAtom* aAttr)

{

  if (!HasDefinedARIAToken(aElement, aAttr))

    return nsGkAtoms::_empty;

  static Element::AttrValuesArray tokens[] =

    { &nsGkAtoms::_false, &nsGkAtoms::_true,

      &nsGkAtoms::mixed, nullptr};

  int32_t idx = aElement->FindAttrValueIn(kNameSpaceID_None,

                                          aAttr, tokens, eCaseMatters);

  if (idx >= 0)

    return *(tokens[idx]);

  return nullptr;

}

Accessible*

nsAccUtils::GetSelectableContainer(Accessible* aAccessible, uint64_t aState)

{

  if (!aAccessible)

    return nullptr;

  if (!(aState & states::SELECTABLE))

    return nullptr;

  Accessible* parent = aAccessible;

  while ((parent = parent->Parent()) && !parent->IsSelect()) {

    if (parent->Role() == roles::PANE)

      return nullptr;

  }

  return parent;

}

bool

nsAccUtils::IsDOMAttrTrue(const Accessible* aAccessible, nsAtom* aAttr)

{

  dom::Element* el = aAccessible->Elm();

  return el && el->AttrValueIs(kNameSpaceID_None, aAttr, nsGkAtoms::_true,

                               eCaseMatters);

}

Accessible*

nsAccUtils::TableFor(Accessible* aRow)

{

  if (aRow) {

    Accessible* table = aRow->Parent();

    if (table) {

      roles::Role tableRole = table->Role();

      if (tableRole == roles::GROUPING) { // if there's a rowgroup.

        table = table->Parent();

        if (table)

          tableRole = table->Role();

      }

      return (tableRole == roles::TABLE || tableRole == roles::TREE_TABLE ||

              tableRole == roles::MATHML_TABLE) ? table : nullptr;

    }

  }

  return nullptr;

}

HyperTextAccessible*

nsAccUtils::GetTextContainer(nsINode* aNode)

{

  // Get text accessible containing the result node.

  DocAccessible* doc =

    GetAccService()->GetDocAccessible(aNode->OwnerDoc());

  Accessible* accessible =

    doc ? doc->GetAccessibleOrContainer(aNode) : nullptr;

  if (!accessible)

    return nullptr;

  do {

    HyperTextAccessible* textAcc = accessible->AsHyperText();

    if (textAcc)

      return textAcc;

    accessible = accessible->Parent();

  } while (accessible);

  return nullptr;

}

nsIntPoint

nsAccUtils::ConvertToScreenCoords(int32_t aX, int32_t aY,

                                  uint32_t aCoordinateType,

                                  Accessible* aAccessible)

{

  nsIntPoint coords(aX, aY);

  switch (aCoordinateType) {

    case nsIAccessibleCoordinateType::COORDTYPE_SCREEN_RELATIVE:

      break;

    case nsIAccessibleCoordinateType::COORDTYPE_WINDOW_RELATIVE:

    {

      coords += nsCoreUtils::GetScreenCoordsForWindow(aAccessible->GetNode());

      break;

    }

    case nsIAccessibleCoordinateType::COORDTYPE_PARENT_RELATIVE:

    {

      coords += GetScreenCoordsForParent(aAccessible);

      break;

    }

    default:

      MOZ_ASSERT_UNREACHABLE("invalid coord type!");

  }

  return coords;

}

void

nsAccUtils::ConvertScreenCoordsTo(int32_t *aX, int32_t *aY,

                                  uint32_t aCoordinateType,

                                  Accessible* aAccessible)

{

  switch (aCoordinateType) {

    case nsIAccessibleCoordinateType::COORDTYPE_SCREEN_RELATIVE:

      break;

    case nsIAccessibleCoordinateType::COORDTYPE_WINDOW_RELATIVE:

    {

      nsIntPoint coords = nsCoreUtils::GetScreenCoordsForWindow(aAccessible->GetNode());

      *aX -= coords.x;

      *aY -= coords.y;

      break;

    }

    case nsIAccessibleCoordinateType::COORDTYPE_PARENT_RELATIVE:

    {

      nsIntPoint coords = GetScreenCoordsForParent(aAccessible);

      *aX -= coords.x;

      *aY -= coords.y;

      break;

    }

    default:

      MOZ_ASSERT_UNREACHABLE("invalid coord type!");

  }

}

nsIntPoint

nsAccUtils::GetScreenCoordsForParent(Accessible* aAccessible)

{

  Accessible* parent = aAccessible->Parent();

  if (!parent)

    return nsIntPoint(0, 0);

  nsIFrame *parentFrame = parent->GetFrame();

  if (!parentFrame)

    return nsIntPoint(0, 0);

  nsRect rect = parentFrame->GetScreenRectInAppUnits();

  return nsPoint(rect.X(), rect.Y()).

    ToNearestPixels(parentFrame->PresContext()->AppUnitsPerDevPixel());

}

bool

nsAccUtils::GetLiveAttrValue(uint32_t aRule, nsAString& aValue)

{

  switch (aRule) {

    case eOffLiveAttr:

      aValue = NS_LITERAL_STRING("off");

      return true;

    case ePoliteLiveAttr:

      aValue = NS_LITERAL_STRING("polite");

      return true;

  }

  return false;

}

#ifdef DEBUG

bool

nsAccUtils::IsTextInterfaceSupportCorrect(Accessible* aAccessible)

{

  // Don't test for accessible docs, it makes us create accessibles too

  // early and fire mutation events before we need to

  if (aAccessible->IsDoc())

    return true;

  bool foundText = false;

  uint32_t childCount = aAccessible->ChildCount();

  for (uint32_t childIdx = 0; childIdx < childCount; childIdx++) {

    Accessible* child = aAccessible->GetChildAt(childIdx);

    if (child->IsText()) {

      foundText = true;

      break;

    }

  }

  return !foundText || aAccessible->IsHyperText();

}

#endif

uint32_t

nsAccUtils::TextLength(Accessible* aAccessible)

{

  if (!aAccessible->IsText()) {

    return 1;

  }

  TextLeafAccessible* textLeaf = aAccessible->AsTextLeaf();

  if (textLeaf)

    return textLeaf->Text().Length();

  // For list bullets (or anything other accessible which would compute its own

  // text. They don't have their own frame.

  // XXX In the future, list bullets may have frame and anon content, so

  // we should be able to remove this at that point

  nsAutoString text;

  aAccessible->AppendTextTo(text); // Get all the text

  return text.Length();

}

bool

nsAccUtils::MustPrune(Accessible* aAccessible)

{

  roles::Role role = aAccessible->Role();

  return

    // Always prune the tree for sliders, as it doesn't make sense for a slider

    // to have descendants and this confuses NVDA.

    role == roles::SLIDER ||

    // Don't prune the tree for certain roles if the tree is more complex than

    // a single text leaf.

    (

     (

      role == roles::MENUITEM ||

      role == roles::COMBOBOX_OPTION ||

      role == roles::OPTION ||

      role == roles::ENTRY ||

      role == roles::FLAT_EQUATION ||

      role == roles::PASSWORD_TEXT ||

      role == roles::PUSHBUTTON ||

      role == roles::TOGGLE_BUTTON ||

      role == roles::GRAPHIC ||

      role == roles::PROGRESSBAR ||

      role == roles::SEPARATOR

     ) &&

     aAccessible->ContentChildCount() == 1 &&

     aAccessible->ContentChildAt(0)->IsTextLeaf()

    );

}