Line data Source code
1 : /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2 : * vim: sw=2 ts=8 et :
3 : */
4 : /* This Source Code Form is subject to the terms of the Mozilla Public
5 : * License, v. 2.0. If a copy of the MPL was not distributed with this
6 : * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
7 : #ifndef mozilla_gfx_layers_LayerAttributes_h
8 : #define mozilla_gfx_layers_LayerAttributes_h
9 :
10 : #include "mozilla/gfx/Types.h"
11 : #include "mozilla/layers/LayersTypes.h"
12 :
13 : namespace IPC {
14 : template <typename T> struct ParamTraits;
15 : } // namespace IPC
16 :
17 : namespace mozilla {
18 : namespace layers {
19 :
20 : // Data stored for scroll thumb container layers.
21 : struct ScrollThumbData {
22 361 : ScrollThumbData()
23 361 : : mDirection(ScrollDirection::NONE)
24 : , mThumbRatio(0.0f)
25 361 : , mIsAsyncDraggable(false)
26 361 : {}
27 0 : ScrollThumbData(ScrollDirection aDirection,
28 : float aThumbRatio,
29 : CSSCoord aThumbStart,
30 : CSSCoord aThumbLength,
31 : bool aIsAsyncDraggable,
32 : CSSCoord aScrollTrackStart,
33 : CSSCoord aScrollTrackLength)
34 0 : : mDirection(aDirection)
35 : , mThumbRatio(aThumbRatio)
36 : , mThumbStart(aThumbStart)
37 : , mThumbLength(aThumbLength)
38 : , mIsAsyncDraggable(aIsAsyncDraggable)
39 : , mScrollTrackStart(aScrollTrackStart)
40 0 : , mScrollTrackLength(aScrollTrackLength)
41 0 : {}
42 :
43 : ScrollDirection mDirection;
44 : // The scrollbar thumb ratio is the ratio of the thumb position (in the CSS
45 : // pixels of the scrollframe's parent's space) to the scroll position (in the
46 : // CSS pixels of the scrollframe's space).
47 : float mThumbRatio;
48 : CSSCoord mThumbStart;
49 : CSSCoord mThumbLength;
50 : // Whether the scrollbar thumb can be dragged asynchronously.
51 : bool mIsAsyncDraggable;
52 : CSSCoord mScrollTrackStart;
53 : CSSCoord mScrollTrackLength;
54 :
55 24 : bool operator==(const ScrollThumbData& aOther) const {
56 48 : return mDirection == aOther.mDirection &&
57 48 : mThumbRatio == aOther.mThumbRatio &&
58 48 : mThumbStart == aOther.mThumbStart &&
59 48 : mThumbLength == aOther.mThumbLength &&
60 48 : mIsAsyncDraggable == aOther.mIsAsyncDraggable &&
61 72 : mScrollTrackStart == aOther.mScrollTrackStart &&
62 48 : mScrollTrackLength == aOther.mScrollTrackLength;
63 : }
64 24 : bool operator!=(const ScrollThumbData& aOther) const {
65 24 : return !(*this == aOther);
66 : }
67 : };
68 :
69 : // Infrequently changing layer attributes that require no special
70 : // serialization work.
71 355 : class SimpleLayerAttributes final
72 : {
73 : friend struct IPC::ParamTraits<mozilla::layers::SimpleLayerAttributes>;
74 : public:
75 311 : SimpleLayerAttributes()
76 311 : : mTransformIsPerspective(false),
77 : mPostXScale(1.0f),
78 : mPostYScale(1.0f),
79 : mContentFlags(0),
80 : mOpacity(1.0f),
81 : mIsFixedPosition(false),
82 : mScrollbarTargetContainerId(FrameMetrics::NULL_SCROLL_ID),
83 : mIsScrollbarContainer(false),
84 : mMixBlendMode(gfx::CompositionOp::OP_OVER),
85 311 : mForceIsolatedGroup(false)
86 : {
87 311 : }
88 :
89 : //
90 : // Setters.
91 : // All set methods return true if values changed, false otherwise.
92 : //
93 :
94 47 : bool SetPostScale(float aXScale, float aYScale) {
95 47 : if (mPostXScale == aXScale && mPostYScale == aYScale) {
96 47 : return false;
97 : }
98 0 : mPostXScale = aXScale;
99 0 : mPostYScale = aYScale;
100 0 : return true;
101 : }
102 882 : bool SetContentFlags(uint32_t aFlags) {
103 882 : if (aFlags == mContentFlags) {
104 766 : return false;
105 : }
106 116 : mContentFlags = aFlags;
107 116 : return true;
108 : }
109 136 : bool SetOpacity(float aOpacity) {
110 136 : if (aOpacity == mOpacity) {
111 127 : return false;
112 : }
113 9 : mOpacity = aOpacity;
114 9 : return true;
115 : }
116 0 : bool SetIsFixedPosition(bool aFixedPosition) {
117 0 : if (mIsFixedPosition == aFixedPosition) {
118 0 : return false;
119 : }
120 0 : mIsFixedPosition = aFixedPosition;
121 0 : return true;
122 : }
123 0 : bool SetScrollThumbData(FrameMetrics::ViewID aScrollId, const ScrollThumbData& aThumbData) {
124 0 : if (mScrollbarTargetContainerId == aScrollId &&
125 0 : mThumbData == aThumbData)
126 : {
127 0 : return false;
128 : }
129 0 : mScrollbarTargetContainerId = aScrollId;
130 0 : mThumbData = aThumbData;
131 0 : return true;
132 : }
133 0 : bool SetIsScrollbarContainer(FrameMetrics::ViewID aScrollId) {
134 0 : if (mIsScrollbarContainer && mScrollbarTargetContainerId == aScrollId) {
135 0 : return false;
136 : }
137 0 : mIsScrollbarContainer = true;
138 0 : mScrollbarTargetContainerId = aScrollId;
139 0 : return true;
140 : }
141 0 : bool SetMixBlendMode(gfx::CompositionOp aMixBlendMode) {
142 0 : if (mMixBlendMode == aMixBlendMode) {
143 0 : return false;
144 : }
145 0 : mMixBlendMode = aMixBlendMode;
146 0 : return true;
147 : }
148 0 : bool SetForceIsolatedGroup(bool aForceIsolatedGroup) {
149 0 : if (mForceIsolatedGroup == aForceIsolatedGroup) {
150 0 : return false;
151 : }
152 0 : mForceIsolatedGroup = aForceIsolatedGroup;
153 0 : return true;
154 : }
155 524 : bool SetTransform(const gfx::Matrix4x4& aMatrix) {
156 524 : if (mTransform == aMatrix) {
157 431 : return false;
158 : }
159 93 : mTransform = aMatrix;
160 93 : return true;
161 : }
162 0 : bool SetTransformIsPerspective(bool aIsPerspective) {
163 0 : if (mTransformIsPerspective == aIsPerspective) {
164 0 : return false;
165 : }
166 0 : mTransformIsPerspective = aIsPerspective;
167 0 : return true;
168 : }
169 76 : bool SetScrolledClip(const Maybe<LayerClip>& aScrolledClip) {
170 76 : if (mScrolledClip == aScrolledClip) {
171 76 : return false;
172 : }
173 0 : mScrolledClip = aScrolledClip;
174 0 : return true;
175 : }
176 0 : bool SetFixedPositionData(FrameMetrics::ViewID aScrollId,
177 : const LayerPoint& aAnchor,
178 : int32_t aSides)
179 : {
180 0 : if (mFixedPositionData &&
181 0 : mFixedPositionData->mScrollId == aScrollId &&
182 0 : mFixedPositionData->mAnchor == aAnchor &&
183 0 : mFixedPositionData->mSides == aSides) {
184 0 : return false;
185 : }
186 0 : if (!mFixedPositionData) {
187 0 : mFixedPositionData.emplace();
188 : }
189 0 : mFixedPositionData->mScrollId = aScrollId;
190 0 : mFixedPositionData->mAnchor = aAnchor;
191 0 : mFixedPositionData->mSides = aSides;
192 0 : return true;
193 : }
194 0 : bool SetStickyPositionData(FrameMetrics::ViewID aScrollId, LayerRect aOuter,
195 : LayerRect aInner)
196 : {
197 0 : if (mStickyPositionData &&
198 0 : mStickyPositionData->mOuter.IsEqualEdges(aOuter) &&
199 0 : mStickyPositionData->mInner.IsEqualEdges(aInner)) {
200 0 : return false;
201 : }
202 0 : if (!mStickyPositionData) {
203 0 : mStickyPositionData.emplace();
204 : }
205 0 : mStickyPositionData->mScrollId = aScrollId;
206 0 : mStickyPositionData->mOuter = aOuter;
207 0 : mStickyPositionData->mInner = aInner;
208 0 : return true;
209 : }
210 :
211 : // This returns true if scrolling info is equivalent for the purposes of
212 : // APZ hit testing.
213 24 : bool HitTestingInfoIsEqual(const SimpleLayerAttributes& aOther) const {
214 24 : if (mIsScrollbarContainer != aOther.mIsScrollbarContainer) {
215 0 : return false;
216 : }
217 24 : if (mScrollbarTargetContainerId != aOther.mScrollbarTargetContainerId) {
218 0 : return false;
219 : }
220 24 : if (mThumbData != aOther.mThumbData) {
221 0 : return false;
222 : }
223 24 : if (FixedPositionScrollContainerId() != aOther.FixedPositionScrollContainerId()) {
224 0 : return false;
225 : }
226 24 : if (mTransform != aOther.mTransform) {
227 1 : return false;
228 : }
229 23 : return true;
230 : }
231 :
232 : //
233 : // Getters.
234 : //
235 :
236 4989 : float PostXScale() const {
237 4989 : return mPostXScale;
238 : }
239 4989 : float PostYScale() const {
240 4989 : return mPostYScale;
241 : }
242 9709 : uint32_t ContentFlags() const {
243 9709 : return mContentFlags;
244 : }
245 2813 : float Opacity() const {
246 2813 : return mOpacity;
247 : }
248 354 : bool IsFixedPosition() const {
249 354 : return mIsFixedPosition;
250 : }
251 211 : FrameMetrics::ViewID ScrollbarTargetContainerId() const {
252 211 : return mScrollbarTargetContainerId;
253 : }
254 426 : const ScrollThumbData& ThumbData() const {
255 426 : return mThumbData;
256 : }
257 337 : float IsScrollbarContainer() const {
258 337 : return mIsScrollbarContainer;
259 : }
260 1906 : gfx::CompositionOp MixBlendMode() const {
261 1906 : return mMixBlendMode;
262 : }
263 393 : bool ForceIsolatedGroup() const {
264 393 : return mForceIsolatedGroup;
265 : }
266 3303 : const gfx::Matrix4x4& Transform() const {
267 3303 : return mTransform;
268 : }
269 222 : bool TransformIsPerspective() const {
270 222 : return mTransformIsPerspective;
271 : }
272 957 : const Maybe<LayerClip>& ScrolledClip() const {
273 957 : return mScrolledClip;
274 : }
275 259 : FrameMetrics::ViewID FixedPositionScrollContainerId() const {
276 : return mFixedPositionData
277 259 : ? mFixedPositionData->mScrollId
278 518 : : FrameMetrics::NULL_SCROLL_ID;
279 : }
280 0 : LayerPoint FixedPositionAnchor() const {
281 0 : return mFixedPositionData ? mFixedPositionData->mAnchor : LayerPoint();
282 : }
283 0 : int32_t FixedPositionSides() const {
284 0 : return mFixedPositionData ? mFixedPositionData->mSides : eSideBitsNone;
285 : }
286 226 : bool IsStickyPosition() const {
287 226 : return !!mStickyPositionData;
288 : }
289 0 : FrameMetrics::ViewID StickyScrollContainerId() const {
290 0 : return mStickyPositionData->mScrollId;
291 : }
292 0 : const LayerRect& StickyScrollRangeOuter() const {
293 0 : return mStickyPositionData->mOuter;
294 : }
295 0 : const LayerRect& StickyScrollRangeInner() const {
296 0 : return mStickyPositionData->mInner;
297 : }
298 :
299 0 : bool operator ==(const SimpleLayerAttributes& aOther) const {
300 0 : return mTransform == aOther.mTransform &&
301 0 : mTransformIsPerspective == aOther.mTransformIsPerspective &&
302 0 : mScrolledClip == aOther.mScrolledClip &&
303 0 : mPostXScale == aOther.mPostXScale &&
304 0 : mPostYScale == aOther.mPostYScale &&
305 0 : mContentFlags == aOther.mContentFlags &&
306 0 : mOpacity == aOther.mOpacity &&
307 0 : mIsFixedPosition == aOther.mIsFixedPosition &&
308 0 : mScrollbarTargetContainerId == aOther.mScrollbarTargetContainerId &&
309 0 : mThumbData == aOther.mThumbData &&
310 0 : mIsScrollbarContainer == aOther.mIsScrollbarContainer &&
311 0 : mMixBlendMode == aOther.mMixBlendMode &&
312 0 : mForceIsolatedGroup == aOther.mForceIsolatedGroup;
313 : }
314 :
315 : private:
316 : gfx::Matrix4x4 mTransform;
317 : bool mTransformIsPerspective;
318 : Maybe<LayerClip> mScrolledClip;
319 : float mPostXScale;
320 : float mPostYScale;
321 : uint32_t mContentFlags;
322 : float mOpacity;
323 : bool mIsFixedPosition;
324 : uint64_t mScrollbarTargetContainerId;
325 : ScrollThumbData mThumbData;
326 : bool mIsScrollbarContainer;
327 : gfx::CompositionOp mMixBlendMode;
328 : bool mForceIsolatedGroup;
329 :
330 0 : struct FixedPositionData {
331 : FrameMetrics::ViewID mScrollId;
332 : LayerPoint mAnchor;
333 : int32_t mSides;
334 : };
335 : Maybe<FixedPositionData> mFixedPositionData;
336 :
337 0 : struct StickyPositionData {
338 : FrameMetrics::ViewID mScrollId;
339 : LayerRect mOuter;
340 : LayerRect mInner;
341 : };
342 : Maybe<StickyPositionData> mStickyPositionData;
343 :
344 : // This class may only contain plain-old-data members that can be safely
345 : // copied over IPC. Make sure to add new members to operator ==.
346 : };
347 :
348 : } // namespace layers
349 : } // namespace mozilla
350 :
351 : #endif // mozilla_gfx_layers_LayerAttributes_h
|
