Always aligns text at vertically center (Textfield, Label).

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 <limits>
 
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "third_party/icu/source/common/unicode/rbbi.h"
 #include "third_party/icu/source/common/unicode/utf16.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/insets.h"
@@ skipping 19 matching lines @@
 
 // Fraction of the text size to lower a strike through below the baseline.
 const SkScalar kStrikeThroughOffset = (-SK_Scalar1 * 6 / 21);
 // Fraction of the text size to lower an underline below the baseline.
 const SkScalar kUnderlineOffset = (SK_Scalar1 / 9);
 // Fraction of the text size to use for a strike through or under-line.
 const SkScalar kLineThickness = (SK_Scalar1 / 18);
 // Fraction of the text size to use for a top margin of a diagonal strike.
 const SkScalar kDiagonalStrikeMarginOffset = (SK_Scalar1 / 4);
 
+// Invalid value of baseline.  Assigning this value to |baseline_| causes
+// re-calculation of baseline.
+const int kInvalidBaseline = std::numeric_limits<int>::max();
+
+// Returns the baseline, with which the text best appears vertically centered.
+int DetermineBaselineCenteringText(const Rect& display_rect,
+                                   const FontList& font_list) {
+  const int display_height = display_rect.height();
+  const int font_height = font_list.GetHeight();
+  // Lower and upper bound of baseline shift as we try to show as much area of
+  // text as possible.  In particular case of |display_height| == |font_height|,
+  // we do not want to shift the baseline.
+  const int min_shift = std::min(0, display_height - font_height);
+  const int max_shift = std::abs(display_height - font_height);
+  const int baseline = font_list.GetBaseline();
+  const int cap_height = font_list.GetCapHeight();
+  const int internal_leading = baseline - cap_height;
+  const int baseline_shift =
+      (display_height - cap_height) / 2 - internal_leading;
+  return baseline + std::max(min_shift, std::min(max_shift, baseline_shift));
+}
+
 // Converts |gfx::Font::FontStyle| flags to |SkTypeface::Style| flags.
 SkTypeface::Style ConvertFontStyleToSkiaTypefaceStyle(int font_style) {
   int skia_style = SkTypeface::kNormal;
   skia_style |= (font_style & gfx::Font::BOLD) ? SkTypeface::kBold : 0;
   skia_style |= (font_style & gfx::Font::ITALIC) ? SkTypeface::kItalic : 0;
   return static_cast<SkTypeface::Style>(skia_style);
 }
 
 // Given |font| and |display_width|, returns the width of the fade gradient.
 int CalculateFadeGradientWidth(const Font& font, int display_width) {
@@ skipping 284 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;
+  baseline_ = kInvalidBaseline;
   cached_bounds_and_offset_valid_ = false;
   ResetLayout();
 }
 
 void RenderText::SetFont(const Font& font) {
   SetFontList(FontList(font));
 }
 
 void RenderText::SetFontSize(int size) {
   SetFontList(font_list_.DeriveFontListWithSize(size));
@@ skipping 36 matching lines @@
 void RenderText::SetMultiline(bool multiline) {
   if (multiline != multiline_) {
     multiline_ = multiline;
     cached_bounds_and_offset_valid_ = false;
     lines_.clear();
   }
 }
 
 void RenderText::SetDisplayRect(const Rect& r) {
   display_rect_ = r;
+  baseline_ = kInvalidBaseline;
   cached_bounds_and_offset_valid_ = false;
   lines_.clear();
 }
 
 void RenderText::SetCursorPosition(size_t position) {
   MoveCursorTo(position, false);
 }
 
 void RenderText::MoveCursor(BreakType break_type,
                             VisualCursorDirection direction,
@@ skipping 219 matching lines @@
 
 SizeF RenderText::GetStringSizeF() {
   const Size size = GetStringSize();
   return SizeF(size.width(), size.height());
 }
 
 int RenderText::GetContentWidth() {
   return GetStringSize().width() + (cursor_enabled_ ? 1 : 0);
 }
 
+int RenderText::GetBaseline() {
+  if (baseline_ == kInvalidBaseline)
+    baseline_ = DetermineBaselineCenteringText(display_rect(), font_list());
+  DCHECK_NE(kInvalidBaseline, baseline_);
+  return baseline_;
+}
+
 void RenderText::Draw(Canvas* canvas) {
   EnsureLayout();
 
   if (clip_to_display_rect()) {
     Rect clip_rect(display_rect());
     clip_rect.Inset(ShadowValue::GetMargin(text_shadows_));
 
     canvas->Save();
     canvas->ClipRect(clip_rect);
   }
@@ skipping 111 matching lines @@
   return SelectionModel(sel.start(),
                         sel.is_reversed() ? CURSOR_BACKWARD : CURSOR_FORWARD);
 }
 
 void RenderText::SetTextShadows(const ShadowValues& shadows) {
   text_shadows_ = shadows;
 }
 
 RenderText::RenderText()
     : horizontal_alignment_(base::i18n::IsRTL() ? ALIGN_RIGHT : ALIGN_LEFT),
-      vertical_alignment_(ALIGN_VCENTER),
       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()),
       colors_(kDefaultColor),
       styles_(NUM_TEXT_STYLES),
       composition_and_selection_styles_applied_(false),
       obscured_(false),
       obscured_reveal_index_(-1),
       truncate_length_(0),
       multiline_(false),
       fade_head_(false),
       fade_tail_(false),
       background_is_transparent_(false),
       clip_to_display_rect_(true),
+      baseline_(kInvalidBaseline),
       cached_bounds_and_offset_valid_(false) {
 }
 
 const Vector2d& RenderText::GetUpdatedDisplayOffset() {
   UpdateCachedBoundsAndOffset();
   return display_offset_;
 }
 
 SelectionModel RenderText::GetAdjacentSelectionModel(
     const SelectionModel& current,
@@ skipping 143 matching lines @@
 #if defined(OS_WIN)
     const int width = lines_[line_number].size.width() +
         (cursor_enabled_ ? 1 : 0);
 #else
     const int width = GetContentWidth();
 #endif
     offset.set_x(display_rect().width() - width);
     if (horizontal_alignment_ == ALIGN_CENTER)
       offset.set_x(offset.x() / 2);
   }
-  if (vertical_alignment_ != ALIGN_TOP) {
-    offset.set_y(display_rect().height() - GetStringSize().height());
-    if (vertical_alignment_ == ALIGN_VCENTER)
-      offset.set_y(offset.y() / 2);
-  }
+  offset.set_y(GetBaseline() - GetLayoutTextBaseline());
   return offset;
 }
 
 void RenderText::ApplyFadeEffects(internal::SkiaTextRenderer* renderer) {
   if (multiline() || (!fade_head() && !fade_tail()))
     return;
 
   const int display_width = display_rect().width();
 
   // If the text fits as-is, no need to fade.
@@ skipping 145 matching lines @@
   cursor_bounds_ += delta_offset;
 }
 
 void RenderText::DrawSelection(Canvas* canvas) {
   const std::vector<Rect> sel = GetSubstringBounds(selection());
   for (std::vector<Rect>::const_iterator i = sel.begin(); i < sel.end(); ++i)
     canvas->FillRect(*i, selection_background_focused_color_);
 }
 
 }  // namespace gfx