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 157 matching lines @@
   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());
 
   cached_bounds_and_offset_valid_ = false;
 }
 
+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);
 }
 
+void RenderText::MoveCursorTo(size_t position, bool select) {
+  size_t caret_pos = GetIndexOfPreviousGrapheme(position);
+  SelectionModel::CaretPlacement placement = (caret_pos == position) ?
+      SelectionModel::LEADING : SelectionModel::TRAILING;
+  size_t selection_start = select ? GetSelectionStart() : position;
+  SelectionModel sel(selection_start, position, caret_pos, placement);
+  SetSelectionModel(sel);

[xji, 2011/08/18 22:47:54]

hmm... the functionality seems different from previous version. Why is this
change?  Without the change, what is wrong? Is there any case that caret_pos
could be equal to position (which means index of previous grapheme is the same
as current) except when postion ==0 and caret is placed at leading?

[msw, 2011/08/19 10:55:30]

This has been reincarnated as a convenience function to set the caret trailing
the cursor's previous grapheme (or lead the cursor if there is no previous
grapheme). This seems to be the intended behavior in numerous cases.

Without the change, my primary hurdle was SetCursorPosition assuming there was a
previous grapheme, and no convenient way to SetCursorPosition while retaining
the selection start.

I opted to check for a non-equal previous grapheme rather than checking for a
cursor at 0, because if the first character is complex, the cursor could
theoretically be at 1 with no previous grapheme.

[xji, 2011/08/19 17:38:13]

make sense.

but I think for complex script, say first characters are "a" and "b" which are
in one grapheme,
if the text is "a", when cursor is at index 1, previous grapheme is "a", index
is 0.
if the text is "ab", we should not allow cursor at index 1, even if cursor at
index 1, previous grapheme index is 0. 
So, the only case that caret_placement is leading is when position==0.

[msw, 2011/08/19 18:03:33]

Interesting, I wonder how that works with the IMEs and composition text, we'll
have to do some good testing around that, I think it's okay to address that in
followup changes.

+}
+
 bool RenderText::MoveCursorTo(const SelectionModel& selection) {
   bool changed = !selection.Equals(selection_model_);
   SetSelectionModel(selection);
   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());
@@ skipping 37 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);

[xji, 2011/08/18 22:47:54]

why this change?

[msw, 2011/08/19 10:55:30]

Convenience of built-in checking for s previous grapheme.

 }
 
 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 255 matching lines @@
 }
 
 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