Move text_elider to gfx.

ui/base/text/text_elider.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.
 //
 // This file implements utility functions for eliding and formatting UI text.
 //
 // Note that several of the functions declared in text_elider.h are implemented
 // in this file using helper classes in an unnamed namespace.
 
-#include "ui/base/text/text_elider.h"
+#include "ui/gfx/text_elider.h"
 
 #include <string>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/i18n/break_iterator.h"
 #include "base/i18n/char_iterator.h"
 #include "base/i18n/rtl.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_split.h"
@@ skipping 786 matching lines @@
 }
 
 // Internal class used to track progress of a rectangular text elide
 // operation.  Exists so the top-level ElideRectangleText() function
 // can be broken into smaller methods sharing this state.
 class RectangleText {
  public:
   RectangleText(const gfx::FontList& font_list,
                 int available_pixel_width,
                 int available_pixel_height,
-                ui::WordWrapBehavior wrap_behavior,
+                gfx::WordWrapBehavior wrap_behavior,
                 std::vector<string16>* lines)
       : font_list_(font_list),
         line_height_(font_list.GetHeight()),
         available_pixel_width_(available_pixel_width),
         available_pixel_height_(available_pixel_height),
         wrap_behavior_(wrap_behavior),
         current_width_(0),
         current_height_(0),
         last_line_ended_in_lf_(false),
         lines_(lines),
@@ skipping 47 matching lines @@
   // The height of each line of text.
   const int line_height_;
 
   // The number of pixels of available width in the rectangle.
   const int available_pixel_width_;
 
   // The number of pixels of available height in the rectangle.
   const int available_pixel_height_;
 
   // The wrap behavior for words that are too long to fit on a single line.
-  const ui::WordWrapBehavior wrap_behavior_;
+  const gfx::WordWrapBehavior wrap_behavior_;
 
   // The current running width.
   int current_width_;
 
   // The current running height.
   int current_height_;
 
   // The current line of text.
   string16 current_line_;
 
@@ skipping 35 matching lines @@
 int RectangleText::Finalize() {
   // Remove trailing whitespace from the last line or remove the last line
   // completely, if it's just whitespace.
   if (!insufficient_height_ && !lines_->empty()) {
     TrimWhitespace(lines_->back(), TRIM_TRAILING, &lines_->back());
     if (lines_->back().empty() && !last_line_ended_in_lf_)
       lines_->pop_back();
   }
   if (last_line_ended_in_lf_)
     lines_->push_back(string16());
-  return (insufficient_width_ ? ui::INSUFFICIENT_SPACE_HORIZONTAL : 0) |
-         (insufficient_height_ ? ui::INSUFFICIENT_SPACE_VERTICAL : 0);
+  return (insufficient_width_ ? gfx::INSUFFICIENT_SPACE_HORIZONTAL : 0) |
+         (insufficient_height_ ? gfx::INSUFFICIENT_SPACE_VERTICAL : 0);
 }
 
 void RectangleText::AddLine(const string16& line) {
   const int line_width = gfx::GetStringWidth(line, font_list_);
   if (line_width <= available_pixel_width_) {
     AddToCurrentLineWithWidth(line, line_width);
   } else {
     // Iterate over positions that are valid to break the line at. In general,
     // these are word boundaries but after any punctuation following the word.
     base::i18n::BreakIterator words(line,
@@ skipping 24 matching lines @@
   NewLine();
 }
 
 int RectangleText::WrapWord(const string16& word) {
   // Word is so wide that it must be fragmented.
   string16 text = word;
   int lines_added = 0;
   bool first_fragment = true;
   while (!insufficient_height_ && !text.empty()) {
     string16 fragment =
-        ui::ElideText(text, font_list_, available_pixel_width_,
-                      ui::TRUNCATE_AT_END);
+        gfx::ElideText(text, font_list_, available_pixel_width_,
+                      gfx::TRUNCATE_AT_END);
     // At least one character has to be added at every line, even if the
     // available space is too small.
     if(fragment.empty())
       fragment = text.substr(0, 1);
     if (!first_fragment && NewLine())
       lines_added++;
     AddToCurrentLine(fragment);
     text = text.substr(fragment.length());
     first_fragment = false;
   }
   return lines_added;
 }
 
 int RectangleText::AddWordOverflow(const string16& word) {
   int lines_added = 0;
 
   // Unless this is the very first word, put it on a new line.
   if (!current_line_.empty()) {
     if (!NewLine())
       return 0;
     lines_added++;
   }
 
-  if (wrap_behavior_ == ui::IGNORE_LONG_WORDS) {
+  if (wrap_behavior_ == gfx::IGNORE_LONG_WORDS) {
     current_line_ = word;
     current_width_ = available_pixel_width_;
-  } else if (wrap_behavior_ == ui::WRAP_LONG_WORDS) {
+  } else if (wrap_behavior_ == gfx::WRAP_LONG_WORDS) {
     lines_added += WrapWord(word);
   } else {
-    const ui::ElideBehavior elide_behavior =
-        (wrap_behavior_ == ui::ELIDE_LONG_WORDS ? ui::ELIDE_AT_END :
-                                                  ui::TRUNCATE_AT_END);
+    const gfx::ElideBehavior elide_behavior =
+        (wrap_behavior_ == gfx::ELIDE_LONG_WORDS ? gfx::ELIDE_AT_END :
+                                                  gfx::TRUNCATE_AT_END);
     const string16 elided_word =
-        ui::ElideText(word, font_list_, available_pixel_width_, elide_behavior);
+        gfx::ElideText(word, font_list_, available_pixel_width_, elide_behavior);
     AddToCurrentLine(elided_word);
     insufficient_width_ = true;
   }
 
   return lines_added;
 }
 
 int RectangleText::AddWord(const string16& word) {
   int lines_added = 0;
   string16 trimmed;
   TrimWhitespace(word, TRIM_TRAILING, &trimmed);
   const int trimmed_width = gfx::GetStringWidth(trimmed, font_list_);
   if (trimmed_width <= available_pixel_width_) {
     // Word can be made to fit, no need to fragment it.
     if ((current_width_ + trimmed_width > available_pixel_width_) && NewLine())
       lines_added++;
     // Append the non-trimmed word, in case more words are added after.
     AddToCurrentLine(word);
   } else {
-    lines_added = AddWordOverflow(wrap_behavior_ == ui::IGNORE_LONG_WORDS ?
+    lines_added = AddWordOverflow(wrap_behavior_ == gfx::IGNORE_LONG_WORDS ?
                                   trimmed : word);
   }
   return lines_added;
 }
 
 void RectangleText::AddToCurrentLine(const string16& text) {
   AddToCurrentLineWithWidth(text, gfx::GetStringWidth(text, font_list_));
 }
 
 void RectangleText::AddToCurrentLineWithWidth(const string16& text,
@@ skipping 115 matching lines @@
       index = char_iterator.getIndex();
     } else {
       // String has leading whitespace, return the elide string.
       return kElideString;
     }
   }
   return string.substr(0, index) + kElideString;
 }
 
 }  // namespace ui