Drag and rotate windows

ui/aura_shell/workspace/workspace_manager.cc

 // Copyright (c) 2011 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 "ui/aura_shell/workspace/workspace_manager.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "ui/aura/desktop.h"
 #include "ui/aura/screen_aura.h"
@@ skipping 42 matching lines @@
   Workspace* workspace = new Workspace(this);
   LayoutWorkspaces();
   return workspace;
 }
 
 Workspace* WorkspaceManager::GetActiveWorkspace() const {
   return active_workspace_;
 }
 
 Workspace* WorkspaceManager::FindBy(aura::Window* window) const {
+  int index = GetWorkspaceIndexContaining(window);
+  return index < 0 ? NULL : workspaces_[index];
+}
+
+aura::Window* WorkspaceManager::FindRotateWindowForLocation(
+    const gfx::Point& point) {
   for (Workspaces::const_iterator i = workspaces_.begin();
        i != workspaces_.end();
        ++i) {
-    if ((*i)->Contains(window))
-      return *i;
+    aura::Window* window = (*i)->FindRotateWindowForLocation(point);
+    if (window)
+      return window;
   }
   return NULL;
 }
 
 void WorkspaceManager::LayoutWorkspaces() {
   UpdateViewport();
 
   gfx::Rect bounds(workspace_size_);
   int x = 0;
   for (Workspaces::const_iterator i = workspaces_.begin();
@@ skipping 36 matching lines @@
     transform.SetTranslateX(-viewport_->GetTargetBounds().x() + dx);
     transform.SetTranslateY(workspace_size_.height() *  (1.0f - scale) / 2);
   } else {
     transform.SetTranslateX(-active_workspace_->bounds().x());
   }
 
   viewport_->layer()->SetAnimation(aura::Window::CreateDefaultAnimation());
   viewport_->layer()->SetTransform(transform);
 }
 
+void WorkspaceManager::RotateWindows(aura::Window* source,
+                                     aura::Window* target) {
+  DCHECK(source);
+  DCHECK(target);
+  int source_ws_index = GetWorkspaceIndexContaining(source);
+  int target_ws_index = GetWorkspaceIndexContaining(target);
+  DCHECK(source_ws_index >= 0);
+  DCHECK(target_ws_index >= 0);
+  if (source_ws_index == target_ws_index) {
+    workspaces_[source_ws_index]->RotateWindows(source, target);
+  } else {
+    aura::Window* insert = source;
+    if (source_ws_index < target_ws_index) {
+      for (int i = target_ws_index; i >= source_ws_index; --i) {
+        insert = workspaces_[i]->ShiftWindows(
+            insert, source, Workspace::SHIFT_TO_LEFT);
+      }
+    } else {
+      for (int i = target_ws_index; i <= source_ws_index; ++i) {
+        insert = workspaces_[i]->ShiftWindows(
+            insert, source, Workspace::SHIFT_TO_RIGHT);
+      }
+    }
+  }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // WorkspaceManager, Overridden from aura::DesktopObserver:
 
 void WorkspaceManager::OnDesktopResized(const gfx::Size& new_size) {
   workspace_size_ =
       gfx::Screen::GetMonitorAreaNearestWindow(viewport_).size();
   LayoutWorkspaces();
 }
 
 void WorkspaceManager::OnActiveWindowChanged(aura::Window* active) {
@@ skipping 38 matching lines @@
 }
 
 gfx::Rect WorkspaceManager::GetWorkAreaBounds(
     const gfx::Rect& workspace_bounds) {
   gfx::Rect bounds = workspace_bounds;
   bounds.Inset(
       aura::Desktop::GetInstance()->screen()->work_area_insets());
   return bounds;
 }
 
+// Returns the index of the workspace that contains the |window|.
+int WorkspaceManager::GetWorkspaceIndexContaining(aura::Window* window) const {
+  for (Workspaces::const_iterator i = workspaces_.begin();
+       i != workspaces_.end();
+       ++i) {
+    if ((*i)->Contains(window))
+      return i - workspaces_.begin();
+  }
+  return -1;
+}
+
 void WorkspaceManager::UpdateViewport() {
   int num_workspaces = std::max(1, static_cast<int>(workspaces_.size()));
   int total_width = workspace_size_.width() * num_workspaces +
       kWorkspaceHorizontalMargin * (num_workspaces - 1);
   gfx::Rect bounds(0, 0, total_width, workspace_size_.height());
 
   if (viewport_->GetTargetBounds() != bounds)
     viewport_->SetBounds(bounds);
 
   // Move to active workspace.
   if (active_workspace_) {
     ui::Transform transform;
     transform.SetTranslateX(-active_workspace_->bounds().x());
     viewport_->layer()->SetAnimation(aura::Window::CreateDefaultAnimation());
     viewport_->SetTransform(transform);
   }
 }
 
 }  // namespace aura_shell