1 // Copyright (c) 2012 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 "chrome/browser/ui/ash/launcher/launcher_context_menu.h" 6 7 #include <string> 8 9 #include "ash/desktop_background/user_wallpaper_delegate.h" 10 #include "ash/metrics/user_metrics_recorder.h" 11 #include "ash/root_window_controller.h" 12 #include "ash/shelf/shelf_item_delegate.h" 13 #include "ash/shelf/shelf_widget.h" 14 #include "ash/shell.h" 15 #include "base/bind.h" 16 #include "base/prefs/pref_service.h" 17 #include "chrome/browser/extensions/context_menu_matcher.h" 18 #include "chrome/browser/extensions/extension_util.h" 19 #include "chrome/browser/fullscreen.h" 20 #include "chrome/browser/prefs/incognito_mode_prefs.h" 21 #include "chrome/browser/profiles/profile.h" 22 #include "chrome/browser/ui/ash/chrome_shell_delegate.h" 23 #include "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h" 24 #include "chrome/common/extensions/extension_constants.h" 25 #include "chrome/grit/generated_resources.h" 26 #include "content/public/common/context_menu_params.h" 27 #include "grit/ash_strings.h" 28 #include "ui/base/l10n/l10n_util.h" 29 30 namespace { 31 32 bool MenuItemHasLauncherContext(const extensions::MenuItem* item) { 33 return item->contexts().Contains(extensions::MenuItem::LAUNCHER); 34 } 35 36 } // namespace 37 38 LauncherContextMenu::LauncherContextMenu(ChromeLauncherController* controller, 39 const ash::ShelfItem* item, 40 aura::Window* root) 41 : ui::SimpleMenuModel(NULL), 42 controller_(controller), 43 item_(*item), 44 shelf_alignment_menu_(root), 45 root_window_(root), 46 item_delegate_(NULL) { 47 DCHECK(item); 48 DCHECK(root_window_); 49 Init(); 50 } 51 52 LauncherContextMenu::LauncherContextMenu(ChromeLauncherController* controller, 53 ash::ShelfItemDelegate* item_delegate, 54 ash::ShelfItem* item, 55 aura::Window* root) 56 : ui::SimpleMenuModel(NULL), 57 controller_(controller), 58 item_(*item), 59 shelf_alignment_menu_(root), 60 root_window_(root), 61 item_delegate_(item_delegate) { 62 DCHECK(item); 63 DCHECK(root_window_); 64 Init(); 65 } 66 67 LauncherContextMenu::LauncherContextMenu(ChromeLauncherController* controller, 68 aura::Window* root) 69 : ui::SimpleMenuModel(NULL), 70 controller_(controller), 71 item_(ash::ShelfItem()), 72 shelf_alignment_menu_(root), 73 extension_items_(new extensions::ContextMenuMatcher( 74 controller->profile(), this, this, 75 base::Bind(MenuItemHasLauncherContext))), 76 root_window_(root), 77 item_delegate_(NULL) { 78 DCHECK(root_window_); 79 Init(); 80 } 81 82 void LauncherContextMenu::Init() { 83 extension_items_.reset(new extensions::ContextMenuMatcher( 84 controller_->profile(), this, this, 85 base::Bind(MenuItemHasLauncherContext))); 86 set_delegate(this); 87 88 if (is_valid_item()) { 89 if (item_.type == ash::TYPE_APP_SHORTCUT || 90 item_.type == ash::TYPE_WINDOWED_APP) { 91 // V1 apps can be started from the menu - but V2 apps should not. 92 if (!controller_->IsPlatformApp(item_.id)) { 93 AddItem(MENU_OPEN_NEW, base::string16()); 94 AddSeparator(ui::NORMAL_SEPARATOR); 95 } 96 AddItem( 97 MENU_PIN, 98 l10n_util::GetStringUTF16(controller_->IsPinned(item_.id) ? 99 IDS_LAUNCHER_CONTEXT_MENU_UNPIN : 100 IDS_LAUNCHER_CONTEXT_MENU_PIN)); 101 if (controller_->IsOpen(item_.id)) { 102 AddItem(MENU_CLOSE, 103 l10n_util::GetStringUTF16(IDS_LAUNCHER_CONTEXT_MENU_CLOSE)); 104 } 105 if (!controller_->IsPlatformApp(item_.id) && 106 item_.type != ash::TYPE_WINDOWED_APP) { 107 AddSeparator(ui::NORMAL_SEPARATOR); 108 if (extensions::util::IsStreamlinedHostedAppsEnabled()) { 109 // Streamlined hosted apps launch in a window by default. This menu 110 // item is re-interpreted as a single, toggle-able option to launch 111 // the hosted app as a tab. 112 AddCheckItemWithStringId( 113 LAUNCH_TYPE_REGULAR_TAB, 114 IDS_APP_CONTEXT_MENU_OPEN_TAB); 115 } else { 116 AddCheckItemWithStringId( 117 LAUNCH_TYPE_REGULAR_TAB, 118 IDS_APP_CONTEXT_MENU_OPEN_REGULAR); 119 AddCheckItemWithStringId( 120 LAUNCH_TYPE_PINNED_TAB, 121 IDS_APP_CONTEXT_MENU_OPEN_PINNED); 122 AddCheckItemWithStringId( 123 LAUNCH_TYPE_WINDOW, 124 IDS_APP_CONTEXT_MENU_OPEN_WINDOW); 125 // Even though the launch type is Full Screen it is more accurately 126 // described as Maximized in Ash. 127 AddCheckItemWithStringId( 128 LAUNCH_TYPE_FULLSCREEN, 129 IDS_APP_CONTEXT_MENU_OPEN_MAXIMIZED); 130 } 131 } 132 } else if (item_.type == ash::TYPE_BROWSER_SHORTCUT) { 133 AddItem(MENU_NEW_WINDOW, 134 l10n_util::GetStringUTF16(IDS_LAUNCHER_NEW_WINDOW)); 135 if (!controller_->IsLoggedInAsGuest()) { 136 AddItem(MENU_NEW_INCOGNITO_WINDOW, 137 l10n_util::GetStringUTF16(IDS_LAUNCHER_NEW_INCOGNITO_WINDOW)); 138 } 139 } else if (item_.type == ash::TYPE_DIALOG) { 140 AddItem(MENU_CLOSE, 141 l10n_util::GetStringUTF16(IDS_LAUNCHER_CONTEXT_MENU_CLOSE)); 142 } else { 143 if (item_.type == ash::TYPE_PLATFORM_APP) { 144 AddItem( 145 MENU_PIN, 146 l10n_util::GetStringUTF16(IDS_LAUNCHER_CONTEXT_MENU_PIN)); 147 AddItem(MENU_INSTALL, l10n_util::GetStringUTF16(IDS_APP_INSTALL_TITLE)); 148 } 149 if (controller_->IsOpen(item_.id)) { 150 AddItem(MENU_CLOSE, 151 l10n_util::GetStringUTF16(IDS_LAUNCHER_CONTEXT_MENU_CLOSE)); 152 } 153 } 154 AddSeparator(ui::NORMAL_SEPARATOR); 155 if (item_.type == ash::TYPE_APP_SHORTCUT || 156 item_.type == ash::TYPE_WINDOWED_APP || 157 item_.type == ash::TYPE_PLATFORM_APP) { 158 const extensions::MenuItem::ExtensionKey app_key( 159 controller_->GetAppIDForShelfID(item_.id)); 160 if (!app_key.empty()) { 161 int index = 0; 162 extension_items_->AppendExtensionItems(app_key, 163 base::string16(), 164 &index, 165 false); // is_action_menu 166 AddSeparator(ui::NORMAL_SEPARATOR); 167 } 168 } 169 } 170 // In fullscreen, the launcher is either hidden or autohidden depending on 171 // the type of fullscreen. Do not show the auto-hide menu item while in 172 // fullscreen because it is confusing when the preference appears not to 173 // apply. 174 if (!IsFullScreenMode() && 175 controller_->CanUserModifyShelfAutoHideBehavior(root_window_)) { 176 AddCheckItemWithStringId(MENU_AUTO_HIDE, 177 IDS_ASH_SHELF_CONTEXT_MENU_AUTO_HIDE); 178 } 179 if (ash::ShelfWidget::ShelfAlignmentAllowed()) { 180 AddSubMenuWithStringId(MENU_ALIGNMENT_MENU, 181 IDS_ASH_SHELF_CONTEXT_MENU_POSITION, 182 &shelf_alignment_menu_); 183 } 184 #if defined(OS_CHROMEOS) 185 AddItem(MENU_CHANGE_WALLPAPER, 186 l10n_util::GetStringUTF16(IDS_AURA_SET_DESKTOP_WALLPAPER)); 187 #endif 188 } 189 190 LauncherContextMenu::~LauncherContextMenu() { 191 } 192 193 bool LauncherContextMenu::IsItemForCommandIdDynamic(int command_id) const { 194 return command_id == MENU_OPEN_NEW; 195 } 196 197 base::string16 LauncherContextMenu::GetLabelForCommandId(int command_id) const { 198 if (command_id == MENU_OPEN_NEW) { 199 if (item_.type == ash::TYPE_PLATFORM_APP) { 200 return l10n_util::GetStringUTF16(IDS_LAUNCHER_CONTEXT_MENU_NEW_WINDOW); 201 } 202 switch (controller_->GetLaunchType(item_.id)) { 203 case extensions::LAUNCH_TYPE_PINNED: 204 case extensions::LAUNCH_TYPE_REGULAR: 205 return l10n_util::GetStringUTF16(IDS_LAUNCHER_CONTEXT_MENU_NEW_TAB); 206 case extensions::LAUNCH_TYPE_FULLSCREEN: 207 case extensions::LAUNCH_TYPE_WINDOW: 208 return l10n_util::GetStringUTF16(IDS_LAUNCHER_CONTEXT_MENU_NEW_WINDOW); 209 default: 210 NOTREACHED(); 211 return base::string16(); 212 } 213 } 214 NOTREACHED(); 215 return base::string16(); 216 } 217 218 bool LauncherContextMenu::IsCommandIdChecked(int command_id) const { 219 switch (command_id) { 220 case LAUNCH_TYPE_PINNED_TAB: 221 return controller_->GetLaunchType(item_.id) == 222 extensions::LAUNCH_TYPE_PINNED; 223 case LAUNCH_TYPE_REGULAR_TAB: 224 return controller_->GetLaunchType(item_.id) == 225 extensions::LAUNCH_TYPE_REGULAR; 226 case LAUNCH_TYPE_WINDOW: 227 return controller_->GetLaunchType(item_.id) == 228 extensions::LAUNCH_TYPE_WINDOW; 229 case LAUNCH_TYPE_FULLSCREEN: 230 return controller_->GetLaunchType(item_.id) == 231 extensions::LAUNCH_TYPE_FULLSCREEN; 232 case MENU_AUTO_HIDE: 233 return controller_->GetShelfAutoHideBehavior(root_window_) == 234 ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS; 235 default: 236 return extension_items_->IsCommandIdChecked(command_id); 237 } 238 } 239 240 bool LauncherContextMenu::IsCommandIdEnabled(int command_id) const { 241 switch (command_id) { 242 case MENU_PIN: 243 return controller_->IsPinnable(item_.id); 244 #if defined(OS_CHROMEOS) 245 case MENU_CHANGE_WALLPAPER: 246 return ash::Shell::GetInstance()->user_wallpaper_delegate()-> 247 CanOpenSetWallpaperPage(); 248 #endif 249 case MENU_NEW_WINDOW: 250 // "Normal" windows are not allowed when incognito is enforced. 251 return IncognitoModePrefs::GetAvailability( 252 controller_->profile()->GetPrefs()) != IncognitoModePrefs::FORCED; 253 case MENU_AUTO_HIDE: 254 return controller_->CanUserModifyShelfAutoHideBehavior(root_window_); 255 case MENU_NEW_INCOGNITO_WINDOW: 256 // Incognito windows are not allowed when incognito is disabled. 257 return IncognitoModePrefs::GetAvailability( 258 controller_->profile()->GetPrefs()) != IncognitoModePrefs::DISABLED; 259 default: 260 return extension_items_->IsCommandIdEnabled(command_id); 261 } 262 } 263 264 bool LauncherContextMenu::IsCommandIdVisible(int command_id) const { 265 if (item_.type != ash::TYPE_PLATFORM_APP) 266 return true; 267 268 switch (command_id) { 269 case MENU_PIN: 270 return !controller_->CanInstall(item_.id); 271 case MENU_INSTALL: 272 return controller_->CanInstall(item_.id); 273 default: 274 return true; 275 } 276 } 277 278 bool LauncherContextMenu::GetAcceleratorForCommandId( 279 int command_id, 280 ui::Accelerator* accelerator) { 281 return false; 282 } 283 284 void LauncherContextMenu::ExecuteCommand(int command_id, int event_flags) { 285 switch (static_cast<MenuItem>(command_id)) { 286 case MENU_OPEN_NEW: 287 controller_->Launch(item_.id, ui::EF_NONE); 288 break; 289 case MENU_CLOSE: 290 if (item_.type == ash::TYPE_DIALOG) { 291 DCHECK(item_delegate_); 292 item_delegate_->Close(); 293 } else { 294 // TODO(simonhong): Use ShelfItemDelegate::Close(). 295 controller_->Close(item_.id); 296 } 297 ash::Shell::GetInstance()->metrics()->RecordUserMetricsAction( 298 ash::UMA_CLOSE_THROUGH_CONTEXT_MENU); 299 break; 300 case MENU_PIN: 301 controller_->TogglePinned(item_.id); 302 break; 303 case MENU_INSTALL: 304 controller_->Install(item_.id); 305 break; 306 case LAUNCH_TYPE_PINNED_TAB: 307 controller_->SetLaunchType(item_.id, extensions::LAUNCH_TYPE_PINNED); 308 break; 309 case LAUNCH_TYPE_REGULAR_TAB: { 310 extensions::LaunchType launch_type = 311 extensions::LAUNCH_TYPE_REGULAR; 312 // Streamlined hosted apps can only toggle between LAUNCH_WINDOW and 313 // LAUNCH_REGULAR. 314 if (extensions::util::IsStreamlinedHostedAppsEnabled()) { 315 launch_type = controller_->GetLaunchType(item_.id) == 316 extensions::LAUNCH_TYPE_REGULAR 317 ? extensions::LAUNCH_TYPE_WINDOW 318 : extensions::LAUNCH_TYPE_REGULAR; 319 } 320 controller_->SetLaunchType(item_.id, launch_type); 321 break; 322 } 323 case LAUNCH_TYPE_WINDOW: 324 controller_->SetLaunchType(item_.id, extensions::LAUNCH_TYPE_WINDOW); 325 break; 326 case LAUNCH_TYPE_FULLSCREEN: 327 controller_->SetLaunchType(item_.id, extensions::LAUNCH_TYPE_FULLSCREEN); 328 break; 329 case MENU_AUTO_HIDE: 330 controller_->ToggleShelfAutoHideBehavior(root_window_); 331 break; 332 case MENU_NEW_WINDOW: 333 controller_->CreateNewWindow(); 334 break; 335 case MENU_NEW_INCOGNITO_WINDOW: 336 controller_->CreateNewIncognitoWindow(); 337 break; 338 case MENU_ALIGNMENT_MENU: 339 break; 340 #if defined(OS_CHROMEOS) 341 case MENU_CHANGE_WALLPAPER: 342 ash::Shell::GetInstance()->user_wallpaper_delegate()-> 343 OpenSetWallpaperPage(); 344 break; 345 #endif 346 default: 347 extension_items_->ExecuteCommand(command_id, NULL, 348 content::ContextMenuParams()); 349 } 350 } 351
