ui/wm/core/window_util.cc

   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 "ui/wm/core/window_util.h"
   6
   7 #include "ui/aura/window.h"
   8 #include "ui/aura/window_event_dispatcher.h"
   9 #include "ui/compositor/layer.h"
  10 #include "ui/compositor/layer_tree_owner.h"
  11 #include "ui/wm/core/transient_window_manager.h"
  12 #include "ui/wm/public/activation_client.h"
  13
  14 namespace {
  15
  16 // Invokes RecreateLayer() on all the children of |to_clone|, adding the newly
  17 // cloned children to |parent|.
  18 //
  19 // WARNING: It is assumed that |parent| is ultimately owned by a LayerTreeOwner.
  20 void CloneChildren(ui::Layer* to_clone, ui::Layer* parent) {
  21   typedef std::vector<ui::Layer*> Layers;
  22   // Make a copy of the children since RecreateLayer() mutates it.
  23   Layers children(to_clone->children());
  24   for (Layers::const_iterator i = children.begin(); i != children.end(); ++i) {
  25     ui::LayerOwner* owner = (*i)->owner();
  26     ui::Layer* old_layer = owner ? owner->RecreateLayer().release() : NULL;
  27     if (old_layer) {
  28       parent->Add(old_layer);
  29       // RecreateLayer() moves the existing children to the new layer. Create a
  30       // copy of those.
  31       CloneChildren(owner->layer(), old_layer);
  32     }
  33   }
  34 }
  35
  36 }  // namespace
  37
  38 namespace wm {
  39
  40 void ActivateWindow(aura::Window* window) {
  41   DCHECK(window);
  42   DCHECK(window->GetRootWindow());
  43   aura::client::GetActivationClient(window->GetRootWindow())->ActivateWindow(
  44       window);
  45 }
  46
  47 void DeactivateWindow(aura::Window* window) {
  48   DCHECK(window);
  49   DCHECK(window->GetRootWindow());
  50   aura::client::GetActivationClient(window->GetRootWindow())->DeactivateWindow(
  51       window);
  52 }
  53
  54 bool IsActiveWindow(aura::Window* window) {
  55   DCHECK(window);
  56   if (!window->GetRootWindow())
  57     return false;
  58   aura::client::ActivationClient* client =
  59       aura::client::GetActivationClient(window->GetRootWindow());
  60   return client && client->GetActiveWindow() == window;
  61 }
  62
  63 bool CanActivateWindow(aura::Window* window) {
  64   DCHECK(window);
  65   if (!window->GetRootWindow())
  66     return false;
  67   aura::client::ActivationClient* client =
  68       aura::client::GetActivationClient(window->GetRootWindow());
  69   return client && client->CanActivateWindow(window);
  70 }
  71
  72 aura::Window* GetActivatableWindow(aura::Window* window) {
  73   aura::client::ActivationClient* client =
  74       aura::client::GetActivationClient(window->GetRootWindow());
  75   return client ? client->GetActivatableWindow(window) : NULL;
  76 }
  77
  78 aura::Window* GetToplevelWindow(aura::Window* window) {
  79   aura::client::ActivationClient* client =
  80       aura::client::GetActivationClient(window->GetRootWindow());
  81   return client ? client->GetToplevelWindow(window) : NULL;
  82 }
  83
  84 scoped_ptr<ui::LayerTreeOwner> RecreateLayers(ui::LayerOwner* root) {
  85   scoped_ptr<ui::LayerTreeOwner> old_layer(
  86       new ui::LayerTreeOwner(root->RecreateLayer().release()));
  87   if (old_layer->root())
  88     CloneChildren(root->layer(), old_layer->root());
  89   return old_layer.Pass();
  90 }
  91
  92 aura::Window* GetTransientParent(aura::Window* window) {
  93   return const_cast<aura::Window*>(GetTransientParent(
  94                                  const_cast<const aura::Window*>(window)));
  95 }
  96
  97 const aura::Window* GetTransientParent(const aura::Window* window) {
  98   const TransientWindowManager* manager = TransientWindowManager::Get(window);
  99   return manager ? manager->transient_parent() : NULL;
 100 }
 101
 102 const std::vector<aura::Window*>& GetTransientChildren(
 103     const aura::Window* window) {
 104   const TransientWindowManager* manager = TransientWindowManager::Get(window);
 105   if (manager)
 106     return manager->transient_children();
 107
 108   static std::vector<aura::Window*>* shared = new std::vector<aura::Window*>;
 109   return *shared;
 110 }
 111
 112 void AddTransientChild(aura::Window* parent, aura::Window* child) {
 113   TransientWindowManager::Get(parent)->AddTransientChild(child);
 114 }
 115
 116 void RemoveTransientChild(aura::Window* parent, aura::Window* child) {
 117   TransientWindowManager::Get(parent)->RemoveTransientChild(child);
 118 }
 119
 120 bool HasTransientAncestor(const aura::Window* window,
 121                           const aura::Window* ancestor) {
 122   const aura::Window* transient_parent = GetTransientParent(window);
 123   if (transient_parent == ancestor)
 124     return true;
 125   return transient_parent ?
 126       HasTransientAncestor(transient_parent, ancestor) : false;
 127 }
 128
 129 }  // namespace wm