layout/base/DisplayListClipState.h

   1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef DISPLAYLISTCLIPSTATE_H_
   7 #define DISPLAYLISTCLIPSTATE_H_
   8
   9 #include "DisplayItemClip.h"
  10
  11 #include "mozilla/DebugOnly.h"
  12
  13 class nsIFrame;
  14 class nsDisplayListBuilder;
  15
  16 namespace mozilla {
  17
  18 /**
  19  * All clip coordinates are in appunits relative to the reference frame
  20  * for the display item we're building.
  21  */
  22 class DisplayListClipState {
  23 public:
  24   DisplayListClipState()
  25     : mClipContentDescendants(nullptr)
  26     , mClipContainingBlockDescendants(nullptr)
  27     , mCurrentCombinedClip(nullptr)
  28   {}
  29
  30   /**
  31    * Returns intersection of mClipContainingBlockDescendants and
  32    * mClipContentDescendants, allocated on aBuilder's arena.
  33    */
  34   const DisplayItemClip* GetCurrentCombinedClip(nsDisplayListBuilder* aBuilder);
  35
  36   const DisplayItemClip* GetClipForContainingBlockDescendants() const
  37   {
  38     return mClipContainingBlockDescendants;
  39   }
  40   const DisplayItemClip* GetClipForContentDescendants() const
  41   {
  42     return mClipContentDescendants;
  43   }
  44
  45   class AutoSaveRestore;
  46   friend class AutoSaveRestore;
  47
  48   class AutoClipContainingBlockDescendantsToContentBox;
  49   friend class AutoClipContainingBlockDescendantsToContentBox;
  50
  51   class AutoClipMultiple;
  52   friend class AutoClipMultiple;
  53
  54   enum {
  55     ASSUME_DRAWING_RESTRICTED_TO_CONTENT_RECT = 0x01
  56   };
  57
  58 private:
  59   void SetClipForContainingBlockDescendants(const DisplayItemClip* aClip)
  60   {
  61     mClipContainingBlockDescendants = aClip;
  62     mCurrentCombinedClip = nullptr;
  63   }
  64
  65   void Clear()
  66   {
  67     mClipContentDescendants = nullptr;
  68     mClipContainingBlockDescendants = nullptr;
  69     mCurrentCombinedClip = nullptr;
  70   }
  71
  72   /**
  73    * Intersects the given clip rect (with optional aRadii) with the current
  74    * mClipContainingBlockDescendants and sets mClipContainingBlockDescendants to
  75    * the result, stored in aClipOnStack.
  76    */
  77   void ClipContainingBlockDescendants(const nsRect& aRect,
  78                                       const nscoord* aRadii,
  79                                       DisplayItemClip& aClipOnStack);
  80
  81   void ClipContentDescendants(const nsRect& aRect,
  82                               const nscoord* aRadii,
  83                               DisplayItemClip& aClipOnStack);
  84   void ClipContentDescendants(const nsRect& aRect,
  85                               const nsRect& aRoundedRect,
  86                               const nscoord* aRadii,
  87                               DisplayItemClip& aClipOnStack);
  88
  89   /**
  90    * Clips containing-block descendants to the frame's content-box,
  91    * taking border-radius into account.
  92    * If aFlags contains ASSUME_DRAWING_RESTRICTED_TO_CONTENT_RECT then
  93    * we assume display items will not draw outside the content rect, so
  94    * clipping is only required if there is a border-radius. This is an
  95    * optimization to reduce the amount of clipping required.
  96    */
  97   void ClipContainingBlockDescendantsToContentBox(nsDisplayListBuilder* aBuilder,
  98                                                   nsIFrame* aFrame,
  99                                                   DisplayItemClip& aClipOnStack,
 100                                                   uint32_t aFlags);
 101
 102   /**
 103    * All content descendants (i.e. following placeholder frames to their
 104    * out-of-flows if necessary) should be clipped by mClipContentDescendants.
 105    * Null if no clipping applies.
 106    */
 107   const DisplayItemClip* mClipContentDescendants;
 108   /**
 109    * All containing-block descendants (i.e. frame descendants), including
 110    * display items for the current frame, should be clipped by
 111    * mClipContainingBlockDescendants.
 112    * Null if no clipping applies.
 113    */
 114   const DisplayItemClip* mClipContainingBlockDescendants;
 115   /**
 116    * The intersection of mClipContentDescendants and
 117    * mClipContainingBlockDescendants.
 118    * Allocated in the nsDisplayListBuilder arena. Null if none has been
 119    * allocated or both mClipContentDescendants and mClipContainingBlockDescendants
 120    * are null.
 121    */
 122   const DisplayItemClip* mCurrentCombinedClip;
 123 };
 124
 125 /**
 126  * A class to automatically save and restore the current clip state. Also
 127  * offers methods for modifying the clip state. Only one modification is allowed
 128  * to be in scope at a time using one of these objects; multiple modifications
 129  * require nested objects. The interface is written this way to prevent
 130  * dangling pointers to DisplayItemClips.
 131  */
 132 class DisplayListClipState::AutoSaveRestore {
 133 public:
 134   explicit AutoSaveRestore(nsDisplayListBuilder* aBuilder);
 135   void Restore()
 136   {
 137     mState = mSavedState;
 138     mRestored = true;
 139   }
 140   ~AutoSaveRestore()
 141   {
 142     mState = mSavedState;
 143   }
 144
 145   void Clear()
 146   {
 147     NS_ASSERTION(!mRestored, "Already restored!");
 148     mState.Clear();
 149     mClipUsed = false;
 150   }
 151
 152   /**
 153    * Intersects the given clip rect (with optional aRadii) with the current
 154    * mClipContainingBlockDescendants and sets mClipContainingBlockDescendants to
 155    * the result, stored in aClipOnStack.
 156    */
 157   void ClipContainingBlockDescendants(const nsRect& aRect,
 158                                       const nscoord* aRadii = nullptr)
 159   {
 160     NS_ASSERTION(!mRestored, "Already restored!");
 161     NS_ASSERTION(!mClipUsed, "mClip already used");
 162     mClipUsed = true;
 163     mState.ClipContainingBlockDescendants(aRect, aRadii, mClip);
 164   }
 165
 166   void ClipContentDescendants(const nsRect& aRect,
 167                               const nscoord* aRadii = nullptr)
 168   {
 169     NS_ASSERTION(!mRestored, "Already restored!");
 170     NS_ASSERTION(!mClipUsed, "mClip already used");
 171     mClipUsed = true;
 172     mState.ClipContentDescendants(aRect, aRadii, mClip);
 173   }
 174
 175   void ClipContentDescendants(const nsRect& aRect,
 176                               const nsRect& aRoundedRect,
 177                               const nscoord* aRadii = nullptr)
 178   {
 179     NS_ASSERTION(!mRestored, "Already restored!");
 180     NS_ASSERTION(!mClipUsed, "mClip already used");
 181     mClipUsed = true;
 182     mState.ClipContentDescendants(aRect, aRoundedRect, aRadii, mClip);
 183   }
 184
 185   /**
 186    * Clips containing-block descendants to the frame's content-box,
 187    * taking border-radius into account.
 188    * If aFlags contains ASSUME_DRAWING_RESTRICTED_TO_CONTENT_RECT then
 189    * we assume display items will not draw outside the content rect, so
 190    * clipping is only required if there is a border-radius. This is an
 191    * optimization to reduce the amount of clipping required.
 192    */
 193   void ClipContainingBlockDescendantsToContentBox(nsDisplayListBuilder* aBuilder,
 194                                                   nsIFrame* aFrame,
 195                                                   uint32_t aFlags = 0)
 196   {
 197     NS_ASSERTION(!mRestored, "Already restored!");
 198     NS_ASSERTION(!mClipUsed, "mClip already used");
 199     mClipUsed = true;
 200     mState.ClipContainingBlockDescendantsToContentBox(aBuilder, aFrame, mClip, aFlags);
 201   }
 202
 203 protected:
 204   DisplayListClipState& mState;
 205   DisplayListClipState mSavedState;
 206   DisplayItemClip mClip;
 207   DebugOnly<bool> mClipUsed;
 208   DebugOnly<bool> mRestored;
 209 };
 210
 211 class DisplayListClipState::AutoClipContainingBlockDescendantsToContentBox : public AutoSaveRestore {
 212 public:
 213   AutoClipContainingBlockDescendantsToContentBox(nsDisplayListBuilder* aBuilder,
 214                                                  nsIFrame* aFrame,
 215                                                  uint32_t aFlags = 0)
 216     : AutoSaveRestore(aBuilder)
 217   {
 218     mClipUsed = true;
 219     mState.ClipContainingBlockDescendantsToContentBox(aBuilder, aFrame, mClip, aFlags);
 220   }
 221 };
 222
 223 /**
 224  * Do not use this outside of nsFrame::BuildDisplayListForChild, use
 225  * multiple AutoSaveRestores instead. We provide this class just to ensure
 226  * BuildDisplayListForChild is as efficient as possible.
 227  */
 228 class DisplayListClipState::AutoClipMultiple : public AutoSaveRestore {
 229 public:
 230   explicit AutoClipMultiple(nsDisplayListBuilder* aBuilder)
 231     : AutoSaveRestore(aBuilder)
 232     , mExtraClipUsed(false)
 233   {}
 234
 235   /**
 236    * *aClip must survive longer than this object. Be careful!!!
 237    */
 238   void SetClipForContainingBlockDescendants(const DisplayItemClip* aClip)
 239   {
 240     mState.SetClipForContainingBlockDescendants(aClip);
 241   }
 242
 243   /**
 244    * Intersects the given clip rect (with optional aRadii) with the current
 245    * mClipContainingBlockDescendants and sets mClipContainingBlockDescendants to
 246    * the result, stored in aClipOnStack.
 247    */
 248   void ClipContainingBlockDescendantsExtra(const nsRect& aRect,
 249                                            const nscoord* aRadii)
 250   {
 251     NS_ASSERTION(!mRestored, "Already restored!");
 252     NS_ASSERTION(!mExtraClipUsed, "mExtraClip already used");
 253     mExtraClipUsed = true;
 254     mState.ClipContainingBlockDescendants(aRect, aRadii, mExtraClip);
 255   }
 256
 257 protected:
 258   DisplayItemClip mExtraClip;
 259   DebugOnly<bool> mExtraClipUsed;
 260 };
 261
 262 }
 263
 264 #endif /* DISPLAYLISTCLIPSTATE_H_ */