| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
