Implement Uniscribe RenderText for Windows.

ui/gfx/render_text.cc

 // Copyright (c) 2011 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 "base/i18n/break_iterator.h"
 #include "base/logging.h"
@@ skipping 146 matching lines @@
       }
     }
     style_ranges_.back().range.set_end(text_.length());
   }
 #ifndef NDEBUG
   CheckStyleRanges(style_ranges_, text_.length());
 #endif
   cached_bounds_and_offset_valid_ = false;
 }
 
-void RenderText::SetSelectionModel(const SelectionModel& sel) {
-  size_t start = sel.selection_start();
-  size_t end = sel.selection_end();
-  selection_model_.set_selection_start(std::min(start, text().length()));
-  selection_model_.set_selection_end(std::min(end, text().length()));
-  selection_model_.set_caret_pos(std::min(sel.caret_pos(), text().length()));
-  selection_model_.set_caret_placement(sel.caret_placement());
-
+void RenderText::ToggleInsertMode() {
+  insert_mode_ = !insert_mode_;
   cached_bounds_and_offset_valid_ = false;
 }
 
 void RenderText::SetDisplayRect(const Rect& r) {
   display_rect_ = r;
   cached_bounds_and_offset_valid_ = false;
 }
 
 size_t RenderText::GetCursorPosition() const {
   return selection_model_.selection_end();
 }
 
-void RenderText::SetCursorPosition(const size_t position) {
-  SelectionModel sel(selection_model());
-  sel.set_selection_start(position);
-  sel.set_selection_end(position);
-  sel.set_caret_pos(GetIndexOfPreviousGrapheme(position));
-  sel.set_caret_placement(SelectionModel::TRAILING);
-  SetSelectionModel(sel);
+void RenderText::SetCursorPosition(size_t position) {
+  MoveCursorTo(position, false);
 }
 
 void RenderText::MoveCursorLeft(BreakType break_type, bool select) {
   SelectionModel position(selection_model());
   position.set_selection_start(GetCursorPosition());
   // Cancelling a selection moves to the edge of the selection.
   if (break_type != LINE_BREAK && !EmptySelection() && !select) {
     // Use the selection start if it is left of the selection end.
     SelectionModel selection_start(GetSelectionStart(), GetSelectionStart(),
                                    SelectionModel::LEADING);
@@ skipping 26 matching lines @@
     if (break_type == WORD_BREAK)
       position = GetRightSelectionModel(position, break_type);
   } else {
     position = GetRightSelectionModel(position, break_type);
   }
   if (select)
     position.set_selection_start(GetSelectionStart());
   MoveCursorTo(position);
 }
 
-bool RenderText::MoveCursorTo(const SelectionModel& selection) {
-  bool changed = !selection.Equals(selection_model_);
-  SetSelectionModel(selection);
+bool RenderText::MoveCursorTo(const SelectionModel& selection_model) {
+  SelectionModel sel(selection_model);
+  size_t text_length = text().length();
+  // Enforce valid selection model components.
+  if (sel.selection_start() > text_length)
+    sel.set_selection_start(text_length);
+  if (sel.selection_end() > text_length)
+    sel.set_selection_end(text_length);
+  // The current model only supports caret positions at valid character indices.
+  if (text_length == 0) {
+    sel.set_caret_pos(0);
+    sel.set_caret_placement(SelectionModel::LEADING);
+  } else if (sel.caret_pos() >= text_length) {
+    SelectionModel end = GetTextDirection() == base::i18n::RIGHT_TO_LEFT ?
+        LeftEndSelectionModel() : RightEndSelectionModel();
+    sel.set_caret_pos(end.caret_pos());
+    sel.set_caret_placement(end.caret_placement());
+  }
+  bool changed = !sel.Equals(selection_model_);
+  SetSelectionModel(sel);
   return changed;
 }
 
 bool RenderText::MoveCursorTo(const Point& point, bool select) {
   SelectionModel selection = FindCursorPosition(point);
   if (select)
     selection.set_selection_start(GetSelectionStart());
   return MoveCursorTo(selection);
 }
 
 bool RenderText::IsPointInSelection(const Point& point) {
+  if (EmptySelection())
+    return false;
   // TODO(xji): should this check whether the point is inside the visual
   // selection bounds? In case of "abcFED", if "ED" is selected, |point| points
   // to the right half of 'c', is the point in selection?
   size_t pos = FindCursorPosition(point).selection_end();
   return (pos >= MinOfSelection() && pos < MaxOfSelection());
 }
 
 void RenderText::ClearSelection() {
   SelectionModel sel(selection_model());
   sel.set_selection_start(GetCursorPosition());
   SetSelectionModel(sel);
 }
 
 void RenderText::SelectAll() {
-  SelectionModel sel(0, text().length(),
-                     text().length(), SelectionModel::LEADING);
+  SelectionModel sel(RightEndSelectionModel());
+  sel.set_selection_start(LeftEndSelectionModel().selection_start());
   SetSelectionModel(sel);
 }
 
 // TODO(xji): it does not work for languages do not use space as word breaker,
 // such as Chinese. Should use BreakIterator.
 void RenderText::SelectWord() {
   size_t selection_start = GetSelectionStart();
   size_t cursor_position = GetCursorPosition();
   // First we setup selection_start_ and selection_end_. There are so many cases
   // because we try to emulate what select-word looks like in a gtk textfield.
@@ skipping 21 matching lines @@
   }
 
   // Now we move selection_end_ to end of selection. Selection boundary
   // is defined as the position where we have alpha-num character on one side
   // and non-alpha-num char on the other side.
   for (; cursor_position < text().length(); cursor_position++) {
     if (IsPositionAtWordSelectionBoundary(cursor_position))
       break;
   }
 
-  SelectionModel sel(selection_model());
-  sel.set_selection_start(selection_start);
-  sel.set_selection_end(cursor_position);
-  sel.set_caret_pos(GetIndexOfPreviousGrapheme(cursor_position));
-  sel.set_caret_placement(SelectionModel::TRAILING);
-  SetSelectionModel(sel);
+  MoveCursorTo(selection_start, false);
+  MoveCursorTo(cursor_position, true);
 }
 
 const ui::Range& RenderText::GetCompositionRange() const {
   return composition_range_;
 }
 
 void RenderText::SetCompositionRange(const ui::Range& composition_range) {
   CHECK(!composition_range.IsValid() ||
         ui::Range(0, text_.length()).Contains(composition_range));
   composition_range_.set_end(composition_range.end());
@@ skipping 16 matching lines @@
 
 void RenderText::ApplyDefaultStyle() {
   style_ranges_.clear();
   StyleRange style = StyleRange(default_style_);
   style.range.set_end(text_.length());
   style_ranges_.push_back(style);
   cached_bounds_and_offset_valid_ = false;
 }
 
 base::i18n::TextDirection RenderText::GetTextDirection() const {
-  // TODO(msw): Bidi implementation, intended to replace the functionality added
-  //  in crrev.com/91881 (discussed in codereview.chromium.org/7324011).
+  if (base::i18n::IsRTL())
+    return base::i18n::RIGHT_TO_LEFT;
   return base::i18n::LEFT_TO_RIGHT;
 }
 
 int RenderText::GetStringWidth() {
   return default_style_.font.GetStringWidth(text());
 }
 
 void RenderText::Draw(Canvas* canvas) {
   // Clip the canvas to the text display area.
   canvas->ClipRectInt(display_rect_.x(), display_rect_.y(),
@@ skipping 71 matching lines @@
     } else if (pivot == x) {
       return SelectionModel(pivot_pos);
     } else {
       right = pivot;
       right_pos = pivot_pos;
     }
   }
   return SelectionModel(left_pos);
 }
 
-std::vector<Rect> RenderText::GetSubstringBounds(size_t from, size_t to) {
-  size_t start = std::min(from, to);
-  size_t end = std::max(from, to);
-  const Font& font = default_style_.font;
-  int start_x = font.GetStringWidth(text().substr(0, start));
-  int end_x = font.GetStringWidth(text().substr(0, end));
-  Rect rect(start_x, 0, end_x - start_x, font.GetHeight());
-  rect.Offset(display_rect_.origin());
-  rect.Offset(GetUpdatedDisplayOffset());
-  // Center the rect vertically in |display_rect_|.
-  rect.Offset(Point(0, (display_rect_.height() - rect.height()) / 2));
-  return std::vector<Rect>(1, rect);
-}
-
 Rect RenderText::GetCursorBounds(const SelectionModel& selection,
                                  bool insert_mode) {
   size_t from = selection.selection_end();
   size_t to = insert_mode ? from : std::min(text_.length(), from + 1);
   return GetSubstringBounds(from, to)[0];
 }
 
 const Rect& RenderText::GetUpdatedCursorBounds() {
   UpdateCachedBoundsAndOffset();
   return cursor_bounds_;
@@ skipping 72 matching lines @@
   if (!success)
     return current;
   while (iter.Advance()) {
     pos = iter.pos();
     if (iter.IsWord() && pos > current.selection_end())
       break;
   }
   return SelectionModel(pos, pos, SelectionModel::LEADING);
 }
 
+SelectionModel RenderText::LeftEndSelectionModel() {
+  return SelectionModel(0, 0, SelectionModel::LEADING);
+}
+
+SelectionModel RenderText::RightEndSelectionModel() {
+  size_t cursor = text().length();
+  size_t caret_pos = GetIndexOfPreviousGrapheme(cursor);
+  SelectionModel::CaretPlacement placement = (caret_pos == cursor) ?
+      SelectionModel::LEADING : SelectionModel::TRAILING;
+  return SelectionModel(cursor, caret_pos, placement);
+}
+
 size_t RenderText::GetIndexOfPreviousGrapheme(size_t position) {
   // TODO(msw): Handle complex script.
-  return std::max(static_cast<int>(position - 1), static_cast<int>(0));
+  return std::max(static_cast<long>(position - 1), static_cast<long>(0));
+}
+
+std::vector<Rect> RenderText::GetSubstringBounds(size_t from, size_t to) {
+  size_t start = std::min(from, to);
+  size_t end = std::max(from, to);
+  const Font& font = default_style_.font;
+  int start_x = font.GetStringWidth(text().substr(0, start));
+  int end_x = font.GetStringWidth(text().substr(0, end));
+  Rect rect(start_x, 0, end_x - start_x, font.GetHeight());
+  rect.Offset(display_rect_.origin());
+  rect.Offset(GetUpdatedDisplayOffset());
+  // Center the rect vertically in |display_rect_|.
+  rect.Offset(Point(0, (display_rect_.height() - rect.height()) / 2));
+  return std::vector<Rect>(1, rect);
 }
 
 void RenderText::ApplyCompositionAndSelectionStyles(
     StyleRanges* style_ranges) const {
   // TODO(msw): This pattern ought to be reconsidered; what about composition
   //            and selection overlaps, retain existing local style features?
   // Apply a composition style override to a copy of the style ranges.
   if (composition_range_.IsValid() && !composition_range_.is_empty()) {
     StyleRange composition_style(default_style_);
     composition_style.underline = true;
     composition_style.range.set_start(composition_range_.start());
     composition_style.range.set_end(composition_range_.end());
     ApplyStyleRangeImpl(style_ranges, composition_style);
   }
   // Apply a selection style override to a copy of the style ranges.
   if (!EmptySelection()) {
     StyleRange selection_style(default_style_);
     selection_style.foreground = kSelectedTextColor;
     selection_style.range.set_start(MinOfSelection());
     selection_style.range.set_end(MaxOfSelection());
     ApplyStyleRangeImpl(style_ranges, selection_style);
   }
 }
 
+Point RenderText::ToTextPoint(const Point& point) {
+  Point p(point.Subtract(display_rect().origin()));
+  p = p.Subtract(GetUpdatedDisplayOffset());
+  if (base::i18n::IsRTL())
+    p.Offset(GetStringWidth() - display_rect().width() + 1, 0);
+  return p;
+}
+
+Point RenderText::ToViewPoint(const Point& point) {
+  Point p(point.Add(display_rect().origin()));
+  p = p.Add(GetUpdatedDisplayOffset());
+  if (base::i18n::IsRTL())
+    p.Offset(display_rect().width() - GetStringWidth() - 1, 0);
+  return p;
+}
+
+void RenderText::SetSelectionModel(const SelectionModel& selection_model) {
+  DCHECK_LE(selection_model.selection_start(), text().length());
+  selection_model_.set_selection_start(selection_model.selection_start());
+  DCHECK_LE(selection_model.selection_end(), text().length());
+  selection_model_.set_selection_end(selection_model.selection_end());
+  DCHECK_LT(selection_model.caret_pos(),
+            std::max(text().length(), static_cast<size_t>(1)));
+  selection_model_.set_caret_pos(selection_model.caret_pos());
+  selection_model_.set_caret_placement(selection_model.caret_placement());
+
+  cached_bounds_and_offset_valid_ = false;
+}
+
+void RenderText::MoveCursorTo(size_t position, bool select) {
+  size_t cursor = std::min(position, text().length());
+  size_t caret_pos = GetIndexOfPreviousGrapheme(cursor);
+  SelectionModel::CaretPlacement placement = (caret_pos == cursor) ?
+      SelectionModel::LEADING : SelectionModel::TRAILING;
+  size_t selection_start = select ? GetSelectionStart() : cursor;
+  SelectionModel sel(selection_start, cursor, caret_pos, placement);
+  SetSelectionModel(sel);
+}
+
 bool RenderText::IsPositionAtWordSelectionBoundary(size_t pos) {
   return pos == 0 || (u_isalnum(text()[pos - 1]) && !u_isalnum(text()[pos])) ||
       (!u_isalnum(text()[pos - 1]) && u_isalnum(text()[pos]));
 }
 
 void RenderText::UpdateCachedBoundsAndOffset() {
   if (cached_bounds_and_offset_valid_)
     return;
   // First, set the valid flag true to calculate the current cursor bounds using
   // the stale |display_offset_|. Applying |delta_offset| at the end of this
   // function will set |cursor_bounds_| and |display_offset_| to correct values.
   cached_bounds_and_offset_valid_ = true;
   cursor_bounds_ = GetCursorBounds(selection_model_, insert_mode_);
-  cursor_bounds_.set_width(std::max(cursor_bounds_.width(), 1));
   // Update |display_offset_| to ensure the current cursor is visible.
   int display_width = display_rect_.width();
   int string_width = GetStringWidth();
   int delta_offset = 0;
   if (string_width < display_width) {
     // Show all text whenever the text fits to the size.
     delta_offset = -display_offset_.x();
   } else if (cursor_bounds_.right() > display_rect_.right()) {
     // Pan to show the cursor when it overflows to the right,
     delta_offset = display_rect_.right() - cursor_bounds_.right();
   } else if (cursor_bounds_.x() < display_rect_.x()) {
     // Pan to show the cursor when it overflows to the left.
     delta_offset = display_rect_.x() - cursor_bounds_.x();
   }
   display_offset_.Offset(delta_offset, 0);
   cursor_bounds_.Offset(delta_offset, 0);
 }
 
 }  // namespace gfx