Setting the touch wrench menu as default menu for ChromeOS

chrome/browser/ui/views/wrench_menu.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 "chrome/browser/ui/views/wrench_menu.h"
 
 #include <algorithm>
 #include <cmath>
 #include <set>
 
@@ skipping 60 matching lines @@
 const SkColor kBorderColor = SkColorSetARGB(36, 0, 0, 0);
 const SkColor kPushedBorderColor = SkColorSetARGB(72, 0, 0, 0);
 const SkColor kHotBackgroundColor = SkColorSetARGB(204, 255, 255, 255);
 const SkColor kBackgroundColor = SkColorSetARGB(102, 255, 255, 255);
 const SkColor kPushedBackgroundColor = SkColorSetARGB(13, 0, 0, 0);
 const SkColor kTouchBackgroundColor = SkColorSetARGB(247, 255, 255, 255);
 const SkColor kHotTouchBackgroundColor = SkColorSetARGB(247, 242, 242, 242);
 const SkColor kPushedTouchBackgroundColor = SkColorSetARGB(247, 235, 235, 235);
 
 const SkColor kTouchButtonText = 0xff5a5a5a;
-const SkColor kTouchImageBrighten = 0x80ffffff;
 
 // Horizontal padding on the edges of the buttons.
 const int kHorizontalPadding = 6;
 // Horizontal padding for a touch enabled menu.
 const int kHorizontalTouchPadding = 15;
 
-// For touch menu items we want to have this height in pixels.
-const int kTouchItemHeight = 47;
+// Menu items which have embedded buttons should have this height in pixel.
+const int kMenuItemContainingButtonsHeight = 43;
+
+// Returns true when the new menu style is used.
+// TODO(skuhne): Remove when only the new menu style is left.
+bool IsNewMenu() {
+#if defined(USE_AURA)
+  return true;
+#else
+  return ui::GetDisplayLayout() == ui::LAYOUT_TOUCH;
+#endif
+}
 
 // Subclass of ImageButton whose preferred size includes the size of the border.
 class FullscreenButton : public ImageButton {
  public:
   explicit FullscreenButton(views::ButtonListener* listener)
       : ImageButton(listener) { }
 
   // Overridden from ImageButton.
   virtual gfx::Size GetPreferredSize() OVERRIDE {
     gfx::Size pref = ImageButton::GetPreferredSize();
     gfx::Insets insets;
     if (border())
       border()->GetInsets(&insets);
     pref.Enlarge(insets.width(), insets.height());
     return pref;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FullscreenButton);
 };
 
 // Border for buttons contained in the menu. This is only used for getting the
 // insets, the actual painting is done in MenuButtonBackground.
 class MenuButtonBorder : public views::Border {
  public:
   MenuButtonBorder()
-    : horizontal_padding_(ui::GetDisplayLayout() == ui::LAYOUT_TOUCH ?
+    : horizontal_padding_(IsNewMenu() ?
                               kHorizontalTouchPadding :
                               kHorizontalPadding) {}
 
   // Overridden from views::Border.
   virtual void Paint(const View& view, gfx::Canvas* canvas) const OVERRIDE {
     // Painting of border is done in MenuButtonBackground.
   }
 
   virtual void GetInsets(gfx::Insets* insets) const OVERRIDE {
     insets->Set(MenuConfig::instance().item_top_margin,
@@ skipping 41 matching lines @@
   // Overridden from views::Background.
   virtual void Paint(gfx::Canvas* canvas, View* view) const OVERRIDE {
     CustomButton::ButtonState state =
         (view->GetClassName() == views::Label::kViewClassName) ?
         CustomButton::BS_NORMAL : static_cast<CustomButton*>(view)->state();
     int w = view->width();
     int h = view->height();
     // Windows is drawing its own separators and we cannot use the touch button
     // for that.
 #if !defined(OS_WIN)
-    if (ui::GetDisplayLayout() == ui::LAYOUT_TOUCH) {
+    if (IsNewMenu()) {
       // Normal buttons get a border drawn on the right side and the rest gets
       // filled in. The left button however does not get a line to combine
       // buttons.
       int border = 0;
       if (type_ != RIGHT_BUTTON) {
         border = 1;
         canvas->FillRect(gfx::Rect(0, 0, border, h),
                          border_color(CustomButton::BS_NORMAL));
       }
       canvas->FillRect(gfx::Rect(border, 0, w - border, h),
@@ skipping 206 matching lines @@
       size.set_height(height);
     return size;
   }
 
  private:
   int height_;
 
   DISALLOW_COPY_AND_ASSIGN(ButtonContainerMenuItemView);
 };
 
-class TintedImageSource: public gfx::CanvasImageSource {
- public:
-  TintedImageSource(gfx::ImageSkia& image, SkColor tint_value)
-      : CanvasImageSource(image.size(), false),
-        image_(image),
-        tint_value_(tint_value) {
-  }
-
-  virtual ~TintedImageSource() {
-  }
-
-  // Overridden from gfx::CanvasImageSource.
-  virtual void Draw(gfx::Canvas* canvas) OVERRIDE {
-    canvas->DrawImageInt(image_, 0, 0);
-    SkPaint paint;
-    // We leave the old alpha alone and add the new color multiplied
-    // with the source alpha to the existing alpha. Thus: We brighten
-    // the image up - but only the non transparent pixels.
-    paint.setXfermodeMode(SkXfermode::kDstATop_Mode);
-    paint.setColor(tint_value_);
-    canvas->sk_canvas()->drawPaint(paint);
-  }
-
- private:
-  const gfx::ImageSkia image_;
-  const SkColor tint_value_;
-
-  DISALLOW_COPY_AND_ASSIGN(TintedImageSource);
-};
-
 }  // namespace
 
 // CutCopyPasteView ------------------------------------------------------------
 
 // CutCopyPasteView is the view containing the cut/copy/paste buttons.
 class WrenchMenu::CutCopyPasteView : public WrenchMenuView {
  public:
   CutCopyPasteView(WrenchMenu* menu,
                    MenuModel* menu_model,
                    int cut_index,
                    int copy_index,
                    int paste_index)
       : WrenchMenuView(menu, menu_model) {
     TextButton* cut = CreateAndConfigureButton(
         IDS_CUT, MenuButtonBackground::LEFT_BUTTON, cut_index, NULL);
 
     MenuButtonBackground* copy_background = NULL;
     TextButton* copy = CreateAndConfigureButton(
         IDS_COPY, MenuButtonBackground::CENTER_BUTTON, copy_index,
         &copy_background);
 
-    bool is_touch = ui::GetDisplayLayout() == ui::LAYOUT_TOUCH;
+    bool is_new_menu = IsNewMenu();
 
     TextButton* paste = CreateAndConfigureButton(
         IDS_PASTE,
 #if !defined(OS_WIN)
-        is_touch ? MenuButtonBackground::CENTER_BUTTON :
+        is_new_menu ? MenuButtonBackground::CENTER_BUTTON :
 #endif
             MenuButtonBackground::RIGHT_BUTTON,
         paste_index,
         NULL);
-    if (is_touch) {
+    if (is_new_menu) {
       cut->SetEnabledColor(kTouchButtonText);
       copy->SetEnabledColor(kTouchButtonText);
       paste->SetEnabledColor(kTouchButtonText);
     }
     copy_background->SetOtherButtons(cut, paste);
   }
 
   // Overridden from View.
   virtual gfx::Size GetPreferredSize() OVERRIDE {
     // Returned height doesn't matter as MenuItemView forces everything to the
@@ skipping 52 matching lines @@
         zoom_label_width_(0) {
     decrement_button_ = CreateButtonWithAccName(
         IDS_ZOOM_MINUS2, MenuButtonBackground::LEFT_BUTTON, decrement_index,
         NULL, IDS_ACCNAME_ZOOM_MINUS2);
 
     zoom_label_ = new Label(
         l10n_util::GetStringFUTF16Int(IDS_ZOOM_PERCENT, 100));
     zoom_label_->SetAutoColorReadabilityEnabled(false);
     zoom_label_->SetHorizontalAlignment(Label::ALIGN_RIGHT);
 
-    bool is_touch = ui::GetDisplayLayout() == ui::LAYOUT_TOUCH;
+    bool is_new_menu = IsNewMenu();
 
     MenuButtonBackground* center_bg = new MenuButtonBackground(
 #if !defined(OS_WIN)
-        is_touch ? MenuButtonBackground::RIGHT_BUTTON :
+        is_new_menu ? MenuButtonBackground::RIGHT_BUTTON :
 #endif
             MenuButtonBackground::CENTER_BUTTON);
     zoom_label_->set_background(center_bg);
     zoom_label_->set_border(new MenuButtonBorder());
     zoom_label_->SetFont(MenuConfig::instance().font);
 
     AddChildView(zoom_label_);
     zoom_label_width_ = MaxWidthForZoomLabel();
 
     increment_button_ = CreateButtonWithAccName(
         IDS_ZOOM_PLUS2, MenuButtonBackground::RIGHT_BUTTON, increment_index,
         NULL, IDS_ACCNAME_ZOOM_PLUS2);
 
     center_bg->SetOtherButtons(decrement_button_, increment_button_);
 
     fullscreen_button_ = new FullscreenButton(this);
     gfx::ImageSkia* full_screen_image =
         ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
             IDR_FULLSCREEN_MENU_BUTTON);
-    if (is_touch) {
-      // In case of touch, the menu needs to be brightened up a bit.
-      gfx::CanvasImageSource* source = new TintedImageSource(
-          *full_screen_image, kTouchImageBrighten);
-      // ImageSkia takes ownership of |source|.
-      tinted_fullscreen_image_ = gfx::ImageSkia(source, source->size());
-      fullscreen_button_->SetImage(ImageButton::BS_NORMAL,
-                                   &tinted_fullscreen_image_);
-    } else {
-      fullscreen_button_->SetImage(ImageButton::BS_NORMAL, full_screen_image);
-    }
-    if (is_touch) {
+    fullscreen_button_->SetImage(ImageButton::BS_NORMAL, full_screen_image);
+    if (is_new_menu) {
       zoom_label_->SetEnabledColor(kTouchButtonText);
       decrement_button_->SetEnabledColor(kTouchButtonText);
       increment_button_->SetEnabledColor(kTouchButtonText);
     } else {
       zoom_label_->SetEnabledColor(MenuConfig::instance().text_color);
     }
 
     fullscreen_button_->set_focusable(true);
     fullscreen_button_->set_request_focus_on_press(false);
     fullscreen_button_->set_tag(fullscreen_index);
     fullscreen_button_->SetImageAlignment(
         ImageButton::ALIGN_CENTER, ImageButton::ALIGN_MIDDLE);
-    int horizontal_padding = ui::GetDisplayLayout() == ui::LAYOUT_TOUCH ?
+    int horizontal_padding = IsNewMenu() ?
                                  kHorizontalTouchPadding : kHorizontalPadding;
     fullscreen_button_->set_border(views::Border::CreateEmptyBorder(
         0, horizontal_padding, 0, horizontal_padding));
     fullscreen_button_->set_background(
         new MenuButtonBackground(MenuButtonBackground::SINGLE_BUTTON));
     fullscreen_button_->SetAccessibleName(
         GetAccessibleNameForWrenchMenuItem(
             menu_model, fullscreen_index, IDS_ACCNAME_FULLSCREEN));
     AddChildView(fullscreen_button_);
 
     UpdateZoomControls();
 
     registrar_.Add(
         this, content::NOTIFICATION_ZOOM_LEVEL_CHANGED,
         content::Source<HostZoomMap>(
             HostZoomMap::GetForBrowserContext(menu->browser_->profile())));
   }
 
   // Overridden from View.
   virtual gfx::Size GetPreferredSize() OVERRIDE {
     // The increment/decrement button are forced to the same width.
     int button_width = std::max(increment_button_->GetPreferredSize().width(),
                                 decrement_button_->GetPreferredSize().width());
-    int zoom_padding = ui::GetDisplayLayout() == ui::LAYOUT_TOUCH ?
-                           kTouchZoomPadding : kZoomPadding;
+    int zoom_padding = IsNewMenu() ? kTouchZoomPadding : kZoomPadding;
     int fullscreen_width = fullscreen_button_->GetPreferredSize().width() +
                            zoom_padding;
     // Returned height doesn't matter as MenuItemView forces everything to the
     // height of the menuitemview. Note that we have overridden the height when
     // constructing the menu.
     return gfx::Size(button_width + zoom_label_width_ + button_width +
                      fullscreen_width, 0);
   }
 
   virtual void Layout() OVERRIDE {
     int x = 0;
     int button_width = std::max(increment_button_->GetPreferredSize().width(),
                                 decrement_button_->GetPreferredSize().width());
     gfx::Rect bounds(0, 0, button_width, height());
 
     decrement_button_->SetBoundsRect(bounds);
 
     x += bounds.width();
     bounds.set_x(x);
     bounds.set_width(zoom_label_width_);
     zoom_label_->SetBoundsRect(bounds);
 
     x += bounds.width();
     bounds.set_x(x);
     bounds.set_width(button_width);
     increment_button_->SetBoundsRect(bounds);
 
-    bool is_touch = ui::GetDisplayLayout() == ui::LAYOUT_TOUCH;
-    x += bounds.width() + (is_touch ? 0 : kZoomPadding);
+    bool is_new_menu = IsNewMenu();
+    x += bounds.width() + (is_new_menu ? 0 : kZoomPadding);
     bounds.set_x(x);
     bounds.set_width(fullscreen_button_->GetPreferredSize().width() +
-                     (is_touch ? kTouchZoomPadding : 0));
+                     (is_new_menu ? kTouchZoomPadding : 0));
     fullscreen_button_->SetBoundsRect(bounds);
   }
 
   // Overridden from ButtonListener.
   virtual void ButtonPressed(views::Button* sender,
                              const ui::Event& event) OVERRIDE {
     if (sender->tag() == fullscreen_index_) {
       menu_->CancelAndEvaluate(menu_model_, sender->tag());
     } else {
       // Zoom buttons don't close the menu.
@@ skipping 73 matching lines @@
   TextButton* increment_button_;
 
   // Label showing zoom as a percent.
   Label* zoom_label_;
 
   // Button for decrementing the zoom.
   TextButton* decrement_button_;
 
   ImageButton* fullscreen_button_;
 
-  // The tinted bitmap of the fullscreen button.
-  gfx::ImageSkia tinted_fullscreen_image_;
-
   // Width given to |zoom_label_|. This is the width at 100%.
   int zoom_label_width_;
 
   DISALLOW_COPY_AND_ASSIGN(ZoomView);
 };
 
 // WrenchMenu ------------------------------------------------------------------
 
 WrenchMenu::WrenchMenu(Browser* browser)
     : root_(NULL),
@@ skipping 240 matching lines @@
       root_->Cancel();
       break;
     default:
       NOTREACHED();
   }
 }
 
 void WrenchMenu::PopulateMenu(MenuItemView* parent,
                               MenuModel* model,
                               int* next_id) {
-  bool is_touch = ui::GetDisplayLayout() == ui::LAYOUT_TOUCH;
+  bool is_new_menu = IsNewMenu();
 
   int index_offset = model->GetFirstItemIndex(NULL);
   for (int i = 0, max = model->GetItemCount(); i < max; ++i) {
     int index = i + index_offset;
 
     // The button container menu items have a special height which we have to
     // use instead of the normal height.
     int height = 0;
-    if (is_touch &&
+    if (is_new_menu &&
         (model->GetCommandIdAt(index) == IDC_CUT ||
          model->GetCommandIdAt(index) == IDC_ZOOM_MINUS))
-      height = kTouchItemHeight;
+      height = kMenuItemContainingButtonsHeight;
 
     MenuItemView* item = AppendMenuItem(
         parent, model, index, model->GetTypeAt(index), next_id, height);
 
     if (model->GetTypeAt(index) == MenuModel::TYPE_SUBMENU)
       PopulateMenu(item, model->GetSubmenuModelAt(index), next_id);
 
     switch (model->GetCommandIdAt(index)) {
       case IDC_CUT:
         DCHECK_EQ(MenuModel::TYPE_COMMAND, model->GetTypeAt(index));
@@ skipping 49 matching lines @@
     // For menu items with a special menu height we use our special class to be
     // able to modify the item height.
     menu_item = new ButtonContainerMenuItemView(parent, id, height);
     parent->GetSubmenu()->AddChildView(menu_item);
   } else {
     // For all other cases we use the more generic way to add menu items.
     menu_item = parent->AppendMenuItemFromModel(model, index, id);
   }
 
   if (menu_item) {
-    // Flush all buttons to the right side of the menu for touch menus.
-    menu_item->set_use_right_margin(
-        ui::GetDisplayLayout() != ui::LAYOUT_TOUCH);
+    bool is_new_menu = IsNewMenu();
+    // Flush all buttons to the right side of the menu for the new menu type.
+    menu_item->set_use_right_margin(!is_new_menu);
     menu_item->SetVisible(model->IsVisibleAt(index));
 
     if (menu_type == MenuModel::TYPE_COMMAND && model->HasIcons()) {
       gfx::Image icon;
       if (model->GetIconAt(index, &icon))
         menu_item->SetIcon(*icon.ToImageSkia());
     }
   }
 
   return menu_item;
@@ skipping 22 matching lines @@
   bookmark_menu_delegate_.reset(
       new BookmarkMenuDelegate(browser_,
                                browser_,
                                parent,
                                first_bookmark_command_id_));
   bookmark_menu_delegate_->Init(
       this, bookmark_menu_, model->bookmark_bar_node(), 0,
       BookmarkMenuDelegate::SHOW_PERMANENT_FOLDERS,
       bookmark_utils::LAUNCH_WRENCH_MENU);
 }