athena: Fix window-layout in split-view mode.

athena/wm/window_manager_impl.cc

 // Copyright 2014 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 "athena/wm/window_manager_impl.h"
 
 #include <algorithm>
 
 #include "athena/common/container_priorities.h"
 #include "athena/screen/public/screen_manager.h"
 #include "athena/wm/bezel_controller.h"
 #include "athena/wm/public/window_manager_observer.h"
 #include "athena/wm/split_view_controller.h"
 #include "athena/wm/title_drag_controller.h"
 #include "athena/wm/window_list_provider_impl.h"
 #include "athena/wm/window_overview_mode.h"
 #include "base/logging.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
+#include "ui/gfx/display.h"
+#include "ui/gfx/screen.h"
 #include "ui/wm/core/shadow_controller.h"
 #include "ui/wm/core/window_util.h"
 #include "ui/wm/core/wm_state.h"
 #include "ui/wm/public/activation_client.h"
 #include "ui/wm/public/window_types.h"
 
 namespace athena {
 namespace {
-
 class WindowManagerImpl* instance = NULL;
+}  // namespace
 
 class AthenaContainerLayoutManager : public aura::LayoutManager {
  public:
   AthenaContainerLayoutManager();
   virtual ~AthenaContainerLayoutManager();
 
  private:
   // aura::LayoutManager:
   virtual void OnWindowResized() OVERRIDE;
   virtual void OnWindowAddedToLayout(aura::Window* child) OVERRIDE;
   virtual void OnWillRemoveWindowFromLayout(aura::Window* child) OVERRIDE;
   virtual void OnWindowRemovedFromLayout(aura::Window* child) OVERRIDE;
   virtual void OnChildWindowVisibilityChanged(aura::Window* child,
                                               bool visible) OVERRIDE;
   virtual void SetChildBounds(aura::Window* child,
                               const gfx::Rect& requested_bounds) OVERRIDE;
 
   DISALLOW_COPY_AND_ASSIGN(AthenaContainerLayoutManager);
 };
 
 AthenaContainerLayoutManager::AthenaContainerLayoutManager() {
 }
 
 AthenaContainerLayoutManager::~AthenaContainerLayoutManager() {
 }
 
 void AthenaContainerLayoutManager::OnWindowResized() {
-  instance->Layout();
+  // Resize all the existing windows.
+  aura::Window::Windows list = instance->window_list_provider_->GetWindowList();
+  const gfx::Size work_area =
+      gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area().size();
+  bool is_splitview = instance->split_view_controller_->IsSplitViewModeActive();
+  gfx::Size split_size;
+  if (is_splitview) {
+    CHECK(instance->split_view_controller_->left_window());
+    split_size =
+        instance->split_view_controller_->left_window()->bounds().size();
+  }
+
+  for (aura::Window::Windows::const_iterator iter = list.begin();
+       iter != list.end();
+       ++iter) {
+    aura::Window* window = *iter;
+    if (is_splitview) {
+      if (window == instance->split_view_controller_->left_window())
+        window->SetBounds(gfx::Rect(split_size));
+      else if (window == instance->split_view_controller_->right_window())
+        window->SetBounds(
+            gfx::Rect(gfx::Point(split_size.width(), 0), split_size));
+      else
+        window->SetBounds(gfx::Rect(work_area));
+    } else {
+      window->SetBounds(gfx::Rect(work_area));
+    }
+  }
 }
 
 void AthenaContainerLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
-  instance->Layout();
+  aura::Window::Windows list = instance->window_list_provider_->GetWindowList();
+  if (std::find(list.begin(), list.end(), child) == list.end())
+    return;
+  aura::Window* window = NULL;
+  if (instance->split_view_controller_->IsSplitViewModeActive())
+    window = instance->split_view_controller_->left_window();
+  else
+    window = instance->container_.get();
+  CHECK(window);
+  child->SetBounds(gfx::Rect(window->bounds().size()));
 }
 
 void AthenaContainerLayoutManager::OnWillRemoveWindowFromLayout(
     aura::Window* child) {
 }
 
 void AthenaContainerLayoutManager::OnWindowRemovedFromLayout(
     aura::Window* child) {
-  instance->Layout();
 }
 
 void AthenaContainerLayoutManager::OnChildWindowVisibilityChanged(
     aura::Window* child,
     bool visible) {
-  instance->Layout();
 }
 
 void AthenaContainerLayoutManager::SetChildBounds(
     aura::Window* child,
     const gfx::Rect& requested_bounds) {
   if (!requested_bounds.IsEmpty())
     SetChildBoundsDirect(child, requested_bounds);
 }
 
-}  // namespace
-
 WindowManagerImpl::WindowManagerImpl() {
   ScreenManager::ContainerParams params("DefaultContainer", CP_DEFAULT);
   params.can_activate_children = true;
   container_.reset(ScreenManager::Get()->CreateDefaultContainer(params));
   container_->SetLayoutManager(new AthenaContainerLayoutManager);
   container_->AddObserver(this);
   window_list_provider_.reset(new WindowListProviderImpl(container_.get()));
   bezel_controller_.reset(new BezelController(container_.get()));
   split_view_controller_.reset(
       new SplitViewController(container_.get(), window_list_provider_.get()));
@@ skipping 15 matching lines @@
   if (container_) {
     container_->RemoveObserver(this);
     container_->RemovePreTargetHandler(bezel_controller_.get());
   }
   // |title_drag_controller_| needs to be reset before |container_|.
   title_drag_controller_.reset();
   container_.reset();
   instance = NULL;
 }
 
-void WindowManagerImpl::Layout() {
-  if (!container_)
-    return;
-  gfx::Rect bounds = gfx::Rect(container_->bounds().size());
-  const aura::Window::Windows& children = container_->children();
-  for (aura::Window::Windows::const_iterator iter = children.begin();
-       iter != children.end();
-       ++iter) {
-    if ((*iter)->type() == ui::wm::WINDOW_TYPE_NORMAL)
-      (*iter)->SetBounds(bounds);
-  }
-}
-
 void WindowManagerImpl::ToggleOverview() {
   SetInOverview(overview_.get() == NULL);
 }
 
 bool WindowManagerImpl::IsOverviewModeActive() {
   return overview_;
 }
 
 void WindowManagerImpl::SetInOverview(bool active) {
   bool in_overview = !!overview_;
@@ skipping 143 matching lines @@
   DCHECK(!instance);
 }
 
 // static
 WindowManager* WindowManager::GetInstance() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena