diff options
Diffstat (limited to '')
| -rw-r--r-- | accessible/base/TextAttrs.cpp | 816 |
1 files changed, 816 insertions, 0 deletions
diff --git a/accessible/base/TextAttrs.cpp b/accessible/base/TextAttrs.cpp new file mode 100644 index 0000000000..e1ca62e549 --- /dev/null +++ b/accessible/base/TextAttrs.cpp @@ -0,0 +1,816 @@ +/* -*- 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 "TextAttrs.h" + +#include "AccAttributes.h" +#include "nsAccUtils.h" +#include "nsCoreUtils.h" +#include "StyleInfo.h" + +#include "gfxTextRun.h" +#include "nsFontMetrics.h" +#include "nsLayoutUtils.h" +#include "nsContainerFrame.h" +#include "HyperTextAccessible.h" +#include "mozilla/AppUnits.h" + +using namespace mozilla; +using namespace mozilla::a11y; + +//////////////////////////////////////////////////////////////////////////////// +// TextAttrsMgr +//////////////////////////////////////////////////////////////////////////////// + +void TextAttrsMgr::GetAttributes(AccAttributes* aAttributes, + uint32_t* aStartOffset, uint32_t* aEndOffset) { + // 1. Hyper text accessible must be specified always. + // 2. Offset accessible must be specified in + // the case of text attributes. Result hyper text offsets are optional if you + // just want the attributes for a single text Accessible. + // 3. Offset accessible and result hyper text offsets must not be specified + // but include default text attributes flag and attributes list must be + // specified in the case of default text attributes. + MOZ_ASSERT( + mHyperTextAcc && ((mOffsetAcc && mOffsetAccIdx != -1) || + (!mOffsetAcc && mOffsetAccIdx == -1 && !aStartOffset && + !aEndOffset && mIncludeDefAttrs && aAttributes)), + "Wrong usage of TextAttrsMgr!"); + + // Embedded objects are combined into own range with empty attributes set. + if (mOffsetAcc && !mOffsetAcc->IsText()) { + if (!aStartOffset) { + return; + } + for (int32_t childIdx = mOffsetAccIdx - 1; childIdx >= 0; childIdx--) { + LocalAccessible* currAcc = mHyperTextAcc->LocalChildAt(childIdx); + if (currAcc->IsText()) break; + + (*aStartOffset)--; + } + + uint32_t childCount = mHyperTextAcc->ChildCount(); + for (uint32_t childIdx = mOffsetAccIdx + 1; childIdx < childCount; + childIdx++) { + LocalAccessible* currAcc = mHyperTextAcc->LocalChildAt(childIdx); + if (currAcc->IsText()) break; + + (*aEndOffset)++; + } + + return; + } + + // Get the content and frame of the accessible. In the case of document + // accessible it's role content and root frame. + nsIContent* hyperTextElm = mHyperTextAcc->GetContent(); + if (!hyperTextElm) { + return; // XXX: we don't support text attrs on document with no body + } + + nsIFrame* rootFrame = mHyperTextAcc->GetFrame(); + if (!rootFrame) { + return; + } + + nsIContent *offsetNode = nullptr, *offsetElm = nullptr; + nsIFrame* frame = nullptr; + if (mOffsetAcc) { + offsetNode = mOffsetAcc->GetContent(); + offsetElm = nsCoreUtils::GetDOMElementFor(offsetNode); + MOZ_ASSERT(offsetElm, "No element for offset accessible!"); + if (!offsetElm) return; + + frame = offsetElm->GetPrimaryFrame(); + } + + // "language" text attribute + LangTextAttr langTextAttr(mHyperTextAcc, hyperTextElm, offsetNode); + + // "aria-invalid" text attribute + InvalidTextAttr invalidTextAttr(hyperTextElm, offsetNode); + + // "background-color" text attribute + BGColorTextAttr bgColorTextAttr(rootFrame, frame); + + // "color" text attribute + ColorTextAttr colorTextAttr(rootFrame, frame); + + // "font-family" text attribute + FontFamilyTextAttr fontFamilyTextAttr(rootFrame, frame); + + // "font-size" text attribute + FontSizeTextAttr fontSizeTextAttr(rootFrame, frame); + + // "font-style" text attribute + FontStyleTextAttr fontStyleTextAttr(rootFrame, frame); + + // "font-weight" text attribute + FontWeightTextAttr fontWeightTextAttr(rootFrame, frame); + + // "auto-generated" text attribute + AutoGeneratedTextAttr autoGenTextAttr(mHyperTextAcc, mOffsetAcc); + + // "text-underline(line-through)-style(color)" text attributes + TextDecorTextAttr textDecorTextAttr(rootFrame, frame); + + // "text-position" text attribute + TextPosTextAttr textPosTextAttr(rootFrame, frame, hyperTextElm, offsetNode); + + TextAttr* attrArray[] = { + &langTextAttr, &invalidTextAttr, &bgColorTextAttr, + &colorTextAttr, &fontFamilyTextAttr, &fontSizeTextAttr, + &fontStyleTextAttr, &fontWeightTextAttr, &autoGenTextAttr, + &textDecorTextAttr, &textPosTextAttr}; + + // Expose text attributes if applicable. + if (aAttributes) { + for (uint32_t idx = 0; idx < ArrayLength(attrArray); idx++) { + attrArray[idx]->Expose(aAttributes, mIncludeDefAttrs); + } + } + + // Expose text attributes range where they are applied if applicable. + if (aStartOffset) { + GetRange(attrArray, ArrayLength(attrArray), aStartOffset, aEndOffset); + } +} + +void TextAttrsMgr::GetRange(TextAttr* aAttrArray[], uint32_t aAttrArrayLen, + uint32_t* aStartOffset, uint32_t* aEndOffset) { + // Navigate backward from anchor accessible to find start offset. + for (int32_t childIdx = mOffsetAccIdx - 1; childIdx >= 0; childIdx--) { + LocalAccessible* currAcc = mHyperTextAcc->LocalChildAt(childIdx); + + // Stop on embedded accessible since embedded accessibles are combined into + // own range. + if (!currAcc->IsText()) break; + + MOZ_ASSERT(nsCoreUtils::GetDOMElementFor(currAcc->GetContent()), + "Text accessible has to have an associated DOM element"); + + bool offsetFound = false; + for (uint32_t attrIdx = 0; attrIdx < aAttrArrayLen; attrIdx++) { + TextAttr* textAttr = aAttrArray[attrIdx]; + if (!textAttr->Equal(currAcc)) { + offsetFound = true; + break; + } + } + + if (offsetFound) break; + + *(aStartOffset) -= nsAccUtils::TextLength(currAcc); + } + + // Navigate forward from anchor accessible to find end offset. + uint32_t childLen = mHyperTextAcc->ChildCount(); + for (uint32_t childIdx = mOffsetAccIdx + 1; childIdx < childLen; childIdx++) { + LocalAccessible* currAcc = mHyperTextAcc->LocalChildAt(childIdx); + if (!currAcc->IsText()) break; + + MOZ_ASSERT(nsCoreUtils::GetDOMElementFor(currAcc->GetContent()), + "Text accessible has to have an associated DOM element"); + + bool offsetFound = false; + for (uint32_t attrIdx = 0; attrIdx < aAttrArrayLen; attrIdx++) { + TextAttr* textAttr = aAttrArray[attrIdx]; + + // Alter the end offset when text attribute changes its value and stop + // the search. + if (!textAttr->Equal(currAcc)) { + offsetFound = true; + break; + } + } + + if (offsetFound) break; + + (*aEndOffset) += nsAccUtils::TextLength(currAcc); + } +} + +//////////////////////////////////////////////////////////////////////////////// +// LangTextAttr +//////////////////////////////////////////////////////////////////////////////// + +TextAttrsMgr::LangTextAttr::LangTextAttr(HyperTextAccessible* aRoot, + nsIContent* aRootElm, nsIContent* aElm) + : TTextAttr<nsString>(!aElm), mRootContent(aRootElm) { + aRoot->Language(mRootNativeValue); + mIsRootDefined = !mRootNativeValue.IsEmpty(); + + if (aElm) { + nsCoreUtils::GetLanguageFor(aElm, mRootContent, mNativeValue); + mIsDefined = !mNativeValue.IsEmpty(); + } +} + +TextAttrsMgr::LangTextAttr::~LangTextAttr() {} + +bool TextAttrsMgr::LangTextAttr::GetValueFor(LocalAccessible* aAccessible, + nsString* aValue) { + nsCoreUtils::GetLanguageFor(aAccessible->GetContent(), mRootContent, *aValue); + return !aValue->IsEmpty(); +} + +void TextAttrsMgr::LangTextAttr::ExposeValue(AccAttributes* aAttributes, + const nsString& aValue) { + RefPtr<nsAtom> lang = NS_Atomize(aValue); + aAttributes->SetAttribute(nsGkAtoms::language, lang); +} + +//////////////////////////////////////////////////////////////////////////////// +// InvalidTextAttr +//////////////////////////////////////////////////////////////////////////////// + +TextAttrsMgr::InvalidTextAttr::InvalidTextAttr(nsIContent* aRootElm, + nsIContent* aElm) + : TTextAttr<uint32_t>(!aElm), mRootElm(aRootElm) { + mIsRootDefined = GetValue(mRootElm, &mRootNativeValue); + if (aElm) mIsDefined = GetValue(aElm, &mNativeValue); +} + +bool TextAttrsMgr::InvalidTextAttr::GetValueFor(LocalAccessible* aAccessible, + uint32_t* aValue) { + nsIContent* elm = nsCoreUtils::GetDOMElementFor(aAccessible->GetContent()); + return elm ? GetValue(elm, aValue) : false; +} + +void TextAttrsMgr::InvalidTextAttr::ExposeValue(AccAttributes* aAttributes, + const uint32_t& aValue) { + switch (aValue) { + case eFalse: + aAttributes->SetAttribute(nsGkAtoms::invalid, nsGkAtoms::_false); + break; + + case eGrammar: + aAttributes->SetAttribute(nsGkAtoms::invalid, nsGkAtoms::grammar); + break; + + case eSpelling: + aAttributes->SetAttribute(nsGkAtoms::invalid, nsGkAtoms::spelling); + break; + + case eTrue: + aAttributes->SetAttribute(nsGkAtoms::invalid, nsGkAtoms::_true); + break; + } +} + +bool TextAttrsMgr::InvalidTextAttr::GetValue(nsIContent* aElm, + uint32_t* aValue) { + nsIContent* elm = aElm; + do { + if (nsAccUtils::HasDefinedARIAToken(elm, nsGkAtoms::aria_invalid)) { + static dom::Element::AttrValuesArray tokens[] = { + nsGkAtoms::_false, nsGkAtoms::grammar, nsGkAtoms::spelling, nullptr}; + + int32_t idx = nsAccUtils::FindARIAAttrValueIn( + elm->AsElement(), nsGkAtoms::aria_invalid, tokens, eCaseMatters); + switch (idx) { + case 0: + *aValue = eFalse; + return true; + case 1: + *aValue = eGrammar; + return true; + case 2: + *aValue = eSpelling; + return true; + default: + *aValue = eTrue; + return true; + } + } + } while ((elm = elm->GetParent()) && elm != mRootElm); + + return false; +} + +//////////////////////////////////////////////////////////////////////////////// +// BGColorTextAttr +//////////////////////////////////////////////////////////////////////////////// + +TextAttrsMgr::BGColorTextAttr::BGColorTextAttr(nsIFrame* aRootFrame, + nsIFrame* aFrame) + : TTextAttr<nscolor>(!aFrame), mRootFrame(aRootFrame) { + mIsRootDefined = GetColor(mRootFrame, &mRootNativeValue); + if (aFrame) mIsDefined = GetColor(aFrame, &mNativeValue); +} + +bool TextAttrsMgr::BGColorTextAttr::GetValueFor(LocalAccessible* aAccessible, + nscolor* aValue) { + nsIContent* elm = nsCoreUtils::GetDOMElementFor(aAccessible->GetContent()); + if (elm) { + nsIFrame* frame = elm->GetPrimaryFrame(); + if (frame) { + return GetColor(frame, aValue); + } + } + return false; +} + +void TextAttrsMgr::BGColorTextAttr::ExposeValue(AccAttributes* aAttributes, + const nscolor& aValue) { + aAttributes->SetAttribute(nsGkAtoms::backgroundColor, Color{aValue}); +} + +bool TextAttrsMgr::BGColorTextAttr::GetColor(nsIFrame* aFrame, + nscolor* aColor) { + nscolor backgroundColor = aFrame->StyleBackground()->BackgroundColor(aFrame); + if (NS_GET_A(backgroundColor) > 0) { + *aColor = backgroundColor; + return true; + } + + nsContainerFrame* parentFrame = aFrame->GetParent(); + if (!parentFrame) { + *aColor = aFrame->PresContext()->DefaultBackgroundColor(); + return true; + } + + // Each frame of parents chain for the initially passed 'aFrame' has + // transparent background color. So background color isn't changed from + // 'mRootFrame' to initially passed 'aFrame'. + if (parentFrame == mRootFrame) return false; + + return GetColor(parentFrame, aColor); +} + +//////////////////////////////////////////////////////////////////////////////// +// ColorTextAttr +//////////////////////////////////////////////////////////////////////////////// + +TextAttrsMgr::ColorTextAttr::ColorTextAttr(nsIFrame* aRootFrame, + nsIFrame* aFrame) + : TTextAttr<nscolor>(!aFrame) { + mRootNativeValue = aRootFrame->StyleText()->mColor.ToColor(); + mIsRootDefined = true; + + if (aFrame) { + mNativeValue = aFrame->StyleText()->mColor.ToColor(); + mIsDefined = true; + } +} + +bool TextAttrsMgr::ColorTextAttr::GetValueFor(LocalAccessible* aAccessible, + nscolor* aValue) { + nsIContent* elm = nsCoreUtils::GetDOMElementFor(aAccessible->GetContent()); + if (elm) { + if (nsIFrame* frame = elm->GetPrimaryFrame()) { + *aValue = frame->StyleText()->mColor.ToColor(); + return true; + } + } + return false; +} + +void TextAttrsMgr::ColorTextAttr::ExposeValue(AccAttributes* aAttributes, + const nscolor& aValue) { + aAttributes->SetAttribute(nsGkAtoms::color, Color{aValue}); +} + +//////////////////////////////////////////////////////////////////////////////// +// FontFamilyTextAttr +//////////////////////////////////////////////////////////////////////////////// + +TextAttrsMgr::FontFamilyTextAttr::FontFamilyTextAttr(nsIFrame* aRootFrame, + nsIFrame* aFrame) + : TTextAttr<nsString>(!aFrame) { + mIsRootDefined = GetFontFamily(aRootFrame, mRootNativeValue); + + if (aFrame) mIsDefined = GetFontFamily(aFrame, mNativeValue); +} + +bool TextAttrsMgr::FontFamilyTextAttr::GetValueFor(LocalAccessible* aAccessible, + nsString* aValue) { + nsIContent* elm = nsCoreUtils::GetDOMElementFor(aAccessible->GetContent()); + if (elm) { + nsIFrame* frame = elm->GetPrimaryFrame(); + if (frame) { + return GetFontFamily(frame, *aValue); + } + } + return false; +} + +void TextAttrsMgr::FontFamilyTextAttr::ExposeValue(AccAttributes* aAttributes, + const nsString& aValue) { + RefPtr<nsAtom> family = NS_Atomize(aValue); + aAttributes->SetAttribute(nsGkAtoms::font_family, family); +} + +bool TextAttrsMgr::FontFamilyTextAttr::GetFontFamily(nsIFrame* aFrame, + nsString& aFamily) { + RefPtr<nsFontMetrics> fm = + nsLayoutUtils::GetFontMetricsForFrame(aFrame, 1.0f); + + gfxFontGroup* fontGroup = fm->GetThebesFontGroup(); + RefPtr<gfxFont> font = fontGroup->GetFirstValidFont(); + gfxFontEntry* fontEntry = font->GetFontEntry(); + aFamily.Append(NS_ConvertUTF8toUTF16(fontEntry->FamilyName())); + return true; +} + +//////////////////////////////////////////////////////////////////////////////// +// FontSizeTextAttr +//////////////////////////////////////////////////////////////////////////////// + +TextAttrsMgr::FontSizeTextAttr::FontSizeTextAttr(nsIFrame* aRootFrame, + nsIFrame* aFrame) + : TTextAttr<nscoord>(!aFrame) { + mDC = aRootFrame->PresContext()->DeviceContext(); + + mRootNativeValue = aRootFrame->StyleFont()->mSize.ToAppUnits(); + mIsRootDefined = true; + + if (aFrame) { + mNativeValue = aFrame->StyleFont()->mSize.ToAppUnits(); + mIsDefined = true; + } +} + +bool TextAttrsMgr::FontSizeTextAttr::GetValueFor(LocalAccessible* aAccessible, + nscoord* aValue) { + nsIContent* el = nsCoreUtils::GetDOMElementFor(aAccessible->GetContent()); + if (el) { + nsIFrame* frame = el->GetPrimaryFrame(); + if (frame) { + *aValue = frame->StyleFont()->mSize.ToAppUnits(); + return true; + } + } + return false; +} + +void TextAttrsMgr::FontSizeTextAttr::ExposeValue(AccAttributes* aAttributes, + const nscoord& aValue) { + // Convert from nscoord to pt. + // + // Note: according to IA2, "The conversion doesn't have to be exact. + // The intent is to give the user a feel for the size of the text." + // + // ATK does not specify a unit and will likely follow IA2 here. + // + // XXX todo: consider sharing this code with layout module? (bug 474621) + float px = NSAppUnitsToFloatPixels(aValue, mozilla::AppUnitsPerCSSPixel()); + // Each pt is 4/3 of a CSS pixel. + FontSize fontSize{NS_lround(px * 3 / 4)}; + + aAttributes->SetAttribute(nsGkAtoms::font_size, fontSize); +} + +//////////////////////////////////////////////////////////////////////////////// +// FontStyleTextAttr +//////////////////////////////////////////////////////////////////////////////// + +TextAttrsMgr::FontStyleTextAttr::FontStyleTextAttr(nsIFrame* aRootFrame, + nsIFrame* aFrame) + : TTextAttr<FontSlantStyle>(!aFrame) { + mRootNativeValue = aRootFrame->StyleFont()->mFont.style; + mIsRootDefined = true; + + if (aFrame) { + mNativeValue = aFrame->StyleFont()->mFont.style; + mIsDefined = true; + } +} + +bool TextAttrsMgr::FontStyleTextAttr::GetValueFor(LocalAccessible* aAccessible, + FontSlantStyle* aValue) { + nsIContent* elm = nsCoreUtils::GetDOMElementFor(aAccessible->GetContent()); + if (elm) { + nsIFrame* frame = elm->GetPrimaryFrame(); + if (frame) { + *aValue = frame->StyleFont()->mFont.style; + return true; + } + } + return false; +} + +void TextAttrsMgr::FontStyleTextAttr::ExposeValue( + AccAttributes* aAttributes, const FontSlantStyle& aValue) { + if (aValue.IsNormal()) { + aAttributes->SetAttribute(nsGkAtoms::font_style, nsGkAtoms::normal); + } else if (aValue.IsItalic()) { + RefPtr<nsAtom> atom = NS_Atomize("italic"); + aAttributes->SetAttribute(nsGkAtoms::font_style, atom); + } else { + nsAutoCString s; + aValue.ToString(s); + nsString wide; + CopyUTF8toUTF16(s, wide); + aAttributes->SetAttribute(nsGkAtoms::font_style, std::move(wide)); + } +} + +//////////////////////////////////////////////////////////////////////////////// +// FontWeightTextAttr +//////////////////////////////////////////////////////////////////////////////// + +TextAttrsMgr::FontWeightTextAttr::FontWeightTextAttr(nsIFrame* aRootFrame, + nsIFrame* aFrame) + : TTextAttr<FontWeight>(!aFrame) { + mRootNativeValue = GetFontWeight(aRootFrame); + mIsRootDefined = true; + + if (aFrame) { + mNativeValue = GetFontWeight(aFrame); + mIsDefined = true; + } +} + +bool TextAttrsMgr::FontWeightTextAttr::GetValueFor(LocalAccessible* aAccessible, + FontWeight* aValue) { + nsIContent* elm = nsCoreUtils::GetDOMElementFor(aAccessible->GetContent()); + if (elm) { + nsIFrame* frame = elm->GetPrimaryFrame(); + if (frame) { + *aValue = GetFontWeight(frame); + return true; + } + } + return false; +} + +void TextAttrsMgr::FontWeightTextAttr::ExposeValue(AccAttributes* aAttributes, + const FontWeight& aValue) { + int value = aValue.ToIntRounded(); + aAttributes->SetAttribute(nsGkAtoms::fontWeight, value); +} + +FontWeight TextAttrsMgr::FontWeightTextAttr::GetFontWeight(nsIFrame* aFrame) { + // nsFont::width isn't suitable here because it's necessary to expose real + // value of font weight (used font might not have some font weight values). + RefPtr<nsFontMetrics> fm = + nsLayoutUtils::GetFontMetricsForFrame(aFrame, 1.0f); + + gfxFontGroup* fontGroup = fm->GetThebesFontGroup(); + RefPtr<gfxFont> font = fontGroup->GetFirstValidFont(); + + // When there doesn't exist a bold font in the family and so the rendering of + // a non-bold font face is changed so that the user sees what looks like a + // bold font, i.e. synthetic bolding is used. (Simply returns false on any + // platforms that don't use the multi-strike synthetic bolding.) + if (font->ApplySyntheticBold()) { + return FontWeight::BOLD; + } + + // On Windows, font->GetStyle()->weight will give the same weight as + // fontEntry->Weight(), the weight of the first font in the font group, + // which may not be the weight of the font face used to render the + // characters. On Mac, font->GetStyle()->weight will just give the same + // number as getComputedStyle(). fontEntry->Weight() will give the weight + // range supported by the font face used, so we clamp the weight that was + // requested by style to what is actually supported by the font. + gfxFontEntry* fontEntry = font->GetFontEntry(); + return fontEntry->Weight().Clamp(font->GetStyle()->weight); +} + +//////////////////////////////////////////////////////////////////////////////// +// AutoGeneratedTextAttr +//////////////////////////////////////////////////////////////////////////////// +TextAttrsMgr::AutoGeneratedTextAttr::AutoGeneratedTextAttr( + HyperTextAccessible* aHyperTextAcc, LocalAccessible* aAccessible) + : TTextAttr<bool>(!aAccessible) { + mRootNativeValue = false; + mIsRootDefined = false; + + if (aAccessible) { + mIsDefined = mNativeValue = + ((aAccessible->NativeRole() == roles::STATICTEXT) || + (aAccessible->NativeRole() == roles::LISTITEM_MARKER)); + } +} + +bool TextAttrsMgr::AutoGeneratedTextAttr::GetValueFor( + LocalAccessible* aAccessible, bool* aValue) { + return *aValue = (aAccessible->NativeRole() == roles::STATICTEXT); +} + +void TextAttrsMgr::AutoGeneratedTextAttr::ExposeValue( + AccAttributes* aAttributes, const bool& aValue) { + aAttributes->SetAttribute(nsGkAtoms::auto_generated, aValue); +} + +//////////////////////////////////////////////////////////////////////////////// +// TextDecorTextAttr +//////////////////////////////////////////////////////////////////////////////// + +TextAttrsMgr::TextDecorValue::TextDecorValue(nsIFrame* aFrame) { + const nsStyleTextReset* textReset = aFrame->StyleTextReset(); + mStyle = textReset->mTextDecorationStyle; + mColor = textReset->mTextDecorationColor.CalcColor(aFrame); + mLine = + textReset->mTextDecorationLine & (StyleTextDecorationLine::UNDERLINE | + StyleTextDecorationLine::LINE_THROUGH); +} + +TextAttrsMgr::TextDecorTextAttr::TextDecorTextAttr(nsIFrame* aRootFrame, + nsIFrame* aFrame) + : TTextAttr<TextDecorValue>(!aFrame) { + mRootNativeValue = TextDecorValue(aRootFrame); + mIsRootDefined = mRootNativeValue.IsDefined(); + + if (aFrame) { + mNativeValue = TextDecorValue(aFrame); + mIsDefined = mNativeValue.IsDefined(); + } +} + +bool TextAttrsMgr::TextDecorTextAttr::GetValueFor(LocalAccessible* aAccessible, + TextDecorValue* aValue) { + nsIContent* elm = nsCoreUtils::GetDOMElementFor(aAccessible->GetContent()); + if (elm) { + nsIFrame* frame = elm->GetPrimaryFrame(); + if (frame) { + *aValue = TextDecorValue(frame); + return aValue->IsDefined(); + } + } + return false; +} + +void TextAttrsMgr::TextDecorTextAttr::ExposeValue( + AccAttributes* aAttributes, const TextDecorValue& aValue) { + if (aValue.IsUnderline()) { + RefPtr<nsAtom> underlineStyle = + StyleInfo::TextDecorationStyleToAtom(aValue.Style()); + aAttributes->SetAttribute(nsGkAtoms::textUnderlineStyle, underlineStyle); + + aAttributes->SetAttribute(nsGkAtoms::textUnderlineColor, + Color{aValue.Color()}); + return; + } + + if (aValue.IsLineThrough()) { + RefPtr<nsAtom> lineThroughStyle = + StyleInfo::TextDecorationStyleToAtom(aValue.Style()); + aAttributes->SetAttribute(nsGkAtoms::textLineThroughStyle, + lineThroughStyle); + + aAttributes->SetAttribute(nsGkAtoms::textLineThroughColor, + Color{aValue.Color()}); + } +} + +//////////////////////////////////////////////////////////////////////////////// +// TextPosTextAttr +//////////////////////////////////////////////////////////////////////////////// + +TextAttrsMgr::TextPosTextAttr::TextPosTextAttr(nsIFrame* aRootFrame, + nsIFrame* aFrame, + nsIContent* aRootElm, + nsIContent* aElm) + : TTextAttr<Maybe<TextPosValue>>(!aFrame && !aElm), mRootElm(aRootElm) { + // Get the text-position values for the roots and children. + // If we find an ARIA text-position value on a DOM element - searching up + // from the supplied root DOM element - use the associated frame as the root + // frame. This ensures that we're using the proper root frame for comparison. + nsIFrame* ariaFrame = nullptr; + Maybe<TextPosValue> rootAria = GetAriaTextPosValue(aRootElm, ariaFrame); + if (rootAria && ariaFrame) { + aRootFrame = ariaFrame; + } + Maybe<TextPosValue> rootLayout = GetLayoutTextPosValue(aRootFrame); + Maybe<TextPosValue> childLayout; + Maybe<TextPosValue> childAria; + if (aFrame) { + childLayout = GetLayoutTextPosValue(aFrame); + } + if (aElm) { + childAria = GetAriaTextPosValue(aElm); + } + + // Aria values take precedence over layout values. + mIsRootDefined = rootAria || rootLayout; + mRootNativeValue = rootAria ? rootAria : rootLayout; + mIsDefined = childAria || childLayout; + mNativeValue = childAria ? childAria : childLayout; + + // If there's no child text-position information from ARIA, and the child + // layout info is equivalent to the root layout info (i.e., it's inherited), + // then we should prefer the root information. + if (!childAria && childLayout == rootLayout) { + mIsDefined = false; + } +} + +bool TextAttrsMgr::TextPosTextAttr::GetValueFor(LocalAccessible* aAccessible, + Maybe<TextPosValue>* aValue) { + nsIContent* elm = nsCoreUtils::GetDOMElementFor(aAccessible->GetContent()); + if (elm) { + nsIFrame* frame = elm->GetPrimaryFrame(); + if (frame) { + Maybe<TextPosValue> layoutValue = GetLayoutTextPosValue(frame); + Maybe<TextPosValue> ariaValue = GetAriaTextPosValue(elm); + + *aValue = ariaValue ? ariaValue : layoutValue; + return aValue->isSome(); + } + } + return false; +} + +void TextAttrsMgr::TextPosTextAttr::ExposeValue( + AccAttributes* aAttributes, const Maybe<TextPosValue>& aValue) { + if (aValue.isNothing()) { + return; + } + + RefPtr<nsAtom> atom = nullptr; + switch (*aValue) { + case eTextPosBaseline: + atom = nsGkAtoms::baseline; + break; + + case eTextPosSub: + atom = nsGkAtoms::sub; + break; + + case eTextPosSuper: + atom = NS_Atomize("super"); + break; + } + + if (atom) { + aAttributes->SetAttribute(nsGkAtoms::textPosition, atom); + } +} + +Maybe<TextAttrsMgr::TextPosValue> +TextAttrsMgr::TextPosTextAttr::GetAriaTextPosValue(nsIContent* aElm) const { + nsIFrame* ariaFrame = nullptr; + return GetAriaTextPosValue(aElm, ariaFrame); +} + +Maybe<TextAttrsMgr::TextPosValue> +TextAttrsMgr::TextPosTextAttr::GetAriaTextPosValue(nsIContent* aElm, + nsIFrame*& ariaFrame) const { + // Search for the superscript and subscript roles that imply text-position. + const nsIContent* elm = aElm; + do { + if (elm->IsElement()) { + const mozilla::dom::Element* domElm = elm->AsElement(); + static const dom::Element::AttrValuesArray tokens[] = { + nsGkAtoms::subscript, nsGkAtoms::superscript, nullptr}; + const int32_t valueIdx = domElm->FindAttrValueIn( + kNameSpaceID_None, nsGkAtoms::role, tokens, eCaseMatters); + ariaFrame = domElm->GetPrimaryFrame(); + if (valueIdx == 0) { + return Some(eTextPosSub); + } + if (valueIdx == 1) { + return Some(eTextPosSuper); + } + } + } while ((elm = elm->GetParent()) && elm != mRootElm); + + ariaFrame = nullptr; + return Nothing{}; +} + +Maybe<TextAttrsMgr::TextPosValue> +TextAttrsMgr::TextPosTextAttr::GetLayoutTextPosValue(nsIFrame* aFrame) const { + const auto& verticalAlign = aFrame->StyleDisplay()->mVerticalAlign; + if (verticalAlign.IsKeyword()) { + switch (verticalAlign.AsKeyword()) { + case StyleVerticalAlignKeyword::Baseline: + return Some(eTextPosBaseline); + case StyleVerticalAlignKeyword::Sub: + return Some(eTextPosSub); + case StyleVerticalAlignKeyword::Super: + return Some(eTextPosSuper); + // No good guess for the rest, so do not expose value of text-position + // attribute. + default: + return Nothing{}; + } + } + + const auto& length = verticalAlign.AsLength(); + if (length.ConvertsToPercentage()) { + const float percentValue = length.ToPercentage(); + return percentValue > 0 ? Some(eTextPosSuper) + : (percentValue < 0 ? Some(eTextPosSub) + : Some(eTextPosBaseline)); + } + + if (length.ConvertsToLength()) { + const nscoord coordValue = length.ToLength(); + return coordValue > 0 + ? Some(eTextPosSuper) + : (coordValue < 0 ? Some(eTextPosSub) : Some(eTextPosBaseline)); + } + + if (const nsIContent* content = aFrame->GetContent()) { + if (content->IsHTMLElement(nsGkAtoms::sup)) return Some(eTextPosSuper); + if (content->IsHTMLElement(nsGkAtoms::sub)) return Some(eTextPosSub); + } + + return Nothing{}; +} |