ui/message_center/views/message_popup_collection.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/message_center/views/message_popup_collection.h"
   6
   7 #include <set>
   8
   9 #include "base/bind.h"
  10 #include "base/i18n/rtl.h"
  11 #include "base/logging.h"
  12 #include "base/memory/weak_ptr.h"
  13 #include "base/run_loop.h"
  14 #include "base/time/time.h"
  15 #include "base/timer/timer.h"
  16 #include "ui/accessibility/ax_enums.h"
  17 #include "ui/gfx/animation/animation_delegate.h"
  18 #include "ui/gfx/animation/slide_animation.h"
  19 #include "ui/gfx/screen.h"
  20 #include "ui/message_center/message_center.h"
  21 #include "ui/message_center/message_center_style.h"
  22 #include "ui/message_center/message_center_tray.h"
  23 #include "ui/message_center/notification.h"
  24 #include "ui/message_center/notification_list.h"
  25 #include "ui/message_center/views/message_view_context_menu_controller.h"
  26 #include "ui/message_center/views/notification_view.h"
  27 #include "ui/message_center/views/popup_alignment_delegate.h"
  28 #include "ui/message_center/views/toast_contents_view.h"
  29 #include "ui/views/background.h"
  30 #include "ui/views/layout/fill_layout.h"
  31 #include "ui/views/view.h"
  32 #include "ui/views/views_delegate.h"
  33 #include "ui/views/widget/widget.h"
  34 #include "ui/views/widget/widget_delegate.h"
  35
  36 namespace message_center {
  37 namespace {
  38
  39 // Timeout between the last user-initiated close of the toast and the moment
  40 // when normal layout/update of the toast stack continues. If the last toast was
  41 // just closed, the timeout is shorter.
  42 const int kMouseExitedDeferTimeoutMs = 200;
  43
  44 // The margin between messages (and between the anchor unless
  45 // first_item_has_no_margin was specified).
  46 const int kToastMarginY = kMarginBetweenItems;
  47
  48 }  // namespace.
  49
  50 MessagePopupCollection::MessagePopupCollection(
  51     gfx::NativeView parent,
  52     MessageCenter* message_center,
  53     MessageCenterTray* tray,
  54     PopupAlignmentDelegate* alignment_delegate)
  55     : parent_(parent),
  56       message_center_(message_center),
  57       tray_(tray),
  58       alignment_delegate_(alignment_delegate),
  59       defer_counter_(0),
  60       latest_toast_entered_(NULL),
  61       user_is_closing_toasts_by_clicking_(false),
  62       context_menu_controller_(new MessageViewContextMenuController(this)),
  63       weak_factory_(this) {
  64   DCHECK(message_center_);
  65   defer_timer_.reset(new base::OneShotTimer<MessagePopupCollection>);
  66   message_center_->AddObserver(this);
  67   alignment_delegate_->set_collection(this);
  68 }
  69
  70 MessagePopupCollection::~MessagePopupCollection() {
  71   weak_factory_.InvalidateWeakPtrs();
  72
  73   message_center_->RemoveObserver(this);
  74
  75   CloseAllWidgets();
  76 }
  77
  78 void MessagePopupCollection::ClickOnNotification(
  79     const std::string& notification_id) {
  80   message_center_->ClickOnNotification(notification_id);
  81 }
  82
  83 void MessagePopupCollection::RemoveNotification(
  84     const std::string& notification_id,
  85     bool by_user) {
  86   message_center_->RemoveNotification(notification_id, by_user);
  87 }
  88
  89 scoped_ptr<ui::MenuModel> MessagePopupCollection::CreateMenuModel(
  90     const NotifierId& notifier_id,
  91     const base::string16& display_source) {
  92   return tray_->CreateNotificationMenuModel(notifier_id, display_source);
  93 }
  94
  95 bool MessagePopupCollection::HasClickedListener(
  96     const std::string& notification_id) {
  97   return message_center_->HasClickedListener(notification_id);
  98 }
  99
 100 void MessagePopupCollection::ClickOnNotificationButton(
 101     const std::string& notification_id,
 102     int button_index) {
 103   message_center_->ClickOnNotificationButton(notification_id, button_index);
 104 }
 105
 106 void MessagePopupCollection::MarkAllPopupsShown() {
 107   std::set<std::string> closed_ids = CloseAllWidgets();
 108   for (std::set<std::string>::iterator iter = closed_ids.begin();
 109        iter != closed_ids.end(); iter++) {
 110     message_center_->MarkSinglePopupAsShown(*iter, false);
 111   }
 112 }
 113
 114 void MessagePopupCollection::UpdateWidgets() {
 115   NotificationList::PopupNotifications popups =
 116       message_center_->GetPopupNotifications();
 117
 118   if (popups.empty()) {
 119     CloseAllWidgets();
 120     return;
 121   }
 122
 123   bool top_down = alignment_delegate_->IsTopDown();
 124   int base = GetBaseLine(toasts_.empty() ? NULL : toasts_.back());
 125
 126   // Iterate in the reverse order to keep the oldest toasts on screen. Newer
 127   // items may be ignored if there are no room to place them.
 128   for (NotificationList::PopupNotifications::const_reverse_iterator iter =
 129            popups.rbegin(); iter != popups.rend(); ++iter) {
 130     if (FindToast((*iter)->id()))
 131       continue;
 132
 133     NotificationView* view =
 134         NotificationView::Create(NULL,
 135                                  *(*iter),
 136                                  true); // Create top-level notification.
 137     view->set_context_menu_controller(context_menu_controller_.get());
 138     int view_height = ToastContentsView::GetToastSizeForView(view).height();
 139     int height_available =
 140         top_down ? alignment_delegate_->GetWorkAreaBottom() - base : base;
 141
 142     if (height_available - view_height - kToastMarginY < 0) {
 143       delete view;
 144       break;
 145     }
 146
 147     ToastContentsView* toast =
 148         new ToastContentsView((*iter)->id(), weak_factory_.GetWeakPtr());
 149     // There will be no contents already since this is a new ToastContentsView.
 150     toast->SetContents(view, /*a11y_feedback_for_updates=*/false);
 151     toasts_.push_back(toast);
 152     view->set_controller(toast);
 153
 154     gfx::Size preferred_size = toast->GetPreferredSize();
 155     gfx::Point origin(
 156         alignment_delegate_->GetToastOriginX(gfx::Rect(preferred_size)), base);
 157     // The toast slides in from the edge of the screen horizontally.
 158     if (alignment_delegate_->IsFromLeft())
 159       origin.set_x(origin.x() - preferred_size.width());
 160     else
 161       origin.set_x(origin.x() + preferred_size.width());
 162     if (top_down)
 163       origin.set_y(origin.y() + view_height);
 164
 165     toast->RevealWithAnimation(origin);
 166
 167     // Shift the base line to be a few pixels above the last added toast or (few
 168     // pixels below last added toast if top-aligned).
 169     if (top_down)
 170       base += view_height + kToastMarginY;
 171     else
 172       base -= view_height + kToastMarginY;
 173
 174     if (views::ViewsDelegate::GetInstance()) {
 175       views::ViewsDelegate::GetInstance()->NotifyAccessibilityEvent(
 176           toast, ui::AX_EVENT_ALERT);
 177     }
 178
 179     message_center_->DisplayedNotification(
 180         (*iter)->id(), message_center::DISPLAY_SOURCE_POPUP);
 181   }
 182 }
 183
 184 void MessagePopupCollection::OnMouseEntered(ToastContentsView* toast_entered) {
 185   // Sometimes we can get two MouseEntered/MouseExited in a row when animating
 186   // toasts.  So we need to keep track of which one is the currently active one.
 187   latest_toast_entered_ = toast_entered;
 188
 189   message_center_->PausePopupTimers();
 190
 191   if (user_is_closing_toasts_by_clicking_)
 192     defer_timer_->Stop();
 193 }
 194
 195 void MessagePopupCollection::OnMouseExited(ToastContentsView* toast_exited) {
 196   // If we're exiting a toast after entering a different toast, then ignore
 197   // this mouse event.
 198   if (toast_exited != latest_toast_entered_)
 199     return;
 200   latest_toast_entered_ = NULL;
 201
 202   if (user_is_closing_toasts_by_clicking_) {
 203     defer_timer_->Start(
 204         FROM_HERE,
 205         base::TimeDelta::FromMilliseconds(kMouseExitedDeferTimeoutMs),
 206         this,
 207         &MessagePopupCollection::OnDeferTimerExpired);
 208   } else {
 209     message_center_->RestartPopupTimers();
 210   }
 211 }
 212
 213 std::set<std::string> MessagePopupCollection::CloseAllWidgets() {
 214   std::set<std::string> closed_toast_ids;
 215
 216   while (!toasts_.empty()) {
 217     ToastContentsView* toast = toasts_.front();
 218     toasts_.pop_front();
 219     closed_toast_ids.insert(toast->id());
 220
 221     OnMouseExited(toast);
 222
 223     // CloseWithAnimation will cause the toast to forget about |this| so it is
 224     // required when we forget a toast.
 225     toast->CloseWithAnimation();
 226   }
 227
 228   return closed_toast_ids;
 229 }
 230
 231 void MessagePopupCollection::ForgetToast(ToastContentsView* toast) {
 232   toasts_.remove(toast);
 233   OnMouseExited(toast);
 234 }
 235
 236 void MessagePopupCollection::RemoveToast(ToastContentsView* toast,
 237                                          bool mark_as_shown) {
 238   ForgetToast(toast);
 239
 240   toast->CloseWithAnimation();
 241
 242   if (mark_as_shown)
 243     message_center_->MarkSinglePopupAsShown(toast->id(), false);
 244 }
 245
 246 void MessagePopupCollection::RepositionWidgets() {
 247   bool top_down = alignment_delegate_->IsTopDown();
 248   int base = GetBaseLine(NULL);  // We don't want to position relative to last
 249                                  // toast - we want re-position.
 250
 251   for (Toasts::const_iterator iter = toasts_.begin(); iter != toasts_.end();) {
 252     Toasts::const_iterator curr = iter++;
 253     gfx::Rect bounds((*curr)->bounds());
 254     bounds.set_x(alignment_delegate_->GetToastOriginX(bounds));
 255     bounds.set_y(top_down ? base : base - bounds.height());
 256
 257     // The notification may scrolls the boundary of the screen due to image
 258     // load and such notifications should disappear. Do not call
 259     // CloseWithAnimation, we don't want to show the closing animation, and we
 260     // don't want to mark such notifications as shown. See crbug.com/233424
 261     if ((top_down ? alignment_delegate_->GetWorkAreaBottom() - bounds.bottom()
 262                   : bounds.y()) >= 0)
 263       (*curr)->SetBoundsWithAnimation(bounds);
 264     else
 265       RemoveToast(*curr, /*mark_as_shown=*/false);
 266
 267     // Shift the base line to be a few pixels above the last added toast or (few
 268     // pixels below last added toast if top-aligned).
 269     if (top_down)
 270       base += bounds.height() + kToastMarginY;
 271     else
 272       base -= bounds.height() + kToastMarginY;
 273   }
 274 }
 275
 276 void MessagePopupCollection::RepositionWidgetsWithTarget() {
 277   if (toasts_.empty())
 278     return;
 279
 280   bool top_down = alignment_delegate_->IsTopDown();
 281
 282   // Nothing to do if there are no widgets above target if bottom-aligned or no
 283   // widgets below target if top-aligned.
 284   if (top_down ? toasts_.back()->origin().y() < target_top_edge_
 285                : toasts_.back()->origin().y() > target_top_edge_)
 286     return;
 287
 288   Toasts::reverse_iterator iter = toasts_.rbegin();
 289   for (; iter != toasts_.rend(); ++iter) {
 290     // We only reposition widgets above target if bottom-aligned or widgets
 291     // below target if top-aligned.
 292     if (top_down ? (*iter)->origin().y() < target_top_edge_
 293                  : (*iter)->origin().y() > target_top_edge_)
 294       break;
 295   }
 296   --iter;
 297
 298   // Slide length is the number of pixels the widgets should move so that their
 299   // bottom edge (top-edge if top-aligned) touches the target.
 300   int slide_length = std::abs(target_top_edge_ - (*iter)->origin().y());
 301   for (;; --iter) {
 302     gfx::Rect bounds((*iter)->bounds());
 303
 304     // If top-aligned, shift widgets upwards by slide_length. If bottom-aligned,
 305     // shift them downwards by slide_length.
 306     if (top_down)
 307       bounds.set_y(bounds.y() - slide_length);
 308     else
 309       bounds.set_y(bounds.y() + slide_length);
 310     (*iter)->SetBoundsWithAnimation(bounds);
 311
 312     if (iter == toasts_.rbegin())
 313       break;
 314   }
 315 }
 316
 317 int MessagePopupCollection::GetBaseLine(ToastContentsView* last_toast) const {
 318   if (!last_toast) {
 319     return alignment_delegate_->GetBaseLine();
 320   } else if (alignment_delegate_->IsTopDown()) {
 321     return toasts_.back()->bounds().bottom() + kToastMarginY;
 322   } else {
 323     return toasts_.back()->origin().y() - kToastMarginY;
 324   }
 325 }
 326
 327 void MessagePopupCollection::OnNotificationAdded(
 328     const std::string& notification_id) {
 329   DoUpdateIfPossible();
 330 }
 331
 332 void MessagePopupCollection::OnNotificationRemoved(
 333     const std::string& notification_id,
 334     bool by_user) {
 335   // Find a toast.
 336   Toasts::const_iterator iter = toasts_.begin();
 337   for (; iter != toasts_.end(); ++iter) {
 338     if ((*iter)->id() == notification_id)
 339       break;
 340   }
 341   if (iter == toasts_.end())
 342     return;
 343
 344   target_top_edge_ = (*iter)->bounds().y();
 345   if (by_user && !user_is_closing_toasts_by_clicking_) {
 346     // [Re] start a timeout after which the toasts re-position to their
 347     // normal locations after tracking the mouse pointer for easy deletion.
 348     // This provides a period of time when toasts are easy to remove because
 349     // they re-position themselves to have Close button right under the mouse
 350     // pointer. If the user continue to remove the toasts, the delay is reset.
 351     // Once user stopped removing the toasts, the toasts re-populate/rearrange
 352     // after the specified delay.
 353     user_is_closing_toasts_by_clicking_ = true;
 354     IncrementDeferCounter();
 355   }
 356
 357   // CloseWithAnimation ultimately causes a call to RemoveToast, which calls
 358   // OnMouseExited.  This means that |user_is_closing_toasts_by_clicking_| must
 359   // have been set before this call, otherwise it will remain true even after
 360   // the toast is closed, since the defer timer won't be started.
 361   RemoveToast(*iter, /*mark_as_shown=*/true);
 362
 363   if (by_user)
 364     RepositionWidgetsWithTarget();
 365 }
 366
 367 void MessagePopupCollection::OnDeferTimerExpired() {
 368   user_is_closing_toasts_by_clicking_ = false;
 369   DecrementDeferCounter();
 370
 371   message_center_->RestartPopupTimers();
 372 }
 373
 374 void MessagePopupCollection::OnNotificationUpdated(
 375     const std::string& notification_id) {
 376   // Find a toast.
 377   Toasts::const_iterator toast_iter = toasts_.begin();
 378   for (; toast_iter != toasts_.end(); ++toast_iter) {
 379     if ((*toast_iter)->id() == notification_id)
 380       break;
 381   }
 382   if (toast_iter == toasts_.end())
 383     return;
 384
 385   NotificationList::PopupNotifications notifications =
 386       message_center_->GetPopupNotifications();
 387   bool updated = false;
 388
 389   for (NotificationList::PopupNotifications::iterator iter =
 390            notifications.begin(); iter != notifications.end(); ++iter) {
 391     Notification* notification = *iter;
 392     DCHECK(notification);
 393     ToastContentsView* toast_contents_view = *toast_iter;
 394     DCHECK(toast_contents_view);
 395
 396     if (notification->id() != notification_id)
 397       continue;
 398
 399     const RichNotificationData& optional_fields =
 400         notification->rich_notification_data();
 401     bool a11y_feedback_for_updates =
 402         optional_fields.should_make_spoken_feedback_for_popup_updates;
 403
 404     toast_contents_view->UpdateContents(*notification,
 405                                         a11y_feedback_for_updates);
 406
 407     updated = true;
 408   }
 409
 410   // OnNotificationUpdated() can be called when a notification is excluded from
 411   // the popup notification list but still remains in the full notification
 412   // list. In that case the widget for the notification has to be closed here.
 413   if (!updated)
 414     RemoveToast(*toast_iter, /*mark_as_shown=*/true);
 415
 416   if (user_is_closing_toasts_by_clicking_)
 417     RepositionWidgetsWithTarget();
 418   else
 419     DoUpdateIfPossible();
 420 }
 421
 422 ToastContentsView* MessagePopupCollection::FindToast(
 423     const std::string& notification_id) const {
 424   for (Toasts::const_iterator iter = toasts_.begin(); iter != toasts_.end();
 425        ++iter) {
 426     if ((*iter)->id() == notification_id)
 427       return *iter;
 428   }
 429   return NULL;
 430 }
 431
 432 void MessagePopupCollection::IncrementDeferCounter() {
 433   defer_counter_++;
 434 }
 435
 436 void MessagePopupCollection::DecrementDeferCounter() {
 437   defer_counter_--;
 438   DCHECK(defer_counter_ >= 0);
 439   DoUpdateIfPossible();
 440 }
 441
 442 // This is the main sequencer of tasks. It does a step, then waits for
 443 // all started transitions to play out before doing the next step.
 444 // First, remove all expired toasts.
 445 // Then, reposition widgets (the reposition on close happens before all
 446 // deferred tasks are even able to run)
 447 // Then, see if there is vacant space for new toasts.
 448 void MessagePopupCollection::DoUpdateIfPossible() {
 449   if (defer_counter_ > 0)
 450     return;
 451
 452   RepositionWidgets();
 453
 454   if (defer_counter_ > 0)
 455     return;
 456
 457   // Reposition could create extra space which allows additional widgets.
 458   UpdateWidgets();
 459
 460   if (defer_counter_ > 0)
 461     return;
 462
 463   // Test support. Quit the test run loop when no more updates are deferred,
 464   // meaining th echeck for updates did not cause anything to change so no new
 465   // transition animations were started.
 466   if (run_loop_for_test_.get())
 467     run_loop_for_test_->Quit();
 468 }
 469
 470 void MessagePopupCollection::OnDisplayMetricsChanged(
 471     const gfx::Display& display) {
 472   alignment_delegate_->RecomputeAlignment(display);
 473 }
 474
 475 views::Widget* MessagePopupCollection::GetWidgetForTest(const std::string& id)
 476     const {
 477   for (Toasts::const_iterator iter = toasts_.begin(); iter != toasts_.end();
 478        ++iter) {
 479     if ((*iter)->id() == id)
 480       return (*iter)->GetWidget();
 481   }
 482   return NULL;
 483 }
 484
 485 void MessagePopupCollection::CreateRunLoopForTest() {
 486   run_loop_for_test_.reset(new base::RunLoop());
 487 }
 488
 489 void MessagePopupCollection::WaitForTest() {
 490   run_loop_for_test_->Run();
 491   run_loop_for_test_.reset();
 492 }
 493
 494 gfx::Rect MessagePopupCollection::GetToastRectAt(size_t index) const {
 495   DCHECK(defer_counter_ == 0) << "Fetching the bounds with animations active.";
 496   size_t i = 0;
 497   for (Toasts::const_iterator iter = toasts_.begin(); iter != toasts_.end();
 498        ++iter) {
 499     if (i++ == index) {
 500       views::Widget* widget = (*iter)->GetWidget();
 501       if (widget)
 502         return widget->GetWindowBoundsInScreen();
 503       break;
 504     }
 505   }
 506   return gfx::Rect();
 507 }
 508
 509 }  // namespace message_center