Fork a subset of ash/shelf for use in mash.

mash/shelf/shelf_button.cc

 // Copyright 2013 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 "ash/shelf/shelf_button.h"
+#include "mash/shelf/shelf_button.h"
 
 #include <algorithm>
 
-#include "ash/ash_constants.h"
-#include "ash/ash_switches.h"
-#include "ash/shelf/shelf_button_host.h"
-#include "ash/shelf/shelf_layout_manager.h"
 #include "base/time/time.h"
-#include "grit/ash_resources.h"
+#include "mash/shelf/shelf_button_host.h"
 #include "skia/ext/image_operations.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event_constants.h"
 #include "ui/gfx/animation/animation_delegate.h"
 #include "ui/gfx/animation/throb_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/vector2d.h"
@@ skipping 75 matching lines @@
   }
 
   gfx::ThrobAnimation animation_;
   base::ObserverList<Observer> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfButtonAnimation);
 };
 
 }  // namespace
 
-namespace ash {
+namespace mash {
+namespace shelf {
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfButton::BarView
 
 class ShelfButton::BarView : public views::ImageView,
                              public ShelfButtonAnimation::Observer {
  public:
   BarView(ShelfButton* host)
       : host_(host),
         show_attention_(false),
@@ skipping 52 matching lines @@
   void UpdateBounds() {
     gfx::Rect bounds = base_bounds_;
     if (show_attention_) {
       // Scale from .35 to 1.0 of the total width (which is wider than the
       // visible width of the image), so the animation "rests" briefly at full
       // visible width.  Cap bounds length at kIconSize to prevent visual
       // flutter while centering bar within further expanding bounds.
       double animation = animating_ ?
           ShelfButtonAnimation::GetInstance()->GetAnimation() : 1.0;
       double scale = .35 + .65 * animation;
-      if (host_->shelf_layout_manager()->GetAlignment() ==
-          SHELF_ALIGNMENT_BOTTOM) {
+      if (host_->host()->GetAlignment() == SHELF_ALIGNMENT_BOTTOM) {
         int width = base_bounds_.width() * scale;
         bounds.set_width(std::min(width, kIconSize));
         int x_offset = (base_bounds_.width() - bounds.width()) / 2;
         bounds.set_x(base_bounds_.x() + x_offset);
         UpdateAnimating(bounds.width() == kIconSize);
       } else {
         int height = base_bounds_.height() * scale;
         bounds.set_height(std::min(height, kIconSize));
         int y_offset = (base_bounds_.height() - bounds.height()) / 2;
         bounds.set_y(base_bounds_.y() + y_offset);
@@ skipping 33 matching lines @@
 ShelfButton::IconView::~IconView() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfButton
 
 // static
 const char ShelfButton::kViewClassName[] = "ash/ShelfButton";
 
 ShelfButton* ShelfButton::Create(views::ButtonListener* listener,
-                                 ShelfButtonHost* host,
-                                 ShelfLayoutManager* shelf_layout_manager) {
-  ShelfButton* button = new ShelfButton(listener, host, shelf_layout_manager);
+                                 ShelfButtonHost* host) {
+  ShelfButton* button = new ShelfButton(listener, host);
   button->Init();
   return button;
 }
 
 ShelfButton::ShelfButton(views::ButtonListener* listener,
-                         ShelfButtonHost* host,
-                         ShelfLayoutManager* shelf_layout_manager)
+                         ShelfButtonHost* host)
     : CustomButton(listener),
       host_(host),
       icon_view_(NULL),
       bar_(new BarView(this)),
       state_(STATE_NORMAL),
-      shelf_layout_manager_(shelf_layout_manager),
       destroyed_flag_(NULL) {
   SetAccessibilityFocusable(true);
 
   const gfx::ShadowValue kShadows[] = {
       gfx::ShadowValue(gfx::Vector2d(0, 2), 0, SkColorSetARGB(0x1A, 0, 0, 0)),
       gfx::ShadowValue(gfx::Vector2d(0, 3), 1, SkColorSetARGB(0x1A, 0, 0, 0)),
       gfx::ShadowValue(gfx::Vector2d(0, 0), 1, SkColorSetARGB(0x54, 0, 0, 0)),
   };
   icon_shadows_.assign(kShadows, kShadows + arraysize(kShadows));
 
@@ skipping 131 matching lines @@
   host_->MouseExitedButton(this);
 }
 
 void ShelfButton::GetAccessibleState(ui::AXViewState* state) {
   state->role = ui::AX_ROLE_BUTTON;
   state->name = host_->GetAccessibleName(this);
 }
 
 void ShelfButton::Layout() {
   const gfx::Rect button_bounds(GetContentsBounds());
-  int icon_pad =
-      shelf_layout_manager_->GetAlignment() != SHELF_ALIGNMENT_BOTTOM ?
+  int icon_pad = host_->GetAlignment() != SHELF_ALIGNMENT_BOTTOM ?
       kIconPadVertical : kIconPad;
-  int x_offset = shelf_layout_manager_->PrimaryAxisValue(0, icon_pad);
-  int y_offset = shelf_layout_manager_->PrimaryAxisValue(icon_pad, 0);
+  int x_offset = host_->PrimaryAxisValue(0, icon_pad);
+  int y_offset = host_->PrimaryAxisValue(icon_pad, 0);
 
   int icon_width = std::min(kIconSize,
       button_bounds.width() - x_offset);
   int icon_height = std::min(kIconSize,
       button_bounds.height() - y_offset);
 
   // If on the left or top 'invert' the inset so the constant gap is on
   // the interior (towards the center of display) edge of the shelf.
-  if (SHELF_ALIGNMENT_LEFT == shelf_layout_manager_->GetAlignment())
+  if (SHELF_ALIGNMENT_LEFT == host_->GetAlignment())
     x_offset = button_bounds.width() - (kIconSize + icon_pad);
 
-  if (SHELF_ALIGNMENT_TOP == shelf_layout_manager_->GetAlignment())
+  if (SHELF_ALIGNMENT_TOP == host_->GetAlignment())
     y_offset = button_bounds.height() - (kIconSize + icon_pad);
 
   // Center icon with respect to the secondary axis, and ensure
   // that the icon doesn't occlude the bar highlight.
-  if (shelf_layout_manager_->IsHorizontalAlignment()) {
+  if (host_->IsHorizontalAlignment()) {
     x_offset = std::max(0, button_bounds.width() - icon_width) / 2;
     if (y_offset + icon_height + kBarSize > button_bounds.height())
       icon_height = button_bounds.height() - (y_offset + kBarSize);
   } else {
     y_offset = std::max(0, button_bounds.height() - icon_height) / 2;
     if (x_offset + icon_width + kBarSize > button_bounds.width())
       icon_width = button_bounds.width() - (x_offset + kBarSize);
   }
 
   // Expand bounds to include shadows.
@@ skipping 30 matching lines @@
 void ShelfButton::OnBlur() {
   ClearState(STATE_FOCUSED);
   CustomButton::OnBlur();
 }
 
 void ShelfButton::OnPaint(gfx::Canvas* canvas) {
   CustomButton::OnPaint(canvas);
   if (HasFocus()) {
     gfx::Rect paint_bounds(GetLocalBounds());
     paint_bounds.Inset(1, 1, 1, 1);
+    const SkColor kFocusBorderColor = SkColorSetRGB(64, 128, 250);
     canvas->DrawSolidFocusRect(paint_bounds, kFocusBorderColor);
   }
 }
 
 void ShelfButton::OnGestureEvent(ui::GestureEvent* event) {
   switch (event->type()) {
     case ui::ET_GESTURE_TAP_DOWN:
       AddState(STATE_HOVERED);
       return CustomButton::OnGestureEvent(event);
     case ui::ET_GESTURE_END:
@@ skipping 26 matching lines @@
   icon_view_->SetHorizontalAlignment(views::ImageView::CENTER);
   icon_view_->SetVerticalAlignment(views::ImageView::LEADING);
 
   AddChildView(icon_view_);
 }
 
 ShelfButton::IconView* ShelfButton::CreateIconView() {
   return new IconView;
 }
 
-bool ShelfButton::IsShelfHorizontal() const {
-  return shelf_layout_manager_->IsHorizontalAlignment();
-}
-
 void ShelfButton::UpdateState() {
   UpdateBar();
 
-  icon_view_->SetHorizontalAlignment(
-      shelf_layout_manager_->PrimaryAxisValue(views::ImageView::CENTER,
-                                              views::ImageView::LEADING));
-  icon_view_->SetVerticalAlignment(
-      shelf_layout_manager_->PrimaryAxisValue(views::ImageView::LEADING,
-                                              views::ImageView::CENTER));
+  icon_view_->SetHorizontalAlignment(host_->PrimaryAxisValue(
+      views::ImageView::CENTER, views::ImageView::LEADING));
+  icon_view_->SetVerticalAlignment(host_->PrimaryAxisValue(
+      views::ImageView::LEADING, views::ImageView::CENTER));
   SchedulePaint();
 }
 
 void ShelfButton::UpdateBar() {
   if (state_ & STATE_HIDDEN) {
     bar_->SetVisible(false);
     return;
   }
 
   int bar_id = 0;
-  if (state_ & (STATE_ACTIVE))
-    bar_id = IDR_ASH_SHELF_UNDERLINE_ACTIVE;
-  else if (state_ & STATE_ATTENTION)
-    bar_id = IDR_ASH_SHELF_UNDERLINE_ATTENTION;
-  else if (state_ & STATE_RUNNING)
-    bar_id = IDR_ASH_SHELF_UNDERLINE_RUNNING;
+  // TODO(msw): Restore shelf button bar images.

[msw, 2016/01/27 07:43:41]

Standardize commenting.

+  // if (state_ & (STATE_ACTIVE))
+  //   bar_id = IDR_ASH_SHELF_UNDERLINE_ACTIVE;
+  // else if (state_ & STATE_ATTENTION)
+  //   bar_id = IDR_ASH_SHELF_UNDERLINE_ATTENTION;
+  // else if (state_ & STATE_RUNNING)
+  //   bar_id = IDR_ASH_SHELF_UNDERLINE_RUNNING;
 
   if (bar_id != 0) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     const gfx::ImageSkia* image = rb.GetImageNamed(bar_id).ToImageSkia();
-    if (shelf_layout_manager_->GetAlignment() == SHELF_ALIGNMENT_BOTTOM) {
+    if (host_->GetAlignment() == SHELF_ALIGNMENT_BOTTOM) {
       bar_->SetImage(*image);
     } else {
       bar_->SetImage(gfx::ImageSkiaOperations::CreateRotatedImage(*image,
-          shelf_layout_manager_->SelectValueForShelfAlignment(
+          host_->SelectValueForShelfAlignment(
               SkBitmapOperations::ROTATION_90_CW,
               SkBitmapOperations::ROTATION_90_CW,
               SkBitmapOperations::ROTATION_270_CW,
               SkBitmapOperations::ROTATION_180_CW)));
     }
-    bar_->SetHorizontalAlignment(
-        shelf_layout_manager_->SelectValueForShelfAlignment(
-            views::ImageView::CENTER,
-            views::ImageView::LEADING,
-            views::ImageView::TRAILING,
-            views::ImageView::CENTER));
-    bar_->SetVerticalAlignment(
-        shelf_layout_manager_->SelectValueForShelfAlignment(
-            views::ImageView::TRAILING,
-            views::ImageView::CENTER,
-            views::ImageView::CENTER,
-            views::ImageView::LEADING));
+    bar_->SetHorizontalAlignment(host_->SelectValueForShelfAlignment(
+        views::ImageView::CENTER, views::ImageView::LEADING,
+        views::ImageView::TRAILING, views::ImageView::CENTER));
+    bar_->SetVerticalAlignment(host_->SelectValueForShelfAlignment(
+        views::ImageView::TRAILING, views::ImageView::CENTER,
+        views::ImageView::CENTER, views::ImageView::LEADING));
     bar_->SchedulePaint();
   }
 
   bar_->SetVisible(bar_id != 0 && state_ != STATE_NORMAL);
 }
 
-}  // namespace ash
+}  // namespace shelf
+}  // namespace mash