The Tor Browser: comparison accessible/src/base/TextAttrs.h

--1:000000000000
+:98f932253725
+/* -*- 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/. */
+#ifndef nsTextAttrs_h_
+#define nsTextAttrs_h_
+#include "nsCOMPtr.h"
+#include "nsColor.h"
+#include "nsStyleConsts.h"
+class nsIFrame;
+class nsIPersistentProperties;
+class nsIContent;
+class nsDeviceContext;
+namespace mozilla {
+namespace a11y {
+class Accessible;
+class HyperTextAccessible;
+/**
+* Used to expose text attributes for the hyper text accessible (see
+* HyperTextAccessible class).
+*
+* @note "invalid: spelling" text attribute is implemented entirely in
+*       HyperTextAccessible class.
+*/
+class TextAttrsMgr
+{
+public:
+/**
+* Constructor. Used to expose default text attributes.
+*/
+TextAttrsMgr(HyperTextAccessible* aHyperTextAcc) :
+mOffsetAcc(nullptr),  mHyperTextAcc(aHyperTextAcc),
+mOffsetAccIdx(-1), mIncludeDefAttrs(true) { }
+/**
+* Constructor. Used to expose text attributes at the given offset.
+*
+* @param aHyperTextAcc    [in] hyper text accessible text attributes are
+*                          calculated for
+* @param aIncludeDefAttrs [optional] indicates whether default text
+*                          attributes should be included into list of exposed
+*                          text attributes
+* @param oOffsetAcc       [optional] offset an accessible the text attributes
+*                          should be calculated for
+* @param oOffsetAccIdx    [optional] index in parent of offset accessible
+*/
+TextAttrsMgr(HyperTextAccessible* aHyperTextAcc,
+bool aIncludeDefAttrs,
+Accessible* aOffsetAcc,
+int32_t aOffsetAccIdx) :
+mOffsetAcc(aOffsetAcc), mHyperTextAcc(aHyperTextAcc),
+mOffsetAccIdx(aOffsetAccIdx), mIncludeDefAttrs(aIncludeDefAttrs) { }
+/*
+* Return text attributes and hyper text offsets where these attributes are
+* applied. Offsets are calculated in the case of non default attributes.
+*
+* @note In the case of default attributes pointers on hyper text offsets
+*       must be skipped.
+*
+* @param aAttributes    [in, out] text attributes list
+* @param aStartHTOffset [out, optional] start hyper text offset
+* @param aEndHTOffset   [out, optional] end hyper text offset
+*/
+void GetAttributes(nsIPersistentProperties* aAttributes,
+int32_t* aStartHTOffset = nullptr,
+int32_t* aEndHTOffset = nullptr);
+protected:
+/**
+* Calculates range (start and end offsets) of text where the text attributes
+* are stretched. New offsets may be smaller if one of text attributes changes
+* its value before or after the given offsets.
+*
+* @param aTextAttrArray  [in] text attributes array
+* @param aAttrArrayLen   [in] text attributes array length
+* @param aStartHTOffset  [in, out] the start offset
+* @param aEndHTOffset    [in, out] the end offset
+*/
+class TextAttr;
+void GetRange(TextAttr* aAttrArray[], uint32_t aAttrArrayLen,
+int32_t* aStartHTOffset, int32_t* aEndHTOffset);
+private:
+Accessible* mOffsetAcc;
+HyperTextAccessible* mHyperTextAcc;
+int32_t mOffsetAccIdx;
+bool mIncludeDefAttrs;
+protected:
+/**
+* Interface class of text attribute class implementations.
+*/
+class TextAttr
+{
+public:
+/**
+* Expose the text attribute to the given attribute set.
+*
+* @param aAttributes           [in] the given attribute set
+* @param aIncludeDefAttrValue  [in] if true then attribute is exposed even
+*                               if its value is the same as default one
+*/
+virtual void Expose(nsIPersistentProperties* aAttributes,
+bool aIncludeDefAttrValue) = 0;
+/**
+* Return true if the text attribute value on the given element equals with
+* predefined attribute value.
+*/
+virtual bool Equal(Accessible* aAccessible) = 0;
+};
+/**
+* Base class to work with text attributes. See derived classes below.
+*/
+template<class T>
+class TTextAttr : public TextAttr
+{
+public:
+TTextAttr(bool aGetRootValue) : mGetRootValue(aGetRootValue) {}
+// TextAttr
+virtual void Expose(nsIPersistentProperties* aAttributes,
+bool aIncludeDefAttrValue)
+{
+if (mGetRootValue) {
+if (mIsRootDefined)
+ExposeValue(aAttributes, mRootNativeValue);
+return;
+}
+if (mIsDefined) {
+if (aIncludeDefAttrValue || mRootNativeValue != mNativeValue)
+ExposeValue(aAttributes, mNativeValue);
+return;
+}
+if (aIncludeDefAttrValue && mIsRootDefined)
+ExposeValue(aAttributes, mRootNativeValue);
+}
+virtual bool Equal(Accessible* aAccessible)
+{
+T nativeValue;
+bool isDefined = GetValueFor(aAccessible, &nativeValue);
+if (!mIsDefined && !isDefined)
+return true;
+if (mIsDefined && isDefined)
+return nativeValue == mNativeValue;
+if (mIsDefined)
+return mNativeValue == mRootNativeValue;
+return nativeValue == mRootNativeValue;
+}
+protected:
+// Expose the text attribute with the given value to attribute set.
+virtual void ExposeValue(nsIPersistentProperties* aAttributes,
+const T& aValue) = 0;
+// Return native value for the given DOM element.
+virtual bool GetValueFor(Accessible* aAccessible, T* aValue) = 0;
+// Indicates if root value should be exposed.
+bool mGetRootValue;
+// Native value and flag indicating if the value is defined (initialized in
+// derived classes). Note, undefined native value means it is inherited
+// from root.
+T mNativeValue;
+bool mIsDefined;
+// Native root value and flag indicating if the value is defined  (initialized
+// in derived classes).
+T mRootNativeValue;
+bool mIsRootDefined;
+};
+/**
+* Class is used for the work with 'language' text attribute.
+*/
+class LangTextAttr : public TTextAttr<nsString>
+{
+public:
+LangTextAttr(HyperTextAccessible* aRoot, nsIContent* aRootElm,
+nsIContent* aElm);
+virtual ~LangTextAttr();
+protected:
+// TextAttr
+virtual bool GetValueFor(Accessible* aAccessible, nsString* aValue);
+virtual void ExposeValue(nsIPersistentProperties* aAttributes,
+const nsString& aValue);
+private:
+nsCOMPtr<nsIContent> mRootContent;
+};
+/**
+* Class is used for the 'invalid' text attribute. Note, it calculated
+* the attribute from aria-invalid attribute only; invalid:spelling attribute
+* calculated from misspelled text in the editor is managed by
+* HyperTextAccessible and applied on top of the value from aria-invalid.
+*/
+class InvalidTextAttr : public TTextAttr<uint32_t>
+{
+public:
+InvalidTextAttr(nsIContent* aRootElm, nsIContent* aElm);
+virtual ~InvalidTextAttr() { };
+protected:
+enum {
+eFalse,
+eGrammar,
+eSpelling,
+eTrue
+};
+// TextAttr
+virtual bool GetValueFor(Accessible* aAccessible, uint32_t* aValue);
+virtual void ExposeValue(nsIPersistentProperties* aAttributes,
+const uint32_t& aValue);
+private:
+bool GetValue(nsIContent* aElm, uint32_t* aValue);
+nsIContent* mRootElm;
+};
+/**
+* Class is used for the work with 'background-color' text attribute.
+*/
+class BGColorTextAttr : public TTextAttr<nscolor>
+{
+public:
+BGColorTextAttr(nsIFrame* aRootFrame, nsIFrame* aFrame);
+virtual ~BGColorTextAttr() { }
+protected:
+// TextAttr
+virtual bool GetValueFor(Accessible* aAccessible, nscolor* aValue);
+virtual void ExposeValue(nsIPersistentProperties* aAttributes,
+const nscolor& aValue);
+private:
+bool GetColor(nsIFrame* aFrame, nscolor* aColor);
+nsIFrame* mRootFrame;
+};
+/**
+* Class is used for the work with 'color' text attribute.
+*/
+class ColorTextAttr : public TTextAttr<nscolor>
+{
+public:
+ColorTextAttr(nsIFrame* aRootFrame, nsIFrame* aFrame);
+virtual ~ColorTextAttr() { }
+protected:
+// TTextAttr
+virtual bool GetValueFor(Accessible* aAccessible, nscolor* aValue);
+virtual void ExposeValue(nsIPersistentProperties* aAttributes,
+const nscolor& aValue);
+};
+/**
+* Class is used for the work with "font-family" text attribute.
+*/
+class FontFamilyTextAttr : public TTextAttr<nsString>
+{
+public:
+FontFamilyTextAttr(nsIFrame* aRootFrame, nsIFrame* aFrame);
+virtual ~FontFamilyTextAttr() { }
+protected:
+// TTextAttr
+virtual bool GetValueFor(Accessible* aAccessible, nsString* aValue);
+virtual void ExposeValue(nsIPersistentProperties* aAttributes,
+const nsString& aValue);
+private:
+bool GetFontFamily(nsIFrame* aFrame, nsString& aFamily);
+};
+/**
+* Class is used for the work with "font-size" text attribute.
+*/
+class FontSizeTextAttr : public TTextAttr<nscoord>
+{
+public:
+FontSizeTextAttr(nsIFrame* aRootFrame, nsIFrame* aFrame);
+virtual ~FontSizeTextAttr() { }
+protected:
+// TTextAttr
+virtual bool GetValueFor(Accessible* aAccessible, nscoord* aValue);
+virtual void ExposeValue(nsIPersistentProperties* aAttributes,
+const nscoord& aValue);
+private:
+nsDeviceContext* mDC;
+};
+/**
+* Class is used for the work with "font-style" text attribute.
+*/
+class FontStyleTextAttr : public TTextAttr<nscoord>
+{
+public:
+FontStyleTextAttr(nsIFrame* aRootFrame, nsIFrame* aFrame);
+virtual ~FontStyleTextAttr() { }
+protected:
+// TTextAttr
+virtual bool GetValueFor(Accessible* aContent, nscoord* aValue);
+virtual void ExposeValue(nsIPersistentProperties* aAttributes,
+const nscoord& aValue);
+};
+/**
+* Class is used for the work with "font-weight" text attribute.
+*/
+class FontWeightTextAttr : public TTextAttr<int32_t>
+{
+public:
+FontWeightTextAttr(nsIFrame* aRootFrame, nsIFrame* aFrame);
+virtual ~FontWeightTextAttr() { }
+protected:
+// TTextAttr
+virtual bool GetValueFor(Accessible* aAccessible, int32_t* aValue);
+virtual void ExposeValue(nsIPersistentProperties* aAttributes,
+const int32_t& aValue);
+private:
+int32_t GetFontWeight(nsIFrame* aFrame);
+};
+/**
+* Class is used for the work with 'auto-generated' text attribute.
+*/
+class AutoGeneratedTextAttr : public TTextAttr<bool>
+{
+public:
+AutoGeneratedTextAttr(HyperTextAccessible* aHyperTextAcc,
+Accessible* aAccessible);
+virtual ~AutoGeneratedTextAttr() { }
+protected:
+// TextAttr
+virtual bool GetValueFor(Accessible* aAccessible, bool* aValue);
+virtual void ExposeValue(nsIPersistentProperties* aAttributes,
+const bool& aValue);
+};
+/**
+* TextDecorTextAttr class is used for the work with
+* "text-line-through-style", "text-line-through-color",
+* "text-underline-style" and "text-underline-color" text attributes.
+*/
+class TextDecorValue
+{
+public:
+TextDecorValue() { }
+TextDecorValue(nsIFrame* aFrame);
+nscolor Color() const { return mColor; }
+uint8_t Style() const { return mStyle; }
+bool IsDefined() const
+{ return IsUnderline() || IsLineThrough(); }
+bool IsUnderline() const
+{ return mLine & NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE; }
+bool IsLineThrough() const
+{ return mLine & NS_STYLE_TEXT_DECORATION_LINE_LINE_THROUGH; }
+bool operator ==(const TextDecorValue& aValue)
+{
+return mColor == aValue.mColor && mLine == aValue.mLine &&
+mStyle == aValue.mStyle;
+}
+bool operator !=(const TextDecorValue& aValue)
+{ return !(*this == aValue); }
+private:
+nscolor mColor;
+uint8_t mLine;
+uint8_t mStyle;
+};
+class TextDecorTextAttr : public TTextAttr<TextDecorValue>
+{
+public:
+TextDecorTextAttr(nsIFrame* aRootFrame, nsIFrame* aFrame);
+virtual ~TextDecorTextAttr() { }
+protected:
+// TextAttr
+virtual bool GetValueFor(Accessible* aAccessible, TextDecorValue* aValue);
+virtual void ExposeValue(nsIPersistentProperties* aAttributes,
+const TextDecorValue& aValue);
+};
+/**
+* Class is used for the work with "text-position" text attribute.
+*/
+enum TextPosValue {
+eTextPosNone = 0,
+eTextPosBaseline,
+eTextPosSub,
+eTextPosSuper
+};
+class TextPosTextAttr : public TTextAttr<TextPosValue>
+{
+public:
+TextPosTextAttr(nsIFrame* aRootFrame, nsIFrame* aFrame);
+virtual ~TextPosTextAttr() { }
+protected:
+// TextAttr
+virtual bool GetValueFor(Accessible* aAccessible, TextPosValue* aValue);
+virtual void ExposeValue(nsIPersistentProperties* aAttributes,
+const TextPosValue& aValue);
+private:
+TextPosValue GetTextPosValue(nsIFrame* aFrame) const;
+};
+}; // TextAttrMgr
+} // namespace a11y
+} // namespace mozilla
+#endif

The Tor Browser / file comparison

comparison: accessible/src/base/TextAttrs.h

accessible/src/base/TextAttrs.h