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