Made notification center notifications collapsed and expandable.

ui/message_center/message_center_bubble.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/message_center/message_center_bubble.h"
 
+#include <map>
+
 #include "grit/ui_strings.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 #include "ui/gfx/text_constants.h"
@@ skipping 43 matching lines @@
 
   void set_close_all_button(views::Button* button) {
     close_all_button_ = button;
   }
 
  protected:
   NotificationList::Delegate* list_delegate() { return list_delegate_; }
   views::Button* close_all_button() { return close_all_button_; }
 
  private:
-  NotificationList::Delegate* list_delegate_;
+  NotificationList::Delegate* list_delegate_;  // Weak reference.
   views::Button* close_all_button_;
 
   DISALLOW_COPY_AND_ASSIGN(WebNotificationButtonViewBase);
 };
 
 // The view for the buttons at the bottom of the web notification tray.
 class WebNotificationButtonView : public WebNotificationButtonViewBase,
                                   public views::ButtonListener {
  public:
   explicit WebNotificationButtonView(NotificationList::Delegate* list_delegate)
@@ skipping 23 matching lines @@
     close_all_button->set_request_focus_on_press(false);
 
     layout->AddPaddingRow(0, 4);
     layout->StartRow(0, 0);
     layout->AddView(close_all_button);
     set_close_all_button(close_all_button);
   }
 
   virtual ~WebNotificationButtonView() {}
 
-  // Overridden from ButtonListener.
+  // Overridden from views::ButtonListener:
   virtual void ButtonPressed(views::Button* sender,
                              const ui::Event& event) OVERRIDE {
     if (sender == close_all_button())
       list_delegate()->SendRemoveAllNotifications(true);  // Action by user.
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebNotificationButtonView);
 };
 
 class WebNotificationButton : public views::TextButton {
  public:
   WebNotificationButton(views::ButtonListener* listener, const string16& text)
       : views::TextButton(listener, text) {
     set_border(views::Border::CreateEmptyBorder(0, 16, 0, 16));
     set_min_height(kFooterHeight);
     SetEnabledColor(kFooterTextColor);
     SetHighlightColor(kButtonTextHighlightColor);
     SetHoverColor(kButtonTextHoverColor);
   }
 
  protected:
-  // views::View overrides:
+  // Overridden from views::View:

[dharcourt, 2013/03/01 10:17:31]

I took this opportunity to make the override comments consistent in the
src/ui/message_view code. 75% of the /src/ui code uses the "// Overridden from
X" format and only 25% use the "// X overrides" one, so I shifted the dozen or
so uses of that later format to the former one. Now 80% of /src/ui use "//
Overridden from X:".

   virtual gfx::Size GetPreferredSize() OVERRIDE {
     // Returns an empty size when invisible, to trim its space in the parent's
     // GridLayout.
     if (!visible())
       return gfx::Size();
     return views::TextButton::GetPreferredSize();
   }
 
   virtual void OnPaintBorder(gfx::Canvas* canvas) OVERRIDE {
     // Just paint the left border.
@@ skipping 51 matching lines @@
     column->AddColumn(views::GridLayout::LEADING, views::GridLayout::FILL,
                       0, views::GridLayout::USE_PREF, 0, 0);
     layout->StartRow(0, 0);
     layout->AddView(notification_label_);
     layout->AddView(settings_button_);
     layout->AddView(close_all_button);
     set_close_all_button(close_all_button);
   }
 
  private:
-  // views::ButtonListener overrides:
+  // Overridden from views::ButtonListener:
   virtual void ButtonPressed(views::Button* sender,
                              const ui::Event& event) OVERRIDE {
     if (sender == close_all_button())
       list_delegate()->SendRemoveAllNotifications(true);  // Action by user.
     else if (sender == settings_button_)
       list_delegate()->ShowNotificationSettingsDialog(
           GetWidget()->GetNativeView());
     else
       NOTREACHED();
   }
 
   views::Label* notification_label_;
   views::Button* settings_button_;
 
   DISALLOW_COPY_AND_ASSIGN(WebNotificationButtonView2);
 };
 
-// A custom scroll-view that has a specified size.
-class FixedSizedScrollView : public views::ScrollView {
+// A custom scroll view whose height has a minimum and maximum value and whose
+// scroll bar disappears when not needed.
+class BoundedScrollView : public views::ScrollView {
  public:
-  FixedSizedScrollView() {
+  BoundedScrollView(int min_height, int max_height)
+      : min_height_(min_height),
+        max_height_(max_height) {
     set_focusable(true);
     set_notify_enter_exit_on_child(true);
     if (IsRichNotificationEnabled()) {
       set_background(views::Background::CreateSolidBackground(
           kMessageCenterBackgroundColor));
     }
   }
 
-  virtual ~FixedSizedScrollView() {}
+  virtual ~BoundedScrollView() {}
 
-  void SetFixedSize(const gfx::Size& size) {
-    if (fixed_size_ == size)
-      return;
-    fixed_size_ = size;
-    PreferredSizeChanged();
-  }
-
-  // views::View overrides.
+  // Overridden from views::View:
   virtual gfx::Size GetPreferredSize() OVERRIDE {
-    gfx::Size size = fixed_size_.IsEmpty() ?
-        contents()->GetPreferredSize() : fixed_size_;
+    gfx::Size size = contents()->GetPreferredSize();
+    size.ClampToMin(gfx::Size(size.width(), min_height_));
+    size.ClampToMax(gfx::Size(size.width(), max_height_));
     gfx::Insets insets = GetInsets();
     size.Enlarge(insets.width(), insets.height());
     return size;
   }
 
   virtual void Layout() OVERRIDE {
-    gfx::Rect bounds = gfx::Rect(contents()->GetPreferredSize());
-    bounds.set_width(std::max(0, width() - GetScrollBarWidth()));
-    contents()->SetBoundsRect(bounds);
+    // Lay out the view as if it will have a scroll bar.
+    gfx::Rect content_bounds = gfx::Rect(contents()->GetPreferredSize());
+    content_bounds.set_width(std::max(0, width() - GetScrollBarWidth()));
+    contents()->SetBoundsRect(content_bounds);
+    views::ScrollView::Layout();
 
-    views::ScrollView::Layout();
+    // But use the scroll bar space if no scroll bar is needed.
     if (!vertical_scroll_bar()->visible()) {
-      gfx::Rect bounds = contents()->bounds();
-      bounds.set_width(bounds.width() + GetScrollBarWidth());
-      contents()->SetBoundsRect(bounds);
+      content_bounds = contents()->bounds();
+      content_bounds.set_width(content_bounds.width() + GetScrollBarWidth());
+      contents()->SetBoundsRect(content_bounds);
     }
   }
 
   virtual void OnBoundsChanged(const gfx::Rect& previous_bounds) OVERRIDE {
-    gfx::Rect bounds = gfx::Rect(contents()->GetPreferredSize());
-    bounds.set_width(std::max(0, width() - GetScrollBarWidth()));
-    contents()->SetBoundsRect(bounds);
+    // Make sure any content resizing takes into account the scroll bar.
+    gfx::Rect content_bounds = gfx::Rect(contents()->GetPreferredSize());
+    content_bounds.set_width(std::max(0, width() - GetScrollBarWidth()));
+    contents()->SetBoundsRect(content_bounds);
   }
 
  private:
-  gfx::Size fixed_size_;
+  int min_height_;
+  int max_height_;
 
-  DISALLOW_COPY_AND_ASSIGN(FixedSizedScrollView);
+  DISALLOW_COPY_AND_ASSIGN(BoundedScrollView);
 };
 
-// Container for the messages.
-class ScrollContentView : public views::View {
+// Displays a list of messages.
+class MessageListView : public views::View {
  public:
-  ScrollContentView() {
+  MessageListView() {
     if (IsRichNotificationEnabled()) {
       // Set the margin to 0 for the layout. BoxLayout assumes the same margin
       // for top and bottom, but the bottom margin here should be smaller
       // because of the shadow of message view. Use an empty border instead
       // to provide this margin.
       gfx::Insets shadow_insets = MessageView::GetShadowInsets();
       SetLayoutManager(
           new views::BoxLayout(views::BoxLayout::kVertical,
                                0,
                                0,
                                kMarginBetweenItems - shadow_insets.bottom()));
       set_background(views::Background::CreateSolidBackground(
           kMessageCenterBackgroundColor));
       set_border(views::Border::CreateEmptyBorder(
           kMarginBetweenItems - shadow_insets.top(), /* top */
           kMarginBetweenItems - shadow_insets.left(), /* left */
           0,  /* bottom */
           kMarginBetweenItems - shadow_insets.right() /* right */ ));
     } else {
       views::BoxLayout* layout =
           new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 1);
       layout->set_spread_blank_space(true);
       SetLayoutManager(layout);
     }
   }
 
-  virtual ~ScrollContentView() {
+  virtual ~MessageListView() {
   }
 
-  virtual gfx::Size GetPreferredSize() OVERRIDE {
-    if (!preferred_size_.IsEmpty())
-      return preferred_size_;
-    return views::View::GetPreferredSize();
-  }
-
-  void set_preferred_size(const gfx::Size& size) { preferred_size_ = size; }
-
  private:
-  gfx::Size preferred_size_;
-  DISALLOW_COPY_AND_ASSIGN(ScrollContentView);
+  DISALLOW_COPY_AND_ASSIGN(MessageListView);
 };
 
 }  // namespace
 
-// Message Center contents.
-class MessageCenterContentsView : public views::View {
+// View that displays the whole message center.
+class MessageCenterView : public views::View {
  public:
-  explicit MessageCenterContentsView(MessageCenterBubble* bubble,
-                                     NotificationList::Delegate* list_delegate)
-      : list_delegate_(list_delegate),
-        bubble_(bubble) {
+  MessageCenterView(MessageCenterBubble* bubble) : bubble_(bubble) {
     int between_child = IsRichNotificationEnabled() ? 0 : 1;
     SetLayoutManager(
         new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, between_child));
 
-    scroll_content_ = new ScrollContentView;
-    scroller_ = new FixedSizedScrollView;
-    scroller_->SetContents(scroll_content_);
-    AddChildView(scroller_);
+
+    if (IsRichNotificationEnabled())
+      button_view_ = new WebNotificationButtonView2(bubble_);
+    else
+      button_view_ = new WebNotificationButtonView(bubble_);
+
+    const int button_height = button_view_->GetPreferredSize().height();
+    const int min_height = kMessageBubbleBaseMinHeight - button_height;
+    const int max_height = bubble_->max_height() - button_height;
+    scroller_ = new BoundedScrollView(min_height, max_height);
 
     if (get_use_acceleration_when_possible()) {
       scroller_->SetPaintToLayer(true);
       scroller_->SetFillsBoundsOpaquely(false);
       scroller_->layer()->SetMasksToBounds(true);
     }
 
-    if (IsRichNotificationEnabled())
-      button_view_ = new WebNotificationButtonView2(list_delegate);
-    else
-      button_view_ = new WebNotificationButtonView(list_delegate);
+    message_list_view_ = new MessageListView();
+    scroller_->SetContents(message_list_view_);
+
+    AddChildView(scroller_);
     AddChildView(button_view_);
   }
 
   void FocusContents() {
     scroller_->RequestFocus();
   }
 
-  void Update(const NotificationList::Notifications& notifications)  {
-    scroll_content_->RemoveAllChildViews(true);
-    scroll_content_->set_preferred_size(gfx::Size());
-    size_t num_children = 0;
+  void UpdateAllNotifications(
+      const NotificationList::Notifications& notifications)  {
+    RemoveAllNotifications();
     for (NotificationList::Notifications::const_iterator iter =
              notifications.begin(); iter != notifications.end(); ++iter) {
-      MessageView* view = NotificationView::Create(*(*iter), list_delegate_);
-      view->set_scroller(scroller_);
-      scroll_content_->AddChildView(view);
-      if (++num_children >=
+      AddNotification(*(*iter));
+      if (message_views_.size() >=
           NotificationList::kMaxVisibleMessageCenterNotifications) {
         break;
       }
     }
-    if (num_children == 0) {
+    if (message_views_.empty()) {
       views::Label* label = new views::Label(l10n_util::GetStringUTF16(
           IDS_MESSAGE_CENTER_NO_MESSAGES));
       label->SetFont(label->font().DeriveFont(1));
       label->SetEnabledColor(SK_ColorGRAY);
       // Set transparent background to ensure that subpixel rendering
       // is disabled. See crbug.com/169056
       label->SetBackgroundColor(kTransparentColor);
-      scroll_content_->AddChildView(label);
+      message_list_view_->AddChildView(label);
       button_view_->SetCloseAllVisible(false);
       scroller_->set_focusable(false);
     } else {
       button_view_->SetCloseAllVisible(true);
       scroller_->set_focusable(true);
     }
-    SizeScrollContent();
     Layout();
-    if (GetWidget())
-      GetWidget()->GetRootView()->SchedulePaint();
+  }
+
+  void UpdateOneNotification(const Notification& notification) {
+    // Update the corresponding message view if there is one and explicitly
+    // update this view's layout as this is not automatic in spite of the
+    // updated view's likely size change because ScrollView's Viewport breaks
+    // the ChildPreferredSizeChange() chain.
+    MessageView* view = message_views_[notification.id()];
+    if (view) {
+      view->Update(notification);
+      Layout();
+    }
   }
 
   size_t NumMessageViews() const {
-    return scroll_content_->child_count();
+    return message_list_view_->child_count();
+  }
+
+ protected:
+  // Overridden from views::View:
+  virtual void Layout() OVERRIDE {
+      scroller_->SizeToPreferredSize();
+    views::View::Layout();
+    if (GetWidget())
+      GetWidget()->GetRootView()->SchedulePaint();
+    bubble_->bubble_view()->UpdateBubble();
   }
 
  private:
-  void SizeScrollContent() {
-    gfx::Size scroll_size = scroll_content_->GetPreferredSize();
-    const int button_height = button_view_->GetPreferredSize().height();
-    const int min_height = kMessageBubbleBaseMinHeight - button_height;
-    const int max_height = bubble_->max_height() - button_height;
-    int scroll_height = std::min(std::max(
-        scroll_size.height(), min_height), max_height);
-    scroll_size.set_height(scroll_height);
-    if (scroll_height == min_height)
-      scroll_content_->set_preferred_size(scroll_size);
-    else
-      scroll_content_->set_preferred_size(gfx::Size());
-    scroller_->SetFixedSize(scroll_size);
-    scroller_->SizeToPreferredSize();
-    scroll_content_->InvalidateLayout();
+
+  void RemoveAllNotifications() {
+    message_views_.clear();
+    message_list_view_->RemoveAllChildViews(true);
   }
 
-  NotificationList::Delegate* list_delegate_;
-  FixedSizedScrollView* scroller_;
-  ScrollContentView* scroll_content_;
+  void AddNotification(const Notification& notification) {
+    // Always expand the first (topmost) notification.
+    bool expand = (notification.is_expanded() || message_views_.empty());
+    MessageView* view = NotificationView::Create(notification, bubble_, expand);
+    view->set_scroller(scroller_);
+    message_views_[notification.id()] = view;
+    message_list_view_->AddChildView(view);
+  }
+
+  MessageCenterBubble* bubble_;  // Weak reference.
+  std::map<std::string,MessageView*> message_views_;
+  BoundedScrollView* scroller_;
+  MessageListView* message_list_view_;
   WebNotificationButtonViewBase* button_view_;
-  MessageCenterBubble* bubble_;
 
-  DISALLOW_COPY_AND_ASSIGN(MessageCenterContentsView);
+  DISALLOW_COPY_AND_ASSIGN(MessageCenterView);
 };
 
 // Message Center Bubble.
-MessageCenterBubble::MessageCenterBubble(NotificationList::Delegate* delegate)
-    : MessageBubbleBase(delegate),
+MessageCenterBubble::MessageCenterBubble(MessageCenter* message_center)
+    : MessageBubbleBase(message_center),
       contents_view_(NULL) {
 }
 
 MessageCenterBubble::~MessageCenterBubble() {}
 
 views::TrayBubbleView::InitParams MessageCenterBubble::GetInitParams(
     views::TrayBubbleView::AnchorAlignment anchor_alignment) {
   views::TrayBubbleView::InitParams init_params =
       GetDefaultInitParams(anchor_alignment);
   if (IsRichNotificationEnabled()) {
     init_params.min_width += kMarginBetweenItems * 2;
     init_params.max_width += kMarginBetweenItems * 2;
   }
   init_params.max_height = max_height();
   init_params.can_activate = true;
   return init_params;
 }
 
 void MessageCenterBubble::InitializeContents(
     views::TrayBubbleView* new_bubble_view) {
   set_bubble_view(new_bubble_view);
-  contents_view_ = new MessageCenterContentsView(this, list_delegate());
+  contents_view_ = new MessageCenterView(this);
   bubble_view()->AddChildView(contents_view_);
   // Resize the content of the bubble view to the given bubble size. This is
   // necessary in case of the bubble border forcing a bigger size then the
   // |new_bubble_view| actually wants. See crbug.com/169390.
   bubble_view()->Layout();
   UpdateBubbleView();
   contents_view_->FocusContents();
 }
 
 void MessageCenterBubble::OnBubbleViewDestroyed() {
   contents_view_ = NULL;
 }
 
 void MessageCenterBubble::UpdateBubbleView() {
   if (!bubble_view())
     return;  // Could get called after view is closed
   const NotificationList::Notifications& notifications =
-      list_delegate()->GetNotificationList()->GetNotifications();
-  contents_view_->Update(notifications);
+      message_center()->notification_list()->GetNotifications();
+  contents_view_->UpdateAllNotifications(notifications);
   bubble_view()->Show();
   bubble_view()->UpdateBubble();
 }
 
 void MessageCenterBubble::OnMouseEnteredView() {
 }
 
 void MessageCenterBubble::OnMouseExitedView() {
 }
 
+void MessageCenterBubble::SendRemoveNotification(const std::string& id,
+                                                 bool by_user) {
+  message_center()->SendRemoveNotification(id, by_user);
+}
+
+void MessageCenterBubble::SendRemoveAllNotifications(bool by_user) {
+  message_center()->SendRemoveAllNotifications(by_user);
+}
+
+void MessageCenterBubble::DisableNotificationByExtension(
+    const std::string& id) {
+  message_center()->DisableNotificationByExtension(id);
+}
+
+void MessageCenterBubble::DisableNotificationByUrl(const std::string& id) {
+  message_center()->DisableNotificationByUrl(id);
+}
+
+void MessageCenterBubble::ShowNotificationSettings(const std::string& id) {
+  message_center()->ShowNotificationSettings(id);
+}
+
+void MessageCenterBubble::ShowNotificationSettingsDialog(
+    gfx::NativeView context) {
+  message_center()->ShowNotificationSettingsDialog(context);
+}
+
+void MessageCenterBubble::OnNotificationClicked(const std::string& id) {
+  message_center()->OnNotificationClicked(id);
+}
+
+void MessageCenterBubble::OnButtonClicked(const std::string& id,
+                                          int button_index) {
+  message_center()->OnButtonClicked(id, button_index);
+}
+
+void MessageCenterBubble::OnExpand(const std::string& id) {
+  message_center()->OnExpand(id);
+
+  // Update the view corresponding to this notification.
+  const NotificationList::Notifications& notifications =
+      message_center()->notification_list()->GetNotifications();
+  for (NotificationList::Notifications::const_iterator iter =
+           notifications.begin(); iter != notifications.end(); ++iter) {
+    if ((*iter)->id() == id) {
+      contents_view_->UpdateOneNotification(*(*iter));
+      break;
+    }
+  }
+}
+
+void MessageCenterBubble::OnQuietModeChanged(bool quiet_mode) {
+  message_center()->OnQuietModeChanged(quiet_mode);
+}
+

[dharcourt, 2013/03/02 02:08:02]

This isn't now only in NotificationList::Delegate and not needed for
NotificationChangeDelegate so it doesn't need to be implemented here any more.

 size_t MessageCenterBubble::NumMessageViewsForTest() const {
   return contents_view_->NumMessageViews();
 }
 
 }  // namespace message_center