| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 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 "ash/common/wm/overview/window_selector.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 #include <functional> | |
| 9 #include <set> | |
| 10 #include <utility> | |
| 11 #include <vector> | |
| 12 | |
| 13 #include "ash/common/accessibility_delegate.h" | |
| 14 #include "ash/common/accessibility_types.h" | |
| 15 #include "ash/common/metrics/user_metrics_action.h" | |
| 16 #include "ash/common/shelf/wm_shelf.h" | |
| 17 #include "ash/common/wm/mru_window_tracker.h" | |
| 18 #include "ash/common/wm/overview/window_grid.h" | |
| 19 #include "ash/common/wm/overview/window_selector_delegate.h" | |
| 20 #include "ash/common/wm/overview/window_selector_item.h" | |
| 21 #include "ash/common/wm/panels/panel_layout_manager.h" | |
| 22 #include "ash/common/wm/switchable_windows.h" | |
| 23 #include "ash/common/wm/window_state.h" | |
| 24 #include "ash/common/wm/wm_screen_util.h" | |
| 25 #include "ash/common/wm_shell.h" | |
| 26 #include "ash/common/wm_window.h" | |
| 27 #include "ash/public/cpp/shell_window_ids.h" | |
| 28 #include "ash/root_window_controller.h" | |
| 29 #include "base/auto_reset.h" | |
| 30 #include "base/command_line.h" | |
| 31 #include "base/metrics/histogram_macros.h" | |
| 32 #include "third_party/skia/include/core/SkPath.h" | |
| 33 #include "ui/base/resource/resource_bundle.h" | |
| 34 #include "ui/compositor/scoped_layer_animation_settings.h" | |
| 35 #include "ui/display/screen.h" | |
| 36 #include "ui/events/event.h" | |
| 37 #include "ui/gfx/canvas.h" | |
| 38 #include "ui/gfx/paint_vector_icon.h" | |
| 39 #include "ui/gfx/skia_util.h" | |
| 40 #include "ui/gfx/vector_icons_public.h" | |
| 41 #include "ui/views/border.h" | |
| 42 #include "ui/views/controls/image_view.h" | |
| 43 #include "ui/views/controls/textfield/textfield.h" | |
| 44 #include "ui/views/layout/box_layout.h" | |
| 45 | |
| 46 namespace ash { | |
| 47 | |
| 48 namespace { | |
| 49 | |
| 50 // The amount of padding surrounding the text in the text filtering textbox. | |
| 51 const int kTextFilterHorizontalPadding = 10; | |
| 52 | |
| 53 // The height of the text filtering textbox. | |
| 54 const int kTextFilterHeight = 40; | |
| 55 | |
| 56 // The margin at the bottom to make sure the text filter layer is hidden. | |
| 57 // This is needed because positioning the text filter directly touching the top | |
| 58 // edge of the screen still allows the shadow to peek through. | |
| 59 const int kTextFieldBottomMargin = 2; | |
| 60 | |
| 61 // Distance from top of overview to the top of text filtering textbox as a | |
| 62 // proportion of the total overview area. | |
| 63 const float kTextFilterTopScreenProportion = 0.02f; | |
| 64 | |
| 65 // Width of the text filter area. | |
| 66 const int kTextFilterWidth = 280; | |
| 67 | |
| 68 // The font style used for text filtering textbox. | |
| 69 static const ui::ResourceBundle::FontStyle kTextFilterFontStyle = | |
| 70 ui::ResourceBundle::FontStyle::BaseFont; | |
| 71 | |
| 72 // The color of the text and its background in the text filtering textbox. | |
| 73 const SkColor kTextFilterTextColor = SkColorSetARGB(222, 0, 0, 0); | |
| 74 const SkColor kTextFilterBackgroundColor = SK_ColorWHITE; | |
| 75 | |
| 76 // The color or search icon. | |
| 77 const SkColor kTextFilterIconColor = SkColorSetARGB(138, 0, 0, 0); | |
| 78 | |
| 79 // The size of search icon. | |
| 80 const int kTextFilterIconSize = 20; | |
| 81 | |
| 82 // The radius used for the rounded corners on the text filtering textbox. | |
| 83 const int kTextFilterCornerRadius = 2; | |
| 84 | |
| 85 // A comparator for locating a selector item for a given root. | |
| 86 struct WindowSelectorItemForRoot { | |
| 87 explicit WindowSelectorItemForRoot(const WmWindow* root) | |
| 88 : root_window(root) {} | |
| 89 | |
| 90 bool operator()(WindowSelectorItem* item) const { | |
| 91 return item->root_window() == root_window; | |
| 92 } | |
| 93 | |
| 94 const WmWindow* root_window; | |
| 95 }; | |
| 96 | |
| 97 // A View having rounded corners and a specified background color which is | |
| 98 // only painted within the bounds defined by the rounded corners. | |
| 99 // TODO(tdanderson): This duplicates code from RoundedImageView. Refactor these | |
| 100 // classes and move into ui/views. | |
| 101 class RoundedContainerView : public views::View { | |
| 102 public: | |
| 103 RoundedContainerView(int corner_radius, SkColor background) | |
| 104 : corner_radius_(corner_radius), background_(background) {} | |
| 105 | |
| 106 ~RoundedContainerView() override {} | |
| 107 | |
| 108 void OnPaint(gfx::Canvas* canvas) override { | |
| 109 views::View::OnPaint(canvas); | |
| 110 | |
| 111 SkScalar radius = SkIntToScalar(corner_radius_); | |
| 112 const SkScalar kRadius[8] = {radius, radius, radius, radius, | |
| 113 radius, radius, radius, radius}; | |
| 114 SkPath path; | |
| 115 gfx::Rect bounds(size()); | |
| 116 path.addRoundRect(gfx::RectToSkRect(bounds), kRadius); | |
| 117 | |
| 118 canvas->ClipPath(path, true); | |
| 119 canvas->DrawColor(background_); | |
| 120 } | |
| 121 | |
| 122 private: | |
| 123 int corner_radius_; | |
| 124 SkColor background_; | |
| 125 | |
| 126 DISALLOW_COPY_AND_ASSIGN(RoundedContainerView); | |
| 127 }; | |
| 128 | |
| 129 // Triggers a shelf visibility update on all root window controllers. | |
| 130 void UpdateShelfVisibility() { | |
| 131 for (WmWindow* root : WmShell::Get()->GetAllRootWindows()) | |
| 132 WmShelf::ForWindow(root)->UpdateVisibilityState(); | |
| 133 } | |
| 134 | |
| 135 gfx::Rect GetTextFilterPosition(WmWindow* root_window) { | |
| 136 gfx::Rect total_bounds = root_window->ConvertRectToScreen( | |
| 137 wm::GetDisplayWorkAreaBoundsInParent(root_window->GetChildByShellWindowId( | |
| 138 kShellWindowId_DefaultContainer))); | |
| 139 return gfx::Rect( | |
| 140 0.5 * (total_bounds.width() - | |
| 141 std::min(kTextFilterWidth, total_bounds.width())), | |
| 142 total_bounds.y() + total_bounds.height() * kTextFilterTopScreenProportion, | |
| 143 std::min(kTextFilterWidth, total_bounds.width()), kTextFilterHeight); | |
| 144 } | |
| 145 | |
| 146 // Initializes the text filter on the top of the main root window and requests | |
| 147 // focus on its textfield. Uses |image| to place an icon to the left of the text | |
| 148 // field. | |
| 149 views::Widget* CreateTextFilter(views::TextfieldController* controller, | |
| 150 WmWindow* root_window, | |
| 151 const gfx::ImageSkia& image, | |
| 152 int* text_filter_bottom) { | |
| 153 views::Widget* widget = new views::Widget; | |
| 154 views::Widget::InitParams params; | |
| 155 params.type = views::Widget::InitParams::TYPE_WINDOW_FRAMELESS; | |
| 156 params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET; | |
| 157 params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW; | |
| 158 params.accept_events = true; | |
| 159 params.bounds = GetTextFilterPosition(root_window); | |
| 160 params.name = "OverviewModeTextFilter"; | |
| 161 *text_filter_bottom = params.bounds.bottom() + kTextFieldBottomMargin; | |
| 162 root_window->GetRootWindowController()->ConfigureWidgetInitParamsForContainer( | |
| 163 widget, kShellWindowId_StatusContainer, ¶ms); | |
| 164 widget->Init(params); | |
| 165 | |
| 166 // Use |container| to specify the padding surrounding the text and to give | |
| 167 // the textfield rounded corners. | |
| 168 views::View* container = new RoundedContainerView(kTextFilterCornerRadius, | |
| 169 kTextFilterBackgroundColor); | |
| 170 ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance(); | |
| 171 const int text_height = | |
| 172 std::max(kTextFilterIconSize, | |
| 173 bundle.GetFontList(kTextFilterFontStyle).GetHeight()); | |
| 174 DCHECK(text_height); | |
| 175 const int vertical_padding = (params.bounds.height() - text_height) / 2; | |
| 176 views::BoxLayout* layout = new views::BoxLayout( | |
| 177 views::BoxLayout::kHorizontal, kTextFilterHorizontalPadding, | |
| 178 vertical_padding, kTextFilterHorizontalPadding); | |
| 179 container->SetLayoutManager(layout); | |
| 180 | |
| 181 views::Textfield* textfield = new views::Textfield; | |
| 182 textfield->set_controller(controller); | |
| 183 textfield->SetBorder(views::NullBorder()); | |
| 184 textfield->SetBackgroundColor(kTextFilterBackgroundColor); | |
| 185 textfield->SetTextColor(kTextFilterTextColor); | |
| 186 views::ImageView* image_view = new views::ImageView; | |
| 187 image_view->SetImage(image); | |
| 188 container->AddChildView(image_view); | |
| 189 textfield->SetFontList(bundle.GetFontList(kTextFilterFontStyle)); | |
| 190 container->AddChildView(textfield); | |
| 191 layout->SetFlexForView(textfield, 1); | |
| 192 widget->SetContentsView(container); | |
| 193 | |
| 194 // The textfield initially contains no text, so shift its position to be | |
| 195 // outside the visible bounds of the screen. | |
| 196 gfx::Transform transform; | |
| 197 transform.Translate(0, -(*text_filter_bottom)); | |
| 198 WmWindow* text_filter_widget_window = | |
| 199 WmWindow::Get(widget->GetNativeWindow()); | |
| 200 text_filter_widget_window->SetOpacity(0); | |
| 201 text_filter_widget_window->SetTransform(transform); | |
| 202 widget->Show(); | |
| 203 textfield->RequestFocus(); | |
| 204 | |
| 205 return widget; | |
| 206 } | |
| 207 | |
| 208 } // namespace | |
| 209 | |
| 210 // static | |
| 211 bool WindowSelector::IsSelectable(WmWindow* window) { | |
| 212 wm::WindowState* state = window->GetWindowState(); | |
| 213 return state->IsUserPositionable(); | |
| 214 } | |
| 215 | |
| 216 WindowSelector::WindowSelector(WindowSelectorDelegate* delegate) | |
| 217 : delegate_(delegate), | |
| 218 restore_focus_window_(WmShell::Get()->GetFocusedWindow()), | |
| 219 ignore_activations_(false), | |
| 220 selected_grid_index_(0), | |
| 221 overview_start_time_(base::Time::Now()), | |
| 222 num_key_presses_(0), | |
| 223 num_items_(0), | |
| 224 showing_text_filter_(false), | |
| 225 text_filter_string_length_(0), | |
| 226 num_times_textfield_cleared_(0), | |
| 227 restoring_minimized_windows_(false), | |
| 228 text_filter_bottom_(0) { | |
| 229 DCHECK(delegate_); | |
| 230 } | |
| 231 | |
| 232 WindowSelector::~WindowSelector() { | |
| 233 RemoveAllObservers(); | |
| 234 } | |
| 235 | |
| 236 // NOTE: The work done in Init() is not done in the constructor because it may | |
| 237 // cause other, unrelated classes, (ie PanelLayoutManager) to make indirect | |
| 238 // calls to restoring_minimized_windows() on a partially constructed object. | |
| 239 void WindowSelector::Init(const WindowList& windows) { | |
| 240 if (restore_focus_window_) | |
| 241 restore_focus_window_->aura_window()->AddObserver(this); | |
| 242 | |
| 243 WmShell* shell = WmShell::Get(); | |
| 244 | |
| 245 std::vector<WmWindow*> root_windows = shell->GetAllRootWindows(); | |
| 246 std::sort(root_windows.begin(), root_windows.end(), | |
| 247 [](const WmWindow* a, const WmWindow* b) { | |
| 248 // Since we don't know if windows are vertically or horizontally | |
| 249 // oriented we use both x and y position. This may be confusing | |
| 250 // if you have 3 or more monitors which are not strictly | |
| 251 // horizontal or vertical but that case is not yet supported. | |
| 252 return (a->GetBoundsInScreen().x() + a->GetBoundsInScreen().y()) < | |
| 253 (b->GetBoundsInScreen().x() + b->GetBoundsInScreen().y()); | |
| 254 }); | |
| 255 | |
| 256 for (WmWindow* root : root_windows) { | |
| 257 // Observed switchable containers for newly created windows on all root | |
| 258 // windows. | |
| 259 for (size_t i = 0; i < wm::kSwitchableWindowContainerIdsLength; ++i) { | |
| 260 WmWindow* container = | |
| 261 root->GetChildByShellWindowId(wm::kSwitchableWindowContainerIds[i]); | |
| 262 container->aura_window()->AddObserver(this); | |
| 263 observed_windows_.insert(container); | |
| 264 } | |
| 265 | |
| 266 // Hide the callout widgets for panels. It is safe to call this for | |
| 267 // root windows that don't contain any panel windows. | |
| 268 PanelLayoutManager::Get(root)->SetShowCalloutWidgets(false); | |
| 269 | |
| 270 std::unique_ptr<WindowGrid> grid(new WindowGrid(root, windows, this)); | |
| 271 if (grid->empty()) | |
| 272 continue; | |
| 273 num_items_ += grid->size(); | |
| 274 grid_list_.push_back(std::move(grid)); | |
| 275 } | |
| 276 | |
| 277 { | |
| 278 // The calls to WindowGrid::PrepareForOverview() and CreateTextFilter(...) | |
| 279 // requires some LayoutManagers (ie PanelLayoutManager) to perform layouts | |
| 280 // so that windows are correctly visible and properly animated in overview | |
| 281 // mode. Otherwise these layouts should be suppressed during overview mode | |
| 282 // so they don't conflict with overview mode animations. The | |
| 283 // |restoring_minimized_windows_| flag enables the PanelLayoutManager to | |
| 284 // make this decision. | |
| 285 base::AutoReset<bool> auto_restoring_minimized_windows( | |
| 286 &restoring_minimized_windows_, true); | |
| 287 | |
| 288 // Do not call PrepareForOverview until all items are added to window_list_ | |
| 289 // as we don't want to cause any window updates until all windows in | |
| 290 // overview are observed. See http://crbug.com/384495. | |
| 291 for (std::unique_ptr<WindowGrid>& window_grid : grid_list_) { | |
| 292 window_grid->PrepareForOverview(); | |
| 293 window_grid->PositionWindows(true); | |
| 294 } | |
| 295 | |
| 296 search_image_ = | |
| 297 gfx::CreateVectorIcon(gfx::VectorIconId::OMNIBOX_SEARCH, | |
| 298 kTextFilterIconSize, kTextFilterIconColor); | |
| 299 WmWindow* root_window = shell->GetPrimaryRootWindow(); | |
| 300 text_filter_widget_.reset(CreateTextFilter(this, root_window, search_image_, | |
| 301 &text_filter_bottom_)); | |
| 302 } | |
| 303 | |
| 304 DCHECK(!grid_list_.empty()); | |
| 305 UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.Items", num_items_); | |
| 306 | |
| 307 shell->AddActivationObserver(this); | |
| 308 | |
| 309 display::Screen::GetScreen()->AddObserver(this); | |
| 310 shell->RecordUserMetricsAction(UMA_WINDOW_OVERVIEW); | |
| 311 // Send an a11y alert. | |
| 312 WmShell::Get()->accessibility_delegate()->TriggerAccessibilityAlert( | |
| 313 A11Y_ALERT_WINDOW_OVERVIEW_MODE_ENTERED); | |
| 314 | |
| 315 UpdateShelfVisibility(); | |
| 316 } | |
| 317 | |
| 318 // NOTE: The work done in Shutdown() is not done in the destructor because it | |
| 319 // may cause other, unrelated classes, (ie PanelLayoutManager) to make indirect | |
| 320 // calls to restoring_minimized_windows() on a partially destructed object. | |
| 321 void WindowSelector::Shutdown() { | |
| 322 is_shut_down_ = true; | |
| 323 // Stop observing screen metrics changes first to avoid auto-positioning | |
| 324 // windows in response to work area changes from window activation. | |
| 325 display::Screen::GetScreen()->RemoveObserver(this); | |
| 326 | |
| 327 size_t remaining_items = 0; | |
| 328 for (std::unique_ptr<WindowGrid>& window_grid : grid_list_) { | |
| 329 for (const auto& window_selector_item : window_grid->window_list()) | |
| 330 window_selector_item->RestoreWindow(); | |
| 331 remaining_items += window_grid->size(); | |
| 332 } | |
| 333 | |
| 334 // Setting focus after restoring windows' state avoids unnecessary animations. | |
| 335 ResetFocusRestoreWindow(true); | |
| 336 RemoveAllObservers(); | |
| 337 | |
| 338 std::vector<WmWindow*> root_windows = WmShell::Get()->GetAllRootWindows(); | |
| 339 for (WmWindow* window : root_windows) { | |
| 340 // Un-hide the callout widgets for panels. It is safe to call this for | |
| 341 // root_windows that don't contain any panel windows. | |
| 342 PanelLayoutManager::Get(window)->SetShowCalloutWidgets(true); | |
| 343 } | |
| 344 | |
| 345 for (std::unique_ptr<WindowGrid>& window_grid : grid_list_) | |
| 346 window_grid->Shutdown(); | |
| 347 | |
| 348 DCHECK(num_items_ >= remaining_items); | |
| 349 UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.OverviewClosedItems", | |
| 350 num_items_ - remaining_items); | |
| 351 UMA_HISTOGRAM_MEDIUM_TIMES("Ash.WindowSelector.TimeInOverview", | |
| 352 base::Time::Now() - overview_start_time_); | |
| 353 | |
| 354 // Record metrics related to text filtering. | |
| 355 UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.TextFilteringStringLength", | |
| 356 text_filter_string_length_); | |
| 357 UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.TextFilteringTextfieldCleared", | |
| 358 num_times_textfield_cleared_); | |
| 359 if (text_filter_string_length_) { | |
| 360 UMA_HISTOGRAM_MEDIUM_TIMES( | |
| 361 "Ash.WindowSelector.TimeInOverviewWithTextFiltering", | |
| 362 base::Time::Now() - overview_start_time_); | |
| 363 UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.ItemsWhenTextFilteringUsed", | |
| 364 remaining_items); | |
| 365 } | |
| 366 | |
| 367 // Clearing the window list resets the ignored_by_shelf flag on the windows. | |
| 368 grid_list_.clear(); | |
| 369 UpdateShelfVisibility(); | |
| 370 } | |
| 371 | |
| 372 void WindowSelector::RemoveAllObservers() { | |
| 373 for (WmWindow* window : observed_windows_) | |
| 374 window->aura_window()->RemoveObserver(this); | |
| 375 | |
| 376 WmShell::Get()->RemoveActivationObserver(this); | |
| 377 display::Screen::GetScreen()->RemoveObserver(this); | |
| 378 if (restore_focus_window_) | |
| 379 restore_focus_window_->aura_window()->RemoveObserver(this); | |
| 380 } | |
| 381 | |
| 382 void WindowSelector::CancelSelection() { | |
| 383 delegate_->OnSelectionEnded(); | |
| 384 } | |
| 385 | |
| 386 void WindowSelector::OnGridEmpty(WindowGrid* grid) { | |
| 387 size_t index = 0; | |
| 388 for (auto iter = grid_list_.begin(); iter != grid_list_.end(); ++iter) { | |
| 389 if (grid == (*iter).get()) { | |
| 390 index = iter - grid_list_.begin(); | |
| 391 grid_list_.erase(iter); | |
| 392 break; | |
| 393 } | |
| 394 } | |
| 395 if (index > 0 && selected_grid_index_ >= index) { | |
| 396 selected_grid_index_--; | |
| 397 // If the grid which became empty was the one with the selected window, we | |
| 398 // need to select a window on the newly selected grid. | |
| 399 if (selected_grid_index_ == index - 1) | |
| 400 Move(LEFT, true); | |
| 401 } | |
| 402 if (grid_list_.empty()) | |
| 403 CancelSelection(); | |
| 404 } | |
| 405 | |
| 406 void WindowSelector::IncrementSelection(int increment) { | |
| 407 const Direction direction = | |
| 408 increment > 0 ? WindowSelector::RIGHT : WindowSelector::LEFT; | |
| 409 for (int step = 0; step < abs(increment); ++step) | |
| 410 Move(direction, true); | |
| 411 } | |
| 412 | |
| 413 bool WindowSelector::AcceptSelection() { | |
| 414 if (!grid_list_[selected_grid_index_]->is_selecting()) | |
| 415 return false; | |
| 416 SelectWindow(grid_list_[selected_grid_index_]->SelectedWindow()); | |
| 417 return true; | |
| 418 } | |
| 419 | |
| 420 void WindowSelector::SelectWindow(WindowSelectorItem* item) { | |
| 421 WmWindow* window = item->GetWindow(); | |
| 422 std::vector<WmWindow*> window_list = | |
| 423 WmShell::Get()->mru_window_tracker()->BuildMruWindowList(); | |
| 424 if (!window_list.empty()) { | |
| 425 // Record UMA_WINDOW_OVERVIEW_ACTIVE_WINDOW_CHANGED if the user is selecting | |
| 426 // a window other than the window that was active prior to entering overview | |
| 427 // mode (i.e., the window at the front of the MRU list). | |
| 428 if (window_list[0] != window) { | |
| 429 WmShell::Get()->RecordUserMetricsAction( | |
| 430 UMA_WINDOW_OVERVIEW_ACTIVE_WINDOW_CHANGED); | |
| 431 } | |
| 432 const auto it = std::find(window_list.begin(), window_list.end(), window); | |
| 433 if (it != window_list.end()) { | |
| 434 // Record 1-based index so that selecting a top MRU window will record 1. | |
| 435 UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.SelectionDepth", | |
| 436 1 + it - window_list.begin()); | |
| 437 } | |
| 438 } | |
| 439 item->EnsureVisible(); | |
| 440 window->GetWindowState()->Activate(); | |
| 441 } | |
| 442 | |
| 443 void WindowSelector::WindowClosing(WindowSelectorItem* window) { | |
| 444 grid_list_[selected_grid_index_]->WindowClosing(window); | |
| 445 } | |
| 446 | |
| 447 bool WindowSelector::HandleKeyEvent(views::Textfield* sender, | |
| 448 const ui::KeyEvent& key_event) { | |
| 449 if (key_event.type() != ui::ET_KEY_PRESSED) | |
| 450 return false; | |
| 451 | |
| 452 switch (key_event.key_code()) { | |
| 453 case ui::VKEY_ESCAPE: | |
| 454 CancelSelection(); | |
| 455 break; | |
| 456 case ui::VKEY_UP: | |
| 457 num_key_presses_++; | |
| 458 Move(WindowSelector::UP, true); | |
| 459 break; | |
| 460 case ui::VKEY_DOWN: | |
| 461 num_key_presses_++; | |
| 462 Move(WindowSelector::DOWN, true); | |
| 463 break; | |
| 464 case ui::VKEY_RIGHT: | |
| 465 case ui::VKEY_TAB: | |
| 466 if (key_event.key_code() == ui::VKEY_RIGHT || | |
| 467 !(key_event.flags() & ui::EF_SHIFT_DOWN)) { | |
| 468 num_key_presses_++; | |
| 469 Move(WindowSelector::RIGHT, true); | |
| 470 break; | |
| 471 } | |
| 472 case ui::VKEY_LEFT: | |
| 473 num_key_presses_++; | |
| 474 Move(WindowSelector::LEFT, true); | |
| 475 break; | |
| 476 case ui::VKEY_W: | |
| 477 if (!(key_event.flags() & ui::EF_CONTROL_DOWN) || | |
| 478 !grid_list_[selected_grid_index_]->is_selecting()) { | |
| 479 // Allow the textfield to handle 'W' key when not used with Ctrl. | |
| 480 return false; | |
| 481 } | |
| 482 WmShell::Get()->RecordUserMetricsAction(UMA_WINDOW_OVERVIEW_CLOSE_KEY); | |
| 483 grid_list_[selected_grid_index_]->SelectedWindow()->CloseWindow(); | |
| 484 break; | |
| 485 case ui::VKEY_RETURN: | |
| 486 // Ignore if no item is selected. | |
| 487 if (!grid_list_[selected_grid_index_]->is_selecting()) | |
| 488 return false; | |
| 489 UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.ArrowKeyPresses", | |
| 490 num_key_presses_); | |
| 491 UMA_HISTOGRAM_CUSTOM_COUNTS("Ash.WindowSelector.KeyPressesOverItemsRatio", | |
| 492 (num_key_presses_ * 100) / num_items_, 1, 300, | |
| 493 30); | |
| 494 WmShell::Get()->RecordUserMetricsAction(UMA_WINDOW_OVERVIEW_ENTER_KEY); | |
| 495 SelectWindow(grid_list_[selected_grid_index_]->SelectedWindow()); | |
| 496 break; | |
| 497 default: | |
| 498 // Not a key we are interested in, allow the textfield to handle it. | |
| 499 return false; | |
| 500 } | |
| 501 return true; | |
| 502 } | |
| 503 | |
| 504 void WindowSelector::OnDisplayAdded(const display::Display& display) {} | |
| 505 | |
| 506 void WindowSelector::OnDisplayRemoved(const display::Display& display) { | |
| 507 // TODO(flackr): Keep window selection active on remaining displays. | |
| 508 CancelSelection(); | |
| 509 } | |
| 510 | |
| 511 void WindowSelector::OnDisplayMetricsChanged(const display::Display& display, | |
| 512 uint32_t metrics) { | |
| 513 PositionWindows(/* animate */ false); | |
| 514 RepositionTextFilterOnDisplayMetricsChange(); | |
| 515 } | |
| 516 | |
| 517 void WindowSelector::OnWindowHierarchyChanged( | |
| 518 const HierarchyChangeParams& params) { | |
| 519 // Only care about newly added children of |observed_windows_|. | |
| 520 if (!observed_windows_.count(WmWindow::Get(params.receiver)) || | |
| 521 !observed_windows_.count(WmWindow::Get(params.new_parent))) { | |
| 522 return; | |
| 523 } | |
| 524 | |
| 525 WmWindow* new_window = WmWindow::Get(params.target); | |
| 526 if (!IsSelectable(new_window)) | |
| 527 return; | |
| 528 | |
| 529 for (size_t i = 0; i < wm::kSwitchableWindowContainerIdsLength; ++i) { | |
| 530 if (new_window->GetParent()->GetShellWindowId() == | |
| 531 wm::kSwitchableWindowContainerIds[i] && | |
| 532 !new_window->GetTransientParent()) { | |
| 533 // The new window is in one of the switchable containers, abort overview. | |
| 534 CancelSelection(); | |
| 535 return; | |
| 536 } | |
| 537 } | |
| 538 } | |
| 539 | |
| 540 void WindowSelector::OnWindowDestroying(aura::Window* window) { | |
| 541 window->RemoveObserver(this); | |
| 542 observed_windows_.erase(WmWindow::Get(window)); | |
| 543 if (WmWindow::Get(window) == restore_focus_window_) | |
| 544 restore_focus_window_ = nullptr; | |
| 545 } | |
| 546 | |
| 547 void WindowSelector::OnWindowActivated(WmWindow* gained_active, | |
| 548 WmWindow* lost_active) { | |
| 549 if (ignore_activations_ || !gained_active || | |
| 550 gained_active == GetTextFilterWidgetWindow()) { | |
| 551 return; | |
| 552 } | |
| 553 | |
| 554 WmWindow* root_window = gained_active->GetRootWindow(); | |
| 555 auto grid = | |
| 556 std::find_if(grid_list_.begin(), grid_list_.end(), | |
| 557 [root_window](const std::unique_ptr<WindowGrid>& grid) { | |
| 558 return grid->root_window() == root_window; | |
| 559 }); | |
| 560 if (grid == grid_list_.end()) | |
| 561 return; | |
| 562 const auto& windows = (*grid)->window_list(); | |
| 563 | |
| 564 auto iter = std::find_if( | |
| 565 windows.begin(), windows.end(), | |
| 566 [gained_active](const std::unique_ptr<WindowSelectorItem>& window) { | |
| 567 return window->Contains(gained_active); | |
| 568 }); | |
| 569 | |
| 570 if (iter == windows.end() && showing_text_filter_ && | |
| 571 lost_active == GetTextFilterWidgetWindow()) { | |
| 572 return; | |
| 573 } | |
| 574 | |
| 575 // Don't restore focus on exit if a window was just activated. | |
| 576 ResetFocusRestoreWindow(false); | |
| 577 CancelSelection(); | |
| 578 } | |
| 579 | |
| 580 void WindowSelector::OnAttemptToReactivateWindow(WmWindow* request_active, | |
| 581 WmWindow* actual_active) { | |
| 582 OnWindowActivated(request_active, actual_active); | |
| 583 } | |
| 584 | |
| 585 void WindowSelector::ContentsChanged(views::Textfield* sender, | |
| 586 const base::string16& new_contents) { | |
| 587 text_filter_string_length_ = new_contents.length(); | |
| 588 if (!text_filter_string_length_) | |
| 589 num_times_textfield_cleared_++; | |
| 590 | |
| 591 bool should_show_text_filter = !new_contents.empty(); | |
| 592 if (showing_text_filter_ != should_show_text_filter) { | |
| 593 WmWindow* text_filter_widget_window = GetTextFilterWidgetWindow(); | |
| 594 ui::ScopedLayerAnimationSettings animation_settings( | |
| 595 text_filter_widget_window->GetLayer()->GetAnimator()); | |
| 596 animation_settings.SetPreemptionStrategy( | |
| 597 ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET); | |
| 598 animation_settings.SetTweenType(showing_text_filter_ | |
| 599 ? gfx::Tween::FAST_OUT_LINEAR_IN | |
| 600 : gfx::Tween::LINEAR_OUT_SLOW_IN); | |
| 601 | |
| 602 gfx::Transform transform; | |
| 603 if (should_show_text_filter) { | |
| 604 transform.Translate(0, 0); | |
| 605 text_filter_widget_window->SetOpacity(1); | |
| 606 } else { | |
| 607 transform.Translate(0, -text_filter_bottom_); | |
| 608 text_filter_widget_window->SetOpacity(0); | |
| 609 } | |
| 610 | |
| 611 text_filter_widget_window->SetTransform(transform); | |
| 612 showing_text_filter_ = should_show_text_filter; | |
| 613 } | |
| 614 for (auto iter = grid_list_.begin(); iter != grid_list_.end(); iter++) | |
| 615 (*iter)->FilterItems(new_contents); | |
| 616 | |
| 617 // If the selection widget is not active, execute a Move() command so that it | |
| 618 // shows up on the first undimmed item. | |
| 619 if (grid_list_[selected_grid_index_]->is_selecting()) | |
| 620 return; | |
| 621 Move(WindowSelector::RIGHT, false); | |
| 622 } | |
| 623 | |
| 624 WmWindow* WindowSelector::GetTextFilterWidgetWindow() { | |
| 625 return WmWindow::Get(text_filter_widget_->GetNativeWindow()); | |
| 626 } | |
| 627 | |
| 628 void WindowSelector::PositionWindows(bool animate) { | |
| 629 for (std::unique_ptr<WindowGrid>& grid : grid_list_) | |
| 630 grid->PositionWindows(animate); | |
| 631 } | |
| 632 | |
| 633 void WindowSelector::RepositionTextFilterOnDisplayMetricsChange() { | |
| 634 WmWindow* root_window = WmShell::Get()->GetPrimaryRootWindow(); | |
| 635 const gfx::Rect rect = GetTextFilterPosition(root_window); | |
| 636 text_filter_bottom_ = rect.bottom() + kTextFieldBottomMargin; | |
| 637 text_filter_widget_->SetBounds(rect); | |
| 638 | |
| 639 gfx::Transform transform; | |
| 640 transform.Translate( | |
| 641 0, text_filter_string_length_ == 0 ? -text_filter_bottom_ : 0); | |
| 642 WmWindow* text_filter_window = GetTextFilterWidgetWindow(); | |
| 643 text_filter_window->SetOpacity(text_filter_string_length_ == 0 ? 0 : 1); | |
| 644 text_filter_window->SetTransform(transform); | |
| 645 } | |
| 646 | |
| 647 void WindowSelector::ResetFocusRestoreWindow(bool focus) { | |
| 648 if (!restore_focus_window_) | |
| 649 return; | |
| 650 if (focus) { | |
| 651 base::AutoReset<bool> restoring_focus(&ignore_activations_, true); | |
| 652 restore_focus_window_->Activate(); | |
| 653 } | |
| 654 // If the window is in the observed_windows_ list it needs to continue to be | |
| 655 // observed. | |
| 656 if (observed_windows_.find(restore_focus_window_) == | |
| 657 observed_windows_.end()) { | |
| 658 restore_focus_window_->aura_window()->RemoveObserver(this); | |
| 659 } | |
| 660 restore_focus_window_ = nullptr; | |
| 661 } | |
| 662 | |
| 663 void WindowSelector::Move(Direction direction, bool animate) { | |
| 664 // Direction to move if moving past the end of a display. | |
| 665 int display_direction = (direction == RIGHT || direction == DOWN) ? 1 : -1; | |
| 666 | |
| 667 // If this is the first move and it's going backwards, start on the last | |
| 668 // display. | |
| 669 if (display_direction == -1 && !grid_list_.empty() && | |
| 670 !grid_list_[selected_grid_index_]->is_selecting()) { | |
| 671 selected_grid_index_ = grid_list_.size() - 1; | |
| 672 } | |
| 673 | |
| 674 // Keep calling Move() on the grids until one of them reports no overflow or | |
| 675 // we made a full cycle on all the grids. | |
| 676 for (size_t i = 0; i <= grid_list_.size() && | |
| 677 grid_list_[selected_grid_index_]->Move(direction, animate); | |
| 678 i++) { | |
| 679 selected_grid_index_ = | |
| 680 (selected_grid_index_ + display_direction + grid_list_.size()) % | |
| 681 grid_list_.size(); | |
| 682 } | |
| 683 } | |
| 684 | |
| 685 } // namespace ash | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2734653002:
chromeos: Move files in //ash/common to //ash (Closed)
