Replace Label::Alignment with gfx::HorizontalAlignment

ui/views/controls/label.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/views/controls/label.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <vector>
@@ skipping 83 matching lines @@
 }
 
 void Label::SetShadowOffset(int x, int y) {
   shadow_offset_.SetPoint(x, y);
 }
 
 void Label::ClearEmbellishing() {
   has_shadow_ = false;
 }
 
-void Label::SetHorizontalAlignment(Alignment alignment) {
+void Label::SetHorizontalAlignment(gfx::HorizontalAlignment alignment) {
   // If the View's UI layout is right-to-left and directionality_mode_ is
   // USE_UI_DIRECTIONALITY, we need to flip the alignment so that the alignment
   // settings take into account the text directionality.
   if (base::i18n::IsRTL() && (directionality_mode_ == USE_UI_DIRECTIONALITY) &&
-      (alignment != ALIGN_CENTER))
-    alignment = (alignment == ALIGN_LEFT) ? ALIGN_RIGHT : ALIGN_LEFT;
-  if (horiz_alignment_ != alignment) {
-    horiz_alignment_ = alignment;
+      (alignment != gfx::ALIGN_CENTER)) {
+    alignment = (alignment == gfx::ALIGN_LEFT) ?
+        gfx::ALIGN_RIGHT : gfx::ALIGN_LEFT;
+  }
+  if (horizontal_alignment_ != alignment) {
+    horizontal_alignment_ = alignment;
     SchedulePaint();
   }
 }
 
 void Label::SetMultiLine(bool multi_line) {
   DCHECK(!multi_line || elide_behavior_ != ELIDE_IN_MIDDLE);
   if (multi_line != is_multi_line_) {
     is_multi_line_ = multi_line;
     text_size_valid_ = false;
     PreferredSizeChanged();
@@ skipping 191 matching lines @@
   font_ = font;
   text_size_valid_ = false;
   requested_enabled_color_ = ui::NativeTheme::instance()->GetSystemColor(
       ui::NativeTheme::kColorId_LabelEnabledColor);
   requested_disabled_color_ = ui::NativeTheme::instance()->GetSystemColor(
       ui::NativeTheme::kColorId_LabelDisabledColor);
   background_color_ = ui::NativeTheme::instance()->GetSystemColor(
       ui::NativeTheme::kColorId_LabelBackgroundColor);
   auto_color_readability_ = true;
   RecalculateColors();
-  horiz_alignment_ = ALIGN_CENTER;
+  horizontal_alignment_ = gfx::ALIGN_CENTER;
   is_multi_line_ = false;
   allow_character_break_ = false;
   elide_behavior_ = NO_ELIDE;
   collapse_when_hidden_ = false;
   directionality_mode_ = USE_UI_DIRECTIONALITY;
   has_focus_border_ = false;
   enabled_shadow_color_ = 0;
   disabled_shadow_color_ = 0;
   shadow_offset_.SetPoint(1, 1);
   has_shadow_ = false;
@@ skipping 12 matching lines @@
       requested_disabled_color_;
 }
 
 gfx::Rect Label::GetTextBounds() const {
   gfx::Rect available_rect(GetAvailableRect());
   gfx::Size text_size(GetTextSize());
   text_size.set_width(std::min(available_rect.width(), text_size.width()));
 
   gfx::Insets insets = GetInsets();
   gfx::Point text_origin(insets.left(), insets.top());
-  switch (horiz_alignment_) {
-    case ALIGN_LEFT:
+  switch (horizontal_alignment_) {
+    case gfx::ALIGN_LEFT:
       break;
-    case ALIGN_CENTER:
+    case gfx::ALIGN_CENTER:
       // We put any extra margin pixel on the left rather than the right.  We
       // used to do this because measurement on Windows used
       // GetTextExtentPoint32(), which could report a value one too large on the
       // right; we now use DrawText(), and who knows if it can also do this.
       text_origin.Offset((available_rect.width() + 1 - text_size.width()) / 2,
                          0);
       break;
-    case ALIGN_RIGHT:
+    case gfx::ALIGN_RIGHT:
       text_origin.set_x(available_rect.right() - text_size.width());
       break;
     default:
       NOTREACHED();
       break;
   }
   text_origin.Offset(0,
       std::max(0, (available_rect.height() - text_size.height())) / 2);
   return gfx::Rect(text_origin, text_size);
 }
@@ skipping 21 matching lines @@
 #if !defined(OS_WIN)
     // Don't elide multiline labels on Linux.
     // Todo(davemoore): Do we depend on eliding multiline text?
     // Pango insists on limiting the number of lines to one if text is
     // elided. You can get around this if you can pass a maximum height
     // but we don't currently have that data when we call the pango code.
     flags |= gfx::Canvas::NO_ELLIPSIS;
 #endif
   if (allow_character_break_)
     flags |= gfx::Canvas::CHARACTER_BREAK;
-  switch (horiz_alignment_) {
-    case ALIGN_LEFT:
+  switch (horizontal_alignment_) {
+    case gfx::ALIGN_LEFT:
       flags |= gfx::Canvas::TEXT_ALIGN_LEFT;
       break;
-    case ALIGN_CENTER:
+    case gfx::ALIGN_CENTER:
       flags |= gfx::Canvas::TEXT_ALIGN_CENTER;
       break;
-    case ALIGN_RIGHT:
+    case gfx::ALIGN_RIGHT:
       flags |= gfx::Canvas::TEXT_ALIGN_RIGHT;
       break;
   }
 
   return flags;
 }
 
 gfx::Rect Label::GetAvailableRect() const {
   gfx::Rect bounds(size());
   bounds.Inset(GetInsets());
@@ skipping 16 matching lines @@
                                 ui::ELIDE_AT_END);
   } else {
     *paint_text = text_;
   }
 
   *text_bounds = GetTextBounds();
   *flags = ComputeDrawStringFlags();
 }
 
 }  // namespace views