Revert of Shelf Cleanup (- binary files)

ash/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 <algorithm>
 
 #include "ash/ash_constants.h"
 #include "ash/ash_switches.h"
@@ skipping 13 matching lines @@
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "ui/views/controls/image_view.h"
 
 namespace {
 
 // Size of the bar. This is along the opposite axis of the shelf. For example,
 // if the shelf is aligned horizontally then this is the height of the bar.
 const int kBarSize = 3;
 const int kIconSize = 32;
-const int kIconPad = 5;
-const int kIconPadVertical = 6;
+const int kHopSpacing = 2;
+const int kIconPad = 8;
+const int kAlternateIconPad = 5;
+const int kAlternateIconPadVertical = 6;
+const int kHopUpMS = 0;
+const int kHopDownMS = 200;
 const int kAttentionThrobDurationMS = 800;
 
+bool ShouldHop(int state) {
+  return state & ash::internal::ShelfButton::STATE_HOVERED ||
+         state & ash::internal::ShelfButton::STATE_ACTIVE ||
+         state & ash::internal::ShelfButton::STATE_FOCUSED;
+}
+
 // Simple AnimationDelegate that owns a single ThrobAnimation instance to
 // keep all Draw Attention animations in sync.
 class ShelfButtonAnimation : public gfx::AnimationDelegate {
  public:
   class Observer {
    public:
     virtual void AnimationProgressed() = 0;
 
    protected:
     virtual ~Observer() {}
@@ skipping 233 matching lines @@
   SetShadowedImage(gfx::ImageSkiaOperations::CreateResizedImage(image,
       skia::ImageOperations::RESIZE_BEST, gfx::Size(width, height)));
 }
 
 const gfx::ImageSkia& ShelfButton::GetImage() const {
   return icon_view_->GetImage();
 }
 
 void ShelfButton::AddState(State state) {
   if (!(state_ & state)) {
+    if (!ash::switches::UseAlternateShelfLayout() &&
+        (ShouldHop(state) || !ShouldHop(state_))) {
+      ui::ScopedLayerAnimationSettings scoped_setter(
+          icon_view_->layer()->GetAnimator());
+      scoped_setter.SetTransitionDuration(
+          base::TimeDelta::FromMilliseconds(kHopUpMS));
+    }
     state_ |= state;
     Layout();
     if (state & STATE_ATTENTION)
       bar_->ShowAttention(true);
   }
 }
 
 void ShelfButton::ClearState(State state) {
   if (state_ & state) {
+    if (!ash::switches::UseAlternateShelfLayout() &&
+        (!ShouldHop(state) || ShouldHop(state_))) {
+      ui::ScopedLayerAnimationSettings scoped_setter(
+          icon_view_->layer()->GetAnimator());
+      scoped_setter.SetTweenType(gfx::Tween::LINEAR);
+      scoped_setter.SetTransitionDuration(
+          base::TimeDelta::FromMilliseconds(kHopDownMS));
+    }
     state_ &= ~state;
     Layout();
     if (state & STATE_ATTENTION)
       bar_->ShowAttention(false);
   }
 }
 
 gfx::Rect ShelfButton::GetIconBounds() const {
   return icon_view_->bounds();
 }
@@ skipping 58 matching lines @@
 }
 
 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 = kIconPad;
-  icon_pad =
-      shelf_layout_manager_->GetAlignment() != SHELF_ALIGNMENT_BOTTOM ?
-      kIconPadVertical : kIconPad;
+  if (ash::switches::UseAlternateShelfLayout()) {
+      icon_pad =
+          shelf_layout_manager_->GetAlignment() != SHELF_ALIGNMENT_BOTTOM ?
+          kAlternateIconPadVertical : kAlternateIconPad;
+  }
   int x_offset = shelf_layout_manager_->PrimaryAxisValue(0, icon_pad);
   int y_offset = shelf_layout_manager_->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())
     x_offset = button_bounds.width() - (kIconSize + icon_pad);
 
   if (SHELF_ALIGNMENT_TOP == shelf_layout_manager_->GetAlignment())
     y_offset = button_bounds.height() - (kIconSize + icon_pad);
 
+  if (ShouldHop(state_) && !ash::switches::UseAlternateShelfLayout()) {
+    x_offset += shelf_layout_manager_->SelectValueForShelfAlignment(
+        0, kHopSpacing, -kHopSpacing, 0);
+    y_offset += shelf_layout_manager_->SelectValueForShelfAlignment(
+        -kHopSpacing, 0, 0, kHopSpacing);
+  }
+
   // Center icon with respect to the secondary axis, and ensure
   // that the icon doesn't occlude the bar highlight.
   if (shelf_layout_manager_->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);
@@ skipping 97 matching lines @@
   SchedulePaint();
 }
 
 void ShelfButton::UpdateBar() {
   if (state_ & STATE_HIDDEN) {
     bar_->SetVisible(false);
     return;
   }
 
   int bar_id = 0;
-  if (state_ & STATE_ACTIVE)
-    bar_id = IDR_AURA_LAUNCHER_UNDERLINE_ACTIVE;
-  else if (state_ & STATE_RUNNING)
-    bar_id = IDR_AURA_LAUNCHER_UNDERLINE_RUNNING;
+  if (ash::switches::UseAlternateShelfLayout()) {
+    if (state_ & STATE_ACTIVE)
+      bar_id = IDR_AURA_LAUNCHER_UNDERLINE_ACTIVE_ALTERNATE;
+    else if (state_ & STATE_RUNNING)
+      bar_id = IDR_AURA_LAUNCHER_UNDERLINE_RUNNING_ALTERNATE;
+  } else {
+    if (state_ & (STATE_ACTIVE | STATE_ATTENTION))
+      bar_id = IDR_AURA_LAUNCHER_UNDERLINE_ACTIVE;
+    else if (state_ & (STATE_HOVERED | STATE_FOCUSED))
+      bar_id = IDR_AURA_LAUNCHER_UNDERLINE_HOVER;
+    else
+      bar_id = IDR_AURA_LAUNCHER_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) {
       bar_->SetImage(*image);
     } else {
       bar_->SetImage(gfx::ImageSkiaOperations::CreateRotatedImage(*image,
           shelf_layout_manager_->SelectValueForShelfAlignment(
               SkBitmapOperations::ROTATION_90_CW,
@@ skipping 14 matching lines @@
             views::ImageView::CENTER,
             views::ImageView::LEADING));
     bar_->SchedulePaint();
   }
 
   bar_->SetVisible(bar_id != 0 && state_ != STATE_NORMAL);
 }
 
 }  // namespace internal
 }  // namespace ash