Google Git
Sign in
android / platform / external / chromium_org / a3f6a49 / . / ash / wm / dock / docked_window_layout_manager.cc
blob: 3298f05602fceab57d553833909fe8408ee21718 [file] [log] [blame]
// Copyright (c) 2013 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 "ash/wm/dock/docked_window_layout_manager.h"
#include "ash/ash_switches.h"
#include "ash/launcher/launcher.h"
#include "ash/screen_ash.h"
#include "ash/shelf/shelf_layout_manager.h"
#include "ash/shelf/shelf_types.h"
#include "ash/shelf/shelf_widget.h"
#include "ash/shell.h"
#include "ash/shell_window_ids.h"
#include "ash/wm/coordinate_conversion.h"
#include "ash/wm/window_animations.h"
#include "ash/wm/window_properties.h"
#include "ash/wm/window_state.h"
#include "ash/wm/window_util.h"
#include "ash/wm/workspace_controller.h"
#include "base/auto_reset.h"
#include "base/command_line.h"
#include "base/metrics/histogram.h"
#include "grit/ash_resources.h"
#include "third_party/skia/include/core/SkColor.h"
#include "third_party/skia/include/core/SkPaint.h"
#include "ui/aura/client/activation_client.h"
#include "ui/aura/client/focus_client.h"
#include "ui/aura/client/window_tree_client.h"
#include "ui/aura/root_window.h"
#include "ui/aura/window.h"
#include "ui/aura/window_delegate.h"
#include "ui/base/resource/resource_bundle.h"
#include "ui/compositor/scoped_layer_animation_settings.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/image/image_skia_operations.h"
#include "ui/gfx/rect.h"
#include "ui/views/background.h"
namespace ash {
namespace internal {
// Minimum, maximum width of the dock area and a width of the gap
// static
const int DockedWindowLayoutManager::kMaxDockWidth = 360;
// static
const int DockedWindowLayoutManager::kMinDockWidth = 200;
// static
const int DockedWindowLayoutManager::kMinDockGap = 2;
// static
const int DockedWindowLayoutManager::kIdealWidth = 250;
const int kMinimumHeight = 250;
const int kSlideDurationMs = 120;
const int kFadeDurationMs = 60;
const int kMinimizeDurationMs = 720;
class DockedBackgroundWidget : public views::Widget,
public internal::BackgroundAnimatorDelegate {
public:
explicit DockedBackgroundWidget(aura::Window* container)
: alignment_(DOCKED_ALIGNMENT_NONE),
background_animator_(this, 0, kLauncherBackgroundAlpha),
alpha_(0),
opaque_background_(ui::LAYER_SOLID_COLOR) {
InitWidget(container);
}
// Sets widget bounds and sizes opaque background layer to fill the widget.
void SetBackgroundBounds(const gfx::Rect bounds, DockedAlignment alignment) {
SetBounds(bounds);
opaque_background_.SetBounds(gfx::Rect(bounds.size()));
alignment_ = alignment;
}
// Sets the docked area background type and starts transition animation.
void SetPaintsBackground(
ShelfBackgroundType background_type,
BackgroundAnimatorChangeType change_type) {
float target_opacity =
(background_type == SHELF_BACKGROUND_MAXIMIZED) ? 1.0f : 0.0f;
scoped_ptr<ui::ScopedLayerAnimationSettings> opaque_background_animation;
if (change_type != BACKGROUND_CHANGE_IMMEDIATE) {
opaque_background_animation.reset(new ui::ScopedLayerAnimationSettings(
opaque_background_.GetAnimator()));
opaque_background_animation->SetTransitionDuration(
base::TimeDelta::FromMilliseconds(kTimeToSwitchBackgroundMs));
}
opaque_background_.SetOpacity(target_opacity);
// TODO(varkha): use ui::Layer on both opaque_background and normal
// background retire background_animator_ at all. It would be simpler.
// See also ShelfWidget::SetPaintsBackground.
background_animator_.SetPaintsBackground(
background_type != SHELF_BACKGROUND_DEFAULT,
change_type);
SchedulePaintInRect(gfx::Rect(GetWindowBoundsInScreen().size()));
}
// views::Widget:
virtual void OnNativeWidgetPaint(gfx::Canvas* canvas) OVERRIDE {
const gfx::ImageSkia& launcher_background(
alignment_ == DOCKED_ALIGNMENT_LEFT ?
launcher_background_left_ : launcher_background_right_);
gfx::Rect rect = gfx::Rect(GetWindowBoundsInScreen().size());
SkPaint paint;
paint.setAlpha(alpha_);
canvas->DrawImageInt(
launcher_background,
0, 0, launcher_background.width(), launcher_background.height(),
alignment_ == DOCKED_ALIGNMENT_LEFT ?
rect.width() - launcher_background.width() : 0, 0,
launcher_background.width(), rect.height(),
false,
paint);
canvas->DrawImageInt(
launcher_background,
alignment_ == DOCKED_ALIGNMENT_LEFT ?
0 : launcher_background.width() - 1, 0,
1, launcher_background.height(),
alignment_ == DOCKED_ALIGNMENT_LEFT ?
0 : launcher_background.width(), 0,
rect.width() - launcher_background.width(), rect.height(),
false,
paint);
}
// BackgroundAnimatorDelegate:
virtual void UpdateBackground(int alpha) OVERRIDE {
alpha_ = alpha;
SchedulePaintInRect(gfx::Rect(GetWindowBoundsInScreen().size()));
}
private:
void InitWidget(aura::Window* parent) {
views::Widget::InitParams params;
params.type = views::Widget::InitParams::TYPE_POPUP;
params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
params.can_activate = false;
params.keep_on_top = false;
params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
params.parent = parent;
params.accept_events = false;
set_focus_on_creation(false);
Init(params);
GetNativeWindow()->SetProperty(internal::kStayInSameRootWindowKey, true);
opaque_background_.SetColor(SK_ColorBLACK);
opaque_background_.SetBounds(gfx::Rect(GetWindowBoundsInScreen().size()));
opaque_background_.SetOpacity(0.0f);
GetNativeWindow()->layer()->Add(&opaque_background_);
Hide();
ResourceBundle& rb = ResourceBundle::GetSharedInstance();
gfx::ImageSkia launcher_background =
*rb.GetImageSkiaNamed(IDR_AURA_LAUNCHER_BACKGROUND);
launcher_background_left_ = gfx::ImageSkiaOperations::CreateRotatedImage(
launcher_background, SkBitmapOperations::ROTATION_90_CW);
launcher_background_right_ = gfx::ImageSkiaOperations::CreateRotatedImage(
launcher_background, SkBitmapOperations::ROTATION_270_CW);
}
DockedAlignment alignment_;
// The animator for the background transitions.
internal::BackgroundAnimator background_animator_;
// The alpha to use for drawing image assets covering the docked background.
int alpha_;
// Solid black background that can be made fully opaque.
ui::Layer opaque_background_;
// Backgrounds created from shelf background by 90 or 270 degree rotation.
gfx::ImageSkia launcher_background_left_;
gfx::ImageSkia launcher_background_right_;
DISALLOW_COPY_AND_ASSIGN(DockedBackgroundWidget);
};
namespace {
// Returns true if a window is a popup or a transient child.
bool IsPopupOrTransient(const aura::Window* window) {
return (window->type() == aura::client::WINDOW_TYPE_POPUP ||
window->transient_parent());
}
// Certain windows (minimized, hidden or popups) do not matter to docking.
bool IsUsedByLayout(const aura::Window* window) {
return (window->IsVisible() &&
!wm::GetWindowState(window)->IsMinimized() &&
!IsPopupOrTransient(window));
}
void UndockWindow(aura::Window* window) {
gfx::Rect previous_bounds = window->bounds();
aura::Window* old_parent = window->parent();
aura::client::ParentWindowWithContext(window, window, gfx::Rect());
if (window->parent() != old_parent)
wm::ReparentTransientChildrenOfChild(window, old_parent, window->parent());
// Start maximize or fullscreen (affecting packaged apps) animation from
// previous window bounds.
window->layer()->SetBounds(previous_bounds);
}
// Returns width that is as close as possible to |target_width| while being
// consistent with docked min and max restrictions and respects the |window|'s
// minimum and maximum size.
int GetWindowWidthCloseTo(const aura::Window* window, int target_width) {
if (!wm::GetWindowState(window)->CanResize()) {
DCHECK_LE(window->bounds().width(),
DockedWindowLayoutManager::kMaxDockWidth);
return window->bounds().width();
}
int width = std::max(DockedWindowLayoutManager::kMinDockWidth,
std::min(target_width,
DockedWindowLayoutManager::kMaxDockWidth));
if (window->delegate()) {
if (window->delegate()->GetMinimumSize().width() != 0)
width = std::max(width, window->delegate()->GetMinimumSize().width());
if (window->delegate()->GetMaximumSize().width() != 0)
width = std::min(width, window->delegate()->GetMaximumSize().width());
}
DCHECK_LE(width, DockedWindowLayoutManager::kMaxDockWidth);
return width;
}
// Returns height that is as close as possible to |target_height| while
// respecting the |window|'s minimum and maximum size.
int GetWindowHeightCloseTo(const aura::Window* window, int target_height) {
if (!wm::GetWindowState(window)->CanResize())
return window->bounds().height();
int minimum_height = kMinimumHeight;
int maximum_height = 0;
const aura::WindowDelegate* delegate(window->delegate());
if (delegate) {
if (delegate->GetMinimumSize().height() != 0) {
minimum_height = std::max(kMinimumHeight,
delegate->GetMinimumSize().height());
}
if (delegate->GetMaximumSize().height() != 0)
maximum_height = delegate->GetMaximumSize().height();
}
if (minimum_height)
target_height = std::max(target_height, minimum_height);
if (maximum_height)
target_height = std::min(target_height, maximum_height);
return target_height;
}
// A functor used to sort the windows in order of their minimum height.
struct CompareMinimumHeight {
bool operator()(WindowWithHeight win1, WindowWithHeight win2) {
return GetWindowHeightCloseTo(win1.window(), 0) <
GetWindowHeightCloseTo(win2.window(), 0);
}
};
// A functor used to sort the windows in order of their center Y position.
// |delta| is a pre-calculated distance from the bottom of one window to the top
// of the next. Its value can be positive (gap) or negative (overlap).
// Half of |delta| is used as a transition point at which windows could ideally
// swap positions.
struct CompareWindowPos {
CompareWindowPos(aura::Window* dragged_window, float delta)
: dragged_window_(dragged_window),
delta_(delta / 2) {}
bool operator()(WindowWithHeight window_with_height1,
WindowWithHeight window_with_height2) {
// Use target coordinates since animations may be active when windows are
// reordered.
aura::Window* win1(window_with_height1.window());
aura::Window* win2(window_with_height2.window());
gfx::Rect win1_bounds = ScreenAsh::ConvertRectToScreen(
win1->parent(), win1->GetTargetBounds());
gfx::Rect win2_bounds = ScreenAsh::ConvertRectToScreen(
win2->parent(), win2->GetTargetBounds());
win1_bounds.set_height(window_with_height1.height_);
win2_bounds.set_height(window_with_height2.height_);
// If one of the windows is the |dragged_window_| attempt to make an
// earlier swap between the windows than just based on their centers.
// This is possible if the dragged window is at least as tall as the other
// window.
if (win1 == dragged_window_)
return compare_two_windows(win1_bounds, win2_bounds);
if (win2 == dragged_window_)
return !compare_two_windows(win2_bounds, win1_bounds);
// Otherwise just compare the centers.
return win1_bounds.CenterPoint().y() < win2_bounds.CenterPoint().y();
}
// Based on center point tries to deduce where the drag is coming from.
// When dragging from below up the transition point is lower.
// When dragging from above down the transition point is higher.
bool compare_bounds(const gfx::Rect dragged, const gfx::Rect other) {
if (dragged.CenterPoint().y() < other.CenterPoint().y())
return dragged.CenterPoint().y() < other.y() - delta_;
return dragged.CenterPoint().y() < other.bottom() + delta_;
}
// Performs comparison both ways and selects stable result.
bool compare_two_windows(const gfx::Rect bounds1, const gfx::Rect bounds2) {
// Try comparing windows in both possible orders and see if the comparison
// is stable.
bool result1 = compare_bounds(bounds1, bounds2);
bool result2 = compare_bounds(bounds2, bounds1);
if (result1 != result2)
return result1;
// Otherwise it is not possible to be sure that the windows will not bounce.
// In this case just compare the centers.
return bounds1.CenterPoint().y() < bounds2.CenterPoint().y();
}
private:
aura::Window* dragged_window_;
float delta_;
};
} // namespace
////////////////////////////////////////////////////////////////////////////////
// A class that observes launcher shelf for bounds changes.
class DockedWindowLayoutManager::ShelfWindowObserver : public WindowObserver {
public:
explicit ShelfWindowObserver(
DockedWindowLayoutManager* docked_layout_manager)
: docked_layout_manager_(docked_layout_manager) {
DCHECK(docked_layout_manager_->launcher()->shelf_widget());
docked_layout_manager_->launcher()->shelf_widget()->GetNativeView()
->AddObserver(this);
}
virtual ~ShelfWindowObserver() {
if (docked_layout_manager_->launcher() &&
docked_layout_manager_->launcher()->shelf_widget())
docked_layout_manager_->launcher()->shelf_widget()->GetNativeView()
->RemoveObserver(this);
}
// aura::WindowObserver:
virtual void OnWindowBoundsChanged(aura::Window* window,
const gfx::Rect& old_bounds,
const gfx::Rect& new_bounds) OVERRIDE {
shelf_bounds_in_screen_ = ScreenAsh::ConvertRectToScreen(
window->parent(), new_bounds);
docked_layout_manager_->OnShelfBoundsChanged();
}
const gfx::Rect& shelf_bounds_in_screen() const {
return shelf_bounds_in_screen_;
}
private:
DockedWindowLayoutManager* docked_layout_manager_;
gfx::Rect shelf_bounds_in_screen_;
DISALLOW_COPY_AND_ASSIGN(ShelfWindowObserver);
};
////////////////////////////////////////////////////////////////////////////////
// DockedWindowLayoutManager public implementation:
DockedWindowLayoutManager::DockedWindowLayoutManager(
aura::Window* dock_container, WorkspaceController* workspace_controller)
: dock_container_(dock_container),
in_layout_(false),
dragged_window_(NULL),
is_dragged_window_docked_(false),
is_dragged_from_dock_(false),
launcher_(NULL),
workspace_controller_(workspace_controller),
in_fullscreen_(workspace_controller_->GetWindowState() ==
WORKSPACE_WINDOW_STATE_FULL_SCREEN),
docked_width_(0),
alignment_(DOCKED_ALIGNMENT_NONE),
last_active_window_(NULL),
last_action_time_(base::Time::Now()),
background_widget_(new DockedBackgroundWidget(dock_container_)) {
DCHECK(dock_container);
aura::client::GetActivationClient(Shell::GetPrimaryRootWindow())->
AddObserver(this);
Shell::GetInstance()->AddShellObserver(this);
}
DockedWindowLayoutManager::~DockedWindowLayoutManager() {
Shutdown();
}
void DockedWindowLayoutManager::Shutdown() {
if (launcher_ && launcher_->shelf_widget()) {
ShelfLayoutManager* shelf_layout_manager = ShelfLayoutManager::ForLauncher(
launcher_->shelf_widget()->GetNativeWindow());
shelf_layout_manager->RemoveObserver(this);
shelf_observer_.reset();
}
launcher_ = NULL;
for (size_t i = 0; i < dock_container_->children().size(); ++i) {
aura::Window* child = dock_container_->children()[i];
child->RemoveObserver(this);
wm::GetWindowState(child)->RemoveObserver(this);
}
aura::client::GetActivationClient(Shell::GetPrimaryRootWindow())->
RemoveObserver(this);
Shell::GetInstance()->RemoveShellObserver(this);
}
void DockedWindowLayoutManager::AddObserver(
DockedWindowLayoutManagerObserver* observer) {
observer_list_.AddObserver(observer);
}
void DockedWindowLayoutManager::RemoveObserver(
DockedWindowLayoutManagerObserver* observer) {
observer_list_.RemoveObserver(observer);
}
void DockedWindowLayoutManager::StartDragging(aura::Window* window) {
DCHECK(!dragged_window_);
dragged_window_ = window;
DCHECK(!IsPopupOrTransient(window));
// Start observing a window unless it is docked container's child in which
// case it is already observed.
if (dragged_window_->parent() != dock_container_) {
dragged_window_->AddObserver(this);
wm::GetWindowState(dragged_window_)->AddObserver(this);
}
is_dragged_from_dock_ = window->parent() == dock_container_;
DCHECK(!is_dragged_window_docked_);
}
void DockedWindowLayoutManager::DockDraggedWindow(aura::Window* window) {
DCHECK(!IsPopupOrTransient(window));
OnDraggedWindowDocked(window);
Relayout();
}
void DockedWindowLayoutManager::UndockDraggedWindow() {
DCHECK(!IsPopupOrTransient(dragged_window_));
OnDraggedWindowUndocked();
Relayout();
UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
is_dragged_from_dock_ = false;
}
void DockedWindowLayoutManager::FinishDragging(DockedAction action,
DockedActionSource source) {
DCHECK(dragged_window_);
DCHECK(!IsPopupOrTransient(dragged_window_));
if (is_dragged_window_docked_)
OnDraggedWindowUndocked();
DCHECK (!is_dragged_window_docked_);
// Stop observing a window unless it is docked container's child in which
// case it needs to keep being observed after the drag completes.
if (dragged_window_->parent() != dock_container_) {
dragged_window_->RemoveObserver(this);
wm::GetWindowState(dragged_window_)->RemoveObserver(this);
if (last_active_window_ == dragged_window_)
last_active_window_ = NULL;
} else {
// A window is no longer dragged and is a child.
// When a window becomes a child at drag start this is
// the only opportunity we will have to enforce a window
// count limit so do it here.
MaybeMinimizeChildrenExcept(dragged_window_);
}
dragged_window_ = NULL;
dragged_bounds_ = gfx::Rect();
Relayout();
UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
RecordUmaAction(action, source);
}
void DockedWindowLayoutManager::SetLauncher(ash::Launcher* launcher) {
DCHECK(!launcher_);
launcher_ = launcher;
if (launcher_->shelf_widget()) {
ShelfLayoutManager* shelf_layout_manager = ShelfLayoutManager::ForLauncher(
launcher_->shelf_widget()->GetNativeWindow());
shelf_layout_manager->AddObserver(this);
shelf_observer_.reset(new ShelfWindowObserver(this));
}
}
DockedAlignment DockedWindowLayoutManager::GetAlignmentOfWindow(
const aura::Window* window) const {
const gfx::Rect& bounds(window->GetBoundsInScreen());
// Test overlap with an existing docked area first.
if (docked_bounds_.Intersects(bounds) &&
alignment_ != DOCKED_ALIGNMENT_NONE) {
// A window is being added to other docked windows (on the same side).
return alignment_;
}
const gfx::Rect container_bounds = dock_container_->GetBoundsInScreen();
if (bounds.x() <= container_bounds.x() &&
bounds.right() > container_bounds.x()) {
return DOCKED_ALIGNMENT_LEFT;
} else if (bounds.x() < container_bounds.right() &&
bounds.right() >= container_bounds.right()) {
return DOCKED_ALIGNMENT_RIGHT;
}
return DOCKED_ALIGNMENT_NONE;
}
DockedAlignment DockedWindowLayoutManager::CalculateAlignment() const {
// Find a child that is not being dragged and is not a popup.
// If such exists the current alignment is returned - even if some of the
// children are hidden or minimized (so they can be restored without losing
// the docked state).
for (size_t i = 0; i < dock_container_->children().size(); ++i) {
aura::Window* window(dock_container_->children()[i]);
if (window != dragged_window_ && !IsPopupOrTransient(window))
return alignment_;
}
// No docked windows remain other than possibly the window being dragged.
// Return |NONE| to indicate that windows may get docked on either side.
return DOCKED_ALIGNMENT_NONE;
}
bool DockedWindowLayoutManager::CanDockWindow(aura::Window* window,
SnapType edge) {
if (!switches::UseDockedWindows())
return false;
// Don't allow interactive docking of windows with transient parents such as
// modal browser dialogs.
if (IsPopupOrTransient(window))
return false;
// If a window is wide and cannot be resized down to maximum width allowed
// then it cannot be docked.
// TODO(varkha). Prevent windows from changing size programmatically while
// they are docked. The size will take effect only once a window is undocked.
// See http://crbug.com/307792.
if (window->bounds().width() > kMaxDockWidth &&
(!wm::GetWindowState(window)->CanResize() ||
(window->delegate() &&
window->delegate()->GetMinimumSize().width() != 0 &&
window->delegate()->GetMinimumSize().width() > kMaxDockWidth))) {
return false;
}
// If a window is tall and cannot be resized down to maximum height allowed
// then it cannot be docked.
const gfx::Rect work_area =
Shell::GetScreen()->GetDisplayNearestWindow(dock_container_).work_area();
if (GetWindowHeightCloseTo(window, work_area.height() - 2 * kMinDockGap) >
work_area.height() - 2 * kMinDockGap) {
return false;
}
// Cannot dock on the other size from an existing dock.
const DockedAlignment alignment = CalculateAlignment();
if ((edge == SNAP_LEFT && alignment == DOCKED_ALIGNMENT_RIGHT) ||
(edge == SNAP_RIGHT && alignment == DOCKED_ALIGNMENT_LEFT)) {
return false;
}
// Do not allow docking on the same side as launcher shelf.
ShelfAlignment shelf_alignment = SHELF_ALIGNMENT_BOTTOM;
if (launcher_)
shelf_alignment = launcher_->alignment();
if ((edge == SNAP_LEFT && shelf_alignment == SHELF_ALIGNMENT_LEFT) ||
(edge == SNAP_RIGHT && shelf_alignment == SHELF_ALIGNMENT_RIGHT)) {
return false;
}
return true;
}
void DockedWindowLayoutManager::OnShelfBoundsChanged() {
Relayout();
UpdateDockBounds(DockedWindowLayoutManagerObserver::DISPLAY_INSETS_CHANGED);
}
////////////////////////////////////////////////////////////////////////////////
// DockedWindowLayoutManager, aura::LayoutManager implementation:
void DockedWindowLayoutManager::OnWindowResized() {
MaybeMinimizeChildrenExcept(dragged_window_);
Relayout();
// When screen resizes update the insets even when dock width or alignment
// does not change.
UpdateDockBounds(DockedWindowLayoutManagerObserver::DISPLAY_RESIZED);
}
void DockedWindowLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
if (IsPopupOrTransient(child))
return;
// Dragged windows are already observed by StartDragging and do not change
// docked alignment during the drag.
if (child == dragged_window_)
return;
// If this is the first window getting docked - update alignment.
if (alignment_ == DOCKED_ALIGNMENT_NONE) {
alignment_ = GetAlignmentOfWindow(child);
DCHECK(alignment_ != DOCKED_ALIGNMENT_NONE);
}
MaybeMinimizeChildrenExcept(child);
child->AddObserver(this);
wm::GetWindowState(child)->AddObserver(this);
Relayout();
UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
}
void DockedWindowLayoutManager::OnWindowRemovedFromLayout(aura::Window* child) {
if (IsPopupOrTransient(child))
return;
// Dragged windows are stopped being observed by FinishDragging and do not
// change alignment during the drag. They also cannot be set to be the
// |last_active_window_|.
if (child == dragged_window_)
return;
// If this is the last window, set alignment and maximize the workspace.
if (!IsAnyWindowDocked()) {
alignment_ = DOCKED_ALIGNMENT_NONE;
UpdateDockedWidth(0);
}
if (last_active_window_ == child)
last_active_window_ = NULL;
child->RemoveObserver(this);
wm::GetWindowState(child)->RemoveObserver(this);
Relayout();
UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
}
void DockedWindowLayoutManager::OnChildWindowVisibilityChanged(
aura::Window* child,
bool visible) {
if (IsPopupOrTransient(child))
return;
if (visible)
wm::GetWindowState(child)->Restore();
Relayout();
UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
}
void DockedWindowLayoutManager::SetChildBounds(
aura::Window* child,
const gfx::Rect& requested_bounds) {
// Whenever one of our windows is moved or resized enforce layout.
SetChildBoundsDirect(child, requested_bounds);
if (IsPopupOrTransient(child))
return;
ShelfLayoutManager* shelf_layout = internal::ShelfLayoutManager::ForLauncher(
dock_container_);
if (shelf_layout)
shelf_layout->UpdateVisibilityState();
}
////////////////////////////////////////////////////////////////////////////////
// DockedWindowLayoutManager, ash::ShellObserver implementation:
void DockedWindowLayoutManager::OnDisplayWorkAreaInsetsChanged() {
Relayout();
UpdateDockBounds(DockedWindowLayoutManagerObserver::DISPLAY_INSETS_CHANGED);
MaybeMinimizeChildrenExcept(dragged_window_);
}
void DockedWindowLayoutManager::OnFullscreenStateChanged(
bool is_fullscreen, aura::Window* root_window) {
if (dock_container_->GetRootWindow() != root_window)
return;
// Entering fullscreen mode (including immersive) hides docked windows.
in_fullscreen_ = workspace_controller_->GetWindowState() ==
WORKSPACE_WINDOW_STATE_FULL_SCREEN;
{
// prevent Relayout from getting called multiple times during this
base::AutoReset<bool> auto_reset_in_layout(&in_layout_, true);
// Use a copy of children array because a call to MinimizeDockedWindow or
// RestoreDockedWindow can change order.
aura::Window::Windows children(dock_container_->children());
for (aura::Window::Windows::const_iterator iter = children.begin();
iter != children.end(); ++iter) {
aura::Window* window(*iter);
if (IsPopupOrTransient(window))
continue;
wm::WindowState* window_state = wm::GetWindowState(window);
if (in_fullscreen_) {
if (window->IsVisible())
MinimizeDockedWindow(window_state);
} else {
if (!window_state->IsMinimized())
RestoreDockedWindow(window_state);
}
}
}
Relayout();
UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
}
void DockedWindowLayoutManager::OnShelfAlignmentChanged(
aura::Window* root_window) {
if (dock_container_->GetRootWindow() != root_window)
return;
if (!launcher_ || !launcher_->shelf_widget())
return;
if (alignment_ == DOCKED_ALIGNMENT_NONE)
return;
// Do not allow launcher and dock on the same side. Switch side that
// the dock is attached to and move all dock windows to that new side.
ShelfAlignment shelf_alignment = launcher_->shelf_widget()->GetAlignment();
if (alignment_ == DOCKED_ALIGNMENT_LEFT &&
shelf_alignment == SHELF_ALIGNMENT_LEFT) {
alignment_ = DOCKED_ALIGNMENT_RIGHT;
} else if (alignment_ == DOCKED_ALIGNMENT_RIGHT &&
shelf_alignment == SHELF_ALIGNMENT_RIGHT) {
alignment_ = DOCKED_ALIGNMENT_LEFT;
}
Relayout();
UpdateDockBounds(DockedWindowLayoutManagerObserver::SHELF_ALIGNMENT_CHANGED);
}
/////////////////////////////////////////////////////////////////////////////
// DockedWindowLayoutManager, ShelfLayoutManagerObserver implementation:
void DockedWindowLayoutManager::OnBackgroundUpdated(
ShelfBackgroundType background_type,
BackgroundAnimatorChangeType change_type) {
background_widget_->SetPaintsBackground(background_type, change_type);
}
/////////////////////////////////////////////////////////////////////////////
// DockedWindowLayoutManager, WindowStateObserver implementation:
void DockedWindowLayoutManager::OnWindowShowTypeChanged(
wm::WindowState* window_state,
wm::WindowShowType old_type) {
aura::Window* window = window_state->window();
if (IsPopupOrTransient(window))
return;
// The window property will still be set, but no actual change will occur
// until OnFullscreenStateChange is called when exiting fullscreen.
if (in_fullscreen_)
return;
if (window_state->IsMinimized()) {
MinimizeDockedWindow(window_state);
} else if (window_state->IsMaximizedOrFullscreen() ||
window_state->IsSnapped()) {
if (window != dragged_window_) {
UndockWindow(window);
RecordUmaAction(DOCKED_ACTION_MAXIMIZE, DOCKED_ACTION_SOURCE_UNKNOWN);
}
} else if (old_type == wm::SHOW_TYPE_MINIMIZED) {
RestoreDockedWindow(window_state);
}
}
/////////////////////////////////////////////////////////////////////////////
// DockedWindowLayoutManager, WindowObserver implementation:
void DockedWindowLayoutManager::OnWindowBoundsChanged(
aura::Window* window,
const gfx::Rect& old_bounds,
const gfx::Rect& new_bounds) {
// Only relayout if the dragged window would get docked.
if (window == dragged_window_ && is_dragged_window_docked_)
Relayout();
}
void DockedWindowLayoutManager::OnWindowVisibilityChanging(
aura::Window* window, bool visible) {
if (IsPopupOrTransient(window))
return;
int animation_type = views::corewm::WINDOW_VISIBILITY_ANIMATION_TYPE_DEFAULT;
if (visible) {
animation_type = views::corewm::WINDOW_VISIBILITY_ANIMATION_TYPE_DROP;
views::corewm::SetWindowVisibilityAnimationDuration(
window, base::TimeDelta::FromMilliseconds(kFadeDurationMs));
} else if (wm::GetWindowState(window)->IsMinimized()) {
animation_type = WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE;
}
views::corewm::SetWindowVisibilityAnimationType(window, animation_type);
}
void DockedWindowLayoutManager::OnWindowDestroying(aura::Window* window) {
if (dragged_window_ == window) {
FinishDragging(DOCKED_ACTION_NONE, DOCKED_ACTION_SOURCE_UNKNOWN);
DCHECK(!dragged_window_);
DCHECK (!is_dragged_window_docked_);
}
if (window == last_active_window_)
last_active_window_ = NULL;
RecordUmaAction(DOCKED_ACTION_CLOSE, DOCKED_ACTION_SOURCE_UNKNOWN);
}
////////////////////////////////////////////////////////////////////////////////
// DockedWindowLayoutManager, aura::client::ActivationChangeObserver
// implementation:
void DockedWindowLayoutManager::OnWindowActivated(aura::Window* gained_active,
aura::Window* lost_active) {
if (gained_active && IsPopupOrTransient(gained_active))
return;
// Ignore if the window that is not managed by this was activated.
aura::Window* ancestor = NULL;
for (aura::Window* parent = gained_active;
parent; parent = parent->parent()) {
if (parent->parent() == dock_container_) {
ancestor = parent;
break;
}
}
if (ancestor)
UpdateStacking(ancestor);
}
////////////////////////////////////////////////////////////////////////////////
// DockedWindowLayoutManager private implementation:
void DockedWindowLayoutManager::MaybeMinimizeChildrenExcept(
aura::Window* child) {
// Minimize any windows that don't fit without overlap.
const gfx::Rect work_area =
Shell::GetScreen()->GetDisplayNearestWindow(dock_container_).work_area();
int available_room = work_area.height() - kMinDockGap;
if (child)
available_room -= (GetWindowHeightCloseTo(child, 0) + kMinDockGap);
// Use a copy of children array because a call to Minimize can change order.
aura::Window::Windows children(dock_container_->children());
aura::Window::Windows::const_reverse_iterator iter = children.rbegin();
while (iter != children.rend()) {
aura::Window* window(*iter++);
if (window == child || !IsUsedByLayout(window))
continue;
int room_needed = GetWindowHeightCloseTo(window, 0) + kMinDockGap;
if (available_room > room_needed) {
available_room -= room_needed;
} else {
// Slow down minimizing animations. Lock duration so that it is not
// overridden by other ScopedLayerAnimationSettings down the stack.
ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
settings.SetTransitionDuration(
base::TimeDelta::FromMilliseconds(kMinimizeDurationMs));
settings.LockTransitionDuration();
wm::GetWindowState(window)->Minimize();
}
}
}
void DockedWindowLayoutManager::MinimizeDockedWindow(
wm::WindowState* window_state) {
DCHECK(!IsPopupOrTransient(window_state->window()));
window_state->window()->Hide();
if (window_state->IsActive())
window_state->Deactivate();
RecordUmaAction(DOCKED_ACTION_MINIMIZE, DOCKED_ACTION_SOURCE_UNKNOWN);
}
void DockedWindowLayoutManager::RestoreDockedWindow(
wm::WindowState* window_state) {
aura::Window* window = window_state->window();
DCHECK(!IsPopupOrTransient(window));
// Always place restored window at the bottom shuffling the other windows up.
// TODO(varkha): add a separate container for docked windows to keep track
// of ordering.
gfx::Display display = Shell::GetScreen()->GetDisplayNearestWindow(
dock_container_);
const gfx::Rect work_area = display.work_area();
// Evict the window if it can no longer be docked because of its height.
if (!CanDockWindow(window, SNAP_NONE)) {
UndockWindow(window);
RecordUmaAction(DOCKED_ACTION_EVICT, DOCKED_ACTION_SOURCE_UNKNOWN);
return;
}
gfx::Rect bounds(window->bounds());
bounds.set_y(work_area.bottom());
window->SetBounds(bounds);
window->Show();
MaybeMinimizeChildrenExcept(window);
RecordUmaAction(DOCKED_ACTION_RESTORE, DOCKED_ACTION_SOURCE_UNKNOWN);
}
void DockedWindowLayoutManager::RecordUmaAction(DockedAction action,
DockedActionSource source) {
if (action == DOCKED_ACTION_NONE)
return;
UMA_HISTOGRAM_ENUMERATION("Ash.Dock.Action", action, DOCKED_ACTION_COUNT);
UMA_HISTOGRAM_ENUMERATION("Ash.Dock.ActionSource", source,
DOCKED_ACTION_SOURCE_COUNT);
base::Time time_now = base::Time::Now();
base::TimeDelta time_between_use = time_now - last_action_time_;
UMA_HISTOGRAM_CUSTOM_COUNTS("Ash.Dock.TimeBetweenUse",
time_between_use.InSeconds(),
1,
base::TimeDelta::FromHours(10).InSeconds(),
100);
last_action_time_ = time_now;
int docked_all_count = 0;
int docked_visible_count = 0;
int docked_panels_count = 0;
int large_windows_count = 0;
for (size_t i = 0; i < dock_container_->children().size(); ++i) {
const aura::Window* window(dock_container_->children()[i]);
if (IsPopupOrTransient(window))
continue;
docked_all_count++;
if (!IsUsedByLayout(window))
continue;
docked_visible_count++;
if (window->type() == aura::client::WINDOW_TYPE_PANEL)
docked_panels_count++;
const wm::WindowState* window_state = wm::GetWindowState(window);
if (window_state->HasRestoreBounds()) {
const gfx::Rect restore_bounds = window_state->GetRestoreBoundsInScreen();
if (restore_bounds.width() > kMaxDockWidth)
large_windows_count++;
}
}
UMA_HISTOGRAM_COUNTS_100("Ash.Dock.ItemsAll", docked_all_count);
UMA_HISTOGRAM_COUNTS_100("Ash.Dock.ItemsLarge", large_windows_count);
UMA_HISTOGRAM_COUNTS_100("Ash.Dock.ItemsPanels", docked_panels_count);
UMA_HISTOGRAM_COUNTS_100("Ash.Dock.ItemsVisible", docked_visible_count);
}
void DockedWindowLayoutManager::UpdateDockedWidth(int width) {
if (docked_width_ == width)
return;
docked_width_ = width;
UMA_HISTOGRAM_COUNTS_10000("Ash.Dock.Width", docked_width_);
}
void DockedWindowLayoutManager::OnDraggedWindowDocked(aura::Window* window) {
DCHECK(!is_dragged_window_docked_);
is_dragged_window_docked_ = true;
// If there are no other docked windows update alignment.
if (!IsAnyWindowDocked())
alignment_ = DOCKED_ALIGNMENT_NONE;
}
void DockedWindowLayoutManager::OnDraggedWindowUndocked() {
// If this is the first window getting docked - update alignment.
if (!IsAnyWindowDocked())
alignment_ = GetAlignmentOfWindow(dragged_window_);
DCHECK (is_dragged_window_docked_);
is_dragged_window_docked_ = false;
}
bool DockedWindowLayoutManager::IsAnyWindowDocked() {
return CalculateAlignment() != DOCKED_ALIGNMENT_NONE;
}
void DockedWindowLayoutManager::Relayout() {
if (in_layout_)
return;
if (alignment_ == DOCKED_ALIGNMENT_NONE && !is_dragged_window_docked_)
return;
base::AutoReset<bool> auto_reset_in_layout(&in_layout_, true);
gfx::Rect dock_bounds = dock_container_->GetBoundsInScreen();
aura::Window* active_window = NULL;
std::vector<WindowWithHeight> visible_windows;
for (size_t i = 0; i < dock_container_->children().size(); ++i) {
aura::Window* window(dock_container_->children()[i]);
if (!IsUsedByLayout(window) || window == dragged_window_)
continue;
// If the shelf is currently hidden (full-screen mode), hide window until
// full-screen mode is exited.
if (in_fullscreen_) {
// The call to Hide does not set the minimize property, so the window will
// be restored when the shelf becomes visible again.
window->Hide();
continue;
}
if (window->HasFocus() ||
window->Contains(
aura::client::GetFocusClient(window)->GetFocusedWindow())) {
DCHECK(!active_window);
active_window = window;
}
visible_windows.push_back(WindowWithHeight(window));
}
// Consider docked dragged_window_ when fanning out other child windows.
if (is_dragged_window_docked_) {
visible_windows.push_back(WindowWithHeight(dragged_window_));
DCHECK(!active_window);
active_window = dragged_window_;
}
// Position docked windows as well as the window being dragged.
gfx::Rect work_area =
Shell::GetScreen()->GetDisplayNearestWindow(dock_container_).work_area();
if (shelf_observer_)
work_area.Subtract(shelf_observer_->shelf_bounds_in_screen());
int available_room = CalculateWindowHeightsAndRemainingRoom(work_area,
&visible_windows);
FanOutChildren(work_area,
CalculateIdealWidth(visible_windows),
available_room,
&visible_windows);
// After the first Relayout allow the windows to change their order easier
// since we know they are docked.
is_dragged_from_dock_ = true;
UpdateStacking(active_window);
}
int DockedWindowLayoutManager::CalculateWindowHeightsAndRemainingRoom(
const gfx::Rect work_area,
std::vector<WindowWithHeight>* visible_windows) {
int available_room = work_area.height() - kMinDockGap;
int remaining_windows = visible_windows->size();
// Sort windows by their minimum heights and calculate target heights.
std::sort(visible_windows->begin(), visible_windows->end(),
CompareMinimumHeight());
// Distribute the free space among the docked windows. Since the windows are
// sorted (tall windows first) we can now assume that any window which
// required more space than the current window will have already been
// accounted for previously in this loop, so we can safely give that window
// its proportional share of the remaining space.
for (std::vector<WindowWithHeight>::reverse_iterator iter =
visible_windows->rbegin();
iter != visible_windows->rend(); ++iter) {
iter->height_ = GetWindowHeightCloseTo(
iter->window(), available_room / remaining_windows - kMinDockGap);
available_room -= (iter->height_ + kMinDockGap);
remaining_windows--;
}
return available_room;
}
int DockedWindowLayoutManager::CalculateIdealWidth(
const std::vector<WindowWithHeight>& visible_windows) {
int smallest_max_width = kMaxDockWidth;
int largest_min_width = kMinDockWidth;
// Ideal width of the docked area is as close to kIdealWidth as possible
// while still respecting the minimum and maximum width restrictions on the
// individual docked windows as well as the width that was possibly set by a
// user (which needs to be preserved when dragging and rearranging windows).
for (std::vector<WindowWithHeight>::const_iterator iter =
visible_windows.begin();
iter != visible_windows.end(); ++iter) {
const aura::Window* window = iter->window();
int min_window_width = window->bounds().width();
int max_window_width = min_window_width;
if (!wm::GetWindowState(window)->bounds_changed_by_user()) {
min_window_width = GetWindowWidthCloseTo(window, kMinDockWidth);
max_window_width = GetWindowWidthCloseTo(window, kMaxDockWidth);
}
largest_min_width = std::max(largest_min_width, min_window_width);
smallest_max_width = std::min(smallest_max_width, max_window_width);
}
int ideal_width = std::max(largest_min_width,
std::min(smallest_max_width, kIdealWidth));
// Restrict docked area width regardless of window restrictions.
ideal_width = std::max(std::min(ideal_width, kMaxDockWidth), kMinDockWidth);
return ideal_width;
}
void DockedWindowLayoutManager::FanOutChildren(
const gfx::Rect& work_area,
int ideal_docked_width,
int available_room,
std::vector<WindowWithHeight>* visible_windows) {
gfx::Rect dock_bounds = dock_container_->GetBoundsInScreen();
// Calculate initial vertical offset and the gap or overlap between windows.
const int num_windows = visible_windows->size();
const float delta = kMinDockGap + (float)available_room /
((available_room > 0 || num_windows <= 1) ?
num_windows + 1 : num_windows - 1);
float y_pos = work_area.y() + ((delta > 0) ? delta : kMinDockGap);
// Docked area is shown only if there is at least one non-dragged visible
// docked window.
int new_width = ideal_docked_width;
if (visible_windows->empty() ||
(visible_windows->size() == 1 &&
(*visible_windows)[0].window() == dragged_window_)) {
new_width = 0;
}
UpdateDockedWidth(new_width);
// Sort windows by their center positions and fan out overlapping
// windows.
std::sort(visible_windows->begin(), visible_windows->end(),
CompareWindowPos(is_dragged_from_dock_ ? dragged_window_ : NULL,
delta));
for (std::vector<WindowWithHeight>::iterator iter = visible_windows->begin();
iter != visible_windows->end(); ++iter) {
aura::Window* window = iter->window();
gfx::Rect bounds = ScreenAsh::ConvertRectToScreen(
window->parent(), window->GetTargetBounds());
// A window is extended or shrunk to be as close as possible to the ideal
// docked area width. Windows that were resized by a user are kept at their
// existing size.
// This also enforces the min / max restrictions on the docked area width.
bounds.set_width(GetWindowWidthCloseTo(
window,
wm::GetWindowState(window)->bounds_changed_by_user() ?
bounds.width() : ideal_docked_width));
DCHECK_LE(bounds.width(), ideal_docked_width);
DockedAlignment alignment = alignment_;
if (alignment == DOCKED_ALIGNMENT_NONE && window == dragged_window_) {
alignment = GetAlignmentOfWindow(window);
if (alignment == DOCKED_ALIGNMENT_NONE)
bounds.set_size(gfx::Size());
}
// Fan out windows evenly distributing the overlap or remaining free space.
bounds.set_height(iter->height_);
bounds.set_y(std::max(work_area.y(),
std::min(work_area.bottom() - bounds.height(),
static_cast<int>(y_pos + 0.5))));
y_pos += bounds.height() + delta;
// All docked windows other than the one currently dragged remain stuck
// to the screen edge (flush with the edge or centered in the dock area).
switch (alignment) {
case DOCKED_ALIGNMENT_LEFT:
bounds.set_x(dock_bounds.x() +
(ideal_docked_width - bounds.width()) / 2);
break;
case DOCKED_ALIGNMENT_RIGHT:
bounds.set_x(dock_bounds.right() -
(ideal_docked_width + bounds.width()) / 2);
break;
case DOCKED_ALIGNMENT_NONE:
break;
}
if (window == dragged_window_) {
dragged_bounds_ = bounds;
continue;
}
// If the following asserts it is probably because not all the children
// have been removed when dock was closed.
DCHECK_NE(alignment_, DOCKED_ALIGNMENT_NONE);
bounds = ScreenAsh::ConvertRectFromScreen(dock_container_, bounds);
if (bounds != window->GetTargetBounds()) {
ui::Layer* layer = window->layer();
ui::ScopedLayerAnimationSettings slide_settings(layer->GetAnimator());
slide_settings.SetPreemptionStrategy(
ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
slide_settings.SetTransitionDuration(
base::TimeDelta::FromMilliseconds(kSlideDurationMs));
SetChildBoundsDirect(window, bounds);
}
}
}
void DockedWindowLayoutManager::UpdateDockBounds(
DockedWindowLayoutManagerObserver::Reason reason) {
int dock_inset = docked_width_ + (docked_width_ > 0 ? kMinDockGap : 0);
const gfx::Rect work_area =
Shell::GetScreen()->GetDisplayNearestWindow(dock_container_).work_area();
gfx::Rect bounds = gfx::Rect(
alignment_ == DOCKED_ALIGNMENT_RIGHT && dock_inset > 0 ?
dock_container_->bounds().right() - dock_inset:
dock_container_->bounds().x(),
dock_container_->bounds().y(),
dock_inset,
work_area.height());
docked_bounds_ = bounds +
dock_container_->GetBoundsInScreen().OffsetFromOrigin();
FOR_EACH_OBSERVER(
DockedWindowLayoutManagerObserver,
observer_list_,
OnDockBoundsChanging(bounds, reason));
// Show or hide background for docked area.
gfx::Rect background_bounds(docked_bounds_);
if (shelf_observer_)
background_bounds.Subtract(shelf_observer_->shelf_bounds_in_screen());
background_widget_->SetBackgroundBounds(background_bounds, alignment_);
if (docked_width_ > 0)
background_widget_->Show();
else
background_widget_->Hide();
}
void DockedWindowLayoutManager::UpdateStacking(aura::Window* active_window) {
if (!active_window) {
if (!last_active_window_)
return;
active_window = last_active_window_;
}
// Windows are stacked like a deck of cards:
// ,------.
// |,------.|
// |,------.|
// | active |
// | window |
// |`------'|
// |`------'|
// `------'
// Use the middle of each window to figure out how to stack the window.
// This allows us to update the stacking when a window is being dragged around
// by the titlebar.
std::map<int, aura::Window*> window_ordering;
for (aura::Window::Windows::const_iterator it =
dock_container_->children().begin();
it != dock_container_->children().end(); ++it) {
if (!IsUsedByLayout(*it) ||
((*it) == dragged_window_ && !is_dragged_window_docked_)) {
continue;
}
gfx::Rect bounds = (*it)->bounds();
window_ordering.insert(std::make_pair(bounds.y() + bounds.height() / 2,
*it));
}
int active_center_y = active_window->bounds().CenterPoint().y();
aura::Window* previous_window = NULL;
for (std::map<int, aura::Window*>::const_iterator it =
window_ordering.begin();
it != window_ordering.end() && it->first < active_center_y; ++it) {
if (previous_window)
dock_container_->StackChildAbove(it->second, previous_window);
previous_window = it->second;
}
for (std::map<int, aura::Window*>::const_reverse_iterator it =
window_ordering.rbegin();
it != window_ordering.rend() && it->first > active_center_y; ++it) {
if (previous_window)
dock_container_->StackChildAbove(it->second, previous_window);
previous_window = it->second;
}
if (previous_window && active_window->parent() == dock_container_)
dock_container_->StackChildAbove(active_window, previous_window);
if (active_window != dragged_window_)
last_active_window_ = active_window;
}
////////////////////////////////////////////////////////////////////////////////
// keyboard::KeyboardControllerObserver implementation:
void DockedWindowLayoutManager::OnKeyboardBoundsChanging(
const gfx::Rect& keyboard_bounds) {
// This bounds change will have caused a change to the Shelf which does not
// propagate automatically to this class, so manually recalculate bounds.
Relayout();
UpdateDockBounds(DockedWindowLayoutManagerObserver::KEYBOARD_BOUNDS_CHANGING);
}
} // namespace internal
} // namespace ash