MacViews: Implement Force Touch/Mac dictionary lookup for Textfields.

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 <limits.h>
 
 #include <algorithm>
 #include <climits>
@@ skipping 703 matching lines @@
 }
 
 void RenderText::SelectAll(bool reversed) {
   const size_t length = text().length();
   const Range all = reversed ? Range(length, 0) : Range(0, length);
   const bool success = SelectRange(all);
   DCHECK(success);
 }
 
 void RenderText::SelectWord() {
-  if (obscured_) {
-    SelectAll(false);
-    return;
-  }
-
-  size_t selection_max = selection().GetMax();
-
-  base::i18n::BreakIterator iter(text(), base::i18n::BreakIterator::BREAK_WORD);
-  bool success = iter.Init();
-  DCHECK(success);
-  if (!success)
-    return;
-
-  size_t selection_min = selection().GetMin();
-  if (selection_min == text().length() && selection_min != 0)
-    --selection_min;
-
-  for (; selection_min != 0; --selection_min) {
-    if (iter.IsStartOfWord(selection_min) ||
-        iter.IsEndOfWord(selection_min))
-      break;
-  }
-
-  if (selection_min == selection_max && selection_max != text().length())
-    ++selection_max;
-
-  for (; selection_max < text().length(); ++selection_max)
-    if (iter.IsEndOfWord(selection_max) || iter.IsStartOfWord(selection_max))
-      break;
-
-  const bool reversed = selection().is_reversed();
-  MoveCursorTo(reversed ? selection_max : selection_min, false);
-  MoveCursorTo(reversed ? selection_min : selection_max, true);
+  SelectRange(ExpandRangeToWordBoundary(selection()));
 }
 
 void RenderText::SetCompositionRange(const Range& composition_range) {
   CHECK(!composition_range.IsValid() ||
         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
@@ skipping 268 matching lines @@
   Vector2d offset = display_rect().OffsetFromOrigin();
   // TODO(ckocagil): Apply the display offset for multiline scrolling.
   if (!multiline())
     offset.Add(GetUpdatedDisplayOffset());
   else
     offset.Add(Vector2d(0, lines_[line_number].preceding_heights));
   offset.Add(GetAlignmentOffset(line_number));
   return offset;
 }
 
+bool RenderText::GetDecoratedWordAtPoint(const Point& point,
+                                         DecoratedText* decorated_word,
+                                         Point* baseline_point) {
+  // FindCursorPosition doesn't currently support multiline.
+  if (multiline() || obscured())
+    return false;
+
+  const SelectionModel model_at_point = FindCursorPosition(point);
+  const size_t word_index =
+      GetNearestWordStartBoundary(model_at_point.caret_pos());
+  if (word_index >= text().length())
+    return false;
+
+  const Range word_range = ExpandRangeToWordBoundary(Range(word_index));
+  DCHECK(!word_range.is_reversed());
+  DCHECK(!word_range.is_empty());
+
+  if (!GetDecoratedTextForRange(word_range, decorated_word))
+    return false;
+
+  const std::vector<Rect> word_bounds = GetSubstringBounds(word_range);

[karandeepb, 2016/09/22 08:17:39]

Had to change the approach here and use GetSubstringBounds instead of
GetCursorBounds. Reason is that for bidi text, can't find a way to determine the
index of the leftmost glyph.

+  if (word_bounds.empty())
+    return false;
+
+  const Rect* left_rect = &word_bounds[0];
+  for (const Rect& rect : word_bounds)
+    if (rect.x() < left_rect->x())
+      left_rect = &rect;
+
+  *baseline_point = left_rect->origin() + Vector2d(0, GetDisplayTextBaseline());
+  return true;
+}
+
+base::string16 RenderText::GetTextFromRange(const Range& range) const {
+  if (range.IsValid() && range.GetMin() < text().length())
+    return text().substr(range.GetMin(), range.length());
+  return base::string16();
+}
+
 RenderText::RenderText()
     : horizontal_alignment_(base::i18n::IsRTL() ? ALIGN_RIGHT : ALIGN_LEFT),
       directionality_mode_(DIRECTIONALITY_FROM_TEXT),
       text_direction_(base::i18n::UNKNOWN_DIRECTION),
       cursor_enabled_(true),
       cursor_visible_(false),
       cursor_color_(kDefaultColor),
       selection_color_(kDefaultColor),
       selection_background_focused_color_(kDefaultSelectionBackgroundColor),
       focused_(false),
@@ skipping 565 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_);
 }
 
+size_t RenderText::GetNearestWordStartBoundary(size_t index) const {
+  const size_t length = text().length();
+  if (obscured())
+    return length;
+
+  base::i18n::BreakIterator iter(text(), base::i18n::BreakIterator::BREAK_WORD);
+  const bool success = iter.Init();
+  DCHECK(success);
+  if (!success)
+    return length;
+
+  // First search for the word start boundary in the CURSOR_BACKWARD direction,
+  // then in the CURSOR_FORWARD direction.
+  for (int i = std::min<int>(index, (int)length - 1); i >= 0; i--)
+    if (iter.IsStartOfWord(i))
+      return i;
+
+  for (size_t i = index + 1; i < length; i++)
+    if (iter.IsStartOfWord(i))
+      return i;
+
+  return length;
+}
+
+Range RenderText::ExpandRangeToWordBoundary(const Range& range) const {
+  const size_t length = text().length();
+  DCHECK(range.GetMax() <= length);
+  if (obscured())
+    return range.is_reversed() ? Range(length, 0) : Range(0, length);
+
+  base::i18n::BreakIterator iter(text(), base::i18n::BreakIterator::BREAK_WORD);
+  const bool success = iter.Init();
+  DCHECK(success);
+  if (!success)
+    return range;
+
+  size_t range_min = range.GetMin();
+  if (range_min == length && range_min != 0)
+    --range_min;
+
+  for (; range_min != 0; --range_min) {
+    if (iter.IsStartOfWord(range_min) || iter.IsEndOfWord(range_min))
+      break;
+  }
+
+  size_t range_max = range.GetMax();
+  if (range_min == range_max && range_max != length)
+    ++range_max;
+
+  for (; range_max < length; ++range_max)
+    if (iter.IsEndOfWord(range_max) || iter.IsStartOfWord(range_max))
+      break;
+
+  return range.is_reversed() ? Range(range_max, range_min)
+                             : Range(range_min, range_max);
+}
+
 }  // namespace gfx