Implement Pango RenderText for Linux.

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 117 matching lines @@
   selection_start_ = start;
   selection_end_ = end;
   caret_pos_ = pos;
   caret_placement_ = placement;
 }
 
 RenderText::~RenderText() {
 }
 
 void RenderText::SetText(const string16& text) {
+  DCHECK(!composition_range_.IsValid());
   size_t old_text_length = text_.length();
   text_ = text;
 
   // Update the style ranges as needed.
   if (text_.empty()) {
     style_ranges_.clear();
   } else if (style_ranges_.empty()) {
     ApplyDefaultStyle();
   } else if (text_.length() > old_text_length) {
     style_ranges_.back().range.set_end(text_.length());
   } else if (text_.length() < old_text_length) {
     StyleRanges::iterator i;
     for (i = style_ranges_.begin(); i != style_ranges_.end(); i++) {
       if (i->range.start() >= text_.length()) {
         i = style_ranges_.erase(i);
         if (i == style_ranges_.end())
           break;
       } else if (i->range.end() > text_.length()) {
         i->range.set_end(text_.length());
       }
     }
     style_ranges_.back().range.set_end(text_.length());
   }
 #ifndef NDEBUG
   CheckStyleRanges(style_ranges_, text_.length());
 #endif
   cached_bounds_and_offset_valid_ = false;
+
+  // Reset selection model. SetText should always followed by SetSelectionModel
+  // or SetCursorPosition in upper layer.
+  SetSelectionModel(SelectionModel(0, 0, SelectionModel::LEADING));
 }
 
 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(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);
-    if (GetCursorBounds(selection_start, false).x() <
-        GetCursorBounds(position, false).x())
+    SelectionModel selection_start = GetSelectionModelForSelectionStart();
+    if (GetCursorBounds(selection_start, true).x() <
+        GetCursorBounds(position, true).x())
       position = selection_start;
     // For word breaks, use the nearest word boundary left of the selection.
     if (break_type == WORD_BREAK)
       position = GetLeftSelectionModel(position, break_type);
   } else {
     position = GetLeftSelectionModel(position, break_type);
   }
   if (select)
     position.set_selection_start(GetSelectionStart());
   MoveCursorTo(position);
 }
 
 void RenderText::MoveCursorRight(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 right of the selection end.
-    SelectionModel selection_start(GetSelectionStart(), GetSelectionStart(),
-                                   SelectionModel::LEADING);
-    if (GetCursorBounds(selection_start, false).x() >
-        GetCursorBounds(position, false).x())
+    SelectionModel selection_start = GetSelectionModelForSelectionStart();
+    if (GetCursorBounds(selection_start, true).x() >
+        GetCursorBounds(position, true).x())
       position = selection_start;
     // For word breaks, use the nearest word boundary right of the selection.
     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);
@@ skipping 119 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 {
+base::i18n::TextDirection RenderText::GetTextDirection() {
   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) {
@@ skipping 56 matching lines @@
   int left = 0;
   int left_pos = 0;
   int right = font.GetStringWidth(text());
   int right_pos = text().length();
 
   int x = point.x() - (display_rect_.x() + GetUpdatedDisplayOffset().x());
   if (x <= left) return SelectionModel(left_pos);
   if (x >= right) return SelectionModel(right_pos);
   // binary searching the cursor position.
   // TODO(oshima): use the center of character instead of edge.
-  // Binary search may not work for language like arabic.
+  // Binary search may not work for language like Arabic.
   while (std::abs(static_cast<long>(right_pos - left_pos)) > 1) {
     int pivot_pos = left_pos + (right_pos - left_pos) / 2;
     int pivot = font.GetStringWidth(text().substr(0, pivot_pos));
     if (pivot < x) {
       left = pivot;
       left_pos = pivot_pos;
     } else if (pivot == x) {
       return SelectionModel(pivot_pos);
     } else {
       right = pivot;
@@ skipping 14 matching lines @@
   UpdateCachedBoundsAndOffset();
   return cursor_bounds_;
 }
 
 RenderText::RenderText()
     : text_(),
       selection_model_(),
       cursor_bounds_(),
       cursor_visible_(false),
       insert_mode_(true),
-      composition_range_(),
+      composition_range_(ui::Range::InvalidRange()),
       style_ranges_(),
       default_style_(),
       display_rect_(),
       display_offset_(),
       cached_bounds_and_offset_valid_(false) {
 }
 
 const Point& RenderText::GetUpdatedDisplayOffset() {
   UpdateCachedBoundsAndOffset();
   return display_offset_;
 }
 
 SelectionModel RenderText::GetLeftSelectionModel(const SelectionModel& current,
                                                  BreakType break_type) {
   if (break_type == LINE_BREAK)
     return SelectionModel(0, 0, SelectionModel::LEADING);
   size_t pos = std::max(static_cast<long>(current.selection_end() - 1),
                         static_cast<long>(0));
   if (break_type == CHARACTER_BREAK)
     return SelectionModel(pos, pos, SelectionModel::LEADING);
 
-  // Notes: We always iterate words from the begining.
+  // Notes: We always iterate words from the beginning.
   // This is probably fast enough for our usage, but we may
   // want to modify WordIterator so that it can start from the
   // middle of string and advance backwards.
   base::i18n::BreakIterator iter(text(), base::i18n::BreakIterator::BREAK_WORD);
   bool success = iter.Init();
   DCHECK(success);
   if (!success)
     return current;
   while (iter.Advance()) {
     if (iter.IsWord()) {
@@ skipping 11 matching lines @@
         pos = iter.pos() - iter.GetString().length();
       }
     }
   }
 
   return SelectionModel(pos, pos, SelectionModel::LEADING);
 }
 
 SelectionModel RenderText::GetRightSelectionModel(const SelectionModel& current,
                                                   BreakType break_type) {
+  if (text_.empty())
+    return SelectionModel(0, 0, SelectionModel::LEADING);
   if (break_type == LINE_BREAK)
     return SelectionModel(text().length(),
         GetIndexOfPreviousGrapheme(text().length()), SelectionModel::TRAILING);
   size_t pos = std::min(current.selection_end() + 1, text().length());
   if (break_type == CHARACTER_BREAK)
     return SelectionModel(pos, pos, SelectionModel::LEADING);
 
   base::i18n::BreakIterator iter(text(), base::i18n::BreakIterator::BREAK_WORD);
   bool success = iter.Init();
   DCHECK(success);
@@ skipping 113 matching lines @@
   cached_bounds_and_offset_valid_ = true;
   cursor_bounds_ = GetCursorBounds(selection_model_, insert_mode_);
   // 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()) {
+    // TODO(xji): when the character overflow is a RTL character, currently, if
+    // we pan cursor at the rightmost position, the entered RTL character is not
+    // displayed. Should pan cursor to show the last logical characters.
+    //
     // 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()) {
+    // TODO(xji): have similar problem as above when overflow character is a
+    // LTR character.
+    //
     // 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);
 }
 
+SelectionModel RenderText::GetSelectionModelForSelectionStart() {
+  size_t selection_start = GetSelectionStart();
+  size_t selection_end = GetCursorPosition();
+  if (selection_start < selection_end)
+    return SelectionModel(selection_start,
+                          selection_start,
+                          SelectionModel::LEADING);
+  else if (selection_start > selection_end)
+    return SelectionModel(selection_start,
+                          GetIndexOfPreviousGrapheme(selection_start),
+                          SelectionModel::TRAILING);
+  return selection_model_;
+}
+
 }  // namespace gfx