Allow Uber Tray popup pointing to the related tray item view.

ash/system/tray/system_tray_bubble.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/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_item.h"
@@ skipping 158 matching lines @@
   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)
+  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_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);
 
     // Draw the bottom line.
     int y = owner_->height() + 1;
     canvas->FillRect(gfx::Rect(kLeftPadding, y, owner_->width(),
                                kBottomLineHeight), kBorderDarkColor);
 
     if (!Shell::GetInstance()->shelf()->IsVisible())
       return;
 
     // Draw the arrow.
     if (arrow_type_ == ARROW_TYPE_BOTTOM) {
       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;
+      if (arrow_offset_ >= kArrowWidth / 2 &&
+          arrow_offset_ < owner_->width() - kArrowWidth / 2) {
+        tip_x = base::i18n::IsRTL() ?
+            arrow_offset_ : owner_->width() - arrow_offset_;
+        left_base_x = tip_x - kArrowWidth / 2;
+      }

[sadrul, 2012/05/15 02:18:15]

I am not sure I understand this. What does this do?

I was thinking you would only need to change how left_base_x is computed:

  left_base_x = IsRTL() ? kArrowWidth + arrow_offset :
                          owner_->width() - kArrowWidth - arrow_offset;

[Jun Mukai, 2012/05/15 02:43:05]

Done.

+
       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));
 
       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);
     }
   }
 
   views::View* owner_;
   ArrowType arrow_type_;
+  const int arrow_offset_;
 
   DISALLOW_COPY_AND_ASSIGN(SystemTrayBubbleBorder);
 };
 
 }  // namespace
 
 namespace internal {
 
 // SystemTrayBubbleView
 
@@ skipping 67 matching lines @@
 void SystemTrayBubbleView::OnMouseEntered(const views::MouseEvent& event) {
   if (host_)
     host_->StopAutoCloseTimer();
 }
 
 void SystemTrayBubbleView::OnMouseExited(const views::MouseEvent& event) {
   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(-1) {

[sadrul, 2012/05/15 02:18:15]

Initialize offset to kArrowPaddingFromRight

[Jun Mukai, 2012/05/15 02:43:05]

Done.

+}
+
 // SystemTrayBubble
 
 SystemTrayBubble::SystemTrayBubble(
     ash::SystemTray* tray,
     const std::vector<ash::SystemTrayItem*>& items,
     BubbleType bubble_type)
     : tray_(tray),
       bubble_view_(NULL),
       bubble_widget_(NULL),
       items_(items),
@@ skipping 11 matching lines @@
   // Reset the host pointer in bubble_view_ in case its destruction is deferred.
   if (bubble_view_)
     bubble_view_->reset_host();
   if (bubble_widget_) {
     bubble_widget_->RemoveObserver(this);
     // This triggers the destruction of bubble_view_.
     bubble_widget_->Close();
   }
 }
 
-void SystemTrayBubble::InitView(views::View* anchor,
-                                AnchorType anchor_type,
-                                bool can_activate,
-                                ash::user::LoginStatus login_status) {
+void SystemTrayBubble::InitView(const InitParams& init_params) {
   DCHECK(bubble_view_ == NULL);
-  anchor_type_ = anchor_type;
-  bubble_view_ = new SystemTrayBubbleView(anchor, this, can_activate);
+  anchor_type_ = init_params.anchor_type;
+  bubble_view_ = new SystemTrayBubbleView(
+      init_params.anchor, this, init_params.can_activate);
 
   for (std::vector<ash::SystemTrayItem*>::iterator it = items_.begin();
        it != items_.end();
        ++it) {
     views::View* view = NULL;
     switch (bubble_type_) {
       case BUBBLE_TYPE_DEFAULT:
-        view = (*it)->CreateDefaultView(login_status);
+        view = (*it)->CreateDefaultView(init_params.login_status);
         break;
       case BUBBLE_TYPE_DETAILED:
-        view = (*it)->CreateDetailedView(login_status);
+        view = (*it)->CreateDetailedView(init_params.login_status);
         break;
       case BUBBLE_TYPE_NOTIFICATION:
-        view = (*it)->CreateNotificationView(login_status);
+        view = (*it)->CreateNotificationView(init_params.login_status);
         break;
     }
     if (view)
       bubble_view_->AddChildView(new TrayPopupItemContainer(view));
   }
 
   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;
-  bubble_view_->SetBubbleBorder(
-      new SystemTrayBubbleBorder(bubble_view_, arrow_type));
+
+  SystemTrayBubbleBorder* bubble_border = new SystemTrayBubbleBorder(
+      bubble_view_, arrow_type, init_params.arrow_offset);
+  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);
@@ skipping 95 matching lines @@
 void SystemTrayBubble::OnWidgetVisibilityChanged(views::Widget* widget,
                                                  bool visible) {
   if (!visible)
     MessageLoopForUI::current()->RemoveObserver(this);
   else
     MessageLoopForUI::current()->AddObserver(this);
 }
 
 }  // namespace internal
 }  // namespace ash