ChromeCanvas->gfx::Canvas

views/controls/menu/chrome_menu.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/menu/chrome_menu.h"
 
 #include <windows.h>
 #include <uxtheme.h>
 #include <Vssym32.h>
 
-#include "app/gfx/chrome_canvas.h"
+#include "app/gfx/canvas.h"
 #include "app/gfx/color_utils.h"
 #include "app/l10n_util.h"
 #include "app/l10n_util_win.h"
 #include "app/os_exchange_data.h"
 #include "base/base_drag_source.h"
 #include "base/gfx/native_theme.h"
 #include "base/message_loop.h"
 #include "base/task.h"
 #include "base/timer.h"
 #include "base/win_util.h"
@@ skipping 306 matching lines @@
 
   virtual void OnDragExited() {
     DCHECK(host_->GetMenuItem()->GetMenuController());
     host_->GetMenuItem()->GetMenuController()->OnDragExitedScrollButton(host_);
   }
 
   virtual int OnPerformDrop(const DropTargetEvent& event) {
     return DragDropTypes::DRAG_NONE;
   }
 
-  virtual void Paint(ChromeCanvas* canvas) {
+  virtual void Paint(gfx::Canvas* canvas) {
     HDC dc = canvas->beginPlatformPaint();
 
     // The background.
     RECT item_bounds = { 0, 0, width(), height() };
     NativeTheme::instance()->PaintMenuItemBackground(
         NativeTheme::MENU, dc, MENU_POPUPITEM, MPI_NORMAL, false,
         &item_bounds);
 
     // Then the arrow.
     int x = width() / 2;
@@ skipping 74 matching lines @@
     AddChildView(scroll_down_button_);
 
     scroll_view_ = new MenuScrollView(content_view);
     AddChildView(scroll_view_);
 
     set_border(Border::CreateEmptyBorder(
         kSubmenuBorderSize, kSubmenuBorderSize,
         kSubmenuBorderSize, kSubmenuBorderSize));
   }
 
-  virtual void Paint(ChromeCanvas* canvas) {
+  virtual void Paint(gfx::Canvas* canvas) {
     HDC dc = canvas->beginPlatformPaint();
     CRect bounds(0, 0, width(), height());
     NativeTheme::instance()->PaintMenuBackground(
         NativeTheme::MENU, dc, MENU_POPUPBACKGROUND, 0, &bounds);
     canvas->endPlatformPaint();
   }
 
   View* scroll_down_button() { return scroll_down_button_; }
 
   View* scroll_up_button() { return scroll_up_button_; }
@@ skipping 52 matching lines @@
 
 // MenuSeparator ---------------------------------------------------------------
 
 // Renders a separator.
 
 class MenuSeparator : public View {
  public:
   MenuSeparator() {
   }
 
-  void Paint(ChromeCanvas* canvas) {
+  void Paint(gfx::Canvas* canvas) {
     // The gutter is rendered before the background.
     int start_x = 0;
     int start_y = height() / 3;
     HDC dc = canvas->beginPlatformPaint();
     if (render_gutter) {
       // If render_gutter is true, we're on Vista and need to render the
       // gutter, then indent the separator from the gutter.
       RECT gutter_bounds = { label_start - kGutterToLabel - gutter_width, 0, 0,
                               height() };
       gutter_bounds.right = gutter_bounds.left + gutter_width;
@@ skipping 349 matching lines @@
   }
   gfx::Insets insets = GetInsets();
   return gfx::Size(max_width + insets.width(), height + insets.height());
 }
 
 void SubmenuView::DidChangeBounds(const gfx::Rect& previous,
                                   const gfx::Rect& current) {
   SchedulePaint();
 }
 
-void SubmenuView::PaintChildren(ChromeCanvas* canvas) {
+void SubmenuView::PaintChildren(gfx::Canvas* canvas) {
   View::PaintChildren(canvas);
 
   if (drop_item_ && drop_position_ != MenuDelegate::DROP_ON)
     PaintDropIndicator(canvas, drop_item_, drop_position_);
 }
 
 bool SubmenuView::CanDrop(const OSExchangeData& data) {
   DCHECK(GetMenuItem()->GetMenuController());
   return GetMenuItem()->GetMenuController()->CanDrop(this, data);
 }
@@ skipping 137 matching lines @@
 
 MenuScrollViewContainer* SubmenuView::GetScrollViewContainer() {
   if (!scroll_view_container_) {
     scroll_view_container_ = new MenuScrollViewContainer(this);
     // Otherwise MenuHost would delete us.
     scroll_view_container_->SetParentOwned(false);
   }
   return scroll_view_container_;
 }
 
-void SubmenuView::PaintDropIndicator(ChromeCanvas* canvas,
+void SubmenuView::PaintDropIndicator(gfx::Canvas* canvas,
                                      MenuItemView* item,
                                      MenuDelegate::DropPosition position) {
   if (position == MenuDelegate::DROP_NONE)
     return;
 
   gfx::Rect bounds = CalculateDropIndicatorBounds(item, position);
   canvas->FillRectInt(kDropIndicatorColor, bounds.x(), bounds.y(),
                       bounds.width(), bounds.height());
 }
 
@@ skipping 158 matching lines @@
   MenuItemView* item = GetDescendantByID(item_id);
   DCHECK(item);
   item->SetIcon(icon);
 }
 
 void MenuItemView::SetIcon(const SkBitmap& icon) {
   icon_ = icon;
   SchedulePaint();
 }
 
-void MenuItemView::Paint(ChromeCanvas* canvas) {
+void MenuItemView::Paint(gfx::Canvas* canvas) {
   Paint(canvas, false);
 }
 
 gfx::Size MenuItemView::GetPreferredSize() {
   gfx::Font& font = GetRootMenuItem()->font_;
   return gfx::Size(
       font.GetStringWidth(title_) + label_start + item_right_margin,
       font.height() + GetBottomMargin() + GetTopMargin());
 }
 
@@ skipping 143 matching lines @@
 
   BOOL show_cues;
   show_mnemonics =
       (SystemParametersInfo(SPI_GETKEYBOARDCUES, 0, &show_cues, 0) &&
        show_cues == TRUE);
 }
 
 int MenuItemView::GetDrawStringFlags() {
   int flags = 0;
   if (UILayoutIsRightToLeft())
-    flags |= ChromeCanvas::TEXT_ALIGN_RIGHT;
+    flags |= gfx::Canvas::TEXT_ALIGN_RIGHT;
   else
-    flags |= ChromeCanvas::TEXT_ALIGN_LEFT;
+    flags |= gfx::Canvas::TEXT_ALIGN_LEFT;
 
   if (has_mnemonics_) {
     if (show_mnemonics)
-      flags |= ChromeCanvas::SHOW_PREFIX;
+      flags |= gfx::Canvas::SHOW_PREFIX;
     else
-      flags |= ChromeCanvas::HIDE_PREFIX;
+      flags |= gfx::Canvas::HIDE_PREFIX;
   }
   return flags;
 }
 
 void MenuItemView::AddEmptyMenus() {
   DCHECK(HasSubmenu());
   if (submenu_->GetChildViewCount() == 0) {
     submenu_->AddChildView(0, new EmptyMenuMenuItem(this));
   } else {
     for (int i = 0, item_count = submenu_->GetMenuItemCount(); i < item_count;
@@ skipping 20 matching lines @@
     }
   }
 }
 
 void MenuItemView::AdjustBoundsForRTLUI(RECT* rect) const {
   gfx::Rect mirrored_rect(*rect);
   mirrored_rect.set_x(MirroredLeftPointForRect(mirrored_rect));
   *rect = mirrored_rect.ToRECT();
 }
 
-void MenuItemView::Paint(ChromeCanvas* canvas, bool for_drag) {
+void MenuItemView::Paint(gfx::Canvas* canvas, bool for_drag) {
   bool render_selection =
       (!for_drag && IsSelected() &&
        parent_menu_item_->GetSubmenu()->GetShowSelection(this));
   int state = render_selection ? MPI_HOT :
                                  (IsEnabled() ? MPI_NORMAL : MPI_DISABLED);
   HDC dc = canvas->beginPlatformPaint();
 
   // The gutter is rendered before the background.
   if (render_gutter && !for_drag) {
     RECT gutter_bounds = { label_start - kGutterToLabel - gutter_width, 0, 0,
@@ skipping 380 matching lines @@
       DCHECK(item);
       // Points are in the coordinates of the submenu, need to map to that of
       // the selected item. Additionally source may not be the parent of
       // the selected item, so need to map to screen first then to item.
       gfx::Point press_loc(press_x_, press_y_);
       View::ConvertPointToScreen(source->GetScrollViewContainer(), &press_loc);
       View::ConvertPointToView(NULL, item, &press_loc);
       gfx::Point drag_loc(event.location());
       View::ConvertPointToScreen(source->GetScrollViewContainer(), &drag_loc);
       View::ConvertPointToView(NULL, item, &drag_loc);
-      ChromeCanvas canvas(item->width(), item->height(), false);
+      gfx::Canvas canvas(item->width(), item->height(), false);
       item->Paint(&canvas, true);
 
       scoped_refptr<OSExchangeData> data(new OSExchangeData);
       item->GetDelegate()->WriteDragData(item, data.get());
       drag_utils::SetDragImageOnDataObject(canvas, item->width(),
                                            item->height(), press_loc.x(),
                                            press_loc.y(), data);
 
       scoped_refptr<BaseDragSource> drag_source(new BaseDragSource);
       int drag_ops = item->GetDelegate()->GetDragOperations(item);
@@ skipping 973 matching lines @@
   if (!scroll_task_.get())
     scroll_task_.reset(new MenuScrollTask());
   scroll_task_->Update(part);
 }
 
 void MenuController::StopScrolling() {
   scroll_task_.reset(NULL);
 }
 
 }  // namespace views