[Chrome OS MD] Draw a 1px separator between 2 tray items

ash/common/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/common/system/tray/tray_background_view.h"
 
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shelf/wm_shelf_util.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/system/tray/system_tray.h"
 #include "ash/common/system/tray/tray_constants.h"
 #include "ash/common/system/tray/tray_event_filter.h"
+#include "ash/common/system/view_observer.h"
 #include "ash/common/wm_lookup.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "grit/ash_resources.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/nine_image_painter_factory.h"
 #include "ui/base/ui_base_switches_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_element.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event_constants.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/nine_image_painter.h"
+#include "ui/gfx/scoped_canvas.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
 #include "ui/views/background.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/wm/core/window_animations.h"
 
 namespace {
 
 const int kAnimationDurationForPopupMs = 200;
 
@@ skipping 60 matching lines @@
         ShelfBackgroundType::SHELF_BACKGROUND_DEFAULT) {
       background_color = SkColorSetA(kShelfBaseColor,
                                      GetShelfConstant(SHELF_BACKGROUND_ALPHA));
     }
 
     // TODO(bruthig|tdanderson): The background should be changed using a
     // fade in/out animation.
     SkPaint background_paint;
     background_paint.setFlags(SkPaint::kAntiAlias_Flag);
     background_paint.setColor(background_color);
-    canvas->DrawRoundRect(view->GetLocalBounds(), kTrayRoundedBorderRadius,
+    canvas->DrawRoundRect(view->GetContentsBounds(), kTrayRoundedBorderRadius,
                           background_paint);
 
     if (tray_background_view_->draw_background_as_active()) {
       SkPaint highlight_paint;
       highlight_paint.setFlags(SkPaint::kAntiAlias_Flag);
       highlight_paint.setColor(kShelfButtonActivatedHighlightColor);
-      canvas->DrawRoundRect(view->GetLocalBounds(), kTrayRoundedBorderRadius,
+      canvas->DrawRoundRect(view->GetContentsBounds(), kTrayRoundedBorderRadius,
                             highlight_paint);
     }
   }
 
   void PaintNonMaterial(gfx::Canvas* canvas, views::View* view) const {
     const int kGridSizeForPainter = 9;
     const int kImages[kNumOrientations][kNumStates][kGridSizeForPainter] = {
         {
             // Horizontal
             IMAGE_GRID_HORIZONTAL(IDR_AURA_TRAY_BG_HORIZ),
@@ skipping 71 matching lines @@
     PreferredSizeChanged();
 }
 
 void TrayBackgroundView::TrayContainer::UpdateLayout() {
   // Adjust the size of status tray dark background by adding additional
   // empty border.
   views::BoxLayout::Orientation orientation =
       IsHorizontalAlignment(alignment_) ? views::BoxLayout::kHorizontal
                                         : views::BoxLayout::kVertical;
 
-  if (!ash::MaterialDesignController::IsShelfMaterial()) {
-    // Additional padding used to adjust the user-visible size of status tray
-    // dark background.
-    const int padding = 3;
-    SetBorder(
-        views::Border::CreateEmptyBorder(padding, padding, padding, padding));
-  }
-
   views::BoxLayout* layout = new views::BoxLayout(orientation, 0, 0, 0);
   layout->SetDefaultFlex(1);
   views::View::SetLayoutManager(layout);
   PreferredSizeChanged();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TrayBackgroundView
 
-TrayBackgroundView::TrayBackgroundView(WmShelf* wm_shelf)
+TrayBackgroundView::TrayBackgroundView(WmShelf* wm_shelf,
+                                       ViewObserver* view_observer)
     : wm_shelf_(wm_shelf),
       tray_container_(NULL),
       shelf_alignment_(SHELF_ALIGNMENT_BOTTOM),
       background_(NULL),
       draw_background_as_active_(false),
       widget_observer_(new TrayWidgetObserver(this)) {
   DCHECK(wm_shelf_);
   set_notify_enter_exit_on_child(true);
 
   tray_container_ = new TrayContainer(shelf_alignment_);
   SetContents(tray_container_);
   tray_event_filter_.reset(new TrayEventFilter);
+  view_observer_ = view_observer;
+  is_separator_visible_ = false;
 
   SetPaintToLayer(true);
   layer()->SetFillsBoundsOpaquely(false);
   // Start the tray items not visible, because visibility changes are animated.
   views::View::SetVisible(false);
+  CalculateAndSetTrayContainerBorder();
 }
 
 TrayBackgroundView::~TrayBackgroundView() {
   if (GetWidget())
     GetWidget()->RemoveObserver(widget_observer_.get());
   StopObservingImplicitAnimations();
 }
 
 void TrayBackgroundView::Initialize() {
   GetWidget()->AddObserver(widget_observer_.get());
 }
 
 // static
 void TrayBackgroundView::InitializeBubbleAnimations(
     views::Widget* bubble_widget) {
   WmWindow* window = WmLookup::Get()->GetWindowForWidget(bubble_widget);
   window->SetVisibilityAnimationType(
       ::wm::WINDOW_VISIBILITY_ANIMATION_TYPE_FADE);
   window->SetVisibilityAnimationTransition(::wm::ANIMATE_HIDE);
   window->SetVisibilityAnimationDuration(
       base::TimeDelta::FromMilliseconds(kAnimationDurationForPopupMs));
 }
 
 void TrayBackgroundView::SetVisible(bool visible) {
   if (visible == layer()->GetTargetVisibility())
     return;
+  // OnVisibilityChange will only be called if the visibility of the tray item
+  // is changed.
+  view_observer_->OnVisibilityChange(this);
 
   if (visible) {
     // The alignment of the shelf can change while the TrayBackgroundView is
     // hidden. Reset the offscreen transform so that the animation to becoming
     // visible reflects the current layout.
     HideTransformation();
     // SetVisible(false) is defered until the animation for hiding is done.
     // Otherwise the view is immediately hidden and the animation does not
     // render.
     views::View::SetVisible(true);
@@ skipping 88 matching lines @@
   SetLayoutManager(new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 0));
   AddChildView(contents);
 }
 void TrayBackgroundView::SetContentsBackground() {
   background_ = new TrayBackground(this);
   tray_container_->set_background(background_);
 }
 
 void TrayBackgroundView::SetShelfAlignment(ShelfAlignment alignment) {
   shelf_alignment_ = alignment;
+  CalculateAndSetTrayContainerBorder();
   tray_container_->SetAlignment(alignment);
 }
 
+void TrayBackgroundView::CalculateAndSetTrayContainerBorder() {
+  if (!MaterialDesignController::IsShelfMaterial()) {
+    tray_container()->SetBorder(views::Border::NullBorder());
+    return;
+  }
+  if (IsHorizontalAlignment(shelf()->GetAlignment())) {
+    // Extend hit region horizontally when horizontally aligned.
+    tray_container()->SetBorder(views::Border::CreateEmptyBorder(gfx::Insets(
+        0, kHitRegionPadding, 0, kHitRegionPadding + kSeparatorWidth)));
+  } else {
+    // Extend hit region vertically when vertically aligned.
+    tray_container()->SetBorder(views::Border::CreateEmptyBorder(gfx::Insets(
+        kHitRegionPadding, 0, kHitRegionPadding + kSeparatorWidth, 0)));
+  }
+}
+
 void TrayBackgroundView::OnImplicitAnimationsCompleted() {
   // If there is another animation in the queue, the reverse animation was
   // triggered before the completion of animating to invisible. Do not turn off
   // the visibility so that the next animation may render. The value of
   // layer()->GetTargetVisibility() can be incorrect if the hide animation was
   // aborted to schedule an animation to become visible. As the new animation
   // is not yet added to the queue. crbug.com/374236
   if (layer()->GetAnimator()->is_animating() || layer()->GetTargetVisibility())
     return;
   views::View::SetVisible(false);
@@ skipping 110 matching lines @@
   if (!background_)
     return;
   SchedulePaint();
 }
 
 void TrayBackgroundView::UpdateBubbleViewArrow(
     views::TrayBubbleView* bubble_view) {
   // Nothing to do here.
 }
 
+void TrayBackgroundView::SetSeparatorVisibility(bool is_show) {
+  if (is_separator_visible_ != is_show)
+    is_separator_visible_ = is_show;
+}
+
+void TrayBackgroundView::OnPaint(gfx::Canvas* canvas) {
+  if (!MaterialDesignController::IsShelfMaterial() ||
+      shelf()->GetBackgroundType() ==
+          ShelfBackgroundType::SHELF_BACKGROUND_DEFAULT)
+    return;
+
+  if (is_separator_visible_) {
+    const int height = GetTrayConstant(TRAY_ITEM_HEIGHT_LEGACY);
+    const int width = kSeparatorWidth;
+    const int x = height + kHitRegionPadding + kHitRegionPadding;
+    const int y = (GetShelfConstant(SHELF_SIZE) - height) / 2;
+    const float scale = canvas->UndoDeviceScaleFactor();
+    SkPaint paint;
+    paint.setColor(kSeparatorColor);
+    paint.setAntiAlias(true);
+    const bool horizontal_shelf =
+        IsHorizontalAlignment(shelf()->GetAlignment());
+    const gfx::Rect bounds = horizontal_shelf ? gfx::Rect(x, y, width, height)
+                                              : gfx::Rect(y, x, height, width);
+    gfx::ScopedCanvas scoped_canvas(canvas);
+    gfx::RectF rect(gfx::ScaleRect(gfx::RectF(bounds), scale));
+    canvas->DrawLine(horizontal_shelf ? rect.top_right() : rect.bottom_left(),
+                     rect.bottom_right(), paint);
+  }
+}
+
 }  // namespace ash