michael@0: /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
michael@0: /* This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: /*
michael@0:  * structs that contain the data provided by nsStyleContext, the
michael@0:  * internal API for computed style data for an element
michael@0:  */
michael@0: 
michael@0: #ifndef nsStyleStruct_h___
michael@0: #define nsStyleStruct_h___
michael@0: 
michael@0: #include "mozilla/Attributes.h"
michael@0: #include "mozilla/CSSVariableValues.h"
michael@0: #include "nsColor.h"
michael@0: #include "nsCoord.h"
michael@0: #include "nsMargin.h"
michael@0: #include "nsRect.h"
michael@0: #include "nsFont.h"
michael@0: #include "nsStyleCoord.h"
michael@0: #include "nsStyleConsts.h"
michael@0: #include "nsChangeHint.h"
michael@0: #include "nsPresContext.h"
michael@0: #include "nsCOMPtr.h"
michael@0: #include "nsCOMArray.h"
michael@0: #include "nsTArray.h"
michael@0: #include "nsIAtom.h"
michael@0: #include "nsCSSValue.h"
michael@0: #include "imgRequestProxy.h"
michael@0: #include "Orientation.h"
michael@0: #include <algorithm>
michael@0: 
michael@0: class nsIFrame;
michael@0: class nsIURI;
michael@0: class imgIContainer;
michael@0: 
michael@0: // Includes nsStyleStructID.
michael@0: #include "nsStyleStructFwd.h"
michael@0: 
michael@0: // Bits for each struct.
michael@0: // NS_STYLE_INHERIT_BIT defined in nsStyleStructFwd.h
michael@0: #define NS_STYLE_INHERIT_MASK              0x000ffffff
michael@0: 
michael@0: // Additional bits for nsStyleContext's mBits:
michael@0: // See nsStyleContext::HasTextDecorationLines
michael@0: #define NS_STYLE_HAS_TEXT_DECORATION_LINES 0x001000000
michael@0: // See nsStyleContext::HasPseudoElementData.
michael@0: #define NS_STYLE_HAS_PSEUDO_ELEMENT_DATA   0x002000000
michael@0: // See nsStyleContext::RelevantLinkIsVisited
michael@0: #define NS_STYLE_RELEVANT_LINK_VISITED     0x004000000
michael@0: // See nsStyleContext::IsStyleIfVisited
michael@0: #define NS_STYLE_IS_STYLE_IF_VISITED       0x008000000
michael@0: // See nsStyleContext::GetPseudoEnum
michael@0: #define NS_STYLE_CONTEXT_TYPE_MASK         0x1f0000000
michael@0: #define NS_STYLE_CONTEXT_TYPE_SHIFT        28
michael@0: 
michael@0: // Additional bits for nsRuleNode's mDependentBits:
michael@0: #define NS_RULE_NODE_GC_MARK                0x02000000
michael@0: #define NS_RULE_NODE_USED_DIRECTLY          0x04000000
michael@0: #define NS_RULE_NODE_IS_IMPORTANT           0x08000000
michael@0: #define NS_RULE_NODE_LEVEL_MASK             0xf0000000
michael@0: #define NS_RULE_NODE_LEVEL_SHIFT            28
michael@0: 
michael@0: // The lifetime of these objects is managed by the presshell's arena.
michael@0: 
michael@0: struct nsStyleFont {
michael@0:   nsStyleFont(const nsFont& aFont, nsPresContext *aPresContext);
michael@0:   nsStyleFont(const nsStyleFont& aStyleFont);
michael@0:   nsStyleFont(nsPresContext *aPresContext);
michael@0: private:
michael@0:   void Init(nsPresContext *aPresContext);
michael@0: public:
michael@0:   ~nsStyleFont(void) {
michael@0:     MOZ_COUNT_DTOR(nsStyleFont);
michael@0:   }
michael@0: 
michael@0:   nsChangeHint CalcDifference(const nsStyleFont& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     return NS_STYLE_HINT_REFLOW;
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference never returns nsChangeHint_NeedReflow or
michael@0:     // nsChangeHint_ClearAncestorIntrinsics as inherited hints.
michael@0:     return NS_CombineHint(nsChangeHint_NeedReflow,
michael@0:                           nsChangeHint_ClearAncestorIntrinsics);
michael@0:   }
michael@0:   static nsChangeHint CalcFontDifference(const nsFont& aFont1, const nsFont& aFont2);
michael@0: 
michael@0:   static nscoord ZoomText(nsPresContext* aPresContext, nscoord aSize);
michael@0:   static nscoord UnZoomText(nsPresContext* aPresContext, nscoord aSize);
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW;
michael@0:   void Destroy(nsPresContext* aContext);
michael@0: 
michael@0:   void EnableZoom(nsPresContext* aContext, bool aEnable);
michael@0: 
michael@0:   nsFont  mFont;        // [inherited]
michael@0:   nscoord mSize;        // [inherited] Our "computed size". Can be different
michael@0:                         // from mFont.size which is our "actual size" and is
michael@0:                         // enforced to be >= the user's preferred min-size.
michael@0:                         // mFont.size should be used for display purposes
michael@0:                         // while mSize is the value to return in
michael@0:                         // getComputedStyle() for example.
michael@0:   uint8_t mGenericID;   // [inherited] generic CSS font family, if any;
michael@0:                         // value is a kGenericFont_* constant, see nsFont.h.
michael@0: 
michael@0:   // MathML scriptlevel support
michael@0:   int8_t  mScriptLevel;          // [inherited]
michael@0:   // MathML  mathvariant support
michael@0:   uint8_t mMathVariant;          // [inherited]
michael@0:   // MathML displaystyle support
michael@0:   uint8_t mMathDisplay;         // [inherited]
michael@0: 
michael@0:   // was mLanguage set based on a lang attribute in the document?
michael@0:   bool mExplicitLanguage;        // [inherited]
michael@0: 
michael@0:   // should calls to ZoomText() and UnZoomText() be made to the font
michael@0:   // size on this nsStyleFont?
michael@0:   bool mAllowZoom;               // [inherited]
michael@0: 
michael@0:   // The value mSize would have had if scriptminsize had never been applied
michael@0:   nscoord mScriptUnconstrainedSize;
michael@0:   nscoord mScriptMinSize;        // [inherited] length
michael@0:   float   mScriptSizeMultiplier; // [inherited]
michael@0:   nsCOMPtr<nsIAtom> mLanguage;   // [inherited]
michael@0: };
michael@0: 
michael@0: struct nsStyleGradientStop {
michael@0:   nsStyleCoord mLocation; // percent, coord, calc, none
michael@0:   nscolor mColor;
michael@0: };
michael@0: 
michael@0: class nsStyleGradient MOZ_FINAL {
michael@0: public:
michael@0:   nsStyleGradient();
michael@0:   uint8_t mShape;  // NS_STYLE_GRADIENT_SHAPE_*
michael@0:   uint8_t mSize;   // NS_STYLE_GRADIENT_SIZE_*;
michael@0:                    // not used (must be FARTHEST_CORNER) for linear shape
michael@0:   bool mRepeating;
michael@0:   bool mLegacySyntax;
michael@0: 
michael@0:   nsStyleCoord mBgPosX; // percent, coord, calc, none
michael@0:   nsStyleCoord mBgPosY; // percent, coord, calc, none
michael@0:   nsStyleCoord mAngle;  // none, angle
michael@0: 
michael@0:   nsStyleCoord mRadiusX; // percent, coord, calc, none
michael@0:   nsStyleCoord mRadiusY; // percent, coord, calc, none
michael@0: 
michael@0:   // stops are in the order specified in the stylesheet
michael@0:   nsTArray<nsStyleGradientStop> mStops;
michael@0: 
michael@0:   bool operator==(const nsStyleGradient& aOther) const;
michael@0:   bool operator!=(const nsStyleGradient& aOther) const {
michael@0:     return !(*this == aOther);
michael@0:   }
michael@0: 
michael@0:   bool IsOpaque();
michael@0:   bool HasCalc();
michael@0:   uint32_t Hash(PLDHashNumber aHash);
michael@0: 
michael@0:   NS_INLINE_DECL_REFCOUNTING(nsStyleGradient)
michael@0: 
michael@0: private:
michael@0:   // Private destructor, to discourage deletion outside of Release():
michael@0:   ~nsStyleGradient() {}
michael@0: 
michael@0:   nsStyleGradient(const nsStyleGradient& aOther) MOZ_DELETE;
michael@0:   nsStyleGradient& operator=(const nsStyleGradient& aOther) MOZ_DELETE;
michael@0: };
michael@0: 
michael@0: enum nsStyleImageType {
michael@0:   eStyleImageType_Null,
michael@0:   eStyleImageType_Image,
michael@0:   eStyleImageType_Gradient,
michael@0:   eStyleImageType_Element
michael@0: };
michael@0: 
michael@0: /**
michael@0:  * Represents a paintable image of one of the following types.
michael@0:  * (1) A real image loaded from an external source.
michael@0:  * (2) A CSS linear or radial gradient.
michael@0:  * (3) An element within a document, or an <img>, <video>, or <canvas> element
michael@0:  *     not in a document.
michael@0:  * (*) Optionally a crop rect can be set to paint a partial (rectangular)
michael@0:  * region of an image. (Currently, this feature is only supported with an
michael@0:  * image of type (1)).
michael@0:  */
michael@0: struct nsStyleImage {
michael@0:   nsStyleImage();
michael@0:   ~nsStyleImage();
michael@0:   nsStyleImage(const nsStyleImage& aOther);
michael@0:   nsStyleImage& operator=(const nsStyleImage& aOther);
michael@0: 
michael@0:   void SetNull();
michael@0:   void SetImageData(imgIRequest* aImage);
michael@0:   void TrackImage(nsPresContext* aContext);
michael@0:   void UntrackImage(nsPresContext* aContext);
michael@0:   void SetGradientData(nsStyleGradient* aGradient);
michael@0:   void SetElementId(const char16_t* aElementId);
michael@0:   void SetCropRect(nsStyleSides* aCropRect);
michael@0: 
michael@0:   nsStyleImageType GetType() const {
michael@0:     return mType;
michael@0:   }
michael@0:   imgIRequest* GetImageData() const {
michael@0:     NS_ABORT_IF_FALSE(mType == eStyleImageType_Image, "Data is not an image!");
michael@0:     NS_ABORT_IF_FALSE(mImageTracked,
michael@0:                       "Should be tracking any image we're going to use!");
michael@0:     return mImage;
michael@0:   }
michael@0:   nsStyleGradient* GetGradientData() const {
michael@0:     NS_ASSERTION(mType == eStyleImageType_Gradient, "Data is not a gradient!");
michael@0:     return mGradient;
michael@0:   }
michael@0:   const char16_t* GetElementId() const {
michael@0:     NS_ASSERTION(mType == eStyleImageType_Element, "Data is not an element!");
michael@0:     return mElementId;
michael@0:   }
michael@0:   nsStyleSides* GetCropRect() const {
michael@0:     NS_ASSERTION(mType == eStyleImageType_Image,
michael@0:                  "Only image data can have a crop rect");
michael@0:     return mCropRect;
michael@0:   }
michael@0: 
michael@0:   /**
michael@0:    * Compute the actual crop rect in pixels, using the source image bounds.
michael@0:    * The computation involves converting percentage unit to pixel unit and
michael@0:    * clamping each side value to fit in the source image bounds.
michael@0:    * @param aActualCropRect the computed actual crop rect.
michael@0:    * @param aIsEntireImage true iff |aActualCropRect| is identical to the
michael@0:    * source image bounds.
michael@0:    * @return true iff |aActualCropRect| holds a meaningful value.
michael@0:    */
michael@0:   bool ComputeActualCropRect(nsIntRect& aActualCropRect,
michael@0:                                bool* aIsEntireImage = nullptr) const;
michael@0: 
michael@0:   /**
michael@0:    * Starts the decoding of a image.
michael@0:    */
michael@0:   nsresult StartDecoding() const;
michael@0:   /**
michael@0:    * @return true if the item is definitely opaque --- i.e., paints every
michael@0:    * pixel within its bounds opaquely, and the bounds contains at least a pixel.
michael@0:    */
michael@0:   bool IsOpaque() const;
michael@0:   /**
michael@0:    * @return true if this image is fully loaded, and its size is calculated;
michael@0:    * always returns true if |mType| is |eStyleImageType_Gradient| or
michael@0:    * |eStyleImageType_Element|.
michael@0:    */
michael@0:   bool IsComplete() const;
michael@0:   /**
michael@0:    * @return true if this image is loaded without error;
michael@0:    * always returns true if |mType| is |eStyleImageType_Gradient| or
michael@0:    * |eStyleImageType_Element|.
michael@0:    */
michael@0:   bool IsLoaded() const;
michael@0:   /**
michael@0:    * @return true if it is 100% confident that this image contains no pixel
michael@0:    * to draw.
michael@0:    */
michael@0:   bool IsEmpty() const {
michael@0:     // There are some other cases when the image will be empty, for example
michael@0:     // when the crop rect is empty. However, checking the emptiness of crop
michael@0:     // rect is non-trivial since each side value can be specified with
michael@0:     // percentage unit, which can not be evaluated until the source image size
michael@0:     // is available. Therefore, we currently postpone the evaluation of crop
michael@0:     // rect until the actual rendering time --- alternatively until GetOpaqueRegion()
michael@0:     // is called.
michael@0:     return mType == eStyleImageType_Null;
michael@0:   }
michael@0: 
michael@0:   bool operator==(const nsStyleImage& aOther) const;
michael@0:   bool operator!=(const nsStyleImage& aOther) const {
michael@0:     return !(*this == aOther);
michael@0:   }
michael@0: 
michael@0:   bool ImageDataEquals(const nsStyleImage& aOther) const
michael@0:   {
michael@0:     return GetType() == eStyleImageType_Image &&
michael@0:            aOther.GetType() == eStyleImageType_Image &&
michael@0:            GetImageData() == aOther.GetImageData();
michael@0:   }
michael@0: 
michael@0:   // These methods are used for the caller to caches the sub images created
michael@0:   // during a border-image paint operation
michael@0:   inline void SetSubImage(uint8_t aIndex, imgIContainer* aSubImage) const;
michael@0:   inline imgIContainer* GetSubImage(uint8_t aIndex) const;
michael@0: 
michael@0: private:
michael@0:   void DoCopy(const nsStyleImage& aOther);
michael@0: 
michael@0:   // Cache for border-image painting.
michael@0:   nsCOMArray<imgIContainer> mSubImages;
michael@0: 
michael@0:   nsStyleImageType mType;
michael@0:   union {
michael@0:     imgIRequest* mImage;
michael@0:     nsStyleGradient* mGradient;
michael@0:     char16_t* mElementId;
michael@0:   };
michael@0:   // This is _currently_ used only in conjunction with eStyleImageType_Image.
michael@0:   nsAutoPtr<nsStyleSides> mCropRect;
michael@0: #ifdef DEBUG
michael@0:   bool mImageTracked;
michael@0: #endif
michael@0: };
michael@0: 
michael@0: struct nsStyleColor {
michael@0:   nsStyleColor(nsPresContext* aPresContext);
michael@0:   nsStyleColor(const nsStyleColor& aOther);
michael@0:   ~nsStyleColor(void) {
michael@0:     MOZ_COUNT_DTOR(nsStyleColor);
michael@0:   }
michael@0: 
michael@0:   nsChangeHint CalcDifference(const nsStyleColor& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     return NS_STYLE_HINT_VISUAL;
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference never returns nsChangeHint_NeedReflow or
michael@0:     // nsChangeHint_ClearAncestorIntrinsics at all.
michael@0:     return nsChangeHint(0);
michael@0:   }
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
michael@0:     return aContext->AllocateFromShell(sz);
michael@0:   }
michael@0:   void Destroy(nsPresContext* aContext) {
michael@0:     this->~nsStyleColor();
michael@0:     aContext->FreeToShell(sizeof(nsStyleColor), this);
michael@0:   }
michael@0: 
michael@0:   // Don't add ANY members to this struct!  We can achieve caching in the rule
michael@0:   // tree (rather than the style tree) by letting color stay by itself! -dwh
michael@0:   nscolor mColor;                 // [inherited]
michael@0: };
michael@0: 
michael@0: struct nsStyleBackground {
michael@0:   nsStyleBackground();
michael@0:   nsStyleBackground(const nsStyleBackground& aOther);
michael@0:   ~nsStyleBackground();
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
michael@0:     return aContext->AllocateFromShell(sz);
michael@0:   }
michael@0:   void Destroy(nsPresContext* aContext);
michael@0: 
michael@0:   nsChangeHint CalcDifference(const nsStyleBackground& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     return NS_CombineHint(nsChangeHint_UpdateEffects, NS_STYLE_HINT_VISUAL);
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference never returns nsChangeHint_NeedReflow or
michael@0:     // nsChangeHint_ClearAncestorIntrinsics at all.
michael@0:     return nsChangeHint(0);
michael@0:   }
michael@0: 
michael@0:   struct Position;
michael@0:   friend struct Position;
michael@0:   struct Position {
michael@0:     typedef nsStyleCoord::Calc PositionCoord;
michael@0:     PositionCoord mXPosition, mYPosition;
michael@0: 
michael@0:     // Initialize nothing
michael@0:     Position() {}
michael@0: 
michael@0:     // Initialize to initial values
michael@0:     void SetInitialValues();
michael@0: 
michael@0:     // True if the effective background image position described by this depends
michael@0:     // on the size of the corresponding frame.
michael@0:     bool DependsOnPositioningAreaSize() const {
michael@0:       return mXPosition.mPercent != 0.0f || mYPosition.mPercent != 0.0f;
michael@0:     }
michael@0: 
michael@0:     bool operator==(const Position& aOther) const {
michael@0:       return mXPosition == aOther.mXPosition &&
michael@0:              mYPosition == aOther.mYPosition;
michael@0:     }
michael@0:     bool operator!=(const Position& aOther) const {
michael@0:       return !(*this == aOther);
michael@0:     }
michael@0:   };
michael@0: 
michael@0:   struct Size;
michael@0:   friend struct Size;
michael@0:   struct Size {
michael@0:     struct Dimension : public nsStyleCoord::Calc {
michael@0:       nscoord ResolveLengthPercentage(nscoord aAvailable) const {
michael@0:         double d = double(mPercent) * double(aAvailable) + double(mLength);
michael@0:         if (d < 0.0)
michael@0:           return 0;
michael@0:         return NSToCoordRoundWithClamp(float(d));
michael@0:       }
michael@0:     };
michael@0:     Dimension mWidth, mHeight;
michael@0: 
michael@0:     nscoord ResolveWidthLengthPercentage(const nsSize& aBgPositioningArea) const {
michael@0:       NS_ABORT_IF_FALSE(mWidthType == eLengthPercentage,
michael@0:                         "resolving non-length/percent dimension!");
michael@0:       return mWidth.ResolveLengthPercentage(aBgPositioningArea.width);
michael@0:     }
michael@0: 
michael@0:     nscoord ResolveHeightLengthPercentage(const nsSize& aBgPositioningArea) const {
michael@0:       NS_ABORT_IF_FALSE(mHeightType == eLengthPercentage,
michael@0:                         "resolving non-length/percent dimension!");
michael@0:       return mHeight.ResolveLengthPercentage(aBgPositioningArea.height);
michael@0:     }
michael@0: 
michael@0:     // Except for eLengthPercentage, Dimension types which might change
michael@0:     // how a layer is painted when the corresponding frame's dimensions
michael@0:     // change *must* precede all dimension types which are agnostic to
michael@0:     // frame size; see DependsOnDependsOnPositioningAreaSizeSize.
michael@0:     enum DimensionType {
michael@0:       // If one of mWidth and mHeight is eContain or eCover, then both are.
michael@0:       // Also, these two values must equal the corresponding values in
michael@0:       // kBackgroundSizeKTable.
michael@0:       eContain, eCover,
michael@0: 
michael@0:       eAuto,
michael@0:       eLengthPercentage,
michael@0:       eDimensionType_COUNT
michael@0:     };
michael@0:     uint8_t mWidthType, mHeightType;
michael@0: 
michael@0:     // True if the effective image size described by this depends on the size of
michael@0:     // the corresponding frame, when aImage (which must not have null type) is
michael@0:     // the background image.
michael@0:     bool DependsOnPositioningAreaSize(const nsStyleImage& aImage) const;
michael@0: 
michael@0:     // Initialize nothing
michael@0:     Size() {}
michael@0: 
michael@0:     // Initialize to initial values
michael@0:     void SetInitialValues();
michael@0: 
michael@0:     bool operator==(const Size& aOther) const;
michael@0:     bool operator!=(const Size& aOther) const {
michael@0:       return !(*this == aOther);
michael@0:     }
michael@0:   };
michael@0:   
michael@0:   struct Repeat;
michael@0:   friend struct Repeat;
michael@0:   struct Repeat {
michael@0:     uint8_t mXRepeat, mYRepeat;
michael@0:     
michael@0:     // Initialize nothing
michael@0:     Repeat() {}
michael@0: 
michael@0:     // Initialize to initial values
michael@0:     void SetInitialValues();
michael@0: 
michael@0:     bool operator==(const Repeat& aOther) const {
michael@0:       return mXRepeat == aOther.mXRepeat &&
michael@0:              mYRepeat == aOther.mYRepeat;
michael@0:     }
michael@0:     bool operator!=(const Repeat& aOther) const {
michael@0:       return !(*this == aOther);
michael@0:     }
michael@0:   };
michael@0: 
michael@0:   struct Layer;
michael@0:   friend struct Layer;
michael@0:   struct Layer {
michael@0:     uint8_t mAttachment;                // [reset] See nsStyleConsts.h
michael@0:     uint8_t mClip;                      // [reset] See nsStyleConsts.h
michael@0:     uint8_t mOrigin;                    // [reset] See nsStyleConsts.h
michael@0:     uint8_t mBlendMode;                 // [reset] See nsStyleConsts.h
michael@0:     Repeat mRepeat;                     // [reset] See nsStyleConsts.h
michael@0:     Position mPosition;                 // [reset]
michael@0:     nsStyleImage mImage;                // [reset]
michael@0:     Size mSize;                         // [reset]
michael@0: 
michael@0:     // Initializes only mImage
michael@0:     Layer();
michael@0:     ~Layer();
michael@0: 
michael@0:     // Register/unregister images with the document. We do this only
michael@0:     // after the dust has settled in ComputeBackgroundData.
michael@0:     void TrackImages(nsPresContext* aContext) {
michael@0:       if (mImage.GetType() == eStyleImageType_Image)
michael@0:         mImage.TrackImage(aContext);
michael@0:     }
michael@0:     void UntrackImages(nsPresContext* aContext) {
michael@0:       if (mImage.GetType() == eStyleImageType_Image)
michael@0:         mImage.UntrackImage(aContext);
michael@0:     }
michael@0: 
michael@0:     void SetInitialValues();
michael@0: 
michael@0:     // True if the rendering of this layer might change when the size
michael@0:     // of the background positioning area changes.  This is true for any
michael@0:     // non-solid-color background whose position or size depends on
michael@0:     // the size of the positioning area.  It's also true for SVG images
michael@0:     // whose root <svg> node has a viewBox.
michael@0:     bool RenderingMightDependOnPositioningAreaSizeChange() const;
michael@0: 
michael@0:     // An equality operator that compares the images using URL-equality
michael@0:     // rather than pointer-equality.
michael@0:     bool operator==(const Layer& aOther) const;
michael@0:     bool operator!=(const Layer& aOther) const {
michael@0:       return !(*this == aOther);
michael@0:     }
michael@0:   };
michael@0: 
michael@0:   // The (positive) number of computed values of each property, since
michael@0:   // the lengths of the lists are independent.
michael@0:   uint32_t mAttachmentCount,
michael@0:            mClipCount,
michael@0:            mOriginCount,
michael@0:            mRepeatCount,
michael@0:            mPositionCount,
michael@0:            mImageCount,
michael@0:            mSizeCount,
michael@0:            mBlendModeCount;
michael@0:   // Layers are stored in an array, matching the top-to-bottom order in
michael@0:   // which they are specified in CSS.  The number of layers to be used
michael@0:   // should come from the background-image property.  We create
michael@0:   // additional |Layer| objects for *any* property, not just
michael@0:   // background-image.  This means that the bottommost layer that
michael@0:   // callers in layout care about (which is also the one whose
michael@0:   // background-clip applies to the background-color) may not be last
michael@0:   // layer.  In layers below the bottom layer, properties will be
michael@0:   // uninitialized unless their count, above, indicates that they are
michael@0:   // present.
michael@0:   nsAutoTArray<Layer, 1> mLayers;
michael@0: 
michael@0:   const Layer& BottomLayer() const { return mLayers[mImageCount - 1]; }
michael@0: 
michael@0:   #define NS_FOR_VISIBLE_BACKGROUND_LAYERS_BACK_TO_FRONT(var_, stylebg_) \
michael@0:     for (uint32_t var_ = (stylebg_) ? (stylebg_)->mImageCount : 1; var_-- != 0; )
michael@0:   #define NS_FOR_VISIBLE_BACKGROUND_LAYERS_BACK_TO_FRONT_WITH_RANGE(var_, stylebg_, start_, count_) \
michael@0:     NS_ASSERTION((int32_t)(start_) >= 0 && (uint32_t)(start_) < ((stylebg_) ? (stylebg_)->mImageCount : 1), "Invalid layer start!"); \
michael@0:     NS_ASSERTION((count_) > 0 && (count_) <= (start_) + 1, "Invalid layer range!"); \
michael@0:     for (uint32_t var_ = (start_) + 1; var_-- != (uint32_t)((start_) + 1 - (count_)); )
michael@0: 
michael@0:   nscolor mBackgroundColor;       // [reset]
michael@0: 
michael@0:   // FIXME: This (now background-break in css3-background) should
michael@0:   // probably move into a different struct so that everything in
michael@0:   // nsStyleBackground is set by the background shorthand.
michael@0:   uint8_t mBackgroundInlinePolicy; // [reset] See nsStyleConsts.h
michael@0: 
michael@0:   // True if this background is completely transparent.
michael@0:   bool IsTransparent() const;
michael@0: 
michael@0:   // We have to take slower codepaths for fixed background attachment,
michael@0:   // but we don't want to do that when there's no image.
michael@0:   // Not inline because it uses an nsCOMPtr<imgIRequest>
michael@0:   // FIXME: Should be in nsStyleStructInlines.h.
michael@0:   bool HasFixedBackground() const;
michael@0: };
michael@0: 
michael@0: // See https://bugzilla.mozilla.org/show_bug.cgi?id=271586#c43 for why
michael@0: // this is hard to replace with 'currentColor'.
michael@0: #define BORDER_COLOR_FOREGROUND   0x20
michael@0: #define OUTLINE_COLOR_INITIAL     0x80
michael@0: // FOREGROUND | INITIAL(OUTLINE)
michael@0: #define BORDER_COLOR_SPECIAL      0xA0
michael@0: #define BORDER_STYLE_MASK         0x1F
michael@0: 
michael@0: #define NS_SPACING_MARGIN   0
michael@0: #define NS_SPACING_PADDING  1
michael@0: #define NS_SPACING_BORDER   2
michael@0: 
michael@0: 
michael@0: struct nsStyleMargin {
michael@0:   nsStyleMargin(void);
michael@0:   nsStyleMargin(const nsStyleMargin& aMargin);
michael@0:   ~nsStyleMargin(void) {
michael@0:     MOZ_COUNT_DTOR(nsStyleMargin);
michael@0:   }
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW;
michael@0:   void Destroy(nsPresContext* aContext);
michael@0: 
michael@0:   void RecalcData();
michael@0:   nsChangeHint CalcDifference(const nsStyleMargin& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     return NS_SubtractHint(NS_STYLE_HINT_REFLOW,
michael@0:                            NS_CombineHint(nsChangeHint_ClearDescendantIntrinsics,
michael@0:                                           nsChangeHint_NeedDirtyReflow));
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference can return both nsChangeHint_ClearAncestorIntrinsics and
michael@0:     // nsChangeHint_NeedReflow as inherited hints.
michael@0:     return nsChangeHint(0);
michael@0:   }
michael@0: 
michael@0:   nsStyleSides  mMargin;          // [reset] coord, percent, calc, auto
michael@0: 
michael@0:   bool IsWidthDependent() const { return !mHasCachedMargin; }
michael@0:   bool GetMargin(nsMargin& aMargin) const
michael@0:   {
michael@0:     if (mHasCachedMargin) {
michael@0:       aMargin = mCachedMargin;
michael@0:       return true;
michael@0:     }
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0: protected:
michael@0:   bool          mHasCachedMargin;
michael@0:   nsMargin      mCachedMargin;
michael@0: };
michael@0: 
michael@0: 
michael@0: struct nsStylePadding {
michael@0:   nsStylePadding(void);
michael@0:   nsStylePadding(const nsStylePadding& aPadding);
michael@0:   ~nsStylePadding(void) {
michael@0:     MOZ_COUNT_DTOR(nsStylePadding);
michael@0:   }
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW;
michael@0:   void Destroy(nsPresContext* aContext);
michael@0: 
michael@0:   void RecalcData();
michael@0:   nsChangeHint CalcDifference(const nsStylePadding& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     return NS_SubtractHint(NS_STYLE_HINT_REFLOW,
michael@0:                            nsChangeHint_ClearDescendantIntrinsics);
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference can return nsChangeHint_ClearAncestorIntrinsics as an
michael@0:     // inherited hint.
michael@0:     return nsChangeHint(0);
michael@0:   }
michael@0: 
michael@0:   nsStyleSides  mPadding;         // [reset] coord, percent, calc
michael@0: 
michael@0:   bool IsWidthDependent() const { return !mHasCachedPadding; }
michael@0:   bool GetPadding(nsMargin& aPadding) const
michael@0:   {
michael@0:     if (mHasCachedPadding) {
michael@0:       aPadding = mCachedPadding;
michael@0:       return true;
michael@0:     }
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0: protected:
michael@0:   bool          mHasCachedPadding;
michael@0:   nsMargin      mCachedPadding;
michael@0: };
michael@0: 
michael@0: struct nsBorderColors {
michael@0:   nsBorderColors* mNext;
michael@0:   nscolor mColor;
michael@0: 
michael@0:   nsBorderColors() : mNext(nullptr), mColor(NS_RGB(0,0,0)) {}
michael@0:   nsBorderColors(const nscolor& aColor) : mNext(nullptr), mColor(aColor) {}
michael@0:   ~nsBorderColors();
michael@0: 
michael@0:   nsBorderColors* Clone() const { return Clone(true); }
michael@0: 
michael@0:   static bool Equal(const nsBorderColors* c1,
michael@0:                       const nsBorderColors* c2) {
michael@0:     if (c1 == c2)
michael@0:       return true;
michael@0:     while (c1 && c2) {
michael@0:       if (c1->mColor != c2->mColor)
michael@0:         return false;
michael@0:       c1 = c1->mNext;
michael@0:       c2 = c2->mNext;
michael@0:     }
michael@0:     // both should be nullptr if these are equal, otherwise one
michael@0:     // has more colors than another
michael@0:     return !c1 && !c2;
michael@0:   }
michael@0: 
michael@0: private:
michael@0:   nsBorderColors* Clone(bool aDeep) const;
michael@0: };
michael@0: 
michael@0: struct nsCSSShadowItem {
michael@0:   nscoord mXOffset;
michael@0:   nscoord mYOffset;
michael@0:   nscoord mRadius;
michael@0:   nscoord mSpread;
michael@0: 
michael@0:   nscolor      mColor;
michael@0:   bool mHasColor; // Whether mColor should be used
michael@0:   bool mInset;
michael@0: 
michael@0:   nsCSSShadowItem() : mHasColor(false) {
michael@0:     MOZ_COUNT_CTOR(nsCSSShadowItem);
michael@0:   }
michael@0:   ~nsCSSShadowItem() {
michael@0:     MOZ_COUNT_DTOR(nsCSSShadowItem);
michael@0:   }
michael@0: 
michael@0:   bool operator==(const nsCSSShadowItem& aOther) const {
michael@0:     return (mXOffset == aOther.mXOffset &&
michael@0:             mYOffset == aOther.mYOffset &&
michael@0:             mRadius == aOther.mRadius &&
michael@0:             mHasColor == aOther.mHasColor &&
michael@0:             mSpread == aOther.mSpread &&
michael@0:             mInset == aOther.mInset &&
michael@0:             (!mHasColor || mColor == aOther.mColor));
michael@0:   }
michael@0:   bool operator!=(const nsCSSShadowItem& aOther) const {
michael@0:     return !(*this == aOther);
michael@0:   }
michael@0: };
michael@0: 
michael@0: class nsCSSShadowArray MOZ_FINAL {
michael@0:   public:
michael@0:     void* operator new(size_t aBaseSize, uint32_t aArrayLen) {
michael@0:       // We can allocate both this nsCSSShadowArray and the
michael@0:       // actual array in one allocation. The amount of memory to
michael@0:       // allocate is equal to the class's size + the number of bytes for all
michael@0:       // but the first array item (because aBaseSize includes one
michael@0:       // item, see the private declarations)
michael@0:       return ::operator new(aBaseSize +
michael@0:                             (aArrayLen - 1) * sizeof(nsCSSShadowItem));
michael@0:     }
michael@0: 
michael@0:     nsCSSShadowArray(uint32_t aArrayLen) :
michael@0:       mLength(aArrayLen)
michael@0:     {
michael@0:       MOZ_COUNT_CTOR(nsCSSShadowArray);
michael@0:       for (uint32_t i = 1; i < mLength; ++i) {
michael@0:         // Make sure we call the constructors of each nsCSSShadowItem
michael@0:         // (the first one is called for us because we declared it under private)
michael@0:         new (&mArray[i]) nsCSSShadowItem();
michael@0:       }
michael@0:     }
michael@0: 
michael@0: private:
michael@0:     // Private destructor, to discourage deletion outside of Release():
michael@0:     ~nsCSSShadowArray() {
michael@0:       MOZ_COUNT_DTOR(nsCSSShadowArray);
michael@0:       for (uint32_t i = 1; i < mLength; ++i) {
michael@0:         mArray[i].~nsCSSShadowItem();
michael@0:       }
michael@0:     }
michael@0: 
michael@0: public:
michael@0:     uint32_t Length() const { return mLength; }
michael@0:     nsCSSShadowItem* ShadowAt(uint32_t i) {
michael@0:       NS_ABORT_IF_FALSE(i < mLength, "Accessing too high an index in the text shadow array!");
michael@0:       return &mArray[i];
michael@0:     }
michael@0:     const nsCSSShadowItem* ShadowAt(uint32_t i) const {
michael@0:       NS_ABORT_IF_FALSE(i < mLength, "Accessing too high an index in the text shadow array!");
michael@0:       return &mArray[i];
michael@0:     }
michael@0: 
michael@0:     bool HasShadowWithInset(bool aInset) {
michael@0:       for (uint32_t i = 0; i < mLength; ++i) {
michael@0:         if (mArray[i].mInset == aInset)
michael@0:           return true;
michael@0:       }
michael@0:       return false;
michael@0:     }
michael@0: 
michael@0:     bool operator==(const nsCSSShadowArray& aOther) const {
michael@0:       if (mLength != aOther.Length())
michael@0:         return false;
michael@0: 
michael@0:       for (uint32_t i = 0; i < mLength; ++i) {
michael@0:         if (ShadowAt(i) != aOther.ShadowAt(i))
michael@0:           return false;
michael@0:       }
michael@0: 
michael@0:       return true;
michael@0:     }
michael@0: 
michael@0:     NS_INLINE_DECL_REFCOUNTING(nsCSSShadowArray)
michael@0: 
michael@0:   private:
michael@0:     uint32_t mLength;
michael@0:     nsCSSShadowItem mArray[1]; // This MUST be the last item
michael@0: };
michael@0: 
michael@0: // Border widths are rounded to the nearest-below integer number of pixels,
michael@0: // but values between zero and one device pixels are always rounded up to
michael@0: // one device pixel.
michael@0: #define NS_ROUND_BORDER_TO_PIXELS(l,tpp) \
michael@0:   ((l) == 0) ? 0 : std::max((tpp), (l) / (tpp) * (tpp))
michael@0: // Outline offset is rounded to the nearest integer number of pixels, but values
michael@0: // between zero and one device pixels are always rounded up to one device pixel.
michael@0: // Note that the offset can be negative.
michael@0: #define NS_ROUND_OFFSET_TO_PIXELS(l,tpp) \
michael@0:   (((l) == 0) ? 0 : \
michael@0:     ((l) > 0) ? std::max( (tpp), ((l) + ((tpp) / 2)) / (tpp) * (tpp)) : \
michael@0:                 std::min(-(tpp), ((l) - ((tpp) / 2)) / (tpp) * (tpp)))
michael@0: 
michael@0: // Returns if the given border style type is visible or not
michael@0: static bool IsVisibleBorderStyle(uint8_t aStyle)
michael@0: {
michael@0:   return (aStyle != NS_STYLE_BORDER_STYLE_NONE &&
michael@0:           aStyle != NS_STYLE_BORDER_STYLE_HIDDEN);
michael@0: }
michael@0: 
michael@0: struct nsStyleBorder {
michael@0:   nsStyleBorder(nsPresContext* aContext);
michael@0:   nsStyleBorder(const nsStyleBorder& aBorder);
michael@0:   ~nsStyleBorder();
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW;
michael@0:   void Destroy(nsPresContext* aContext);
michael@0: 
michael@0:   nsChangeHint CalcDifference(const nsStyleBorder& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     return NS_CombineHint(NS_STYLE_HINT_REFLOW,
michael@0:                           nsChangeHint_BorderStyleNoneChange);
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference never returns nsChangeHint_NeedReflow or
michael@0:     // nsChangeHint_ClearAncestorIntrinsics as inherited hints.
michael@0:     return NS_CombineHint(nsChangeHint_NeedReflow,
michael@0:                           nsChangeHint_ClearAncestorIntrinsics);
michael@0:   }
michael@0: 
michael@0:   void EnsureBorderColors() {
michael@0:     if (!mBorderColors) {
michael@0:       mBorderColors = new nsBorderColors*[4];
michael@0:       if (mBorderColors)
michael@0:         for (int32_t i = 0; i < 4; i++)
michael@0:           mBorderColors[i] = nullptr;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   void ClearBorderColors(mozilla::css::Side aSide) {
michael@0:     if (mBorderColors && mBorderColors[aSide]) {
michael@0:       delete mBorderColors[aSide];
michael@0:       mBorderColors[aSide] = nullptr;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // Return whether aStyle is a visible style.  Invisible styles cause
michael@0:   // the relevant computed border width to be 0.
michael@0:   // Note that this does *not* consider the effects of 'border-image':
michael@0:   // if border-style is none, but there is a loaded border image,
michael@0:   // HasVisibleStyle will be false even though there *is* a border.
michael@0:   bool HasVisibleStyle(mozilla::css::Side aSide) const
michael@0:   {
michael@0:     return IsVisibleBorderStyle(GetBorderStyle(aSide));
michael@0:   }
michael@0: 
michael@0:   // aBorderWidth is in twips
michael@0:   void SetBorderWidth(mozilla::css::Side aSide, nscoord aBorderWidth)
michael@0:   {
michael@0:     nscoord roundedWidth =
michael@0:       NS_ROUND_BORDER_TO_PIXELS(aBorderWidth, mTwipsPerPixel);
michael@0:     mBorder.Side(aSide) = roundedWidth;
michael@0:     if (HasVisibleStyle(aSide))
michael@0:       mComputedBorder.Side(aSide) = roundedWidth;
michael@0:   }
michael@0: 
michael@0:   // Get the computed border (plus rounding).  This does consider the
michael@0:   // effects of 'border-style: none', but does not consider
michael@0:   // 'border-image'.
michael@0:   const nsMargin& GetComputedBorder() const
michael@0:   {
michael@0:     return mComputedBorder;
michael@0:   }
michael@0: 
michael@0:   bool HasBorder() const
michael@0:   {
michael@0:     return mComputedBorder != nsMargin(0,0,0,0) || !mBorderImageSource.IsEmpty();
michael@0:   }
michael@0: 
michael@0:   // Get the actual border width for a particular side, in appunits.  Note that
michael@0:   // this is zero if and only if there is no border to be painted for this
michael@0:   // side.  That is, this value takes into account the border style and the
michael@0:   // value is rounded to the nearest device pixel by NS_ROUND_BORDER_TO_PIXELS.
michael@0:   nscoord GetComputedBorderWidth(mozilla::css::Side aSide) const
michael@0:   {
michael@0:     return GetComputedBorder().Side(aSide);
michael@0:   }
michael@0: 
michael@0:   uint8_t GetBorderStyle(mozilla::css::Side aSide) const
michael@0:   {
michael@0:     NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side");
michael@0:     return (mBorderStyle[aSide] & BORDER_STYLE_MASK);
michael@0:   }
michael@0: 
michael@0:   void SetBorderStyle(mozilla::css::Side aSide, uint8_t aStyle)
michael@0:   {
michael@0:     NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side");
michael@0:     mBorderStyle[aSide] &= ~BORDER_STYLE_MASK;
michael@0:     mBorderStyle[aSide] |= (aStyle & BORDER_STYLE_MASK);
michael@0:     mComputedBorder.Side(aSide) =
michael@0:       (HasVisibleStyle(aSide) ? mBorder.Side(aSide) : 0);
michael@0:   }
michael@0: 
michael@0:   inline bool IsBorderImageLoaded() const
michael@0:   {
michael@0:     return mBorderImageSource.IsLoaded();
michael@0:   }
michael@0: 
michael@0:   // Defined in nsStyleStructInlines.h
michael@0:   inline nsresult RequestDecode();
michael@0: 
michael@0:   void GetBorderColor(mozilla::css::Side aSide, nscolor& aColor,
michael@0:                       bool& aForeground) const
michael@0:   {
michael@0:     aForeground = false;
michael@0:     NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side");
michael@0:     if ((mBorderStyle[aSide] & BORDER_COLOR_SPECIAL) == 0)
michael@0:       aColor = mBorderColor[aSide];
michael@0:     else if (mBorderStyle[aSide] & BORDER_COLOR_FOREGROUND)
michael@0:       aForeground = true;
michael@0:     else
michael@0:       NS_NOTREACHED("OUTLINE_COLOR_INITIAL should not be set here");
michael@0:   }
michael@0: 
michael@0:   void SetBorderColor(mozilla::css::Side aSide, nscolor aColor)
michael@0:   {
michael@0:     NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side");
michael@0:     mBorderColor[aSide] = aColor;
michael@0:     mBorderStyle[aSide] &= ~BORDER_COLOR_SPECIAL;
michael@0:   }
michael@0: 
michael@0:   void TrackImage(nsPresContext* aContext)
michael@0:   {
michael@0:     if (mBorderImageSource.GetType() == eStyleImageType_Image) {
michael@0:       mBorderImageSource.TrackImage(aContext);
michael@0:     }
michael@0:   }
michael@0:   void UntrackImage(nsPresContext* aContext)
michael@0:   {
michael@0:     if (mBorderImageSource.GetType() == eStyleImageType_Image) {
michael@0:       mBorderImageSource.UntrackImage(aContext);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   nsMargin GetImageOutset() const;
michael@0: 
michael@0:   void GetCompositeColors(int32_t aIndex, nsBorderColors** aColors) const
michael@0:   {
michael@0:     if (!mBorderColors)
michael@0:       *aColors = nullptr;
michael@0:     else
michael@0:       *aColors = mBorderColors[aIndex];
michael@0:   }
michael@0: 
michael@0:   void AppendBorderColor(int32_t aIndex, nscolor aColor)
michael@0:   {
michael@0:     NS_ASSERTION(aIndex >= 0 && aIndex <= 3, "bad side for composite border color");
michael@0:     nsBorderColors* colorEntry = new nsBorderColors(aColor);
michael@0:     if (!mBorderColors[aIndex])
michael@0:       mBorderColors[aIndex] = colorEntry;
michael@0:     else {
michael@0:       nsBorderColors* last = mBorderColors[aIndex];
michael@0:       while (last->mNext)
michael@0:         last = last->mNext;
michael@0:       last->mNext = colorEntry;
michael@0:     }
michael@0:     mBorderStyle[aIndex] &= ~BORDER_COLOR_SPECIAL;
michael@0:   }
michael@0: 
michael@0:   void SetBorderToForeground(mozilla::css::Side aSide)
michael@0:   {
michael@0:     NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side");
michael@0:     mBorderStyle[aSide] &= ~BORDER_COLOR_SPECIAL;
michael@0:     mBorderStyle[aSide] |= BORDER_COLOR_FOREGROUND;
michael@0:   }
michael@0: 
michael@0:   imgIRequest* GetBorderImageRequest() const
michael@0:   {
michael@0:     if (mBorderImageSource.GetType() == eStyleImageType_Image) {
michael@0:       return mBorderImageSource.GetImageData();
michael@0:     }
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0: public:
michael@0:   nsBorderColors** mBorderColors;        // [reset] composite (stripe) colors
michael@0:   nsRefPtr<nsCSSShadowArray> mBoxShadow; // [reset] nullptr for 'none'
michael@0: 
michael@0: public:
michael@0:   nsStyleCorners mBorderRadius;       // [reset] coord, percent
michael@0:   nsStyleImage   mBorderImageSource;  // [reset]
michael@0:   nsStyleSides   mBorderImageSlice;   // [reset] factor, percent
michael@0:   nsStyleSides   mBorderImageWidth;   // [reset] length, factor, percent, auto
michael@0:   nsStyleSides   mBorderImageOutset;  // [reset] length, factor
michael@0: 
michael@0:   uint8_t        mBorderImageFill;    // [reset]
michael@0:   uint8_t        mBorderImageRepeatH; // [reset] see nsStyleConsts.h
michael@0:   uint8_t        mBorderImageRepeatV; // [reset]
michael@0:   uint8_t        mFloatEdge;          // [reset]
michael@0: 
michael@0: protected:
michael@0:   // mComputedBorder holds the CSS2.1 computed border-width values.
michael@0:   // In particular, these widths take into account the border-style
michael@0:   // for the relevant side, and the values are rounded to the nearest
michael@0:   // device pixel (which is not part of the definition of computed
michael@0:   // values). The presence or absence of a border-image does not
michael@0:   // affect border-width values.
michael@0:   nsMargin      mComputedBorder;
michael@0: 
michael@0:   // mBorder holds the nscoord values for the border widths as they
michael@0:   // would be if all the border-style values were visible (not hidden
michael@0:   // or none).  This member exists so that when we create structs
michael@0:   // using the copy constructor during style resolution the new
michael@0:   // structs will know what the specified values of the border were in
michael@0:   // case they have more specific rules setting the border style.
michael@0:   //
michael@0:   // Note that this isn't quite the CSS specified value, since this
michael@0:   // has had the enumerated border widths converted to lengths, and
michael@0:   // all lengths converted to twips.  But it's not quite the computed
michael@0:   // value either. The values are rounded to the nearest device pixel.
michael@0:   nsMargin      mBorder;
michael@0: 
michael@0:   uint8_t       mBorderStyle[4];  // [reset] See nsStyleConsts.h
michael@0:   nscolor       mBorderColor[4];  // [reset] the colors to use for a simple
michael@0:                                   // border.  not used for -moz-border-colors
michael@0: private:
michael@0:   nscoord       mTwipsPerPixel;
michael@0: 
michael@0:   nsStyleBorder& operator=(const nsStyleBorder& aOther) MOZ_DELETE;
michael@0: };
michael@0: 
michael@0: 
michael@0: struct nsStyleOutline {
michael@0:   nsStyleOutline(nsPresContext* aPresContext);
michael@0:   nsStyleOutline(const nsStyleOutline& aOutline);
michael@0:   ~nsStyleOutline(void) {
michael@0:     MOZ_COUNT_DTOR(nsStyleOutline);
michael@0:   }
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
michael@0:     return aContext->AllocateFromShell(sz);
michael@0:   }
michael@0:   void Destroy(nsPresContext* aContext) {
michael@0:     this->~nsStyleOutline();
michael@0:     aContext->FreeToShell(sizeof(nsStyleOutline), this);
michael@0:   }
michael@0: 
michael@0:   void RecalcData(nsPresContext* aContext);
michael@0:   nsChangeHint CalcDifference(const nsStyleOutline& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     return NS_CombineHint(nsChangeHint_AllReflowHints,
michael@0:                           nsChangeHint_RepaintFrame);
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference never returns nsChangeHint_NeedReflow or
michael@0:     // nsChangeHint_ClearAncestorIntrinsics as inherited hints.
michael@0:     return NS_CombineHint(nsChangeHint_NeedReflow,
michael@0:                           nsChangeHint_ClearAncestorIntrinsics);
michael@0:   }
michael@0: 
michael@0:   nsStyleCorners  mOutlineRadius; // [reset] coord, percent, calc
michael@0: 
michael@0:   // Note that this is a specified value.  You can get the actual values
michael@0:   // with GetOutlineWidth.  You cannot get the computed value directly.
michael@0:   nsStyleCoord  mOutlineWidth;    // [reset] coord, enum (see nsStyleConsts.h)
michael@0:   nscoord       mOutlineOffset;   // [reset]
michael@0: 
michael@0:   bool GetOutlineWidth(nscoord& aWidth) const
michael@0:   {
michael@0:     if (mHasCachedOutline) {
michael@0:       aWidth = mCachedOutlineWidth;
michael@0:       return true;
michael@0:     }
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   uint8_t GetOutlineStyle(void) const
michael@0:   {
michael@0:     return (mOutlineStyle & BORDER_STYLE_MASK);
michael@0:   }
michael@0: 
michael@0:   void SetOutlineStyle(uint8_t aStyle)
michael@0:   {
michael@0:     mOutlineStyle &= ~BORDER_STYLE_MASK;
michael@0:     mOutlineStyle |= (aStyle & BORDER_STYLE_MASK);
michael@0:   }
michael@0: 
michael@0:   // false means initial value
michael@0:   bool GetOutlineColor(nscolor& aColor) const
michael@0:   {
michael@0:     if ((mOutlineStyle & BORDER_COLOR_SPECIAL) == 0) {
michael@0:       aColor = mOutlineColor;
michael@0:       return true;
michael@0:     }
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   void SetOutlineColor(nscolor aColor)
michael@0:   {
michael@0:     mOutlineColor = aColor;
michael@0:     mOutlineStyle &= ~BORDER_COLOR_SPECIAL;
michael@0:   }
michael@0: 
michael@0:   void SetOutlineInitialColor()
michael@0:   {
michael@0:     mOutlineStyle |= OUTLINE_COLOR_INITIAL;
michael@0:   }
michael@0: 
michael@0:   bool GetOutlineInitialColor() const
michael@0:   {
michael@0:     return !!(mOutlineStyle & OUTLINE_COLOR_INITIAL);
michael@0:   }
michael@0: 
michael@0: protected:
michael@0:   // This value is the actual value, so it's rounded to the nearest device
michael@0:   // pixel.
michael@0:   nscoord       mCachedOutlineWidth;
michael@0: 
michael@0:   nscolor       mOutlineColor;    // [reset]
michael@0: 
michael@0:   bool          mHasCachedOutline;
michael@0:   uint8_t       mOutlineStyle;    // [reset] See nsStyleConsts.h
michael@0: 
michael@0:   nscoord       mTwipsPerPixel;
michael@0: };
michael@0: 
michael@0: 
michael@0: struct nsStyleList {
michael@0:   nsStyleList(void);
michael@0:   nsStyleList(const nsStyleList& aStyleList);
michael@0:   ~nsStyleList(void);
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
michael@0:     return aContext->AllocateFromShell(sz);
michael@0:   }
michael@0:   void Destroy(nsPresContext* aContext) {
michael@0:     this->~nsStyleList();
michael@0:     aContext->FreeToShell(sizeof(nsStyleList), this);
michael@0:   }
michael@0: 
michael@0:   nsChangeHint CalcDifference(const nsStyleList& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     return NS_STYLE_HINT_FRAMECHANGE;
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference never returns nsChangeHint_NeedReflow or
michael@0:     // nsChangeHint_ClearAncestorIntrinsics as inherited hints.
michael@0:     return NS_CombineHint(nsChangeHint_NeedReflow,
michael@0:                           nsChangeHint_ClearAncestorIntrinsics);
michael@0:   }
michael@0: 
michael@0:   imgRequestProxy* GetListStyleImage() const { return mListStyleImage; }
michael@0:   void SetListStyleImage(imgRequestProxy* aReq)
michael@0:   {
michael@0:     if (mListStyleImage)
michael@0:       mListStyleImage->UnlockImage();
michael@0:     mListStyleImage = aReq;
michael@0:     if (mListStyleImage)
michael@0:       mListStyleImage->LockImage();
michael@0:   }
michael@0: 
michael@0:   uint8_t   mListStyleType;             // [inherited] See nsStyleConsts.h
michael@0:   uint8_t   mListStylePosition;         // [inherited]
michael@0: private:
michael@0:   nsRefPtr<imgRequestProxy> mListStyleImage; // [inherited]
michael@0:   nsStyleList& operator=(const nsStyleList& aOther) MOZ_DELETE;
michael@0: public:
michael@0:   nsRect        mImageRegion;           // [inherited] the rect to use within an image
michael@0: };
michael@0: 
michael@0: // Computed value of the grid-template-columns or grid-columns-rows property
michael@0: // (but *not* grid-template-areas.)
michael@0: // http://dev.w3.org/csswg/css-grid/#track-sizing
michael@0: //
michael@0: // This represents either:
michael@0: // * none:
michael@0: //   mIsSubgrid is false, all three arrays are empty
michael@0: // * <track-list>:
michael@0: //   mIsSubgrid is false,
michael@0: //   mMinTrackSizingFunctions and mMaxTrackSizingFunctions
michael@0: //   are of identical non-zero size,
michael@0: //   and mLineNameLists is one element longer than that.
michael@0: //   (Delimiting N columns requires N+1 lines:
michael@0: //   one before each track, plus one at the very end.)
michael@0: //
michael@0: //   An omitted <line-names> is still represented in mLineNameLists,
michael@0: //   as an empty sub-array.
michael@0: //
michael@0: //   A <track-size> specified as a single <track-breadth> is represented
michael@0: //   as identical min and max sizing functions.
michael@0: //
michael@0: //   The units for nsStyleCoord are:
michael@0: //   * eStyleUnit_Percent represents a <percentage>
michael@0: //   * eStyleUnit_FlexFraction represents a <flex> flexible fraction
michael@0: //   * eStyleUnit_Coord represents a <length>
michael@0: //   * eStyleUnit_Enumerated represents min-content or max-content
michael@0: // * subgrid <line-name-list>?:
michael@0: //   mIsSubgrid is true,
michael@0: //   mLineNameLists may or may not be empty,
michael@0: //   mMinTrackSizingFunctions and mMaxTrackSizingFunctions are empty.
michael@0: struct nsStyleGridTemplate {
michael@0:   bool mIsSubgrid;
michael@0:   nsTArray<nsTArray<nsString>> mLineNameLists;
michael@0:   nsTArray<nsStyleCoord> mMinTrackSizingFunctions;
michael@0:   nsTArray<nsStyleCoord> mMaxTrackSizingFunctions;
michael@0: 
michael@0:   nsStyleGridTemplate()
michael@0:     : mIsSubgrid(false)
michael@0:   {
michael@0:   }
michael@0: 
michael@0:   inline bool operator!=(const nsStyleGridTemplate& aOther) const {
michael@0:     return mLineNameLists != aOther.mLineNameLists ||
michael@0:            mMinTrackSizingFunctions != aOther.mMinTrackSizingFunctions ||
michael@0:            mMaxTrackSizingFunctions != aOther.mMaxTrackSizingFunctions;
michael@0:   }
michael@0: };
michael@0: 
michael@0: struct nsStyleGridLine {
michael@0:   // http://dev.w3.org/csswg/css-grid/#typedef-grid-line
michael@0:   bool mHasSpan;
michael@0:   int32_t mInteger;  // 0 means not provided
michael@0:   nsString mLineName;  // Empty string means not provided.
michael@0: 
michael@0:   nsStyleGridLine()
michael@0:     : mHasSpan(false)
michael@0:     , mInteger(0)
michael@0:     // mLineName get its default constructor, the empty string
michael@0:   {
michael@0:   }
michael@0: 
michael@0:   nsStyleGridLine(const nsStyleGridLine& aOther)
michael@0:   {
michael@0:     (*this) = aOther;
michael@0:   }
michael@0: 
michael@0:   void operator=(const nsStyleGridLine& aOther)
michael@0:   {
michael@0:     mHasSpan = aOther.mHasSpan;
michael@0:     mInteger = aOther.mInteger;
michael@0:     mLineName = aOther.mLineName;
michael@0:   }
michael@0: 
michael@0:   bool operator!=(const nsStyleGridLine& aOther) const
michael@0:   {
michael@0:     return mHasSpan != aOther.mHasSpan ||
michael@0:            mInteger != aOther.mInteger ||
michael@0:            mLineName != aOther.mLineName;
michael@0:   }
michael@0: 
michael@0:   void SetToInteger(uint32_t value)
michael@0:   {
michael@0:     mHasSpan = false;
michael@0:     mInteger = value;
michael@0:     mLineName.Truncate();
michael@0:   }
michael@0: 
michael@0:   void SetAuto()
michael@0:   {
michael@0:     mHasSpan = false;
michael@0:     mInteger = 0;
michael@0:     mLineName.Truncate();
michael@0:   }
michael@0: 
michael@0:   bool IsAuto() const
michael@0:   {
michael@0:     bool haveInitialValues =  mInteger == 0 && mLineName.IsEmpty();
michael@0:     MOZ_ASSERT(!(haveInitialValues && mHasSpan),
michael@0:                "should not have 'span' when other components are "
michael@0:                "at their initial values");
michael@0:     return haveInitialValues;
michael@0:   }
michael@0: };
michael@0: 
michael@0: struct nsStylePosition {
michael@0:   nsStylePosition(void);
michael@0:   nsStylePosition(const nsStylePosition& aOther);
michael@0:   ~nsStylePosition(void);
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
michael@0:     return aContext->AllocateFromShell(sz);
michael@0:   }
michael@0:   void Destroy(nsPresContext* aContext) {
michael@0:     this->~nsStylePosition();
michael@0:     aContext->FreeToShell(sizeof(nsStylePosition), this);
michael@0:   }
michael@0: 
michael@0:   nsChangeHint CalcDifference(const nsStylePosition& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     return NS_CombineHint(NS_STYLE_HINT_REFLOW,
michael@0:                           nsChangeHint(nsChangeHint_RecomputePosition |
michael@0:                                        nsChangeHint_UpdateOverflow));
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference can return both nsChangeHint_ClearAncestorIntrinsics and
michael@0:     // nsChangeHint_NeedReflow as inherited hints.
michael@0:     return nsChangeHint(0);
michael@0:   }
michael@0: 
michael@0:   nsStyleSides  mOffset;                // [reset] coord, percent, calc, auto
michael@0:   nsStyleCoord  mWidth;                 // [reset] coord, percent, enum, calc, auto
michael@0:   nsStyleCoord  mMinWidth;              // [reset] coord, percent, enum, calc
michael@0:   nsStyleCoord  mMaxWidth;              // [reset] coord, percent, enum, calc, none
michael@0:   nsStyleCoord  mHeight;                // [reset] coord, percent, calc, auto
michael@0:   nsStyleCoord  mMinHeight;             // [reset] coord, percent, calc
michael@0:   nsStyleCoord  mMaxHeight;             // [reset] coord, percent, calc, none
michael@0:   nsStyleCoord  mFlexBasis;             // [reset] coord, percent, enum, calc, auto
michael@0:   nsStyleCoord  mGridAutoColumnsMin;    // [reset] coord, percent, enum, calc, flex
michael@0:   nsStyleCoord  mGridAutoColumnsMax;    // [reset] coord, percent, enum, calc, flex
michael@0:   nsStyleCoord  mGridAutoRowsMin;       // [reset] coord, percent, enum, calc, flex
michael@0:   nsStyleCoord  mGridAutoRowsMax;       // [reset] coord, percent, enum, calc, flex
michael@0:   uint8_t       mGridAutoFlow;          // [reset] enumerated. See nsStyleConsts.h
michael@0:   uint8_t       mBoxSizing;             // [reset] see nsStyleConsts.h
michael@0:   uint8_t       mAlignContent;          // [reset] see nsStyleConsts.h
michael@0:   uint8_t       mAlignItems;            // [reset] see nsStyleConsts.h
michael@0:   uint8_t       mAlignSelf;             // [reset] see nsStyleConsts.h
michael@0:   uint8_t       mFlexDirection;         // [reset] see nsStyleConsts.h
michael@0:   uint8_t       mFlexWrap;              // [reset] see nsStyleConsts.h
michael@0:   uint8_t       mJustifyContent;        // [reset] see nsStyleConsts.h
michael@0:   int32_t       mOrder;                 // [reset] integer
michael@0:   float         mFlexGrow;              // [reset] float
michael@0:   float         mFlexShrink;            // [reset] float
michael@0:   nsStyleCoord  mZIndex;                // [reset] integer, auto
michael@0:   // NOTE: Fields so far can be memcpy()'ed, while following fields
michael@0:   // need to have their copy constructor called when we're being copied.
michael@0:   // See nsStylePosition::nsStylePosition(const nsStylePosition& aSource)
michael@0:   // in nsStyleStruct.cpp
michael@0:   nsStyleGridTemplate mGridTemplateColumns;
michael@0:   nsStyleGridTemplate mGridTemplateRows;
michael@0: 
michael@0:   // nullptr for 'none'
michael@0:   nsRefPtr<mozilla::css::GridTemplateAreasValue> mGridTemplateAreas;
michael@0: 
michael@0:   // We represent the "grid-auto-position" property in two parts:
michael@0:   nsStyleGridLine mGridAutoPositionColumn;
michael@0:   nsStyleGridLine mGridAutoPositionRow;
michael@0: 
michael@0:   nsStyleGridLine mGridColumnStart;
michael@0:   nsStyleGridLine mGridColumnEnd;
michael@0:   nsStyleGridLine mGridRowStart;
michael@0:   nsStyleGridLine mGridRowEnd;
michael@0: 
michael@0:   bool WidthDependsOnContainer() const
michael@0:     { return WidthCoordDependsOnContainer(mWidth); }
michael@0:   bool MinWidthDependsOnContainer() const
michael@0:     { return WidthCoordDependsOnContainer(mMinWidth); }
michael@0:   bool MaxWidthDependsOnContainer() const
michael@0:     { return WidthCoordDependsOnContainer(mMaxWidth); }
michael@0: 
michael@0:   // Note that these functions count 'auto' as depending on the
michael@0:   // container since that's the case for absolutely positioned elements.
michael@0:   // However, some callers do not care about this case and should check
michael@0:   // for it, since it is the most common case.
michael@0:   // FIXME: We should probably change the assumption to be the other way
michael@0:   // around.
michael@0:   bool HeightDependsOnContainer() const
michael@0:     { return HeightCoordDependsOnContainer(mHeight); }
michael@0:   bool MinHeightDependsOnContainer() const
michael@0:     { return HeightCoordDependsOnContainer(mMinHeight); }
michael@0:   bool MaxHeightDependsOnContainer() const
michael@0:     { return HeightCoordDependsOnContainer(mMaxHeight); }
michael@0: 
michael@0:   bool OffsetHasPercent(mozilla::css::Side aSide) const
michael@0:   {
michael@0:     return mOffset.Get(aSide).HasPercent();
michael@0:   }
michael@0: 
michael@0: private:
michael@0:   static bool WidthCoordDependsOnContainer(const nsStyleCoord &aCoord);
michael@0:   static bool HeightCoordDependsOnContainer(const nsStyleCoord &aCoord)
michael@0:   {
michael@0:     return aCoord.GetUnit() == eStyleUnit_Auto || // CSS 2.1, 10.6.4, item (5)
michael@0:            aCoord.HasPercent();
michael@0:   }
michael@0: };
michael@0: 
michael@0: struct nsStyleTextOverflowSide {
michael@0:   nsStyleTextOverflowSide() : mType(NS_STYLE_TEXT_OVERFLOW_CLIP) {}
michael@0: 
michael@0:   bool operator==(const nsStyleTextOverflowSide& aOther) const {
michael@0:     return mType == aOther.mType &&
michael@0:            (mType != NS_STYLE_TEXT_OVERFLOW_STRING ||
michael@0:             mString == aOther.mString);
michael@0:   }
michael@0:   bool operator!=(const nsStyleTextOverflowSide& aOther) const {
michael@0:     return !(*this == aOther);
michael@0:   }
michael@0: 
michael@0:   nsString mString;
michael@0:   uint8_t  mType;
michael@0: };
michael@0: 
michael@0: struct nsStyleTextOverflow {
michael@0:   nsStyleTextOverflow() : mLogicalDirections(true) {}
michael@0:   bool operator==(const nsStyleTextOverflow& aOther) const {
michael@0:     return mLeft == aOther.mLeft && mRight == aOther.mRight;
michael@0:   }
michael@0:   bool operator!=(const nsStyleTextOverflow& aOther) const {
michael@0:     return !(*this == aOther);
michael@0:   }
michael@0: 
michael@0:   // Returns the value to apply on the left side.
michael@0:   const nsStyleTextOverflowSide& GetLeft(uint8_t aDirection) const {
michael@0:     NS_ASSERTION(aDirection == NS_STYLE_DIRECTION_LTR ||
michael@0:                  aDirection == NS_STYLE_DIRECTION_RTL, "bad direction");
michael@0:     return !mLogicalDirections || aDirection == NS_STYLE_DIRECTION_LTR ?
michael@0:              mLeft : mRight;
michael@0:   }
michael@0: 
michael@0:   // Returns the value to apply on the right side.
michael@0:   const nsStyleTextOverflowSide& GetRight(uint8_t aDirection) const {
michael@0:     NS_ASSERTION(aDirection == NS_STYLE_DIRECTION_LTR ||
michael@0:                  aDirection == NS_STYLE_DIRECTION_RTL, "bad direction");
michael@0:     return !mLogicalDirections || aDirection == NS_STYLE_DIRECTION_LTR ?
michael@0:              mRight : mLeft;
michael@0:   }
michael@0: 
michael@0:   // Returns the first value that was specified.
michael@0:   const nsStyleTextOverflowSide* GetFirstValue() const {
michael@0:     return mLogicalDirections ? &mRight : &mLeft;
michael@0:   }
michael@0: 
michael@0:   // Returns the second value, or null if there was only one value specified.
michael@0:   const nsStyleTextOverflowSide* GetSecondValue() const {
michael@0:     return mLogicalDirections ? nullptr : &mRight;
michael@0:   }
michael@0: 
michael@0:   nsStyleTextOverflowSide mLeft;  // start side when mLogicalDirections is true
michael@0:   nsStyleTextOverflowSide mRight; // end side when mLogicalDirections is true
michael@0:   bool mLogicalDirections;  // true when only one value was specified
michael@0: };
michael@0: 
michael@0: struct nsStyleTextReset {
michael@0:   nsStyleTextReset(void);
michael@0:   nsStyleTextReset(const nsStyleTextReset& aOther);
michael@0:   ~nsStyleTextReset(void);
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
michael@0:     return aContext->AllocateFromShell(sz);
michael@0:   }
michael@0:   void Destroy(nsPresContext* aContext) {
michael@0:     this->~nsStyleTextReset();
michael@0:     aContext->FreeToShell(sizeof(nsStyleTextReset), this);
michael@0:   }
michael@0: 
michael@0:   uint8_t GetDecorationStyle() const
michael@0:   {
michael@0:     return (mTextDecorationStyle & BORDER_STYLE_MASK);
michael@0:   }
michael@0: 
michael@0:   void SetDecorationStyle(uint8_t aStyle)
michael@0:   {
michael@0:     NS_ABORT_IF_FALSE((aStyle & BORDER_STYLE_MASK) == aStyle,
michael@0:                       "style doesn't fit");
michael@0:     mTextDecorationStyle &= ~BORDER_STYLE_MASK;
michael@0:     mTextDecorationStyle |= (aStyle & BORDER_STYLE_MASK);
michael@0:   }
michael@0: 
michael@0:   void GetDecorationColor(nscolor& aColor, bool& aForeground) const
michael@0:   {
michael@0:     aForeground = false;
michael@0:     if ((mTextDecorationStyle & BORDER_COLOR_SPECIAL) == 0) {
michael@0:       aColor = mTextDecorationColor;
michael@0:     } else if (mTextDecorationStyle & BORDER_COLOR_FOREGROUND) {
michael@0:       aForeground = true;
michael@0:     } else {
michael@0:       NS_NOTREACHED("OUTLINE_COLOR_INITIAL should not be set here");
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   void SetDecorationColor(nscolor aColor)
michael@0:   {
michael@0:     mTextDecorationColor = aColor;
michael@0:     mTextDecorationStyle &= ~BORDER_COLOR_SPECIAL;
michael@0:   }
michael@0: 
michael@0:   void SetDecorationColorToForeground()
michael@0:   {
michael@0:     mTextDecorationStyle &= ~BORDER_COLOR_SPECIAL;
michael@0:     mTextDecorationStyle |= BORDER_COLOR_FOREGROUND;
michael@0:   }
michael@0: 
michael@0:   nsChangeHint CalcDifference(const nsStyleTextReset& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     return NS_STYLE_HINT_REFLOW;
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference never returns nsChangeHint_NeedReflow or
michael@0:     // nsChangeHint_ClearAncestorIntrinsics as inherited hints.
michael@0:     return NS_CombineHint(nsChangeHint_NeedReflow,
michael@0:                           nsChangeHint_ClearAncestorIntrinsics);
michael@0:   }
michael@0: 
michael@0:   nsStyleCoord  mVerticalAlign;         // [reset] coord, percent, calc, enum (see nsStyleConsts.h)
michael@0:   nsStyleTextOverflow mTextOverflow;    // [reset] enum, string
michael@0: 
michael@0:   uint8_t mTextDecorationLine;          // [reset] see nsStyleConsts.h
michael@0:   uint8_t mUnicodeBidi;                 // [reset] see nsStyleConsts.h
michael@0: protected:
michael@0:   uint8_t mTextDecorationStyle;         // [reset] see nsStyleConsts.h
michael@0: 
michael@0:   nscolor mTextDecorationColor;         // [reset] the colors to use for a decoration lines, not used at currentColor
michael@0: };
michael@0: 
michael@0: struct nsStyleText {
michael@0:   nsStyleText(void);
michael@0:   nsStyleText(const nsStyleText& aOther);
michael@0:   ~nsStyleText(void);
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
michael@0:     return aContext->AllocateFromShell(sz);
michael@0:   }
michael@0:   void Destroy(nsPresContext* aContext) {
michael@0:     this->~nsStyleText();
michael@0:     aContext->FreeToShell(sizeof(nsStyleText), this);
michael@0:   }
michael@0: 
michael@0:   nsChangeHint CalcDifference(const nsStyleText& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     return NS_STYLE_HINT_FRAMECHANGE;
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference never returns nsChangeHint_NeedReflow or
michael@0:     // nsChangeHint_ClearAncestorIntrinsics as inherited hints.
michael@0:     return NS_CombineHint(nsChangeHint_NeedReflow,
michael@0:                           nsChangeHint_ClearAncestorIntrinsics);
michael@0:   }
michael@0: 
michael@0:   uint8_t mTextAlign;                   // [inherited] see nsStyleConsts.h
michael@0:   uint8_t mTextAlignLast;               // [inherited] see nsStyleConsts.h
michael@0:   bool mTextAlignTrue : 1;              // [inherited] see nsStyleConsts.h
michael@0:   bool mTextAlignLastTrue : 1;          // [inherited] see nsStyleConsts.h
michael@0:   uint8_t mTextTransform;               // [inherited] see nsStyleConsts.h
michael@0:   uint8_t mWhiteSpace;                  // [inherited] see nsStyleConsts.h
michael@0:   uint8_t mWordBreak;                   // [inherited] see nsStyleConsts.h
michael@0:   uint8_t mWordWrap;                    // [inherited] see nsStyleConsts.h
michael@0:   uint8_t mHyphens;                     // [inherited] see nsStyleConsts.h
michael@0:   uint8_t mTextSizeAdjust;              // [inherited] see nsStyleConsts.h
michael@0:   uint8_t mTextOrientation;             // [inherited] see nsStyleConsts.h
michael@0:   uint8_t mTextCombineUpright;          // [inherited] see nsStyleConsts.h
michael@0:   uint8_t mControlCharacterVisibility;  // [inherited] see nsStyleConsts.h
michael@0:   int32_t mTabSize;                     // [inherited] see nsStyleConsts.h
michael@0: 
michael@0:   nscoord mWordSpacing;                 // [inherited]
michael@0:   nsStyleCoord  mLetterSpacing;         // [inherited] coord, normal
michael@0:   nsStyleCoord  mLineHeight;            // [inherited] coord, factor, normal
michael@0:   nsStyleCoord  mTextIndent;            // [inherited] coord, percent, calc
michael@0: 
michael@0:   nsRefPtr<nsCSSShadowArray> mTextShadow; // [inherited] nullptr in case of a zero-length
michael@0: 
michael@0:   bool WhiteSpaceIsSignificant() const {
michael@0:     return mWhiteSpace == NS_STYLE_WHITESPACE_PRE ||
michael@0:            mWhiteSpace == NS_STYLE_WHITESPACE_PRE_WRAP ||
michael@0:            mWhiteSpace == NS_STYLE_WHITESPACE_PRE_DISCARD_NEWLINES;
michael@0:   }
michael@0: 
michael@0:   bool NewlineIsSignificant() const {
michael@0:     return mWhiteSpace == NS_STYLE_WHITESPACE_PRE ||
michael@0:            mWhiteSpace == NS_STYLE_WHITESPACE_PRE_WRAP ||
michael@0:            mWhiteSpace == NS_STYLE_WHITESPACE_PRE_LINE;
michael@0:   }
michael@0: 
michael@0:   bool NewlineIsDiscarded() const {
michael@0:     return mWhiteSpace == NS_STYLE_WHITESPACE_PRE_DISCARD_NEWLINES;
michael@0:   }
michael@0: 
michael@0:   bool WhiteSpaceOrNewlineIsSignificant() const {
michael@0:     return mWhiteSpace == NS_STYLE_WHITESPACE_PRE ||
michael@0:            mWhiteSpace == NS_STYLE_WHITESPACE_PRE_WRAP ||
michael@0:            mWhiteSpace == NS_STYLE_WHITESPACE_PRE_LINE ||
michael@0:            mWhiteSpace == NS_STYLE_WHITESPACE_PRE_DISCARD_NEWLINES;
michael@0:   }
michael@0: 
michael@0:   bool WhiteSpaceCanWrapStyle() const {
michael@0:     return mWhiteSpace == NS_STYLE_WHITESPACE_NORMAL ||
michael@0:            mWhiteSpace == NS_STYLE_WHITESPACE_PRE_WRAP ||
michael@0:            mWhiteSpace == NS_STYLE_WHITESPACE_PRE_LINE;
michael@0:   }
michael@0: 
michael@0:   bool WordCanWrapStyle() const {
michael@0:     return WhiteSpaceCanWrapStyle() &&
michael@0:            mWordWrap == NS_STYLE_WORDWRAP_BREAK_WORD;
michael@0:   }
michael@0: 
michael@0:   // These are defined in nsStyleStructInlines.h.
michael@0:   inline bool HasTextShadow() const;
michael@0:   inline nsCSSShadowArray* GetTextShadow() const;
michael@0: 
michael@0:   // The aContextFrame argument on each of these is the frame this
michael@0:   // style struct is for.  If the frame is for SVG text, the return
michael@0:   // value will be massaged to be something that makes sense for
michael@0:   // SVG text.
michael@0:   inline bool WhiteSpaceCanWrap(const nsIFrame* aContextFrame) const;
michael@0:   inline bool WordCanWrap(const nsIFrame* aContextFrame) const;
michael@0: };
michael@0: 
michael@0: struct nsStyleImageOrientation {
michael@0:   static nsStyleImageOrientation CreateAsAngleAndFlip(double aRadians,
michael@0:                                                       bool aFlip) {
michael@0:     uint8_t orientation(0);
michael@0: 
michael@0:     // Compute the final angle value, rounding to the closest quarter turn.
michael@0:     double roundedAngle = fmod(aRadians, 2 * M_PI);
michael@0:     if      (roundedAngle < 0.25 * M_PI) orientation = ANGLE_0;
michael@0:     else if (roundedAngle < 0.75 * M_PI) orientation = ANGLE_90;
michael@0:     else if (roundedAngle < 1.25 * M_PI) orientation = ANGLE_180;
michael@0:     else if (roundedAngle < 1.75 * M_PI) orientation = ANGLE_270;
michael@0:     else                                 orientation = ANGLE_0;
michael@0: 
michael@0:     // Add a bit for 'flip' if needed.
michael@0:     if (aFlip)
michael@0:       orientation |= FLIP_MASK;
michael@0: 
michael@0:     return nsStyleImageOrientation(orientation);
michael@0:   }
michael@0: 
michael@0:   static nsStyleImageOrientation CreateAsFlip() {
michael@0:     return nsStyleImageOrientation(FLIP_MASK);
michael@0:   }
michael@0: 
michael@0:   static nsStyleImageOrientation CreateAsFromImage() {
michael@0:     return nsStyleImageOrientation(FROM_IMAGE_MASK);
michael@0:   }
michael@0: 
michael@0:   // The default constructor yields 0 degrees of rotation and no flip.
michael@0:   nsStyleImageOrientation() : mOrientation(0) { }
michael@0: 
michael@0:   bool IsDefault()   const { return mOrientation == 0; }
michael@0:   bool IsFlipped()   const { return mOrientation & FLIP_MASK; }
michael@0:   bool IsFromImage() const { return mOrientation & FROM_IMAGE_MASK; }
michael@0: 
michael@0:   mozilla::image::Angle Angle() const {
michael@0:     switch (mOrientation & ORIENTATION_MASK) {
michael@0:       case ANGLE_0:   return mozilla::image::Angle::D0;
michael@0:       case ANGLE_90:  return mozilla::image::Angle::D90;
michael@0:       case ANGLE_180: return mozilla::image::Angle::D180;
michael@0:       case ANGLE_270: return mozilla::image::Angle::D270;
michael@0:       default:
michael@0:         NS_NOTREACHED("Unexpected angle");
michael@0:         return mozilla::image::Angle::D0;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   nsStyleCoord AngleAsCoord() const {
michael@0:     switch (mOrientation & ORIENTATION_MASK) {
michael@0:       case ANGLE_0:   return nsStyleCoord(0.0f,   eStyleUnit_Degree);
michael@0:       case ANGLE_90:  return nsStyleCoord(90.0f,  eStyleUnit_Degree);
michael@0:       case ANGLE_180: return nsStyleCoord(180.0f, eStyleUnit_Degree);
michael@0:       case ANGLE_270: return nsStyleCoord(270.0f, eStyleUnit_Degree);
michael@0:       default:
michael@0:         NS_NOTREACHED("Unexpected angle");
michael@0:         return nsStyleCoord();
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   bool operator==(const nsStyleImageOrientation& aOther) const {
michael@0:     return aOther.mOrientation == mOrientation;
michael@0:   }
michael@0: 
michael@0:   bool operator!=(const nsStyleImageOrientation& aOther) const {
michael@0:     return !(*this == aOther);
michael@0:   }
michael@0: 
michael@0: protected:
michael@0:   enum Bits {
michael@0:     ORIENTATION_MASK = 0x1 | 0x2,  // The bottom two bits are the angle.
michael@0:     FLIP_MASK        = 0x4,        // Whether the image should be flipped.
michael@0:     FROM_IMAGE_MASK  = 0x8,        // Whether the image's inherent orientation
michael@0:   };                               // should be used.
michael@0: 
michael@0:   enum Angles {
michael@0:     ANGLE_0   = 0,
michael@0:     ANGLE_90  = 1,
michael@0:     ANGLE_180 = 2,
michael@0:     ANGLE_270 = 3,
michael@0:   };
michael@0: 
michael@0:   explicit nsStyleImageOrientation(uint8_t aOrientation)
michael@0:     : mOrientation(aOrientation)
michael@0:   { }
michael@0: 
michael@0:   uint8_t mOrientation;
michael@0: };
michael@0: 
michael@0: struct nsStyleVisibility {
michael@0:   nsStyleVisibility(nsPresContext* aPresContext);
michael@0:   nsStyleVisibility(const nsStyleVisibility& aVisibility);
michael@0:   ~nsStyleVisibility() {
michael@0:     MOZ_COUNT_DTOR(nsStyleVisibility);
michael@0:   }
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
michael@0:     return aContext->AllocateFromShell(sz);
michael@0:   }
michael@0:   void Destroy(nsPresContext* aContext) {
michael@0:     this->~nsStyleVisibility();
michael@0:     aContext->FreeToShell(sizeof(nsStyleVisibility), this);
michael@0:   }
michael@0: 
michael@0:   nsChangeHint CalcDifference(const nsStyleVisibility& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     return NS_STYLE_HINT_FRAMECHANGE;
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference never returns nsChangeHint_NeedReflow or
michael@0:     // nsChangeHint_ClearAncestorIntrinsics as inherited hints.
michael@0:     return NS_CombineHint(nsChangeHint_NeedReflow,
michael@0:                           nsChangeHint_ClearAncestorIntrinsics);
michael@0:   }
michael@0: 
michael@0:   nsStyleImageOrientation mImageOrientation;  // [inherited]
michael@0:   uint8_t mDirection;                  // [inherited] see nsStyleConsts.h NS_STYLE_DIRECTION_*
michael@0:   uint8_t mVisible;                    // [inherited]
michael@0:   uint8_t mPointerEvents;              // [inherited] see nsStyleConsts.h
michael@0:   uint8_t mWritingMode;                // [inherited] see nsStyleConsts.h
michael@0: 
michael@0:   bool IsVisible() const {
michael@0:     return (mVisible == NS_STYLE_VISIBILITY_VISIBLE);
michael@0:   }
michael@0: 
michael@0:   bool IsVisibleOrCollapsed() const {
michael@0:     return ((mVisible == NS_STYLE_VISIBILITY_VISIBLE) ||
michael@0:             (mVisible == NS_STYLE_VISIBILITY_COLLAPSE));
michael@0:   }
michael@0: 
michael@0:   inline uint8_t GetEffectivePointerEvents(nsIFrame* aFrame) const;
michael@0: };
michael@0: 
michael@0: struct nsTimingFunction {
michael@0:   enum Type { Function, StepStart, StepEnd };
michael@0: 
michael@0:   explicit nsTimingFunction(int32_t aTimingFunctionType
michael@0:                               = NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE)
michael@0:   {
michael@0:     AssignFromKeyword(aTimingFunctionType);
michael@0:   }
michael@0: 
michael@0:   nsTimingFunction(float x1, float y1, float x2, float y2)
michael@0:     : mType(Function)
michael@0:   {
michael@0:     mFunc.mX1 = x1;
michael@0:     mFunc.mY1 = y1;
michael@0:     mFunc.mX2 = x2;
michael@0:     mFunc.mY2 = y2;
michael@0:   }
michael@0: 
michael@0:   nsTimingFunction(Type aType, uint32_t aSteps)
michael@0:     : mType(aType)
michael@0:   {
michael@0:     NS_ABORT_IF_FALSE(mType == StepStart || mType == StepEnd, "wrong type");
michael@0:     mSteps = aSteps;
michael@0:   }
michael@0: 
michael@0:   nsTimingFunction(const nsTimingFunction& aOther)
michael@0:   {
michael@0:     *this = aOther;
michael@0:   }
michael@0: 
michael@0:   Type mType;
michael@0:   union {
michael@0:     struct {
michael@0:       float mX1;
michael@0:       float mY1;
michael@0:       float mX2;
michael@0:       float mY2;
michael@0:     } mFunc;
michael@0:     uint32_t mSteps;
michael@0:   };
michael@0: 
michael@0:   nsTimingFunction&
michael@0:   operator=(const nsTimingFunction& aOther)
michael@0:   {
michael@0:     if (&aOther == this)
michael@0:       return *this;
michael@0: 
michael@0:     mType = aOther.mType;
michael@0: 
michael@0:     if (mType == Function) {
michael@0:       mFunc.mX1 = aOther.mFunc.mX1;
michael@0:       mFunc.mY1 = aOther.mFunc.mY1;
michael@0:       mFunc.mX2 = aOther.mFunc.mX2;
michael@0:       mFunc.mY2 = aOther.mFunc.mY2;
michael@0:     } else {
michael@0:       mSteps = aOther.mSteps;
michael@0:     }
michael@0: 
michael@0:     return *this;
michael@0:   }
michael@0: 
michael@0:   bool operator==(const nsTimingFunction& aOther) const
michael@0:   {
michael@0:     if (mType != aOther.mType) {
michael@0:       return false;
michael@0:     }
michael@0:     if (mType == Function) {
michael@0:       return mFunc.mX1 == aOther.mFunc.mX1 && mFunc.mY1 == aOther.mFunc.mY1 &&
michael@0:              mFunc.mX2 == aOther.mFunc.mX2 && mFunc.mY2 == aOther.mFunc.mY2;
michael@0:     }
michael@0:     return mSteps == aOther.mSteps;
michael@0:   }
michael@0: 
michael@0:   bool operator!=(const nsTimingFunction& aOther) const
michael@0:   {
michael@0:     return !(*this == aOther);
michael@0:   }
michael@0: 
michael@0: private:
michael@0:   void AssignFromKeyword(int32_t aTimingFunctionType);
michael@0: };
michael@0: 
michael@0: struct nsTransition {
michael@0:   nsTransition() { /* leaves uninitialized; see also SetInitialValues */ }
michael@0:   explicit nsTransition(const nsTransition& aCopy);
michael@0: 
michael@0:   void SetInitialValues();
michael@0: 
michael@0:   // Delay and Duration are in milliseconds
michael@0: 
michael@0:   const nsTimingFunction& GetTimingFunction() const { return mTimingFunction; }
michael@0:   float GetDelay() const { return mDelay; }
michael@0:   float GetDuration() const { return mDuration; }
michael@0:   nsCSSProperty GetProperty() const { return mProperty; }
michael@0:   nsIAtom* GetUnknownProperty() const { return mUnknownProperty; }
michael@0: 
michael@0:   void SetTimingFunction(const nsTimingFunction& aTimingFunction)
michael@0:     { mTimingFunction = aTimingFunction; }
michael@0:   void SetDelay(float aDelay) { mDelay = aDelay; }
michael@0:   void SetDuration(float aDuration) { mDuration = aDuration; }
michael@0:   void SetProperty(nsCSSProperty aProperty)
michael@0:     {
michael@0:       NS_ASSERTION(aProperty != eCSSProperty_UNKNOWN, "invalid property");
michael@0:       mProperty = aProperty;
michael@0:     }
michael@0:   void SetUnknownProperty(const nsAString& aUnknownProperty);
michael@0:   void CopyPropertyFrom(const nsTransition& aOther)
michael@0:     {
michael@0:       mProperty = aOther.mProperty;
michael@0:       mUnknownProperty = aOther.mUnknownProperty;
michael@0:     }
michael@0: 
michael@0:   nsTimingFunction& TimingFunctionSlot() { return mTimingFunction; }
michael@0: 
michael@0: private:
michael@0:   nsTimingFunction mTimingFunction;
michael@0:   float mDuration;
michael@0:   float mDelay;
michael@0:   nsCSSProperty mProperty;
michael@0:   nsCOMPtr<nsIAtom> mUnknownProperty; // used when mProperty is
michael@0:                                       // eCSSProperty_UNKNOWN
michael@0: };
michael@0: 
michael@0: struct nsAnimation {
michael@0:   nsAnimation() { /* leaves uninitialized; see also SetInitialValues */ }
michael@0:   explicit nsAnimation(const nsAnimation& aCopy);
michael@0: 
michael@0:   void SetInitialValues();
michael@0: 
michael@0:   // Delay and Duration are in milliseconds
michael@0: 
michael@0:   const nsTimingFunction& GetTimingFunction() const { return mTimingFunction; }
michael@0:   float GetDelay() const { return mDelay; }
michael@0:   float GetDuration() const { return mDuration; }
michael@0:   const nsString& GetName() const { return mName; }
michael@0:   uint8_t GetDirection() const { return mDirection; }
michael@0:   uint8_t GetFillMode() const { return mFillMode; }
michael@0:   uint8_t GetPlayState() const { return mPlayState; }
michael@0:   float GetIterationCount() const { return mIterationCount; }
michael@0: 
michael@0:   void SetTimingFunction(const nsTimingFunction& aTimingFunction)
michael@0:     { mTimingFunction = aTimingFunction; }
michael@0:   void SetDelay(float aDelay) { mDelay = aDelay; }
michael@0:   void SetDuration(float aDuration) { mDuration = aDuration; }
michael@0:   void SetName(const nsSubstring& aName) { mName = aName; }
michael@0:   void SetDirection(uint8_t aDirection) { mDirection = aDirection; }
michael@0:   void SetFillMode(uint8_t aFillMode) { mFillMode = aFillMode; }
michael@0:   void SetPlayState(uint8_t aPlayState) { mPlayState = aPlayState; }
michael@0:   void SetIterationCount(float aIterationCount)
michael@0:     { mIterationCount = aIterationCount; }
michael@0: 
michael@0:   nsTimingFunction& TimingFunctionSlot() { return mTimingFunction; }
michael@0: 
michael@0: private:
michael@0:   nsTimingFunction mTimingFunction;
michael@0:   float mDuration;
michael@0:   float mDelay;
michael@0:   nsString mName; // empty string for 'none'
michael@0:   uint8_t mDirection;
michael@0:   uint8_t mFillMode;
michael@0:   uint8_t mPlayState;
michael@0:   float mIterationCount; // NS_IEEEPositiveInfinity() means infinite
michael@0: };
michael@0: 
michael@0: struct nsStyleDisplay {
michael@0:   nsStyleDisplay();
michael@0:   nsStyleDisplay(const nsStyleDisplay& aOther);
michael@0:   ~nsStyleDisplay() {
michael@0:     MOZ_COUNT_DTOR(nsStyleDisplay);
michael@0:   }
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
michael@0:     return aContext->AllocateFromShell(sz);
michael@0:   }
michael@0:   void Destroy(nsPresContext* aContext) {
michael@0:     this->~nsStyleDisplay();
michael@0:     aContext->FreeToShell(sizeof(nsStyleDisplay), this);
michael@0:   }
michael@0: 
michael@0:   nsChangeHint CalcDifference(const nsStyleDisplay& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     // All the parts of FRAMECHANGE are present in CalcDifference.
michael@0:     return nsChangeHint(NS_STYLE_HINT_FRAMECHANGE |
michael@0:                         nsChangeHint_UpdateOpacityLayer |
michael@0:                         nsChangeHint_UpdateTransformLayer |
michael@0:                         nsChangeHint_UpdateOverflow |
michael@0:                         nsChangeHint_UpdatePostTransformOverflow |
michael@0:                         nsChangeHint_AddOrRemoveTransform);
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference can return both nsChangeHint_ClearAncestorIntrinsics and
michael@0:     // nsChangeHint_NeedReflow as inherited hints.
michael@0:     return nsChangeHint(0);
michael@0:   }
michael@0: 
michael@0:   // We guarantee that if mBinding is non-null, so are mBinding->GetURI() and
michael@0:   // mBinding->mOriginPrincipal.
michael@0:   nsRefPtr<mozilla::css::URLValue> mBinding;    // [reset]
michael@0:   nsRect  mClip;                // [reset] offsets from upper-left border edge
michael@0:   float   mOpacity;             // [reset]
michael@0:   uint8_t mDisplay;             // [reset] see nsStyleConsts.h NS_STYLE_DISPLAY_*
michael@0:   uint8_t mOriginalDisplay;     // [reset] saved mDisplay for position:absolute/fixed
michael@0:                                 //         and float:left/right; otherwise equal
michael@0:                                 //         to mDisplay
michael@0:   uint8_t mAppearance;          // [reset]
michael@0:   uint8_t mPosition;            // [reset] see nsStyleConsts.h
michael@0:   uint8_t mFloats;              // [reset] see nsStyleConsts.h NS_STYLE_FLOAT_*
michael@0:   uint8_t mOriginalFloats;      // [reset] saved mFloats for position:absolute/fixed;
michael@0:                                 //         otherwise equal to mFloats
michael@0:   uint8_t mBreakType;           // [reset] see nsStyleConsts.h NS_STYLE_CLEAR_*
michael@0:   uint8_t mBreakInside;         // [reset] NS_STYLE_PAGE_BREAK_AUTO/AVOID
michael@0:   bool mBreakBefore;    // [reset]
michael@0:   bool mBreakAfter;     // [reset]
michael@0:   uint8_t mOverflowX;           // [reset] see nsStyleConsts.h
michael@0:   uint8_t mOverflowY;           // [reset] see nsStyleConsts.h
michael@0:   uint8_t mOverflowClipBox;     // [reset] see nsStyleConsts.h
michael@0:   uint8_t mResize;              // [reset] see nsStyleConsts.h
michael@0:   uint8_t mClipFlags;           // [reset] see nsStyleConsts.h
michael@0:   uint8_t mOrient;              // [reset] see nsStyleConsts.h
michael@0:   uint8_t mMixBlendMode;        // [reset] see nsStyleConsts.h
michael@0:   uint8_t mWillChangeBitField;  // [reset] see nsStyleConsts.h. Stores a
michael@0:                                 // bitfield representation of the properties
michael@0:                                 // that are frequently queried. This should
michael@0:                                 // match mWillChange. Also tracks if any of the
michael@0:                                 // properties in the will-change list require
michael@0:                                 // a stacking context.
michael@0:   nsAutoTArray<nsString, 1> mWillChange;
michael@0: 
michael@0:   uint8_t mTouchAction;         // [reset] see nsStyleConsts.h
michael@0: 
michael@0:   // mSpecifiedTransform is the list of transform functions as
michael@0:   // specified, or null to indicate there is no transform.  (inherit or
michael@0:   // initial are replaced by an actual list of transform functions, or
michael@0:   // null, as appropriate.)
michael@0:   uint8_t mBackfaceVisibility;
michael@0:   uint8_t mTransformStyle;
michael@0:   nsRefPtr<nsCSSValueSharedList> mSpecifiedTransform; // [reset]
michael@0:   nsStyleCoord mTransformOrigin[3]; // [reset] percent, coord, calc, 3rd param is coord, calc only
michael@0:   nsStyleCoord mChildPerspective; // [reset] coord
michael@0:   nsStyleCoord mPerspectiveOrigin[2]; // [reset] percent, coord, calc
michael@0: 
michael@0:   nsAutoTArray<nsTransition, 1> mTransitions; // [reset]
michael@0:   // The number of elements in mTransitions that are not from repeating
michael@0:   // a list due to another property being longer.
michael@0:   uint32_t mTransitionTimingFunctionCount,
michael@0:            mTransitionDurationCount,
michael@0:            mTransitionDelayCount,
michael@0:            mTransitionPropertyCount;
michael@0: 
michael@0:   nsAutoTArray<nsAnimation, 1> mAnimations; // [reset]
michael@0:   // The number of elements in mAnimations that are not from repeating
michael@0:   // a list due to another property being longer.
michael@0:   uint32_t mAnimationTimingFunctionCount,
michael@0:            mAnimationDurationCount,
michael@0:            mAnimationDelayCount,
michael@0:            mAnimationNameCount,
michael@0:            mAnimationDirectionCount,
michael@0:            mAnimationFillModeCount,
michael@0:            mAnimationPlayStateCount,
michael@0:            mAnimationIterationCountCount;
michael@0: 
michael@0:   bool IsBlockInsideStyle() const {
michael@0:     return NS_STYLE_DISPLAY_BLOCK == mDisplay ||
michael@0:            NS_STYLE_DISPLAY_LIST_ITEM == mDisplay ||
michael@0:            NS_STYLE_DISPLAY_INLINE_BLOCK == mDisplay;
michael@0:     // Should TABLE_CELL and TABLE_CAPTION go here?  They have
michael@0:     // block frames nested inside of them.
michael@0:     // (But please audit all callers before changing.)
michael@0:   }
michael@0: 
michael@0:   bool IsBlockOutsideStyle() const {
michael@0:     return NS_STYLE_DISPLAY_BLOCK == mDisplay ||
michael@0:            NS_STYLE_DISPLAY_FLEX == mDisplay ||
michael@0:            NS_STYLE_DISPLAY_GRID == mDisplay ||
michael@0:            NS_STYLE_DISPLAY_LIST_ITEM == mDisplay ||
michael@0:            NS_STYLE_DISPLAY_TABLE == mDisplay;
michael@0:   }
michael@0: 
michael@0:   static bool IsDisplayTypeInlineOutside(uint8_t aDisplay) {
michael@0:     return NS_STYLE_DISPLAY_INLINE == aDisplay ||
michael@0:            NS_STYLE_DISPLAY_INLINE_BLOCK == aDisplay ||
michael@0:            NS_STYLE_DISPLAY_INLINE_TABLE == aDisplay ||
michael@0:            NS_STYLE_DISPLAY_INLINE_BOX == aDisplay ||
michael@0:            NS_STYLE_DISPLAY_INLINE_FLEX == aDisplay ||
michael@0:            NS_STYLE_DISPLAY_INLINE_GRID == aDisplay ||
michael@0:            NS_STYLE_DISPLAY_INLINE_XUL_GRID == aDisplay ||
michael@0:            NS_STYLE_DISPLAY_INLINE_STACK == aDisplay;
michael@0:   }
michael@0: 
michael@0:   bool IsInlineOutsideStyle() const {
michael@0:     return IsDisplayTypeInlineOutside(mDisplay);
michael@0:   }
michael@0: 
michael@0:   bool IsOriginalDisplayInlineOutsideStyle() const {
michael@0:     return IsDisplayTypeInlineOutside(mOriginalDisplay);
michael@0:   }
michael@0: 
michael@0:   bool IsInnerTableStyle() const {
michael@0:     return NS_STYLE_DISPLAY_TABLE_CAPTION == mDisplay ||
michael@0:            NS_STYLE_DISPLAY_TABLE_CELL == mDisplay ||
michael@0:            NS_STYLE_DISPLAY_TABLE_ROW == mDisplay ||
michael@0:            NS_STYLE_DISPLAY_TABLE_ROW_GROUP == mDisplay ||
michael@0:            NS_STYLE_DISPLAY_TABLE_HEADER_GROUP == mDisplay ||
michael@0:            NS_STYLE_DISPLAY_TABLE_FOOTER_GROUP == mDisplay ||
michael@0:            NS_STYLE_DISPLAY_TABLE_COLUMN == mDisplay ||
michael@0:            NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP == mDisplay;
michael@0:   }
michael@0: 
michael@0:   bool IsFloatingStyle() const {
michael@0:     return NS_STYLE_FLOAT_NONE != mFloats;
michael@0:   }
michael@0: 
michael@0:   bool IsAbsolutelyPositionedStyle() const {
michael@0:     return NS_STYLE_POSITION_ABSOLUTE == mPosition ||
michael@0:            NS_STYLE_POSITION_FIXED == mPosition;
michael@0:   }
michael@0: 
michael@0:   bool IsRelativelyPositionedStyle() const {
michael@0:     return NS_STYLE_POSITION_RELATIVE == mPosition ||
michael@0:            NS_STYLE_POSITION_STICKY == mPosition;
michael@0:   }
michael@0: 
michael@0:   bool IsScrollableOverflow() const {
michael@0:     // mOverflowX and mOverflowY always match when one of them is
michael@0:     // NS_STYLE_OVERFLOW_VISIBLE or NS_STYLE_OVERFLOW_CLIP.
michael@0:     return mOverflowX != NS_STYLE_OVERFLOW_VISIBLE &&
michael@0:            mOverflowX != NS_STYLE_OVERFLOW_CLIP;
michael@0:   }
michael@0: 
michael@0:   /* Returns whether the element has the -moz-transform property
michael@0:    * or a related property. */
michael@0:   bool HasTransformStyle() const {
michael@0:     return mSpecifiedTransform != nullptr ||
michael@0:            mTransformStyle == NS_STYLE_TRANSFORM_STYLE_PRESERVE_3D ||
michael@0:            (mWillChangeBitField & NS_STYLE_WILL_CHANGE_TRANSFORM);
michael@0:   }
michael@0: 
michael@0:   bool HasPerspectiveStyle() const {
michael@0:     return mChildPerspective.GetUnit() == eStyleUnit_Coord;
michael@0:   }
michael@0: 
michael@0:   bool BackfaceIsHidden() const {
michael@0:     return mBackfaceVisibility == NS_STYLE_BACKFACE_VISIBILITY_HIDDEN;
michael@0:   }
michael@0: 
michael@0:   // These are defined in nsStyleStructInlines.h.
michael@0: 
michael@0:   // The aContextFrame argument on each of these is the frame this
michael@0:   // style struct is for.  If the frame is for SVG text, the return
michael@0:   // value will be massaged to be something that makes sense for
michael@0:   // SVG text.
michael@0:   inline bool IsBlockInside(const nsIFrame* aContextFrame) const;
michael@0:   inline bool IsBlockOutside(const nsIFrame* aContextFrame) const;
michael@0:   inline bool IsInlineOutside(const nsIFrame* aContextFrame) const;
michael@0:   inline bool IsOriginalDisplayInlineOutside(const nsIFrame* aContextFrame) const;
michael@0:   inline uint8_t GetDisplay(const nsIFrame* aContextFrame) const;
michael@0:   inline bool IsFloating(const nsIFrame* aContextFrame) const;
michael@0:   inline bool IsPositioned(const nsIFrame* aContextFrame) const;
michael@0:   inline bool IsRelativelyPositioned(const nsIFrame* aContextFrame) const;
michael@0:   inline bool IsAbsolutelyPositioned(const nsIFrame* aContextFrame) const;
michael@0: 
michael@0:   /* Returns whether the element has the -moz-transform property
michael@0:    * or a related property, and supports CSS transforms. */
michael@0:   inline bool HasTransform(const nsIFrame* aContextFrame) const;
michael@0: };
michael@0: 
michael@0: struct nsStyleTable {
michael@0:   nsStyleTable(void);
michael@0:   nsStyleTable(const nsStyleTable& aOther);
michael@0:   ~nsStyleTable(void);
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
michael@0:     return aContext->AllocateFromShell(sz);
michael@0:   }
michael@0:   void Destroy(nsPresContext* aContext) {
michael@0:     this->~nsStyleTable();
michael@0:     aContext->FreeToShell(sizeof(nsStyleTable), this);
michael@0:   }
michael@0: 
michael@0:   nsChangeHint CalcDifference(const nsStyleTable& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     return NS_STYLE_HINT_FRAMECHANGE;
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference never returns nsChangeHint_NeedReflow or
michael@0:     // nsChangeHint_ClearAncestorIntrinsics as inherited hints.
michael@0:     return NS_CombineHint(nsChangeHint_NeedReflow,
michael@0:                           nsChangeHint_ClearAncestorIntrinsics);
michael@0:   }
michael@0: 
michael@0:   uint8_t       mLayoutStrategy;// [reset] see nsStyleConsts.h NS_STYLE_TABLE_LAYOUT_*
michael@0:   uint8_t       mFrame;         // [reset] see nsStyleConsts.h NS_STYLE_TABLE_FRAME_*
michael@0:   uint8_t       mRules;         // [reset] see nsStyleConsts.h NS_STYLE_TABLE_RULES_*
michael@0:   int32_t       mSpan;          // [reset] the number of columns spanned by a colgroup or col
michael@0: };
michael@0: 
michael@0: struct nsStyleTableBorder {
michael@0:   nsStyleTableBorder(nsPresContext* aContext);
michael@0:   nsStyleTableBorder(const nsStyleTableBorder& aOther);
michael@0:   ~nsStyleTableBorder(void);
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
michael@0:     return aContext->AllocateFromShell(sz);
michael@0:   }
michael@0:   void Destroy(nsPresContext* aContext) {
michael@0:     this->~nsStyleTableBorder();
michael@0:     aContext->FreeToShell(sizeof(nsStyleTableBorder), this);
michael@0:   }
michael@0: 
michael@0:   nsChangeHint CalcDifference(const nsStyleTableBorder& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     return NS_STYLE_HINT_FRAMECHANGE;
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference never returns nsChangeHint_NeedReflow or
michael@0:     // nsChangeHint_ClearAncestorIntrinsics as inherited hints.
michael@0:     return NS_CombineHint(nsChangeHint_NeedReflow,
michael@0:                           nsChangeHint_ClearAncestorIntrinsics);
michael@0:   }
michael@0: 
michael@0:   nscoord       mBorderSpacingX;// [inherited]
michael@0:   nscoord       mBorderSpacingY;// [inherited]
michael@0:   uint8_t       mBorderCollapse;// [inherited]
michael@0:   uint8_t       mCaptionSide;   // [inherited]
michael@0:   uint8_t       mEmptyCells;    // [inherited]
michael@0: };
michael@0: 
michael@0: enum nsStyleContentType {
michael@0:   eStyleContentType_String        = 1,
michael@0:   eStyleContentType_Image         = 10,
michael@0:   eStyleContentType_Attr          = 20,
michael@0:   eStyleContentType_Counter       = 30,
michael@0:   eStyleContentType_Counters      = 31,
michael@0:   eStyleContentType_OpenQuote     = 40,
michael@0:   eStyleContentType_CloseQuote    = 41,
michael@0:   eStyleContentType_NoOpenQuote   = 42,
michael@0:   eStyleContentType_NoCloseQuote  = 43,
michael@0:   eStyleContentType_AltContent    = 50,
michael@0:   eStyleContentType_Uninitialized
michael@0: };
michael@0: 
michael@0: struct nsStyleContentData {
michael@0:   nsStyleContentType  mType;
michael@0:   union {
michael@0:     char16_t *mString;
michael@0:     imgRequestProxy *mImage;
michael@0:     nsCSSValue::Array* mCounters;
michael@0:   } mContent;
michael@0: #ifdef DEBUG
michael@0:   bool mImageTracked;
michael@0: #endif
michael@0: 
michael@0:   nsStyleContentData()
michael@0:     : mType(eStyleContentType_Uninitialized)
michael@0: #ifdef DEBUG
michael@0:     , mImageTracked(false)
michael@0: #endif
michael@0:   { mContent.mString = nullptr; }
michael@0: 
michael@0:   ~nsStyleContentData();
michael@0:   nsStyleContentData& operator=(const nsStyleContentData& aOther);
michael@0:   bool operator==(const nsStyleContentData& aOther) const;
michael@0: 
michael@0:   bool operator!=(const nsStyleContentData& aOther) const {
michael@0:     return !(*this == aOther);
michael@0:   }
michael@0: 
michael@0:   void TrackImage(nsPresContext* aContext);
michael@0:   void UntrackImage(nsPresContext* aContext);
michael@0: 
michael@0:   void SetImage(imgRequestProxy* aRequest)
michael@0:   {
michael@0:     NS_ABORT_IF_FALSE(!mImageTracked,
michael@0:                       "Setting a new image without untracking the old one!");
michael@0:     NS_ABORT_IF_FALSE(mType == eStyleContentType_Image, "Wrong type!");
michael@0:     NS_IF_ADDREF(mContent.mImage = aRequest);
michael@0:   }
michael@0: private:
michael@0:   nsStyleContentData(const nsStyleContentData&); // not to be implemented
michael@0: };
michael@0: 
michael@0: struct nsStyleCounterData {
michael@0:   nsString  mCounter;
michael@0:   int32_t   mValue;
michael@0: };
michael@0: 
michael@0: 
michael@0: #define DELETE_ARRAY_IF(array)  if (array) { delete[] array; array = nullptr; }
michael@0: 
michael@0: struct nsStyleQuotes {
michael@0:   nsStyleQuotes();
michael@0:   nsStyleQuotes(const nsStyleQuotes& aQuotes);
michael@0:   ~nsStyleQuotes();
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
michael@0:     return aContext->AllocateFromShell(sz);
michael@0:   }
michael@0:   void Destroy(nsPresContext* aContext) {
michael@0:     this->~nsStyleQuotes();
michael@0:     aContext->FreeToShell(sizeof(nsStyleQuotes), this);
michael@0:   }
michael@0: 
michael@0:   void SetInitial();
michael@0:   void CopyFrom(const nsStyleQuotes& aSource);
michael@0: 
michael@0:   nsChangeHint CalcDifference(const nsStyleQuotes& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     return NS_STYLE_HINT_FRAMECHANGE;
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference never returns nsChangeHint_NeedReflow or
michael@0:     // nsChangeHint_ClearAncestorIntrinsics as inherited hints.
michael@0:     return NS_CombineHint(nsChangeHint_NeedReflow,
michael@0:                           nsChangeHint_ClearAncestorIntrinsics);
michael@0:   }
michael@0: 
michael@0:   uint32_t  QuotesCount(void) const { return mQuotesCount; } // [inherited]
michael@0: 
michael@0:   const nsString* OpenQuoteAt(uint32_t aIndex) const
michael@0:   {
michael@0:     NS_ASSERTION(aIndex < mQuotesCount, "out of range");
michael@0:     return mQuotes + (aIndex * 2);
michael@0:   }
michael@0:   const nsString* CloseQuoteAt(uint32_t aIndex) const
michael@0:   {
michael@0:     NS_ASSERTION(aIndex < mQuotesCount, "out of range");
michael@0:     return mQuotes + (aIndex * 2 + 1);
michael@0:   }
michael@0:   nsresult  GetQuotesAt(uint32_t aIndex, nsString& aOpen, nsString& aClose) const {
michael@0:     if (aIndex < mQuotesCount) {
michael@0:       aIndex *= 2;
michael@0:       aOpen = mQuotes[aIndex];
michael@0:       aClose = mQuotes[++aIndex];
michael@0:       return NS_OK;
michael@0:     }
michael@0:     return NS_ERROR_ILLEGAL_VALUE;
michael@0:   }
michael@0: 
michael@0:   nsresult  AllocateQuotes(uint32_t aCount) {
michael@0:     if (aCount != mQuotesCount) {
michael@0:       DELETE_ARRAY_IF(mQuotes);
michael@0:       if (aCount) {
michael@0:         mQuotes = new nsString[aCount * 2];
michael@0:         if (! mQuotes) {
michael@0:           mQuotesCount = 0;
michael@0:           return NS_ERROR_OUT_OF_MEMORY;
michael@0:         }
michael@0:       }
michael@0:       mQuotesCount = aCount;
michael@0:     }
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   nsresult  SetQuotesAt(uint32_t aIndex, const nsString& aOpen, const nsString& aClose) {
michael@0:     if (aIndex < mQuotesCount) {
michael@0:       aIndex *= 2;
michael@0:       mQuotes[aIndex] = aOpen;
michael@0:       mQuotes[++aIndex] = aClose;
michael@0:       return NS_OK;
michael@0:     }
michael@0:     return NS_ERROR_ILLEGAL_VALUE;
michael@0:   }
michael@0: 
michael@0: protected:
michael@0:   uint32_t            mQuotesCount;
michael@0:   nsString*           mQuotes;
michael@0: };
michael@0: 
michael@0: struct nsStyleContent {
michael@0:   nsStyleContent(void);
michael@0:   nsStyleContent(const nsStyleContent& aContent);
michael@0:   ~nsStyleContent(void);
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
michael@0:     return aContext->AllocateFromShell(sz);
michael@0:   }
michael@0:   void Destroy(nsPresContext* aContext);
michael@0: 
michael@0:   nsChangeHint CalcDifference(const nsStyleContent& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     return NS_STYLE_HINT_FRAMECHANGE;
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference never returns nsChangeHint_NeedReflow or
michael@0:     // nsChangeHint_ClearAncestorIntrinsics as inherited hints.
michael@0:     return NS_CombineHint(nsChangeHint_NeedReflow,
michael@0:                           nsChangeHint_ClearAncestorIntrinsics);
michael@0:   }
michael@0: 
michael@0:   uint32_t  ContentCount(void) const  { return mContentCount; } // [reset]
michael@0: 
michael@0:   const nsStyleContentData& ContentAt(uint32_t aIndex) const {
michael@0:     NS_ASSERTION(aIndex < mContentCount, "out of range");
michael@0:     return mContents[aIndex];
michael@0:   }
michael@0: 
michael@0:   nsStyleContentData& ContentAt(uint32_t aIndex) {
michael@0:     NS_ASSERTION(aIndex < mContentCount, "out of range");
michael@0:     return mContents[aIndex];
michael@0:   }
michael@0: 
michael@0:   nsresult AllocateContents(uint32_t aCount);
michael@0: 
michael@0:   uint32_t  CounterIncrementCount(void) const { return mIncrementCount; }  // [reset]
michael@0:   const nsStyleCounterData* GetCounterIncrementAt(uint32_t aIndex) const {
michael@0:     NS_ASSERTION(aIndex < mIncrementCount, "out of range");
michael@0:     return &mIncrements[aIndex];
michael@0:   }
michael@0: 
michael@0:   nsresult  AllocateCounterIncrements(uint32_t aCount) {
michael@0:     if (aCount != mIncrementCount) {
michael@0:       DELETE_ARRAY_IF(mIncrements);
michael@0:       if (aCount) {
michael@0:         mIncrements = new nsStyleCounterData[aCount];
michael@0:         if (! mIncrements) {
michael@0:           mIncrementCount = 0;
michael@0:           return NS_ERROR_OUT_OF_MEMORY;
michael@0:         }
michael@0:       }
michael@0:       mIncrementCount = aCount;
michael@0:     }
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   nsresult  SetCounterIncrementAt(uint32_t aIndex, const nsString& aCounter, int32_t aIncrement) {
michael@0:     if (aIndex < mIncrementCount) {
michael@0:       mIncrements[aIndex].mCounter = aCounter;
michael@0:       mIncrements[aIndex].mValue = aIncrement;
michael@0:       return NS_OK;
michael@0:     }
michael@0:     return NS_ERROR_ILLEGAL_VALUE;
michael@0:   }
michael@0: 
michael@0:   uint32_t  CounterResetCount(void) const { return mResetCount; }  // [reset]
michael@0:   const nsStyleCounterData* GetCounterResetAt(uint32_t aIndex) const {
michael@0:     NS_ASSERTION(aIndex < mResetCount, "out of range");
michael@0:     return &mResets[aIndex];
michael@0:   }
michael@0: 
michael@0:   nsresult  AllocateCounterResets(uint32_t aCount) {
michael@0:     if (aCount != mResetCount) {
michael@0:       DELETE_ARRAY_IF(mResets);
michael@0:       if (aCount) {
michael@0:         mResets = new nsStyleCounterData[aCount];
michael@0:         if (! mResets) {
michael@0:           mResetCount = 0;
michael@0:           return NS_ERROR_OUT_OF_MEMORY;
michael@0:         }
michael@0:       }
michael@0:       mResetCount = aCount;
michael@0:     }
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   nsresult  SetCounterResetAt(uint32_t aIndex, const nsString& aCounter, int32_t aValue) {
michael@0:     if (aIndex < mResetCount) {
michael@0:       mResets[aIndex].mCounter = aCounter;
michael@0:       mResets[aIndex].mValue = aValue;
michael@0:       return NS_OK;
michael@0:     }
michael@0:     return NS_ERROR_ILLEGAL_VALUE;
michael@0:   }
michael@0: 
michael@0:   nsStyleCoord  mMarkerOffset;  // [reset] coord, auto
michael@0: 
michael@0: protected:
michael@0:   nsStyleContentData* mContents;
michael@0:   nsStyleCounterData* mIncrements;
michael@0:   nsStyleCounterData* mResets;
michael@0: 
michael@0:   uint32_t            mContentCount;
michael@0:   uint32_t            mIncrementCount;
michael@0:   uint32_t            mResetCount;
michael@0: };
michael@0: 
michael@0: struct nsStyleUIReset {
michael@0:   nsStyleUIReset(void);
michael@0:   nsStyleUIReset(const nsStyleUIReset& aOther);
michael@0:   ~nsStyleUIReset(void);
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
michael@0:     return aContext->AllocateFromShell(sz);
michael@0:   }
michael@0:   void Destroy(nsPresContext* aContext) {
michael@0:     this->~nsStyleUIReset();
michael@0:     aContext->FreeToShell(sizeof(nsStyleUIReset), this);
michael@0:   }
michael@0: 
michael@0:   nsChangeHint CalcDifference(const nsStyleUIReset& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     return NS_STYLE_HINT_FRAMECHANGE;
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference never returns nsChangeHint_NeedReflow or
michael@0:     // nsChangeHint_ClearAncestorIntrinsics as inherited hints.
michael@0:     return NS_CombineHint(nsChangeHint_NeedReflow,
michael@0:                           nsChangeHint_ClearAncestorIntrinsics);
michael@0:   }
michael@0: 
michael@0:   uint8_t   mUserSelect;      // [reset] (selection-style)
michael@0:   uint8_t   mForceBrokenImageIcon; // [reset]  (0 if not forcing, otherwise forcing)
michael@0:   uint8_t   mIMEMode;         // [reset]
michael@0:   uint8_t   mWindowShadow;    // [reset]
michael@0: };
michael@0: 
michael@0: struct nsCursorImage {
michael@0:   bool mHaveHotspot;
michael@0:   float mHotspotX, mHotspotY;
michael@0: 
michael@0:   nsCursorImage();
michael@0:   nsCursorImage(const nsCursorImage& aOther);
michael@0:   ~nsCursorImage();
michael@0: 
michael@0:   nsCursorImage& operator=(const nsCursorImage& aOther);
michael@0:   /*
michael@0:    * We hide mImage and force access through the getter and setter so that we
michael@0:    * can lock the images we use. Cursor images are likely to be small, so we
michael@0:    * don't care about discarding them. See bug 512260.
michael@0:    * */
michael@0:   void SetImage(imgIRequest *aImage) {
michael@0:     if (mImage)
michael@0:       mImage->UnlockImage();
michael@0:     mImage = aImage;
michael@0:     if (mImage)
michael@0:       mImage->LockImage();
michael@0:   }
michael@0:   imgIRequest* GetImage() const {
michael@0:     return mImage;
michael@0:   }
michael@0: 
michael@0: private:
michael@0:   nsCOMPtr<imgIRequest> mImage;
michael@0: };
michael@0: 
michael@0: struct nsStyleUserInterface {
michael@0:   nsStyleUserInterface(void);
michael@0:   nsStyleUserInterface(const nsStyleUserInterface& aOther);
michael@0:   ~nsStyleUserInterface(void);
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
michael@0:     return aContext->AllocateFromShell(sz);
michael@0:   }
michael@0:   void Destroy(nsPresContext* aContext) {
michael@0:     this->~nsStyleUserInterface();
michael@0:     aContext->FreeToShell(sizeof(nsStyleUserInterface), this);
michael@0:   }
michael@0: 
michael@0:   nsChangeHint CalcDifference(const nsStyleUserInterface& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     return nsChangeHint(nsChangeHint_UpdateCursor | NS_STYLE_HINT_FRAMECHANGE);
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference never returns nsChangeHint_NeedReflow or
michael@0:     // nsChangeHint_ClearAncestorIntrinsics as inherited hints.
michael@0:     return NS_CombineHint(nsChangeHint_NeedReflow,
michael@0:                           nsChangeHint_ClearAncestorIntrinsics);
michael@0:   }
michael@0: 
michael@0:   uint8_t   mUserInput;       // [inherited]
michael@0:   uint8_t   mUserModify;      // [inherited] (modify-content)
michael@0:   uint8_t   mUserFocus;       // [inherited] (auto-select)
michael@0: 
michael@0:   uint8_t   mCursor;          // [inherited] See nsStyleConsts.h
michael@0: 
michael@0:   uint32_t mCursorArrayLength;
michael@0:   nsCursorImage *mCursorArray;// [inherited] The specified URL values
michael@0:                               //   and coordinates.  Takes precedence over
michael@0:                               //   mCursor.  Zero-length array is represented
michael@0:                               //   by null pointer.
michael@0: 
michael@0:   // Does not free mCursorArray; the caller is responsible for calling
michael@0:   // |delete [] mCursorArray| first if it is needed.
michael@0:   void CopyCursorArrayFrom(const nsStyleUserInterface& aSource);
michael@0: };
michael@0: 
michael@0: struct nsStyleXUL {
michael@0:   nsStyleXUL();
michael@0:   nsStyleXUL(const nsStyleXUL& aSource);
michael@0:   ~nsStyleXUL();
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
michael@0:     return aContext->AllocateFromShell(sz);
michael@0:   }
michael@0:   void Destroy(nsPresContext* aContext) {
michael@0:     this->~nsStyleXUL();
michael@0:     aContext->FreeToShell(sizeof(nsStyleXUL), this);
michael@0:   }
michael@0: 
michael@0:   nsChangeHint CalcDifference(const nsStyleXUL& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     return NS_STYLE_HINT_FRAMECHANGE;
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference never returns nsChangeHint_NeedReflow or
michael@0:     // nsChangeHint_ClearAncestorIntrinsics as inherited hints.
michael@0:     return NS_CombineHint(nsChangeHint_NeedReflow,
michael@0:                           nsChangeHint_ClearAncestorIntrinsics);
michael@0:   }
michael@0: 
michael@0:   float         mBoxFlex;               // [reset] see nsStyleConsts.h
michael@0:   uint32_t      mBoxOrdinal;            // [reset] see nsStyleConsts.h
michael@0:   uint8_t       mBoxAlign;              // [reset] see nsStyleConsts.h
michael@0:   uint8_t       mBoxDirection;          // [reset] see nsStyleConsts.h
michael@0:   uint8_t       mBoxOrient;             // [reset] see nsStyleConsts.h
michael@0:   uint8_t       mBoxPack;               // [reset] see nsStyleConsts.h
michael@0:   bool          mStretchStack;          // [reset] see nsStyleConsts.h
michael@0: };
michael@0: 
michael@0: struct nsStyleColumn {
michael@0:   nsStyleColumn(nsPresContext* aPresContext);
michael@0:   nsStyleColumn(const nsStyleColumn& aSource);
michael@0:   ~nsStyleColumn();
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
michael@0:     return aContext->AllocateFromShell(sz);
michael@0:   }
michael@0:   void Destroy(nsPresContext* aContext) {
michael@0:     this->~nsStyleColumn();
michael@0:     aContext->FreeToShell(sizeof(nsStyleColumn), this);
michael@0:   }
michael@0: 
michael@0:   nsChangeHint CalcDifference(const nsStyleColumn& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     return NS_STYLE_HINT_FRAMECHANGE;
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference never returns nsChangeHint_NeedReflow or
michael@0:     // nsChangeHint_ClearAncestorIntrinsics as inherited hints.
michael@0:     return NS_CombineHint(nsChangeHint_NeedReflow,
michael@0:                           nsChangeHint_ClearAncestorIntrinsics);
michael@0:   }
michael@0: 
michael@0:   /**
michael@0:    * This is the maximum number of columns we can process. It's used in both
michael@0:    * nsColumnSetFrame and nsRuleNode.
michael@0:    */
michael@0:   static const uint32_t kMaxColumnCount;
michael@0: 
michael@0:   uint32_t     mColumnCount; // [reset] see nsStyleConsts.h
michael@0:   nsStyleCoord mColumnWidth; // [reset] coord, auto
michael@0:   nsStyleCoord mColumnGap;   // [reset] coord, normal
michael@0: 
michael@0:   nscolor      mColumnRuleColor;  // [reset]
michael@0:   uint8_t      mColumnRuleStyle;  // [reset]
michael@0:   uint8_t      mColumnFill;  // [reset] see nsStyleConsts.h
michael@0: 
michael@0:   // See https://bugzilla.mozilla.org/show_bug.cgi?id=271586#c43 for why
michael@0:   // this is hard to replace with 'currentColor'.
michael@0:   bool mColumnRuleColorIsForeground;
michael@0: 
michael@0:   void SetColumnRuleWidth(nscoord aWidth) {
michael@0:     mColumnRuleWidth = NS_ROUND_BORDER_TO_PIXELS(aWidth, mTwipsPerPixel);
michael@0:   }
michael@0: 
michael@0:   nscoord GetComputedColumnRuleWidth() const {
michael@0:     return (IsVisibleBorderStyle(mColumnRuleStyle) ? mColumnRuleWidth : 0);
michael@0:   }
michael@0: 
michael@0: protected:
michael@0:   nscoord mColumnRuleWidth;  // [reset] coord
michael@0:   nscoord mTwipsPerPixel;
michael@0: };
michael@0: 
michael@0: enum nsStyleSVGPaintType {
michael@0:   eStyleSVGPaintType_None = 1,
michael@0:   eStyleSVGPaintType_Color,
michael@0:   eStyleSVGPaintType_Server,
michael@0:   eStyleSVGPaintType_ContextFill,
michael@0:   eStyleSVGPaintType_ContextStroke
michael@0: };
michael@0: 
michael@0: enum nsStyleSVGOpacitySource {
michael@0:   eStyleSVGOpacitySource_Normal,
michael@0:   eStyleSVGOpacitySource_ContextFillOpacity,
michael@0:   eStyleSVGOpacitySource_ContextStrokeOpacity
michael@0: };
michael@0: 
michael@0: struct nsStyleSVGPaint
michael@0: {
michael@0:   union {
michael@0:     nscolor mColor;
michael@0:     nsIURI *mPaintServer;
michael@0:   } mPaint;
michael@0:   nsStyleSVGPaintType mType;
michael@0:   nscolor mFallbackColor;
michael@0: 
michael@0:   nsStyleSVGPaint() : mType(nsStyleSVGPaintType(0)) { mPaint.mPaintServer = nullptr; }
michael@0:   ~nsStyleSVGPaint();
michael@0:   void SetType(nsStyleSVGPaintType aType);
michael@0:   nsStyleSVGPaint& operator=(const nsStyleSVGPaint& aOther);
michael@0:   bool operator==(const nsStyleSVGPaint& aOther) const;
michael@0: 
michael@0:   bool operator!=(const nsStyleSVGPaint& aOther) const {
michael@0:     return !(*this == aOther);
michael@0:   }
michael@0: };
michael@0: 
michael@0: struct nsStyleSVG {
michael@0:   nsStyleSVG();
michael@0:   nsStyleSVG(const nsStyleSVG& aSource);
michael@0:   ~nsStyleSVG();
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
michael@0:     return aContext->AllocateFromShell(sz);
michael@0:   }
michael@0:   void Destroy(nsPresContext* aContext) {
michael@0:     this->~nsStyleSVG();
michael@0:     aContext->FreeToShell(sizeof(nsStyleSVG), this);
michael@0:   }
michael@0: 
michael@0:   nsChangeHint CalcDifference(const nsStyleSVG& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     return NS_CombineHint(NS_CombineHint(nsChangeHint_UpdateEffects,
michael@0:              NS_CombineHint(nsChangeHint_NeedReflow, nsChangeHint_NeedDirtyReflow)), // XXX remove nsChangeHint_NeedDirtyReflow: bug 876085
michael@0:                                          nsChangeHint_RepaintFrame);
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference never returns nsChangeHint_NeedReflow as an inherited hint
michael@0:     // and never returns nsChangeHint_ClearAncestorIntrinsics at all.
michael@0:     return nsChangeHint_NeedReflow;
michael@0:   }
michael@0: 
michael@0:   nsStyleSVGPaint  mFill;             // [inherited]
michael@0:   nsStyleSVGPaint  mStroke;           // [inherited]
michael@0:   nsCOMPtr<nsIURI> mMarkerEnd;        // [inherited]
michael@0:   nsCOMPtr<nsIURI> mMarkerMid;        // [inherited]
michael@0:   nsCOMPtr<nsIURI> mMarkerStart;      // [inherited]
michael@0:   nsStyleCoord    *mStrokeDasharray;  // [inherited] coord, percent, factor
michael@0: 
michael@0:   nsStyleCoord     mStrokeDashoffset; // [inherited] coord, percent, factor
michael@0:   nsStyleCoord     mStrokeWidth;      // [inherited] coord, percent, factor
michael@0: 
michael@0:   float            mFillOpacity;      // [inherited]
michael@0:   float            mStrokeMiterlimit; // [inherited]
michael@0:   float            mStrokeOpacity;    // [inherited]
michael@0: 
michael@0:   uint32_t         mStrokeDasharrayLength;
michael@0:   uint8_t          mClipRule;         // [inherited]
michael@0:   uint8_t          mColorInterpolation; // [inherited] see nsStyleConsts.h
michael@0:   uint8_t          mColorInterpolationFilters; // [inherited] see nsStyleConsts.h
michael@0:   uint8_t          mFillRule;         // [inherited] see nsStyleConsts.h
michael@0:   uint8_t          mImageRendering;   // [inherited] see nsStyleConsts.h
michael@0:   uint8_t          mPaintOrder;       // [inherited] see nsStyleConsts.h
michael@0:   uint8_t          mShapeRendering;   // [inherited] see nsStyleConsts.h
michael@0:   uint8_t          mStrokeLinecap;    // [inherited] see nsStyleConsts.h
michael@0:   uint8_t          mStrokeLinejoin;   // [inherited] see nsStyleConsts.h
michael@0:   uint8_t          mTextAnchor;       // [inherited] see nsStyleConsts.h
michael@0:   uint8_t          mTextRendering;    // [inherited] see nsStyleConsts.h
michael@0: 
michael@0:   // In SVG glyphs, whether we inherit fill or stroke opacity from the outer
michael@0:   // text object.
michael@0:   // Use 3 bits to avoid signedness problems in MSVC.
michael@0:   nsStyleSVGOpacitySource mFillOpacitySource    : 3;
michael@0:   nsStyleSVGOpacitySource mStrokeOpacitySource  : 3;
michael@0: 
michael@0:   // SVG glyph outer object inheritance for other properties
michael@0:   bool mStrokeDasharrayFromObject   : 1;
michael@0:   bool mStrokeDashoffsetFromObject  : 1;
michael@0:   bool mStrokeWidthFromObject       : 1;
michael@0: 
michael@0:   bool HasMarker() const {
michael@0:     return mMarkerStart || mMarkerMid || mMarkerEnd;
michael@0:   }
michael@0: 
michael@0:   /**
michael@0:    * Returns true if the stroke is not "none" and the stroke-opacity is greater
michael@0:    * than zero. This ignores stroke-widths as that depends on the context.
michael@0:    */
michael@0:   bool HasStroke() const {
michael@0:     return mStroke.mType != eStyleSVGPaintType_None && mStrokeOpacity > 0;
michael@0:   }
michael@0: 
michael@0:   /**
michael@0:    * Returns true if the fill is not "none" and the fill-opacity is greater
michael@0:    * than zero.
michael@0:    */
michael@0:   bool HasFill() const {
michael@0:     return mFill.mType != eStyleSVGPaintType_None && mFillOpacity > 0;
michael@0:   }
michael@0: };
michael@0: 
michael@0: struct nsStyleFilter {
michael@0:   nsStyleFilter();
michael@0:   nsStyleFilter(const nsStyleFilter& aSource);
michael@0:   ~nsStyleFilter();
michael@0: 
michael@0:   nsStyleFilter& operator=(const nsStyleFilter& aOther);
michael@0: 
michael@0:   bool operator==(const nsStyleFilter& aOther) const;
michael@0: 
michael@0:   int32_t GetType() const {
michael@0:     return mType;
michael@0:   }
michael@0: 
michael@0:   const nsStyleCoord& GetFilterParameter() const {
michael@0:     NS_ASSERTION(mType != NS_STYLE_FILTER_DROP_SHADOW &&
michael@0:                  mType != NS_STYLE_FILTER_URL &&
michael@0:                  mType != NS_STYLE_FILTER_NONE, "wrong filter type");
michael@0:     return mFilterParameter;
michael@0:   }
michael@0:   void SetFilterParameter(const nsStyleCoord& aFilterParameter,
michael@0:                           int32_t aType);
michael@0: 
michael@0:   nsIURI* GetURL() const {
michael@0:     NS_ASSERTION(mType == NS_STYLE_FILTER_URL, "wrong filter type");
michael@0:     return mURL;
michael@0:   }
michael@0:   void SetURL(nsIURI* aURL);
michael@0: 
michael@0:   nsCSSShadowArray* GetDropShadow() const {
michael@0:     NS_ASSERTION(mType == NS_STYLE_FILTER_DROP_SHADOW, "wrong filter type");
michael@0:     return mDropShadow;
michael@0:   }
michael@0:   void SetDropShadow(nsCSSShadowArray* aDropShadow);
michael@0: 
michael@0: private:
michael@0:   void ReleaseRef();
michael@0: 
michael@0:   int32_t mType; // see NS_STYLE_FILTER_* constants in nsStyleConsts.h
michael@0:   nsStyleCoord mFilterParameter; // coord, percent, factor, angle
michael@0:   union {
michael@0:     nsIURI* mURL;
michael@0:     nsCSSShadowArray* mDropShadow;
michael@0:   };
michael@0: };
michael@0: 
michael@0: template<>
michael@0: struct nsTArray_CopyChooser<nsStyleFilter> {
michael@0:   typedef nsTArray_CopyWithConstructors<nsStyleFilter> Type;
michael@0: };
michael@0: 
michael@0: struct nsStyleSVGReset {
michael@0:   nsStyleSVGReset();
michael@0:   nsStyleSVGReset(const nsStyleSVGReset& aSource);
michael@0:   ~nsStyleSVGReset();
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
michael@0:     return aContext->AllocateFromShell(sz);
michael@0:   }
michael@0:   void Destroy(nsPresContext* aContext) {
michael@0:     this->~nsStyleSVGReset();
michael@0:     aContext->FreeToShell(sizeof(nsStyleSVGReset), this);
michael@0:   }
michael@0: 
michael@0:   nsChangeHint CalcDifference(const nsStyleSVGReset& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     return NS_CombineHint(nsChangeHint_UpdateEffects,
michael@0:             NS_CombineHint(nsChangeHint_UpdateOverflow, NS_STYLE_HINT_REFLOW));
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference never returns nsChangeHint_NeedReflow or
michael@0:     // nsChangeHint_ClearAncestorIntrinsics as inherited hints.
michael@0:     return NS_CombineHint(nsChangeHint_NeedReflow,
michael@0:                           nsChangeHint_ClearAncestorIntrinsics);
michael@0:   }
michael@0: 
michael@0:   bool HasFilters() const {
michael@0:     return mFilters.Length() > 0;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIURI> mClipPath;         // [reset]
michael@0:   nsTArray<nsStyleFilter> mFilters;   // [reset]
michael@0:   nsCOMPtr<nsIURI> mMask;             // [reset]
michael@0:   nscolor          mStopColor;        // [reset]
michael@0:   nscolor          mFloodColor;       // [reset]
michael@0:   nscolor          mLightingColor;    // [reset]
michael@0: 
michael@0:   float            mStopOpacity;      // [reset]
michael@0:   float            mFloodOpacity;     // [reset]
michael@0: 
michael@0:   uint8_t          mDominantBaseline; // [reset] see nsStyleConsts.h
michael@0:   uint8_t          mVectorEffect;     // [reset] see nsStyleConsts.h
michael@0:   uint8_t          mMaskType;         // [reset] see nsStyleConsts.h
michael@0: };
michael@0: 
michael@0: struct nsStyleVariables {
michael@0:   nsStyleVariables();
michael@0:   nsStyleVariables(const nsStyleVariables& aSource);
michael@0:   ~nsStyleVariables();
michael@0: 
michael@0:   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
michael@0:     return aContext->AllocateFromShell(sz);
michael@0:   }
michael@0:   void Destroy(nsPresContext* aContext) {
michael@0:     this->~nsStyleVariables();
michael@0:     aContext->FreeToShell(sizeof(nsStyleVariables), this);
michael@0:   }
michael@0: 
michael@0:   nsChangeHint CalcDifference(const nsStyleVariables& aOther) const;
michael@0:   static nsChangeHint MaxDifference() {
michael@0:     return nsChangeHint(0);
michael@0:   }
michael@0:   static nsChangeHint MaxDifferenceNeverInherited() {
michael@0:     // CalcDifference never returns nsChangeHint_NeedReflow or
michael@0:     // nsChangeHint_ClearAncestorIntrinsics at all.
michael@0:     return nsChangeHint(0);
michael@0:   }
michael@0: 
michael@0:   mozilla::CSSVariableValues mVariables;
michael@0: };
michael@0: 
michael@0: #endif /* nsStyleStruct_h___ */