third_party/blink/renderer/core/layout/ng/inline/ng_line_truncator.cc - chromium/src - Git at Google

 // Copyright 2018 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "third_party/blink/renderer/core/layout/ng/inline/ng_line_truncator.h"

 #include "third_party/blink/renderer/core/layout/ng/inline/ng_inline_item_result.h"
 #include "third_party/blink/renderer/core/layout/ng/inline/ng_text_fragment_builder.h"
 #include "third_party/blink/renderer/core/layout/ng/ng_physical_box_fragment.h"
 #include "third_party/blink/renderer/platform/fonts/font_baseline.h"
 #include "third_party/blink/renderer/platform/fonts/shaping/harfbuzz_shaper.h"
 #include "third_party/blink/renderer/platform/fonts/shaping/shape_result_view.h"

 namespace blink {

 NGLineTruncator::NGLineTruncator(NGInlineNode& node,
                                  const NGLineInfo& line_info)
     : node_(node),
       line_style_(&line_info.LineStyle()),
       available_width_(line_info.AvailableWidth()),
       line_direction_(line_info.BaseDirection()) {}

 LayoutUnit NGLineTruncator::TruncateLine(
     LayoutUnit line_width,
     NGLineBoxFragmentBuilder::ChildList* line_box) {
   // Shape the ellipsis and compute its inline size.
   // The ellipsis is styled according to the line style.
   // https://drafts.csswg.org/css-ui/#ellipsing-details
   const ComputedStyle* ellipsis_style = line_style_.get();
   const Font& font = ellipsis_style->GetFont();
   const SimpleFontData* font_data = font.PrimaryFont();
   DCHECK(font_data);
   String ellipsis_text =
       font_data && font_data->GlyphForCharacter(kHorizontalEllipsisCharacter)
           ? String(&kHorizontalEllipsisCharacter, 1)
           : String(u"...");
   HarfBuzzShaper shaper(ellipsis_text);
   scoped_refptr<ShapeResultView> ellipsis_shape_result =
       ShapeResultView::Create(shaper.Shape(&font, line_direction_).get());
   LayoutUnit ellipsis_width = ellipsis_shape_result->SnappedWidth();

   // Loop children from the logical last to the logical first to determine where
   // to place the ellipsis. Children maybe truncated or moved as part of the
   // process.
   LayoutUnit ellipsis_inline_offset;
   const NGPhysicalFragment* ellipsized_fragment = nullptr;
   if (IsLtr(line_direction_)) {
     NGLineBoxFragmentBuilder::Child* first_child = line_box->FirstInFlowChild();
     for (auto it = line_box->rbegin(); it != line_box->rend(); it++) {
       auto& child = *it;
       if (base::Optional<LayoutUnit> candidate = EllipsisOffset(
               line_width, ellipsis_width, &child == first_child, &child)) {
         ellipsis_inline_offset = *candidate;
         ellipsized_fragment = child.PhysicalFragment();
         DCHECK(ellipsized_fragment);
         break;
       }
     }
   } else {
     NGLineBoxFragmentBuilder::Child* first_child = line_box->LastInFlowChild();
     ellipsis_inline_offset = available_width_ - ellipsis_width;
     for (auto& child : *line_box) {
       if (base::Optional<LayoutUnit> candidate = EllipsisOffset(
               line_width, ellipsis_width, &child == first_child, &child)) {
         ellipsis_inline_offset = *candidate;
         ellipsized_fragment = child.PhysicalFragment();
         DCHECK(ellipsized_fragment);
         break;
       }
     }
   }

   // Abort if ellipsis could not be placed.
   if (!ellipsized_fragment)
     return line_width;

   // Now the offset of the ellpisis is determined. Place the ellpisis into the
   // line box.
   NGTextFragmentBuilder builder(node_, line_style_->GetWritingMode());
   DCHECK(ellipsized_fragment->GetLayoutObject() &&
          ellipsized_fragment->GetLayoutObject()->IsInline());
   builder.SetText(ellipsized_fragment->GetMutableLayoutObject(), ellipsis_text,
                   ellipsis_style, true /* is_ellipsis_style */,
                   std::move(ellipsis_shape_result));
   FontBaseline baseline_type = line_style_->GetFontBaseline();
   NGLineHeightMetrics ellipsis_metrics(font_data->GetFontMetrics(),
                                        baseline_type);
   line_box->AddChild(
       builder.ToTextFragment(),
       LogicalOffset{ellipsis_inline_offset, -ellipsis_metrics.ascent},
       ellipsis_width, 0);
   return std::max(ellipsis_inline_offset + ellipsis_width, line_width);
 }

 // Hide this child from being painted.
 void NGLineTruncator::HideChild(NGLineBoxFragmentBuilder::Child* child) {
   DCHECK(child->HasInFlowFragment());

   const NGPhysicalFragment* fragment = nullptr;
   if (const NGLayoutResult* layout_result = child->layout_result.get()) {
     // Need to propagate OOF descendants in this inline-block child.
     if (!layout_result->PhysicalFragment()
              .OutOfFlowPositionedDescendants()
              .IsEmpty())
       return;
     fragment = &layout_result->PhysicalFragment();
   } else {
     fragment = child->fragment.get();
   }
   DCHECK(fragment);

   // If this child has self painting layer, not producing fragments will not
   // suppress painting because layers are painted separately. Move it out of the
   // clipping area.
   if (fragment->HasSelfPaintingLayer()) {
     // |available_width_| may not be enough when the containing block has
     // paddings, because clipping is at the content box but ellipsizing is at
     // the padding box. Just move to the max because we don't know paddings,
     // and max should do what we need.
     child->offset.inline_offset = LayoutUnit::NearlyMax();
     return;
   }

   // TODO(kojii): Not producing fragments is the most clean and efficient way to
   // hide them, but we may want to revisit how to do this to reduce special
   // casing in other code.
   child->layout_result = nullptr;
   child->fragment = nullptr;
 }

 // Return the offset to place the ellipsis.
 //
 // This function may truncate or move the child so that the ellipsis can fit.
 base::Optional<LayoutUnit> NGLineTruncator::EllipsisOffset(
     LayoutUnit line_width,
     LayoutUnit ellipsis_width,
     bool is_first_child,
     NGLineBoxFragmentBuilder::Child* child) {
   // Leave out-of-flow children as is.
   if (!child->HasInFlowFragment())
     return base::nullopt;

   // Can't place ellipsis if this child is completely outside of the box.
   LayoutUnit child_inline_offset =
       IsLtr(line_direction_)
           ? child->offset.inline_offset
           : line_width - (child->offset.inline_offset + child->inline_size);
   LayoutUnit space_for_child = available_width_ - child_inline_offset;
   if (space_for_child <= 0) {
     // This child is outside of the content box, but we still need to hide it.
     // When the box has paddings, this child outside of the content box maybe
     // still inside of the clipping box.
     if (!is_first_child)
       HideChild(child);
     return base::nullopt;
   }

   // At least part of this child is in the box.
   // If not all of this child can fit, try to truncate.
   space_for_child -= ellipsis_width;
   if (space_for_child < child->inline_size &&
       !TruncateChild(space_for_child, is_first_child, child)) {
     // This child is partially in the box, but it should not be visible because
     // earlier sibling will be truncated and ellipsized.
     if (!is_first_child)
       HideChild(child);
     return base::nullopt;
   }

   return IsLtr(line_direction_)
              ? child->offset.inline_offset + child->inline_size
              : child->offset.inline_offset - ellipsis_width;
 }

 // Truncate the specified child. Returns true if truncated successfully, false
 // otherwise.
 //
 // Note that this function may return true even if it can't fit the child when
 // |is_first_child|, because the spec defines that the first character or atomic
 // inline-level element on a line must be clipped rather than ellipsed.
 // https://drafts.csswg.org/css-ui/#text-overflow
 bool NGLineTruncator::TruncateChild(LayoutUnit space_for_child,
                                     bool is_first_child,
                                     NGLineBoxFragmentBuilder::Child* child) {
   // If the space is not enough, try the next child.
   if (space_for_child <= 0 && !is_first_child)
     return false;

   // Only text fragments can be truncated.
   if (!child->fragment)
     return is_first_child;
   auto& fragment = To<NGPhysicalTextFragment>(*child->fragment);

   // No need to truncate empty results.
   if (!fragment.TextShapeResult())
     return is_first_child;

   // TODO(layout-dev): Add support for OffsetToFit to ShapeResultView to avoid
   // this copy.
   scoped_refptr<blink::ShapeResult> shape_result =
       fragment.TextShapeResult()->CreateShapeResult();
   if (!shape_result)
     return is_first_child;

   // Compute the offset to truncate.
   unsigned new_length = shape_result->OffsetToFit(
       IsLtr(line_direction_) ? space_for_child
                              : shape_result->Width() - space_for_child,
       line_direction_);
   DCHECK_LE(new_length, fragment.Length());
   if (!new_length || new_length == fragment.Length()) {
     if (!is_first_child)
       return false;
     new_length = !new_length ? 1 : new_length - 1;
   }

   // Truncate the text fragment.
   child->fragment = line_direction_ == shape_result->Direction()
                         ? fragment.TrimText(fragment.StartOffset(),
                                             fragment.StartOffset() + new_length)
                         : fragment.TrimText(fragment.StartOffset() + new_length,
                                             fragment.EndOffset());
   LayoutUnit new_inline_size = line_style_->IsHorizontalWritingMode()
                                    ? child->fragment->Size().width
                                    : child->fragment->Size().height;
   DCHECK_LE(new_inline_size, child->inline_size);
   if (UNLIKELY(IsRtl(line_direction_)))
     child->offset.inline_offset += child->inline_size - new_inline_size;
   child->inline_size = new_inline_size;
   return true;
 }

 }  // namespace blink
	// Copyright 2018 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "third_party/blink/renderer/core/layout/ng/inline/ng_line_truncator.h"

	#include "third_party/blink/renderer/core/layout/ng/inline/ng_inline_item_result.h"
	#include "third_party/blink/renderer/core/layout/ng/inline/ng_text_fragment_builder.h"
	#include "third_party/blink/renderer/core/layout/ng/ng_physical_box_fragment.h"
	#include "third_party/blink/renderer/platform/fonts/font_baseline.h"
	#include "third_party/blink/renderer/platform/fonts/shaping/harfbuzz_shaper.h"
	#include "third_party/blink/renderer/platform/fonts/shaping/shape_result_view.h"

	namespace blink {

	NGLineTruncator::NGLineTruncator(NGInlineNode& node,
	const NGLineInfo& line_info)
	: node_(node),
	line_style_(&line_info.LineStyle()),
	available_width_(line_info.AvailableWidth()),
	line_direction_(line_info.BaseDirection()) {}

	LayoutUnit NGLineTruncator::TruncateLine(
	LayoutUnit line_width,
	NGLineBoxFragmentBuilder::ChildList* line_box) {
	// Shape the ellipsis and compute its inline size.
	// The ellipsis is styled according to the line style.
	// https://drafts.csswg.org/css-ui/#ellipsing-details
	const ComputedStyle* ellipsis_style = line_style_.get();
	const Font& font = ellipsis_style->GetFont();
	const SimpleFontData* font_data = font.PrimaryFont();
	DCHECK(font_data);
	String ellipsis_text =
	font_data && font_data->GlyphForCharacter(kHorizontalEllipsisCharacter)
	? String(&kHorizontalEllipsisCharacter, 1)
	: String(u"...");
	HarfBuzzShaper shaper(ellipsis_text);
	scoped_refptr<ShapeResultView> ellipsis_shape_result =
	ShapeResultView::Create(shaper.Shape(&font, line_direction_).get());
	LayoutUnit ellipsis_width = ellipsis_shape_result->SnappedWidth();

	// Loop children from the logical last to the logical first to determine where
	// to place the ellipsis. Children maybe truncated or moved as part of the
	// process.
	LayoutUnit ellipsis_inline_offset;
	const NGPhysicalFragment* ellipsized_fragment = nullptr;
	if (IsLtr(line_direction_)) {
	NGLineBoxFragmentBuilder::Child* first_child = line_box->FirstInFlowChild();
	for (auto it = line_box->rbegin(); it != line_box->rend(); it++) {
	auto& child = *it;
	if (base::Optional<LayoutUnit> candidate = EllipsisOffset(
	line_width, ellipsis_width, &child == first_child, &child)) {
	ellipsis_inline_offset = *candidate;
	ellipsized_fragment = child.PhysicalFragment();
	DCHECK(ellipsized_fragment);
	break;
	}
	}
	} else {
	NGLineBoxFragmentBuilder::Child* first_child = line_box->LastInFlowChild();
	ellipsis_inline_offset = available_width_ - ellipsis_width;
	for (auto& child : *line_box) {
	if (base::Optional<LayoutUnit> candidate = EllipsisOffset(
	line_width, ellipsis_width, &child == first_child, &child)) {
	ellipsis_inline_offset = *candidate;
	ellipsized_fragment = child.PhysicalFragment();
	DCHECK(ellipsized_fragment);
	break;
	}
	}
	}

	// Abort if ellipsis could not be placed.
	if (!ellipsized_fragment)
	return line_width;

	// Now the offset of the ellpisis is determined. Place the ellpisis into the
	// line box.
	NGTextFragmentBuilder builder(node_, line_style_->GetWritingMode());
	DCHECK(ellipsized_fragment->GetLayoutObject() &&
	ellipsized_fragment->GetLayoutObject()->IsInline());
	builder.SetText(ellipsized_fragment->GetMutableLayoutObject(), ellipsis_text,
	ellipsis_style, true /* is_ellipsis_style */,
	std::move(ellipsis_shape_result));
	FontBaseline baseline_type = line_style_->GetFontBaseline();
	NGLineHeightMetrics ellipsis_metrics(font_data->GetFontMetrics(),
	baseline_type);
	line_box->AddChild(
	builder.ToTextFragment(),
	LogicalOffset{ellipsis_inline_offset, -ellipsis_metrics.ascent},
	ellipsis_width, 0);
	return std::max(ellipsis_inline_offset + ellipsis_width, line_width);
	}

	// Hide this child from being painted.
	void NGLineTruncator::HideChild(NGLineBoxFragmentBuilder::Child* child) {
	DCHECK(child->HasInFlowFragment());

	const NGPhysicalFragment* fragment = nullptr;
	if (const NGLayoutResult* layout_result = child->layout_result.get()) {
	// Need to propagate OOF descendants in this inline-block child.
	if (!layout_result->PhysicalFragment()
	.OutOfFlowPositionedDescendants()
	.IsEmpty())
	return;
	fragment = &layout_result->PhysicalFragment();
	} else {
	fragment = child->fragment.get();
	}
	DCHECK(fragment);

	// If this child has self painting layer, not producing fragments will not
	// suppress painting because layers are painted separately. Move it out of the
	// clipping area.
	if (fragment->HasSelfPaintingLayer()) {
	// \|available_width_\| may not be enough when the containing block has
	// paddings, because clipping is at the content box but ellipsizing is at
	// the padding box. Just move to the max because we don't know paddings,
	// and max should do what we need.
	child->offset.inline_offset = LayoutUnit::NearlyMax();
	return;
	}

	// TODO(kojii): Not producing fragments is the most clean and efficient way to
	// hide them, but we may want to revisit how to do this to reduce special
	// casing in other code.
	child->layout_result = nullptr;
	child->fragment = nullptr;
	}

	// Return the offset to place the ellipsis.
	//
	// This function may truncate or move the child so that the ellipsis can fit.
	base::Optional<LayoutUnit> NGLineTruncator::EllipsisOffset(
	LayoutUnit line_width,
	LayoutUnit ellipsis_width,
	bool is_first_child,
	NGLineBoxFragmentBuilder::Child* child) {
	// Leave out-of-flow children as is.
	if (!child->HasInFlowFragment())
	return base::nullopt;

	// Can't place ellipsis if this child is completely outside of the box.
	LayoutUnit child_inline_offset =
	IsLtr(line_direction_)
	? child->offset.inline_offset
	: line_width - (child->offset.inline_offset + child->inline_size);
	LayoutUnit space_for_child = available_width_ - child_inline_offset;
	if (space_for_child <= 0) {
	// This child is outside of the content box, but we still need to hide it.
	// When the box has paddings, this child outside of the content box maybe
	// still inside of the clipping box.
	if (!is_first_child)
	HideChild(child);
	return base::nullopt;
	}

	// At least part of this child is in the box.
	// If not all of this child can fit, try to truncate.
	space_for_child -= ellipsis_width;
	if (space_for_child < child->inline_size &&
	!TruncateChild(space_for_child, is_first_child, child)) {
	// This child is partially in the box, but it should not be visible because
	// earlier sibling will be truncated and ellipsized.
	if (!is_first_child)
	HideChild(child);
	return base::nullopt;
	}

	return IsLtr(line_direction_)
	? child->offset.inline_offset + child->inline_size
	: child->offset.inline_offset - ellipsis_width;
	}

	// Truncate the specified child. Returns true if truncated successfully, false
	// otherwise.
	//
	// Note that this function may return true even if it can't fit the child when
	// \|is_first_child\|, because the spec defines that the first character or atomic
	// inline-level element on a line must be clipped rather than ellipsed.
	// https://drafts.csswg.org/css-ui/#text-overflow
	bool NGLineTruncator::TruncateChild(LayoutUnit space_for_child,
	bool is_first_child,
	NGLineBoxFragmentBuilder::Child* child) {
	// If the space is not enough, try the next child.
	if (space_for_child <= 0 && !is_first_child)
	return false;

	// Only text fragments can be truncated.
	if (!child->fragment)
	return is_first_child;
	auto& fragment = To<NGPhysicalTextFragment>(*child->fragment);

	// No need to truncate empty results.
	if (!fragment.TextShapeResult())
	return is_first_child;

	// TODO(layout-dev): Add support for OffsetToFit to ShapeResultView to avoid
	// this copy.
	scoped_refptr<blink::ShapeResult> shape_result =
	fragment.TextShapeResult()->CreateShapeResult();
	if (!shape_result)
	return is_first_child;

	// Compute the offset to truncate.
	unsigned new_length = shape_result->OffsetToFit(
	IsLtr(line_direction_) ? space_for_child
	: shape_result->Width() - space_for_child,
	line_direction_);
	DCHECK_LE(new_length, fragment.Length());
	if (!new_length \|\| new_length == fragment.Length()) {
	if (!is_first_child)
	return false;
	new_length = !new_length ? 1 : new_length - 1;
	}

	// Truncate the text fragment.
	child->fragment = line_direction_ == shape_result->Direction()
	? fragment.TrimText(fragment.StartOffset(),
	fragment.StartOffset() + new_length)
	: fragment.TrimText(fragment.StartOffset() + new_length,
	fragment.EndOffset());
	LayoutUnit new_inline_size = line_style_->IsHorizontalWritingMode()
	? child->fragment->Size().width
	: child->fragment->Size().height;
	DCHECK_LE(new_inline_size, child->inline_size);
	if (UNLIKELY(IsRtl(line_direction_)))
	child->offset.inline_offset += child->inline_size - new_inline_size;
	child->inline_size = new_inline_size;
	return true;
	}

	} // namespace blink