ui/message_center/message_center_tray.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/message_center_tray.h"
   6
   7 #include "base/observer_list.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "ui/base/l10n/l10n_util.h"
  10 #include "ui/base/models/simple_menu_model.h"
  11 #include "ui/message_center/message_center.h"
  12 #include "ui/message_center/message_center_tray_delegate.h"
  13 #include "ui/message_center/message_center_types.h"
  14 #include "ui/message_center/notification_blocker.h"
  15 #include "ui/strings/grit/ui_strings.h"
  16
  17 namespace message_center {
  18
  19 namespace {
  20
  21 // Menu constants
  22 const int kTogglePermissionCommand = 0;
  23 const int kShowSettingsCommand = 1;
  24
  25 // The model of the context menu for a notification card.
  26 class NotificationMenuModel : public ui::SimpleMenuModel,
  27                               public ui::SimpleMenuModel::Delegate {
  28  public:
  29   NotificationMenuModel(MessageCenterTray* tray,
  30                         const NotifierId& notifier_id,
  31                         const base::string16& display_source);
  32   ~NotificationMenuModel() override;
  33
  34   // Overridden from ui::SimpleMenuModel::Delegate:
  35   bool IsCommandIdChecked(int command_id) const override;
  36   bool IsCommandIdEnabled(int command_id) const override;
  37   bool GetAcceleratorForCommandId(int command_id,
  38                                   ui::Accelerator* accelerator) override;
  39   void ExecuteCommand(int command_id, int event_flags) override;
  40
  41  private:
  42   MessageCenterTray* tray_;
  43   NotifierId notifier_id_;
  44   DISALLOW_COPY_AND_ASSIGN(NotificationMenuModel);
  45 };
  46
  47 NotificationMenuModel::NotificationMenuModel(
  48     MessageCenterTray* tray,
  49     const NotifierId& notifier_id,
  50     const base::string16& display_source)
  51     : ui::SimpleMenuModel(this),
  52       tray_(tray),
  53       notifier_id_(notifier_id) {
  54   // Add 'disable notifications' menu item.
  55   if (!display_source.empty()) {
  56     AddItem(kTogglePermissionCommand,
  57             l10n_util::GetStringFUTF16(IDS_MESSAGE_CENTER_NOTIFIER_DISABLE,
  58                                        display_source));
  59   }
  60   // Add settings menu item.
  61   AddItem(kShowSettingsCommand,
  62           l10n_util::GetStringUTF16(IDS_MESSAGE_CENTER_SETTINGS));
  63 }
  64
  65 NotificationMenuModel::~NotificationMenuModel() {
  66 }
  67
  68 bool NotificationMenuModel::IsCommandIdChecked(int command_id) const {
  69   return false;
  70 }
  71
  72 bool NotificationMenuModel::IsCommandIdEnabled(int command_id) const {
  73   return tray_->delegate()->IsContextMenuEnabled();
  74 }
  75
  76 bool NotificationMenuModel::GetAcceleratorForCommandId(
  77     int command_id,
  78     ui::Accelerator* accelerator) {
  79   return false;
  80 }
  81
  82 void NotificationMenuModel::ExecuteCommand(int command_id, int event_flags) {
  83   switch (command_id) {
  84     case kTogglePermissionCommand:
  85       tray_->message_center()->DisableNotificationsByNotifier(notifier_id_);
  86       break;
  87     case kShowSettingsCommand:
  88       tray_->ShowNotifierSettingsBubble();
  89       break;
  90     default:
  91       NOTREACHED();
  92   }
  93 }
  94
  95 }  // namespace
  96
  97 MessageCenterTray::MessageCenterTray(
  98     MessageCenterTrayDelegate* delegate,
  99     message_center::MessageCenter* message_center)
 100     : message_center_(message_center),
 101       message_center_visible_(false),
 102       popups_visible_(false),
 103       delegate_(delegate) {
 104   message_center_->AddObserver(this);
 105 }
 106
 107 MessageCenterTray::~MessageCenterTray() {
 108   message_center_->RemoveObserver(this);
 109 }
 110
 111 bool MessageCenterTray::ShowMessageCenterBubble() {
 112   if (message_center_visible_)
 113     return true;
 114
 115   HidePopupBubbleInternal();
 116
 117   message_center_visible_ = delegate_->ShowMessageCenter();
 118   message_center_->SetVisibility(message_center::VISIBILITY_MESSAGE_CENTER);
 119   NotifyMessageCenterTrayChanged();
 120   return message_center_visible_;
 121 }
 122
 123 bool MessageCenterTray::HideMessageCenterBubble() {
 124   if (!message_center_visible_)
 125     return false;
 126   delegate_->HideMessageCenter();
 127   MarkMessageCenterHidden();
 128   return true;
 129 }
 130
 131 void MessageCenterTray::MarkMessageCenterHidden() {
 132   if (!message_center_visible_)
 133     return;
 134   message_center_visible_ = false;
 135   message_center_->SetVisibility(message_center::VISIBILITY_TRANSIENT);
 136
 137   // Some notifications (like system ones) should appear as popups again
 138   // after the message center is closed.
 139   if (message_center_->HasPopupNotifications()) {
 140     ShowPopupBubble();
 141     return;
 142   }
 143
 144   NotifyMessageCenterTrayChanged();
 145 }
 146
 147 void MessageCenterTray::ToggleMessageCenterBubble() {
 148   if (message_center_visible_)
 149     HideMessageCenterBubble();
 150   else
 151     ShowMessageCenterBubble();
 152 }
 153
 154 void MessageCenterTray::ShowPopupBubble() {
 155   if (message_center_visible_)
 156     return;
 157
 158   if (popups_visible_) {
 159     NotifyMessageCenterTrayChanged();
 160     return;
 161   }
 162
 163   if (!message_center_->HasPopupNotifications())
 164     return;
 165
 166   popups_visible_ = delegate_->ShowPopups();
 167
 168   NotifyMessageCenterTrayChanged();
 169 }
 170
 171 bool MessageCenterTray::HidePopupBubble() {
 172   if (!popups_visible_)
 173     return false;
 174   HidePopupBubbleInternal();
 175   NotifyMessageCenterTrayChanged();
 176
 177   return true;
 178 }
 179
 180 void MessageCenterTray::HidePopupBubbleInternal() {
 181   if (!popups_visible_)
 182     return;
 183
 184   delegate_->HidePopups();
 185   popups_visible_ = false;
 186 }
 187
 188 void MessageCenterTray::ShowNotifierSettingsBubble() {
 189   if (popups_visible_)
 190     HidePopupBubbleInternal();
 191
 192   message_center_visible_ = delegate_->ShowNotifierSettings();
 193   message_center_->SetVisibility(message_center::VISIBILITY_SETTINGS);
 194
 195   NotifyMessageCenterTrayChanged();
 196 }
 197
 198 scoped_ptr<ui::MenuModel> MessageCenterTray::CreateNotificationMenuModel(
 199     const NotifierId& notifier_id,
 200     const base::string16& display_source) {
 201   return scoped_ptr<ui::MenuModel>(new NotificationMenuModel(
 202       this, notifier_id, display_source));
 203 }
 204
 205 void MessageCenterTray::OnNotificationAdded(
 206     const std::string& notification_id) {
 207   OnMessageCenterChanged();
 208 }
 209
 210 void MessageCenterTray::OnNotificationRemoved(
 211     const std::string& notification_id,
 212     bool by_user) {
 213   OnMessageCenterChanged();
 214 }
 215
 216 void MessageCenterTray::OnNotificationUpdated(
 217     const std::string& notification_id) {
 218   OnMessageCenterChanged();
 219 }
 220
 221 void MessageCenterTray::OnNotificationClicked(
 222     const std::string& notification_id) {
 223   if (popups_visible_)
 224     OnMessageCenterChanged();
 225 }
 226
 227 void MessageCenterTray::OnNotificationButtonClicked(
 228     const std::string& notification_id,
 229     int button_index) {
 230   if (popups_visible_)
 231     OnMessageCenterChanged();
 232 }
 233
 234 void MessageCenterTray::OnNotificationDisplayed(
 235     const std::string& notification_id,
 236     const DisplaySource source) {
 237   NotifyMessageCenterTrayChanged();
 238 }
 239
 240 void MessageCenterTray::OnQuietModeChanged(bool in_quiet_mode) {
 241   NotifyMessageCenterTrayChanged();
 242 }
 243
 244 void MessageCenterTray::OnBlockingStateChanged(NotificationBlocker* blocker) {
 245   OnMessageCenterChanged();
 246 }
 247
 248 void MessageCenterTray::OnMessageCenterChanged() {
 249   if (message_center_visible_ && message_center_->NotificationCount() == 0)
 250     HideMessageCenterBubble();
 251
 252   if (popups_visible_ && !message_center_->HasPopupNotifications())
 253     HidePopupBubbleInternal();
 254   else if (!popups_visible_ && message_center_->HasPopupNotifications())
 255     ShowPopupBubble();
 256
 257   NotifyMessageCenterTrayChanged();
 258 }
 259
 260 void MessageCenterTray::NotifyMessageCenterTrayChanged() {
 261   delegate_->OnMessageCenterTrayChanged();
 262 }
 263
 264 }  // namespace message_center