1use std::collections::VecDeque;
10use std::fmt::Debug;
11use std::mem;
12use std::ops::Range;
13
14use app_units::{Au, MAX_AU, MIN_AU};
15use euclid::num::Zero;
16use malloc_size_of_derive::MallocSizeOf;
17use servo_arc::Arc;
18use style::computed_values::float::T as FloatProperty;
19use style::computed_values::position::T as Position;
20use style::logical_geometry::WritingMode;
21use style::properties::ComputedValues;
22use style::values::computed::Clear as StyleClear;
23
24use crate::PropagatedBoxTreeData;
25use crate::containing_block::ContainingBlock;
26use crate::context::LayoutContext;
27use crate::dom_traversal::{Contents, NodeAndStyleInfo};
28use crate::formatting_contexts::IndependentFormattingContext;
29use crate::fragment_tree::{BoxFragment, CollapsedMargin};
30use crate::geom::{LogicalRect, LogicalSides, LogicalVec2};
31use crate::positioned::{PositioningContext, relative_adjustement};
32use crate::style_ext::{DisplayInside, PaddingBorderMargin};
33
34#[derive(Debug, MallocSizeOf)]
36pub(crate) struct FloatBox {
37 pub contents: IndependentFormattingContext,
39}
40
41#[derive(Clone, Copy, Debug)]
46pub struct ContainingBlockPositionInfo {
47 pub(crate) block_start: Au,
53 pub(crate) block_start_margins_not_collapsed: CollapsedMargin,
57 pub inline_start: Au,
61 pub inline_end: Au,
65}
66
67impl ContainingBlockPositionInfo {
68 pub fn new_with_inline_offsets(inline_start: Au, inline_end: Au) -> Self {
69 Self {
70 block_start: Au::zero(),
71 block_start_margins_not_collapsed: CollapsedMargin::zero(),
72 inline_start,
73 inline_end,
74 }
75 }
76}
77
78pub(crate) struct PlacementAmongFloats<'a> {
82 float_context: &'a FloatContext,
84 current_bands: VecDeque<FloatBand>,
86 next_band: FloatBand,
88 object_size: LogicalVec2<Au>,
90 ceiling: Au,
93 min_inline_start: Au,
96 max_inline_end: Au,
98}
99
100impl<'a> PlacementAmongFloats<'a> {
101 pub(crate) fn new(
102 float_context: &'a FloatContext,
103 ceiling: Au,
104 object_size: LogicalVec2<Au>,
105 pbm: &PaddingBorderMargin,
106 ) -> Self {
107 let mut ceiling_band = float_context.bands.find(ceiling).unwrap();
108 let (current_bands, next_band) = if ceiling == MAX_AU {
109 (VecDeque::new(), ceiling_band)
110 } else {
111 ceiling_band.top = ceiling;
112 let current_bands = VecDeque::from([ceiling_band]);
113 let next_band = float_context.bands.find_next(ceiling).unwrap();
114 (current_bands, next_band)
115 };
116 let min_inline_start = float_context.containing_block_info.inline_start +
117 pbm.margin.inline_start.auto_is(Au::zero);
118 let max_inline_end = (float_context.containing_block_info.inline_end -
119 pbm.margin.inline_end.auto_is(Au::zero))
120 .max(min_inline_start + object_size.inline);
121 PlacementAmongFloats {
122 float_context,
123 current_bands,
124 next_band,
125 object_size,
126 ceiling,
127 min_inline_start,
128 max_inline_end,
129 }
130 }
131
132 fn top_of_bands(&self) -> Option<Au> {
136 self.current_bands.front().map(|band| band.top)
137 }
138
139 fn current_bands_height(&self) -> Au {
141 if self.next_band.top == MAX_AU {
142 MAX_AU
144 } else {
145 let top = self
146 .top_of_bands()
147 .expect("Should have bands before reaching the end");
148 self.next_band.top - top
149 }
150 }
151
152 fn add_one_band(&mut self) {
155 assert!(self.next_band.top != MAX_AU);
156 self.current_bands.push_back(self.next_band);
157 self.next_band = self
158 .float_context
159 .bands
160 .find_next(self.next_band.top)
161 .unwrap();
162 }
163
164 fn accumulate_enough_bands_for_block_size(&mut self) {
167 while self.current_bands_height() < self.object_size.block {
168 self.add_one_band();
169 }
170 }
171
172 fn calculate_inline_start_and_end(&self) -> (Au, Au) {
175 let mut max_inline_start = self.min_inline_start;
176 let mut min_inline_end = self.max_inline_end;
177 for band in self.current_bands.iter() {
178 if let Some(inline_start) = band.inline_start {
179 max_inline_start.max_assign(inline_start);
180 }
181 if let Some(inline_end) = band.inline_end {
182 min_inline_end.min_assign(inline_end);
183 }
184 }
185 (max_inline_start, min_inline_end)
186 }
187
188 fn calculate_viable_inline_size(&self) -> Au {
190 let (inline_start, inline_end) = self.calculate_inline_start_and_end();
191 inline_end - inline_start
192 }
193
194 fn try_place_once(&mut self) -> Option<LogicalRect<Au>> {
195 assert!(!self.current_bands.is_empty());
196 self.accumulate_enough_bands_for_block_size();
197 let (inline_start, inline_end) = self.calculate_inline_start_and_end();
198 let available_inline_size = inline_end - inline_start;
199 if available_inline_size < self.object_size.inline {
200 return None;
201 }
202 Some(LogicalRect {
203 start_corner: LogicalVec2 {
204 inline: inline_start,
205 block: self.top_of_bands().unwrap(),
206 },
207 size: LogicalVec2 {
208 inline: available_inline_size,
209 block: self.current_bands_height(),
210 },
211 })
212 }
213
214 fn has_bands_or_at_end(&self) -> bool {
217 !self.current_bands.is_empty() || self.next_band.top == MAX_AU
218 }
219
220 fn pop_front_band_ensuring_has_bands_or_at_end(&mut self) {
221 self.current_bands.pop_front();
222 if !self.has_bands_or_at_end() {
223 self.add_one_band();
224 }
225 }
226
227 pub(crate) fn place(&mut self) -> LogicalRect<Au> {
229 debug_assert!(self.has_bands_or_at_end());
230 while !self.current_bands.is_empty() {
231 if let Some(result) = self.try_place_once() {
232 return result;
233 }
234 self.pop_front_band_ensuring_has_bands_or_at_end();
235 }
236 debug_assert!(self.has_bands_or_at_end());
237
238 LogicalRect {
241 start_corner: LogicalVec2 {
242 inline: self.min_inline_start,
243 block: self
244 .ceiling
245 .max(self.float_context.clear_inline_start_position)
246 .max(self.float_context.clear_inline_end_position),
247 },
248 size: LogicalVec2 {
249 inline: self.max_inline_end - self.min_inline_start,
250 block: MAX_AU,
251 },
252 }
253 }
254
255 pub(crate) fn try_to_expand_for_auto_block_size(
262 &mut self,
263 block_size_after_layout: Au,
264 size_from_placement: &LogicalVec2<Au>,
265 ) -> bool {
266 debug_assert!(self.has_bands_or_at_end());
267 debug_assert_eq!(size_from_placement.block, self.current_bands_height());
268 debug_assert_eq!(
269 size_from_placement.inline,
270 self.calculate_viable_inline_size()
271 );
272
273 if block_size_after_layout <= size_from_placement.block {
276 return true;
277 }
278
279 let old_num_bands = self.current_bands.len();
282 assert!(old_num_bands > 0);
283 while self.current_bands_height() < block_size_after_layout {
284 self.add_one_band();
285
286 let available_inline_size = self.calculate_viable_inline_size();
291 if available_inline_size < size_from_placement.inline {
292 if available_inline_size < self.object_size.inline {
296 self.next_band = self.current_bands[old_num_bands];
297 self.current_bands.truncate(old_num_bands);
298 self.pop_front_band_ensuring_has_bands_or_at_end();
299 }
300 return false;
301 }
302 }
303 true
304 }
305}
306
307#[derive(Clone, Debug)]
312pub struct FloatContext {
313 pub bands: FloatBandTree,
318 pub ceiling_from_floats: Au,
321 pub ceiling_from_non_floats: Au,
325 pub containing_block_info: ContainingBlockPositionInfo,
329 pub clear_inline_start_position: Au,
331 pub clear_inline_end_position: Au,
333}
334
335impl FloatContext {
336 pub fn new(max_inline_size: Au) -> Self {
339 let mut bands = FloatBandTree::new();
340 bands = bands.insert(FloatBand {
341 top: MIN_AU,
342 inline_start: None,
343 inline_end: None,
344 });
345 bands = bands.insert(FloatBand {
346 top: MAX_AU,
347 inline_start: None,
348 inline_end: None,
349 });
350 FloatContext {
351 bands,
352 ceiling_from_floats: Au::zero(),
353 ceiling_from_non_floats: Au::zero(),
354 containing_block_info: ContainingBlockPositionInfo::new_with_inline_offsets(
355 Au::zero(),
356 max_inline_size,
357 ),
358 clear_inline_start_position: Au::zero(),
359 clear_inline_end_position: Au::zero(),
360 }
361 }
362
363 pub fn set_ceiling_from_non_floats(&mut self, new_ceiling: Au) {
367 self.ceiling_from_non_floats = new_ceiling;
368 }
369
370 fn ceiling(&mut self) -> Au {
373 self.ceiling_from_floats.max(self.ceiling_from_non_floats)
374 }
375
376 pub(crate) fn place_object(&self, object: &PlacementInfo, ceiling: Au) -> LogicalVec2<Au> {
382 let ceiling = match object.clear {
383 Clear::None => ceiling,
384 Clear::InlineStart => ceiling.max(self.clear_inline_start_position),
385 Clear::InlineEnd => ceiling.max(self.clear_inline_end_position),
386 Clear::Both => ceiling
387 .max(self.clear_inline_start_position)
388 .max(self.clear_inline_end_position),
389 };
390
391 let mut first_band = self.bands.find(ceiling).unwrap();
393 while !first_band.object_fits(object, &self.containing_block_info) {
394 let next_band = self.bands.find_next(first_band.top).unwrap();
395 if next_band.top == MAX_AU {
396 break;
397 }
398 first_band = next_band;
399 }
400
401 match object.side {
403 FloatSide::InlineStart => {
404 let inline_start_object_edge = match first_band.inline_start {
405 Some(inline_start) => inline_start.max(self.containing_block_info.inline_start),
406 None => self.containing_block_info.inline_start,
407 };
408 LogicalVec2 {
409 inline: inline_start_object_edge,
410 block: first_band.top.max(ceiling),
411 }
412 },
413 FloatSide::InlineEnd => {
414 let inline_end_object_edge = match first_band.inline_end {
415 Some(inline_end) => inline_end.min(self.containing_block_info.inline_end),
416 None => self.containing_block_info.inline_end,
417 };
418 LogicalVec2 {
419 inline: inline_end_object_edge - object.size.inline,
420 block: first_band.top.max(ceiling),
421 }
422 },
423 }
424 }
425
426 pub fn add_float(&mut self, new_float: &PlacementInfo) -> LogicalVec2<Au> {
428 let ceiling = self.ceiling();
430 let new_float_origin = self.place_object(new_float, ceiling);
431 let new_float_extent = match new_float.side {
432 FloatSide::InlineStart => new_float_origin.inline + new_float.size.inline,
433 FloatSide::InlineEnd => new_float_origin.inline,
434 };
435
436 let new_float_rect = LogicalRect {
437 start_corner: new_float_origin,
438 size: LogicalVec2 {
443 inline: new_float.size.inline.max(Au::zero()),
444 block: new_float.size.block.max(Au::zero()),
445 },
446 };
447
448 match new_float.side {
450 FloatSide::InlineStart => {
451 self.clear_inline_start_position
452 .max_assign(new_float_rect.max_block_position());
453 },
454 FloatSide::InlineEnd => {
455 self.clear_inline_end_position
456 .max_assign(new_float_rect.max_block_position());
457 },
458 }
459
460 let mut first_band = self.bands.find(new_float_rect.start_corner.block).unwrap();
462 first_band.top = new_float_rect.start_corner.block;
463 self.bands = self.bands.insert(first_band);
464
465 let mut last_band = self
467 .bands
468 .find(new_float_rect.max_block_position())
469 .unwrap();
470 last_band.top = new_float_rect.max_block_position();
471 self.bands = self.bands.insert(last_band);
472
473 let block_range = new_float_rect.start_corner.block..new_float_rect.max_block_position();
475 self.bands = self
476 .bands
477 .set_range(&block_range, new_float.side, new_float_extent);
478
479 self.ceiling_from_floats
482 .max_assign(new_float_rect.start_corner.block);
483
484 new_float_rect.start_corner
485 }
486}
487
488#[derive(Clone, Copy, Debug, PartialEq)]
489pub enum Clear {
490 None,
491 InlineStart,
492 InlineEnd,
493 Both,
494}
495
496impl Clear {
497 pub(crate) fn from_style_and_container_writing_mode(
498 style: &ComputedValues,
499 container_writing_mode: WritingMode,
500 ) -> Self {
501 match style.get_box().clear {
502 StyleClear::None => Self::None,
503 StyleClear::Both => Self::Both,
504 StyleClear::InlineStart => Self::InlineStart,
505 StyleClear::InlineEnd => Self::InlineEnd,
506 StyleClear::Left if container_writing_mode.is_bidi_ltr() => Self::InlineStart,
507 StyleClear::Left => Self::InlineEnd,
508 StyleClear::Right if container_writing_mode.is_bidi_ltr() => Self::InlineEnd,
509 StyleClear::Right => Self::InlineStart,
510 }
511 }
512}
513
514#[derive(Clone, Debug)]
516pub struct PlacementInfo {
517 pub size: LogicalVec2<Au>,
519 pub side: FloatSide,
521 pub clear: Clear,
523}
524
525#[derive(Clone, Copy, Debug, PartialEq)]
529pub enum FloatSide {
530 InlineStart,
531 InlineEnd,
532}
533
534#[derive(Clone, Copy, Debug, PartialEq)]
537pub struct FloatBand {
538 pub top: Au,
540 pub inline_start: Option<Au>,
545 pub inline_end: Option<Au>,
550}
551
552impl FloatSide {
553 pub(crate) fn from_style_and_container_writing_mode(
554 style: &ComputedValues,
555 container_writing_mode: WritingMode,
556 ) -> Option<FloatSide> {
557 Some(match style.get_box().float {
558 FloatProperty::None => return None,
559 FloatProperty::InlineStart => Self::InlineStart,
560 FloatProperty::InlineEnd => Self::InlineEnd,
561 FloatProperty::Left if container_writing_mode.is_bidi_ltr() => Self::InlineStart,
562 FloatProperty::Left => Self::InlineEnd,
563 FloatProperty::Right if container_writing_mode.is_bidi_ltr() => Self::InlineEnd,
564 FloatProperty::Right => Self::InlineStart,
565 })
566 }
567}
568
569impl FloatBand {
570 fn object_fits(&self, object: &PlacementInfo, walls: &ContainingBlockPositionInfo) -> bool {
572 match object.side {
573 FloatSide::InlineStart => {
574 let candidate_inline_start = match self.inline_start {
576 None => walls.inline_start,
577 Some(inline_start) => inline_start.max(walls.inline_start),
578 };
579
580 if self.inline_start.is_some() &&
583 candidate_inline_start + object.size.inline > walls.inline_end
584 {
585 return false;
586 }
587
588 match self.inline_end {
591 None => true,
592 Some(inline_end) => object.size.inline <= inline_end - candidate_inline_start,
593 }
594 },
595
596 FloatSide::InlineEnd => {
597 let candidate_inline_end = match self.inline_end {
599 None => walls.inline_end,
600 Some(inline_end) => inline_end.min(walls.inline_end),
601 };
602
603 if self.inline_end.is_some() &&
606 candidate_inline_end - object.size.inline < walls.inline_start
607 {
608 return false;
609 }
610
611 match self.inline_start {
614 None => true,
615 Some(inline_start) => object.size.inline <= candidate_inline_end - inline_start,
616 }
617 },
618 }
619 }
620}
621
622#[derive(Clone, Debug)]
634pub struct FloatBandTree {
635 pub root: FloatBandLink,
636}
637
638#[derive(Clone, Debug)]
640pub struct FloatBandLink(pub Option<Arc<FloatBandNode>>);
641
642#[derive(Clone, Debug)]
644pub struct FloatBandNode {
645 pub band: FloatBand,
647 pub left: FloatBandLink,
649 pub right: FloatBandLink,
651 pub level: i32,
655}
656
657impl FloatBandTree {
658 pub fn new() -> FloatBandTree {
660 FloatBandTree {
661 root: FloatBandLink(None),
662 }
663 }
664
665 pub fn find(&self, block_position: Au) -> Option<FloatBand> {
667 self.root.find(block_position)
668 }
669
670 pub fn find_next(&self, block_position: Au) -> Option<FloatBand> {
672 self.root.find_next(block_position)
673 }
674
675 #[must_use]
678 pub fn set_range(&self, range: &Range<Au>, side: FloatSide, new_value: Au) -> FloatBandTree {
679 FloatBandTree {
680 root: FloatBandLink(
681 self.root
682 .0
683 .as_ref()
684 .map(|root| root.set_range(range, side, new_value)),
685 ),
686 }
687 }
688
689 #[must_use]
692 pub fn insert(&self, band: FloatBand) -> FloatBandTree {
693 FloatBandTree {
694 root: self.root.insert(band),
695 }
696 }
697}
698
699impl Default for FloatBandTree {
700 fn default() -> Self {
701 Self::new()
702 }
703}
704
705impl FloatBandNode {
706 fn new(band: FloatBand) -> FloatBandNode {
707 FloatBandNode {
708 band,
709 left: FloatBandLink(None),
710 right: FloatBandLink(None),
711 level: 1,
712 }
713 }
714
715 fn set_range(&self, range: &Range<Au>, side: FloatSide, new_value: Au) -> Arc<FloatBandNode> {
718 let mut new_band = self.band;
719 if self.band.top >= range.start && self.band.top < range.end {
720 match side {
721 FloatSide::InlineStart => {
722 new_band.inline_start = match new_band.inline_start {
723 Some(old_value) => Some(std::cmp::max(old_value, new_value)),
724 None => Some(new_value),
725 };
726 },
727 FloatSide::InlineEnd => {
728 new_band.inline_end = match new_band.inline_end {
729 Some(old_value) => Some(std::cmp::min(old_value, new_value)),
730 None => Some(new_value),
731 };
732 },
733 }
734 }
735
736 let new_left = match self.left.0 {
737 None => FloatBandLink(None),
738 Some(ref old_left) if range.start < new_band.top => {
739 FloatBandLink(Some(old_left.set_range(range, side, new_value)))
740 },
741 Some(ref old_left) => FloatBandLink(Some((*old_left).clone())),
742 };
743
744 let new_right = match self.right.0 {
745 None => FloatBandLink(None),
746 Some(ref old_right) if range.end > new_band.top => {
747 FloatBandLink(Some(old_right.set_range(range, side, new_value)))
748 },
749 Some(ref old_right) => FloatBandLink(Some((*old_right).clone())),
750 };
751
752 Arc::new(FloatBandNode {
753 band: new_band,
754 left: new_left,
755 right: new_right,
756 level: self.level,
757 })
758 }
759}
760
761impl FloatBandLink {
762 fn find(&self, block_position: Au) -> Option<FloatBand> {
764 let this = self.0.as_ref()?;
765
766 if block_position < this.band.top {
767 return this.left.find(block_position);
768 }
769
770 if let Some(band) = this.right.find(block_position) {
773 return Some(band);
774 }
775
776 Some(this.band)
777 }
778
779 fn find_next(&self, block_position: Au) -> Option<FloatBand> {
781 let this = self.0.as_ref()?;
782
783 if block_position >= this.band.top {
784 return this.right.find_next(block_position);
785 }
786
787 if let Some(band) = this.left.find_next(block_position) {
790 return Some(band);
791 }
792
793 Some(this.band)
794 }
795
796 fn insert(&self, band: FloatBand) -> FloatBandLink {
799 let mut this = match self.0 {
800 None => return FloatBandLink(Some(Arc::new(FloatBandNode::new(band)))),
801 Some(ref this) => (**this).clone(),
802 };
803
804 if band.top < this.band.top {
805 this.left = this.left.insert(band);
806 return FloatBandLink(Some(Arc::new(this))).skew().split();
807 }
808 if band.top > this.band.top {
809 this.right = this.right.insert(band);
810 return FloatBandLink(Some(Arc::new(this))).skew().split();
811 }
812
813 this.band = band;
814 FloatBandLink(Some(Arc::new(this)))
815 }
816
817 fn skew(&self) -> FloatBandLink {
826 if let Some(ref this) = self.0 &&
827 let Some(ref left) = this.left.0 &&
828 this.level == left.level
829 {
830 return FloatBandLink(Some(Arc::new(FloatBandNode {
831 level: this.level,
832 left: left.left.clone(),
833 band: left.band,
834 right: FloatBandLink(Some(Arc::new(FloatBandNode {
835 level: this.level,
836 left: left.right.clone(),
837 band: this.band,
838 right: this.right.clone(),
839 }))),
840 })));
841 }
842
843 (*self).clone()
844 }
845
846 fn split(&self) -> FloatBandLink {
855 if let Some(ref this) = self.0 &&
856 let Some(ref right) = this.right.0 &&
857 let Some(ref right_right) = right.right.0 &&
858 this.level == right_right.level
859 {
860 return FloatBandLink(Some(Arc::new(FloatBandNode {
861 level: this.level + 1,
862 left: FloatBandLink(Some(Arc::new(FloatBandNode {
863 level: this.level,
864 left: this.left.clone(),
865 band: this.band,
866 right: right.left.clone(),
867 }))),
868 band: right.band,
869 right: right.right.clone(),
870 })));
871 }
872
873 (*self).clone()
874 }
875}
876
877impl FloatBox {
878 pub fn construct(
880 context: &LayoutContext,
881 info: &NodeAndStyleInfo<'_>,
882 display_inside: DisplayInside,
883 contents: Contents,
884 propagated_data: PropagatedBoxTreeData,
885 ) -> Self {
886 Self {
887 contents: IndependentFormattingContext::construct(
888 context,
889 info,
890 display_inside,
891 contents,
892 propagated_data,
893 ),
894 }
895 }
896
897 pub fn layout(
901 &self,
902 layout_context: &LayoutContext,
903 positioning_context: &mut PositioningContext,
904 containing_block: &ContainingBlock,
905 ) -> BoxFragment {
906 positioning_context.layout_maybe_position_relative_fragment(
907 layout_context,
908 containing_block,
909 &self.contents.base,
910 |positioning_context| {
911 self.contents
912 .layout_float_or_atomic_inline(
913 layout_context,
914 positioning_context,
915 containing_block,
916 )
917 .fragment
918 },
919 )
920 }
921}
922
923#[derive(Clone)]
934pub(crate) struct SequentialLayoutState {
935 pub(crate) floats: FloatContext,
937 pub(crate) bfc_relative_block_position: Au,
944 pub(crate) current_margin: CollapsedMargin,
946}
947
948impl SequentialLayoutState {
949 pub(crate) fn new(max_inline_size: Au) -> SequentialLayoutState {
951 SequentialLayoutState {
952 floats: FloatContext::new(max_inline_size),
953 current_margin: CollapsedMargin::zero(),
954 bfc_relative_block_position: Au::zero(),
955 }
956 }
957
958 pub(crate) fn advance_block_position(&mut self, block_distance: Au) {
965 self.bfc_relative_block_position += block_distance;
966 self.floats
967 .set_ceiling_from_non_floats(self.bfc_relative_block_position);
968 }
969
970 pub(crate) fn replace_containing_block_position_info(
973 &mut self,
974 mut position_info: ContainingBlockPositionInfo,
975 ) -> ContainingBlockPositionInfo {
976 mem::swap(&mut position_info, &mut self.floats.containing_block_info);
977 position_info
978 }
979
980 pub(crate) fn current_block_position_including_margins(&self) -> Au {
983 self.bfc_relative_block_position + self.current_margin.solve()
984 }
985
986 pub(crate) fn commit_margin(&mut self) {
992 self.advance_block_position(self.current_margin.solve());
993 self.current_margin = CollapsedMargin::zero();
994 }
995
996 pub(crate) fn position_without_clearance(&self, block_start_margin: &CollapsedMargin) -> Au {
999 self.bfc_relative_block_position + self.current_margin.adjoin(block_start_margin).solve()
1001 }
1002
1003 pub(crate) fn position_with_zero_clearance(&self, block_start_margin: &CollapsedMargin) -> Au {
1006 self.bfc_relative_block_position + self.current_margin.solve() + block_start_margin.solve()
1009 }
1010
1011 pub(crate) fn calculate_clear_position(
1014 &self,
1015 clear: Clear,
1016 block_start_margin: &CollapsedMargin,
1017 ) -> Option<Au> {
1018 if clear == Clear::None {
1019 return None;
1020 }
1021
1022 let hypothetical_block_position = self.position_without_clearance(block_start_margin);
1025
1026 let clear_position = match clear {
1029 Clear::None => unreachable!(),
1030 Clear::InlineStart => self.floats.clear_inline_start_position,
1031 Clear::InlineEnd => self.floats.clear_inline_end_position,
1032 Clear::Both => self
1033 .floats
1034 .clear_inline_start_position
1035 .max(self.floats.clear_inline_end_position),
1036 };
1037 if hypothetical_block_position >= clear_position {
1038 None
1039 } else {
1040 Some(clear_position)
1041 }
1042 }
1043
1044 pub(crate) fn calculate_clearance(
1053 &self,
1054 clear: Clear,
1055 block_start_margin: &CollapsedMargin,
1056 ) -> Option<Au> {
1057 self.calculate_clear_position(clear, block_start_margin)
1058 .map(|offset| offset - self.position_with_zero_clearance(block_start_margin))
1059 }
1060
1061 pub(crate) fn adjoin_assign(&mut self, margin: &CollapsedMargin) {
1063 self.current_margin.adjoin_assign(margin)
1064 }
1065
1066 pub(crate) fn current_containing_block_offset(&self) -> Au {
1068 self.floats.containing_block_info.block_start +
1069 self.floats
1070 .containing_block_info
1071 .block_start_margins_not_collapsed
1072 .solve()
1073 }
1074
1075 pub(crate) fn place_float_fragment(
1078 &mut self,
1079 box_fragment: &BoxFragment,
1080 containing_block: &ContainingBlock,
1081 margins_collapsing_with_parent_containing_block: CollapsedMargin,
1082 block_offset_from_containing_block_top: Au,
1083 ) -> LogicalRect<Au> {
1084 let block_start_of_containing_block_in_bfc = self.floats.containing_block_info.block_start +
1085 self.floats
1086 .containing_block_info
1087 .block_start_margins_not_collapsed
1088 .adjoin(&margins_collapsing_with_parent_containing_block)
1089 .solve();
1090
1091 self.floats.set_ceiling_from_non_floats(
1092 block_start_of_containing_block_in_bfc + block_offset_from_containing_block_top,
1093 );
1094
1095 let style = box_fragment.style().clone();
1096 let container_writing_mode = containing_block.style.writing_mode;
1097 let logical_float_size = LogicalVec2::from_physical_size(
1098 &box_fragment.content_rect().size,
1099 container_writing_mode,
1100 );
1101 let pbm_sums = LogicalSides::from_physical(
1102 &box_fragment.padding_border_margin(),
1103 container_writing_mode,
1104 );
1105 let margin_box_start_corner = self.floats.add_float(&PlacementInfo {
1106 size: logical_float_size + pbm_sums.sum(),
1107 side: FloatSide::from_style_and_container_writing_mode(&style, container_writing_mode)
1108 .expect("Float box wasn't floated!"),
1109 clear: Clear::from_style_and_container_writing_mode(&style, container_writing_mode),
1110 });
1111
1112 let relative_offset = match style.get_box().position {
1115 Position::Relative => relative_adjustement(&style, containing_block),
1116 _ => LogicalVec2::zero(),
1117 };
1118
1119 let new_position_in_bfc =
1122 margin_box_start_corner + pbm_sums.start_offset() + relative_offset;
1123
1124 let new_position_in_containing_block = LogicalVec2 {
1126 inline: new_position_in_bfc.inline - self.floats.containing_block_info.inline_start,
1127 block: new_position_in_bfc.block - block_start_of_containing_block_in_bfc,
1128 };
1129
1130 let rect = LogicalRect {
1131 start_corner: new_position_in_containing_block,
1132 size: LogicalVec2::from_physical_size(
1133 &box_fragment.content_rect().size,
1134 container_writing_mode,
1135 ),
1136 };
1137 box_fragment
1138 .base
1139 .set_rect(rect.as_physical_deprecated(containing_block));
1140 rect
1141 }
1142}