tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

nsDisplayListInvalidation.h (7280B)

      1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
      2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
      3 /* This Source Code Form is subject to the terms of the Mozilla Public
      4 * License, v. 2.0. If a copy of the MPL was not distributed with this
      5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      6 
      7 #ifndef NSDISPLAYLISTINVALIDATION_H_
      8 #define NSDISPLAYLISTINVALIDATION_H_
      9 
     10 #include "ImgDrawResult.h"
     11 #include "gfxRect.h"
     12 #include "mozilla/gfx/MatrixFwd.h"
     13 #include "mozilla/layers/WebRenderUserData.h"
     14 #include "nsColor.h"
     15 #include "nsRect.h"
     16 
     17 namespace mozilla {
     18 class nsDisplayBackgroundImage;
     19 class nsCharClipDisplayItem;
     20 class nsDisplayItem;
     21 class nsDisplayListBuilder;
     22 class nsDisplayTableItem;
     23 class nsDisplayThemedBackground;
     24 class nsDisplayEffectsBase;
     25 class nsDisplayMasksAndClipPaths;
     26 class nsDisplayFilters;
     27 
     28 namespace gfx {
     29 struct sRGBColor;
     30 }
     31 
     32 /**
     33 * This stores the geometry of an nsDisplayItem, and the area
     34 * that will be affected when painting the item.
     35 *
     36 * It is used to retain information about display items so they
     37 * can be compared against new display items in the next paint.
     38 */
     39 class nsDisplayItemGeometry {
     40 public:
     41  nsDisplayItemGeometry(nsDisplayItem* aItem, nsDisplayListBuilder* aBuilder);
     42  virtual ~nsDisplayItemGeometry();
     43 
     44  /**
     45   * Compute the area required to be invalidated if this
     46   * display item is removed.
     47   */
     48  const nsRect& ComputeInvalidationRegion() { return mBounds; }
     49 
     50  /**
     51   * Shifts all retained areas of the nsDisplayItemGeometry by the given offset.
     52   *
     53   * This is used to compensate for scrolling, since the destination buffer
     54   * can scroll without requiring a full repaint.
     55   *
     56   * @param aOffset Offset to shift by.
     57   */
     58  virtual void MoveBy(const nsPoint& aOffset) { mBounds.MoveBy(aOffset); }
     59 
     60  /**
     61   * Bounds of the display item
     62   */
     63  nsRect mBounds;
     64 };
     65 
     66 /**
     67 * A default geometry implementation, used by nsDisplayItem. Retains
     68 * and compares the bounds, and border rect.
     69 *
     70 * This should be sufficient for the majority of display items.
     71 */
     72 class nsDisplayItemGenericGeometry : public nsDisplayItemGeometry {
     73 public:
     74  nsDisplayItemGenericGeometry(nsDisplayItem* aItem,
     75                               nsDisplayListBuilder* aBuilder);
     76 
     77  void MoveBy(const nsPoint& aOffset) override;
     78 
     79  nsRect mBorderRect;
     80 };
     81 
     82 bool ShouldSyncDecodeImages(nsDisplayListBuilder* aBuilder);
     83 
     84 nsDisplayItemGeometry* GetPreviousGeometry(nsDisplayItem*);
     85 
     86 class nsDisplayItemBoundsGeometry : public nsDisplayItemGeometry {
     87 public:
     88  nsDisplayItemBoundsGeometry(nsDisplayItem* aItem,
     89                              nsDisplayListBuilder* aBuilder);
     90 
     91  bool mHasRoundedCorners;
     92 };
     93 
     94 class nsDisplayBorderGeometry : public nsDisplayItemGeometry {
     95 public:
     96  nsDisplayBorderGeometry(nsDisplayItem* aItem, nsDisplayListBuilder* aBuilder);
     97 };
     98 
     99 class nsDisplayBackgroundGeometry : public nsDisplayItemGeometry {
    100 public:
    101  nsDisplayBackgroundGeometry(nsDisplayBackgroundImage* aItem,
    102                              nsDisplayListBuilder* aBuilder);
    103 
    104  void MoveBy(const nsPoint& aOffset) override;
    105 
    106  nsRect mPositioningArea;
    107  nsRect mDestRect;
    108 };
    109 
    110 class nsDisplayThemedBackgroundGeometry : public nsDisplayItemGeometry {
    111 public:
    112  nsDisplayThemedBackgroundGeometry(nsDisplayThemedBackground* aItem,
    113                                    nsDisplayListBuilder* aBuilder);
    114 
    115  void MoveBy(const nsPoint& aOffset) override;
    116 
    117  nsRect mPositioningArea;
    118  bool mWindowIsActive;
    119 };
    120 
    121 class nsDisplayTreeBodyGeometry : public nsDisplayItemGenericGeometry {
    122 public:
    123  nsDisplayTreeBodyGeometry(nsDisplayItem* aItem,
    124                            nsDisplayListBuilder* aBuilder,
    125                            bool aWindowIsActive)
    126      : nsDisplayItemGenericGeometry(aItem, aBuilder),
    127        mWindowIsActive(aWindowIsActive) {}
    128 
    129  bool mWindowIsActive = false;
    130 };
    131 
    132 class nsDisplayBoxShadowInnerGeometry : public nsDisplayItemGeometry {
    133 public:
    134  nsDisplayBoxShadowInnerGeometry(nsDisplayItem* aItem,
    135                                  nsDisplayListBuilder* aBuilder);
    136 
    137  void MoveBy(const nsPoint& aOffset) override;
    138 
    139  nsRect mPaddingRect;
    140 };
    141 
    142 class nsDisplaySolidColorGeometry : public nsDisplayItemBoundsGeometry {
    143 public:
    144  nsDisplaySolidColorGeometry(nsDisplayItem* aItem,
    145                              nsDisplayListBuilder* aBuilder, nscolor aColor)
    146      : nsDisplayItemBoundsGeometry(aItem, aBuilder), mColor(aColor) {}
    147 
    148  nscolor mColor;
    149 };
    150 
    151 class nsDisplaySolidColorRegionGeometry : public nsDisplayItemBoundsGeometry {
    152 public:
    153  nsDisplaySolidColorRegionGeometry(nsDisplayItem* aItem,
    154                                    nsDisplayListBuilder* aBuilder,
    155                                    const nsRegion& aRegion,
    156                                    mozilla::gfx::sRGBColor aColor)
    157      : nsDisplayItemBoundsGeometry(aItem, aBuilder),
    158        mRegion(aRegion),
    159        mColor(aColor) {}
    160 
    161  void MoveBy(const nsPoint& aOffset) override;
    162 
    163  nsRegion mRegion;
    164  mozilla::gfx::sRGBColor mColor;
    165 };
    166 
    167 class nsDisplaySVGEffectGeometry : public nsDisplayItemGeometry {
    168 public:
    169  nsDisplaySVGEffectGeometry(nsDisplayEffectsBase* aItem,
    170                             nsDisplayListBuilder* aBuilder);
    171 
    172  void MoveBy(const nsPoint& aOffset) override;
    173 
    174  gfxRect mBBox;
    175  gfxPoint mUserSpaceOffset;
    176  nsPoint mFrameOffsetToReferenceFrame;
    177  bool mHandleOpacity;
    178 };
    179 
    180 class nsDisplayMasksAndClipPathsGeometry : public nsDisplaySVGEffectGeometry {
    181 public:
    182  nsDisplayMasksAndClipPathsGeometry(nsDisplayMasksAndClipPaths* aItem,
    183                                     nsDisplayListBuilder* aBuilder);
    184 
    185  nsTArray<nsRect> mDestRects;
    186 };
    187 
    188 class nsDisplayFiltersGeometry : public nsDisplaySVGEffectGeometry {
    189 public:
    190  nsDisplayFiltersGeometry(nsDisplayFilters* aItem,
    191                           nsDisplayListBuilder* aBuilder);
    192 };
    193 
    194 class nsDisplayTableItemGeometry : public nsDisplayItemGenericGeometry {
    195 public:
    196  nsDisplayTableItemGeometry(nsDisplayTableItem* aItem,
    197                             nsDisplayListBuilder* aBuilder,
    198                             const nsPoint& aFrameOffsetToViewport);
    199 
    200  nsPoint mFrameOffsetToViewport;
    201 };
    202 
    203 class nsDisplayOpacityGeometry : public nsDisplayItemGenericGeometry {
    204 public:
    205  nsDisplayOpacityGeometry(nsDisplayItem* aItem, nsDisplayListBuilder* aBuilder,
    206                           float aOpacity)
    207      : nsDisplayItemGenericGeometry(aItem, aBuilder), mOpacity(aOpacity) {}
    208 
    209  float mOpacity;
    210 };
    211 
    212 class nsDisplayTransformGeometry : public nsDisplayItemGeometry {
    213 public:
    214  nsDisplayTransformGeometry(nsDisplayItem* aItem,
    215                             nsDisplayListBuilder* aBuilder,
    216                             const mozilla::gfx::Matrix4x4Flagged& aTransform,
    217                             int32_t aAppUnitsPerDevPixel)
    218      : nsDisplayItemGeometry(aItem, aBuilder),
    219        mTransform(aTransform),
    220        mAppUnitsPerDevPixel(aAppUnitsPerDevPixel) {}
    221 
    222  void MoveBy(const nsPoint& aOffset) override {
    223    nsDisplayItemGeometry::MoveBy(aOffset);
    224    mTransform.PostTranslate(
    225        NSAppUnitsToFloatPixels(aOffset.x, mAppUnitsPerDevPixel),
    226        NSAppUnitsToFloatPixels(aOffset.y, mAppUnitsPerDevPixel), 0.0f);
    227  }
    228 
    229  mozilla::gfx::Matrix4x4Flagged mTransform;
    230  int32_t mAppUnitsPerDevPixel;
    231 };
    232 
    233 }  // namespace mozilla
    234 
    235 #endif /*NSDISPLAYLISTINVALIDATION_H_*/