The Tor Browser: accessible/src/base/TextAttrs.h@b8a032363ba2 (annotated)

accessible/src/base/TextAttrs.h@b8a032363ba2 (annotated)

accessible/src/base/TextAttrs.h

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- 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 / annotate

accessible/src/base/TextAttrs.h@b8a032363ba2 (annotated)

accessible/src/base/TextAttrs.h