nsComputedDOMStyle.h

mozilla-central/layout/style/nsComputedDOMStyle.h (file symbol)

Enable keyboard shortcuts

Source code

Revision control

Copy as Markdown

Other Tools

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

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

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

/* DOM object returned from element.getComputedStyle() */

#ifndef nsComputedDOMStyle_h__

#define nsComputedDOMStyle_h__

#include "mozilla/Attributes.h"

#include "mozilla/StyleColorInlines.h"

#include "mozilla/UniquePtr.h"

#include "nsCOMPtr.h"

#include "nsContentUtils.h"

#include "nscore.h"

#include "nsDOMCSSDeclaration.h"

#include "mozilla/ComputedStyle.h"

#include "nsIWeakReferenceUtils.h"

#include "mozilla/gfx/Types.h"

#include "nsCoord.h"

#include "nsColor.h"

#include "nsStubMutationObserver.h"

#include "nsStyleStruct.h"

#include "mozilla/WritingModes.h"

// XXX Avoid including this here by moving function bodies to the cpp file

#include "mozilla/dom/Element.h"

namespace mozilla {

enum class FlushType : uint8_t;

enum class PseudoStyleType : uint8_t;

namespace dom {

class DocGroup;

class Element;

}  // namespace dom

class PresShell;

struct ComputedGridTrackInfo;

}  // namespace mozilla

struct ComputedStyleMap;

struct nsCSSKTableEntry;

class nsIFrame;

class nsDOMCSSValueList;

struct nsMargin;

class nsROCSSPrimitiveValue;

class nsStyleGradient;

class nsComputedDOMStyle final : public nsDOMCSSDeclaration,

                                 public nsStubMutationObserver {

 private:

  // Convenience typedefs:

  template <typename T>

  using Span = mozilla::Span<T>;

  using KTableEntry = nsCSSKTableEntry;

  using CSSValue = mozilla::dom::CSSValue;

  using StyleGeometryBox = mozilla::StyleGeometryBox;

  using Element = mozilla::dom::Element;

  using Document = mozilla::dom::Document;

  using PseudoStyleType = mozilla::PseudoStyleType;

  using LengthPercentage = mozilla::LengthPercentage;

  using LengthPercentageOrAuto = mozilla::LengthPercentageOrAuto;

  using ComputedStyle = mozilla::ComputedStyle;

 public:

  NS_DECL_CYCLE_COLLECTING_ISUPPORTS

  NS_DECL_CYCLE_COLLECTION_SKIPPABLE_WRAPPERCACHE_CLASS_AMBIGUOUS(

      nsComputedDOMStyle, nsICSSDeclaration)

  NS_DECL_NSIDOMCSSSTYLEDECLARATION_HELPER

  void GetPropertyValue(const nsCSSPropertyID aPropID,

                        nsACString& aValue) override;

  void SetPropertyValue(const nsCSSPropertyID aPropID, const nsACString& aValue,

                        nsIPrincipal* aSubjectPrincipal,

                        mozilla::ErrorResult& aRv) override;

  void IndexedGetter(uint32_t aIndex, bool& aFound,

                     nsACString& aPropName) final;

  enum class StyleType : uint8_t {

    DefaultOnly,  // Only includes UA and user sheets

    All           // Includes all stylesheets

};

  // In some cases, for legacy reasons, we forcefully return an empty style.

  enum class AlwaysReturnEmptyStyle : bool { No, Yes };

  nsComputedDOMStyle(Element*, PseudoStyleType,

                     nsAtom* aFunctionalPseudoParameter, Document*, StyleType,

                     AlwaysReturnEmptyStyle = AlwaysReturnEmptyStyle::No);

  nsINode* GetAssociatedNode() const override { return mElement; }

  nsINode* GetParentObject() const override { return mElement; }

  static already_AddRefed<const ComputedStyle> GetComputedStyle(

      Element* aElement, PseudoStyleType = PseudoStyleType::NotPseudo,

      nsAtom* aFunctionalPseudoParameter = nullptr, StyleType = StyleType::All);

  static already_AddRefed<const ComputedStyle> GetComputedStyleNoFlush(

      const Element* aElement,

      PseudoStyleType aPseudo = PseudoStyleType::NotPseudo,

      nsAtom* aFunctionalPseudoParameter = nullptr,

      StyleType aStyleType = StyleType::All) {

    return DoGetComputedStyleNoFlush(

        aElement, aPseudo, aFunctionalPseudoParameter,

        nsContentUtils::GetPresShellForContent(aElement), aStyleType);

  static already_AddRefed<const ComputedStyle>

  GetUnanimatedComputedStyleNoFlush(

      Element*, PseudoStyleType = PseudoStyleType::NotPseudo,

      nsAtom* aFunctionalPseudoParameter = nullptr);

  // Helper for nsDOMWindowUtils::GetVisitedDependentComputedStyle

  void SetExposeVisitedStyle(bool aExpose) {

    NS_ASSERTION(aExpose != mExposeVisitedStyle, "should always be changing");

    mExposeVisitedStyle = aExpose;

  float UsedFontSize() final;

  void GetCSSImageURLs(const nsACString& aPropertyName,

                       nsTArray<nsCString>& aImageURLs,

                       mozilla::ErrorResult& aRv) final;

  // nsDOMCSSDeclaration abstract methods which should never be called

  // on a nsComputedDOMStyle object, but must be defined to avoid

  // compile errors.

  mozilla::DeclarationBlock* GetOrCreateCSSDeclaration(

      Operation aOperation, mozilla::DeclarationBlock** aCreated) final;

  virtual nsresult SetCSSDeclaration(mozilla::DeclarationBlock*,

                                     mozilla::MutationClosureData*) override;

  virtual mozilla::dom::Document* DocToUpdate() final;

  nsDOMCSSDeclaration::ParsingEnvironment GetParsingEnvironment(

      nsIPrincipal* aSubjectPrincipal) const final;

  static already_AddRefed<nsROCSSPrimitiveValue> MatrixToCSSValue(

      const mozilla::gfx::Matrix4x4& aMatrix);

  static void RegisterPrefChangeCallbacks();

  static void UnregisterPrefChangeCallbacks();

  // nsIMutationObserver

  NS_DECL_NSIMUTATIONOBSERVER_PARENTCHAINCHANGED

 private:

  already_AddRefed<nsROCSSPrimitiveValue> AppUnitsToCSSValue(nscoord);

  already_AddRefed<nsROCSSPrimitiveValue> PixelsToCSSValue(float);

  void SetValueToPixels(nsROCSSPrimitiveValue*, float);

  void GetPropertyValue(const nsCSSPropertyID aPropID,

                        const nsACString& aMaybeCustomPropertyNme,

                        nsACString& aValue);

  using nsDOMCSSDeclaration::GetPropertyValue;

  virtual ~nsComputedDOMStyle();

  void AssertFlushedPendingReflows() {

    NS_ASSERTION(mFlushedPendingReflows,

                 "property getter should have been marked layout-dependent");

  nsMargin GetAdjustedValuesForBoxSizing();

  // This indicates error by leaving mComputedStyle null.

  void UpdateCurrentStyleSources(nsCSSPropertyID);

  void ClearCurrentStyleSources();

  // Helper functions called by UpdateCurrentStyleSources.

  void ClearComputedStyle();

  void SetResolvedComputedStyle(RefPtr<const ComputedStyle>&& aContext,

                                uint64_t aGeneration);

  void SetFrameComputedStyle(ComputedStyle* aStyle, uint64_t aGeneration);

  static already_AddRefed<const ComputedStyle> DoGetComputedStyleNoFlush(

      const Element*, PseudoStyleType, nsAtom* aFunctionalPseudoParameter,

      mozilla::PresShell*, StyleType);

#define STYLE_STRUCT(name_)                \

  const nsStyle##name_* Style##name_() {   \

    return mComputedStyle->Style##name_(); \

#include "nsStyleStructList.h"

#undef STYLE_STRUCT

/**

   * A method to get a percentage base for a percentage value.  Returns true

   * if a percentage base value was determined, false otherwise.

*/

  typedef bool (nsComputedDOMStyle::*PercentageBaseGetter)(nscoord&);

  already_AddRefed<CSSValue> GetOffsetWidthFor(mozilla::Side);

  already_AddRefed<CSSValue> GetAbsoluteOffset(mozilla::Side);

  nscoord GetUsedAbsoluteOffset(mozilla::Side);

  already_AddRefed<CSSValue> GetNonStaticPositionOffset(

      mozilla::Side aSide, bool aResolveAuto, PercentageBaseGetter aWidthGetter,

      PercentageBaseGetter aHeightGetter);

  already_AddRefed<CSSValue> GetStaticOffset(mozilla::Side aSide);

  already_AddRefed<CSSValue> GetPaddingWidthFor(mozilla::Side aSide);

  already_AddRefed<CSSValue> GetBorderWidthFor(mozilla::Side aSide);

  already_AddRefed<CSSValue> GetMarginFor(mozilla::Side aSide);

  already_AddRefed<CSSValue> GetTransformValue(const mozilla::StyleTransform&);

  already_AddRefed<nsROCSSPrimitiveValue> GetGridTrackSize(

      const mozilla::StyleTrackSize&);

  already_AddRefed<nsROCSSPrimitiveValue> GetGridTrackBreadth(

      const mozilla::StyleTrackBreadth&);

  void SetValueToTrackBreadth(nsROCSSPrimitiveValue*,

                              const mozilla::StyleTrackBreadth&);

  already_AddRefed<CSSValue> GetGridTemplateColumnsRows(

      const mozilla::StyleGridTemplateComponent& aTrackList,

      const mozilla::ComputedGridTrackInfo& aTrackInfo);

  bool GetLineHeightCoord(nscoord& aCoord);

  bool ShouldHonorMinSizeAutoInAxis(mozilla::PhysicalAxis aAxis);

  /* Properties queryable as CSSValues.

   * To avoid a name conflict with nsIDOM*CSS2Properties, these are all

   * DoGetXXX instead of GetXXX.

*/

  /* Box properties */

  already_AddRefed<CSSValue> DoGetWidth();

  already_AddRefed<CSSValue> DoGetHeight();

  already_AddRefed<CSSValue> DoGetMaxHeight();

  already_AddRefed<CSSValue> DoGetMaxWidth();

  already_AddRefed<CSSValue> DoGetMinHeight();

  already_AddRefed<CSSValue> DoGetMinWidth();

  already_AddRefed<CSSValue> DoGetLeft();

  already_AddRefed<CSSValue> DoGetTop();

  already_AddRefed<CSSValue> DoGetRight();

  already_AddRefed<CSSValue> DoGetBottom();

  /* Font properties */

  already_AddRefed<CSSValue> DoGetMozOsxFontSmoothing();

  /* Grid properties */

  already_AddRefed<CSSValue> DoGetGridTemplateColumns();

  already_AddRefed<CSSValue> DoGetGridTemplateRows();

  /* StyleImageLayer properties */

  already_AddRefed<CSSValue> DoGetImageLayerPosition(

      const nsStyleImageLayers& aLayers);

  /* Padding properties */

  already_AddRefed<CSSValue> DoGetPaddingTop();

  already_AddRefed<CSSValue> DoGetPaddingBottom();

  already_AddRefed<CSSValue> DoGetPaddingLeft();

  already_AddRefed<CSSValue> DoGetPaddingRight();

  /* Table Properties */

  already_AddRefed<CSSValue> DoGetBorderSpacing();

  /* Border Properties */

  already_AddRefed<CSSValue> DoGetBorderTopWidth();

  already_AddRefed<CSSValue> DoGetBorderBottomWidth();

  already_AddRefed<CSSValue> DoGetBorderLeftWidth();

  already_AddRefed<CSSValue> DoGetBorderRightWidth();

  /* Margin Properties */

  already_AddRefed<CSSValue> DoGetMarginTop();

  already_AddRefed<CSSValue> DoGetMarginBottom();

  already_AddRefed<CSSValue> DoGetMarginLeft();

  already_AddRefed<CSSValue> DoGetMarginRight();

  /* Display properties */

  already_AddRefed<CSSValue> DoGetTransform();

  already_AddRefed<CSSValue> DoGetTransformOrigin();

  already_AddRefed<CSSValue> DoGetPerspectiveOrigin();

  // For working around a MSVC bug. See related comment in

  // GenerateComputedDOMStyleGenerated.py.

  already_AddRefed<CSSValue> DummyGetter();

  /* Helper functions */

  void SetValueToPosition(const mozilla::Position& aPosition,

                          nsDOMCSSValueList* aValueList);

  void SetValueFromFitContentFunction(nsROCSSPrimitiveValue* aValue,

                                      const mozilla::LengthPercentage&);

  void SetValueToSize(nsROCSSPrimitiveValue* aValue, const mozilla::StyleSize&);

  void SetValueToLengthPercentageOrAuto(nsROCSSPrimitiveValue* aValue,

                                        const LengthPercentageOrAuto&,

                                        bool aClampNegativeCalc);

  void SetValueToLengthPercentage(nsROCSSPrimitiveValue* aValue,

                                  const LengthPercentage&,

                                  bool aClampNegativeCalc);

  void SetValueToMaxSize(nsROCSSPrimitiveValue* aValue,

                         const mozilla::StyleMaxSize&);

  bool GetCBContentWidth(nscoord& aWidth);

  bool GetCBContentHeight(nscoord& aHeight);

  bool GetCBPaddingRectWidth(nscoord& aWidth);

  bool GetCBPaddingRectHeight(nscoord& aHeight);

  bool GetScrollFrameContentWidth(nscoord& aWidth);

  bool GetScrollFrameContentHeight(nscoord& aHeight);

  bool GetFrameBorderRectWidth(nscoord& aWidth);

  bool GetFrameBorderRectHeight(nscoord& aHeight);

  // Find out if we can safely skip flushing (i.e. pending restyles do not

  // affect our element).

  bool NeedsToFlushStyle(nsCSSPropertyID) const;

  // Find out if we need to flush layout of the document, depending on the

  // property that was requested.

  bool NeedsToFlushLayout(nsCSSPropertyID) const;

  // Find out if we need to flush layout of the document due to container

  // query being made before relevant query containers are reflowed at least

  // once.

  bool NeedsToFlushLayoutForContainerQuery() const;

  // Flushes the given document, which must be our document, and potentially the

  // mElement's document.

  void Flush(Document&, mozilla::FlushType);

  nsIFrame* GetOuterFrame() const;

  static ComputedStyleMap* GetComputedStyleMap();

  // We don't really have a good immutable representation of "presentation".

  // Given the way GetComputedStyle is currently used, we should just grab the

  // presshell, if any, from the document.

  mozilla::WeakPtr<mozilla::dom::Document> mDocumentWeak;

  RefPtr<Element> mElement;

/**

   * Strong reference to the ComputedStyle we access data from.  This can be

   * either a ComputedStyle we resolved ourselves or a ComputedStyle we got

   * from our frame.

   * If we got the ComputedStyle from the frame, we clear out mComputedStyle

   * in ClearCurrentStyleSources.  If we resolved one ourselves, then

   * ClearCurrentStyleSources leaves it in mComputedStyle for use the next

   * time this nsComputedDOMStyle object is queried.  UpdateCurrentStyleSources

   * in this case will check that the ComputedStyle is still valid to be used,

   * by checking whether flush styles results in any restyles having been

   * processed.

*/

  RefPtr<const ComputedStyle> mComputedStyle;

/*

   * While computing style data, the primary frame for mContent --- named

   * "outer" because we should use it to compute positioning data.  Null

   * otherwise.

*/

  nsIFrame* mOuterFrame;

/*

   * While computing style data, the "inner frame" for mContent --- the frame

   * which we should use to compute margin, border, padding and content data.

   * Null otherwise.

*/

  nsIFrame* mInnerFrame;

/*

   * While computing style data, the presshell we're working with.  Null

   * otherwise.

*/

  mozilla::PresShell* mPresShell;

  PseudoStyleType mPseudo;

  RefPtr<nsAtom> mFunctionalPseudoParameter;

  /* The kind of styles we should be returning. */

  StyleType mStyleType;

  /* Whether for legacy reasons we return an empty style (when an unknown

   * pseudo-element is specified) */

  AlwaysReturnEmptyStyle mAlwaysReturnEmpty;

/**

   * The nsComputedDOMStyle generation at the time we last resolved a style

   * context and stored it in mComputedStyle, and the pres shell we got the

   * style from. Should only be used together.

*/

  uint64_t mComputedStyleGeneration = 0;

  uint32_t mPresShellId = 0;

  bool mExposeVisitedStyle = false;

/**

   * Whether we resolved a ComputedStyle last time we called

   * UpdateCurrentStyleSources.  Initially false.

*/

  bool mResolvedComputedStyle = false;

#ifdef DEBUG

  bool mFlushedPendingReflows = false;

#endif

  friend struct ComputedStyleMap;

};

already_AddRefed<nsComputedDOMStyle> NS_NewComputedDOMStyle(

    mozilla::dom::Element*, const nsAString& aPseudoElt,

    mozilla::dom::Document*, nsComputedDOMStyle::StyleType,

    mozilla::ErrorResult&);

#endif /* nsComputedDOMStyle_h__ */