adding baseline options for super/sub scripting

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 156 matching lines @@
     FontRenderParams::Hinting params_hinting) {
   switch (params_hinting) {
     case FontRenderParams::HINTING_NONE:   return SkPaint::kNo_Hinting;
     case FontRenderParams::HINTING_SLIGHT: return SkPaint::kSlight_Hinting;
     case FontRenderParams::HINTING_MEDIUM: return SkPaint::kNormal_Hinting;
     case FontRenderParams::HINTING_FULL:   return SkPaint::kFull_Hinting;
   }
   return SkPaint::kNo_Hinting;
 }
 
+// Make sure ranges don't break text graphemes.  If a range in |break_list|
+// does break a grapheme in |render_text|, the range will be slightly
+// extended to encompass the grapheme.
+template <typename T>
+void RestoreBreakList(RenderText* render_text, BreakList<T>& break_list) {
+  break_list.SetMax(render_text->text().length());
+  Range range;
+  while (range.end() < break_list.max()) {
+    const auto& current_break = break_list.GetBreak(range.end());
+    range = break_list.GetRange(current_break);
+    if (range.end() < break_list.max() &&
+        !render_text->IsValidCursorIndex(range.end())) {
+      range.set_end(
+          render_text->IndexOfAdjacentGrapheme(range.end(), CURSOR_FORWARD));
+      break_list.ApplyValue(current_break->second, range);
+    }
+  }
+}
+
 }  // namespace
 
 namespace internal {
 
 // Value of |underline_thickness_| that indicates that underline metrics have
 // not been set explicitly.
 const SkScalar kUnderlineMetricsNotSet = -1.0f;
 
 SkiaTextRenderer::SkiaTextRenderer(Canvas* canvas)
     : canvas_(canvas),
@@ skipping 155 matching lines @@
     canvas_->DrawLine(start_, end, paint_);
 
     if (clipped)
       canvas_->Restore();
 
     x += pieces_[i].first;
   }
 }
 
 StyleIterator::StyleIterator(const BreakList<SkColor>& colors,
-                             const std::vector<BreakList<bool> >& styles)
-    : colors_(colors),
-      styles_(styles) {
+                             const BreakList<BaselineStyle>& baselines,
+                             const std::vector<BreakList<bool>>& styles)
+    : colors_(colors), baselines_(baselines), styles_(styles) {
   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(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) {
   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() {}
 
 Line::Line() : preceding_heights(0), baseline(0) {}
 
@@ skipping 35 matching lines @@
 RenderText* RenderText::CreateInstanceForEditing() {
   return new RenderTextHarfBuzz;
 }
 
 void RenderText::SetText(const base::string16& text) {
   DCHECK(!composition_range_.IsValid());
   if (text_ == text)
     return;
   text_ = text;
 
-  // Adjust ranged styles and colors to accommodate a new text length.
-  // Clear style ranges as they might break new text graphemes and apply
+  // Adjust ranged styles, baselines, and colors to accommodate a new text
+  // length. Clear style ranges as they might break new text graphemes and apply
   // the first style to the whole text instead.
   const size_t text_length = text_.length();
   colors_.SetMax(text_length);
+  baselines_.SetValue(baselines_.breaks().begin()->second);
+  baselines_.SetMax(text_length);
   for (size_t style = 0; style < NUM_TEXT_STYLES; ++style) {
     BreakList<bool>& break_list = styles_[style];
     break_list.SetValue(break_list.breaks().begin()->second);
     break_list.SetMax(text_length);
   }
   cached_bounds_and_offset_valid_ = false;
 
   // Reset selection model. SetText should always followed by SetSelectionModel
   // or SetCursorPosition in upper layer.
   SetSelectionModel(SelectionModel());
@@ skipping 222 matching lines @@
 }
 
 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);
+}
+
+void RenderText::ApplyBaselineStyle(BaselineStyle value, const Range& range) {
+  baselines_.ApplyValue(value, range);
+}
+
 void RenderText::SetStyle(TextStyle style, bool value) {
   styles_[style].SetValue(value);
 
   cached_bounds_and_offset_valid_ = false;
   // TODO(oshima|msw): Not all style change requires layout changes.
   // Consider optimizing based on the type of change.
   OnLayoutTextAttributeChanged(false);
 }
 
 void RenderText::ApplyStyle(TextStyle style, bool value, const Range& range) {
@@ skipping 220 matching lines @@
       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()),
       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),
       multiline_(false),
       subpixel_rendering_suppressed_(false),
@@ skipping 356 matching lines @@
 
   TRACE_EVENT0("ui", "RenderText::Elide");
 
   // 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_;
   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);
   const bool elide_at_beginning = (behavior == ELIDE_HEAD);
 
   if (insert_ellipsis) {
     render_text->SetText(ellipsis);
     const float ellipsis_width = render_text->GetContentWidthF();
     if (ellipsis_width > available_width)
       return base::string16();
   }
 
   StringSlicer slicer(text, ellipsis, elide_in_middle, elide_at_beginning);
 
   // Use binary search to compute the elided text.
   size_t lo = 0;
   size_t hi = text.length() - 1;
   const base::i18n::TextDirection text_direction = GetTextDirection(text);
   for (size_t guess = (lo + hi) / 2; lo <= hi; guess = (lo + hi) / 2) {
     // Restore colors. They will be truncated to size by SetText.
     render_text->colors_ = colors_;
+    render_text->baselines_ = baselines_;

[msw, 2015/02/25 16:02:33]

I think you can remove this with the call to RestoreBreakList below.

[dschuyler, 2015/02/26 02:11:02]

Done.

     base::string16 new_text =
         slicer.CutString(guess, insert_ellipsis && behavior != ELIDE_TAIL);
     render_text->SetText(new_text);
 
     // This has to be an additional step so that the ellipsis is rendered with
     // same style as trailing part of the text.
     if (insert_ellipsis && behavior == ELIDE_TAIL) {
       // When ellipsis follows text whose directionality is not the same as that
       // of the whole text, it will be rendered with the directionality of the
       // whole text. Since we want ellipsis to indicate continuation of the
       // preceding text, we force the directionality of ellipsis to be same as
       // the preceding text using LTR or RTL markers.
       base::i18n::TextDirection trailing_text_direction =
           base::i18n::GetLastStrongCharacterDirection(new_text);
       new_text.append(ellipsis);
       if (trailing_text_direction != text_direction) {
         if (trailing_text_direction == base::i18n::LEFT_TO_RIGHT)
           new_text += base::i18n::kLeftToRightMark;
         else
           new_text += base::i18n::kRightToLeftMark;
       }
       render_text->SetText(new_text);
     }
 
-    // Restore styles. Make sure style ranges don't break new text graphemes.
+    // Restore styles and baselines without breaking multi-character graphemes.
     render_text->styles_ = styles_;
-    for (size_t style = 0; style < NUM_TEXT_STYLES; ++style) {
-      BreakList<bool>& break_list = render_text->styles_[style];
-      break_list.SetMax(render_text->text_.length());
-      Range range;
-      while (range.end() < break_list.max()) {
-        BreakList<bool>::const_iterator current_break =
-            break_list.GetBreak(range.end());
-        range = break_list.GetRange(current_break);
-        if (range.end() < break_list.max() &&
-            !render_text->IsValidCursorIndex(range.end())) {
-          range.set_end(render_text->IndexOfAdjacentGrapheme(range.end(),
-                                                             CURSOR_FORWARD));
-          break_list.ApplyValue(current_break->second, range);
-        }
-      }
-    }
+    for (size_t style = 0; style < NUM_TEXT_STYLES; ++style)
+      RestoreBreakList(render_text.get(), render_text->styles_[style]);
+    RestoreBreakList(render_text.get(), baselines_);
 
     // 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