ui/wm/core/base_focus_rules.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/base_focus_rules.h"
   6
   7 #include "ui/aura/client/focus_client.h"
   8 #include "ui/aura/window.h"
   9 #include "ui/wm/core/window_modality_controller.h"
  10 #include "ui/wm/core/window_util.h"
  11 #include "ui/wm/public/activation_delegate.h"
  12
  13 namespace wm {
  14 namespace {
  15
  16 aura::Window* GetFocusedWindow(aura::Window* context) {
  17   aura::client::FocusClient* focus_client =
  18       aura::client::GetFocusClient(context);
  19   return focus_client ? focus_client->GetFocusedWindow() : NULL;
  20 }
  21
  22 }  // namespace
  23
  24 ////////////////////////////////////////////////////////////////////////////////
  25 // BaseFocusRules, protected:
  26
  27 BaseFocusRules::BaseFocusRules() {
  28 }
  29
  30 BaseFocusRules::~BaseFocusRules() {
  31 }
  32
  33 bool BaseFocusRules::IsWindowConsideredVisibleForActivation(
  34     aura::Window* window) const {
  35   return window->IsVisible();
  36 }
  37
  38 ////////////////////////////////////////////////////////////////////////////////
  39 // BaseFocusRules, FocusRules implementation:
  40
  41 bool BaseFocusRules::IsToplevelWindow(aura::Window* window) const {
  42   // The window must in a valid hierarchy.
  43   if (!window->GetRootWindow())
  44     return false;
  45
  46   // The window must exist within a container that supports activation.
  47   // The window cannot be blocked by a modal transient.
  48   return SupportsChildActivation(window->parent());
  49 }
  50
  51 bool BaseFocusRules::CanActivateWindow(aura::Window* window) const {
  52   // It is possible to activate a NULL window, it is equivalent to clearing
  53   // activation.
  54   if (!window)
  55     return true;
  56
  57   // Only toplevel windows can be activated.
  58   if (!IsToplevelWindow(window))
  59     return false;
  60
  61   // The window must be visible.
  62   if (!IsWindowConsideredVisibleForActivation(window))
  63     return false;
  64
  65   // The window's activation delegate must allow this window to be activated.
  66   if (aura::client::GetActivationDelegate(window) &&
  67       !aura::client::GetActivationDelegate(window)->ShouldActivate()) {
  68     return false;
  69   }
  70
  71   // A window must be focusable to be activatable. We don't call
  72   // CanFocusWindow() from here because it will call back to us via
  73   // GetActivatableWindow().
  74   if (!window->CanFocus())
  75     return false;
  76
  77   // The window cannot be blocked by a modal transient.
  78   return !GetModalTransient(window);
  79 }
  80
  81 bool BaseFocusRules::CanFocusWindow(aura::Window* window) const {
  82   // It is possible to focus a NULL window, it is equivalent to clearing focus.
  83   if (!window)
  84     return true;
  85
  86   // The focused window is always inside the active window, so windows that
  87   // aren't activatable can't contain the focused window.
  88   aura::Window* activatable = GetActivatableWindow(window);
  89   if (!activatable || !activatable->Contains(window))
  90     return false;
  91   return window->CanFocus();
  92 }
  93
  94 aura::Window* BaseFocusRules::GetToplevelWindow(aura::Window* window) const {
  95   aura::Window* parent = window->parent();
  96   aura::Window* child = window;
  97   while (parent) {
  98     if (IsToplevelWindow(child))
  99       return child;
 100
 101     parent = parent->parent();
 102     child = child->parent();
 103   }
 104   return NULL;
 105 }
 106
 107 aura::Window* BaseFocusRules::GetActivatableWindow(aura::Window* window) const {
 108   aura::Window* parent = window->parent();
 109   aura::Window* child = window;
 110   while (parent) {
 111     if (CanActivateWindow(child))
 112       return child;
 113
 114     // CanActivateWindow() above will return false if |child| is blocked by a
 115     // modal transient. In this case the modal is or contains the activatable
 116     // window. We recurse because the modal may itself be blocked by a modal
 117     // transient.
 118     aura::Window* modal_transient = GetModalTransient(child);
 119     if (modal_transient)
 120       return GetActivatableWindow(modal_transient);
 121
 122     if (wm::GetTransientParent(child)) {
 123       // To avoid infinite recursion, if |child| has a transient parent
 124       // whose own modal transient is |child| itself, just return |child|.
 125       aura::Window* parent_modal_transient =
 126           GetModalTransient(wm::GetTransientParent(child));
 127       if (parent_modal_transient == child)
 128         return child;
 129
 130       return GetActivatableWindow(wm::GetTransientParent(child));
 131     }
 132
 133     parent = parent->parent();
 134     child = child->parent();
 135   }
 136   return NULL;
 137 }
 138
 139 aura::Window* BaseFocusRules::GetFocusableWindow(aura::Window* window) const {
 140   if (CanFocusWindow(window))
 141     return window;
 142
 143   // |window| may be in a hierarchy that is non-activatable, in which case we
 144   // need to cut over to the activatable hierarchy.
 145   aura::Window* activatable = GetActivatableWindow(window);
 146   if (!activatable) {
 147     // There may not be a related activatable hierarchy to cut over to, in which
 148     // case we try an unrelated one.
 149     aura::Window* toplevel = GetToplevelWindow(window);
 150     if (toplevel)
 151       activatable = GetNextActivatableWindow(toplevel);
 152     if (!activatable)
 153       return NULL;
 154   }
 155
 156   if (!activatable->Contains(window)) {
 157     // If there's already a child window focused in the activatable hierarchy,
 158     // just use that (i.e. don't shift focus), otherwise we need to at least cut
 159     // over to the activatable hierarchy.
 160     aura::Window* focused = GetFocusedWindow(activatable);
 161     return activatable->Contains(focused) ? focused : activatable;
 162   }
 163
 164   while (window && !CanFocusWindow(window))
 165     window = window->parent();
 166   return window;
 167 }
 168
 169 aura::Window* BaseFocusRules::GetNextActivatableWindow(
 170     aura::Window* ignore) const {
 171   DCHECK(ignore);
 172
 173   // Can be called from the RootWindow's destruction, which has a NULL parent.
 174   if (!ignore->parent())
 175     return NULL;
 176
 177   // In the basic scenarios handled by BasicFocusRules, the pool of activatable
 178   // windows is limited to the |ignore|'s siblings.
 179   const aura::Window::Windows& siblings = ignore->parent()->children();
 180   DCHECK(!siblings.empty());
 181
 182   for (aura::Window::Windows::const_reverse_iterator rit = siblings.rbegin();
 183        rit != siblings.rend();
 184        ++rit) {
 185     aura::Window* cur = *rit;
 186     if (cur == ignore)
 187       continue;
 188     if (CanActivateWindow(cur))
 189       return cur;
 190   }
 191   return NULL;
 192 }
 193
 194 }  // namespace wm