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

ash/system/tray/system_tray.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.h"
 
 #include "ash/shell.h"
 #include "ash/shell/panel_window.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/audio/tray_volume.h"
@@ skipping 225 matching lines @@
 }
 
 void SystemTray::AddTrayItem(SystemTrayItem* item) {
   items_.push_back(item);
 
   SystemTrayDelegate* delegate = Shell::GetInstance()->tray_delegate();
   views::View* tray_item = item->CreateTrayView(delegate->GetUserLoginStatus());
   if (tray_item) {
     tray_container_->AddChildViewAt(tray_item, 0);
     PreferredSizeChanged();
+    tray_item_map_[item] = tray_item;
   }
 }
 
 void SystemTray::RemoveTrayItem(SystemTrayItem* item) {
   NOTIMPLEMENTED();
 }
 
 void SystemTray::ShowDefaultView() {
-  ShowItems(items_.get(), false, true);
+  ShowDefaultViewWithOffset(-1);
+}
+
+void SystemTray::ShowDefaultViewWithOffset(int arrow_offset) {

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

The order of the functions in the .cc file should match the order in the .h file

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

Done.

+  ShowItems(items_.get(), false, true, arrow_offset);
 }
 
 void SystemTray::ShowDetailedView(SystemTrayItem* item,
                                   int close_delay,
                                   bool activate) {
   std::vector<SystemTrayItem*> items;
   items.push_back(item);
-  ShowItems(items, true, activate);
+  ShowItems(items, true, activate, GetTrayXOffset(item));
   bubble_->StartAutoCloseTimer(close_delay);
 }
 
 void SystemTray::ShowNotificationView(SystemTrayItem* item) {
   if (std::find(notification_items_.begin(), notification_items_.end(), item)
       != notification_items_.end())
     return;
   notification_items_.push_back(item);
   UpdateNotificationBubble();
 }
@@ skipping 54 matching lines @@
     NOTREACHED();
   }
 }
 
 void SystemTray::SetPaintsBackground(
       bool value,
       internal::BackgroundAnimator::ChangeType change_type) {
   hide_background_animator_.SetPaintsBackground(value, change_type);
 }
 
+int SystemTray::GetTrayXOffset(SystemTrayItem* item) const {
+  std::map<SystemTrayItem*, views::View*>::const_iterator it =
+      tray_item_map_.find(item);
+  if (it == tray_item_map_.end())
+    return -1;
+
+  const views::View* item_view = it->second;
+  gfx::Rect item_bounds = item_view->bounds();
+  if (!item_bounds.IsEmpty()) {
+    int x_offset = item_bounds.x() + item_bounds.width() / 2;
+    return base::i18n::IsRTL() ? x_offset : tray_container_->width() - x_offset;
+  }
+
+  // Sometimes the bounds of item is still empty.  In that case, we
+  // want to guess the offset from the position of its parent.

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

I guess this happens when the tray-view for an item is invisible (e.g. for
caps-lock when it's turned off)?

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

No... It happens first time the user presses caps lock.  At that time, the view
bounds is not yet calculated, so the bounds is (0, 0), 0x0.
Added the comment more to describe this situation.

[sadrul, 2012/05/15 02:58:16]

Ah, cool. Thanks for explaining.

+  int x_offset = 0;
+  for (int i = 0; i < tray_container_->child_count(); ++i) {
+    const views::View* child = tray_container_->child_at(i);
+    if (child == item_view)
+      return base::i18n::IsRTL() ?
+          x_offset : tray_container_->width() - x_offset;
+
+    if (!child->visible())
+      continue;
+    x_offset = child->bounds().right();
+  }
+
+  return -1;
+}
+
 void SystemTray::ShowItems(const std::vector<SystemTrayItem*>& items,
                            bool detailed,
-                           bool can_activate) {
+                           bool can_activate,
+                           int arrow_offset) {
   // Destroy any existing bubble and create a new one.
   SystemTrayBubble::BubbleType bubble_type = detailed ?
       SystemTrayBubble::BUBBLE_TYPE_DETAILED :
       SystemTrayBubble::BUBBLE_TYPE_DEFAULT;
   bubble_.reset(new SystemTrayBubble(this, items, bubble_type));
   ash::SystemTrayDelegate* delegate =
       ash::Shell::GetInstance()->tray_delegate();
   views::View* anchor = tray_container_;
-  bubble_->InitView(anchor, SystemTrayBubble::ANCHOR_TYPE_TRAY,
-                    can_activate, delegate->GetUserLoginStatus());
+  SystemTrayBubble::InitParams init_params(SystemTrayBubble::ANCHOR_TYPE_TRAY);
+  init_params.anchor = anchor;
+  init_params.can_activate = can_activate;
+  init_params.login_status = delegate->GetUserLoginStatus();
+  init_params.arrow_offset = arrow_offset;
+  bubble_->InitView(init_params);
   // If we have focus the shelf should be visible and we need to continue
   // showing the shelf when the popup is shown.
   if (GetWidget()->IsActive())
     should_show_launcher_ = true;
   UpdateNotificationBubble();  // State changed, re-create notifications.
 }
 
 void SystemTray::UpdateNotificationBubble() {
   // Only show the notification buble if we have notifications and we are not
   // showing the default bubble.
   if (notification_items_.empty() ||
       (bubble_.get() &&
        bubble_->bubble_type() == SystemTrayBubble::BUBBLE_TYPE_DEFAULT)) {
     notification_bubble_.reset();
     return;
   }
   notification_bubble_.reset(
       new SystemTrayBubble(this, notification_items_,
                            SystemTrayBubble::BUBBLE_TYPE_NOTIFICATION));
   views::View* anchor;
   SystemTrayBubble::AnchorType anchor_type;
   if (bubble_.get()) {
     anchor = bubble_->bubble_view();
     anchor_type = SystemTrayBubble::ANCHOR_TYPE_BUBBLE;
   } else {
     anchor = tray_container_;
     anchor_type = SystemTrayBubble::ANCHOR_TYPE_TRAY;
   }
-  notification_bubble_->InitView(
-      anchor, anchor_type,
-      false /* can_activate */,
-      ash::Shell::GetInstance()->tray_delegate()->GetUserLoginStatus());
+  SystemTrayBubble::InitParams init_params(anchor_type);
+  init_params.anchor = anchor;
+  init_params.login_status =
+      ash::Shell::GetInstance()->tray_delegate()->GetUserLoginStatus();
+  init_params.arrow_offset = GetTrayXOffset(notification_items_[0]);
+  notification_bubble_->InitView(init_params);
 }
 
 void SystemTray::UpdateNotificationAnchor() {
   if (!notification_bubble_.get())
     return;
   notification_bubble_->bubble_view()->UpdateAnchor();
   // Ensure that the notification buble is above the launcher/status area.
   notification_bubble_->bubble_view()->GetWidget()->StackAtTop();
 }
 
 bool SystemTray::PerformAction(const views::Event& event) {
   // If we're already showing the default view, hide it; otherwise, show it
   // (and hide any popup that's currently shown).
   if (bubble_.get() &&
       bubble_->bubble_type() == SystemTrayBubble::BUBBLE_TYPE_DEFAULT) {
     bubble_->Close();
   } else {
-    ShowDefaultView();
+    int arrow_offset = -1;
+    if (event.IsMouseEvent() || event.IsTouchEvent()) {
+      const views::LocatedEvent& located_event =
+          static_cast<const views::LocatedEvent&>(event);
+      arrow_offset = base::i18n::IsRTL() ?
+          located_event.x() : tray_container_->width() - located_event.x();
+    }
+    ShowDefaultViewWithOffset(arrow_offset);
   }
   return true;
 }
 
 void SystemTray::OnMouseEntered(const views::MouseEvent& event) {
   should_show_launcher_ = true;
   hover_background_animator_.SetPaintsBackground(true,
       internal::BackgroundAnimator::CHANGE_ANIMATE);
 }
 
@@ skipping 25 matching lines @@
     canvas->DrawFocusRect(tray_container_->bounds());
 }
 
 void SystemTray::UpdateBackground(int alpha) {
   background_->set_alpha(hide_background_animator_.alpha() +
                          hover_background_animator_.alpha());
   SchedulePaint();
 }
 
 }  // namespace ash