DNCI [RenderText] Added font size options in RenderText.

ui/gfx/render_text.cc

 // Copyright (c) 2012 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 "ui/gfx/render_text.h"
 
 #include <algorithm>
 #include <climits>
 
 #include "base/command_line.h"
@@ skipping 349 matching lines @@
 
     canvas_->DrawLine(start_, end, paint_);
 
     if (clipped)
       canvas_->Restore();
 
     x += pieces_[i].first;
   }
 }
 
-StyleIterator::StyleIterator(const BreakList<SkColor>& colors,
+StyleIterator::StyleIterator(const BreakList<uint32_t>& font_sizes,
+                             const BreakList<SkColor>& colors,
                              const BreakList<BaselineStyle>& baselines,
                              const std::vector<BreakList<bool>>& styles)
-    : colors_(colors), baselines_(baselines), styles_(styles) {
+    : font_sizes_(font_sizes),
+      colors_(colors),
+      baselines_(baselines),
+      styles_(styles) {
+  font_size_ = font_sizes_.breaks().begin();
   color_ = colors_.breaks().begin();
   baseline_ = baselines_.breaks().begin();
   for (size_t i = 0; i < styles_.size(); ++i)
     style_.push_back(styles_[i].breaks().begin());
 }
 
 StyleIterator::~StyleIterator() {}
 
 Range StyleIterator::GetRange() const {
   Range range(colors_.GetRange(color_));
+  range = range.Intersect(font_sizes_.GetRange(font_size_));
   range = range.Intersect(baselines_.GetRange(baseline_));
   for (size_t i = 0; i < NUM_TEXT_STYLES; ++i)
     range = range.Intersect(styles_[i].GetRange(style_[i]));
   return range;
 }
 
 void StyleIterator::UpdatePosition(size_t position) {
+  font_size_ = font_sizes_.GetBreak(position);
   color_ = colors_.GetBreak(position);
   baseline_ = baselines_.GetBreak(position);
   for (size_t i = 0; i < NUM_TEXT_STYLES; ++i)
     style_[i] = styles_[i].GetBreak(position);
 }
 
 LineSegment::LineSegment() : width(0), run(0) {}
 
 LineSegment::~LineSegment() {}
 
@@ skipping 42 matching lines @@
 
 void RenderText::SetText(const base::string16& text) {
   DCHECK(!composition_range_.IsValid());
   if (text_ == text)
     return;
   text_ = text;
   UpdateStyleLengths();
 
   // Clear style ranges as they might break new text graphemes and apply
   // the first style to the whole text instead.
+  font_sizes_.SetValue(font_sizes_.breaks().begin()->second);
   colors_.SetValue(colors_.breaks().begin()->second);
   baselines_.SetValue(baselines_.breaks().begin()->second);
   for (size_t style = 0; style < NUM_TEXT_STYLES; ++style)
     styles_[style].SetValue(styles_[style].breaks().begin()->second);
   cached_bounds_and_offset_valid_ = false;
 
   // Reset selection model. SetText should always followed by SetSelectionModel
   // or SetCursorPosition in upper layer.
   SetSelectionModel(SelectionModel());
 
@@ skipping 14 matching lines @@
 }
 
 void RenderText::SetHorizontalAlignment(HorizontalAlignment alignment) {
   if (horizontal_alignment_ != alignment) {
     horizontal_alignment_ = alignment;
     display_offset_ = Vector2d();
     cached_bounds_and_offset_valid_ = false;
   }
 }
 
+void RenderText::SetVerticalAlignment(VerticalAlignment alignment) {
+  if (vertical_alignment_ != alignment) {
+    vertical_alignment_ = alignment;
+    display_offset_ = Vector2d();
+    cached_bounds_and_offset_valid_ = false;
+  }
+}
+
 void RenderText::SetFontList(const FontList& font_list) {
   font_list_ = font_list;
   const int font_style = font_list.GetFontStyle();
   SetStyle(BOLD, (font_style & gfx::Font::BOLD) != 0);
   SetStyle(ITALIC, (font_style & gfx::Font::ITALIC) != 0);
   SetStyle(UNDERLINE, (font_style & gfx::Font::UNDERLINE) != 0);
   baseline_ = kInvalidBaseline;
   cached_bounds_and_offset_valid_ = false;
   OnLayoutTextAttributeChanged(false);
 }
@@ skipping 195 matching lines @@
         Range(0, text_.length()).Contains(composition_range));
   composition_range_.set_end(composition_range.end());
   composition_range_.set_start(composition_range.start());
   // TODO(oshima|msw): Altering composition underlines shouldn't
   // require layout changes. It's currently necessary because
   // RenderTextHarfBuzz paints text decorations by run, and
   // RenderTextMac applies all styles during layout.
   OnLayoutTextAttributeChanged(false);
 }
 
+void RenderText::SetFontSize(uint32_t value) {
+  font_sizes_.SetValue(value);
+  cached_bounds_and_offset_valid_ = false;
+  OnLayoutTextAttributeChanged(false);
+}
+
+void RenderText::ApplyFontSize(uint32_t value, const Range& range) {
+  font_sizes_.ApplyValue(value, range);
+  cached_bounds_and_offset_valid_ = false;
+  OnLayoutTextAttributeChanged(false);
+}
+
 void RenderText::SetColor(SkColor value) {
   colors_.SetValue(value);
 }
 
 void RenderText::ApplyColor(SkColor value, const Range& range) {
   colors_.ApplyValue(value, range);
 }
 
 void RenderText::SetBaselineStyle(BaselineStyle value) {
   baselines_.SetValue(value);
@@ skipping 236 matching lines @@
   if (!multiline())
     offset.Add(GetUpdatedDisplayOffset());
   else
     offset.Add(Vector2d(0, lines_[line_number].preceding_heights));
   offset.Add(GetAlignmentOffset(line_number));
   return offset;
 }
 
 RenderText::RenderText()
     : horizontal_alignment_(base::i18n::IsRTL() ? ALIGN_RIGHT : ALIGN_LEFT),
+      vertical_alignment_(VALIGN_MIDDLE),
       directionality_mode_(DIRECTIONALITY_FROM_TEXT),
       text_direction_(base::i18n::UNKNOWN_DIRECTION),
       cursor_enabled_(true),
       cursor_visible_(false),
       insert_mode_(true),
       cursor_color_(kDefaultColor),
       selection_color_(kDefaultColor),
       selection_background_focused_color_(kDefaultSelectionBackgroundColor),
       focused_(false),
       composition_range_(Range::InvalidRange()),
+      font_sizes_(0),
       colors_(kDefaultColor),
       baselines_(NORMAL_BASELINE),
       styles_(NUM_TEXT_STYLES),
       composition_and_selection_styles_applied_(false),
       obscured_(false),
       obscured_reveal_index_(-1),
       truncate_length_(0),
       elide_behavior_(NO_ELIDE),
       text_elided_(false),
       min_line_height_(0),
@@ skipping 170 matching lines @@
     const int width = multiline_ ?
         std::ceil(lines_[line_number].size.width()) +
         (cursor_enabled_ ? 1 : 0) :
         GetContentWidth();
     offset.set_x(display_rect().width() - width);
     // Put any extra margin pixel on the left to match legacy behavior.
     if (horizontal_alignment == ALIGN_CENTER)
       offset.set_x((offset.x() + 1) / 2);
   }
 
-  // Vertically center the text.
+  // Vertically align the text.
   if (multiline_) {
-    const int text_height = lines_.back().preceding_heights +
-        lines_.back().size.height();
-    offset.set_y((display_rect_.height() - text_height) / 2);
+    const int text_height =
+        lines_.back().preceding_heights + lines_.back().size.height();
+    if (vertical_alignment_ == VALIGN_TOP) {
+      offset.set_y(lines_.back().preceding_heights);
+    } else if (vertical_alignment_ == VALIGN_BOTTOM) {
+      offset.set_y(display_rect_.height() - text_height);
+    } else {
+      // Vertically center the text.
+      offset.set_y((display_rect_.height() - text_height) / 2);
+    }
   } else {
-    offset.set_y(GetBaseline() - GetDisplayTextBaseline());
+    if (vertical_alignment_ == VALIGN_TOP) {
+      offset.set_y(0);
+    } else if (vertical_alignment_ == VALIGN_BOTTOM) {
+      offset.set_y(display_rect_.height() - font_list_.GetHeight());
+    } else {
+      // Vertically center the text.
+      offset.set_y(GetBaseline() - GetDisplayTextBaseline());
+    }
   }
-
   return offset;
 }
 
 void RenderText::ApplyFadeEffects(internal::SkiaTextRenderer* renderer) {
   const int width = display_rect().width();
   if (multiline() || elide_behavior_ != FADE_TAIL || GetContentWidth() <= width)
     return;
 
   const int gradient_width = CalculateFadeGradientWidth(font_list(), width);
   if (gradient_width == 0)
@@ skipping 62 matching lines @@
   DCHECK(given_text == layout_text() || given_text == display_text());
   DCHECK_LE(index, text().length());
   ptrdiff_t i = obscured() ? UTF16IndexToOffset(text(), 0, index) : index;
   CHECK_GE(i, 0);
   // Clamp indices to the length of the given layout or display text.
   return std::min<size_t>(given_text.length(), i);
 }
 
 void RenderText::UpdateStyleLengths() {
   const size_t text_length = text_.length();
+  font_sizes_.SetMax(text_length);
   colors_.SetMax(text_length);
   baselines_.SetMax(text_length);
   for (size_t style = 0; style < NUM_TEXT_STYLES; ++style)
     styles_[style].SetMax(text_length);
 }
 
 // static
 bool RenderText::RangeContainsCaret(const Range& range,
                                     size_t caret_pos,
                                     LogicalCursorDirection caret_affinity) {
@@ skipping 85 matching lines @@
 
   // Create a RenderText copy with attributes that affect the rendering width.
   scoped_ptr<RenderText> render_text = CreateInstanceOfSameType();
   render_text->SetFontList(font_list_);
   render_text->SetDirectionalityMode(directionality_mode_);
   render_text->SetCursorEnabled(cursor_enabled_);
   render_text->set_truncate_length(truncate_length_);
   render_text->styles_ = styles_;
   render_text->baselines_ = baselines_;
   render_text->colors_ = colors_;
+  render_text->font_sizes_ = font_sizes_;
   if (text_width == 0) {
     render_text->SetText(text);
     text_width = render_text->GetContentWidthF();
   }
   if (text_width <= available_width)
     return text;
 
   const base::string16 ellipsis = base::string16(kEllipsisUTF16);
   const bool insert_ellipsis = (behavior != TRUNCATE);
   const bool elide_in_middle = (behavior == ELIDE_MIDDLE);
@@ skipping 37 matching lines @@
           new_text += base::i18n::kRightToLeftMark;
       }
       render_text->SetText(new_text);
     }
 
     // Restore styles and baselines without breaking multi-character graphemes.
     render_text->styles_ = styles_;
     for (size_t style = 0; style < NUM_TEXT_STYLES; ++style)
       RestoreBreakList(render_text.get(), render_text->styles_[style]);
     RestoreBreakList(render_text.get(), baselines_);
+    RestoreBreakList(render_text.get(), font_sizes_);
 
     // We check the width of the whole desired string at once to ensure we
     // handle kerning/ligatures/etc. correctly.
     const float guess_width = render_text->GetContentWidthF();
     if (guess_width == available_width)
       break;
     if (guess_width > available_width) {
       hi = guess - 1;
       // Move back on the loop terminating condition when the guess is too wide.
       if (hi < lo)
@@ skipping 86 matching lines @@
 
   SetDisplayOffset(display_offset_.x() + delta_x);
 }
 
 void RenderText::DrawSelection(Canvas* canvas) {
   for (const Rect& s : GetSubstringBounds(selection()))
     canvas->FillRect(s, selection_background_focused_color_);
 }
 
 }  // namespace gfx