| // Copyright 2019 The Cobalt Authors. All Rights Reserved. | |
| // | |
| // Licensed under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| #include "cobalt/layout/flex_formatting_context.h" | |
| #include <algorithm> | |
| #include "base/logging.h" | |
| #include "cobalt/cssom/keyword_value.h" | |
| #include "cobalt/layout/line_box.h" | |
| #include "cobalt/layout/used_style.h" | |
| namespace cobalt { | |
| namespace layout { | |
| FlexFormattingContext::FlexFormattingContext(const LayoutParams& layout_params, | |
| bool main_direction_is_horizontal, | |
| bool direction_is_reversed) | |
| : layout_params_(layout_params), | |
| main_direction_is_horizontal_(main_direction_is_horizontal), | |
| direction_is_reversed_(direction_is_reversed), | |
| fit_content_main_size_(LayoutUnit()) {} | |
| FlexFormattingContext::~FlexFormattingContext() {} | |
| void FlexFormattingContext::UpdateRect(Box* child_box) { | |
| DCHECK(!child_box->IsAbsolutelyPositioned()); | |
| { | |
| LayoutParams child_layout_params(layout_params_); | |
| child_layout_params.shrink_to_fit_width_forced = true; | |
| child_box->UpdateSize(child_layout_params); | |
| } | |
| // Shrink-to-fit doesn't exists anymore by itself in CSS3. It is called the | |
| // fit-content size, which is derived from the 'min-content' and 'max-content' | |
| // sizes and the 'stretch-fit' size. | |
| // https://www.w3.org/TR/css-sizing-3/#fit-content-size | |
| // which depends on the intrinsic sizes: | |
| // https://www.w3.org/TR/css-flexbox-1/#intrinsic-sizes | |
| // Note that for column flex-direction, this is the intrinsic cross size. | |
| if (main_direction_is_horizontal_) { | |
| fit_content_main_size_ = shrink_to_fit_width() + child_box->width() + | |
| child_box->GetContentToMarginHorizontal(); | |
| set_shrink_to_fit_width(fit_content_main_size_); | |
| } else { | |
| fit_content_main_size_ += | |
| child_box->height() + child_box->GetContentToMarginVertical(); | |
| } | |
| set_auto_height(child_box->height()); | |
| } | |
| void FlexFormattingContext::CollectItemIntoLine( | |
| LayoutUnit main_space, std::unique_ptr<FlexItem>&& item) { | |
| // Collect flex items into flex lines: | |
| // https://www.w3.org/TR/css-flexbox-1/#algo-line-break | |
| if (lines_.empty()) { | |
| lines_.emplace_back(new FlexLine(layout_params_, | |
| main_direction_is_horizontal_, | |
| direction_is_reversed_, main_space)); | |
| fit_content_main_size_ = LayoutUnit(); | |
| } | |
| DCHECK(!lines_.empty()); | |
| if (multi_line_ && !lines_.back()->CanAddItem(*item)) { | |
| lines_.emplace_back(new FlexLine(layout_params_, | |
| main_direction_is_horizontal_, | |
| direction_is_reversed_, main_space)); | |
| } | |
| lines_.back()->AddItem(std::move(item)); | |
| fit_content_main_size_ = | |
| std::max(fit_content_main_size_, lines_.back()->items_outer_main_size()); | |
| } | |
| void FlexFormattingContext::ResolveFlexibleLengthsAndCrossSizes( | |
| const base::Optional<LayoutUnit>& cross_space, | |
| const base::Optional<LayoutUnit>& min_cross_space, | |
| const base::Optional<LayoutUnit>& max_cross_space, | |
| const scoped_refptr<cssom::PropertyValue>& align_content) { | |
| // Algorithm for Flex Layout: | |
| // https://www.w3.org/TR/css-flexbox-1/#layout-algorithm | |
| // 6. Resolve the flexible lengths. | |
| // Cross Size Determination: | |
| // 7. Determine the hypothetical cross size of each item. | |
| for (auto& line : lines_) { | |
| line->ResolveFlexibleLengthsAndCrossSize(); | |
| } | |
| // 8. Calculate the cross size of each flex line. | |
| // If the flex container is single-line and has a definite cross size, the | |
| // cross size of the flex line is the flex container's inner cross size. | |
| if (!multi_line_ && cross_space && !lines_.empty()) { | |
| lines_.front()->set_cross_size(*cross_space); | |
| } else { | |
| // Otherwise, for each flex line: | |
| for (auto& line : lines_) { | |
| line->CalculateCrossSize(); | |
| } | |
| } | |
| // If the flex container is single-line, then clamp the line's cross-size | |
| // to be within the container's computed min and max cross sizes. | |
| // https://www.w3.org/TR/css-flexbox-1/#change-201403-clamp-single-line | |
| if (!multi_line_ && !lines_.empty()) { | |
| LayoutUnit line_cross_size = lines_.front()->cross_size(); | |
| if (min_cross_space && line_cross_size < *min_cross_space) { | |
| lines_.front()->set_cross_size(*min_cross_space); | |
| } else if (max_cross_space && line_cross_size > *max_cross_space) { | |
| lines_.front()->set_cross_size(*max_cross_space); | |
| } | |
| } | |
| // Note, this is numbered as step 15 in the spec, however it does not rely on | |
| // any calculations done during step 9..14, and the result is needed for | |
| // step 9 below. | |
| // 15. Determine the flex container's used cross size. | |
| LayoutUnit total_cross_size = LayoutUnit(); | |
| for (auto& line : lines_) { | |
| total_cross_size += line->cross_size(); | |
| } | |
| if (cross_space) { | |
| // If the cross size property is a definite size, use that. | |
| cross_size_ = *cross_space; | |
| } else { | |
| // Otherwise, use the sum of the flex lines' cross sizes. | |
| cross_size_ = total_cross_size; | |
| } | |
| // Clamped by the used min and max cross sizes of the flex container. | |
| if (min_cross_space && cross_size_ < *min_cross_space) { | |
| cross_size_ = *min_cross_space; | |
| } else if (max_cross_space && cross_size_ > *max_cross_space) { | |
| cross_size_ = *max_cross_space; | |
| } | |
| if (lines_.empty()) { | |
| return; | |
| } | |
| LayoutUnit leftover_cross_size = cross_size_ - total_cross_size; | |
| // 9. Handle 'align-content: stretch'. | |
| if (align_content == cssom::KeywordValue::GetStretch()) { | |
| if (leftover_cross_size > LayoutUnit()) { | |
| LayoutUnit leftover_cross_size_per_line = | |
| leftover_cross_size / static_cast<int>(lines_.size()); | |
| for (auto& line : lines_) { | |
| line->set_cross_size(line->cross_size() + leftover_cross_size_per_line); | |
| } | |
| leftover_cross_size = LayoutUnit(); | |
| } | |
| } | |
| // 10. Collapse visibility:collapse items. | |
| // Cobalt does not implement visibility:collapse. | |
| // 11. Determine the used cross size of each flex item. | |
| for (auto& line : lines_) { | |
| line->DetermineUsedCrossSizes(cross_size_); | |
| } | |
| // Main-Axis Alignment: | |
| // 12. Distribute any remaining free space. | |
| for (auto& line : lines_) { | |
| line->DoMainAxisAlignment(); | |
| } | |
| // Cross-Axis Alignment: | |
| // 13. Resolve cross-axis auto margins. | |
| // 14. Align all flex items along the cross-axis. | |
| // 16. Align all flex lines per 'align-content'. | |
| LayoutUnit line_cross_axis_start = LayoutUnit(); | |
| LayoutUnit leftover_cross_size_per_line = LayoutUnit(); | |
| if (leftover_cross_size > LayoutUnit()) { | |
| if (align_content == cssom::KeywordValue::GetCenter()) { | |
| line_cross_axis_start = leftover_cross_size / 2; | |
| } else if (align_content == cssom::KeywordValue::GetFlexEnd()) { | |
| line_cross_axis_start = leftover_cross_size; | |
| } else if (align_content == cssom::KeywordValue::GetSpaceBetween()) { | |
| leftover_cross_size_per_line = | |
| (lines_.size() < 2) | |
| ? LayoutUnit() | |
| : leftover_cross_size / static_cast<int>(lines_.size() - 1); | |
| } else if (align_content == cssom::KeywordValue::GetSpaceAround()) { | |
| leftover_cross_size_per_line = | |
| leftover_cross_size / static_cast<int>(lines_.size()); | |
| line_cross_axis_start = leftover_cross_size_per_line / 2; | |
| } else { | |
| DCHECK((align_content == cssom::KeywordValue::GetFlexStart()) || | |
| (align_content == cssom::KeywordValue::GetStretch())); | |
| } | |
| } | |
| for (auto& line : lines_) { | |
| line->DoCrossAxisAlignment(line_cross_axis_start); | |
| line_cross_axis_start += line->cross_size() + leftover_cross_size_per_line; | |
| } | |
| } | |
| LayoutUnit FlexFormattingContext::GetBaseline() { | |
| LayoutUnit baseline = cross_size_; | |
| if (!lines_.empty()) { | |
| if (direction_is_reversed_ && !main_direction_is_horizontal_) { | |
| baseline = lines_.back()->GetBaseline(); | |
| } else { | |
| baseline = lines_.front()->GetBaseline(); | |
| } | |
| } | |
| return baseline; | |
| } | |
| } // namespace layout | |
| } // namespace cobalt |