Move Range code to gfx.

ui/gfx/render_text.cc

 // Copyright (c) 2012 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 270 matching lines @@
                              const std::vector<BreakList<bool> >& styles)
     : colors_(colors),
       styles_(styles) {
   color_ = colors_.breaks().begin();
   for (size_t i = 0; i < styles_.size(); ++i)
     style_.push_back(styles_[i].breaks().begin());
 }
 
 StyleIterator::~StyleIterator() {}
 
-ui::Range StyleIterator::GetRange() const {
-  ui::Range range(colors_.GetRange(color_));
+gfx::Range StyleIterator::GetRange() const {
+  gfx::Range range(colors_.GetRange(color_));
   for (size_t i = 0; i < NUM_TEXT_STYLES; ++i)
     range = range.Intersect(styles_[i].GetRange(style_[i]));
   return range;
 }
 
 void StyleIterator::UpdatePosition(size_t position) {
   color_ = colors_.GetBreak(position);
   for (size_t i = 0; i < NUM_TEXT_STYLES; ++i)
     style_[i] = styles_[i].GetBreak(position);
 }
@@ skipping 121 matching lines @@
     position = GetAdjacentSelectionModel(position, break_type, direction);
   }
   if (select)
     position.set_selection_start(selection().start());
   MoveCursorTo(position);
 }
 
 bool RenderText::MoveCursorTo(const SelectionModel& model) {
   // Enforce valid selection model components.
   size_t text_length = text().length();
-  ui::Range range(std::min(model.selection().start(), text_length),
+  gfx::Range range(std::min(model.selection().start(), text_length),
                   std::min(model.caret_pos(), text_length));
   // The current model only supports caret positions at valid character indices.
   if (!IsCursorablePosition(range.start()) ||
       !IsCursorablePosition(range.end()))
     return false;
   SelectionModel sel(range, model.caret_affinity());
   bool changed = sel != selection_model_;
   SetSelectionModel(sel);
   return changed;
 }
 
 bool RenderText::MoveCursorTo(const Point& point, bool select) {
   SelectionModel position = FindCursorPosition(point);
   if (select)
     position.set_selection_start(selection().start());
   return MoveCursorTo(position);
 }
 
-bool RenderText::SelectRange(const ui::Range& range) {
-  ui::Range sel(std::min(range.start(), text().length()),
+bool RenderText::SelectRange(const gfx::Range& range) {
+  gfx::Range sel(std::min(range.start(), text().length()),
                 std::min(range.end(), text().length()));
   if (!IsCursorablePosition(sel.start()) || !IsCursorablePosition(sel.end()))
     return false;
   LogicalCursorDirection affinity =
       (sel.is_reversed() || sel.is_empty()) ? CURSOR_FORWARD : CURSOR_BACKWARD;
   SetSelectionModel(SelectionModel(sel, affinity));
   return true;
 }
 
 bool RenderText::IsPointInSelection(const Point& point) {
   if (selection().is_empty())
     return false;
   SelectionModel cursor = FindCursorPosition(point);
   return RangeContainsCaret(
       selection(), cursor.caret_pos(), cursor.caret_affinity());
 }
 
 void RenderText::ClearSelection() {
   SetSelectionModel(SelectionModel(cursor_position(),
                                    selection_model_.caret_affinity()));
 }
 
 void RenderText::SelectAll(bool reversed) {
   const size_t length = text().length();
-  const ui::Range all = reversed ? ui::Range(length, 0) : ui::Range(0, length);
+  const gfx::Range all = reversed ? gfx::Range(length, 0) :
+      gfx::Range(0, length);
   const bool success = SelectRange(all);
   DCHECK(success);
 }
 
 void RenderText::SelectWord() {
   if (obscured_) {
     SelectAll(false);
     return;
   }
 
@@ skipping 20 matching lines @@
 
   for (; selection_max < text().length(); ++selection_max)
     if (iter.IsEndOfWord(selection_max) || iter.IsStartOfWord(selection_max))
       break;
 
   const bool reversed = selection().is_reversed();
   MoveCursorTo(reversed ? selection_max : selection_min, false);
   MoveCursorTo(reversed ? selection_min : selection_max, true);
 }
 
-const ui::Range& RenderText::GetCompositionRange() const {
+const gfx::Range& RenderText::GetCompositionRange() const {
   return composition_range_;
 }
 
-void RenderText::SetCompositionRange(const ui::Range& composition_range) {
+void RenderText::SetCompositionRange(const gfx::Range& composition_range) {
   CHECK(!composition_range.IsValid() ||
-        ui::Range(0, text_.length()).Contains(composition_range));
+        gfx::Range(0, text_.length()).Contains(composition_range));
   composition_range_.set_end(composition_range.end());
   composition_range_.set_start(composition_range.start());
   ResetLayout();
 }
 
 void RenderText::SetColor(SkColor value) {
   colors_.SetValue(value);
 
 #if defined(OS_WIN)
   // TODO(msw): Windows applies colors and decorations in the layout process.
   cached_bounds_and_offset_valid_ = false;
   ResetLayout();
 #endif
 }
 
-void RenderText::ApplyColor(SkColor value, const ui::Range& range) {
+void RenderText::ApplyColor(SkColor value, const gfx::Range& range) {
   colors_.ApplyValue(value, range);
 
 #if defined(OS_WIN)
   // TODO(msw): Windows applies colors and decorations in the layout process.
   cached_bounds_and_offset_valid_ = false;
   ResetLayout();
 #endif
 }
 
 void RenderText::SetStyle(TextStyle style, bool value) {
   styles_[style].SetValue(value);
 
   // Only invalidate the layout on font changes; not for colors or decorations.
   bool invalidate = (style == BOLD) || (style == ITALIC);
 #if defined(OS_WIN)
   // TODO(msw): Windows applies colors and decorations in the layout process.
   invalidate = true;
 #endif
   if (invalidate) {
     cached_bounds_and_offset_valid_ = false;
     ResetLayout();
   }
 }
 
 void RenderText::ApplyStyle(TextStyle style,
                             bool value,
-                            const ui::Range& range) {
+                            const gfx::Range& range) {
   styles_[style].ApplyValue(value, range);
 
   // Only invalidate the layout on font changes; not for colors or decorations.
   bool invalidate = (style == BOLD) || (style == ITALIC);
 #if defined(OS_WIN)
   // TODO(msw): Windows applies colors and decorations in the layout process.
   invalidate = true;
 #endif
   if (invalidate) {
     cached_bounds_and_offset_valid_ = false;
@@ skipping 117 matching lines @@
   int x = 0, width = 1;
   Size size = GetStringSize();
   if (caret_pos == (caret_affinity == CURSOR_BACKWARD ? 0 : text().length())) {
     // The caret is attached to the boundary. Always return a 1-dip width caret,
     // since there is nothing to overtype.
     if ((GetTextDirection() == base::i18n::RIGHT_TO_LEFT) == (caret_pos == 0))
       x = size.width();
   } else {
     size_t grapheme_start = (caret_affinity == CURSOR_FORWARD) ?
         caret_pos : IndexOfAdjacentGrapheme(caret_pos, CURSOR_BACKWARD);
-    ui::Range xspan(GetGlyphBounds(grapheme_start));
+    gfx::Range xspan(GetGlyphBounds(grapheme_start));
     if (insert_mode) {
       x = (caret_affinity == CURSOR_BACKWARD) ? xspan.end() : xspan.start();
     } else {  // overtype mode
       x = xspan.GetMin();
       width = xspan.length();
     }
   }
   return Rect(ToViewPoint(Point(x, 0)), Size(width, size.height()));
 }
 
@@ skipping 20 matching lines @@
 
   while (index > 0) {
     index--;
     if (IsCursorablePosition(index))
       return index;
   }
   return 0;
 }
 
 SelectionModel RenderText::GetSelectionModelForSelectionStart() {
-  const ui::Range& sel = selection();
+  const gfx::Range& sel = selection();
   if (sel.is_empty())
     return selection_model_;
   return SelectionModel(sel.start(),
                         sel.is_reversed() ? CURSOR_BACKWARD : CURSOR_FORWARD);
 }
 
 void RenderText::SetTextShadows(const ShadowValues& shadows) {
   text_shadows_ = shadows;
 }
 
 RenderText::RenderText()
     : horizontal_alignment_(base::i18n::IsRTL() ? ALIGN_RIGHT : ALIGN_LEFT),
       vertical_alignment_(ALIGN_VCENTER),
       directionality_mode_(DIRECTIONALITY_FROM_TEXT),
       text_direction_(base::i18n::UNKNOWN_DIRECTION),
       cursor_enabled_(true),
       cursor_visible_(false),
       insert_mode_(true),
       cursor_color_(kDefaultColor),
       selection_color_(kDefaultColor),
       selection_background_focused_color_(kDefaultSelectionBackgroundColor),
       focused_(false),
-      composition_range_(ui::Range::InvalidRange()),
+      composition_range_(gfx::Range::InvalidRange()),
       colors_(kDefaultColor),
       styles_(NUM_TEXT_STYLES),
       composition_and_selection_styles_applied_(false),
       obscured_(false),
       obscured_reveal_index_(-1),
       truncate_length_(0),
       fade_head_(false),
       fade_tail_(false),
       background_is_transparent_(false),
       clip_to_display_rect_(true),
@@ skipping 41 matching lines @@
   DCHECK(!composition_and_selection_styles_applied_);
   saved_colors_ = colors_;
   saved_underlines_ = styles_[UNDERLINE];
 
   // Apply an underline to the composition range in |underlines|.
   if (composition_range_.IsValid() && !composition_range_.is_empty())
     styles_[UNDERLINE].ApplyValue(true, composition_range_);
 
   // Apply the selected text color to the [un-reversed] selection range.
   if (!selection().is_empty()) {
-    const ui::Range range(selection().GetMin(), selection().GetMax());
+    const gfx::Range range(selection().GetMin(), selection().GetMax());
     colors_.ApplyValue(selection_color_, range);
   }
   composition_and_selection_styles_applied_ = true;
 }
 
 void RenderText::UndoCompositionAndSelectionStyles() {
   // Restore the underline and color breaks to undo the temporary styles.
   DCHECK(composition_and_selection_styles_applied_);
   colors_ = saved_colors_;
   styles_[UNDERLINE] = saved_underlines_;
@@ skipping 78 matching lines @@
   if (shader)
     renderer->SetShader(shader.get(), display_rect());
 }
 
 void RenderText::ApplyTextShadows(internal::SkiaTextRenderer* renderer) {
   skia::RefPtr<SkDrawLooper> looper = CreateShadowDrawLooper(text_shadows_);
   renderer->SetDrawLooper(looper.get());
 }
 
 // static
-bool RenderText::RangeContainsCaret(const ui::Range& range,
+bool RenderText::RangeContainsCaret(const gfx::Range& range,
                                     size_t caret_pos,
                                     LogicalCursorDirection caret_affinity) {
   // NB: exploits unsigned wraparound (WG14/N1124 section 6.2.5 paragraph 9).
   size_t adjacent = (caret_affinity == CURSOR_BACKWARD) ?
       caret_pos - 1 : caret_pos + 1;
-  return range.Contains(ui::Range(caret_pos, adjacent));
+  return range.Contains(gfx::Range(caret_pos, adjacent));
 }
 
 void RenderText::MoveCursorTo(size_t position, bool select) {
   size_t cursor = std::min(position, text().length());
   if (IsCursorablePosition(cursor))
     SetSelectionModel(SelectionModel(
-        ui::Range(select ? selection().start() : cursor, cursor),
+        gfx::Range(select ? selection().start() : cursor, cursor),
         (cursor == 0) ? CURSOR_FORWARD : CURSOR_BACKWARD));
 }
 
 void RenderText::UpdateLayoutText() {
   layout_text_.clear();
 
   if (obscured_) {
     size_t obscured_text_length =
         static_cast<size_t>(ui::UTF16IndexToOffset(text_, 0, text_.length()));
     layout_text_.assign(obscured_text_length, kPasswordReplacementChar);
@@ skipping 71 matching lines @@
   cursor_bounds_ += delta_offset;
 }
 
 void RenderText::DrawSelection(Canvas* canvas) {
   const std::vector<Rect> sel = GetSubstringBounds(selection());
   for (std::vector<Rect>::const_iterator i = sel.begin(); i < sel.end(); ++i)
     canvas->FillRect(*i, selection_background_focused_color_);
 }
 
 }  // namespace gfx