Adjust positioning of cros tray bubbles.

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"
@@ skipping 227 matching lines @@
   views::BoxLayout::Orientation orientation =
       is_horizontal ? views::BoxLayout::kHorizontal
                     : views::BoxLayout::kVertical;
   const gfx::Insets insets(
       ash::MaterialDesignController::IsShelfMaterial()
           ? is_horizontal ? gfx::Insets(0, kHitRegionPadding, 0,
                                         kHitRegionPadding + kSeparatorWidth)
                           : gfx::Insets(kHitRegionPadding, 0,
                                         kHitRegionPadding + kSeparatorWidth, 0)
           : gfx::Insets(kBackgroundAdjustPadding));
-  const gfx::Insets margin(
-      is_horizontal ? gfx::Insets(cross_axis_margin_, main_axis_margin_)
-                    : gfx::Insets(main_axis_margin_, cross_axis_margin_));
-  SetBorder(views::CreateEmptyBorder(insets + margin));
+  SetBorder(views::CreateEmptyBorder(insets));
 
-  views::BoxLayout* layout = new views::BoxLayout(orientation, 0, 0, 0);
+  int horizontal_margin = main_axis_margin_;
+  int vertical_margin = cross_axis_margin_;
+  if (!is_horizontal)
+    std::swap(horizontal_margin, vertical_margin);
+  views::BoxLayout* layout =
+      new views::BoxLayout(orientation, horizontal_margin, vertical_margin, 0);
+
   if (!ash::MaterialDesignController::IsShelfMaterial())
     layout->SetDefaultFlex(1);
   layout->set_minimum_cross_axis_size(kTrayItemSize);
   views::View::SetLayoutManager(layout);
 
   PreferredSizeChanged();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TrayBackgroundView
@@ skipping 145 matching lines @@
       SetIsActive(false);
     }
   }
   ActionableView::OnGestureEvent(event);
 }
 
 void TrayBackgroundView::SetContents(views::View* contents) {
   SetLayoutManager(new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 0));
   AddChildView(contents);
 }
+
 void TrayBackgroundView::SetContentsBackground(bool draws_active) {
   background_ = new TrayBackground(this, draws_active);
   tray_container_->set_background(background_);
 }
 
 void TrayBackgroundView::SetShelfAlignment(ShelfAlignment alignment) {
   shelf_alignment_ = alignment;
   tray_container_->SetAlignment(alignment);
 }
 
@@ skipping 20 matching lines @@
 
 void TrayBackgroundView::HideTransformation() {
   gfx::Transform transform;
   if (IsHorizontalAlignment(shelf_alignment_))
     transform.Translate(width(), 0.0f);
   else
     transform.Translate(0.0f, height());
   layer()->SetTransform(transform);
 }
 
-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);
-      } else if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_LEFT) {
-        rect.Inset(0, 0, kBubblePaddingVerticalSide + 4,
-                   kBubblePaddingVerticalBottom);
-      } else if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_RIGHT) {
-        rect.Inset(kBubblePaddingVerticalSide, 0, 0,
-                   kBubblePaddingVerticalBottom);
-      } else {
-        // TODO(bruthig) May need to handle other ANCHOR_ALIGNMENT_ values.
-        // ie. ANCHOR_ALIGNMENT_TOP
-        DCHECK(false) << "Unhandled anchor alignment.";
-      }
-    } else if (anchor_type == TrayBubbleView::ANCHOR_TYPE_BUBBLE) {
-      // Invert the offsets to align with the bubble below.
-      // 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 = 0;
-      int horizontal_alignment = kBubblePaddingVerticalBottom;
-      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);
-    } else {
-      DCHECK(false) << "Unhandled anchor type.";
-    }
-  } else {
-    WmWindow* target_root = anchor_widget
-                                ? WmLookup::Get()
-                                      ->GetWindowForWidget(anchor_widget)
-                                      ->GetRootWindow()
-                                : WmShell::Get()->GetPrimaryRootWindow();
-    rect = target_root->GetBounds();
-    if (anchor_type == TrayBubbleView::ANCHOR_TYPE_TRAY) {
-      if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_BOTTOM) {
-        rect = gfx::Rect(
-            base::i18n::IsRTL()
-                ? kPaddingFromRightEdgeOfScreenBottomAlignment
-                : rect.width() - kPaddingFromRightEdgeOfScreenBottomAlignment,
-            rect.height() - kPaddingFromBottomOfScreenBottomAlignment, 0, 0);
-        rect = target_root->ConvertRectToScreen(rect);
-      } else if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_LEFT) {
-        rect = gfx::Rect(
-            kPaddingFromRightEdgeOfScreenBottomAlignment,
-            rect.height() - kPaddingFromBottomOfScreenBottomAlignment, 1, 1);
-        rect = target_root->ConvertRectToScreen(rect);
-      } else if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_RIGHT) {
-        rect = gfx::Rect(
-            rect.width() - kPaddingFromRightEdgeOfScreenBottomAlignment,
-            rect.height() - kPaddingFromBottomOfScreenBottomAlignment, 1, 1);
-        rect = target_root->ConvertRectToScreen(rect);
-      } else {
-        // TODO(bruthig) May need to handle other ANCHOR_ALIGNMENT_ values.
-        // ie. ANCHOR_ALIGNMENT_TOP
-        DCHECK(false) << "Unhandled anchor alignment.";
-      }
-    } else {
-      rect = gfx::Rect(
-          base::i18n::IsRTL()
-              ? kPaddingFromRightEdgeOfScreenBottomAlignment
-              : rect.width() - kPaddingFromRightEdgeOfScreenBottomAlignment,
-          rect.height() - kPaddingFromBottomOfScreenBottomAlignment, 0, 0);
-    }
-  }
-  return rect;
-}
-
 TrayBubbleView::AnchorAlignment TrayBackgroundView::GetAnchorAlignment() const {
   if (shelf_alignment_ == SHELF_ALIGNMENT_LEFT)
     return TrayBubbleView::ANCHOR_ALIGNMENT_LEFT;
   if (shelf_alignment_ == SHELF_ALIGNMENT_RIGHT)
     return TrayBubbleView::ANCHOR_ALIGNMENT_RIGHT;
   return TrayBubbleView::ANCHOR_ALIGNMENT_BOTTOM;
 }
 
 void TrayBackgroundView::SetIsActive(bool is_active) {
   if (is_active_ == is_active)
@@ skipping 19 matching lines @@
     background_->set_alpha(alpha);
     SchedulePaint();
   }
 }
 
 void TrayBackgroundView::SetSeparatorVisibility(bool is_shown) {
   is_separator_visible_ = is_shown;
   SchedulePaint();
 }
 
+views::View* TrayBackgroundView::GetBubbleAnchor() const {
+  return tray_container_;
+}
+
+gfx::Insets TrayBackgroundView::GetBubbleAnchorInsets() const {
+  gfx::Insets anchor_insets = GetBubbleAnchor()->GetInsets();
+  gfx::Insets tray_bg_insets = GetInsets();
+  // TODO(estade): for reasons I don't understand, BubbleBorder distances the
+  // bubble by the arrow's "interior" thickness even when the paint type is
+  // PAINT_NONE.
+  const int kBigShadowArrowInteriorThickness = 9;
+  if (GetAnchorAlignment() == TrayBubbleView::ANCHOR_ALIGNMENT_BOTTOM) {
+    return gfx::Insets(kBigShadowArrowInteriorThickness - tray_bg_insets.top(),
+                       anchor_insets.left(), -tray_bg_insets.bottom(),
+                       anchor_insets.right());
+  } else {
+    return gfx::Insets(
+        anchor_insets.top(),
+        kBigShadowArrowInteriorThickness - tray_bg_insets.left(),
+        anchor_insets.bottom(),
+        kBigShadowArrowInteriorThickness - tray_bg_insets.right());
+  }
+}
+
 std::unique_ptr<views::InkDropMask> TrayBackgroundView::CreateInkDropMask()
     const {
   return base::MakeUnique<views::RoundRectInkDropMask>(
       GetLocalBounds(),
       GetBackgroundBounds(GetContentsBounds(), shelf_alignment_),
       kTrayRoundedBorderRadius);
 }
 
 bool TrayBackgroundView::ShouldEnterPushedState(const ui::Event& event) {
   if (is_active_)
@@ skipping 46 matching lines @@
   paint.setAntiAlias(true);
 
   const gfx::Rect bounds = horizontal_shelf ? gfx::Rect(x, y, width, height)
                                             : gfx::Rect(y, x, height, width);
   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