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/wm/window_positioner.h" 6 7 #include "ash/ash_switches.h" 8 #include "ash/screen_util.h" 9 #include "ash/shell.h" 10 #include "ash/shell_window_ids.h" 11 #include "ash/wm/mru_window_tracker.h" 12 #include "ash/wm/window_resizer.h" 13 #include "ash/wm/window_state.h" 14 #include "ash/wm/window_util.h" 15 #include "base/command_line.h" 16 #include "ui/aura/window.h" 17 #include "ui/aura/window_delegate.h" 18 #include "ui/aura/window_event_dispatcher.h" 19 #include "ui/compositor/layer.h" 20 #include "ui/compositor/scoped_layer_animation_settings.h" 21 #include "ui/gfx/screen.h" 22 #include "ui/wm/core/window_animations.h" 23 #include "ui/wm/core/window_util.h" 24 25 namespace ash { 26 27 const int WindowPositioner::kMinimumWindowOffset = 32; 28 29 // The number of pixels which are kept free top, left and right when a window 30 // gets positioned to its default location. 31 // static 32 const int WindowPositioner::kDesktopBorderSize = 16; 33 34 // Maximum width of a window even if there is more room on the desktop. 35 // static 36 const int WindowPositioner::kMaximumWindowWidth = 1100; 37 38 namespace { 39 40 // When a window gets opened in default mode and the screen is less than or 41 // equal to this width, the window will get opened in maximized mode. This value 42 // can be reduced to a "tame" number if the feature is disabled. 43 const int kForceMaximizeWidthLimit = 1366; 44 45 // The time in milliseconds which should be used to visually move a window 46 // through an automatic "intelligent" window management option. 47 const int kWindowAutoMoveDurationMS = 125; 48 49 // If set to true all window repositioning actions will be ignored. Set through 50 // WindowPositioner::SetIgnoreActivations(). 51 static bool disable_auto_positioning = false; 52 53 // If set to true, by default the first window in ASH will be maximized. 54 static bool maximize_first_window = false; 55 56 // Check if any management should be performed (with a given |window|). 57 bool UseAutoWindowManager(const aura::Window* window) { 58 if (disable_auto_positioning) 59 return false; 60 const wm::WindowState* window_state = wm::GetWindowState(window); 61 return !window_state->is_dragged() && window_state->window_position_managed(); 62 } 63 64 // Check if a given |window| can be managed. This includes that it's state is 65 // not minimized/maximized/the user has changed it's size by hand already. 66 // It furthermore checks for the WindowIsManaged status. 67 bool WindowPositionCanBeManaged(const aura::Window* window) { 68 if (disable_auto_positioning) 69 return false; 70 const wm::WindowState* window_state = wm::GetWindowState(window); 71 return window_state->window_position_managed() && 72 !window_state->IsMinimized() && 73 !window_state->IsMaximized() && 74 !window_state->bounds_changed_by_user(); 75 } 76 77 // Get the work area for a given |window| in parent coordinates. 78 gfx::Rect GetWorkAreaForWindowInParent(aura::Window* window) { 79 #if defined(OS_WIN) 80 // On Win 8, the host window can't be resized, so 81 // use window's bounds instead. 82 // TODO(oshima): Emulate host window resize on win8. 83 gfx::Rect work_area = gfx::Rect(window->parent()->bounds().size()); 84 work_area.Inset(Shell::GetScreen()->GetDisplayMatching( 85 window->parent()->GetBoundsInScreen()).GetWorkAreaInsets()); 86 return work_area; 87 #else 88 return ScreenUtil::GetDisplayWorkAreaBoundsInParent(window); 89 #endif 90 } 91 92 // Move the given |bounds| on the available |work_area| in the direction 93 // indicated by |move_right|. If |move_right| is true, the rectangle gets moved 94 // to the right edge, otherwise to the left one. 95 bool MoveRectToOneSide(const gfx::Rect& work_area, 96 bool move_right, 97 gfx::Rect* bounds) { 98 if (move_right) { 99 if (work_area.right() > bounds->right()) { 100 bounds->set_x(work_area.right() - bounds->width()); 101 return true; 102 } 103 } else { 104 if (work_area.x() < bounds->x()) { 105 bounds->set_x(work_area.x()); 106 return true; 107 } 108 } 109 return false; 110 } 111 112 // Move a |window| to new |bounds|. Animate if desired by user. 113 // Moves the transient children of the |window| as well by the same |offset| as 114 // the parent |window|. 115 void SetBoundsAndOffsetTransientChildren(aura::Window* window, 116 const gfx::Rect& bounds, 117 const gfx::Rect& work_area, 118 const gfx::Vector2d& offset) { 119 aura::Window::Windows transient_children = 120 ::wm::GetTransientChildren(window); 121 for (aura::Window::Windows::iterator iter = transient_children.begin(); 122 iter != transient_children.end(); ++iter) { 123 aura::Window* transient_child = *iter; 124 gfx::Rect child_bounds = transient_child->bounds(); 125 gfx::Rect new_child_bounds = child_bounds + offset; 126 if ((child_bounds.x() <= work_area.x() && 127 new_child_bounds.x() <= work_area.x()) || 128 (child_bounds.right() >= work_area.right() && 129 new_child_bounds.right() >= work_area.right())) { 130 continue; 131 } 132 if (new_child_bounds.right() > work_area.right()) 133 new_child_bounds.set_x(work_area.right() - bounds.width()); 134 else if (new_child_bounds.x() < work_area.x()) 135 new_child_bounds.set_x(work_area.x()); 136 SetBoundsAndOffsetTransientChildren(transient_child, 137 new_child_bounds, work_area, offset); 138 } 139 140 if (::wm::WindowAnimationsDisabled(window)) { 141 window->SetBounds(bounds); 142 return; 143 } 144 145 ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator()); 146 settings.SetTransitionDuration( 147 base::TimeDelta::FromMilliseconds(kWindowAutoMoveDurationMS)); 148 window->SetBounds(bounds); 149 } 150 151 // Move a |window| to new |bounds|. Animate if desired by user. 152 // Note: The function will do nothing if the bounds did not change. 153 void SetBoundsAnimated(aura::Window* window, 154 const gfx::Rect& bounds, 155 const gfx::Rect& work_area) { 156 gfx::Rect old_bounds = window->GetTargetBounds(); 157 if (bounds == old_bounds) 158 return; 159 gfx::Vector2d offset(bounds.origin() - old_bounds.origin()); 160 SetBoundsAndOffsetTransientChildren(window, bounds, work_area, offset); 161 } 162 163 // Move |window| into the center of the screen - or restore it to the previous 164 // position. 165 void AutoPlaceSingleWindow(aura::Window* window, bool animated) { 166 gfx::Rect work_area = GetWorkAreaForWindowInParent(window); 167 gfx::Rect bounds = window->bounds(); 168 const gfx::Rect* user_defined_area = 169 wm::GetWindowState(window)->pre_auto_manage_window_bounds(); 170 if (user_defined_area) { 171 bounds = *user_defined_area; 172 ash::wm::AdjustBoundsToEnsureMinimumWindowVisibility(work_area, &bounds); 173 } else { 174 // Center the window (only in x). 175 bounds.set_x(work_area.x() + (work_area.width() - bounds.width()) / 2); 176 } 177 178 if (animated) 179 SetBoundsAnimated(window, bounds, work_area); 180 else 181 window->SetBounds(bounds); 182 } 183 184 // Get the first open (non minimized) window which is on the screen defined. 185 aura::Window* GetReferenceWindow(const aura::Window* root_window, 186 const aura::Window* exclude, 187 bool *single_window) { 188 if (single_window) 189 *single_window = true; 190 // Get the active window. 191 aura::Window* active = ash::wm::GetActiveWindow(); 192 if (active && active->GetRootWindow() != root_window) 193 active = NULL; 194 195 // Get a list of all windows. 196 const std::vector<aura::Window*> windows = 197 ash::MruWindowTracker::BuildWindowList(false); 198 199 if (windows.empty()) 200 return NULL; 201 202 aura::Window::Windows::const_iterator iter = windows.begin(); 203 // Find the index of the current active window. 204 if (active) 205 iter = std::find(windows.begin(), windows.end(), active); 206 207 int index = (iter == windows.end()) ? 0 : (iter - windows.begin()); 208 209 // Scan the cycle list backwards to see which is the second topmost window 210 // (and so on). Note that we might cycle a few indices twice if there is no 211 // suitable window. However - since the list is fairly small this should be 212 // very fast anyways. 213 aura::Window* found = NULL; 214 for (int i = index + windows.size(); i >= 0; i--) { 215 aura::Window* window = windows[i % windows.size()]; 216 while (::wm::GetTransientParent(window)) 217 window = ::wm::GetTransientParent(window); 218 if (window != exclude && window->type() == ui::wm::WINDOW_TYPE_NORMAL && 219 window->GetRootWindow() == root_window && window->TargetVisibility() && 220 wm::GetWindowState(window)->window_position_managed()) { 221 if (found && found != window) { 222 // no need to check !single_window because the function must have 223 // been already returned in the "if (!single_window)" below. 224 *single_window = false; 225 return found; 226 } 227 found = window; 228 // If there is no need to check single window, return now. 229 if (!single_window) 230 return found; 231 } 232 } 233 return found; 234 } 235 236 } // namespace 237 238 // static 239 int WindowPositioner::GetForceMaximizedWidthLimit() { 240 return kForceMaximizeWidthLimit; 241 } 242 243 // static 244 void WindowPositioner::GetBoundsAndShowStateForNewWindow( 245 const gfx::Screen* screen, 246 const aura::Window* new_window, 247 bool is_saved_bounds, 248 ui::WindowShowState show_state_in, 249 gfx::Rect* bounds_in_out, 250 ui::WindowShowState* show_state_out) { 251 252 // Always open new window in the target display. 253 aura::Window* target = Shell::GetTargetRootWindow(); 254 255 aura::Window* top_window = GetReferenceWindow(target, NULL, NULL); 256 // Our window should not have any impact if we are already on top. 257 if (top_window == new_window) 258 top_window = NULL; 259 260 // If there is no valid other window we take and adjust the passed coordinates 261 // and show state. 262 if (!top_window) { 263 gfx::Rect work_area = screen->GetDisplayNearestWindow(target).work_area(); 264 265 bounds_in_out->AdjustToFit(work_area); 266 // Use adjusted saved bounds, if there is one. 267 if (is_saved_bounds) 268 return; 269 // When using "small screens" we want to always open in full screen mode. 270 if (show_state_in == ui::SHOW_STATE_DEFAULT && (maximize_first_window || 271 (work_area.width() <= GetForceMaximizedWidthLimit() && 272 (!new_window || !wm::GetWindowState(new_window)->IsFullscreen())))) { 273 *show_state_out = ui::SHOW_STATE_MAXIMIZED; 274 } 275 return; 276 } 277 wm::WindowState* top_window_state = wm::GetWindowState(top_window); 278 bool maximized = top_window_state->IsMaximized(); 279 // We ignore the saved show state, but look instead for the top level 280 // window's show state. 281 if (show_state_in == ui::SHOW_STATE_DEFAULT) { 282 *show_state_out = maximized ? ui::SHOW_STATE_MAXIMIZED : 283 ui::SHOW_STATE_DEFAULT; 284 } 285 286 if (maximized) { 287 bool has_restore_bounds = top_window_state->HasRestoreBounds(); 288 if (has_restore_bounds) { 289 // For a maximized window ignore the real bounds of the top level window 290 // and use its restore bounds instead. Offset the bounds to prevent the 291 // windows from overlapping exactly when restored. 292 *bounds_in_out = top_window_state->GetRestoreBoundsInScreen() + 293 gfx::Vector2d(kMinimumWindowOffset, kMinimumWindowOffset); 294 } 295 if (is_saved_bounds || has_restore_bounds) { 296 gfx::Rect work_area = screen->GetDisplayNearestWindow(target).work_area(); 297 bounds_in_out->AdjustToFit(work_area); 298 // Use adjusted saved bounds or restore bounds, if there is one. 299 return; 300 } 301 } 302 303 // Use the size of the other window. The window's bound will be rearranged 304 // in ash::WorkspaceLayoutManager using this location. 305 *bounds_in_out = top_window->GetBoundsInScreen(); 306 } 307 308 // static 309 void WindowPositioner::RearrangeVisibleWindowOnHideOrRemove( 310 const aura::Window* removed_window) { 311 if (!UseAutoWindowManager(removed_window)) 312 return; 313 // Find a single open browser window. 314 bool single_window; 315 aura::Window* other_shown_window = GetReferenceWindow( 316 removed_window->GetRootWindow(), removed_window, &single_window); 317 if (!other_shown_window || !single_window || 318 !WindowPositionCanBeManaged(other_shown_window)) 319 return; 320 AutoPlaceSingleWindow(other_shown_window, true); 321 } 322 323 // static 324 bool WindowPositioner::DisableAutoPositioning(bool ignore) { 325 bool old_state = disable_auto_positioning; 326 disable_auto_positioning = ignore; 327 return old_state; 328 } 329 330 // static 331 void WindowPositioner::RearrangeVisibleWindowOnShow( 332 aura::Window* added_window) { 333 wm::WindowState* added_window_state = wm::GetWindowState(added_window); 334 if (!added_window->TargetVisibility()) 335 return; 336 337 if (!UseAutoWindowManager(added_window) || 338 added_window_state->bounds_changed_by_user()) { 339 if (added_window_state->minimum_visibility()) { 340 // Guarantee minimum visibility within the work area. 341 gfx::Rect work_area = GetWorkAreaForWindowInParent(added_window); 342 gfx::Rect bounds = added_window->bounds(); 343 gfx::Rect new_bounds = bounds; 344 ash::wm::AdjustBoundsToEnsureMinimumWindowVisibility(work_area, 345 &new_bounds); 346 if (new_bounds != bounds) 347 added_window->SetBounds(new_bounds); 348 } 349 return; 350 } 351 // Find a single open managed window. 352 bool single_window; 353 aura::Window* other_shown_window = GetReferenceWindow( 354 added_window->GetRootWindow(), added_window, &single_window); 355 356 if (!other_shown_window) { 357 // It could be that this window is the first window joining the workspace. 358 if (!WindowPositionCanBeManaged(added_window) || other_shown_window) 359 return; 360 // Since we might be going from 0 to 1 window, we have to arrange the new 361 // window to a good default. 362 AutoPlaceSingleWindow(added_window, false); 363 return; 364 } 365 366 gfx::Rect other_bounds = other_shown_window->bounds(); 367 gfx::Rect work_area = GetWorkAreaForWindowInParent(added_window); 368 bool move_other_right = 369 other_bounds.CenterPoint().x() > work_area.x() + work_area.width() / 2; 370 371 // Push the other window to the size only if there are two windows left. 372 if (single_window) { 373 // When going from one to two windows both windows loose their 374 // "positioned by user" flags. 375 added_window_state->set_bounds_changed_by_user(false); 376 wm::WindowState* other_window_state = 377 wm::GetWindowState(other_shown_window); 378 other_window_state->set_bounds_changed_by_user(false); 379 380 if (WindowPositionCanBeManaged(other_shown_window)) { 381 // Don't override pre auto managed bounds as the current bounds 382 // may not be original. 383 if (!other_window_state->pre_auto_manage_window_bounds()) 384 other_window_state->SetPreAutoManageWindowBounds(other_bounds); 385 386 // Push away the other window after remembering its current position. 387 if (MoveRectToOneSide(work_area, move_other_right, &other_bounds)) 388 SetBoundsAnimated(other_shown_window, other_bounds, work_area); 389 } 390 } 391 392 // Remember the current location of the window if it's new and push 393 // it also to the opposite location if needed. Since it is just 394 // being shown, we do not need to animate it. 395 gfx::Rect added_bounds = added_window->bounds(); 396 if (!added_window_state->pre_auto_manage_window_bounds()) 397 added_window_state->SetPreAutoManageWindowBounds(added_bounds); 398 if (MoveRectToOneSide(work_area, !move_other_right, &added_bounds)) 399 added_window->SetBounds(added_bounds); 400 } 401 402 WindowPositioner::WindowPositioner() 403 : pop_position_offset_increment_x(0), 404 pop_position_offset_increment_y(0), 405 popup_position_offset_from_screen_corner_x(0), 406 popup_position_offset_from_screen_corner_y(0), 407 last_popup_position_x_(0), 408 last_popup_position_y_(0) { 409 } 410 411 WindowPositioner::~WindowPositioner() { 412 } 413 414 gfx::Rect WindowPositioner::GetDefaultWindowBounds( 415 const gfx::Display& display) { 416 const gfx::Rect work_area = display.work_area(); 417 // There should be a 'desktop' border around the window at the left and right 418 // side. 419 int default_width = work_area.width() - 2 * kDesktopBorderSize; 420 // There should also be a 'desktop' border around the window at the top. 421 // Since the workspace excludes the tray area we only need one border size. 422 int default_height = work_area.height() - kDesktopBorderSize; 423 int offset_x = kDesktopBorderSize; 424 if (default_width > kMaximumWindowWidth) { 425 // The window should get centered on the screen and not follow the grid. 426 offset_x = (work_area.width() - kMaximumWindowWidth) / 2; 427 default_width = kMaximumWindowWidth; 428 } 429 return gfx::Rect(work_area.x() + offset_x, 430 work_area.y() + kDesktopBorderSize, 431 default_width, 432 default_height); 433 } 434 435 gfx::Rect WindowPositioner::GetPopupPosition(const gfx::Rect& old_pos) { 436 int grid = kMinimumWindowOffset; 437 popup_position_offset_from_screen_corner_x = grid; 438 popup_position_offset_from_screen_corner_y = grid; 439 if (!pop_position_offset_increment_x) { 440 // When the popup position increment is 0, the last popup position 441 // was not yet initialized. 442 last_popup_position_x_ = popup_position_offset_from_screen_corner_x; 443 last_popup_position_y_ = popup_position_offset_from_screen_corner_y; 444 } 445 pop_position_offset_increment_x = grid; 446 pop_position_offset_increment_y = grid; 447 // We handle the Multi monitor support by retrieving the active window's 448 // work area. 449 aura::Window* window = wm::GetActiveWindow(); 450 const gfx::Rect work_area = window && window->IsVisible() ? 451 Shell::GetScreen()->GetDisplayNearestWindow(window).work_area() : 452 Shell::GetScreen()->GetPrimaryDisplay().work_area(); 453 // Only try to reposition the popup when it is not spanning the entire 454 // screen. 455 if ((old_pos.width() + popup_position_offset_from_screen_corner_x >= 456 work_area.width()) || 457 (old_pos.height() + popup_position_offset_from_screen_corner_y >= 458 work_area.height())) 459 return AlignPopupPosition(old_pos, work_area, grid); 460 const gfx::Rect result = SmartPopupPosition(old_pos, work_area, grid); 461 if (!result.IsEmpty()) 462 return AlignPopupPosition(result, work_area, grid); 463 return NormalPopupPosition(old_pos, work_area); 464 } 465 466 // static 467 void WindowPositioner::SetMaximizeFirstWindow(bool maximize) { 468 maximize_first_window = maximize; 469 } 470 471 gfx::Rect WindowPositioner::NormalPopupPosition( 472 const gfx::Rect& old_pos, 473 const gfx::Rect& work_area) { 474 int w = old_pos.width(); 475 int h = old_pos.height(); 476 // Note: The 'last_popup_position' is checked and kept relative to the 477 // screen size. The offsetting will be done in the last step when the 478 // target rectangle gets returned. 479 bool reset = false; 480 if (last_popup_position_y_ + h > work_area.height() || 481 last_popup_position_x_ + w > work_area.width()) { 482 // Popup does not fit on screen. Reset to next diagonal row. 483 last_popup_position_x_ -= last_popup_position_y_ - 484 popup_position_offset_from_screen_corner_x - 485 pop_position_offset_increment_x; 486 last_popup_position_y_ = popup_position_offset_from_screen_corner_y; 487 reset = true; 488 } 489 if (last_popup_position_x_ + w > work_area.width()) { 490 // Start again over. 491 last_popup_position_x_ = popup_position_offset_from_screen_corner_x; 492 last_popup_position_y_ = popup_position_offset_from_screen_corner_y; 493 reset = true; 494 } 495 int x = last_popup_position_x_; 496 int y = last_popup_position_y_; 497 if (!reset) { 498 last_popup_position_x_ += pop_position_offset_increment_x; 499 last_popup_position_y_ += pop_position_offset_increment_y; 500 } 501 return gfx::Rect(x + work_area.x(), y + work_area.y(), w, h); 502 } 503 504 gfx::Rect WindowPositioner::SmartPopupPosition( 505 const gfx::Rect& old_pos, 506 const gfx::Rect& work_area, 507 int grid) { 508 const std::vector<aura::Window*> windows = 509 MruWindowTracker::BuildWindowList(false); 510 511 std::vector<const gfx::Rect*> regions; 512 // Process the window list and check if we can bail immediately. 513 for (size_t i = 0; i < windows.size(); i++) { 514 // We only include opaque and visible windows. 515 if (windows[i] && windows[i]->IsVisible() && windows[i]->layer() && 516 (!windows[i]->transparent() || 517 windows[i]->layer()->GetTargetOpacity() == 1.0)) { 518 wm::WindowState* window_state = wm::GetWindowState(windows[i]); 519 // When any window is maximized we cannot find any free space. 520 if (window_state->IsMaximizedOrFullscreen()) 521 return gfx::Rect(0, 0, 0, 0); 522 if (window_state->IsNormalOrSnapped()) 523 regions.push_back(&windows[i]->bounds()); 524 } 525 } 526 527 if (regions.empty()) 528 return gfx::Rect(0, 0, 0, 0); 529 530 int w = old_pos.width(); 531 int h = old_pos.height(); 532 int x_end = work_area.width() / 2; 533 int x, x_increment; 534 // We parse for a proper location on the screen. We do this in two runs: 535 // The first run will start from the left, parsing down, skipping any 536 // overlapping windows it will encounter until the popup's height can not 537 // be served anymore. Then the next grid position to the right will be 538 // taken, and the same cycle starts again. This will be repeated until we 539 // hit the middle of the screen (or we find a suitable location). 540 // In the second run we parse beginning from the right corner downwards and 541 // then to the left. 542 // When no location was found, an empty rectangle will be returned. 543 for (int run = 0; run < 2; run++) { 544 if (run == 0) { // First run: Start left, parse right till mid screen. 545 x = 0; 546 x_increment = pop_position_offset_increment_x; 547 } else { // Second run: Start right, parse left till mid screen. 548 x = work_area.width() - w; 549 x_increment = -pop_position_offset_increment_x; 550 } 551 // Note: The passing (x,y,w,h) window is always relative to the work area's 552 // origin. 553 for (; x_increment > 0 ? (x < x_end) : (x > x_end); x += x_increment) { 554 int y = 0; 555 while (y + h <= work_area.height()) { 556 size_t i; 557 for (i = 0; i < regions.size(); i++) { 558 if (regions[i]->Intersects(gfx::Rect(x + work_area.x(), 559 y + work_area.y(), w, h))) { 560 y = regions[i]->bottom() - work_area.y(); 561 break; 562 } 563 } 564 if (i >= regions.size()) 565 return gfx::Rect(x + work_area.x(), y + work_area.y(), w, h); 566 } 567 } 568 } 569 return gfx::Rect(0, 0, 0, 0); 570 } 571 572 gfx::Rect WindowPositioner::AlignPopupPosition( 573 const gfx::Rect& pos, 574 const gfx::Rect& work_area, 575 int grid) { 576 if (grid <= 1) 577 return pos; 578 579 int x = pos.x() - (pos.x() - work_area.x()) % grid; 580 int y = pos.y() - (pos.y() - work_area.y()) % grid; 581 int w = pos.width(); 582 int h = pos.height(); 583 584 // If the alignment was pushing the window out of the screen, we ignore the 585 // alignment for that call. 586 if (abs(pos.right() - work_area.right()) < grid) 587 x = work_area.right() - w; 588 if (abs(pos.bottom() - work_area.bottom()) < grid) 589 y = work_area.bottom() - h; 590 return gfx::Rect(x, y, w, h); 591 } 592 593 } // namespace ash 594
