Initial crack at new workspace behavior. Each workspace now has its

ash/wm/activation_controller.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ash/wm/activation_controller.h"
 
+#include "ash/root_window_controller.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
+#include "ash/wm/property_util.h"
 #include "ash/wm/window_modality_controller.h"
 #include "ash/wm/window_util.h"
+#include "ash/wm/workspace_controller.h"
 #include "base/auto_reset.h"
 #include "ui/aura/client/activation_change_observer.h"
 #include "ui/aura/client/activation_delegate.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/env.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/layer.h"
 
 namespace ash {
 namespace internal {
 namespace {
 
 // These are the list of container ids of containers which may contain windows
 // that need to be activated in the order that they should be activated.
 const int kWindowContainerIds[] = {
     kShellWindowId_LockSystemModalContainer,
     kShellWindowId_SettingBubbleContainer,
     kShellWindowId_LockScreenContainer,
     kShellWindowId_SystemModalContainer,
     kShellWindowId_AlwaysOnTopContainer,
     kShellWindowId_AppListContainer,
+    // TODO(sky): defaultcontainer shouldn't be in the list with workspace2.
     kShellWindowId_DefaultContainer,
 
     // Panel, launcher and status are intentionally checked after other
     // containers even though these layers are higher. The user expects their
     // windows to be focused before these elements.
     kShellWindowId_PanelContainer,
     kShellWindowId_LauncherContainer,
     kShellWindowId_StatusContainer,
 };
 
 // Returns true if children of |window| can be activated.
 // These are the only containers in which windows can receive focus.
 bool SupportsChildActivation(aura::Window* window) {
+  // TODO(sky): straighten this out when workspace2 is the default.
+  // kShellWindowId_WorkspaceContainer isn't in |kWindowContainerIds| since it
+  // needs to be special cased in GetTopmostWindowToActivate().
+  if (window->id() == kShellWindowId_WorkspaceContainer)
+    return true;
+
   for (size_t i = 0; i < arraysize(kWindowContainerIds); i++) {
-    if (window->id() == kWindowContainerIds[i])
+    if (window->id() == kWindowContainerIds[i] &&
+        (window->id() != kShellWindowId_DefaultContainer ||
+         !WorkspaceController::IsWorkspace2Enabled())) {
       return true;
+    }
   }
   return false;
 }
 
 bool HasModalTransientChild(aura::Window* window) {
   aura::Window::Windows::const_iterator it;
   for (it = window->transient_children().begin();
        it != window->transient_children().end();
        ++it) {
     if ((*it)->GetProperty(aura::client::kModalKey) == ui::MODAL_TYPE_WINDOW)
       return true;
   }
   return false;
 }
 
 // See description in VisibilityMatches.
 enum ActivateVisibilityType {
   TARGET_VISIBILITY,
   CURRENT_VISIBILITY,
 };
 
 // Used by CanActivateWindowWithEvent() to test the visibility of a window.
 // This is used by two distinct code paths:
 // . when activating from an event we only care about the actual visibility.
 // . when activating because of a keyboard accelerator, in which case we
 //   care about the TargetVisibility.
 bool VisibilityMatches(aura::Window* window, ActivateVisibilityType type) {
   bool visible = (type == CURRENT_VISIBILITY) ? window->IsVisible() :
       window->TargetVisibility();
-  return visible || wm::IsWindowMinimized(window);
+  return visible || wm::IsWindowMinimized(window) ||
+      (window->TargetVisibility() &&
+       window->parent()->id() == kShellWindowId_WorkspaceContainer);
 }
 
 // Returns true if |window| can be activated or deactivated.
 // A window manager typically defines some notion of "top level window" that
 // supports activation/deactivation.
 bool CanActivateWindowWithEvent(aura::Window* window,
                                 const ui::Event* event,
                                 ActivateVisibilityType visibility_type) {
   return window &&
       VisibilityMatches(window, visibility_type) &&
@@ skipping 151 matching lines @@
 
   AutoReset<bool> in_activate_window(&updating_activation_, true);
   // Nothing may actually have changed.
   if (active_window_ == window)
     return;
   // The stacking client may impose rules on what window configurations can be
   // activated or deactivated.
   if (window && !CanActivateWindowWithEvent(window, event, CURRENT_VISIBILITY))
     return;
 
+  // Make sure the workspace manager switches to the workspace for window.
+  // Without this CanReceiveEvents() below returns false and activation never
+  // changes. CanReceiveEvents() returns false if |window| isn't in the active
+  // workspace, in which case its parent is not visible.
+  // TODO(sky): if I instead change the opacity of the parent this isn't an
+  // issue, but will make animations trickier... Consider which one is better.
+  if (window) {
+    internal::RootWindowController* root_window_controller =
+        GetRootWindowController(window->GetRootWindow());
+    root_window_controller->workspace_controller()->
+        SetActiveWorkspaceByWindow(window);
+  }
+
   // Restore minimized window. This needs to be done before CanReceiveEvents()
   // is called as that function checks window visibility.
   if (window && wm::IsWindowMinimized(window))
     window->Show();
 
   // If the screen is locked, just bring the window to top so that
   // it will be activated when the lock window is destroyed.
   if (window && !window->CanReceiveEvents()) {
     StackTransientParentsBelowModalWindow(window);
     window->parent()->StackChildAtTop(window);
@@ skipping 51 matching lines @@
     if (container && container->Contains(ignore)) {
       current_container_index = i;
       break;
     }
   }
 
   // Look for windows to focus in that container and below.
   aura::Window* window = NULL;
   for (; !window && current_container_index < arraysize(kWindowContainerIds);
        current_container_index++) {
-
     aura::Window::Windows containers =
         Shell::GetAllContainers(kWindowContainerIds[current_container_index]);
     for (aura::Window::Windows::const_iterator iter = containers.begin();
-         iter != containers.end();
-         ++iter) {
+         iter != containers.end() && !window; ++iter) {
       window = GetTopmostWindowToActivateInContainer((*iter), ignore);
     }
   }
   return window;
 }
 
 aura::Window* ActivationController::GetTopmostWindowToActivateInContainer(
     aura::Window* container,
     aura::Window* ignore) const {
+  // Workspace2 has an extra level of windows that needs to be special cased.
+  if (container->id() == kShellWindowId_DefaultContainer &&
+      WorkspaceController::IsWorkspace2Enabled()) {
+    for (aura::Window::Windows::const_reverse_iterator i =
+             container->children().rbegin();
+         i != container->children().rend(); ++i) {
+      if ((*i)->IsVisible()) {
+        aura::Window* window = GetTopmostWindowToActivateInContainer(
+            *i, ignore);
+        if (window)
+          return window;
+      }
+    }
+    return NULL;
+  }
   for (aura::Window::Windows::const_reverse_iterator i =
            container->children().rbegin();
        i != container->children().rend();
        ++i) {
     if (*i != ignore &&
         CanActivateWindowWithEvent(*i, NULL, CURRENT_VISIBILITY) &&
         !wm::IsWindowMinimized(*i))
       return *i;
   }
   return NULL;
 }
 
 }  // namespace internal
 }  // namespace ash