Add left/right layout support for uber tray.

ash/system/tray/system_tray_bubble.cc

+

[sadrul, 2012/05/17 19:57:05]

- this line

[jennyz, 2012/05/17 22:13:30]

Done.

 // 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/system_tray_bubble.h"
 
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/tray/system_tray.h"
 #include "ash/system/tray/system_tray_delegate.h"
@@ skipping 16 matching lines @@
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/view.h"
 
 namespace ash {
 
 namespace {
 
 const int kShadowThickness = 4;
 
-const int kLeftPadding = 4;
 const int kBottomLineHeight = 1;
 
+const int kSystemTrayBubbleHorizontalInset = 1;
+const int kSystemTrayBubbleVerticalInset = 1;
+
 const int kArrowHeight = 10;
 const int kArrowWidth = 20;
 const int kArrowPaddingFromRight = 20;
+const int kArrowPaddingFromBottom = 17;
 
 const int kAnimationDurationForPopupMS = 200;
 
 const SkColor kShadowColor = SkColorSetARGB(0xff, 0, 0, 0);
 
 void DrawBlurredShadowAroundView(gfx::Canvas* canvas,
                                  int top,
                                  int bottom,
                                  int width,
                                  const gfx::Insets& inset) {
@@ skipping 68 matching lines @@
       canvas->FillRect(gfx::Rect(size()),
           hover_ ? kHoverBackgroundColor : kBackgroundColor);
     }
   }
 
   bool hover_;
 
   DISALLOW_COPY_AND_ASSIGN(TrayPopupItemContainer);
 };
 
-class SystemTrayBubbleBackground : public views::Background {

[sadrul, 2012/05/17 19:57:05]

Oooh. It was on my TODO to remove SystemTrayBubbleBackground. Thanks!

+class SystemTrayBubbleBorder : public views::BubbleBorder {
  public:
-  explicit SystemTrayBubbleBackground(views::View* owner)
-      : owner_(owner) {
+  SystemTrayBubbleBorder(views::View* owner,
+                         views::BubbleBorder::ArrowLocation arrow_location)
+      : views::BubbleBorder(arrow_location,
+                            views::BubbleBorder::NO_SHADOW),
+        owner_(owner) {
+    set_alignment(views::BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
   }
 
-  virtual ~SystemTrayBubbleBackground() {}
+  virtual ~SystemTrayBubbleBorder() {}
 
  private:
-  // Overridden from views::Background.
-  virtual void Paint(gfx::Canvas* canvas, views::View* view) const OVERRIDE {
+  virtual void PaintChildBorder(gfx::Canvas* canvas) const {

[sadrul, 2012/05/17 19:57:05]

This doesn't need to be virtual, right?

[jennyz, 2012/05/17 22:13:30]

Done.

+    gfx::Insets insets;
+    GetInsets(&insets);
+    canvas->Save();
+    canvas->Translate(gfx::Point(insets.left(), insets.top()));
     views::View* last_view = NULL;
     for (int i = 0; i < owner_->child_count(); i++) {
       views::View* v = owner_->child_at(i);
+      if (!v->visible())
+        continue;
 
       if (!v->border()) {
         canvas->DrawLine(gfx::Point(v->x(), v->y() - 1),
             gfx::Point(v->x() + v->width(), v->y() - 1),
             !last_view || last_view->border() ? kBorderDarkColor :
                                                 kBorderLightColor);
       } else if (last_view && !last_view->border()) {
         canvas->DrawLine(gfx::Point(v->x() - 1, v->y() - 1),
             gfx::Point(v->x() + v->width() + 1, v->y() - 1),
             kBorderDarkColor);
       }
 
       canvas->DrawLine(gfx::Point(v->x() - 1, v->y() - 1),
           gfx::Point(v->x() - 1, v->y() + v->height() + 1),
           kBorderDarkColor);
       canvas->DrawLine(gfx::Point(v->x() + v->width(), v->y() - 1),
           gfx::Point(v->x() + v->width(), v->y() + v->height() + 1),
           kBorderDarkColor);
       last_view = v;
     }
+    canvas->Restore();
   }
 
-  views::View* owner_;
-
-  DISALLOW_COPY_AND_ASSIGN(SystemTrayBubbleBackground);
-};
-
-class SystemTrayBubbleBorder : public views::BubbleBorder {
- public:
-  enum ArrowType {
-    ARROW_TYPE_NONE,
-    ARROW_TYPE_BOTTOM,
-  };
-
-  SystemTrayBubbleBorder(views::View* owner,
-                         ArrowType arrow_type,
-                         int arrow_offset)
-      : views::BubbleBorder(views::BubbleBorder::BOTTOM_RIGHT,
-                            views::BubbleBorder::NO_SHADOW),
-        owner_(owner),
-        arrow_type_(arrow_type),
-        arrow_offset_(arrow_offset) {
-    set_alignment(views::BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
-  }
-
-  virtual ~SystemTrayBubbleBorder() {}
-
- private:
   // Overridden from views::Border.
   virtual void Paint(const views::View& view,
                      gfx::Canvas* canvas) const OVERRIDE {
     gfx::Insets inset;
     GetInsets(&inset);
     DrawBlurredShadowAroundView(canvas, 0, owner_->height(), owner_->width(),
         inset);
 
+    PaintChildBorder(canvas);
+
     // Draw the bottom line.
     int y = owner_->height() + 1;
-    canvas->FillRect(gfx::Rect(kLeftPadding, y, owner_->width(),
+    canvas->FillRect(gfx::Rect(inset.left(), y, owner_->width(),
                                kBottomLineHeight), kBorderDarkColor);
 
-    if (!Shell::GetInstance()->shelf()->IsVisible())
+    if (!Shell::GetInstance()->shelf()->IsVisible() ||
+        arrow_location() == views::BubbleBorder::NONE)
       return;
 
-    // Draw the arrow.
-    if (arrow_type_ == ARROW_TYPE_BOTTOM) {
-      int tip_x = base::i18n::IsRTL() ? arrow_offset_ :
-          owner_->width() - arrow_offset_;
-      int left_base_x = tip_x - kArrowWidth / 2;
+    // Draw the arrow after drawing child borders, so that the arrow can cover
+    // the its overlap section with child border.
+    SkPath path;
+    if (arrow_location() == views::BubbleBorder::BOTTOM_RIGHT) {
+      int left_base_x = base::i18n::IsRTL() ? kArrowWidth :
+          owner_->width() - kArrowPaddingFromRight - kArrowWidth;
       int left_base_y = y;
+      int tip_x = left_base_x + kArrowWidth / 2;
       int tip_y = left_base_y + kArrowHeight;
-
-      SkPath path;
       path.incReserve(4);
       path.moveTo(SkIntToScalar(left_base_x), SkIntToScalar(left_base_y));
       path.lineTo(SkIntToScalar(tip_x), SkIntToScalar(tip_y));
       path.lineTo(SkIntToScalar(left_base_x + kArrowWidth),
                   SkIntToScalar(left_base_y));
+    } else if (arrow_location() == views::BubbleBorder::LEFT_BOTTOM) {
+      int top_base_x = inset.left() + kSystemTrayBubbleHorizontalInset;
+      int top_base_y = y -kArrowPaddingFromBottom - kArrowWidth;
+      int tip_x = top_base_x - kArrowHeight;
+      int tip_y = top_base_y + kArrowWidth / 2;
+      path.incReserve(4);
+      path.moveTo(SkIntToScalar(top_base_x), SkIntToScalar(top_base_y));
+      path.lineTo(SkIntToScalar(tip_x), SkIntToScalar(tip_y));
+      path.lineTo(SkIntToScalar(top_base_x),
+                  SkIntToScalar(top_base_y + kArrowWidth));
+    } else if (arrow_location() == views::BubbleBorder::RIGHT_BOTTOM){
+        int top_base_x = inset.left() + owner_->width() -
+                         kSystemTrayBubbleHorizontalInset;
+        int top_base_y = y -kArrowPaddingFromBottom - kArrowWidth;
+        int tip_x = top_base_x + kArrowHeight;
+        int tip_y = top_base_y + kArrowWidth / 2;
+        path.incReserve(4);
+        path.moveTo(SkIntToScalar(top_base_x), SkIntToScalar(top_base_y));
+        path.lineTo(SkIntToScalar(tip_x), SkIntToScalar(tip_y));
+        path.lineTo(SkIntToScalar(top_base_x),
+                    SkIntToScalar(top_base_y + kArrowWidth));
+    }
 
-      SkPaint paint;
-      paint.setStyle(SkPaint::kFill_Style);
-      paint.setColor(kHeaderBackgroundColorDark);
-      canvas->DrawPath(path, paint);
+    SkPaint paint;
+    paint.setStyle(SkPaint::kFill_Style);
+    paint.setColor(kHeaderBackgroundColorDark);
+    canvas->DrawPath(path, paint);
 
-      // Now draw the arrow border.
-      paint.setStyle(SkPaint::kStroke_Style);
-      paint.setColor(kBorderDarkColor);
-      canvas->DrawPath(path, paint);
-    }
+    // Now draw the arrow border.
+    paint.setStyle(SkPaint::kStroke_Style);
+    paint.setColor(kBorderDarkColor);
+    canvas->DrawPath(path, paint);
+
   }
 
   views::View* owner_;
-  ArrowType arrow_type_;
-  const int arrow_offset_;

[sadrul, 2012/05/17 19:57:05]

I think the removal of arrow_offset_ was accidental? We will still need this.
(see crbugs 124636, 124637)

[jennyz, 2012/05/17 22:13:30]

Yes, that was removed by accident during rebasing and merging, I added it back.
But I noticed the UI looks a little weird to me when the arrow kept moving with
the mouse clicking, but the arrow can looks funny and even off the bubble when
the mouse is pointing to the border of the bubble . Also this will further
create UI problems in left/right layout, if the arrow moves to the upper part of
the bubble, we will need to change the fill color of the arrow. The worst case
will be for the arrow to be positioned across the border between the dark and
light section of the bubble. I wonder if we will further refine this UI
behavior. For now I only added a kMinArrowOffset to limit the arrow not to move
off and too close to the edge of the bubble.

 
   DISALLOW_COPY_AND_ASSIGN(SystemTrayBubbleBorder);
 };
 
 }  // namespace
 
 namespace internal {
 
 // SystemTrayBubbleView
 
 SystemTrayBubbleView::SystemTrayBubbleView(views::View* anchor,
-                                           SystemTrayBubble* host,
-                                           bool can_activate)
-    : views::BubbleDelegateView(anchor, views::BubbleBorder::BOTTOM_RIGHT),
+    views::BubbleBorder::ArrowLocation arrow_location,
+    SystemTrayBubble* host, bool can_activate)

[sadrul, 2012/05/17 19:57:05]

bool can_activate should be in its own line

[jennyz, 2012/05/17 22:13:30]

Done.

+    : views::BubbleDelegateView(anchor, arrow_location),
       host_(host),
       can_activate_(can_activate) {
   set_margin(0);
   set_parent_window(ash::Shell::GetInstance()->GetContainer(
       ash::internal::kShellWindowId_SettingBubbleContainer));
   set_notify_enter_exit_on_child(true);
 }
 
 SystemTrayBubbleView::~SystemTrayBubbleView() {
   // Inform host items (models) that their views are being destroyed.
   if (host_)
     host_->DestroyItemViews();
 }
 
 void SystemTrayBubbleView::SetBubbleBorder(views::BubbleBorder* border) {
   GetBubbleFrameView()->SetBubbleBorder(border);
 }
 
 void SystemTrayBubbleView::UpdateAnchor() {
   SizeToContents();
   GetWidget()->GetRootView()->SchedulePaint();
 }
 
 void SystemTrayBubbleView::Init() {
   views::BoxLayout* layout =
-      new views::BoxLayout(views::BoxLayout::kVertical, 1, 1, 1);
+      new views::BoxLayout(views::BoxLayout::kVertical,
+                           kSystemTrayBubbleHorizontalInset,
+                           kSystemTrayBubbleVerticalInset,
+                           1);
   layout->set_spread_blank_space(true);
   SetLayoutManager(layout);
-  set_background(new SystemTrayBubbleBackground(this));
+  set_background(NULL);
 }
 
 gfx::Rect SystemTrayBubbleView::GetAnchorRect() {
   gfx::Rect rect;
   if (host_)
     rect = host_->GetAnchorRect();
+  // TODO(jennyz): May need to add left/right alignment in the following code.
   if (rect.IsEmpty()) {
     rect = gfx::Screen::GetPrimaryMonitor().bounds();
-    rect = gfx::Rect(base::i18n::IsRTL() ? kPaddingFromRightEdgeOfScreen :
-                     rect.width() - kPaddingFromRightEdgeOfScreen,
-                     rect.height() - kPaddingFromBottomOfScreen,
-                     0, 0);
+    rect = gfx::Rect(
+        base::i18n::IsRTL() ? kPaddingFromRightEdgeOfScreenBottomAlignment :
+            rect.width() - kPaddingFromRightEdgeOfScreenBottomAlignment,
+        rect.height() - kPaddingFromBottomOfScreenBottomAlignment,
+        0, 0);
   }
   return rect;
 }
 
 void SystemTrayBubbleView::ChildPreferredSizeChanged(View* child) {
   SizeToContents();
 }
 
 void SystemTrayBubbleView::GetAccessibleState(ui::AccessibleViewState* state) {
   if (can_activate_) {
@@ skipping 21 matching lines @@
   if (host_)
     host_->RestartAutoCloseTimer();
 }
 
 // SystemTrayBubble::InitParams
 SystemTrayBubble::InitParams::InitParams(
     SystemTrayBubble::AnchorType anchor_type)
     : anchor(NULL),
       anchor_type(anchor_type),
       can_activate(false),
-      login_status(ash::user::LOGGED_IN_NONE),
-      arrow_offset(kArrowPaddingFromRight + kArrowWidth / 2) {
+      login_status(ash::user::LOGGED_IN_NONE) {
 }
 
 // SystemTrayBubble
 
 SystemTrayBubble::SystemTrayBubble(
     ash::SystemTray* tray,
     const std::vector<ash::SystemTrayItem*>& items,
     BubbleType bubble_type)
     : tray_(tray),
       bubble_view_(NULL),
@@ skipping 24 matching lines @@
 
   items_ = items;
   bubble_type_ = bubble_type;
   CreateItemViews(Shell::GetInstance()->tray_delegate()->GetUserLoginStatus());
   bubble_widget_->GetContentsView()->Layout();
 }
 
 void SystemTrayBubble::InitView(const InitParams& init_params) {
   DCHECK(bubble_view_ == NULL);
   anchor_type_ = init_params.anchor_type;
+  views::BubbleBorder::ArrowLocation arrow_location;
+  if (anchor_type_ == ANCHOR_TYPE_TRAY) {
+    if (tray_->GetAlignment() == SHELF_ALIGNMENT_BOTTOM) {
+      arrow_location = views::BubbleBorder::BOTTOM_RIGHT;
+    } else if (tray_->GetAlignment() == SHELF_ALIGNMENT_LEFT) {
+      arrow_location = views::BubbleBorder::LEFT_BOTTOM;
+    } else {
+      arrow_location = views::BubbleBorder::RIGHT_BOTTOM;
+    }
+  } else {
+      arrow_location = views::BubbleBorder::NONE;
+  }
   bubble_view_ = new SystemTrayBubbleView(
-      init_params.anchor, this, init_params.can_activate);
+      init_params.anchor, arrow_location, this, init_params.can_activate);
   if (bubble_type_ == BUBBLE_TYPE_NOTIFICATION)
     bubble_view_->set_close_on_deactivate(false);
 
   CreateItemViews(init_params.login_status);
 
   DCHECK(bubble_widget_ == NULL);
   bubble_widget_ = views::BubbleDelegateView::CreateBubble(bubble_view_);
 
   // Must occur after call to CreateBubble()
   bubble_view_->SetAlignment(views::BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
   bubble_widget_->non_client_view()->frame_view()->set_background(NULL);
-  SystemTrayBubbleBorder::ArrowType arrow_type;
-  if (anchor_type_ == ANCHOR_TYPE_TRAY)
-    arrow_type = SystemTrayBubbleBorder::ARROW_TYPE_BOTTOM;
-  else
-    arrow_type = SystemTrayBubbleBorder::ARROW_TYPE_NONE;
-
   SystemTrayBubbleBorder* bubble_border = new SystemTrayBubbleBorder(
-      bubble_view_, arrow_type, init_params.arrow_offset);
+      bubble_view_, arrow_location);
   bubble_view_->SetBubbleBorder(bubble_border);
 
   bubble_widget_->AddObserver(this);
 
   // Setup animation.
   ash::SetWindowVisibilityAnimationType(
       bubble_widget_->GetNativeWindow(),
       ash::WINDOW_VISIBILITY_ANIMATION_TYPE_FADE);
   ash::SetWindowVisibilityAnimationTransition(
       bubble_widget_->GetNativeWindow(),
       ash::ANIMATE_BOTH);
   ash::SetWindowVisibilityAnimationDuration(
       bubble_widget_->GetNativeWindow(),
       base::TimeDelta::FromMilliseconds(kAnimationDurationForPopupMS));
 
   bubble_view_->Show();
 }
 
 gfx::Rect SystemTrayBubble::GetAnchorRect() const {
   gfx::Rect rect;
   views::Widget* widget = bubble_view()->anchor_widget();
   if (widget->IsVisible()) {
     rect = widget->GetWindowScreenBounds();
     if (anchor_type_ == ANCHOR_TYPE_TRAY) {
-      rect.Inset(
-          base::i18n::IsRTL() ? kPaddingFromRightEdgeOfScreen : 0,
-          0,
-          base::i18n::IsRTL() ? 0 : kPaddingFromRightEdgeOfScreen,
-          kPaddingFromBottomOfScreen);
+      if (tray_->GetAlignment() == SHELF_ALIGNMENT_BOTTOM) {
+        rect.Inset(
+            base::i18n::IsRTL() ?
+                kPaddingFromRightEdgeOfScreenBottomAlignment : 0,
+            0,
+            base::i18n::IsRTL() ?
+                0 : kPaddingFromRightEdgeOfScreenBottomAlignment,
+            kPaddingFromBottomOfScreenBottomAlignment);
+      } else if (tray_->GetAlignment() == SHELF_ALIGNMENT_LEFT) {
+        rect.Inset(0, 0, kPaddingFromLeftEdgeOfScreenLeftAlignment,
+                   kPaddingFromBottomOfScreenVerticalAlignment);
+      } else {
+        rect.Inset(-kPaddingFromRightEdgeOfScreenRightAlignment,
+                   0, 0, kPaddingFromBottomOfScreenVerticalAlignment);
+      }
     } else if (anchor_type_ == ANCHOR_TYPE_BUBBLE) {
+      // TODO(jennyz): add left/right launcher support for notification bubble.
       rect.Inset(
           base::i18n::IsRTL() ? kShadowThickness - 1 : 0,
           0,
           base::i18n::IsRTL() ? 0 : kShadowThickness - 1,
           0);
     }
   }
   return rect;
 }
 
@@ skipping 61 matching lines @@
 }
 
 void SystemTrayBubble::OnWidgetClosing(views::Widget* widget) {
   CHECK_EQ(bubble_widget_, widget);
   bubble_widget_ = NULL;
   tray_->RemoveBubble(this);
 }
 
 }  // namespace internal
 }  // namespace ash