[LFC][Floating] Decouple the incoming floats and floats already placed in the list
[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 FloatBox;
40 class BlockFormattingContext;
41 class FormattingContext;
42 class FloatingContext;
43 class LayoutContext;
44 }
45
46 namespace Display {
47
48 class Box {
49     WTF_MAKE_ISO_ALLOCATED(Box);
50 public:
51     friend class Layout::FloatBox;
52     friend class Layout::BlockFormattingContext;
53     friend class Layout::FormattingContext;
54     friend class Layout::FloatingContext;
55     friend class Layout::LayoutContext;
56
57     Box(const Box&);
58
59     class Rect {
60     public:
61         Rect() = default;
62         Rect(LayoutUnit top, LayoutUnit left, LayoutUnit width, LayoutUnit height);
63         
64         LayoutUnit top() const;
65         LayoutUnit left() const;
66         LayoutPoint topLeft() const;
67
68         LayoutUnit bottom() const;
69         LayoutUnit right() const;        
70         LayoutPoint bottomRight() const;
71
72         LayoutUnit width() const;
73         LayoutUnit height() const;
74         LayoutSize size() const;
75
76         void setTop(LayoutUnit);
77         void setLeft(LayoutUnit);
78         void setTopLeft(const LayoutPoint&);
79         void setWidth(LayoutUnit);
80         void setHeight(LayoutUnit);
81         void setSize(const LayoutSize&);
82
83         void shiftLeftTo(LayoutUnit);
84         void shiftRightTo(LayoutUnit);
85         void shiftTopTo(LayoutUnit);
86         void shiftBottomTo(LayoutUnit);
87
88         void moveHorizontally(LayoutUnit);
89         void moveVertically(LayoutUnit);
90
91         void expand(LayoutUnit, LayoutUnit);
92         bool intersects(const Rect& rect) const { return m_rect.intersects(rect); }
93
94         Rect clone() const;
95         operator LayoutRect() const;
96
97     private:
98 #if !ASSERT_DISABLED
99         void invalidateTop() { m_hasValidTop = false; }
100         void invalidateLeft() { m_hasValidLeft = false; }
101         void invalidateWidth() { m_hasValidWidth = false; }
102         void invalidateHeight() { m_hasValidHeight = false; }
103         void invalidatePosition();
104
105         bool hasValidPosition() const { return m_hasValidTop && m_hasValidLeft; }
106         bool hasValidSize() const { return m_hasValidWidth && m_hasValidHeight; }
107         bool hasValidGeometry() const { return hasValidPosition() && hasValidSize(); }
108     
109         void setHasValidPosition();
110         void setHasValidSize();
111
112         bool m_hasValidTop { false };
113         bool m_hasValidLeft { false };
114         bool m_hasValidWidth { false };
115         bool m_hasValidHeight { false };
116 #endif
117         LayoutRect m_rect;
118     };
119
120     ~Box();
121
122     LayoutUnit top() const;
123     LayoutUnit left() const;
124     LayoutUnit bottom() const { return top() + height(); }
125     LayoutUnit right() const { return left() + width(); }
126
127     LayoutPoint topLeft() const;
128     LayoutPoint bottomRight() const { return { right(), bottom() }; }
129
130     LayoutSize size() const { return { width(), height() }; }
131     LayoutUnit width() const { return borderLeft() + paddingLeft().value_or(0) + contentBoxWidth() + paddingRight().value_or(0) + borderRight(); }
132     LayoutUnit height() const { return borderTop() + paddingTop().value_or(0) + contentBoxHeight() + paddingBottom().value_or(0) + borderBottom(); }
133     Rect rect() const { return { top(), left(), width(), height() }; }
134     Rect rectWithMargin() const { return { top() - marginTop(), left() - marginLeft(), marginLeft() + width() + marginRight(), marginTop() + height() + marginBottom() }; }
135
136     LayoutUnit marginTop() const;
137     LayoutUnit marginLeft() const;
138     LayoutUnit marginBottom() const;
139     LayoutUnit marginRight() const;
140
141     LayoutUnit nonCollapsedMarginTop() const;
142     LayoutUnit nonCollapsedMarginBottom() const;
143     std::optional<LayoutUnit> estimatedMarginTop() const { return m_estimatedMarginTop; }
144
145     LayoutUnit borderTop() const;
146     LayoutUnit borderLeft() const;
147     LayoutUnit borderBottom() const;
148     LayoutUnit borderRight() const;
149
150     std::optional<LayoutUnit> paddingTop() const;
151     std::optional<LayoutUnit> paddingLeft() const;
152     std::optional<LayoutUnit> paddingBottom() const;
153     std::optional<LayoutUnit> paddingRight() const;
154
155     LayoutUnit contentBoxTop() const { return borderTop() + paddingTop().value_or(0); }
156     LayoutUnit contentBoxLeft() const { return borderLeft() + paddingLeft().value_or(0); }
157     LayoutUnit contentBoxBottom() const { return contentBoxTop() + contentBoxHeight(); }
158     LayoutUnit contentBoxRight() const { return contentBoxLeft() + contentBoxWidth(); }
159     LayoutUnit contentBoxHeight() const;
160     LayoutUnit contentBoxWidth() const;
161
162     Rect marginBox() const;
163     Rect nonCollapsedMarginBox() const;
164
165     Rect borderBox() const;
166     Rect paddingBox() const;
167     Rect contentBox() const;
168
169 private:
170     Box(const RenderStyle&);
171
172     struct Style {
173         Style(const RenderStyle&);
174
175         BoxSizing boxSizing { BoxSizing::ContentBox };
176     };
177
178     void setTopLeft(const LayoutPoint&);
179     void setTop(LayoutUnit);
180     void setLeft(LayoutUnit);
181     void moveHorizontally(LayoutUnit offset) { m_topLeft.move(offset, { }); }
182     void moveVertically(LayoutUnit offset) { m_topLeft.move({ }, offset); }
183
184     void setContentBoxHeight(LayoutUnit);
185     void setContentBoxWidth(LayoutUnit);
186
187     void setHorizontalMargin(Layout::HorizontalEdges);
188     void setVerticalMargin(Layout::VerticalEdges);
189     void setVerticalNonCollapsedMargin(Layout::VerticalEdges);
190     void setEstimatedMarginTop(LayoutUnit marginTop) { m_estimatedMarginTop = marginTop; }
191
192     void setBorder(Layout::Edges);
193     void setPadding(std::optional<Layout::Edges>);
194
195 #if !ASSERT_DISABLED
196     void invalidateMargin();
197     void invalidateBorder() { m_hasValidBorder = false; }
198     void invalidatePadding() { m_hasValidPadding = false; }
199
200     void setHasValidTop() { m_hasValidTop = true; }
201     void setHasValidLeft() { m_hasValidLeft = true; }
202     void setHasValidVerticalMargin() { m_hasValidVerticalMargin = true; }
203     void setHasValidVerticalNonCollapsedMargin() { m_hasValidVerticalNonCollapsedMargin = true; }
204     void setHasValidHorizontalMargin() { m_hasValidHorizontalMargin = true; }
205
206     void setHasValidBorder() { m_hasValidBorder = true; }
207     void setHasValidPadding() { m_hasValidPadding = true; }
208
209     void setHasValidContentHeight() { m_hasValidContentHeight = true; }
210     void setHasValidContentWidth() { m_hasValidContentWidth = true; }
211 #endif
212
213     const Style m_style;
214
215     LayoutPoint m_topLeft;
216     LayoutUnit m_contentWidth;
217     LayoutUnit m_contentHeight;
218
219     Layout::Edges m_margin;
220     Layout::VerticalEdges m_verticalNonCollapsedMargin;
221     std::optional<LayoutUnit> m_estimatedMarginTop;
222
223     Layout::Edges m_border;
224     std::optional<Layout::Edges> m_padding;
225
226 #if !ASSERT_DISABLED
227     bool m_hasValidTop { false };
228     bool m_hasValidLeft { false };
229     bool m_hasValidHorizontalMargin { false };
230     bool m_hasValidVerticalMargin { false };
231     bool m_hasValidVerticalNonCollapsedMargin { false };
232     bool m_hasValidBorder { false };
233     bool m_hasValidPadding { false };
234     bool m_hasValidContentHeight { false };
235     bool m_hasValidContentWidth { false };
236 #endif
237 };
238
239 #if !ASSERT_DISABLED
240 inline void Box::Rect::invalidatePosition()
241 {
242     invalidateTop();
243     invalidateLeft();
244 }
245
246 inline void Box::Rect::setHasValidPosition()
247 {
248     m_hasValidTop = true;
249     m_hasValidLeft = true;
250 }
251
252 inline void Box::Rect::setHasValidSize()
253 {
254     m_hasValidWidth = true;
255     m_hasValidHeight = true;
256 }
257
258 inline void Box::invalidateMargin()
259 {
260     m_hasValidHorizontalMargin = false;
261     m_hasValidVerticalMargin = false;
262 }
263 #endif
264
265 inline LayoutUnit Box::Rect::top() const
266 {
267     ASSERT(m_hasValidTop);
268     return m_rect.y();
269 }
270
271 inline LayoutUnit Box::Rect::left() const
272 {
273     ASSERT(m_hasValidLeft);
274     return m_rect.x();
275 }
276
277 inline LayoutUnit Box::Rect::bottom() const
278 {
279     ASSERT(m_hasValidTop && m_hasValidHeight);
280     return m_rect.maxY();
281 }
282
283 inline LayoutUnit Box::Rect::right() const
284 {
285     ASSERT(m_hasValidLeft && m_hasValidWidth);
286     return m_rect.maxX();
287 }
288
289 inline LayoutPoint Box::Rect::topLeft() const
290 {
291     ASSERT(hasValidPosition());
292     return m_rect.minXMinYCorner();
293 }
294
295 inline LayoutPoint Box::Rect::bottomRight() const
296 {
297     ASSERT(hasValidGeometry());
298     return m_rect.maxXMaxYCorner();
299 }
300
301 inline LayoutSize Box::Rect::size() const
302 {
303     ASSERT(hasValidSize());
304     return m_rect.size();
305 }
306
307 inline LayoutUnit Box::Rect::width() const
308 {
309     ASSERT(m_hasValidWidth);
310     return m_rect.width();
311 }
312
313 inline LayoutUnit Box::Rect::height() const
314 {
315     ASSERT(m_hasValidHeight);
316     return m_rect.height();
317 }
318
319 inline void Box::Rect::setTopLeft(const LayoutPoint& topLeft)
320 {
321 #if !ASSERT_DISABLED
322     setHasValidPosition();
323 #endif
324     m_rect.setLocation(topLeft);
325 }
326
327 inline void Box::Rect::setTop(LayoutUnit top)
328 {
329 #if !ASSERT_DISABLED
330     m_hasValidTop = true;
331 #endif
332     m_rect.setY(top);
333 }
334
335 inline void Box::Rect::setLeft(LayoutUnit left)
336 {
337 #if !ASSERT_DISABLED
338     m_hasValidLeft = true;
339 #endif
340     m_rect.setX(left);
341 }
342
343 inline void Box::Rect::setWidth(LayoutUnit width)
344 {
345 #if !ASSERT_DISABLED
346     m_hasValidWidth = true;
347 #endif
348     m_rect.setWidth(width);
349 }
350
351 inline void Box::Rect::setHeight(LayoutUnit height)
352 {
353 #if !ASSERT_DISABLED
354     m_hasValidHeight = true;
355 #endif
356     m_rect.setHeight(height);
357 }
358
359 inline void Box::Rect::setSize(const LayoutSize& size)
360 {
361 #if !ASSERT_DISABLED
362     setHasValidSize();
363 #endif
364     m_rect.setSize(size);
365 }
366
367 inline void Box::Rect::shiftLeftTo(LayoutUnit left)
368 {
369     ASSERT(m_hasValidLeft);
370     m_rect.shiftXEdgeTo(left);
371 }
372
373 inline void Box::Rect::shiftRightTo(LayoutUnit right)
374 {
375     ASSERT(m_hasValidLeft && m_hasValidWidth);
376     m_rect.shiftMaxXEdgeTo(right);
377 }
378
379 inline void Box::Rect::shiftTopTo(LayoutUnit top)
380 {
381     ASSERT(m_hasValidTop);
382     m_rect.shiftYEdgeTo(top);
383 }
384
385 inline void Box::Rect::shiftBottomTo(LayoutUnit bottom)
386 {
387     ASSERT(m_hasValidTop && m_hasValidHeight);
388     m_rect.shiftMaxYEdgeTo(bottom);
389 }
390
391 inline void Box::Rect::moveHorizontally(LayoutUnit offset)
392 {
393     ASSERT(m_hasValidLeft);
394     m_rect.move(offset, { });
395 }
396
397 inline void Box::Rect::moveVertically(LayoutUnit offset)
398 {
399     ASSERT(m_hasValidTop);
400     m_rect.move({ }, offset);
401 }
402
403 inline void Box::Rect::expand(LayoutUnit width, LayoutUnit height)
404 {
405     ASSERT(hasValidGeometry());
406     m_rect.expand(width, height);
407 }
408
409 inline Box::Rect Box::Rect::clone() const
410 {
411     Rect rect;
412 #if !ASSERT_DISABLED
413     rect.m_hasValidTop = m_hasValidTop;
414     rect.m_hasValidLeft = m_hasValidLeft;
415     rect.m_hasValidWidth = m_hasValidWidth;
416     rect.m_hasValidHeight  = m_hasValidHeight;
417 #endif 
418     rect.m_rect = m_rect;
419     return rect;
420 }
421
422 inline Box::Rect::operator LayoutRect() const
423 {
424     ASSERT(hasValidGeometry()); 
425     return m_rect;
426 }
427
428 inline LayoutUnit Box::top() const
429 {
430     ASSERT(m_hasValidTop && (m_estimatedMarginTop || m_hasValidVerticalMargin));
431     return m_topLeft.y();
432 }
433
434 inline LayoutUnit Box::left() const
435 {
436     ASSERT(m_hasValidLeft && m_hasValidHorizontalMargin);
437     return m_topLeft.x();
438 }
439
440 inline LayoutPoint Box::topLeft() const
441 {
442     ASSERT(m_hasValidTop && (m_estimatedMarginTop || m_hasValidVerticalMargin));
443     ASSERT(m_hasValidLeft && m_hasValidHorizontalMargin);
444     return m_topLeft;
445 }
446
447 inline void Box::setTopLeft(const LayoutPoint& topLeft)
448 {
449 #if !ASSERT_DISABLED
450     setHasValidTop();
451     setHasValidLeft();
452 #endif
453     m_topLeft = topLeft;
454 }
455
456 inline void Box::setTop(LayoutUnit top)
457 {
458 #if !ASSERT_DISABLED
459     setHasValidTop();
460 #endif
461     m_topLeft.setY(top);
462 }
463
464 inline void Box::setLeft(LayoutUnit left)
465 {
466 #if !ASSERT_DISABLED
467     setHasValidLeft();
468 #endif
469     m_topLeft.setX(left);
470 }
471
472 inline void Box::setContentBoxHeight(LayoutUnit height)
473
474 #if !ASSERT_DISABLED
475     setHasValidContentHeight();
476 #endif
477     m_contentHeight = height;
478 }
479
480 inline void Box::setContentBoxWidth(LayoutUnit width)
481
482 #if !ASSERT_DISABLED
483     setHasValidContentWidth();
484 #endif
485     m_contentWidth = width;
486 }
487
488 inline LayoutUnit Box::contentBoxHeight() const
489 {
490     ASSERT(m_hasValidContentHeight);
491     return m_contentHeight;
492 }
493
494 inline LayoutUnit Box::contentBoxWidth() const
495 {
496     ASSERT(m_hasValidContentWidth);
497     return m_contentWidth;
498 }
499
500 inline void Box::setHorizontalMargin(Layout::HorizontalEdges margin)
501 {
502 #if !ASSERT_DISABLED
503     setHasValidHorizontalMargin();
504 #endif
505     m_margin.horizontal = margin;
506 }
507
508 inline void Box::setVerticalMargin(Layout::VerticalEdges margin)
509 {
510 #if !ASSERT_DISABLED
511     setHasValidVerticalMargin();
512 #endif
513     ASSERT(!m_estimatedMarginTop || *m_estimatedMarginTop == margin.top);
514     m_margin.vertical = margin;
515 }
516
517 inline void Box::setVerticalNonCollapsedMargin(Layout::VerticalEdges margin)
518 {
519 #if !ASSERT_DISABLED
520     setHasValidVerticalNonCollapsedMargin();
521 #endif
522     m_verticalNonCollapsedMargin = margin;
523 }
524
525 inline void Box::setBorder(Layout::Edges border)
526 {
527 #if !ASSERT_DISABLED
528     setHasValidBorder();
529 #endif
530     m_border = border;
531 }
532
533 inline void Box::setPadding(std::optional<Layout::Edges> padding)
534 {
535 #if !ASSERT_DISABLED
536     setHasValidPadding();
537 #endif
538     m_padding = padding;
539 }
540
541 inline LayoutUnit Box::marginTop() const
542 {
543     ASSERT(m_hasValidVerticalMargin);
544     return m_margin.vertical.top;
545 }
546
547 inline LayoutUnit Box::marginLeft() const
548 {
549     ASSERT(m_hasValidHorizontalMargin);
550     return m_margin.horizontal.left;
551 }
552
553 inline LayoutUnit Box::marginBottom() const
554 {
555     ASSERT(m_hasValidVerticalMargin);
556     return m_margin.vertical.bottom;
557 }
558
559 inline LayoutUnit Box::marginRight() const
560 {
561     ASSERT(m_hasValidHorizontalMargin);
562     return m_margin.horizontal.right;
563 }
564
565 inline LayoutUnit Box::nonCollapsedMarginTop() const
566 {
567     ASSERT(m_hasValidVerticalNonCollapsedMargin);
568     return m_verticalNonCollapsedMargin.top;
569 }
570
571 inline LayoutUnit Box::nonCollapsedMarginBottom() const
572 {
573     ASSERT(m_hasValidVerticalNonCollapsedMargin);
574     return m_verticalNonCollapsedMargin.bottom;
575 }
576
577 inline std::optional<LayoutUnit> Box::paddingTop() const
578 {
579     ASSERT(m_hasValidPadding);
580     if (!m_padding)
581         return { };
582     return m_padding->vertical.top;
583 }
584
585 inline std::optional<LayoutUnit> Box::paddingLeft() const
586 {
587     ASSERT(m_hasValidPadding);
588     if (!m_padding)
589         return { };
590     return m_padding->horizontal.left;
591 }
592
593 inline std::optional<LayoutUnit> Box::paddingBottom() const
594 {
595     ASSERT(m_hasValidPadding);
596     if (!m_padding)
597         return { };
598     return m_padding->vertical.bottom;
599 }
600
601 inline std::optional<LayoutUnit> Box::paddingRight() const
602 {
603     ASSERT(m_hasValidPadding);
604     if (!m_padding)
605         return { };
606     return m_padding->horizontal.right;
607 }
608
609 inline LayoutUnit Box::borderTop() const
610 {
611     ASSERT(m_hasValidBorder);
612     return m_border.vertical.top;
613 }
614
615 inline LayoutUnit Box::borderLeft() const
616 {
617     ASSERT(m_hasValidBorder);
618     return m_border.horizontal.left;
619 }
620
621 inline LayoutUnit Box::borderBottom() const
622 {
623     ASSERT(m_hasValidBorder);
624     return m_border.vertical.bottom;
625 }
626
627 inline LayoutUnit Box::borderRight() const
628 {
629     ASSERT(m_hasValidBorder);
630     return m_border.horizontal.right;
631 }
632
633 }
634 }
635 #endif