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