| // Copyright 2014 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/text_box.h" |
| |
| #include <algorithm> |
| #include <limits> |
| |
| #include "cobalt/cssom/keyword_value.h" |
| #include "cobalt/cssom/shadow_value.h" |
| #include "cobalt/layout/render_tree_animations.h" |
| #include "cobalt/layout/used_style.h" |
| #include "cobalt/layout/white_space_processing.h" |
| #include "cobalt/math/transform_2d.h" |
| #include "cobalt/render_tree/filter_node.h" |
| #include "cobalt/render_tree/glyph_buffer.h" |
| #include "cobalt/render_tree/text_node.h" |
| |
| namespace cobalt { |
| namespace layout { |
| |
| TextBox::TextBox(const scoped_refptr<cssom::CSSComputedStyleDeclaration>& |
| css_computed_style_declaration, |
| const scoped_refptr<Paragraph>& paragraph, |
| int32 text_start_position, int32 text_end_position, |
| bool has_trailing_line_break, bool is_product_of_split, |
| UsedStyleProvider* used_style_provider, |
| LayoutStatTracker* layout_stat_tracker) |
| : Box(css_computed_style_declaration, used_style_provider, |
| layout_stat_tracker), |
| paragraph_(paragraph), |
| text_start_position_(text_start_position), |
| text_end_position_(text_end_position), |
| truncated_text_start_position_(text_start_position), |
| truncated_text_end_position_(text_end_position), |
| previous_truncated_text_start_position_(text_start_position), |
| previous_truncated_text_end_position_(text_end_position), |
| truncated_text_offset_from_left_(0), |
| used_font_(used_style_provider->GetUsedFontList( |
| css_computed_style_declaration->data()->font_family(), |
| css_computed_style_declaration->data()->font_size(), |
| css_computed_style_declaration->data()->font_style(), |
| css_computed_style_declaration->data()->font_weight())), |
| text_has_leading_white_space_(false), |
| text_has_trailing_white_space_(false), |
| should_collapse_leading_white_space_(false), |
| should_collapse_trailing_white_space_(false), |
| has_trailing_line_break_(has_trailing_line_break), |
| is_product_of_split_(is_product_of_split), |
| update_size_results_valid_(false), |
| ascent_(0) { |
| DCHECK(text_start_position_ <= text_end_position_); |
| |
| UpdateTextHasLeadingWhiteSpace(); |
| UpdateTextHasTrailingWhiteSpace(); |
| } |
| |
| Box::Level TextBox::GetLevel() const { return kInlineLevel; } |
| |
| TextBox* TextBox::AsTextBox() { return this; } |
| const TextBox* TextBox::AsTextBox() const { return this; } |
| |
| bool TextBox::ValidateUpdateSizeInputs(const LayoutParams& params) { |
| // Also take into account mutable local state about (at least) whether white |
| // space should be collapsed or not. |
| if (Box::ValidateUpdateSizeInputs(params) && update_size_results_valid_) { |
| return true; |
| } else { |
| update_size_results_valid_ = true; |
| return false; |
| } |
| } |
| |
| LayoutUnit TextBox::GetInlineLevelBoxHeight() const { return line_height_; } |
| |
| LayoutUnit TextBox::GetInlineLevelTopMargin() const { |
| return inline_top_margin_; |
| } |
| |
| void TextBox::UpdateContentSizeAndMargins(const LayoutParams& layout_params) { |
| // Anonymous boxes do not have margins. |
| DCHECK(GetUsedMarginLeftIfNotAuto(computed_style(), |
| layout_params.containing_block_size) |
| ->EqualOrNaN(LayoutUnit())); |
| DCHECK(GetUsedMarginTopIfNotAuto(computed_style(), |
| layout_params.containing_block_size) |
| ->EqualOrNaN(LayoutUnit())); |
| DCHECK(GetUsedMarginRightIfNotAuto(computed_style(), |
| layout_params.containing_block_size) |
| ->EqualOrNaN(LayoutUnit())); |
| DCHECK(GetUsedMarginBottomIfNotAuto(computed_style(), |
| layout_params.containing_block_size) |
| ->EqualOrNaN(LayoutUnit())); |
| |
| // The non-collapsible content size only needs to be calculated if |
| // |non_collapsible_text_width_| is unset. This indicates that either the |
| // width has not previously been calculated for this box, or that the width |
| // was invalidated as the result of a split. |
| if (!non_collapsible_text_width_) { |
| const scoped_refptr<cssom::PropertyValue>& line_height = |
| computed_style()->line_height(); |
| |
| // Factor in all of the fonts needed by the text when generating font |
| // metrics if the line height is set to normal: |
| // "When an element contains text that is rendered in more than one font, |
| // user agents may determine the 'normal' 'line-height' value according to |
| // the largest font size." |
| // https://www.w3.org/TR/CSS21/visudet.html#line-height |
| bool use_text_fonts_to_generate_font_metrics = |
| (line_height == cssom::KeywordValue::GetNormal()); |
| |
| render_tree::FontVector text_fonts; |
| int32 text_start_position = GetNonCollapsibleTextStartPosition(); |
| non_collapsible_text_width_ = |
| HasNonCollapsibleText() |
| ? LayoutUnit(used_font_->GetTextWidth( |
| paragraph_->GetTextBuffer() + text_start_position, |
| GetNonCollapsibleTextLength(), |
| paragraph_->IsRTL(text_start_position), |
| use_text_fonts_to_generate_font_metrics ? &text_fonts : NULL)) |
| : LayoutUnit(); |
| |
| // The line height values are only calculated when one of two conditions are |
| // met: |
| // 1. |baseline_offset_from_top_| has not previously been set, meaning that |
| // the line height has never been calculated for this box. |
| // 2. |use_text_fonts_to_generate_font_metrics| is true, meaning that the |
| // line height values depend on the content of the text itself. When |
| // this is the case, the line height value is not constant and a split |
| // in the text box can result in the line height values changing. |
| if (!baseline_offset_from_top_ || use_text_fonts_to_generate_font_metrics) { |
| set_margin_left(LayoutUnit()); |
| set_margin_top(LayoutUnit()); |
| set_margin_right(LayoutUnit()); |
| set_margin_bottom(LayoutUnit()); |
| |
| render_tree::FontMetrics font_metrics = |
| used_font_->GetFontMetrics(text_fonts); |
| |
| UsedLineHeightProvider used_line_height_provider( |
| font_metrics, computed_style()->font_size()); |
| line_height->Accept(&used_line_height_provider); |
| set_height(LayoutUnit(font_metrics.em_box_height())); |
| baseline_offset_from_top_ = |
| used_line_height_provider.baseline_offset_from_top(); |
| line_height_ = used_line_height_provider.used_line_height(); |
| inline_top_margin_ = used_line_height_provider.half_leading(); |
| ascent_ = font_metrics.ascent(); |
| } |
| } |
| |
| set_width(GetLeadingWhiteSpaceWidth() + *non_collapsible_text_width_ + |
| GetTrailingWhiteSpaceWidth()); |
| } |
| |
| WrapResult TextBox::TryWrapAt(WrapAtPolicy wrap_at_policy, |
| WrapOpportunityPolicy wrap_opportunity_policy, |
| bool is_line_existence_justified, |
| LayoutUnit available_width, |
| bool should_collapse_trailing_white_space) { |
| DCHECK(!IsAbsolutelyPositioned()); |
| |
| bool style_allows_break_word = |
| computed_style()->overflow_wrap() == cssom::KeywordValue::GetBreakWord(); |
| |
| if (!ShouldProcessWrapOpportunityPolicy(wrap_opportunity_policy, |
| style_allows_break_word)) { |
| return kWrapResultNoWrap; |
| } |
| |
| // Even when the text box's style prevents wrapping, wrapping can still occur |
| // before the box if the following requirements are met: |
| // - The text box is not the product of a split. If it is, and this box's |
| // style prevents text wrapping, then the previous box also prevents text |
| // wrapping, and no wrap should occur between them. |
| // - The line's existence has already been justified. Wrapping cannot occur |
| // prior to that. |
| // - Whitespace precedes the text box. This can only occur in the case where |
| // the preceding box allows wrapping, otherwise a no-breaking space will |
| // have been appended (the one exception to this is when this box was the |
| // product of a split, but that case is already handled above). |
| if (!DoesAllowTextWrapping(computed_style()->white_space())) { |
| if (!is_product_of_split_ && is_line_existence_justified && |
| text_start_position_ > 0 && |
| paragraph_->IsCollapsibleWhiteSpace(text_start_position_ - 1)) { |
| return kWrapResultWrapBefore; |
| } else { |
| return kWrapResultNoWrap; |
| } |
| } |
| |
| // If the line existence is already justified, then leading whitespace can be |
| // included in the wrap search, as it provides a wrappable point. If it isn't, |
| // then the leading whitespace is skipped, because the line cannot wrap before |
| // it is justified. |
| int32 start_position = is_line_existence_justified |
| ? text_start_position_ |
| : GetNonCollapsibleTextStartPosition(); |
| |
| int32 wrap_position = GetWrapPosition( |
| wrap_at_policy, wrap_opportunity_policy, is_line_existence_justified, |
| available_width, should_collapse_trailing_white_space, |
| style_allows_break_word, start_position); |
| |
| WrapResult wrap_result; |
| // Wrapping at the text start position is only allowed when the line's |
| // existence is already justified. |
| if (wrap_position == text_start_position_ && is_line_existence_justified) { |
| wrap_result = kWrapResultWrapBefore; |
| } else if (wrap_position > start_position && |
| wrap_position < text_end_position_) { |
| SplitAtPosition(wrap_position); |
| wrap_result = kWrapResultSplitWrap; |
| } else { |
| wrap_result = kWrapResultNoWrap; |
| } |
| return wrap_result; |
| } |
| |
| Box* TextBox::GetSplitSibling() const { return split_sibling_; } |
| |
| bool TextBox::DoesFulfillEllipsisPlacementRequirement() const { |
| // This box has non-collapsed text and fulfills the requirement that the first |
| // character or inline-level element must appear on the line before ellipsing |
| // can occur if it has non-collapsed characters. |
| // https://www.w3.org/TR/css3-ui/#propdef-text-overflow |
| return GetNonCollapsedTextStartPosition() < GetNonCollapsedTextEndPosition(); |
| } |
| |
| void TextBox::DoPreEllipsisPlacementProcessing() { |
| previous_truncated_text_start_position_ = truncated_text_start_position_; |
| previous_truncated_text_end_position_ = truncated_text_end_position_; |
| truncated_text_start_position_ = text_start_position_; |
| truncated_text_end_position_ = text_end_position_; |
| } |
| |
| void TextBox::DoPostEllipsisPlacementProcessing() { |
| if (previous_truncated_text_start_position_ != |
| truncated_text_start_position_ || |
| previous_truncated_text_end_position_ != truncated_text_end_position_) { |
| InvalidateRenderTreeNodesOfBoxAndAncestors(); |
| } |
| } |
| |
| void TextBox::SplitBidiLevelRuns() {} |
| |
| bool TextBox::TrySplitAtSecondBidiLevelRun() { |
| int32 split_position; |
| if (paragraph_->GetNextRunPosition(text_start_position_, &split_position) && |
| split_position < text_end_position_) { |
| SplitAtPosition(split_position); |
| return true; |
| } else { |
| return false; |
| } |
| } |
| |
| base::Optional<int> TextBox::GetBidiLevel() const { |
| return paragraph_->GetBidiLevel(text_start_position_); |
| } |
| |
| void TextBox::SetShouldCollapseLeadingWhiteSpace( |
| bool should_collapse_leading_white_space) { |
| if (should_collapse_leading_white_space_ != |
| should_collapse_leading_white_space) { |
| should_collapse_leading_white_space_ = should_collapse_leading_white_space; |
| update_size_results_valid_ = false; |
| } |
| } |
| |
| void TextBox::SetShouldCollapseTrailingWhiteSpace( |
| bool should_collapse_trailing_white_space) { |
| if (should_collapse_trailing_white_space_ != |
| should_collapse_trailing_white_space) { |
| should_collapse_trailing_white_space_ = |
| should_collapse_trailing_white_space; |
| update_size_results_valid_ = false; |
| } |
| } |
| |
| bool TextBox::IsCollapsed() const { |
| return !HasLeadingWhiteSpace() && !HasTrailingWhiteSpace() && |
| !HasNonCollapsibleText(); |
| } |
| |
| bool TextBox::HasLeadingWhiteSpace() const { |
| return text_has_leading_white_space_ && |
| !should_collapse_leading_white_space_ && |
| (HasNonCollapsibleText() || !should_collapse_trailing_white_space_); |
| } |
| |
| bool TextBox::HasTrailingWhiteSpace() const { |
| return text_has_trailing_white_space_ && |
| !should_collapse_trailing_white_space_ && |
| (HasNonCollapsibleText() || !should_collapse_leading_white_space_); |
| } |
| |
| bool TextBox::JustifiesLineExistence() const { |
| return HasNonCollapsibleText() || has_trailing_line_break_; |
| } |
| |
| bool TextBox::HasTrailingLineBreak() const { return has_trailing_line_break_; } |
| |
| bool TextBox::AffectsBaselineInBlockFormattingContext() const { |
| NOTREACHED() << "Should only be called in a block formatting context."; |
| return true; |
| } |
| |
| LayoutUnit TextBox::GetBaselineOffsetFromTopMarginEdge() const { |
| return baseline_offset_from_top_.value_or(LayoutUnit()); |
| } |
| |
| namespace { |
| void PopulateBaseStyleForTextNode( |
| const scoped_refptr<const cssom::CSSComputedStyleData>& source_style, |
| const scoped_refptr<cssom::MutableCSSComputedStyleData>& |
| destination_style) { |
| // NOTE: Properties set by PopulateBaseStyleForTextNode() should match the |
| // properties used by SetupTextNodeFromStyle(). |
| destination_style->set_color(source_style->color()); |
| } |
| |
| void SetupTextNodeFromStyle( |
| const scoped_refptr<const cssom::CSSComputedStyleData>& style, |
| render_tree::TextNode::Builder* text_node_builder) { |
| text_node_builder->color = GetUsedColor(style->color()); |
| } |
| |
| void AddTextShadows(render_tree::TextNode::Builder* builder, |
| cssom::PropertyListValue* shadow_list) { |
| if (shadow_list->value().empty()) { |
| return; |
| } |
| |
| builder->shadows.emplace(); |
| builder->shadows->reserve(shadow_list->value().size()); |
| |
| for (size_t s = 0; s < shadow_list->value().size(); ++s) { |
| cssom::ShadowValue* shadow_value = |
| base::polymorphic_downcast<cssom::ShadowValue*>( |
| shadow_list->value()[s].get()); |
| |
| math::Vector2dF offset(shadow_value->offset_x()->value(), |
| shadow_value->offset_y()->value()); |
| |
| // Since most of a Gaussian fits within 3 standard deviations from |
| // the mean, we setup here the Gaussian blur sigma to be a third of |
| // the blur radius. |
| float shadow_blur_sigma = |
| shadow_value->blur_radius() |
| ? GetUsedLength(shadow_value->blur_radius()).toFloat() / 3.0f |
| : 0.0f; |
| |
| render_tree::ColorRGBA shadow_color = GetUsedColor(shadow_value->color()); |
| |
| builder->shadows->push_back( |
| render_tree::Shadow(offset, shadow_blur_sigma, shadow_color)); |
| } |
| } |
| |
| } // namespace |
| |
| void TextBox::RenderAndAnimateContent( |
| render_tree::CompositionNode::Builder* border_node_builder, |
| ContainerBox* stacking_context) const { |
| if (computed_style()->visibility() != cssom::KeywordValue::GetVisible()) { |
| return; |
| } |
| |
| DCHECK((border_left_width() + padding_left()).EqualOrNaN(LayoutUnit())); |
| DCHECK((border_top_width() + padding_top()).EqualOrNaN(LayoutUnit())); |
| |
| // Only add the text node to the render tree if it actually has visible |
| // content that isn't simply collapsible whitespace and a font isn't loading. |
| // The font is treated as transparent if a font is currently being downloaded |
| // and hasn't timed out: "In cases where textual content is loaded before |
| // downloadable fonts are available, user agents may... render text |
| // transparently with fallback fonts to avoid a flash of text using a fallback |
| // font. In cases where the font download fails user agents must display text, |
| // simply leaving transparent text is considered non-conformant behavior." |
| // https://www.w3.org/TR/css3-fonts/#font-face-loading |
| if (HasNonCollapsibleText() && HasVisibleText() && used_font_->IsVisible()) { |
| bool is_color_animated = |
| animations()->IsPropertyAnimated(cssom::kColorProperty); |
| |
| render_tree::ColorRGBA used_color = GetUsedColor(computed_style()->color()); |
| |
| const scoped_refptr<cssom::PropertyValue>& text_shadow = |
| computed_style()->text_shadow(); |
| |
| // Only render the text if it is not completely transparent, or if the |
| // color is animated, in which case it could become non-transparent. |
| if (used_color.a() > 0.0f || is_color_animated || |
| text_shadow != cssom::KeywordValue::GetNone()) { |
| int32 text_start_position = GetVisibleTextStartPosition(); |
| int32 text_length = GetVisibleTextLength(); |
| |
| scoped_refptr<render_tree::GlyphBuffer> glyph_buffer = |
| used_font_->CreateGlyphBuffer( |
| paragraph_->GetTextBuffer() + text_start_position, text_length, |
| paragraph_->IsRTL(text_start_position)); |
| |
| render_tree::TextNode::Builder text_node_builder( |
| math::Vector2dF(truncated_text_offset_from_left_, ascent_), |
| glyph_buffer, used_color); |
| |
| if (text_shadow != cssom::KeywordValue::GetNone()) { |
| cssom::PropertyListValue* shadow_list = |
| base::polymorphic_downcast<cssom::PropertyListValue*>( |
| computed_style()->text_shadow().get()); |
| |
| AddTextShadows(&text_node_builder, shadow_list); |
| } |
| |
| scoped_refptr<render_tree::TextNode> text_node = |
| new render_tree::TextNode(text_node_builder); |
| |
| // The render tree API considers text coordinates to be a position |
| // of a baseline, offset the text node accordingly. |
| scoped_refptr<render_tree::Node> node_to_add; |
| if (is_color_animated) { |
| render_tree::animations::AnimateNode::Builder animate_node_builder; |
| AddAnimations<render_tree::TextNode>( |
| base::Bind(&PopulateBaseStyleForTextNode), |
| base::Bind(&SetupTextNodeFromStyle), |
| *css_computed_style_declaration(), text_node, |
| &animate_node_builder); |
| node_to_add = new render_tree::animations::AnimateNode( |
| animate_node_builder, text_node); |
| } else { |
| node_to_add = text_node; |
| } |
| border_node_builder->AddChild(node_to_add); |
| } |
| } |
| } |
| |
| bool TextBox::IsTransformable() const { return false; } |
| |
| #ifdef COBALT_BOX_DUMP_ENABLED |
| |
| void TextBox::DumpClassName(std::ostream* stream) const { |
| *stream << "TextBox "; |
| } |
| |
| void TextBox::DumpProperties(std::ostream* stream) const { |
| Box::DumpProperties(stream); |
| |
| *stream << "text_start=" << text_start_position_ << " " |
| << "text_end=" << text_end_position_ << " "; |
| |
| *stream << std::boolalpha << "line_height=" << line_height_ << " " |
| << "inline_top_margin=" << inline_top_margin_ << " " |
| << "has_leading_white_space=" << HasLeadingWhiteSpace() << " " |
| << "has_trailing_white_space=" << HasTrailingWhiteSpace() << " " |
| << std::noboolalpha; |
| |
| *stream << "bidi_level=" << paragraph_->GetBidiLevel(text_start_position_) |
| << " "; |
| } |
| |
| void TextBox::DumpChildrenWithIndent(std::ostream* stream, int indent) const { |
| Box::DumpChildrenWithIndent(stream, indent); |
| |
| DumpIndent(stream, indent); |
| |
| *stream << "\"" << GetNonCollapsibleText() << "\"\n"; |
| } |
| |
| #endif // COBALT_BOX_DUMP_ENABLED |
| |
| void TextBox::DoPlaceEllipsisOrProcessPlacedEllipsis( |
| BaseDirection base_direction, LayoutUnit desired_offset, |
| bool* is_placement_requirement_met, bool* is_placed, |
| LayoutUnit* placed_offset) { |
| // If the ellipsis has already been placed, then the text is fully truncated |
| // by the ellipsis. |
| if (*is_placed) { |
| if (paragraph_->AreInlineAndScriptDirectionsTheSame(base_direction, |
| text_start_position_)) { |
| truncated_text_end_position_ = text_start_position_; |
| } else { |
| truncated_text_start_position_ = text_end_position_; |
| } |
| return; |
| } |
| |
| // Otherwise, the ellipsis is being placed somewhere within this text box. |
| *is_placed = true; |
| |
| LayoutUnit content_box_start_offset = |
| GetContentBoxStartEdgeOffsetFromContainingBlock(base_direction); |
| |
| // Determine the available width in the content before to the desired offset. |
| // This is the distance from the start edge of the content box to the desired |
| // offset. |
| LayoutUnit desired_content_offset = |
| base_direction == kRightToLeftBaseDirection |
| ? content_box_start_offset - desired_offset |
| : desired_offset - content_box_start_offset; |
| |
| int32 start_position = GetNonCollapsedTextStartPosition(); |
| int32 end_position = GetNonCollapsedTextEndPosition(); |
| int32 found_position; |
| LayoutUnit found_offset; |
| |
| // Attempt to find a break position allowing breaks anywhere within the text, |
| // and not simply at soft wrap locations. If the placement requirement has |
| // already been satisfied, then the ellipsis can appear anywhere within the |
| // text box. Otherwise, it can only appear after the first character |
| // (https://www.w3.org/TR/css3-ui/#propdef-text-overflow). |
| if (paragraph_->FindBreakPosition( |
| base_direction, false, used_font_, start_position, end_position, |
| desired_content_offset, false, !(*is_placement_requirement_met), |
| Paragraph::kBreakPolicyBreakWord, &found_position, &found_offset)) { |
| // A usable break position was found. Calculate the placed offset using the |
| // the break position's distance from the content box's start edge. In the |
| // case where the base direction is right-to-left, the truncated text must |
| // be offset to begin after the ellipsis. |
| if (base_direction == kRightToLeftBaseDirection) { |
| *placed_offset = content_box_start_offset - found_offset; |
| truncated_text_offset_from_left_ = |
| (*placed_offset - GetContentBoxLeftEdgeOffsetFromContainingBlock()) |
| .toFloat(); |
| } else { |
| *placed_offset = content_box_start_offset + found_offset; |
| } |
| if (paragraph_->AreInlineAndScriptDirectionsTheSame(base_direction, |
| start_position)) { |
| truncated_text_end_position_ = found_position; |
| } else { |
| truncated_text_start_position_ = found_position; |
| } |
| // An acceptable break position was not found. If the placement requirement |
| // was already met prior to this box, then the ellipsis doesn't require a |
| // character from this box to appear prior to its position, so simply place |
| // the ellipsis at the start edge of the box and fully truncate the text. |
| } else if (is_placement_requirement_met) { |
| *placed_offset = |
| GetMarginBoxStartEdgeOffsetFromContainingBlock(base_direction); |
| if (paragraph_->AreInlineAndScriptDirectionsTheSame(base_direction, |
| start_position)) { |
| truncated_text_end_position_ = text_start_position_; |
| } else { |
| truncated_text_start_position_ = text_end_position_; |
| } |
| // The placement requirement has not already been met. Given that an |
| // acceptable break position was not found within the text, the ellipsis can |
| // only be placed at the end edge of the box. |
| } else { |
| *placed_offset = |
| GetMarginBoxEndEdgeOffsetFromContainingBlock(base_direction); |
| } |
| } |
| |
| void TextBox::UpdateTextHasLeadingWhiteSpace() { |
| text_has_leading_white_space_ = |
| text_start_position_ != text_end_position_ && |
| paragraph_->IsCollapsibleWhiteSpace(text_start_position_) && |
| DoesCollapseWhiteSpace(computed_style()->white_space()); |
| } |
| |
| void TextBox::UpdateTextHasTrailingWhiteSpace() { |
| text_has_trailing_white_space_ = |
| !has_trailing_line_break_ && text_start_position_ != text_end_position_ && |
| paragraph_->IsCollapsibleWhiteSpace(text_end_position_ - 1) && |
| DoesCollapseWhiteSpace(computed_style()->white_space()); |
| } |
| |
| int32 TextBox::GetWrapPosition(WrapAtPolicy wrap_at_policy, |
| WrapOpportunityPolicy wrap_opportunity_policy, |
| bool is_line_existence_justified, |
| LayoutUnit available_width, |
| bool should_collapse_trailing_white_space, |
| bool style_allows_break_word, |
| int32 start_position) { |
| Paragraph::BreakPolicy break_policy = |
| Paragraph::GetBreakPolicyFromWrapOpportunityPolicy( |
| wrap_opportunity_policy, style_allows_break_word); |
| |
| int32 wrap_position = -1; |
| switch (wrap_at_policy) { |
| case kWrapAtPolicyBefore: |
| // Wrapping before the box is only permitted when the line's existence is |
| // justified. |
| if (is_line_existence_justified && |
| paragraph_->IsBreakPosition(text_start_position_, break_policy)) { |
| wrap_position = text_start_position_; |
| } else { |
| wrap_position = -1; |
| } |
| break; |
| case kWrapAtPolicyLastOpportunityWithinWidth: { |
| if (is_line_existence_justified) { |
| // If the line existence is already justified, then the line can |
| // potentially wrap after the box's leading whitespace. However, if that |
| // whitespace has been collapsed, then we need to add its width to the |
| // available width, because it'll be counted against the available width |
| // while searching for the break position, but it won't impact the |
| // length of the line. |
| if (start_position != GetNonCollapsedTextStartPosition()) { |
| available_width += LayoutUnit(used_font_->GetSpaceWidth()); |
| } |
| // If the line's existence isn't already justified, then the line cannot |
| // wrap on leading whitespace. Subtract the width of non-collapsed |
| // whitespace from the available width, as the search is starting after |
| // it. |
| } else { |
| available_width -= GetLeadingWhiteSpaceWidth(); |
| } |
| |
| // Attempt to find the last break position after the start position that |
| // fits within the available width. Overflow is never allowed. |
| LayoutUnit wrap_width; |
| if (!paragraph_->FindBreakPosition( |
| paragraph_->base_direction(), true, used_font_, start_position, |
| text_end_position_, available_width, |
| should_collapse_trailing_white_space, false, break_policy, |
| &wrap_position, &wrap_width)) { |
| // If no break position is found, but the line existence is already |
| // justified, then check for text start position being a break position. |
| // Wrapping before the box is permitted when the line's existence is |
| // justified. |
| if (is_line_existence_justified && |
| paragraph_->IsBreakPosition(text_start_position_, break_policy)) { |
| wrap_position = text_start_position_; |
| } else { |
| wrap_position = -1; |
| } |
| } |
| break; |
| } |
| case kWrapAtPolicyLastOpportunity: |
| wrap_position = paragraph_->GetPreviousBreakPosition(text_end_position_, |
| break_policy); |
| break; |
| case kWrapAtPolicyFirstOpportunity: { |
| // If the line is already justified, the wrap can occur at the start |
| // position. Otherwise, the wrap cannot occur until after non-collapsible |
| // text is included. |
| int32 search_start_position = |
| is_line_existence_justified ? start_position - 1 : start_position; |
| wrap_position = |
| paragraph_->GetNextBreakPosition(search_start_position, break_policy); |
| break; |
| } |
| } |
| return wrap_position; |
| } |
| |
| void TextBox::SplitAtPosition(int32 split_start_position) { |
| int32 split_end_position = text_end_position_; |
| DCHECK_LT(split_start_position, split_end_position); |
| |
| text_end_position_ = split_start_position; |
| truncated_text_end_position_ = text_end_position_; |
| |
| // The width is no longer valid for this box now that it has been split. |
| update_size_results_valid_ = false; |
| non_collapsible_text_width_ = base::nullopt; |
| |
| const bool kIsProductOfSplitTrue = true; |
| |
| scoped_refptr<TextBox> box_after_split(new TextBox( |
| css_computed_style_declaration(), paragraph_, split_start_position, |
| split_end_position, has_trailing_line_break_, kIsProductOfSplitTrue, |
| used_style_provider(), layout_stat_tracker())); |
| |
| // Update the split sibling links. |
| box_after_split->split_sibling_ = split_sibling_; |
| split_sibling_ = box_after_split; |
| |
| // TODO: Set the text width of the box after split to |
| // |text_width_ - pre_split_width| to save a call to Skia/HarfBuzz. |
| |
| // Pass the trailing line break on to the sibling that retains the trailing |
| // portion of the text and reset the value for this text box. |
| has_trailing_line_break_ = false; |
| |
| // Update the paragraph end position white space now that this text box has |
| // a new end position. The start position white space does not need to be |
| // updated as it has not changed. |
| UpdateTextHasTrailingWhiteSpace(); |
| } |
| |
| LayoutUnit TextBox::GetLeadingWhiteSpaceWidth() const { |
| return HasLeadingWhiteSpace() ? LayoutUnit(used_font_->GetSpaceWidth()) |
| : LayoutUnit(); |
| } |
| |
| LayoutUnit TextBox::GetTrailingWhiteSpaceWidth() const { |
| return HasTrailingWhiteSpace() && HasNonCollapsibleText() |
| ? LayoutUnit(used_font_->GetSpaceWidth()) |
| : LayoutUnit(); |
| } |
| |
| int32 TextBox::GetNonCollapsedTextStartPosition() const { |
| return should_collapse_leading_white_space_ |
| ? GetNonCollapsibleTextStartPosition() |
| : text_start_position_; |
| } |
| |
| int32 TextBox::GetNonCollapsedTextEndPosition() const { |
| return should_collapse_trailing_white_space_ |
| ? GetNonCollapsibleTextEndPosition() |
| : text_end_position_; |
| } |
| |
| int32 TextBox::GetNonCollapsibleTextStartPosition() const { |
| return text_has_leading_white_space_ ? text_start_position_ + 1 |
| : text_start_position_; |
| } |
| |
| int32 TextBox::GetNonCollapsibleTextEndPosition() const { |
| return text_has_trailing_white_space_ ? text_end_position_ - 1 |
| : text_end_position_; |
| } |
| |
| int32 TextBox::GetNonCollapsibleTextLength() const { |
| return GetNonCollapsibleTextEndPosition() - |
| GetNonCollapsibleTextStartPosition(); |
| } |
| |
| bool TextBox::HasNonCollapsibleText() const { |
| return GetNonCollapsibleTextLength() > 0; |
| } |
| |
| std::string TextBox::GetNonCollapsibleText() const { |
| return paragraph_->RetrieveUtf8SubString(GetNonCollapsibleTextStartPosition(), |
| GetNonCollapsibleTextEndPosition(), |
| Paragraph::kVisualTextOrder); |
| } |
| |
| int32 TextBox::GetVisibleTextStartPosition() const { |
| return std::max(GetNonCollapsedTextStartPosition(), |
| truncated_text_start_position_); |
| } |
| |
| int32 TextBox::GetVisibleTextEndPosition() const { |
| return std::min(GetNonCollapsedTextEndPosition(), |
| truncated_text_end_position_); |
| } |
| |
| int32 TextBox::GetVisibleTextLength() const { |
| return GetVisibleTextEndPosition() - GetVisibleTextStartPosition(); |
| } |
| |
| bool TextBox::HasVisibleText() const { return GetVisibleTextLength() > 0; } |
| |
| std::string TextBox::GetVisibleText() const { |
| return paragraph_->RetrieveUtf8SubString(GetVisibleTextStartPosition(), |
| GetVisibleTextEndPosition(), |
| Paragraph::kVisualTextOrder); |
| } |
| |
| } // namespace layout |
| } // namespace cobalt |
