ChromeCanvas->gfx::Canvas

views/controls/label.cc

 // Copyright (c) 2006-2008 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/label.h"
 
 #include <math.h>
 
-#include "app/gfx/chrome_canvas.h"
-#include "app/gfx/chrome_font.h"
+#include "app/gfx/canvas.h"
+#include "app/gfx/font.h"
 #include "app/gfx/insets.h"
 #include "app/gfx/text_elider.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "views/background.h"
 
 namespace views {
 
@@ skipping 40 matching lines @@
   // Return a size of (0, 0) if the label is not visible and if the
   // collapse_when_hidden_ flag is set.
   // TODO(munjal): This logic probably belongs to the View class. But for now,
   // put it here since putting it in View class means all inheriting classes
   // need ot respect the collapse_when_hidden_ flag.
   if (!IsVisible() && collapse_when_hidden_)
     return prefsize;
 
   if (is_multi_line_) {
     int w = width(), h = 0;
-    ChromeCanvas::SizeStringInt(text_, font_, &w, &h, ComputeMultiLineFlags());
+    gfx::Canvas::SizeStringInt(text_, font_, &w, &h, ComputeMultiLineFlags());
     prefsize.SetSize(w, h);
   } else {
     prefsize = GetTextSize();
   }
 
   gfx::Insets insets = GetInsets();
   prefsize.Enlarge(insets.width(), insets.height());
   return prefsize;
 }
 
 int Label::ComputeMultiLineFlags() {
-  int flags = ChromeCanvas::MULTI_LINE;
+  int flags = gfx::Canvas::MULTI_LINE;
   if (allow_character_break_)
-    flags |= ChromeCanvas::CHARACTER_BREAK;
+    flags |= gfx::Canvas::CHARACTER_BREAK;
   switch (horiz_alignment_) {
     case ALIGN_LEFT:
-      flags |= ChromeCanvas::TEXT_ALIGN_LEFT;
+      flags |= gfx::Canvas::TEXT_ALIGN_LEFT;
       break;
     case ALIGN_CENTER:
-      flags |= ChromeCanvas::TEXT_ALIGN_CENTER;
+      flags |= gfx::Canvas::TEXT_ALIGN_CENTER;
       break;
     case ALIGN_RIGHT:
-      flags |= ChromeCanvas::TEXT_ALIGN_RIGHT;
+      flags |= gfx::Canvas::TEXT_ALIGN_RIGHT;
       break;
   }
   return flags;
 }
 
 void Label::CalculateDrawStringParams(
     std::wstring* paint_text, gfx::Rect* text_bounds, int* flags) {
   DCHECK(paint_text && text_bounds && flags);
 
   if (url_set_) {
@@ skipping 22 matching lines @@
                          insets.top(),
                          width() - insets.width(),
                          height() - insets.height());
     *flags = ComputeMultiLineFlags();
   } else {
     *text_bounds = GetTextBounds();
     *flags = 0;
   }
 }
 
-void Label::Paint(ChromeCanvas* canvas) {
+void Label::Paint(gfx::Canvas* canvas) {
   PaintBackground(canvas);
   std::wstring paint_text;
   gfx::Rect text_bounds;
   int flags = 0;
   CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
   canvas->DrawStringInt(paint_text,
                         font_,
                         color_,
                         text_bounds.x(),
                         text_bounds.y(),
                         text_bounds.width(),
                         text_bounds.height(),
                         flags);
 
   // The focus border always hugs the text, regardless of the label's bounds.
   if (HasFocus() || paint_as_focused_) {
     int w = text_bounds.width();
     int h = 0;
     // We explicitly OR in MULTI_LINE here since SizeStringInt seems to return
     // an incorrect height for single line text when the MULTI_LINE flag isn't
     // specified. o_O...
-    ChromeCanvas::SizeStringInt(paint_text, font_, &w, &h,
-                                flags | ChromeCanvas::MULTI_LINE);
+    gfx::Canvas::SizeStringInt(paint_text, font_, &w, &h,
+                               flags | gfx::Canvas::MULTI_LINE);
     gfx::Rect focus_rect = text_bounds;
     focus_rect.set_width(w);
     focus_rect.set_height(h);
     focus_rect.Inset(-kFocusBorderPadding, -kFocusBorderPadding);
     // If the label is a single line of text, then the computed text bound
     // corresponds directly to the text being drawn and no mirroring is needed
     // for the RTL case. For multiline text, the text bound is an estimation
-    // and is recomputed in ChromeCanvas::SizeStringInt(). For multiline text
+    // and is recomputed in gfx::Canvas::SizeStringInt(). For multiline text
     // in RTL, we need to take mirroring into account when computing the focus
     // rectangle.
     int x = focus_rect.x();
-    if (flags & ChromeCanvas::MULTI_LINE)
+    if (flags & gfx::Canvas::MULTI_LINE)
       x = MirroredLeftPointForRect(focus_rect);
     canvas->DrawFocusRect(x, focus_rect.y(), focus_rect.width(),
                           focus_rect.height());
   }
 }
 
-void Label::PaintBackground(ChromeCanvas* canvas) {
+void Label::PaintBackground(gfx::Canvas* canvas) {
   const Background* bg = contains_mouse_ ? GetMouseOverBackground() : NULL;
   if (!bg)
     bg = background();
   if (bg)
     bg->Paint(canvas, this);
 }
 
 void Label::SetFont(const gfx::Font& font) {
   font_ = font;
   text_size_valid_ = false;
@@ skipping 42 matching lines @@
   if (text_size_valid_)
     return text_size_;
   return gfx::Size();
 }
 
 int Label::GetHeightForWidth(int w) {
   if (is_multi_line_) {
     gfx::Insets insets = GetInsets();
     w = std::max<int>(0, w - insets.width());
     int h = 0;
-    ChromeCanvas cc(0, 0, true);
+    gfx::Canvas cc(0, 0, true);
     cc.SizeStringInt(text_, font_, &w, &h, ComputeMultiLineFlags());
     return h + insets.height();
   }
 
   return View::GetHeightForWidth(w);
 }
 
 std::string Label::GetClassName() const {
   return kViewClassName;
 }
@@ skipping 191 matching lines @@
 }
 
 bool Label::GetAccessibleState(AccessibilityTypes::State* state) {
   DCHECK(state);
 
   *state = AccessibilityTypes::STATE_READONLY;
   return true;
 }
 
 }  // namespace views