diff options
Diffstat (limited to 'ui/gfx')
| -rw-r--r-- | ui/gfx/render_text.cc | 363 | ||||
| -rw-r--r-- | ui/gfx/render_text.h | 184 |
2 files changed, 381 insertions, 166 deletions
diff --git a/ui/gfx/render_text.cc b/ui/gfx/render_text.cc index 1664b22..7e67d21 100644 --- a/ui/gfx/render_text.cc +++ b/ui/gfx/render_text.cc @@ -11,6 +11,7 @@ #include "base/stl_util.h" #include "ui/gfx/canvas.h" #include "ui/gfx/canvas_skia.h" +#include "unicode/uchar.h" namespace { @@ -38,26 +39,26 @@ void CheckStyleRanges(const gfx::StyleRanges& style_ranges, size_t length) { } #endif -void ApplyStyleRangeImpl(gfx::StyleRanges& style_ranges, +void ApplyStyleRangeImpl(gfx::StyleRanges* style_ranges, gfx::StyleRange style_range) { const ui::Range& new_range = style_range.range; // Follow StyleRanges invariant conditions: sorted and non-overlapping ranges. gfx::StyleRanges::iterator i; - for (i = style_ranges.begin(); i != style_ranges.end();) { + for (i = style_ranges->begin(); i != style_ranges->end();) { if (i->range.end() < new_range.start()) { i++; } else if (i->range.start() == new_range.end()) { break; } else if (new_range.Contains(i->range)) { - i = style_ranges.erase(i); - if (i == style_ranges.end()) + i = style_ranges->erase(i); + if (i == style_ranges->end()) break; } else if (i->range.start() < new_range.start() && i->range.end() > new_range.end()) { // Split the current style into two styles. gfx::StyleRange split_style = gfx::StyleRange(*i); split_style.range.set_end(new_range.start()); - i = style_ranges.insert(i, split_style) + 1; + i = style_ranges->insert(i, split_style) + 1; i->range.set_start(new_range.end()); break; } else if (i->range.start() < new_range.start()) { @@ -70,7 +71,7 @@ void ApplyStyleRangeImpl(gfx::StyleRanges& style_ranges, NOTREACHED(); } // Add the new range in its sorted location. - style_ranges.insert(i, style_range); + style_ranges->insert(i, style_range); } } // namespace @@ -85,6 +86,50 @@ StyleRange::StyleRange() range() { } +SelectionModel::SelectionModel() { + Init(0, 0, 0, PREVIOUS_GRAPHEME_TRAILING); +} + +SelectionModel::SelectionModel(size_t pos) { + Init(pos, pos, pos, PREVIOUS_GRAPHEME_TRAILING); +} + +SelectionModel::SelectionModel(size_t end, + size_t pos, + CaretPlacement placement) { + Init(end, end, pos, placement); +} + +SelectionModel::SelectionModel(size_t start, + size_t end, + size_t pos, + CaretPlacement placement) { + Init(start, end, pos, placement); +} + +SelectionModel::~SelectionModel() { +} + +bool SelectionModel::Equals(const SelectionModel& sel) const { + return selection_start_ == sel.selection_start() && + selection_end_ == sel.selection_end() && + caret_pos_ == sel.caret_pos() && + caret_placement_ == sel.caret_placement(); +} + +void SelectionModel::Init(size_t start, + size_t end, + size_t pos, + CaretPlacement placement) { + selection_start_ = start; + selection_end_ = end; + caret_pos_ = pos; + caret_placement_ = placement; +} + +RenderText::~RenderText() { +} + void RenderText::SetText(const string16& text) { size_t old_text_length = text_.length(); text_ = text; @@ -114,101 +159,107 @@ void RenderText::SetText(const string16& text) { #endif } +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()); + + cursor_bounds_valid_ = false; +} + size_t RenderText::GetCursorPosition() const { - return GetSelection().end(); + return selection_model_.selection_end(); } void RenderText::SetCursorPosition(const size_t position) { - SetSelection(ui::Range(position, position)); + SelectionModel sel(selection_model()); + sel.set_selection_start(position); + sel.set_selection_end(position); + SetSelectionModel(sel); } void RenderText::MoveCursorLeft(BreakType break_type, bool select) { if (break_type == LINE_BREAK) { - MoveCursorTo(0, select); + SelectionModel selection(GetSelectionStart(), 0, + 0, SelectionModel::LEADING); + if (!select) + selection.set_selection_start(selection.selection_end()); + MoveCursorTo(selection); return; } - size_t position = GetCursorPosition(); + SelectionModel position = selection_model_; // Cancelling a selection moves to the edge of the selection. - if (!GetSelection().is_empty() && !select) { + if (!EmptySelection() && !select) { // Use the selection start if it is left of the selection end. - if (GetCursorBounds(GetSelection().start(), false).x() < + SelectionModel selection_start(GetSelectionStart(), GetSelectionStart(), + GetSelectionStart(), SelectionModel::LEADING); + if (GetCursorBounds(selection_start, false).x() < GetCursorBounds(position, false).x()) - position = GetSelection().start(); + position = selection_start; // If |move_by_word|, use the nearest word boundary left of the selection. if (break_type == WORD_BREAK) position = GetLeftCursorPosition(position, true); } else { position = GetLeftCursorPosition(position, break_type == WORD_BREAK); } - MoveCursorTo(position, select); + if (!select) + position.set_selection_start(position.selection_end()); + MoveCursorTo(position); } void RenderText::MoveCursorRight(BreakType break_type, bool select) { if (break_type == LINE_BREAK) { - MoveCursorTo(text().length(), select); + SelectionModel selection(GetSelectionStart(), text().length(), + text().length(), SelectionModel::PREVIOUS_GRAPHEME_TRAILING); + if (!select) + selection.set_selection_start(selection.selection_end()); + MoveCursorTo(selection); return; } - size_t position = GetCursorPosition(); + SelectionModel position = selection_model_; // Cancelling a selection moves to the edge of the selection. - if (!GetSelection().is_empty() && !select) { + if (!EmptySelection() && !select) { // Use the selection start if it is right of the selection end. - if (GetCursorBounds(GetSelection().start(), false).x() > + SelectionModel selection_start(GetSelectionStart(), GetSelectionStart(), + GetSelectionStart(), SelectionModel::LEADING); + if (GetCursorBounds(selection_start, false).x() > GetCursorBounds(position, false).x()) - position = GetSelection().start(); + position = selection_start; // If |move_by_word|, use the nearest word boundary right of the selection. if (break_type == WORD_BREAK) position = GetRightCursorPosition(position, true); } else { position = GetRightCursorPosition(position, break_type == WORD_BREAK); } - MoveCursorTo(position, select); + if (!select) + position.set_selection_start(position.selection_end()); + MoveCursorTo(position); } -bool RenderText::MoveCursorTo(size_t position, bool select) { - bool changed = GetCursorPosition() != position || - select == GetSelection().is_empty(); - if (select) - SetSelection(ui::Range(GetSelection().start(), position)); - else - SetSelection(ui::Range(position, position)); +bool RenderText::MoveCursorTo(const SelectionModel& selection) { + bool changed = !selection.Equals(selection_model_); + SetSelectionModel(selection); return changed; } bool RenderText::MoveCursorTo(const Point& point, bool select) { - // TODO(msw): Make this function support cursor placement via mouse near BiDi - // level changes. The visual cursor appearance will depend on the location - // clicked, not solely the resulting logical cursor position. See the TODO - // note pertaining to selection_range_ for more information. - return MoveCursorTo(FindCursorPosition(point), select); -} - -const ui::Range& RenderText::GetSelection() const { - return selection_range_; -} - -void RenderText::SetSelection(const ui::Range& range) { - selection_range_.set_end(std::min(range.end(), text().length())); - selection_range_.set_start(std::min(range.start(), text().length())); - - // Update |display_offset_| to ensure the current cursor is visible. - Rect cursor_bounds(GetCursorBounds(GetCursorPosition(), insert_mode())); - int display_width = display_rect_.width(); - int string_width = GetStringWidth(); - if (string_width < display_width) { - // Show all text whenever the text fits to the size. - display_offset_.set_x(0); - } else if ((display_offset_.x() + cursor_bounds.right()) > display_width) { - // Pan to show the cursor when it overflows to the right, - display_offset_.set_x(display_width - cursor_bounds.right()); - } else if ((display_offset_.x() + cursor_bounds.x()) < 0) { - // Pan to show the cursor when it overflows to the left. - display_offset_.set_x(-cursor_bounds.x()); - } + SelectionModel selection = FindCursorPosition(point); + if (select) + selection.set_selection_start(GetSelectionStart()); + else + selection.set_selection_start(selection.selection_end()); + return MoveCursorTo(selection); } -bool RenderText::IsPointInSelection(const Point& point) const { - size_t pos = FindCursorPosition(point); - return (pos >= GetSelection().GetMin() && pos < GetSelection().GetMax()); +bool RenderText::IsPointInSelection(const Point& point) { + // 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() { @@ -216,17 +267,19 @@ void RenderText::ClearSelection() { } void RenderText::SelectAll() { - SetSelection(ui::Range(0, text().length())); + SelectionModel sel(0, text().length(), + text().length(), SelectionModel::LEADING); + SetSelectionModel(sel); } void RenderText::SelectWord() { - size_t selection_start = GetSelection().start(); + size_t selection_start = GetSelectionStart(); size_t cursor_position = GetCursorPosition(); - // First we setup selection_start_ and cursor_pos_. There are so many cases + // 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. // See associated testcase for different cases. if (cursor_position > 0 && cursor_position < text().length()) { - if (isalnum(text()[cursor_position])) { + if (u_isalnum(text()[cursor_position])) { selection_start = cursor_position; cursor_position++; } else @@ -247,7 +300,7 @@ void RenderText::SelectWord() { break; } - // Now we move cursor_pos_ to end of selection. Selection boundary + // 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++) { @@ -255,7 +308,11 @@ void RenderText::SelectWord() { break; } - SetSelection(ui::Range(selection_start, cursor_position)); + SelectionModel sel(selection_model()); + sel.set_selection_start(selection_start); + sel.set_selection_end(cursor_position); + sel.set_caret_placement(SelectionModel::PREVIOUS_GRAPHEME_TRAILING); + SetSelectionModel(sel); } const ui::Range& RenderText::GetCompositionRange() const { @@ -275,10 +332,12 @@ void RenderText::ApplyStyleRange(StyleRange style_range) { return; CHECK(!new_range.is_reversed()); CHECK(ui::Range(0, text_.length()).Contains(new_range)); - ApplyStyleRangeImpl(style_ranges_, style_range); + ApplyStyleRangeImpl(&style_ranges_, style_range); #ifndef NDEBUG CheckStyleRanges(style_ranges_, text_.length()); #endif + // TODO(xji): only invalidate cursor_bounds if font or underline change. + cursor_bounds_valid_ = false; } void RenderText::ApplyDefaultStyle() { @@ -286,6 +345,7 @@ void RenderText::ApplyDefaultStyle() { StyleRange style = StyleRange(default_style_); style.range.set_end(text_.length()); style_ranges_.push_back(style); + cursor_bounds_valid_ = false; } base::i18n::TextDirection RenderText::GetTextDirection() const { @@ -294,8 +354,8 @@ base::i18n::TextDirection RenderText::GetTextDirection() const { return base::i18n::LEFT_TO_RIGHT; } -int RenderText::GetStringWidth() const { - return GetSubstringBounds(ui::Range(0, text_.length()))[0].width(); +int RenderText::GetStringWidth() { + return GetSubstringBounds(0, text_.length())[0].width(); } void RenderText::Draw(Canvas* canvas) { @@ -304,7 +364,8 @@ void RenderText::Draw(Canvas* canvas) { display_rect_.width(), display_rect_.height()); // Draw the selection. - std::vector<Rect> selection(GetSubstringBounds(GetSelection())); + std::vector<Rect> selection(GetSubstringBounds(GetSelectionStart(), + GetCursorPosition())); SkColor selection_color = focused() ? kFocusedSelectionColor : kUnfocusedSelectionColor; for (std::vector<Rect>::const_iterator i = selection.begin(); @@ -318,25 +379,8 @@ void RenderText::Draw(Canvas* canvas) { } // Create a temporary copy of the style ranges for composition and selection. - // TODO(msw): This pattern ought to be reconsidered; what about composition - // and selection overlaps, retain existing local style features? StyleRanges style_ranges(style_ranges_); - // 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 (selection_range_.IsValid() && !selection_range_.is_empty()) { - StyleRange selection_style(default_style_); - selection_style.foreground = kSelectedTextColor; - selection_style.range.set_start(selection_range_.GetMin()); - selection_style.range.set_end(selection_range_.GetMax()); - ApplyStyleRangeImpl(style_ranges, selection_style); - } + ApplyCompositionAndSelectionStyles(&style_ranges); // Draw the text. Rect bounds(display_rect_); @@ -368,7 +412,7 @@ void RenderText::Draw(Canvas* canvas) { // Paint cursor. Replace cursor is drawn as rectangle for now. if (cursor_visible() && focused()) { - bounds = GetCursorBounds(GetCursorPosition(), insert_mode()); + bounds = CursorBounds(); bounds.Offset(display_offset_); if (!bounds.IsEmpty()) canvas->DrawRectInt(kCursorColor, @@ -379,7 +423,7 @@ void RenderText::Draw(Canvas* canvas) { } } -size_t RenderText::FindCursorPosition(const Point& point) const { +SelectionModel RenderText::FindCursorPosition(const Point& point) { const Font& font = default_style_.font; int left = 0; int left_pos = 0; @@ -387,31 +431,31 @@ size_t RenderText::FindCursorPosition(const Point& point) const { int right_pos = text().length(); int x = point.x(); - if (x <= left) return left_pos; - if (x >= right) return right_pos; + 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. - while (std::abs(static_cast<long>(right_pos - left_pos) > 1)) { + 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 pivot_pos; + return SelectionModel(pivot_pos); } else { right = pivot; right_pos = pivot_pos; } } - return left_pos; + return SelectionModel(left_pos); } std::vector<Rect> RenderText::GetSubstringBounds( - const ui::Range& range) const { - size_t start = range.GetMin(); - size_t end = range.GetMax(); + size_t from, size_t to) const { + 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)); @@ -420,7 +464,9 @@ std::vector<Rect> RenderText::GetSubstringBounds( return bounds; } -Rect RenderText::GetCursorBounds(size_t cursor_pos, bool insert_mode) const { +Rect RenderText::GetCursorBounds(const SelectionModel& selection, + bool insert_mode) { + size_t cursor_pos = selection.selection_end(); const Font& font = default_style_.font; int x = font.GetStringWidth(text_.substr(0U, cursor_pos)); DCHECK_GE(x, 0); @@ -431,10 +477,37 @@ Rect RenderText::GetCursorBounds(size_t cursor_pos, bool insert_mode) const { return bounds; } -size_t RenderText::GetLeftCursorPosition(size_t position, - bool move_by_word) const { - if (!move_by_word) - return position == 0? position : position - 1; +const Rect& RenderText::CursorBounds() { + if (cursor_bounds_valid_ == false) { + UpdateCursorBoundsAndDisplayOffset(); + cursor_bounds_valid_ = true; + } + return cursor_bounds_; +} + +RenderText::RenderText() + : text_(), + selection_model_(), + cursor_bounds_(), + cursor_bounds_valid_(false), + cursor_visible_(false), + insert_mode_(true), + composition_range_(), + style_ranges_(), + default_style_(), + display_rect_(), + display_offset_() { +} + +SelectionModel RenderText::GetLeftCursorPosition(const SelectionModel& current, + bool move_by_word) { + size_t position = current.selection_end(); + SelectionModel left = current; + if (!move_by_word) { + left.set_selection_end(std::max(static_cast<long>(position - 1), + static_cast<long>(0))); + return left; + } // Notes: We always iterate words from the begining. // This is probably fast enough for our usage, but we may // want to modify WordIterator so that it can start from the @@ -442,8 +515,10 @@ size_t RenderText::GetLeftCursorPosition(size_t position, base::i18n::BreakIterator iter(text(), base::i18n::BreakIterator::BREAK_WORD); bool success = iter.Init(); DCHECK(success); - if (!success) - return position; + if (!success) { + left.set_selection_end(position); + return left; + } int last = 0; while (iter.Advance()) { if (iter.IsWord()) { @@ -452,7 +527,7 @@ size_t RenderText::GetLeftCursorPosition(size_t position, // The cursor is at the beginning of a word. // Move to previous word. break; - } else if(iter.pos() >= position) { + } else if (iter.pos() >= position) { // The cursor is in the middle or at the end of a word. // Move to the top of current word. last = begin; @@ -463,18 +538,27 @@ size_t RenderText::GetLeftCursorPosition(size_t position, } } - return last; + left.set_selection_end(last); + return left; } -size_t RenderText::GetRightCursorPosition(size_t position, - bool move_by_word) const { - if (!move_by_word) - return std::min(position + 1, text().length()); +SelectionModel RenderText::GetRightCursorPosition(const SelectionModel& current, + bool move_by_word) { + size_t position = current.selection_end(); + SelectionModel right = current; + + if (!move_by_word) { + right.set_selection_end(std::min(position + 1, text().length())); + return right; + } + base::i18n::BreakIterator iter(text(), base::i18n::BreakIterator::BREAK_WORD); bool success = iter.Init(); DCHECK(success); - if (!success) - return position; + if (!success) { + right.set_selection_end(position); + return right; + } size_t pos = 0; while (iter.Advance()) { pos = iter.pos(); @@ -482,27 +566,52 @@ size_t RenderText::GetRightCursorPosition(size_t position, break; } } - return pos; + right.set_selection_end(pos); + return right; } -RenderText::RenderText() - : text_(), - selection_range_(), - cursor_visible_(false), - insert_mode_(true), - composition_range_(), - style_ranges_(), - default_style_(), - display_rect_(), - display_offset_() { +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); + } } -RenderText::~RenderText() { +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])); } -bool RenderText::IsPositionAtWordSelectionBoundary(size_t pos) { - return pos == 0 || (isalnum(text()[pos - 1]) && !isalnum(text()[pos])) || - (!isalnum(text()[pos - 1]) && isalnum(text()[pos])); +void RenderText::UpdateCursorBoundsAndDisplayOffset() { + 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(); + if (string_width < display_width) { + // Show all text whenever the text fits to the size. + display_offset_.set_x(0); + } else if ((display_offset_.x() + cursor_bounds_.right()) > display_width) { + // Pan to show the cursor when it overflows to the right, + display_offset_.set_x(display_width - cursor_bounds_.right()); + } else if ((display_offset_.x() + cursor_bounds_.x()) < 0) { + // Pan to show the cursor when it overflows to the left. + display_offset_.set_x(-cursor_bounds_.x()); + } } } // namespace gfx diff --git a/ui/gfx/render_text.h b/ui/gfx/render_text.h index 40209ea..020386b 100644 --- a/ui/gfx/render_text.h +++ b/ui/gfx/render_text.h @@ -6,6 +6,7 @@ #define UI_GFX_RENDER_TEXT_H_ #pragma once +#include <algorithm> #include <vector> #include "base/gtest_prod_util.h" @@ -17,7 +18,7 @@ #include "ui/gfx/rect.h" #include "ui/gfx/point.h" -namespace { +namespace gfx { // Strike line width. const int kStrikeWidth = 2; @@ -32,10 +33,6 @@ const SkColor kFocusedSelectionColor = SK_ColorCYAN; const SkColor kUnfocusedSelectionColor = SK_ColorLTGRAY; const SkColor kCursorColor = SK_ColorBLACK; -} // namespace - -namespace gfx { - class Canvas; class RenderTextTest; @@ -59,6 +56,86 @@ enum BreakType { LINE_BREAK, }; +// TODO(xji): publish bidi-editing guide line and replace the place holder. +// SelectionModel is used to represent the logical selection and visual +// position of cursor. +// +// For bi-directional text, the mapping between visual position and logical +// position is not one-to-one. For example, logical text "abcDEF" where capital +// letters stand for Hebrew, the visual display is "abcFED". According to the +// bidi editing guide (http://bidi-editing-guideline): +// 1. If pointing to the right half of the cell of a LTR character, the current +// position must be set after this character and the caret must be displayed +// after this character. +// 2. If pointing to the right half of the cell of a RTL character, the current +// position must be set before this character and the caret must be displayed +// before this character. +// +// Pointing to the right half of 'c' and pointing to the right half of 'D' both +// set the logical cursor position to 3. But the cursor displayed visually at +// different places: +// Pointing to the right half of 'c' displays the cursor right of 'c' as +// "abc|FED". +// Pointing to the right half of 'D' displays the cursor right of 'D' as +// "abcFED|". +// So, besides the logical selection start point and end point, we need extra +// information to specify to which character and on which edge of the character +// the visual cursor is bound to. For example, the visual cursor is bound to +// the trailing side of the 2nd character 'c' when pointing to right half of +// 'c'. And it is bound to the leading edge of the 3rd character 'D' when +// pointing to right of 'D'. +class UI_API SelectionModel { + public: + enum CaretPlacement { + // PREVIOUS_GRAPHEME_TRAILING means cursor is visually attached to the + // trailing edge of previous grapheme. + PREVIOUS_GRAPHEME_TRAILING, + LEADING, + TRAILING, + }; + + SelectionModel(); + explicit SelectionModel(size_t pos); + SelectionModel(size_t end, size_t pos, CaretPlacement status); + SelectionModel(size_t start, size_t end, size_t pos, CaretPlacement status); + + virtual ~SelectionModel(); + + size_t selection_start() const { return selection_start_; } + void set_selection_start(size_t pos) { selection_start_ = pos; } + + size_t selection_end() const { return selection_end_; } + void set_selection_end(size_t pos) { selection_end_ = pos; } + + size_t caret_pos() const { return caret_pos_; } + void set_caret_pos(size_t pos) { caret_pos_ = pos; } + + CaretPlacement caret_placement() const { return caret_placement_; } + void set_caret_placement(CaretPlacement placement) { + caret_placement_ = placement; + } + + bool Equals(const SelectionModel& sel) const; + + private: + void Init(size_t start, size_t end, size_t pos, CaretPlacement status); + + // Logical selection start. If there is non-empty selection, the selection + // always starts visually at the leading edge of the selection_start. So, we + // do not need extra information for visual selection bounding. + size_t selection_start_; + + // The logical cursor position that next character will be inserted into. + // It is also the end of the selection. + size_t selection_end_; + + // The following two fields are used to guide cursor visual position. + // The index of the character that cursor is visually attached to. + size_t caret_pos_; + // The visual placement of the cursor, relative to its associated character. + CaretPlacement caret_placement_; +}; + // TODO(msw): Implement RenderText[Win|Linux] for Uniscribe/Pango BiDi... // RenderText represents an abstract model of styled text and its corresponding @@ -66,7 +143,6 @@ enum BreakType { // complex scripts, and bi-directional text. Implementations provide mechanisms // for rendering and translation between logical and visual data. class UI_API RenderText { - public: virtual ~RenderText(); @@ -76,6 +152,9 @@ class UI_API RenderText { const string16& text() const { return text_; } virtual void SetText(const string16& text); + const SelectionModel& selection_model() const { return selection_model_; } + void SetSelectionModel(const SelectionModel& sel); + bool cursor_visible() const { return cursor_visible_; } void set_cursor_visible(bool visible) { cursor_visible_ = visible; } @@ -89,13 +168,21 @@ class UI_API RenderText { void set_default_style(StyleRange style) { default_style_ = style; } const Rect& display_rect() const { return display_rect_; } - void set_display_rect(const Rect& r) { display_rect_ = r; } + virtual void set_display_rect(const Rect& r) { display_rect_ = r; } - const gfx::Point& display_offset() const { return display_offset_; } + const Point& display_offset() const { return display_offset_; } + // This cursor position corresponds to SelectionModel::selection_end. In + // addition to representing the selection end, it's also where logical text + // edits take place, and doesn't necessarily correspond to + // SelectionModel::caret_pos. size_t GetCursorPosition() const; void SetCursorPosition(const size_t position); + void SetCaretPlacement(SelectionModel::CaretPlacement placement) { + selection_model_.set_caret_placement(placement); + } + // Moves the cursor left or right. Cursor movement is visual, meaning that // left and right are relative to screen, not the directionality of the text. // If |select| is false, the selection range is emptied at the new position. @@ -105,20 +192,29 @@ class UI_API RenderText { void MoveCursorLeft(BreakType break_type, bool select); void MoveCursorRight(BreakType break_type, bool select); - // Moves the cursor to the specified logical |position|. - // If |select| is false, the selection range is emptied at the new position. + // Set the selection_model_ to the value of |selection|. // Returns true if the cursor position or selection range changed. - bool MoveCursorTo(size_t position, bool select); + bool MoveCursorTo(const SelectionModel& selection); // Move the cursor to the position associated with the clicked point. // If |select| is false, the selection range is emptied at the new position. bool MoveCursorTo(const Point& point, bool select); - const ui::Range& GetSelection() const; - void SetSelection(const ui::Range& range); + size_t GetSelectionStart() const { + return selection_model_.selection_start(); + } + size_t MinOfSelection() const { + return std::min(GetSelectionStart(), GetCursorPosition()); + } + size_t MaxOfSelection() const { + return std::max(GetSelectionStart(), GetCursorPosition()); + } + bool EmptySelection() const { + return GetSelectionStart() == GetCursorPosition(); + } // Returns true if the local point is over selected text. - bool IsPointInSelection(const Point& point) const; + bool IsPointInSelection(const Point& point); // Selects no text, all text, or the word at the current cursor position. void ClearSelection(); @@ -137,37 +233,46 @@ class UI_API RenderText { base::i18n::TextDirection GetTextDirection() const; // Get the width of the entire string. - int GetStringWidth() const; + virtual int GetStringWidth(); virtual void Draw(Canvas* canvas); - // TODO(msw): Deprecate this function. Logical and visual cursors are not - // mapped one-to-one. See the selection_range_ TODO for more information. - // Get the logical cursor position from a visual point in local coordinates. - virtual size_t FindCursorPosition(const Point& point) const; + // Gets the SelectionModel from a visual point in local coordinates. + virtual SelectionModel FindCursorPosition(const Point& point); - // Get the visual bounds containing the logical substring within |range|. - // These bounds could be visually discontiguous if the logical selection range - // is split by an odd number of LTR/RTL level change. + // Get the visual bounds containing the logical substring within |from| to + // |to|. These bounds could be visually discontinuous if the logical + // selection range is split by an odd number of LTR/RTL level change. virtual std::vector<Rect> GetSubstringBounds( - const ui::Range& range) const; + size_t from, size_t to) const; - // Get the visual bounds describing the cursor at |position|. These bounds + // Get the visual bounds describing the cursor at |selection|. These bounds // typically represent a vertical line, but if |insert_mode| is true they // contain the bounds of the associated glyph. - virtual Rect GetCursorBounds(size_t position, bool insert_mode) const; + virtual Rect GetCursorBounds(const SelectionModel& selection, + bool insert_mode); + + // Compute cursor_bounds_ and update display_offset_ when necessary. Cache + // the values for later use and return cursor_bounds_. + const Rect& CursorBounds(); protected: RenderText(); + void set_cursor_bounds_valid(bool valid) { cursor_bounds_valid_ = valid; } + const StyleRanges& style_ranges() const { return style_ranges_; } // Get the cursor position that visually neighbors |position|. // If |move_by_word| is true, return the neighboring word delimiter position. - virtual size_t GetLeftCursorPosition(size_t position, - bool move_by_word) const; - virtual size_t GetRightCursorPosition(size_t position, - bool move_by_word) const; + virtual SelectionModel GetLeftCursorPosition(const SelectionModel& current, + bool move_by_word); + virtual SelectionModel GetRightCursorPosition(const SelectionModel& current, + bool move_by_word); + + // Apply composition style (underline) to composition range and selection + // style (foreground) to selection range. + void ApplyCompositionAndSelectionStyles(StyleRanges* style_ranges) const; private: friend class RenderTextTest; @@ -182,19 +287,20 @@ class UI_API RenderText { bool IsPositionAtWordSelectionBoundary(size_t pos); + void UpdateCursorBoundsAndDisplayOffset(); + // Logical UTF-16 string data to be drawn. string16 text_; - // TODO(msw): A single logical cursor position doesn't support two potential - // visual cursor positions. For example, clicking right of 'c' & 'D' yeilds: - // (visually: 'abc|FEDghi' and 'abcFED|ghi', both logically: 'abc|DEFghi'). - // Similarly, one visual position may have two associated logical positions. - // For example, clicking the right side of 'D' and left side of 'g' yields: - // (both visually: 'abcFED|ghi', logically: 'abc|DEFghi' and 'abcDEF|ghi'). - // Update the cursor model with a leading/trailing flag, a level association, - // or a disjoint visual position to satisfy the proposed visual behavior. - // Logical selection range; the range end is also the logical cursor position. - ui::Range selection_range_; + // Logical selection range and visual cursor position. + SelectionModel selection_model_; + + // The cached cursor bounds. + Rect cursor_bounds_; + // cursor_bounds_ is computed when needed and cached afterwards. And it is + // invalidated in operations such as SetCursorPosition, SetSelection, Font + // related style change, and other operations that trigger re-layout. + bool cursor_bounds_valid_; // The cursor visibility and insert mode. bool cursor_visible_; |