ui/message_center/views/message_center_view.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_center_view.h"
   6
   7 #include <list>
   8 #include <map>
   9
  10 #include "base/command_line.h"
  11 #include "base/memory/weak_ptr.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "base/stl_util.h"
  14 #include "ui/base/l10n/l10n_util.h"
  15 #include "ui/gfx/animation/multi_animation.h"
  16 #include "ui/gfx/animation/slide_animation.h"
  17 #include "ui/gfx/canvas.h"
  18 #include "ui/gfx/insets.h"
  19 #include "ui/gfx/rect.h"
  20 #include "ui/gfx/size.h"
  21 #include "ui/message_center/message_center.h"
  22 #include "ui/message_center/message_center_style.h"
  23 #include "ui/message_center/message_center_switches.h"
  24 #include "ui/message_center/message_center_tray.h"
  25 #include "ui/message_center/message_center_types.h"
  26 #include "ui/message_center/views/message_center_button_bar.h"
  27 #include "ui/message_center/views/message_view.h"
  28 #include "ui/message_center/views/message_view_context_menu_controller.h"
  29 #include "ui/message_center/views/notification_view.h"
  30 #include "ui/message_center/views/notifier_settings_view.h"
  31 #include "ui/resources/grit/ui_resources.h"
  32 #include "ui/strings/grit/ui_strings.h"
  33 #include "ui/views/animation/bounds_animator.h"
  34 #include "ui/views/animation/bounds_animator_observer.h"
  35 #include "ui/views/background.h"
  36 #include "ui/views/border.h"
  37 #include "ui/views/controls/button/button.h"
  38 #include "ui/views/controls/label.h"
  39 #include "ui/views/controls/scroll_view.h"
  40 #include "ui/views/controls/scrollbar/overlay_scroll_bar.h"
  41 #include "ui/views/layout/box_layout.h"
  42 #include "ui/views/layout/fill_layout.h"
  43 #include "ui/views/widget/widget.h"
  44
  45 namespace message_center {
  46
  47 namespace {
  48
  49 const SkColor kNoNotificationsTextColor = SkColorSetRGB(0xb4, 0xb4, 0xb4);
  50 #if defined(OS_LINUX) && defined(OS_CHROMEOS)
  51 const SkColor kTransparentColor = SkColorSetARGB(0, 0, 0, 0);
  52 #endif
  53 const int kAnimateClearingNextNotificationDelayMS = 40;
  54
  55 const int kDefaultAnimationDurationMs = 120;
  56 const int kDefaultFrameRateHz = 60;
  57 }  // namespace
  58
  59 class NoNotificationMessageView : public views::View {
  60  public:
  61   NoNotificationMessageView();
  62   virtual ~NoNotificationMessageView();
  63
  64   // Overridden from views::View.
  65   virtual gfx::Size GetPreferredSize() const OVERRIDE;
  66   virtual int GetHeightForWidth(int width) const OVERRIDE;
  67   virtual void Layout() OVERRIDE;
  68
  69  private:
  70   views::Label* label_;
  71
  72   DISALLOW_COPY_AND_ASSIGN(NoNotificationMessageView);
  73 };
  74
  75 NoNotificationMessageView::NoNotificationMessageView() {
  76   label_ = new views::Label(l10n_util::GetStringUTF16(
  77       IDS_MESSAGE_CENTER_NO_MESSAGES));
  78   label_->SetAutoColorReadabilityEnabled(false);
  79   label_->SetEnabledColor(kNoNotificationsTextColor);
  80   // Set transparent background to ensure that subpixel rendering
  81   // is disabled. See crbug.com/169056
  82 #if defined(OS_LINUX) && defined(OS_CHROMEOS)
  83   label_->SetBackgroundColor(kTransparentColor);
  84 #endif
  85   AddChildView(label_);
  86 }
  87
  88 NoNotificationMessageView::~NoNotificationMessageView() {
  89 }
  90
  91 gfx::Size NoNotificationMessageView::GetPreferredSize() const {
  92   return gfx::Size(kMinScrollViewHeight, label_->GetPreferredSize().width());
  93 }
  94
  95 int NoNotificationMessageView::GetHeightForWidth(int width) const {
  96   return kMinScrollViewHeight;
  97 }
  98
  99 void NoNotificationMessageView::Layout() {
 100   int text_height = label_->GetHeightForWidth(width());
 101   int margin = (height() - text_height) / 2;
 102   label_->SetBounds(0, margin, width(), text_height);
 103 }
 104
 105 // Displays a list of messages for rich notifications. Functions as an array of
 106 // MessageViews and animates them on transitions. It also supports
 107 // repositioning.
 108 class MessageListView : public views::View,
 109                         public views::BoundsAnimatorObserver {
 110  public:
 111   explicit MessageListView(MessageCenterView* message_center_view,
 112                            bool top_down);
 113   virtual ~MessageListView();
 114
 115   void AddNotificationAt(MessageView* view, int i);
 116   void RemoveNotification(MessageView* view);
 117   void UpdateNotification(MessageView* view, const Notification& notification);
 118   void SetRepositionTarget(const gfx::Rect& target_rect);
 119   void ResetRepositionSession();
 120   void ClearAllNotifications(const gfx::Rect& visible_scroll_rect);
 121
 122  protected:
 123   // Overridden from views::View.
 124   virtual void Layout() OVERRIDE;
 125   virtual gfx::Size GetPreferredSize() const OVERRIDE;
 126   virtual int GetHeightForWidth(int width) const OVERRIDE;
 127   virtual void PaintChildren(gfx::Canvas* canvas,
 128                              const views::CullSet& cull_set) OVERRIDE;
 129   virtual void ReorderChildLayers(ui::Layer* parent_layer) OVERRIDE;
 130
 131   // Overridden from views::BoundsAnimatorObserver.
 132   virtual void OnBoundsAnimatorProgressed(
 133       views::BoundsAnimator* animator) OVERRIDE;
 134   virtual void OnBoundsAnimatorDone(views::BoundsAnimator* animator) OVERRIDE;
 135
 136  private:
 137   bool IsValidChild(const views::View* child) const;
 138   void DoUpdateIfPossible();
 139
 140   // Animates all notifications below target upwards to align with the top of
 141   // the last closed notification.
 142   void AnimateNotificationsBelowTarget();
 143   // Animates all notifications above target downwards to align with the top of
 144   // the last closed notification.
 145   void AnimateNotificationsAboveTarget();
 146
 147   // Schedules animation for a child to the specified position. Returns false
 148   // if |child| will disappear after the animation.
 149   bool AnimateChild(views::View* child, int top, int height);
 150
 151   // Animate clearing one notification.
 152   void AnimateClearingOneNotification();
 153   MessageCenterView* message_center_view() const {
 154     return message_center_view_;
 155   }
 156
 157   MessageCenterView* message_center_view_;  // Weak reference.
 158   // The top position of the reposition target rectangle.
 159   int reposition_top_;
 160   int fixed_height_;
 161   bool has_deferred_task_;
 162   bool clear_all_started_;
 163   bool top_down_;
 164   std::set<views::View*> adding_views_;
 165   std::set<views::View*> deleting_views_;
 166   std::set<views::View*> deleted_when_done_;
 167   std::list<views::View*> clearing_all_views_;
 168   scoped_ptr<views::BoundsAnimator> animator_;
 169   base::WeakPtrFactory<MessageListView> weak_ptr_factory_;
 170
 171   DISALLOW_COPY_AND_ASSIGN(MessageListView);
 172 };
 173
 174 MessageListView::MessageListView(MessageCenterView* message_center_view,
 175                                  bool top_down)
 176     : message_center_view_(message_center_view),
 177       reposition_top_(-1),
 178       fixed_height_(0),
 179       has_deferred_task_(false),
 180       clear_all_started_(false),
 181       top_down_(top_down),
 182       weak_ptr_factory_(this) {
 183   views::BoxLayout* layout =
 184       new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 1);
 185   layout->SetDefaultFlex(1);
 186   SetLayoutManager(layout);
 187
 188   // Set the margin to 0 for the layout. BoxLayout assumes the same margin
 189   // for top and bottom, but the bottom margin here should be smaller
 190   // because of the shadow of message view. Use an empty border instead
 191   // to provide this margin.
 192   gfx::Insets shadow_insets = MessageView::GetShadowInsets();
 193   set_background(views::Background::CreateSolidBackground(
 194       kMessageCenterBackgroundColor));
 195   SetBorder(views::Border::CreateEmptyBorder(
 196       top_down ? 0 : kMarginBetweenItems - shadow_insets.top(),    /* top */
 197       kMarginBetweenItems - shadow_insets.left(),                  /* left */
 198       top_down ? kMarginBetweenItems - shadow_insets.bottom() : 0, /* bottom */
 199       kMarginBetweenItems - shadow_insets.right() /* right */));
 200 }
 201
 202 MessageListView::~MessageListView() {
 203   if (animator_.get())
 204     animator_->RemoveObserver(this);
 205 }
 206
 207 void MessageListView::Layout() {
 208   if (animator_.get())
 209     return;
 210
 211   gfx::Rect child_area = GetContentsBounds();
 212   int top = child_area.y();
 213   int between_items =
 214       kMarginBetweenItems - MessageView::GetShadowInsets().bottom();
 215
 216   for (int i = 0; i < child_count(); ++i) {
 217     views::View* child = child_at(i);
 218     if (!child->visible())
 219       continue;
 220     int height = child->GetHeightForWidth(child_area.width());
 221     child->SetBounds(child_area.x(), top, child_area.width(), height);
 222     top += height + between_items;
 223   }
 224 }
 225
 226 void MessageListView::AddNotificationAt(MessageView* view, int index) {
 227   // |index| refers to a position in a subset of valid children. |real_index|
 228   // in a list includes the invalid children, so we compute the real index by
 229   // walking the list until |index| number of valid children are encountered,
 230   // or to the end of the list.
 231   int real_index = 0;
 232   while (real_index < child_count()) {
 233     if (IsValidChild(child_at(real_index))) {
 234       --index;
 235       if (index < 0)
 236         break;
 237     }
 238     ++real_index;
 239   }
 240
 241   AddChildViewAt(view, real_index);
 242   if (GetContentsBounds().IsEmpty())
 243     return;
 244
 245   adding_views_.insert(view);
 246   DoUpdateIfPossible();
 247 }
 248
 249 void MessageListView::RemoveNotification(MessageView* view) {
 250   DCHECK_EQ(view->parent(), this);
 251   if (GetContentsBounds().IsEmpty()) {
 252     delete view;
 253   } else {
 254     if (view->layer()) {
 255       deleting_views_.insert(view);
 256     } else {
 257       if (animator_.get())
 258         animator_->StopAnimatingView(view);
 259       delete view;
 260     }
 261     DoUpdateIfPossible();
 262   }
 263 }
 264
 265 void MessageListView::UpdateNotification(MessageView* view,
 266                                          const Notification& notification) {
 267   int index = GetIndexOf(view);
 268   DCHECK_LE(0, index);  // GetIndexOf is negative if not a child.
 269
 270   if (animator_.get())
 271     animator_->StopAnimatingView(view);
 272   if (deleting_views_.find(view) != deleting_views_.end())
 273     deleting_views_.erase(view);
 274   if (deleted_when_done_.find(view) != deleted_when_done_.end())
 275     deleted_when_done_.erase(view);
 276   view->UpdateWithNotification(notification);
 277   DoUpdateIfPossible();
 278 }
 279
 280 gfx::Size MessageListView::GetPreferredSize() const {
 281   int width = 0;
 282   for (int i = 0; i < child_count(); i++) {
 283     const views::View* child = child_at(i);
 284     if (IsValidChild(child))
 285       width = std::max(width, child->GetPreferredSize().width());
 286   }
 287
 288   return gfx::Size(width + GetInsets().width(),
 289                    GetHeightForWidth(width + GetInsets().width()));
 290 }
 291
 292 int MessageListView::GetHeightForWidth(int width) const {
 293   if (fixed_height_ > 0)
 294     return fixed_height_;
 295
 296   width -= GetInsets().width();
 297   int height = 0;
 298   int padding = 0;
 299   for (int i = 0; i < child_count(); ++i) {
 300     const views::View* child = child_at(i);
 301     if (!IsValidChild(child))
 302       continue;
 303     height += child->GetHeightForWidth(width) + padding;
 304     padding = kMarginBetweenItems - MessageView::GetShadowInsets().bottom();
 305   }
 306
 307   return height + GetInsets().height();
 308 }
 309
 310 void MessageListView::PaintChildren(gfx::Canvas* canvas,
 311                                     const views::CullSet& cull_set) {
 312   // Paint in the inversed order. Otherwise upper notification may be
 313   // hidden by the lower one.
 314   for (int i = child_count() - 1; i >= 0; --i) {
 315     if (!child_at(i)->layer())
 316       child_at(i)->Paint(canvas, cull_set);
 317   }
 318 }
 319
 320 void MessageListView::ReorderChildLayers(ui::Layer* parent_layer) {
 321   // Reorder children to stack the last child layer at the top. Otherwise
 322   // upper notification may be hidden by the lower one.
 323   for (int i = 0; i < child_count(); ++i) {
 324     if (child_at(i)->layer())
 325       parent_layer->StackAtBottom(child_at(i)->layer());
 326   }
 327 }
 328
 329 void MessageListView::SetRepositionTarget(const gfx::Rect& target) {
 330   reposition_top_ = target.y();
 331   fixed_height_ = GetHeightForWidth(width());
 332 }
 333
 334 void MessageListView::ResetRepositionSession() {
 335   // Don't call DoUpdateIfPossible(), but let Layout() do the task without
 336   // animation. Reset will cause the change of the bubble size itself, and
 337   // animation from the old location will look weird.
 338   if (reposition_top_ >= 0 && animator_.get()) {
 339     has_deferred_task_ = false;
 340     // cancel cause OnBoundsAnimatorDone which deletes |deleted_when_done_|.
 341     animator_->Cancel();
 342     STLDeleteContainerPointers(deleting_views_.begin(), deleting_views_.end());
 343     deleting_views_.clear();
 344     adding_views_.clear();
 345     animator_.reset();
 346   }
 347
 348   reposition_top_ = -1;
 349   fixed_height_ = 0;
 350 }
 351
 352 void MessageListView::ClearAllNotifications(
 353     const gfx::Rect& visible_scroll_rect) {
 354   for (int i = 0; i < child_count(); ++i) {
 355     views::View* child = child_at(i);
 356     if (!child->visible())
 357       continue;
 358     if (gfx::IntersectRects(child->bounds(), visible_scroll_rect).IsEmpty())
 359       continue;
 360     clearing_all_views_.push_back(child);
 361   }
 362   DoUpdateIfPossible();
 363 }
 364
 365 void MessageListView::OnBoundsAnimatorProgressed(
 366     views::BoundsAnimator* animator) {
 367   DCHECK_EQ(animator_.get(), animator);
 368   for (std::set<views::View*>::iterator iter = deleted_when_done_.begin();
 369        iter != deleted_when_done_.end(); ++iter) {
 370     const gfx::SlideAnimation* animation = animator->GetAnimationForView(*iter);
 371     if (animation)
 372       (*iter)->layer()->SetOpacity(animation->CurrentValueBetween(1.0, 0.0));
 373   }
 374 }
 375
 376 void MessageListView::OnBoundsAnimatorDone(views::BoundsAnimator* animator) {
 377   STLDeleteContainerPointers(
 378       deleted_when_done_.begin(), deleted_when_done_.end());
 379   deleted_when_done_.clear();
 380
 381   if (clear_all_started_) {
 382     clear_all_started_ = false;
 383     message_center_view()->OnAllNotificationsCleared();
 384   }
 385
 386   if (has_deferred_task_) {
 387     has_deferred_task_ = false;
 388     DoUpdateIfPossible();
 389   }
 390
 391   if (GetWidget())
 392     GetWidget()->SynthesizeMouseMoveEvent();
 393 }
 394
 395 bool MessageListView::IsValidChild(const views::View* child) const {
 396   return child->visible() &&
 397       deleting_views_.find(const_cast<views::View*>(child)) ==
 398           deleting_views_.end() &&
 399       deleted_when_done_.find(const_cast<views::View*>(child)) ==
 400           deleted_when_done_.end();
 401 }
 402
 403 void MessageListView::DoUpdateIfPossible() {
 404   gfx::Rect child_area = GetContentsBounds();
 405   if (child_area.IsEmpty())
 406     return;
 407
 408   if (animator_.get() && animator_->IsAnimating()) {
 409     has_deferred_task_ = true;
 410     return;
 411   }
 412
 413   if (!animator_.get()) {
 414     animator_.reset(new views::BoundsAnimator(this));
 415     animator_->AddObserver(this);
 416   }
 417
 418   if (!clearing_all_views_.empty()) {
 419     AnimateClearingOneNotification();
 420     return;
 421   }
 422
 423   if (top_down_ ||
 424       CommandLine::ForCurrentProcess()->HasSwitch(
 425           switches::kEnableMessageCenterAlwaysScrollUpUponNotificationRemoval))
 426     AnimateNotificationsBelowTarget();
 427   else
 428     AnimateNotificationsAboveTarget();
 429
 430   adding_views_.clear();
 431   deleting_views_.clear();
 432 }
 433
 434 void MessageListView::AnimateNotificationsBelowTarget() {
 435   int last_index = -1;
 436   for (int i = 0; i < child_count(); ++i) {
 437     views::View* child = child_at(i);
 438     if (!IsValidChild(child)) {
 439       AnimateChild(child, child->y(), child->height());
 440     } else if (reposition_top_ < 0 || child->y() > reposition_top_) {
 441       // Find first notification below target (or all notifications if no
 442       // target).
 443       last_index = i;
 444       break;
 445     }
 446   }
 447   if (last_index > 0) {
 448     int between_items =
 449         kMarginBetweenItems - MessageView::GetShadowInsets().bottom();
 450     int top = (reposition_top_ > 0) ? reposition_top_ : GetInsets().top();
 451
 452     for (int i = last_index; i < child_count(); ++i) {
 453       // Animate notifications below target upwards.
 454       views::View* child = child_at(i);
 455       if (AnimateChild(child, top, child->height()))
 456         top += child->height() + between_items;
 457     }
 458   }
 459 }
 460
 461 void MessageListView::AnimateNotificationsAboveTarget() {
 462   int last_index = -1;
 463   for (int i = child_count() - 1; i >= 0; --i) {
 464     views::View* child = child_at(i);
 465     if (!IsValidChild(child)) {
 466       AnimateChild(child, child->y(), child->height());
 467     } else if (reposition_top_ < 0 || child->y() < reposition_top_) {
 468       // Find first notification above target (or all notifications if no
 469       // target).
 470       last_index = i;
 471       break;
 472     }
 473   }
 474   if (last_index >= 0) {
 475     int between_items =
 476         kMarginBetweenItems - MessageView::GetShadowInsets().bottom();
 477     int bottom = (reposition_top_ > 0)
 478                      ? reposition_top_ + child_at(last_index)->height()
 479                      : GetHeightForWidth(width()) - GetInsets().bottom();
 480     for (int i = last_index; i >= 0; --i) {
 481       // Animate notifications above target downwards.
 482       views::View* child = child_at(i);
 483       if (AnimateChild(child, bottom - child->height(), child->height()))
 484         bottom -= child->height() + between_items;
 485     }
 486   }
 487 }
 488
 489 bool MessageListView::AnimateChild(views::View* child, int top, int height) {
 490   gfx::Rect child_area = GetContentsBounds();
 491   if (adding_views_.find(child) != adding_views_.end()) {
 492     child->SetBounds(child_area.right(), top, child_area.width(), height);
 493     animator_->AnimateViewTo(
 494         child, gfx::Rect(child_area.x(), top, child_area.width(), height));
 495   } else if (deleting_views_.find(child) != deleting_views_.end()) {
 496     DCHECK(child->layer());
 497     // No moves, but animate to fade-out.
 498     animator_->AnimateViewTo(child, child->bounds());
 499     deleted_when_done_.insert(child);
 500     return false;
 501   } else {
 502     gfx::Rect target(child_area.x(), top, child_area.width(), height);
 503     if (child->bounds().origin() != target.origin())
 504       animator_->AnimateViewTo(child, target);
 505     else
 506       child->SetBoundsRect(target);
 507   }
 508   return true;
 509 }
 510
 511 void MessageListView::AnimateClearingOneNotification() {
 512   DCHECK(!clearing_all_views_.empty());
 513
 514   clear_all_started_ = true;
 515
 516   views::View* child = clearing_all_views_.front();
 517   clearing_all_views_.pop_front();
 518
 519   // Slide from left to right.
 520   gfx::Rect new_bounds = child->bounds();
 521   new_bounds.set_x(new_bounds.right() + kMarginBetweenItems);
 522   animator_->AnimateViewTo(child, new_bounds);
 523
 524   // Schedule to start sliding out next notification after a short delay.
 525   if (!clearing_all_views_.empty()) {
 526     base::MessageLoop::current()->PostDelayedTask(
 527         FROM_HERE,
 528         base::Bind(&MessageListView::AnimateClearingOneNotification,
 529                    weak_ptr_factory_.GetWeakPtr()),
 530         base::TimeDelta::FromMilliseconds(
 531             kAnimateClearingNextNotificationDelayMS));
 532   }
 533 }
 534
 535 // MessageCenterView ///////////////////////////////////////////////////////////
 536
 537 MessageCenterView::MessageCenterView(MessageCenter* message_center,
 538                                      MessageCenterTray* tray,
 539                                      int max_height,
 540                                      bool initially_settings_visible,
 541                                      bool top_down,
 542                                      const base::string16& title)
 543     : message_center_(message_center),
 544       tray_(tray),
 545       scroller_(NULL),
 546       settings_view_(NULL),
 547       button_bar_(NULL),
 548       top_down_(top_down),
 549       settings_visible_(initially_settings_visible),
 550       source_view_(NULL),
 551       source_height_(0),
 552       target_view_(NULL),
 553       target_height_(0),
 554       is_closing_(false),
 555       context_menu_controller_(new MessageViewContextMenuController(this)) {
 556   message_center_->AddObserver(this);
 557   set_notify_enter_exit_on_child(true);
 558   set_background(views::Background::CreateSolidBackground(
 559       kMessageCenterBackgroundColor));
 560
 561   NotifierSettingsProvider* notifier_settings_provider =
 562       message_center_->GetNotifierSettingsProvider();
 563   button_bar_ = new MessageCenterButtonBar(this,
 564                                            message_center,
 565                                            notifier_settings_provider,
 566                                            initially_settings_visible,
 567                                            title);
 568
 569   const int button_height = button_bar_->GetPreferredSize().height();
 570
 571   scroller_ = new views::ScrollView();
 572   scroller_->ClipHeightTo(kMinScrollViewHeight, max_height - button_height);
 573   scroller_->SetVerticalScrollBar(new views::OverlayScrollBar(false));
 574   scroller_->set_background(
 575       views::Background::CreateSolidBackground(kMessageCenterBackgroundColor));
 576
 577   scroller_->SetPaintToLayer(true);
 578   scroller_->SetFillsBoundsOpaquely(false);
 579   scroller_->layer()->SetMasksToBounds(true);
 580
 581   empty_list_view_.reset(new NoNotificationMessageView);
 582   empty_list_view_->set_owned_by_client();
 583   message_list_view_.reset(new MessageListView(this, top_down));
 584   message_list_view_->set_owned_by_client();
 585
 586   // We want to swap the contents of the scroll view between the empty list
 587   // view and the message list view, without constructing them afresh each
 588   // time.  So, since the scroll view deletes old contents each time you
 589   // set the contents (regardless of the |owned_by_client_| setting) we need
 590   // an intermediate view for the contents whose children we can swap in and
 591   // out.
 592   views::View* scroller_contents = new views::View();
 593   scroller_contents->SetLayoutManager(new views::FillLayout());
 594   scroller_contents->AddChildView(empty_list_view_.get());
 595   scroller_->SetContents(scroller_contents);
 596
 597   settings_view_ = new NotifierSettingsView(notifier_settings_provider);
 598
 599   if (initially_settings_visible)
 600     scroller_->SetVisible(false);
 601   else
 602     settings_view_->SetVisible(false);
 603
 604   AddChildView(scroller_);
 605   AddChildView(settings_view_);
 606   AddChildView(button_bar_);
 607 }
 608
 609 MessageCenterView::~MessageCenterView() {
 610   if (!is_closing_)
 611     message_center_->RemoveObserver(this);
 612 }
 613
 614 void MessageCenterView::SetNotifications(
 615     const NotificationList::Notifications& notifications)  {
 616   if (is_closing_)
 617     return;
 618
 619   notification_views_.clear();
 620
 621   int index = 0;
 622   for (NotificationList::Notifications::const_iterator iter =
 623            notifications.begin(); iter != notifications.end(); ++iter) {
 624     AddNotificationAt(*(*iter), index++);
 625
 626     message_center_->DisplayedNotification(
 627         (*iter)->id(), message_center::DISPLAY_SOURCE_MESSAGE_CENTER);
 628     if (notification_views_.size() >= kMaxVisibleMessageCenterNotifications)
 629       break;
 630   }
 631
 632   NotificationsChanged();
 633   scroller_->RequestFocus();
 634 }
 635
 636 void MessageCenterView::SetSettingsVisible(bool visible) {
 637   if (is_closing_)
 638     return;
 639
 640   if (visible == settings_visible_)
 641     return;
 642
 643   settings_visible_ = visible;
 644
 645   if (visible) {
 646     source_view_ = scroller_;
 647     target_view_ = settings_view_;
 648   } else {
 649     source_view_ = settings_view_;
 650     target_view_ = scroller_;
 651   }
 652   source_height_ = source_view_->GetHeightForWidth(width());
 653   target_height_ = target_view_->GetHeightForWidth(width());
 654
 655   gfx::MultiAnimation::Parts parts;
 656   // First part: slide resize animation.
 657   parts.push_back(gfx::MultiAnimation::Part(
 658       (source_height_ == target_height_) ? 0 : kDefaultAnimationDurationMs,
 659       gfx::Tween::EASE_OUT));
 660   // Second part: fade-out the source_view.
 661   if (source_view_->layer()) {
 662     parts.push_back(gfx::MultiAnimation::Part(
 663         kDefaultAnimationDurationMs, gfx::Tween::LINEAR));
 664   } else {
 665     parts.push_back(gfx::MultiAnimation::Part());
 666   }
 667   // Third part: fade-in the target_view.
 668   if (target_view_->layer()) {
 669     parts.push_back(gfx::MultiAnimation::Part(
 670         kDefaultAnimationDurationMs, gfx::Tween::LINEAR));
 671     target_view_->layer()->SetOpacity(0);
 672     target_view_->SetVisible(true);
 673   } else {
 674     parts.push_back(gfx::MultiAnimation::Part());
 675   }
 676   settings_transition_animation_.reset(new gfx::MultiAnimation(
 677       parts, base::TimeDelta::FromMicroseconds(1000000 / kDefaultFrameRateHz)));
 678   settings_transition_animation_->set_delegate(this);
 679   settings_transition_animation_->set_continuous(false);
 680   settings_transition_animation_->Start();
 681
 682   button_bar_->SetBackArrowVisible(visible);
 683 }
 684
 685 void MessageCenterView::ClearAllNotifications() {
 686   if (is_closing_)
 687     return;
 688
 689   scroller_->SetEnabled(false);
 690   button_bar_->SetAllButtonsEnabled(false);
 691   message_list_view_->ClearAllNotifications(scroller_->GetVisibleRect());
 692 }
 693
 694 void MessageCenterView::OnAllNotificationsCleared() {
 695   scroller_->SetEnabled(true);
 696   button_bar_->SetAllButtonsEnabled(true);
 697   button_bar_->SetCloseAllButtonEnabled(false);
 698   message_center_->RemoveAllVisibleNotifications(true);  // Action by user.
 699 }
 700
 701 size_t MessageCenterView::NumMessageViewsForTest() const {
 702   return message_list_view_->child_count();
 703 }
 704
 705 void MessageCenterView::OnSettingsChanged() {
 706   scroller_->InvalidateLayout();
 707   PreferredSizeChanged();
 708   Layout();
 709 }
 710
 711 void MessageCenterView::SetIsClosing(bool is_closing) {
 712   is_closing_ = is_closing;
 713   if (is_closing)
 714     message_center_->RemoveObserver(this);
 715   else
 716     message_center_->AddObserver(this);
 717 }
 718
 719 void MessageCenterView::Layout() {
 720   if (is_closing_)
 721     return;
 722
 723   int button_height = button_bar_->GetHeightForWidth(width()) +
 724                       button_bar_->GetInsets().height();
 725   // Skip unnecessary re-layout of contents during the resize animation.
 726   bool animating = settings_transition_animation_ &&
 727                    settings_transition_animation_->is_animating();
 728   if (animating && settings_transition_animation_->current_part_index() == 0) {
 729     if (!top_down_) {
 730       button_bar_->SetBounds(
 731           0, height() - button_height, width(), button_height);
 732     }
 733     return;
 734   }
 735
 736   scroller_->SetBounds(0,
 737                        top_down_ ? button_height : 0,
 738                        width(),
 739                        height() - button_height);
 740   settings_view_->SetBounds(0,
 741                             top_down_ ? button_height : 0,
 742                             width(),
 743                             height() - button_height);
 744
 745   bool is_scrollable = false;
 746   if (scroller_->visible())
 747     is_scrollable = scroller_->height() < message_list_view_->height();
 748   else
 749     is_scrollable = settings_view_->IsScrollable();
 750
 751   if (!animating) {
 752     if (is_scrollable) {
 753       // Draw separator line on the top of the button bar if it is on the bottom
 754       // or draw it at the bottom if the bar is on the top.
 755       button_bar_->SetBorder(views::Border::CreateSolidSidedBorder(
 756           top_down_ ? 0 : 1, 0, top_down_ ? 1 : 0, 0, kFooterDelimiterColor));
 757     } else {
 758       button_bar_->SetBorder(views::Border::CreateEmptyBorder(
 759           top_down_ ? 0 : 1, 0, top_down_ ? 1 : 0, 0));
 760     }
 761     button_bar_->SchedulePaint();
 762   }
 763   button_bar_->SetBounds(0,
 764                          top_down_ ? 0 : height() - button_height,
 765                          width(),
 766                          button_height);
 767   if (GetWidget())
 768     GetWidget()->GetRootView()->SchedulePaint();
 769 }
 770
 771 gfx::Size MessageCenterView::GetPreferredSize() const {
 772   if (settings_transition_animation_ &&
 773       settings_transition_animation_->is_animating()) {
 774     int content_width = std::max(source_view_->GetPreferredSize().width(),
 775                                  target_view_->GetPreferredSize().width());
 776     int width = std::max(content_width,
 777                          button_bar_->GetPreferredSize().width());
 778     return gfx::Size(width, GetHeightForWidth(width));
 779   }
 780
 781   int width = 0;
 782   for (int i = 0; i < child_count(); ++i) {
 783     const views::View* child = child_at(0);
 784     if (child->visible())
 785       width = std::max(width, child->GetPreferredSize().width());
 786   }
 787   return gfx::Size(width, GetHeightForWidth(width));
 788 }
 789
 790 int MessageCenterView::GetHeightForWidth(int width) const {
 791   if (settings_transition_animation_ &&
 792       settings_transition_animation_->is_animating()) {
 793     int content_height = target_height_;
 794     if (settings_transition_animation_->current_part_index() == 0) {
 795       content_height = settings_transition_animation_->CurrentValueBetween(
 796           source_height_, target_height_);
 797     }
 798     return button_bar_->GetHeightForWidth(width) + content_height;
 799   }
 800
 801   int content_height = 0;
 802   if (scroller_->visible())
 803     content_height += scroller_->GetHeightForWidth(width);
 804   else
 805     content_height += settings_view_->GetHeightForWidth(width);
 806   return button_bar_->GetHeightForWidth(width) +
 807          button_bar_->GetInsets().height() + content_height;
 808 }
 809
 810 bool MessageCenterView::OnMouseWheel(const ui::MouseWheelEvent& event) {
 811   // Do not rely on the default scroll event handler of ScrollView because
 812   // the scroll happens only when the focus is on the ScrollView. The
 813   // notification center will allow the scrolling even when the focus is on
 814   // the buttons.
 815   if (scroller_->bounds().Contains(event.location()))
 816     return scroller_->OnMouseWheel(event);
 817   return views::View::OnMouseWheel(event);
 818 }
 819
 820 void MessageCenterView::OnMouseExited(const ui::MouseEvent& event) {
 821   if (is_closing_)
 822     return;
 823
 824   message_list_view_->ResetRepositionSession();
 825   NotificationsChanged();
 826 }
 827
 828 void MessageCenterView::OnNotificationAdded(const std::string& id) {
 829   int index = 0;
 830   const NotificationList::Notifications& notifications =
 831       message_center_->GetVisibleNotifications();
 832   for (NotificationList::Notifications::const_iterator iter =
 833            notifications.begin(); iter != notifications.end();
 834        ++iter, ++index) {
 835     if ((*iter)->id() == id) {
 836       AddNotificationAt(*(*iter), index);
 837       break;
 838     }
 839     if (notification_views_.size() >= kMaxVisibleMessageCenterNotifications)
 840       break;
 841   }
 842   NotificationsChanged();
 843 }
 844
 845 void MessageCenterView::OnNotificationRemoved(const std::string& id,
 846                                               bool by_user) {
 847   NotificationViewsMap::iterator view_iter = notification_views_.find(id);
 848   if (view_iter == notification_views_.end())
 849     return;
 850   NotificationView* view = view_iter->second;
 851   int index = message_list_view_->GetIndexOf(view);
 852   DCHECK_LE(0, index);
 853   if (by_user) {
 854     message_list_view_->SetRepositionTarget(view->bounds());
 855     // Moves the keyboard focus to the next notification if the removed
 856     // notification is focused so that the user can dismiss notifications
 857     // without re-focusing by tab key.
 858     if (view->IsCloseButtonFocused() ||
 859         view == GetFocusManager()->GetFocusedView()) {
 860       views::View* next_focused_view = NULL;
 861       if (message_list_view_->child_count() > index + 1)
 862         next_focused_view = message_list_view_->child_at(index + 1);
 863       else if (index > 0)
 864         next_focused_view = message_list_view_->child_at(index - 1);
 865
 866       if (next_focused_view) {
 867         if (view->IsCloseButtonFocused())
 868           // Safe cast since all views in MessageListView are MessageViews.
 869           static_cast<MessageView*>(
 870               next_focused_view)->RequestFocusOnCloseButton();
 871         else
 872           next_focused_view->RequestFocus();
 873       }
 874     }
 875   }
 876   message_list_view_->RemoveNotification(view);
 877   notification_views_.erase(view_iter);
 878   NotificationsChanged();
 879 }
 880
 881 void MessageCenterView::OnNotificationUpdated(const std::string& id) {
 882   NotificationViewsMap::const_iterator view_iter = notification_views_.find(id);
 883   if (view_iter == notification_views_.end())
 884     return;
 885   NotificationView* view = view_iter->second;
 886   // TODO(dimich): add MessageCenter::GetVisibleNotificationById(id)
 887   const NotificationList::Notifications& notifications =
 888       message_center_->GetVisibleNotifications();
 889   for (NotificationList::Notifications::const_iterator iter =
 890            notifications.begin(); iter != notifications.end(); ++iter) {
 891     if ((*iter)->id() == id) {
 892       int old_width = view->width();
 893       int old_height = view->GetHeightForWidth(old_width);
 894       message_list_view_->UpdateNotification(view, **iter);
 895       if (view->GetHeightForWidth(old_width) != old_height)
 896         NotificationsChanged();
 897       break;
 898     }
 899   }
 900 }
 901
 902 void MessageCenterView::ClickOnNotification(
 903     const std::string& notification_id) {
 904   message_center_->ClickOnNotification(notification_id);
 905 }
 906
 907 void MessageCenterView::RemoveNotification(const std::string& notification_id,
 908                                            bool by_user) {
 909   message_center_->RemoveNotification(notification_id, by_user);
 910 }
 911
 912 scoped_ptr<ui::MenuModel> MessageCenterView::CreateMenuModel(
 913     const NotifierId& notifier_id,
 914     const base::string16& display_source) {
 915   return tray_->CreateNotificationMenuModel(notifier_id, display_source);
 916 }
 917
 918 bool MessageCenterView::HasClickedListener(const std::string& notification_id) {
 919   return message_center_->HasClickedListener(notification_id);
 920 }
 921
 922 void MessageCenterView::ClickOnNotificationButton(
 923     const std::string& notification_id,
 924     int button_index) {
 925   message_center_->ClickOnNotificationButton(notification_id, button_index);
 926 }
 927
 928 void MessageCenterView::AnimationEnded(const gfx::Animation* animation) {
 929   DCHECK_EQ(animation, settings_transition_animation_.get());
 930
 931   Visibility visibility = target_view_ == settings_view_
 932                               ? VISIBILITY_SETTINGS
 933                               : VISIBILITY_MESSAGE_CENTER;
 934   message_center_->SetVisibility(visibility);
 935
 936   source_view_->SetVisible(false);
 937   target_view_->SetVisible(true);
 938   if (source_view_->layer())
 939     source_view_->layer()->SetOpacity(1.0);
 940   if (target_view_->layer())
 941     target_view_->layer()->SetOpacity(1.0);
 942   settings_transition_animation_.reset();
 943   PreferredSizeChanged();
 944   Layout();
 945 }
 946
 947 void MessageCenterView::AnimationProgressed(const gfx::Animation* animation) {
 948   DCHECK_EQ(animation, settings_transition_animation_.get());
 949   PreferredSizeChanged();
 950   if (settings_transition_animation_->current_part_index() == 1 &&
 951       source_view_->layer()) {
 952     source_view_->layer()->SetOpacity(
 953         1.0 - settings_transition_animation_->GetCurrentValue());
 954     SchedulePaint();
 955   } else if (settings_transition_animation_->current_part_index() == 2 &&
 956              target_view_->layer()) {
 957     target_view_->layer()->SetOpacity(
 958         settings_transition_animation_->GetCurrentValue());
 959     SchedulePaint();
 960   }
 961 }
 962
 963 void MessageCenterView::AnimationCanceled(const gfx::Animation* animation) {
 964   DCHECK_EQ(animation, settings_transition_animation_.get());
 965   AnimationEnded(animation);
 966 }
 967
 968 void MessageCenterView::AddNotificationAt(const Notification& notification,
 969                                           int index) {
 970   NotificationView* view =
 971       NotificationView::Create(this, notification, false);  // Not top-level.
 972   view->set_context_menu_controller(context_menu_controller_.get());
 973   notification_views_[notification.id()] = view;
 974   view->set_scroller(scroller_);
 975   message_list_view_->AddNotificationAt(view, index);
 976 }
 977
 978 void MessageCenterView::NotificationsChanged() {
 979   bool no_message_views = notification_views_.empty();
 980
 981   // When the child view is removed from the hierarchy, its focus is cleared.
 982   // In this case we want to save which view has focus so that the user can
 983   // continue to interact with notifications in the order they were expecting.
 984   views::FocusManager* focus_manager = scroller_->GetFocusManager();
 985   View* focused_view = NULL;
 986   // |focus_manager| can be NULL in tests.
 987   if (focus_manager)
 988     focused_view = focus_manager->GetFocusedView();
 989
 990   // All the children of this view are owned by |this|.
 991   scroller_->contents()->RemoveAllChildViews(/*delete_children=*/false);
 992   scroller_->contents()->AddChildView(
 993       no_message_views ? empty_list_view_.get() : message_list_view_.get());
 994
 995   button_bar_->SetCloseAllButtonEnabled(!no_message_views);
 996   scroller_->SetFocusable(!no_message_views);
 997
 998   if (focus_manager && focused_view)
 999     focus_manager->SetFocusedView(focused_view);
1000
1001   scroller_->InvalidateLayout();
1002   PreferredSizeChanged();
1003   Layout();
1004 }
1005
1006 void MessageCenterView::SetNotificationViewForTest(MessageView* view) {
1007   message_list_view_->AddNotificationAt(view, 0);
1008 }
1009
1010 }  // namespace message_center