Made notification center notifications collapsed and expandable.

ui/message_center/notification_view.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/notification_view.h"
 
 #include "base/command_line.h"
 #include "base/utf_string_conversions.h"
 #include "grit/ui_resources.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/text/text_elider.h"
+#include "ui/gfx/canvas.h"
 #include "ui/gfx/size.h"
 #include "ui/message_center/message_center_constants.h"
 #include "ui/message_center/message_center_switches.h"
 #include "ui/message_center/message_simple_view.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/layout/fill_layout.h"
@@ skipping 27 matching lines @@
 // Static function to create an empty border to be used as padding.
 views::Border* MakePadding(int top, int left, int bottom, int right) {
   return views::Border::CreateEmptyBorder(top, left, bottom, right);
 }
 
 // Static function to create an empty border to be used as padding.
 views::Background* MakeBackground(SkColor color) {
   return views::Background::CreateSolidBackground(color);
 }
 
+// ContentViews just propagate their children's preferred size changes.
+class ContentView : public views::View {
+ public:
+  ContentView();
+  virtual ~ContentView();
+
+  // Overridden from views::View.
+  virtual void ChildPreferredSizeChanged(views::View* child) OVERRIDE;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ContentView);
+};
+
+ContentView::ContentView() {
+}
+
+ContentView::~ContentView() {
+}
+
+void ContentView::ChildPreferredSizeChanged(views::View* child) {
+  PreferredSizeChanged();
+}
+
 // ItemViews are responsible for drawing each list notification item's title and
 // message next to each other within a single column.
 class ItemView : public views::View {
  public:
   ItemView(const message_center::NotificationItem& item);
   virtual ~ItemView();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ItemView);
 };
@@ skipping 16 matching lines @@
   message->SetBackgroundColor(kMessageBackgroundColor);
   AddChildView(message);
 
   PreferredSizeChanged();
   SchedulePaint();
 }
 
 ItemView::~ItemView() {
 }
 
-// ProportionalImageViews match their heights to their widths to preserve the
-// proportions of their images.
+// ProportionalImageViews center their images to preserve their proportion.
+// Note that for this subclass of views::ImageView GetImageBounds() will return
+// potentially incorrect values (this can't be fixed because GetImageBounds()
+// is not virtual) and horizontal and vertical alignments will be ignored.
 class ProportionalImageView : public views::ImageView {
  public:
   ProportionalImageView();
   virtual ~ProportionalImageView();
 
   // Overridden from views::View.
   virtual int GetHeightForWidth(int width) OVERRIDE;
+  virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
 
  private:
+  gfx::Size GetImageSizeForWidth(int width);
+
   DISALLOW_COPY_AND_ASSIGN(ProportionalImageView);
 };
 
 ProportionalImageView::ProportionalImageView() {
 }
 
 ProportionalImageView::~ProportionalImageView() {
 }
 
 int ProportionalImageView::GetHeightForWidth(int width) {
-  int height = 0;
-  gfx::ImageSkia image = GetImage();
-  if (image.width() > 0 && image.height() > 0) {
-    double proportion = image.height() / (double) image.width();
-    height = 0.5 + width * proportion;
-    if (height > message_center::kNotificationMaximumImageHeight) {
-      height = message_center::kNotificationMaximumImageHeight;
-      width = 0.5 + height / proportion;
+  return GetImageSizeForWidth(width).height();
+}

[dharcourt, 2013/02/23 04:32:00]

SetImageSize() needed to be removed from GetImageSizeForWidth() because it set
up a GetImageSizeForWidth() -> SetImageSize() -> PreferredSizeChanged() ->
ChildPreferredSizeChanged() -> Layout() -> GetImageSizeForWith() infinite loop.
Breaking this loop required the image sizing logic to be moved to the OnPaint()
method below.

+
+void ProportionalImageView::OnPaint(gfx::Canvas* canvas) {
+  View::OnPaint(canvas);
+
+  gfx::Size draw_size(GetImageSizeForWidth(width()));
+  if (!draw_size.IsEmpty()) {
+    int x = (width() - draw_size.width()) / 2;
+    int y = (height() - draw_size.height()) / 2;
+
+    gfx::Size image_size(GetImage().size());
+    if (image_size == draw_size) {
+      canvas->DrawImageInt(GetImage(), x, y);
+    } else {
+      // Resize case
+      SkPaint paint;
+      paint.setFilterBitmap(true);
+      canvas->DrawImageInt(GetImage(), 0, 0,
+                           image_size.width(), image_size.height(), x, y,
+                           draw_size.width(), draw_size.height(), true, paint);
     }
-    SetImageSize(gfx::Size(width, height));
   }
-  return height;
+}
+
+gfx::Size ProportionalImageView::GetImageSizeForWidth(int width) {
+  gfx::Size size(GetImage().size());
+  if (width > 0 && !size.IsEmpty()) {
+    double proportion = size.height() / (double) size.width();
+    size.SetSize(width, std::max(0.5 + width * proportion, 1.0));
+    if (size.height() > message_center::kNotificationMaximumImageHeight) {
+      int height = message_center::kNotificationMaximumImageHeight;
+      size.SetSize(std::max(0.5 + height / proportion, 1.0), height);
+    }
+  }
+  return size;
 }
 
 // NotificationsButtons render the action buttons of notifications.
 class NotificationButton : public views::CustomButton {
  public:
   NotificationButton(views::ButtonListener* listener);
   virtual ~NotificationButton();
 
   void SetIcon(const gfx::ImageSkia& icon);
   void SetTitle(const string16& title);
@@ skipping 82 matching lines @@
       // functionality.
       LOG(WARNING) << "Unable to fulfill request for unrecognized "
                    << "notification type " << notification.type << ". "
                    << "Falling back to simple notification type.";
   }
 
   // Currently all roads lead to the generic NotificationView.
   return new NotificationView(list_delegate, notification);
 }
 
-NotificationView::NotificationView(
-    NotificationList::Delegate* list_delegate,
-    const Notification& notification)
-    : MessageView(list_delegate, notification) {
+NotificationView::NotificationView(NotificationList::Delegate* list_delegate,
+                                   const Notification& notification)
+    : MessageView(list_delegate, notification),
+      content_view_(NULL),
+      icon_view_(NULL) {
 }
 
 NotificationView::~NotificationView() {
 }
 
 void NotificationView::Layout() {
-  if (content_view_) {
-    gfx::Rect contents_bounds = GetContentsBounds();
-    content_view_->SetBoundsRect(contents_bounds);
-    if (close_button()) {
-      gfx::Size size(close_button()->GetPreferredSize());
-      close_button()->SetBounds(contents_bounds.right() - size.width(), 0,
-                                size.width(), size.height());
+  // Create the child views if necessary. Those are in two layers: The first
+  // layer has the notification content (text, images, action buttons, ...).
+  // This is overlaid by a second layer that has the notification close and
+  // expand buttons. This allows the close and expand buttons to overlap the
+  // content as needed to provide a large enough click area
+  // (<http://crbug.com/168822> and touch area <http://crbug.com/168856>).
+  if (!content_view_) {
+    AddChildView(MakeContentView());
+    AddChildView(close_button());
+    if (!IsExpanded()) {
+      AddChildView(expand_button());
     }
   }
+
+  gfx::Rect content_bounds(GetLocalBounds());
+  content_bounds.Inset(GetInsets());
+  content_view_->SetBoundsRect(content_bounds);
+
+  gfx::Size close_size(close_button()->GetPreferredSize());
+  close_button()->SetBounds(content_bounds.right() - close_size.width(),
+                            content_bounds.y(),
+                            close_size.width(),
+                            close_size.height());
+
+  gfx::Rect icon_bounds(content_bounds.origin(), icon_view_->size());
+  gfx::Size expand_size(expand_button()->GetPreferredSize());
+  expand_button()->SetBounds(content_bounds.right() - expand_size.width(),
+                             icon_bounds.bottom() - expand_size.height(),
+                             expand_size.width(),
+                             expand_size.height());
 }
 
 gfx::Size NotificationView::GetPreferredSize() {
-  if (!content_view_)
-    return gfx::Size();
-  gfx::Size size = content_view_->GetPreferredSize();
-  if (border()) {
-    gfx::Insets border_insets = border()->GetInsets();
-    size.Enlarge(border_insets.width(), border_insets.height());
+  gfx::Size size;
+  if (content_view_) {
+    size = content_view_->GetPreferredSize();
+    if (border()) {
+      gfx::Insets insets = border()->GetInsets();
+      size.Enlarge(insets.width(), insets.height());
+    }
   }
   return size;

[dharcourt, 2013/02/23 04:32:00]

Having a return gfx::Size() in the middle of this method made logging a pain
during debugging, so I changed it to have a single return statement. It also
made the method 18 characters shorter :-).

 }
 
-void NotificationView::SetUpView() {
-  // This view is composed of two layers: The first layer has the notification
-  // content (text, images, action buttons, ...). This is overlaid by a second
-  // layer that has the notification close button and will later also have the
-  // expand button. This allows the close and expand buttons to overlap the
-  // content as needed to provide a large enough click area
-  // (<http://crbug.com/168822> and touch area <http://crbug.com/168856>).
-  AddChildView(MakeContentView());
-  AddChildView(close_button());
+void NotificationView::ChildPreferredSizeChanged(views::View* child) {
+  PreferredSizeChanged();
+}
+
+void NotificationView::SetExpanded(bool expanded) {
+  if (expanded != IsExpanded()) {
+    MessageView::SetExpanded(expanded);
+    content_view_ = NULL;
+    icon_view_ = NULL;
+    action_buttons_.clear();
+    RemoveAllChildViews(true);
+    PreferredSizeChanged();
+    SchedulePaint();
+  }
 }
 
 void NotificationView::ButtonPressed(views::Button* sender,
                                      const ui::Event& event) {
   for (size_t i = 0; i < action_buttons_.size(); ++i) {
-    if (action_buttons_[i] == sender) {
+    if (sender == action_buttons_[i]) {
       list_delegate()->OnButtonClicked(notification().id, i);
       return;
     }
   }
   MessageView::ButtonPressed(sender, event);
 }
 
 views::View* NotificationView::MakeContentView() {
-  content_view_ = new views::View();
+  content_view_ = new ContentView();
   content_view_->set_background(
       views::Background::CreateSolidBackground(kBackgroundColor));
 
   // The top part of the content view is composed of an icon view on the left
   // and a certain number of text views on the right (title and message or list
   // items), followed by a padding view. Laying out the icon view will require
   // information about the text views, so these are created first and collected
   // in this vector.
-  std::vector<views::View*> texts;
+  std::vector<views::View*> text_views;
 
   // Title if it exists.
   if (!notification().title.empty()) {
     views::Label* title = new views::Label(notification().title);
     title->SetHorizontalAlignment(gfx::ALIGN_LEFT);
-    title->SetElideBehavior(views::Label::ELIDE_AT_END);
+    if (IsExpanded())
+      title->SetMultiLine(true);
+    else
+      title->SetElideBehavior(views::Label::ELIDE_AT_END);
     title->SetFont(title->font().DeriveFont(4));
     title->SetEnabledColor(kTitleColor);
     title->SetBackgroundColor(kTitleBackgroundColor);
     title->set_border(MakePadding(kTextTopPadding, 0, 3, kTextRightPadding));
-    texts.push_back(title);
+    text_views.push_back(title);
+  }
+
+  // List notification items up to a maximum if appropriate.
+  int items = static_cast<int>(notification().items.size());
+  items = std::min(items, IsExpanded() ? kNotificationMaximumItems : 0);

[Jun Mukai, 2013/02/26 02:23:30]

as I wrote in _constants.h, I prefer to keep size_t here.
size_t items = ...size();
items = std::min(items, IsExpanded() ? ... : 0ul);

would work well.

[dharcourt, 2013/02/26 03:23:30]

Done.

+  for (int i = 0; i < items; ++i) {
+    ItemView* item = new ItemView(notification().items[i]);
+    item->set_border(MakePadding(0, 0, 4, kTextRightPadding));
+    text_views.push_back(item);
   }

[dharcourt, 2013/02/23 04:32:00]

Item display had to be moved up here so the displayed-item-count could be used
to determine below whether to display the message (the message should be
displayed even when the notification is expanded if it has no items).

 
   // Message if appropriate.
-  if (notification().items.size() == 0 && !notification().message.empty()) {
+  if (items == 0 && !notification().message.empty()) {
     views::Label* message = new views::Label(notification().message);
     message->SetHorizontalAlignment(gfx::ALIGN_LEFT);
-    message->SetMultiLine(true);
+    if (IsExpanded())
+      message->SetMultiLine(true);
+    else
+      message->SetElideBehavior(views::Label::ELIDE_AT_END);
     message->SetEnabledColor(kMessageColor);
     message->SetBackgroundColor(kMessageBackgroundColor);
     message->set_border(MakePadding(0, 0, 3, kTextRightPadding));
-    texts.push_back(message);
-  }
-
-  // List notification items up to a maximum.
-  int items = std::min(notification().items.size(), kNotificationMaximumItems);
-  for (int i = 0; i < items; ++i) {
-    ItemView* item = new ItemView(notification().items[i]);
-    item->set_border(MakePadding(0, 0, 4, kTextRightPadding));
-    texts.push_back(item);
+    text_views.push_back(message);
   }
 
   // Set up the content view with a fixed-width icon column on the left and a
   // text column on the right that consumes the remaining space. To minimize the
   // number of columns and simplify column spanning, padding is applied to each
   // view within columns instead of through padding columns.
   views::GridLayout* layout = new views::GridLayout(content_view_);
   content_view_->SetLayoutManager(layout);
   views::ColumnSet* columns = layout->AddColumnSet(0);
   columns->AddColumn(views::GridLayout::FILL, views::GridLayout::FILL,
                      0, views::GridLayout::FIXED,
                      kIconColumnWidth + kIconToTextPadding,
                      kIconColumnWidth + kIconToTextPadding);
                      // Padding + icon + padding.
   columns->AddColumn(views::GridLayout::FILL, views::GridLayout::FILL,
                      100, views::GridLayout::USE_PREF, 0, 0);
                      // Text + padding.
 
   // Create the first row and its icon view, which spans all the text views
   // to its right as well as the padding view below them.
   layout->StartRow(0, 0);
-  views::ImageView* icon = new views::ImageView();
-  icon->SetImageSize(gfx::Size(message_center::kNotificationIconSize,
-                               message_center::kNotificationIconSize));
-  icon->SetImage(notification().primary_icon);
-  icon->SetHorizontalAlignment(views::ImageView::LEADING);
-  icon->SetVerticalAlignment(views::ImageView::LEADING);
-  icon->set_border(MakePadding(0, 0, 0, kIconToTextPadding));
-  layout->AddView(icon, 1, texts.size() + 1);
+  icon_view_ = new views::ImageView();
+  icon_view_->SetImageSize(gfx::Size(message_center::kNotificationIconSize,
+                                     message_center::kNotificationIconSize));
+  icon_view_->SetImage(notification().primary_icon);
+  icon_view_->SetHorizontalAlignment(views::ImageView::LEADING);
+  icon_view_->SetVerticalAlignment(views::ImageView::LEADING);
+  icon_view_->set_border(MakePadding(0, 0, 0, kIconToTextPadding));
+  layout->AddView(icon_view_, 1, text_views.size() + 1);
 
   // Add the text views, creating rows for them if necessary.
-  for (size_t i = 0; i < texts.size(); ++i) {
+  for (size_t i = 0; i < text_views.size(); ++i) {
     if (i > 0) {
       layout->StartRow(0, 0);
       layout->SkipColumns(1);
     }
-    layout->AddView(texts[i]);
+    layout->AddView(text_views[i]);
   }
 
   // Add a text padding row if necessary. This adds some space between the last
   // line of text and anything below it but it also ensures views above it are
   // top-justified by expanding vertically to take up any extra space.
-  if (texts.size() == 0) {
+  if (text_views.size() == 0) {
     layout->SkipColumns(1);
   } else {
     layout->StartRow(100, 0);
     layout->SkipColumns(1);
     views::View* padding = new views::ImageView();
     padding->set_border(MakePadding(kTextBottomPadding, 1, 0, 0));
     layout->AddView(padding);
   }
 
   // Add an image row if appropriate.
-  if (!notification().image.isNull()) {
+  if (IsExpanded() && !notification().image.isNull()) {
     layout->StartRow(0, 0);
-    views::ImageView* image = new ProportionalImageView();
-    image->SetImageSize(notification().image.size());
-    image->SetImage(notification().image);
-    image->SetHorizontalAlignment(views::ImageView::CENTER);
-    image->SetVerticalAlignment(views::ImageView::LEADING);
-    layout->AddView(image, 2, 1);
+    ProportionalImageView* image_view = new ProportionalImageView();
+    image_view->SetImage(notification().image);
+    layout->AddView(image_view, 2, 1);
   }
 
   // Add action button rows.
   for (size_t i = 0; i < notification().button_titles.size(); ++i) {
     views::View* separator = new views::View();
     separator->set_background(MakeBackground(kButtonSeparatorColor));
     layout->StartRow(0, 0);
     layout->AddView(separator, 2, 1,
                     views::GridLayout::FILL, views::GridLayout::FILL, 0, 1);
     NotificationButton* button = new NotificationButton(this);
     button->SetTitle(notification().button_titles[i]);
     button->SetIcon(notification().button_icons[i]);
     action_buttons_.push_back(button);
     layout->StartRow(0, 0);
     layout->AddView(button, 2, 1,
                     views::GridLayout::FILL, views::GridLayout::FILL, 0, 40);
   }
 
   return content_view_;
 }
 
 }  // namespace message_center