[LFC][Floating] Add basic left/right floating positioning.
[WebKit-https.git] / Source / WebCore / layout / displaytree / DisplayBox.h
1 /*
2  * Copyright (C) 2018 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #pragma once
27
28 #if ENABLE(LAYOUT_FORMATTING_CONTEXT)
29
30 #include "LayoutUnits.h"
31 #include "RenderStyleConstants.h"
32 #include <wtf/IsoMalloc.h>
33
34 namespace WebCore {
35
36 class RenderStyle;
37
38 namespace Layout {
39 class BlockFormattingContext;
40 class FormattingContext;
41 class LayoutContext;
42 }
43
44 namespace Display {
45
46 class Box {
47     WTF_MAKE_ISO_ALLOCATED(Box);
48 public:
49     friend class Layout::BlockFormattingContext;
50     friend class Layout::FormattingContext;
51     friend class Layout::LayoutContext;
52
53     class Rect {
54     public:
55         Rect() = default;
56         Rect(LayoutUnit top, LayoutUnit left, LayoutUnit width, LayoutUnit height);
57         
58         LayoutUnit top() const;
59         LayoutUnit left() const;
60         LayoutPoint topLeft() const;
61
62         LayoutUnit bottom() const;
63         LayoutUnit right() const;        
64         LayoutPoint bottomRight() const;
65
66         LayoutUnit width() const;
67         LayoutUnit height() const;
68         LayoutSize size() const;
69
70         void setTop(LayoutUnit);
71         void setLeft(LayoutUnit);
72         void setTopLeft(const LayoutPoint&);
73         void setWidth(LayoutUnit);
74         void setHeight(LayoutUnit);
75         void setSize(const LayoutSize&);
76
77         void shiftLeftTo(LayoutUnit);
78         void shiftRightTo(LayoutUnit);
79         void shiftTopTo(LayoutUnit);
80         void shiftBottomTo(LayoutUnit);
81
82         void moveHorizontally(LayoutUnit);
83         void moveVertically(LayoutUnit);
84
85         void expand(LayoutUnit, LayoutUnit);
86         bool intersects(const Rect& rect) const { return m_rect.intersects(rect); }
87
88         Rect clone() const;
89         operator LayoutRect() const;
90
91     private:
92 #if !ASSERT_DISABLED
93         void invalidateTop() { m_hasValidTop = false; }
94         void invalidateLeft() { m_hasValidLeft = false; }
95         void invalidateWidth() { m_hasValidWidth = false; }
96         void invalidateHeight() { m_hasValidHeight = false; }
97         void invalidatePosition();
98
99         bool hasValidPosition() const { return m_hasValidTop && m_hasValidLeft; }
100         bool hasValidSize() const { return m_hasValidWidth && m_hasValidHeight; }
101         bool hasValidGeometry() const { return hasValidPosition() && hasValidSize(); }
102     
103         void setHasValidPosition();
104         void setHasValidSize();
105
106         bool m_hasValidTop { false };
107         bool m_hasValidLeft { false };
108         bool m_hasValidWidth { false };
109         bool m_hasValidHeight { false };
110 #endif
111         LayoutRect m_rect;
112     };
113
114     ~Box();
115
116     LayoutUnit top() const { return m_topLeft.y(); }
117     LayoutUnit left() const { return m_topLeft.x(); }
118     LayoutUnit bottom() const { return top() + height(); }
119     LayoutUnit right() const { return left() + width(); }
120
121     LayoutPoint topLeft() const { return m_topLeft; }
122     LayoutPoint bottomRight() const { return { right(), bottom() }; }
123
124     LayoutSize size() const { return { width(), height() }; }
125     LayoutUnit width() const { return borderLeft() + paddingLeft() + contentBoxWidth() + paddingRight() + borderRight(); }
126     LayoutUnit height() const { return borderTop() + paddingTop() + contentBoxHeight() + paddingBottom() + borderBottom(); }
127     Rect rect() const { return { top(), left(), width(), height() }; }
128
129     LayoutUnit marginTop() const;
130     LayoutUnit marginLeft() const;
131     LayoutUnit marginBottom() const;
132     LayoutUnit marginRight() const;
133
134     LayoutUnit nonCollapsedMarginTop() const;
135     LayoutUnit nonCollapsedMarginBottom() const;
136
137     LayoutUnit borderTop() const;
138     LayoutUnit borderLeft() const;
139     LayoutUnit borderBottom() const;
140     LayoutUnit borderRight() const;
141
142     LayoutUnit paddingTop() const;
143     LayoutUnit paddingLeft() const;
144     LayoutUnit paddingBottom() const;
145     LayoutUnit paddingRight() const;
146
147     LayoutUnit contentBoxTop() const { return borderTop() + paddingTop(); }
148     LayoutUnit contentBoxLeft() const { return borderLeft() + paddingLeft(); }
149     LayoutUnit contentBoxBottom() const { return contentBoxTop() + contentBoxHeight(); }
150     LayoutUnit contentBoxRight() const { return contentBoxLeft() + contentBoxWidth(); }
151     LayoutUnit contentBoxHeight() const;
152     LayoutUnit contentBoxWidth() const;
153
154     Rect marginBox() const;
155     Rect nonCollapsedMarginBox() const;
156
157     Rect borderBox() const;
158     Rect paddingBox() const;
159     Rect contentBox() const;
160
161 private:
162     Box(const RenderStyle&);
163
164     struct Style {
165         Style(const RenderStyle&);
166
167         BoxSizing boxSizing { BoxSizing::ContentBox };
168     };
169
170     void setTopLeft(const LayoutPoint& topLeft) { m_topLeft = topLeft; }
171     void setTop(LayoutUnit top) { m_topLeft.setY(top); }
172     void setLeft(LayoutUnit left) { m_topLeft.setX(left); }
173     void moveHorizontally(LayoutUnit offset) { m_topLeft.move(offset, { }); }
174     void moveVertically(LayoutUnit offset) { m_topLeft.move({ }, offset); }
175
176     void setContentBoxHeight(LayoutUnit);
177     void setContentBoxWidth(LayoutUnit);
178
179     void setHorizontalMargin(Layout::HorizontalEdges);
180     void setVerticalMargin(Layout::VerticalEdges);
181     void setVerticalNonCollapsedMargin(Layout::VerticalEdges);
182
183     void setBorder(Layout::Edges);
184     void setPadding(Layout::Edges);
185
186 #if !ASSERT_DISABLED
187     void invalidateMargin();
188     void invalidateBorder() { m_hasValidBorder = false; }
189     void invalidatePadding() { m_hasValidPadding = false; }
190
191     void setHasValidVerticalMargin() { m_hasValidVerticalMargin = true; }
192     void setHasValidVerticalNonCollapsedMargin() { m_hasValidVerticalNonCollapsedMargin = true; }
193     void setHasValidHorizontalMargin() { m_hasValidHorizontalMargin = true; }
194
195     void setHasValidBorder() { m_hasValidBorder = true; }
196     void setHasValidPadding() { m_hasValidPadding = true; }
197
198     void setHasValidContentHeight() { m_hasValidContentHeight = true; }
199     void setHasValidContentWidth() { m_hasValidContentWidth = true; }
200 #endif
201
202     const Style m_style;
203
204     LayoutPoint m_topLeft;
205     LayoutUnit m_contentWidth;
206     LayoutUnit m_contentHeight;
207
208     Layout::Edges m_margin;
209     Layout::VerticalEdges m_verticalNonCollapsedMargin;
210
211     Layout::Edges m_border;
212     Layout::Edges m_padding;
213
214 #if !ASSERT_DISABLED
215     bool m_hasValidHorizontalMargin { false };
216     bool m_hasValidVerticalMargin { false };
217     bool m_hasValidVerticalNonCollapsedMargin { false };
218     bool m_hasValidBorder { false };
219     bool m_hasValidPadding { false };
220     bool m_hasValidContentHeight { false };
221     bool m_hasValidContentWidth { false };
222 #endif
223 };
224
225 #if !ASSERT_DISABLED
226 inline void Box::Rect::invalidatePosition()
227 {
228     invalidateTop();
229     invalidateLeft();
230 }
231
232 inline void Box::Rect::setHasValidPosition()
233 {
234     m_hasValidTop = true;
235     m_hasValidLeft = true;
236 }
237
238 inline void Box::Rect::setHasValidSize()
239 {
240     m_hasValidWidth = true;
241     m_hasValidHeight = true;
242 }
243
244 inline void Box::invalidateMargin()
245 {
246     m_hasValidHorizontalMargin = false;
247     m_hasValidVerticalMargin = false;
248 }
249 #endif
250
251 inline LayoutUnit Box::Rect::top() const
252 {
253     ASSERT(m_hasValidTop);
254     return m_rect.y();
255 }
256
257 inline LayoutUnit Box::Rect::left() const
258 {
259     ASSERT(m_hasValidLeft);
260     return m_rect.x();
261 }
262
263 inline LayoutUnit Box::Rect::bottom() const
264 {
265     ASSERT(m_hasValidTop && m_hasValidHeight);
266     return m_rect.maxY();
267 }
268
269 inline LayoutUnit Box::Rect::right() const
270 {
271     ASSERT(m_hasValidLeft && m_hasValidWidth);
272     return m_rect.maxX();
273 }
274
275 inline LayoutPoint Box::Rect::topLeft() const
276 {
277     ASSERT(hasValidPosition());
278     return m_rect.minXMinYCorner();
279 }
280
281 inline LayoutPoint Box::Rect::bottomRight() const
282 {
283     ASSERT(hasValidGeometry());
284     return m_rect.maxXMaxYCorner();
285 }
286
287 inline LayoutSize Box::Rect::size() const
288 {
289     ASSERT(hasValidSize());
290     return m_rect.size();
291 }
292
293 inline LayoutUnit Box::Rect::width() const
294 {
295     ASSERT(m_hasValidWidth);
296     return m_rect.width();
297 }
298
299 inline LayoutUnit Box::Rect::height() const
300 {
301     ASSERT(m_hasValidHeight);
302     return m_rect.height();
303 }
304
305 inline void Box::Rect::setTopLeft(const LayoutPoint& topLeft)
306 {
307 #if !ASSERT_DISABLED
308     setHasValidPosition();
309 #endif
310     m_rect.setLocation(topLeft);
311 }
312
313 inline void Box::Rect::setTop(LayoutUnit top)
314 {
315 #if !ASSERT_DISABLED
316     m_hasValidTop = true;
317 #endif
318     m_rect.setY(top);
319 }
320
321 inline void Box::Rect::setLeft(LayoutUnit left)
322 {
323 #if !ASSERT_DISABLED
324     m_hasValidLeft = true;
325 #endif
326     m_rect.setX(left);
327 }
328
329 inline void Box::Rect::setWidth(LayoutUnit width)
330 {
331 #if !ASSERT_DISABLED
332     m_hasValidWidth = true;
333 #endif
334     m_rect.setWidth(width);
335 }
336
337 inline void Box::Rect::setHeight(LayoutUnit height)
338 {
339 #if !ASSERT_DISABLED
340     m_hasValidHeight = true;
341 #endif
342     m_rect.setHeight(height);
343 }
344
345 inline void Box::Rect::setSize(const LayoutSize& size)
346 {
347 #if !ASSERT_DISABLED
348     setHasValidSize();
349 #endif
350     m_rect.setSize(size);
351 }
352
353 inline void Box::Rect::shiftLeftTo(LayoutUnit left)
354 {
355     ASSERT(m_hasValidLeft);
356     m_rect.shiftXEdgeTo(left);
357 }
358
359 inline void Box::Rect::shiftRightTo(LayoutUnit right)
360 {
361     ASSERT(m_hasValidLeft && m_hasValidWidth);
362     m_rect.shiftMaxXEdgeTo(right);
363 }
364
365 inline void Box::Rect::shiftTopTo(LayoutUnit top)
366 {
367     ASSERT(m_hasValidTop);
368     m_rect.shiftYEdgeTo(top);
369 }
370
371 inline void Box::Rect::shiftBottomTo(LayoutUnit bottom)
372 {
373     ASSERT(m_hasValidTop && m_hasValidHeight);
374     m_rect.shiftMaxYEdgeTo(bottom);
375 }
376
377 inline void Box::Rect::moveHorizontally(LayoutUnit offset)
378 {
379     ASSERT(m_hasValidLeft);
380     m_rect.move(offset, { });
381 }
382
383 inline void Box::Rect::moveVertically(LayoutUnit offset)
384 {
385     ASSERT(m_hasValidTop);
386     m_rect.move({ }, offset);
387 }
388
389 inline void Box::Rect::expand(LayoutUnit width, LayoutUnit height)
390 {
391     ASSERT(hasValidGeometry());
392     m_rect.expand(width, height);
393 }
394
395 inline Box::Rect Box::Rect::clone() const
396 {
397     Rect rect;
398 #if !ASSERT_DISABLED
399     rect.m_hasValidTop = m_hasValidTop;
400     rect.m_hasValidLeft = m_hasValidLeft;
401     rect.m_hasValidWidth = m_hasValidWidth;
402     rect.m_hasValidHeight  = m_hasValidHeight;
403 #endif 
404     rect.m_rect = m_rect;
405     return rect;
406 }
407
408 inline Box::Rect::operator LayoutRect() const
409 {
410     ASSERT(hasValidGeometry()); 
411     return m_rect;
412 }
413
414 inline void Box::setContentBoxHeight(LayoutUnit height)
415
416 #if !ASSERT_DISABLED
417     setHasValidContentHeight();
418 #endif
419     m_contentHeight = height;
420 }
421
422 inline void Box::setContentBoxWidth(LayoutUnit width)
423
424 #if !ASSERT_DISABLED
425     setHasValidContentWidth();
426 #endif
427     m_contentWidth = width;
428 }
429
430 inline LayoutUnit Box::contentBoxHeight() const
431 {
432     ASSERT(m_hasValidContentHeight);
433     return m_contentHeight;
434 }
435
436 inline LayoutUnit Box::contentBoxWidth() const
437 {
438     ASSERT(m_hasValidContentWidth);
439     return m_contentWidth;
440 }
441
442 inline void Box::setHorizontalMargin(Layout::HorizontalEdges margin)
443 {
444 #if !ASSERT_DISABLED
445     setHasValidHorizontalMargin();
446 #endif
447     m_margin.horizontal = margin;
448 }
449
450 inline void Box::setVerticalMargin(Layout::VerticalEdges margin)
451 {
452 #if !ASSERT_DISABLED
453     setHasValidVerticalMargin();
454 #endif
455     m_margin.vertical = margin;
456 }
457
458 inline void Box::setVerticalNonCollapsedMargin(Layout::VerticalEdges margin)
459 {
460 #if !ASSERT_DISABLED
461     setHasValidVerticalNonCollapsedMargin();
462 #endif
463     m_verticalNonCollapsedMargin = margin;
464 }
465
466 inline void Box::setBorder(Layout::Edges border)
467 {
468 #if !ASSERT_DISABLED
469     setHasValidBorder();
470 #endif
471     m_border = border;
472 }
473
474 inline void Box::setPadding(Layout::Edges padding)
475 {
476 #if !ASSERT_DISABLED
477     setHasValidPadding();
478 #endif
479     m_padding = padding;
480 }
481
482 inline LayoutUnit Box::marginTop() const
483 {
484     ASSERT(m_hasValidVerticalMargin);
485     return m_margin.vertical.top;
486 }
487
488 inline LayoutUnit Box::marginLeft() const
489 {
490     ASSERT(m_hasValidHorizontalMargin);
491     return m_margin.horizontal.left;
492 }
493
494 inline LayoutUnit Box::marginBottom() const
495 {
496     ASSERT(m_hasValidVerticalMargin);
497     return m_margin.vertical.bottom;
498 }
499
500 inline LayoutUnit Box::marginRight() const
501 {
502     ASSERT(m_hasValidHorizontalMargin);
503     return m_margin.horizontal.right;
504 }
505
506 inline LayoutUnit Box::nonCollapsedMarginTop() const
507 {
508     ASSERT(m_hasValidVerticalNonCollapsedMargin);
509     return m_verticalNonCollapsedMargin.top;
510 }
511
512 inline LayoutUnit Box::nonCollapsedMarginBottom() const
513 {
514     ASSERT(m_hasValidVerticalNonCollapsedMargin);
515     return m_verticalNonCollapsedMargin.bottom;
516 }
517
518 inline LayoutUnit Box::paddingTop() const
519 {
520     ASSERT(m_hasValidPadding);
521     return m_padding.vertical.top;
522 }
523
524 inline LayoutUnit Box::paddingLeft() const
525 {
526     ASSERT(m_hasValidPadding);
527     return m_padding.horizontal.left;
528 }
529
530 inline LayoutUnit Box::paddingBottom() const
531 {
532     ASSERT(m_hasValidPadding);
533     return m_padding.vertical.bottom;
534 }
535
536 inline LayoutUnit Box::paddingRight() const
537 {
538     ASSERT(m_hasValidPadding);
539     return m_padding.horizontal.right;
540 }
541
542 inline LayoutUnit Box::borderTop() const
543 {
544     ASSERT(m_hasValidBorder);
545     return m_border.vertical.top;
546 }
547
548 inline LayoutUnit Box::borderLeft() const
549 {
550     ASSERT(m_hasValidBorder);
551     return m_border.horizontal.left;
552 }
553
554 inline LayoutUnit Box::borderBottom() const
555 {
556     ASSERT(m_hasValidBorder);
557     return m_border.vertical.bottom;
558 }
559
560 inline LayoutUnit Box::borderRight() const
561 {
562     ASSERT(m_hasValidBorder);
563     return m_border.horizontal.right;
564 }
565
566 }
567 }
568 #endif