Home | History | Annotate | Download | only in wm 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "ash/wm/window_util.h"
      6 
      7 #include <vector>
      8 
      9 #include "ash/ash_constants.h"
     10 #include "ash/screen_util.h"
     11 #include "ash/shell.h"
     12 #include "ash/snap_to_pixel_layout_manager.h"
     13 #include "ash/wm/window_properties.h"
     14 #include "ash/wm/window_state.h"
     15 #include "ash/wm/wm_event.h"
     16 #include "ui/aura/client/aura_constants.h"
     17 #include "ui/aura/window.h"
     18 #include "ui/aura/window_delegate.h"
     19 #include "ui/aura/window_event_dispatcher.h"
     20 #include "ui/compositor/dip_util.h"
     21 #include "ui/gfx/display.h"
     22 #include "ui/gfx/rect.h"
     23 #include "ui/gfx/screen.h"
     24 #include "ui/gfx/size.h"
     25 #include "ui/views/view.h"
     26 #include "ui/views/widget/widget.h"
     27 #include "ui/wm/core/window_util.h"
     28 #include "ui/wm/public/activation_client.h"
     29 
     30 namespace ash {
     31 namespace wm {
     32 
     33 namespace {
     34 
     35 // Returns the default width of a snapped window.
     36 int GetDefaultSnappedWindowWidth(aura::Window* window) {
     37   const float kSnappedWidthWorkspaceRatio = 0.5f;
     38 
     39   int work_area_width =
     40       ScreenUtil::GetDisplayWorkAreaBoundsInParent(window).width();
     41   int min_width = window->delegate() ?
     42       window->delegate()->GetMinimumSize().width() : 0;
     43   int ideal_width =
     44       static_cast<int>(work_area_width * kSnappedWidthWorkspaceRatio);
     45   return std::min(work_area_width, std::max(ideal_width, min_width));
     46 }
     47 
     48 }  // namespace
     49 
     50 // TODO(beng): replace many of these functions with the corewm versions.
     51 void ActivateWindow(aura::Window* window) {
     52   ::wm::ActivateWindow(window);
     53 }
     54 
     55 void DeactivateWindow(aura::Window* window) {
     56   ::wm::DeactivateWindow(window);
     57 }
     58 
     59 bool IsActiveWindow(aura::Window* window) {
     60   return ::wm::IsActiveWindow(window);
     61 }
     62 
     63 aura::Window* GetActiveWindow() {
     64   return aura::client::GetActivationClient(Shell::GetPrimaryRootWindow())->
     65       GetActiveWindow();
     66 }
     67 
     68 aura::Window* GetActivatableWindow(aura::Window* window) {
     69   return ::wm::GetActivatableWindow(window);
     70 }
     71 
     72 bool CanActivateWindow(aura::Window* window) {
     73   return ::wm::CanActivateWindow(window);
     74 }
     75 
     76 bool IsWindowMinimized(aura::Window* window) {
     77   return ash::wm::GetWindowState(window)->IsMinimized();
     78 }
     79 
     80 void CenterWindow(aura::Window* window) {
     81   wm::WMEvent event(wm::WM_EVENT_CENTER);
     82   wm::GetWindowState(window)->OnWMEvent(&event);
     83 }
     84 
     85 gfx::Rect GetDefaultLeftSnappedWindowBoundsInParent(aura::Window* window) {
     86   gfx::Rect work_area_in_parent(ScreenUtil::GetDisplayWorkAreaBoundsInParent(
     87       window));
     88   return gfx::Rect(work_area_in_parent.x(),
     89                    work_area_in_parent.y(),
     90                    GetDefaultSnappedWindowWidth(window),
     91                    work_area_in_parent.height());
     92 }
     93 
     94 gfx::Rect GetDefaultRightSnappedWindowBoundsInParent(aura::Window* window) {
     95   gfx::Rect work_area_in_parent(ScreenUtil::GetDisplayWorkAreaBoundsInParent(
     96       window));
     97   int width = GetDefaultSnappedWindowWidth(window);
     98   return gfx::Rect(work_area_in_parent.right() - width,
     99                    work_area_in_parent.y(),
    100                    width,
    101                    work_area_in_parent.height());
    102 }
    103 
    104 void AdjustBoundsSmallerThan(const gfx::Size& max_size, gfx::Rect* bounds) {
    105   bounds->set_width(std::min(bounds->width(), max_size.width()));
    106   bounds->set_height(std::min(bounds->height(), max_size.height()));
    107 }
    108 
    109 void AdjustBoundsToEnsureMinimumWindowVisibility(const gfx::Rect& visible_area,
    110                                                  gfx::Rect* bounds) {
    111   AdjustBoundsToEnsureWindowVisibility(
    112       visible_area, kMinimumOnScreenArea, kMinimumOnScreenArea, bounds);
    113 }
    114 
    115 void AdjustBoundsToEnsureWindowVisibility(const gfx::Rect& visible_area,
    116                                           int min_width,
    117                                           int min_height,
    118                                           gfx::Rect* bounds) {
    119   AdjustBoundsSmallerThan(visible_area.size(), bounds);
    120 
    121   min_width = std::min(min_width, visible_area.width());
    122   min_height = std::min(min_height, visible_area.height());
    123 
    124   if (bounds->right() < visible_area.x() + min_width) {
    125     bounds->set_x(visible_area.x() + min_width - bounds->width());
    126   } else if (bounds->x() > visible_area.right() - min_width) {
    127     bounds->set_x(visible_area.right() - min_width);
    128   }
    129   if (bounds->bottom() < visible_area.y() + min_height) {
    130     bounds->set_y(visible_area.y() + min_height - bounds->height());
    131   } else if (bounds->y() > visible_area.bottom() - min_height) {
    132     bounds->set_y(visible_area.bottom() - min_height);
    133   }
    134   if (bounds->y() < visible_area.y())
    135     bounds->set_y(visible_area.y());
    136 }
    137 
    138 bool MoveWindowToEventRoot(aura::Window* window, const ui::Event& event) {
    139   views::View* target = static_cast<views::View*>(event.target());
    140   if (!target)
    141     return false;
    142   aura::Window* target_root =
    143       target->GetWidget()->GetNativeView()->GetRootWindow();
    144   if (!target_root || target_root == window->GetRootWindow())
    145     return false;
    146   aura::Window* window_container =
    147       ash::Shell::GetContainer(target_root, window->parent()->id());
    148   // Move the window to the target launcher.
    149   window_container->AddChild(window);
    150   return true;
    151 }
    152 
    153 void ReparentChildWithTransientChildren(aura::Window* child,
    154                                         aura::Window* old_parent,
    155                                         aura::Window* new_parent) {
    156   if (child->parent() == old_parent)
    157     new_parent->AddChild(child);
    158   ReparentTransientChildrenOfChild(child, old_parent, new_parent);
    159 }
    160 
    161 void ReparentTransientChildrenOfChild(aura::Window* child,
    162                                       aura::Window* old_parent,
    163                                       aura::Window* new_parent) {
    164   for (size_t i = 0;
    165        i < ::wm::GetTransientChildren(child).size();
    166        ++i) {
    167     ReparentChildWithTransientChildren(
    168         ::wm::GetTransientChildren(child)[i],
    169         old_parent,
    170         new_parent);
    171   }
    172 }
    173 
    174 void SnapWindowToPixelBoundary(aura::Window* window) {
    175   aura::Window* snapped_ancestor = window->parent();
    176   while (snapped_ancestor) {
    177     if (snapped_ancestor->GetProperty(kSnapChildrenToPixelBoundary)) {
    178       ui::SnapLayerToPhysicalPixelBoundary(snapped_ancestor->layer(),
    179                                            window->layer());
    180       return;
    181     }
    182     snapped_ancestor = snapped_ancestor->parent();
    183   }
    184 }
    185 
    186 void SetSnapsChildrenToPhysicalPixelBoundary(aura::Window* container) {
    187   DCHECK(!container->GetProperty(kSnapChildrenToPixelBoundary))
    188       << container->name();
    189   container->SetProperty(kSnapChildrenToPixelBoundary, true);
    190 }
    191 
    192 void InstallSnapLayoutManagerToContainers(aura::Window* parent) {
    193   aura::Window::Windows children = parent->children();
    194   for (aura::Window::Windows::iterator iter = children.begin();
    195        iter != children.end();
    196        ++iter) {
    197     aura::Window* container = *iter;
    198     if (container->id() < 0)  // not a container
    199       continue;
    200     if (container->GetProperty(kSnapChildrenToPixelBoundary)) {
    201       if (!container->layout_manager())
    202         container->SetLayoutManager(new SnapToPixelLayoutManager(container));
    203     } else {
    204       InstallSnapLayoutManagerToContainers(container);
    205     }
    206   }
    207 }
    208 
    209 }  // namespace wm
    210 }  // namespace ash
    211