Revert of Shelf Cleanup (- binary files)

ash/system/tray/tray_background_view.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 "ash/system/tray/tray_background_view.h"
 
 #include "ash/ash_switches.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shelf/shelf_layout_manager.h"
@@ skipping 19 matching lines @@
 #include "ui/gfx/skia_util.h"
 #include "ui/views/background.h"
 #include "ui/views/layout/box_layout.h"
 
 namespace {
 
 const int kTrayBackgroundAlpha = 100;
 const int kTrayBackgroundHoverAlpha = 150;
 const SkColor kTrayBackgroundPressedColor = SkColorSetRGB(66, 129, 244);
 
+// Adjust the size of TrayContainer with additional padding.
+const int kTrayContainerVerticalPaddingBottomAlignment  = 1;
+const int kTrayContainerHorizontalPaddingBottomAlignment  = 1;
+const int kTrayContainerVerticalPaddingVerticalAlignment  = 1;
+const int kTrayContainerHorizontalPaddingVerticalAlignment = 1;
+
 const int kAnimationDurationForPopupMS = 200;
 
 }  // namespace
 
 using views::TrayBubbleView;
 
 namespace ash {
 namespace internal {
 
 // static
@@ skipping 91 matching lines @@
   SkColor color() { return color_; }
   void set_color(SkColor color) { color_ = color; }
   void set_alpha(int alpha) { color_ = SkColorSetARGB(alpha, 0, 0, 0); }
 
  private:
   ShelfWidget* GetShelfWidget() const {
     return RootWindowController::ForWindow(tray_background_view_->
         status_area_widget()->GetNativeWindow())->shelf();
   }
 
-  // Overridden from views::Background.
-  virtual void Paint(gfx::Canvas* canvas, views::View* view) const OVERRIDE {
+  void PaintForAlternateShelf(gfx::Canvas* canvas, views::View* view) const {
     int orientation = kImageHorizontal;
     ShelfWidget* shelf_widget = GetShelfWidget();
     if (shelf_widget &&
         !shelf_widget->shelf_layout_manager()->IsHorizontalAlignment())
       orientation = kImageVertical;
 
     int state = kImageTypeDefault;
     if (tray_background_view_->draw_background_as_active())
       state = kImageTypePressed;
     else if (shelf_widget && shelf_widget->GetDimsShelf())
@@ skipping 35 matching lines @@
                          trailing_location.x(),
                          trailing_location.y());
 
     canvas->TileImageInt(*middle,
                          middle_bounds.x(),
                          middle_bounds.y(),
                          middle_bounds.width(),
                          middle_bounds.height());
   }
 
+  // Overridden from views::Background.
+  virtual void Paint(gfx::Canvas* canvas, views::View* view) const OVERRIDE {
+    if (ash::switches::UseAlternateShelfLayout()) {
+      PaintForAlternateShelf(canvas, view);
+    } else {
+      SkPaint paint;
+      paint.setAntiAlias(true);
+      paint.setStyle(SkPaint::kFill_Style);
+      paint.setColor(color_);
+      SkPath path;
+      gfx::Rect bounds(view->GetLocalBounds());
+      SkScalar radius = SkIntToScalar(kTrayRoundedBorderRadius);
+      path.addRoundRect(gfx::RectToSkRect(bounds), radius, radius);
+      canvas->DrawPath(path, paint);
+    }
+  }
+
   SkColor color_;
   // Reference to the TrayBackgroundView for which this is a background.
   TrayBackgroundView* tray_background_view_;
 
   // References to the images used as backgrounds, they are owned by the
   // resource bundle class.
   const gfx::ImageSkia* leading_images_[kNumOrientations][kNumStates];
   const gfx::ImageSkia* middle_images_[kNumOrientations][kNumStates];
   const gfx::ImageSkia* trailing_images_[kNumOrientations][kNumStates];
 
@@ skipping 31 matching lines @@
     const ViewHierarchyChangedDetails& details) {
   if (details.parent == this)
     PreferredSizeChanged();
 }
 
 void TrayBackgroundView::TrayContainer::UpdateLayout() {
   // Adjust the size of status tray dark background by adding additional
   // empty border.
   if (alignment_ == SHELF_ALIGNMENT_BOTTOM ||
       alignment_ == SHELF_ALIGNMENT_TOP) {
-    SetBorder(views::Border::CreateEmptyBorder(
-        kPaddingFromEdgeOfShelf,
-        kPaddingFromEdgeOfShelf,
-        kPaddingFromEdgeOfShelf,
-        kPaddingFromEdgeOfShelf));
+    int vertical_padding = kTrayContainerVerticalPaddingBottomAlignment;
+    int horizontal_padding = kTrayContainerHorizontalPaddingBottomAlignment;
+    if (ash::switches::UseAlternateShelfLayout()) {
+      vertical_padding = kPaddingFromEdgeOfShelf;
+      horizontal_padding = kPaddingFromEdgeOfShelf;
+    }
+    SetBorder(views::Border::CreateEmptyBorder(vertical_padding,
+                                               horizontal_padding,
+                                               vertical_padding,
+                                               horizontal_padding));
 
     views::BoxLayout* layout =
         new views::BoxLayout(views::BoxLayout::kHorizontal, 0, 0, 0);
     layout->set_spread_blank_space(true);
     views::View::SetLayoutManager(layout);
   } else {
-    SetBorder(views::Border::CreateEmptyBorder(
-        kPaddingFromEdgeOfShelf,
-        kPaddingFromEdgeOfShelf,
-        kPaddingFromEdgeOfShelf,
-        kPaddingFromEdgeOfShelf));
+    int vertical_padding = kTrayContainerVerticalPaddingVerticalAlignment;
+    int horizontal_padding = kTrayContainerHorizontalPaddingVerticalAlignment;
+    if (ash::switches::UseAlternateShelfLayout()) {
+      vertical_padding = kPaddingFromEdgeOfShelf;
+      horizontal_padding = kPaddingFromEdgeOfShelf;
+    }
+    SetBorder(views::Border::CreateEmptyBorder(vertical_padding,
+                                               horizontal_padding,
+                                               vertical_padding,
+                                               horizontal_padding));
 
     views::BoxLayout* layout =
         new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 0);
     layout->set_spread_blank_space(true);
     views::View::SetLayoutManager(layout);
   }
   PreferredSizeChanged();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 33 matching lines @@
   GetWidget()->AddObserver(widget_observer_.get());
   SetTrayBorder();
 }
 
 const char* TrayBackgroundView::GetClassName() const {
   return kViewClassName;
 }
 
 void TrayBackgroundView::OnMouseEntered(const ui::MouseEvent& event) {
   hovered_ = true;
+  if (!background_ || draw_background_as_active_ ||
+      ash::switches::UseAlternateShelfLayout())
+    return;
+  hover_background_animator_.SetPaintsBackground(
+      true, BACKGROUND_CHANGE_ANIMATE);
 }
 
 void TrayBackgroundView::OnMouseExited(const ui::MouseEvent& event) {
   hovered_ = false;
+  if (!background_ || draw_background_as_active_ ||
+      ash::switches::UseAlternateShelfLayout())
+    return;
+  hover_background_animator_.SetPaintsBackground(
+      false, BACKGROUND_CHANGE_ANIMATE);
 }
 
 void TrayBackgroundView::ChildPreferredSizeChanged(views::View* child) {
   PreferredSizeChanged();
 }
 
 void TrayBackgroundView::GetAccessibleState(ui::AXViewState* state) {
   state->role = ui::AX_ROLE_BUTTON;
   state->name = GetAccessibleNameForTray();
 }
@@ skipping 13 matching lines @@
   // The tray itself expands to the right and bottom edge of the screen to make
   // sure clicking on the edges brings up the popup. However, the focus border
   // should be only around the container.
   return GetContentsBounds();
 }
 
 void TrayBackgroundView::UpdateBackground(int alpha) {
   // The animator should never fire when the alternate shelf layout is used.
   if (!background_ || draw_background_as_active_)
     return;
+  DCHECK(!ash::switches::UseAlternateShelfLayout());
   background_->set_alpha(hide_background_animator_.alpha() +
                          hover_background_animator_.alpha());
   SchedulePaint();
 }
 
 void TrayBackgroundView::SetContents(views::View* contents) {
   SetLayoutManager(new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 0));
   AddChildView(contents);
 }
 
 void TrayBackgroundView::SetPaintsBackground(
     bool value, BackgroundAnimatorChangeType change_type) {
+  DCHECK(!ash::switches::UseAlternateShelfLayout());
   hide_background_animator_.SetPaintsBackground(value, change_type);
 }
 
 void TrayBackgroundView::SetContentsBackground() {
   background_ = new internal::TrayBackground(this);
   tray_container_->set_background(background_);
 }
 
 ShelfLayoutManager* TrayBackgroundView::GetShelfLayoutManager() {
   return ShelfLayoutManager::ForShelf(GetWidget()->GetNativeView());
 }
 
 void TrayBackgroundView::SetShelfAlignment(ShelfAlignment alignment) {
   shelf_alignment_ = alignment;
   SetTrayBorder();
   tray_container_->SetAlignment(alignment);
 }
 
 void TrayBackgroundView::SetTrayBorder() {
   views::View* parent = status_area_widget_->status_area_widget_delegate();
   // Tray views are laid out right-to-left or bottom-to-top
   bool on_edge = (this == parent->child_at(0));
   int left_edge, top_edge, right_edge, bottom_edge;
-  if (shelf_alignment() == SHELF_ALIGNMENT_BOTTOM) {
-    top_edge = ShelfLayoutManager::kShelfItemInset;
-    left_edge = 0;
-    bottom_edge = kShelfSize -
-        ShelfLayoutManager::kShelfItemInset - ash::kShelfItemHeight;
-    right_edge = on_edge ? kPaddingFromEdgeOfShelf : 0;
-  } else if (shelf_alignment() == SHELF_ALIGNMENT_LEFT) {
-    top_edge = 0;
-    left_edge = kShelfSize -
-        ShelfLayoutManager::kShelfItemInset - ash::kShelfItemHeight;
-    bottom_edge = on_edge ? kPaddingFromEdgeOfShelf : 0;
-    right_edge = ShelfLayoutManager::kShelfItemInset;
-  } else { // SHELF_ALIGNMENT_RIGHT
-    top_edge = 0;
-    left_edge = ShelfLayoutManager::kShelfItemInset;
-    bottom_edge = on_edge ? kPaddingFromEdgeOfShelf : 0;
-    right_edge = kShelfSize -
-        ShelfLayoutManager::kShelfItemInset - ash::kShelfItemHeight;
+  if (ash::switches::UseAlternateShelfLayout()) {
+    if (shelf_alignment() == SHELF_ALIGNMENT_BOTTOM) {
+      top_edge = ShelfLayoutManager::kShelfItemInset;
+      left_edge = 0;
+      bottom_edge = ShelfLayoutManager::GetPreferredShelfSize() -
+          ShelfLayoutManager::kShelfItemInset - GetShelfItemHeight();
+      right_edge = on_edge ? kPaddingFromEdgeOfShelf : 0;
+    } else if (shelf_alignment() == SHELF_ALIGNMENT_LEFT) {
+      top_edge = 0;
+      left_edge = ShelfLayoutManager::GetPreferredShelfSize() -
+          ShelfLayoutManager::kShelfItemInset - GetShelfItemHeight();
+      bottom_edge = on_edge ? kPaddingFromEdgeOfShelf : 0;
+      right_edge = ShelfLayoutManager::kShelfItemInset;
+    } else { // SHELF_ALIGNMENT_RIGHT
+      top_edge = 0;
+      left_edge = ShelfLayoutManager::kShelfItemInset;
+      bottom_edge = on_edge ? kPaddingFromEdgeOfShelf : 0;
+      right_edge = ShelfLayoutManager::GetPreferredShelfSize() -
+          ShelfLayoutManager::kShelfItemInset - GetShelfItemHeight();
+    }
+  } else {
+    // Change the border padding for different shelf alignment.
+    if (shelf_alignment() == SHELF_ALIGNMENT_BOTTOM) {
+      top_edge = 0;
+      left_edge = 0;
+      bottom_edge = on_edge ? kPaddingFromBottomOfScreenBottomAlignment :
+          kPaddingFromBottomOfScreenBottomAlignment - 1;
+      right_edge = on_edge ? kPaddingFromRightEdgeOfScreenBottomAlignment : 0;
+    } else if (shelf_alignment() == SHELF_ALIGNMENT_TOP) {
+      top_edge = on_edge ? kPaddingFromBottomOfScreenBottomAlignment :
+          kPaddingFromBottomOfScreenBottomAlignment - 1;
+      left_edge = 0;
+      bottom_edge = 0;
+      right_edge = on_edge ? kPaddingFromRightEdgeOfScreenBottomAlignment : 0;
+    } else if (shelf_alignment() == SHELF_ALIGNMENT_LEFT) {
+      top_edge = 0;
+      left_edge = kPaddingFromOuterEdgeOfLauncherVerticalAlignment;
+      bottom_edge = on_edge ? kPaddingFromBottomOfScreenVerticalAlignment : 0;
+      right_edge = kPaddingFromInnerEdgeOfLauncherVerticalAlignment;
+    } else {
+      top_edge = 0;
+      left_edge = kPaddingFromInnerEdgeOfLauncherVerticalAlignment;
+      bottom_edge = on_edge ? kPaddingFromBottomOfScreenVerticalAlignment : 0;
+      right_edge = kPaddingFromOuterEdgeOfLauncherVerticalAlignment;
+    }
   }
   SetBorder(views::Border::CreateEmptyBorder(
       top_edge, left_edge, bottom_edge, right_edge));
 }
 
 void TrayBackgroundView::InitializeBubbleAnimations(
     views::Widget* bubble_widget) {
   views::corewm::SetWindowVisibilityAnimationType(
       bubble_widget->GetNativeWindow(),
       views::corewm::WINDOW_VISIBILITY_ANIMATION_TYPE_FADE);
@@ skipping 14 matching lines @@
 gfx::Rect TrayBackgroundView::GetBubbleAnchorRect(
     views::Widget* anchor_widget,
     TrayBubbleView::AnchorType anchor_type,
     TrayBubbleView::AnchorAlignment anchor_alignment) const {
   gfx::Rect rect;
   if (anchor_widget && anchor_widget->IsVisible()) {
     rect = anchor_widget->GetWindowBoundsInScreen();
     if (anchor_type == TrayBubbleView::ANCHOR_TYPE_TRAY) {
       if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_BOTTOM) {
         bool rtl = base::i18n::IsRTL();
-        rect.Inset(
-            rtl ? kBubblePaddingHorizontalSide : 0,
-            kBubblePaddingHorizontalBottom,
-            rtl ? 0 : kBubblePaddingHorizontalSide,
-            0);
+        if (!ash::switches::UseAlternateShelfLayout()) {
+          rect.Inset(
+              rtl ? kPaddingFromRightEdgeOfScreenBottomAlignment : 0,
+              kTrayBubbleAnchorTopInsetBottomAnchor,
+              rtl ? 0 : kPaddingFromRightEdgeOfScreenBottomAlignment,
+              kPaddingFromBottomOfScreenBottomAlignment);
+        } else {
+          rect.Inset(
+              rtl ? kAlternateLayoutBubblePaddingHorizontalSide : 0,
+              kAlternateLayoutBubblePaddingHorizontalBottom,
+              rtl ? 0 : kAlternateLayoutBubblePaddingHorizontalSide,
+              0);
+        }
       } else if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_LEFT) {
-        rect.Inset(0, 0, kBubblePaddingVerticalSide + 4,
-                   kBubblePaddingVerticalBottom);
+        if (!ash::switches::UseAlternateShelfLayout()) {
+          rect.Inset(0, 0, kPaddingFromInnerEdgeOfLauncherVerticalAlignment + 5,
+                     kPaddingFromBottomOfScreenVerticalAlignment);
+        } else {
+          rect.Inset(0, 0, kAlternateLayoutBubblePaddingVerticalSide + 4,
+                     kAlternateLayoutBubblePaddingVerticalBottom);
+        }
       } else {
-        rect.Inset(kBubblePaddingVerticalSide, 0, 0,
-                   kBubblePaddingVerticalBottom);
+        if (!ash::switches::UseAlternateShelfLayout()) {
+          rect.Inset(kPaddingFromInnerEdgeOfLauncherVerticalAlignment + 1,
+                     0, 0, kPaddingFromBottomOfScreenVerticalAlignment);
+        } else {
+          rect.Inset(kAlternateLayoutBubblePaddingVerticalSide, 0, 0,
+                     kAlternateLayoutBubblePaddingVerticalBottom);
+        }
       }
     } else if (anchor_type == TrayBubbleView::ANCHOR_TYPE_BUBBLE) {
       // Invert the offsets to align with the bubble below.
-      int vertical_alignment = 0;
-      int horizontal_alignment = kBubblePaddingVerticalBottom;
+      // Note that with the alternate shelf layout the tips are not shown and
+      // the offsets for left and right alignment do not need to be applied.
+      int vertical_alignment = ash::switches::UseAlternateShelfLayout() ?
+          0 :
+          kPaddingFromInnerEdgeOfLauncherVerticalAlignment;
+      int horizontal_alignment = ash::switches::UseAlternateShelfLayout() ?
+          kAlternateLayoutBubblePaddingVerticalBottom :
+          kPaddingFromBottomOfScreenVerticalAlignment;
       if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_LEFT)
         rect.Inset(vertical_alignment, 0, 0, horizontal_alignment);
       else if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_RIGHT)
         rect.Inset(0, 0, vertical_alignment, horizontal_alignment);
     }
   }
 
   // TODO(jennyz): May need to add left/right alignment in the following code.
   if (rect.IsEmpty()) {
     aura::Window* target_root = anchor_widget ?
@@ skipping 20 matching lines @@
       return TrayBubbleView::ANCHOR_ALIGNMENT_RIGHT;
     case SHELF_ALIGNMENT_TOP:
       return TrayBubbleView::ANCHOR_ALIGNMENT_TOP;
   }
   NOTREACHED();
   return TrayBubbleView::ANCHOR_ALIGNMENT_BOTTOM;
 }
 
 void TrayBackgroundView::SetDrawBackgroundAsActive(bool visible) {
   draw_background_as_active_ = visible;
-  if (!background_)
+  if (!background_ || !switches::UseAlternateShelfLayout())
     return;
 
   // Do not change gradually, changing color between grey and blue is weird.
   if (draw_background_as_active_)
     background_->set_color(kTrayBackgroundPressedColor);
   else if (hovered_)
     background_->set_alpha(kTrayBackgroundHoverAlpha);
   else
     background_->set_alpha(kTrayBackgroundAlpha);
   SchedulePaint();
 }
 
 void TrayBackgroundView::UpdateBubbleViewArrow(
     views::TrayBubbleView* bubble_view) {
+  if (switches::UseAlternateShelfLayout())
+    return;
+
+  aura::Window* root_window =
+      bubble_view->GetWidget()->GetNativeView()->GetRootWindow();
+  ash::internal::ShelfLayoutManager* shelf =
+      ShelfLayoutManager::ForShelf(root_window);
+  bubble_view->SetArrowPaintType(
+      (shelf && shelf->IsVisible()) ?
+      views::BubbleBorder::PAINT_NORMAL :
+      views::BubbleBorder::PAINT_TRANSPARENT);
 }
 
 }  // namespace internal
 }  // namespace ash