modification to RenderText for inheritance/SelectionModel

views/controls/textfield/textfield_views_model.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 "views/controls/textfield/textfield_views_model.h"
 
 #include <algorithm>
 
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
@@ skipping 362 matching lines @@
   render_text_->MoveCursorLeft(break_type, select);
 }
 
 void TextfieldViewsModel::MoveCursorRight(gfx::BreakType break_type,
                                           bool select) {
   if (HasCompositionText())
     ConfirmCompositionText();
   render_text_->MoveCursorRight(break_type, select);
 }
 
-bool TextfieldViewsModel::MoveCursorTo(size_t pos, bool select) {
+bool TextfieldViewsModel::MoveCursorTo(const gfx::SelectionModel& selection,

[msw, 2011/08/01 05:02:23]

We'll need to reconsider this function similarly to the RenderText function,
since |selection| may conflict with |select|, and its behavior is unclear.

+                                       bool select) {
   if (HasCompositionText())
     ConfirmCompositionText();
-  return render_text_->MoveCursorTo(pos, select);
+  return render_text_->MoveCursorTo(selection, select);
 }
 
 bool TextfieldViewsModel::MoveCursorTo(const gfx::Point& point, bool select) {
   if (HasCompositionText())
     ConfirmCompositionText();
   return render_text_->MoveCursorTo(point, select);
 }
 
 std::vector<gfx::Rect> TextfieldViewsModel::GetSelectionBounds() const {
-  return render_text_->GetSubstringBounds(render_text_->GetSelection());
+  return render_text_->GetSubstringBounds(render_text_->GetSelectionStart(),
+                                          render_text_->GetCursorPosition());
 }
 
 string16 TextfieldViewsModel::GetSelectedText() const {
-  ui::Range selection = render_text_->GetSelection();
-  return GetText().substr(selection.GetMin(), selection.length());
+  return GetText().substr(render_text_->MinOfSelection(),
+      std::abs(static_cast<long>(render_text_->GetCursorPosition() -

[msw, 2011/08/01 05:02:23]

why the static cast to long? Shouldn't this be a size_t cast outside the
std::abs if needed?

[xji, 2011/08/01 23:38:42]

is (size_t - size_t) a size_t? then, you need to cast it to signed before
std::abs.

[msw, 2011/08/02 01:29:06]

The call to std::abs implicitly casts the subtraction result to a signed type,
and call to substr implicitly casts the std::abs result to an unsigned type; I
don't think any explicit casting is necessary.

However, my mentor recommends explicitly casting each of the render_text_ values
to longs (or ints) and then subtracting them (he seems to think this is more
readable).

This was a little easier with a ui::Range, but do as you please, I don't really
think it matters all that much.

+                                 render_text_->GetSelectionStart())));
 }
 
 void TextfieldViewsModel::GetSelectedRange(ui::Range* range) const {
-  *range = render_text_->GetSelection();
+  *range = ui::Range(render_text_->GetSelectionStart(),
+                     render_text_->GetCursorPosition());
 }
 
 void TextfieldViewsModel::SelectRange(const ui::Range& range) {
   if (HasCompositionText())
     ConfirmCompositionText();
-  render_text_->SetSelection(range);
+  render_text_->SetSelection(range.start(), range.end());
 }
 
 void TextfieldViewsModel::SelectAll() {
   if (HasCompositionText())
     ConfirmCompositionText();
   render_text_->SelectAll();
 }
 
 void TextfieldViewsModel::SelectWord() {
   if (HasCompositionText())
@@ skipping 63 matching lines @@
 
 bool TextfieldViewsModel::Cut() {
   if (!HasCompositionText() && HasSelection()) {
     ui::ScopedClipboardWriter(views::ViewsDelegate::views_delegate
         ->GetClipboard()).WriteText(GetSelectedText());
     // A trick to let undo/redo handle cursor correctly.
     // Undoing CUT moves the cursor to the end of the change rather
     // than beginning, unlike Delete/Backspace.
     // TODO(oshima): Change Delete/Backspace to use DeleteSelection,
     // update DeleteEdit and remove this trick.
-    ui::Range selection = render_text_->GetSelection();
-    render_text_->SetSelection(ui::Range(selection.end(), selection.start()));
+    render_text_->SetSelection(render_text_->GetCursorPosition(),
+                               render_text_->GetSelectionStart());
     DeleteSelection();
     return true;
   }
   return false;
 }
 
 void TextfieldViewsModel::Copy() {
   if (!HasCompositionText() && HasSelection()) {
     ui::ScopedClipboardWriter(views::ViewsDelegate::views_delegate
         ->GetClipboard()).WriteText(GetSelectedText());
   }
 }
 
 bool TextfieldViewsModel::Paste() {
   string16 result;
   views::ViewsDelegate::views_delegate->GetClipboard()
       ->ReadText(ui::Clipboard::BUFFER_STANDARD, &result);
   if (!result.empty()) {
     InsertTextInternal(result, false);
     return true;
   }
   return false;
 }
 
 bool TextfieldViewsModel::HasSelection() const {
-  return !render_text_->GetSelection().is_empty();
+  return !render_text_->EmptySelection();
 }
 
 void TextfieldViewsModel::DeleteSelection() {
   DCHECK(!HasCompositionText());
   DCHECK(HasSelection());
-  ui::Range selection = render_text_->GetSelection();
-  ExecuteAndRecordDelete(selection.start(), selection.end(), false);
+  ExecuteAndRecordDelete(render_text_->GetSelectionStart(),
+                         render_text_->GetCursorPosition(), false);
 }
 
 void TextfieldViewsModel::DeleteSelectionAndInsertTextAt(
     const string16& text, size_t position) {
   if (HasCompositionText())
     CancelCompositionText();
   ExecuteAndRecordReplace(DO_NOT_MERGE,
                           GetCursorPosition(),
                           position + text.length(),
                           text,
@@ skipping 21 matching lines @@
     return;
 
   size_t cursor = GetCursorPosition();
   string16 new_text = GetText();
   render_text_->SetText(new_text.insert(cursor, composition.text));
   ui::Range range(cursor, cursor + composition.text.length());
   render_text_->SetCompositionRange(range);
   // TODO(msw): Support multiple composition underline ranges.
 
   if (composition.selection.IsValid())
-    render_text_->SetSelection(ui::Range(
+    render_text_->SetSelection(
         std::min(range.start() + composition.selection.start(), range.end()),
-        std::min(range.start() + composition.selection.end(), range.end())));
+        std::min(range.start() + composition.selection.end(), range.end()));
   else
     render_text_->SetCursorPosition(range.end());
 }
 
 void TextfieldViewsModel::ConfirmCompositionText() {
   DCHECK(HasCompositionText());
   ui::Range range = render_text_->GetCompositionRange();
   string16 text = GetText().substr(range.start(), range.length());
   // TODO(oshima): current behavior on ChromeOS is a bit weird and not
   // sure exactly how this should work. Find out and fix if necessary.
@@ skipping 49 matching lines @@
     ExecuteAndRecordInsert(text, mergeable);
   }
 }
 
 void TextfieldViewsModel::ReplaceTextInternal(const string16& text,
                                               bool mergeable) {
   if (HasCompositionText()) {
     CancelCompositionText();
   } else if (!HasSelection()) {
     size_t cursor = GetCursorPosition();
-    render_text_->SetSelection(ui::Range(cursor + text.length(), cursor));
+    render_text_->SetSelection(cursor + text.length(), cursor);
   }
   // Edit history is recorded in InsertText.
   InsertTextInternal(text, mergeable);
 }
 
 void TextfieldViewsModel::ClearEditHistory() {
   STLDeleteContainerPointers(edit_history_.begin(),
                              edit_history_.end());
   edit_history_.clear();
   current_edit_ = edit_history_.end();
@@ skipping 21 matching lines @@
   bool backward = from > to;
   Edit* edit = new DeleteEdit(mergeable, text, old_text_start, backward);
   bool delete_edit = AddOrMergeEditHistory(edit);
   edit->Redo(this);
   if (delete_edit)
     delete edit;
 }
 
 void TextfieldViewsModel::ExecuteAndRecordReplaceSelection(
     MergeType merge_type, const string16& new_text) {
-  size_t new_text_start = render_text_->GetSelection().GetMin();
+  size_t new_text_start = render_text_->MinOfSelection();
   size_t new_cursor_pos = new_text_start + new_text.length();
   ExecuteAndRecordReplace(merge_type,
                           GetCursorPosition(),
                           new_cursor_pos,
                           new_text,
                           new_text_start);
 }
 
 void TextfieldViewsModel::ExecuteAndRecordReplace(MergeType merge_type,
                                                   size_t old_cursor_pos,
                                                   size_t new_cursor_pos,
                                                   const string16& new_text,
                                                   size_t new_text_start) {
-  size_t old_text_start = render_text_->GetSelection().GetMin();
-  bool backward = render_text_->GetSelection().is_reversed();
+  size_t old_text_start = render_text_->MinOfSelection();
+  bool backward = render_text_->GetSelectionStart() >
+                  render_text_->GetCursorPosition();
   Edit* edit = new ReplaceEdit(merge_type,
                                GetSelectedText(),
                                old_cursor_pos,
                                old_text_start,
                                backward,
                                new_cursor_pos,
                                new_text,
                                new_text_start);
   bool delete_edit = AddOrMergeEditHistory(edit);
   edit->Redo(this);
@@ skipping 41 matching lines @@
   if (delete_from != delete_to)
     render_text_->SetText(text.erase(delete_from, delete_to - delete_from));
   if (!new_text.empty())
     render_text_->SetText(text.insert(new_text_insert_at, new_text));
   render_text_->SetCursorPosition(new_cursor_pos);
   // TODO(oshima): mac selects the text that is just undone (but gtk doesn't).
   // This looks fine feature and we may want to do the same.
 }
 
 }  // namespace views