Made notification center notifications collapsed and expandable.

ui/message_center/message_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/message_view.h"
 
 #include "grit/ui_resources.h"
 #include "grit/ui_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/simple_menu_model.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/shadow_value.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/message_center/message_center_util.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/menu/menu_model_adapter.h"
 #include "ui/views/controls/menu/menu_runner.h"
 #include "ui/views/controls/scroll_view.h"
 #include "ui/views/widget/widget.h"
 
 namespace {
 
-const int kCloseButtonSize = 29;
+const int kControlButtonSize = 29;
 const int kCloseIconTopPadding = 5;
 const int kCloseIconRightPadding = 5;
+const int kExpandIconBottomPadding = 8;
+const int kExpandIconRightPadding = 11;
+
 const int kShadowOffset = 1;
 const int kShadowBlur = 4;
 
 const SkColor kShadowColor = SkColorSetARGB(0.3 * 255, 0, 0, 0);
 const SkColor kTransparentColor = SkColorSetARGB(0, 0, 0, 0);
 
 // Menu constants
 const int kTogglePermissionCommand = 0;
 const int kToggleExtensionCommand = 1;
 const int kShowSettingsCommand = 2;
@@ skipping 59 matching lines @@
                resource_id));
 }
 
 void ControlButton::SetPressedImage(int resource_id) {
   SetImage(views::CustomButton::STATE_PRESSED,
            ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
                resource_id));
 }
 
 gfx::Size ControlButton::GetPreferredSize() {
-  return gfx::Size(kCloseButtonSize, kCloseButtonSize);
+  return gfx::Size(kControlButtonSize, kControlButtonSize);
 }
 
 void ControlButton::OnPaint(gfx::Canvas* canvas) {
   // This is the same implementation as ImageButton::OnPaint except
   // that it calls ComputePaddedImagePaintPosition() instead of
   // ComputeImagePaintPosition(), in effect overriding that private method.
   View::OnPaint(canvas);
   gfx::ImageSkia image = GetImageToPaint();
   if (!image.isNull()) {
     gfx::Point position = ComputePaddedImagePaintPosition(image);
@@ skipping 26 matching lines @@
 }
 
 // A border to provide the shadow for each card.
 // Current shadow should look like css box-shadow: 0 1px 4px rgba(0, 0, 0, 0.3)
 class ShadowBorder : public views::Border {
  public:
   ShadowBorder() : views::Border() {}
   virtual ~ShadowBorder() {}
 
  protected:
-  // views::Border overrides:
+  // Overridden from views::Border:
   virtual void Paint(const views::View& view, gfx::Canvas* canvas) OVERRIDE;
   virtual gfx::Insets GetInsets() const OVERRIDE;
 
   DISALLOW_COPY_AND_ASSIGN(ShadowBorder);
 };
 
 void ShadowBorder::Paint(const views::View& view, gfx::Canvas* canvas) {
   SkPaint paint;
   std::vector<gfx::ShadowValue> shadows;
   shadows.push_back(gfx::ShadowValue(gfx::Point(), kShadowBlur, kShadowColor));
   skia::RefPtr<SkDrawLooper> looper = gfx::CreateShadowDrawLooper(shadows);
   paint.setLooper(looper.get());
   paint.setColor(kTransparentColor);
   paint.setStrokeJoin(SkPaint::kRound_Join);
   gfx::Rect bounds(view.size());
   bounds.Inset(gfx::Insets(kShadowBlur / 2, kShadowBlur / 2,
                            kShadowBlur / 2, kShadowBlur / 2));
   canvas->DrawRect(bounds, paint);
 }
 
 gfx::Insets ShadowBorder::GetInsets() const {
   return message_center::MessageView::GetShadowInsets();
 }
 
 // A dropdown menu for notifications.
 class MenuModel : public ui::SimpleMenuModel,
                   public ui::SimpleMenuModel::Delegate {
  public:
-  MenuModel(message_center::NotificationList::Delegate* list_delegate,
+  MenuModel(message_center::NotificationList::Delegate* delegate,
             const std::string& notification_id,
             const string16& display_source,
             const std::string& extension_id);
   virtual ~MenuModel();
 
   // Overridden from ui::SimpleMenuModel::Delegate:
   virtual bool IsItemForCommandIdDynamic(int command_id) const OVERRIDE;
   virtual bool IsCommandIdChecked(int command_id) const OVERRIDE;
   virtual bool IsCommandIdEnabled(int command_id) const OVERRIDE;
   virtual bool GetAcceleratorForCommandId(
       int command_id,
       ui::Accelerator* accelerator) OVERRIDE;
   virtual void ExecuteCommand(int command_id) OVERRIDE;
 
  private:
-  message_center::NotificationList::Delegate* list_delegate_;
-      // Weak, global MessageCenter
+  message_center::NotificationList::Delegate* delegate_;  // Weak reference.
   std::string notification_id_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuModel);
 };
 
-MenuModel::MenuModel(message_center::NotificationList::Delegate* list_delegate,
+MenuModel::MenuModel(message_center::NotificationList::Delegate* delegate,
                      const std::string& notification_id,
                      const string16& display_source,
                      const std::string& extension_id)
     : ALLOW_THIS_IN_INITIALIZER_LIST(ui::SimpleMenuModel(this)),
-      list_delegate_(list_delegate),
+      delegate_(delegate),
       notification_id_(notification_id) {
   // Add 'disable notifications' menu item.
   if (!extension_id.empty()) {
     AddItem(kToggleExtensionCommand,
             l10n_util::GetStringUTF16(IDS_MESSAGE_CENTER_EXTENSIONS_DISABLE));
   } else if (!display_source.empty()) {
     AddItem(kTogglePermissionCommand,
             l10n_util::GetStringFUTF16(IDS_MESSAGE_CENTER_SITE_DISABLE,
                                        display_source));
   }
@@ skipping 20 matching lines @@
 }
 
 bool MenuModel::GetAcceleratorForCommandId(int command_id,
                                            ui::Accelerator* accelerator) {
   return false;
 }
 
 void MenuModel::ExecuteCommand(int command_id) {
   switch (command_id) {
     case kToggleExtensionCommand:
-      list_delegate_->DisableNotificationByExtension(notification_id_);
+      delegate_->DisableNotificationByExtension(notification_id_);
       break;
     case kTogglePermissionCommand:
-      list_delegate_->DisableNotificationByUrl(notification_id_);
+      delegate_->DisableNotificationByUrl(notification_id_);
       break;
     case kShowSettingsCommand:
-      list_delegate_->ShowNotificationSettings(notification_id_);
+      delegate_->ShowNotificationSettings(notification_id_);
       break;
     default:
       NOTREACHED();
   }
 }
 
 } // namespace
 
 namespace message_center {
 
-MessageView::MessageView(NotificationList::Delegate* list_delegate,
-                         const Notification& notification)
-    : list_delegate_(list_delegate),
+MessageView::MessageView(const Notification& notification,
+                         NotificationList::Delegate* delegate,
+                         bool expanded)
+    : delegate_(delegate),
       notification_id_(notification.id()),
       display_source_(notification.display_source()),
       extension_id_(notification.extension_id()),
-      scroller_(NULL) {
+      scroller_(NULL),
+      is_expanded_(expanded) {
   ControlButton *close = new ControlButton(this);
   close->SetPadding(-kCloseIconRightPadding, kCloseIconTopPadding);
   close->SetNormalImage(IDR_NOTIFICATION_CLOSE);
   close->SetHoveredImage(IDR_NOTIFICATION_CLOSE_HOVER);
   close->SetPressedImage(IDR_NOTIFICATION_CLOSE_PRESSED);
+  close->set_owned_by_client();
   close_button_.reset(close);
+
+  ControlButton *expand = new ControlButton(this);
+  expand->SetPadding(-kExpandIconRightPadding, -kExpandIconBottomPadding);
+  expand->SetNormalImage(IDR_NOTIFICATIONS_EXPAND);
+  expand->SetHoveredImage(IDR_NOTIFICATIONS_EXPAND_HOVER);
+  expand->SetPressedImage(IDR_NOTIFICATIONS_EXPAND_PRESSED);
+  expand->set_owned_by_client();
+  expand_button_.reset(expand);
+
   if (IsRichNotificationEnabled())
     set_border(new ShadowBorder());
 }
 
 MessageView::MessageView() {
 }
 
 MessageView::~MessageView() {
 }
 
 // static
 gfx::Insets MessageView::GetShadowInsets() {
   return gfx::Insets(kShadowBlur / 2 - kShadowOffset,
                      kShadowBlur / 2,
                      kShadowBlur / 2 + kShadowOffset,
                      kShadowBlur / 2);
 }
 
+void MessageView::Update(const Notification& notification) {
+  notification_id_ = notification.id();
+  display_source_ = notification.display_source();
+  extension_id_ = notification.extension_id();
+}
+
 bool MessageView::OnMousePressed(const ui::MouseEvent& event) {
   if (event.flags() & ui::EF_RIGHT_MOUSE_BUTTON) {
     ShowMenu(event.location());
     return true;
   }
-  list_delegate_->OnNotificationClicked(notification_id_);
+  delegate_->OnNotificationClicked(notification_id_);
   return true;
 }
 
 void MessageView::OnGestureEvent(ui::GestureEvent* event) {
   if (event->type() == ui::ET_GESTURE_TAP) {
-    list_delegate_->OnNotificationClicked(notification_id_);
+    delegate_->OnNotificationClicked(notification_id_);
     event->SetHandled();
     return;
   }
 
   if (event->type() == ui::ET_GESTURE_LONG_PRESS) {
     ShowMenu(event->location());
     event->SetHandled();
     return;
   }
 
   SlideOutView::OnGestureEvent(event);
   // Do not return here by checking handled(). SlideOutView calls SetHandled()
   // even though the scroll gesture doesn't make no (or little) effects on the
   // slide-out behavior. See http://crbug.com/172991
 
   if (!event->IsScrollGestureEvent())
     return;
 
   if (scroller_)
     scroller_->OnGestureEvent(event);
   event->SetHandled();
 }
 
 void MessageView::ButtonPressed(views::Button* sender,
                                 const ui::Event& event) {
-  if (sender == close_button())
-    list_delegate_->SendRemoveNotification(notification_id_, true);  // By user.
+  if (sender == close_button()) {
+    delegate_->SendRemoveNotification(notification_id_, true);  // By user.
+  } else if (sender == expand_button()) {
+    is_expanded_ = true;
+    delegate_->OnExpand(notification_id_);
+  }
 }
 
 void MessageView::ShowMenu(gfx::Point screen_location) {
-  MenuModel menu_model(list_delegate_, notification_id_,
+  MenuModel menu_model(delegate_, notification_id_,
                        display_source_, extension_id_);
   if (menu_model.GetItemCount() == 0)
     return;
 
   views::MenuModelAdapter menu_model_adapter(&menu_model);
   views::MenuRunner menu_runner(menu_model_adapter.CreateMenu());
 
   views::View::ConvertPointToScreen(this, &screen_location);
   ignore_result(menu_runner.RunMenuAt(
       GetWidget()->GetTopLevelWidget(),
       NULL,
       gfx::Rect(screen_location, gfx::Size()),
       views::MenuItemView::TOPRIGHT,
       views::MenuRunner::HAS_MNEMONICS));
 }
 
 void MessageView::OnSlideOut() {
-  list_delegate_->SendRemoveNotification(notification_id_, true);  // By user.
+  delegate_->SendRemoveNotification(notification_id_, true);  // By user.
 }
 
 }  // namespace message_center