Change behaviour of the Alt-] and Alt-[ keys so that it cycles through SnapLeft/SnapRight to DockLe…

ash/wm/default_state.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 "ash/wm/default_state.h"
 
 #include "ash/display/display_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/coordinate_conversion.h"
+#include "ash/wm/dock/docked_window_layout_manager.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_state_delegate.h"
 #include "ash/wm/window_state_util.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/wm_event.h"
 #include "ash/wm/workspace/workspace_window_resizer.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
@@ skipping 35 matching lines @@
     aura::Window* new_root =
         display_controller->GetRootWindowForDisplayId(display.id());
     if (new_root != window_state->window()->GetRootWindow()) {
       aura::Window* new_container =
           Shell::GetContainer(new_root, window_state->window()->parent()->id());
       new_container->AddChild(window_state->window());
     }
   }
 }
 
+DockedWindowLayoutManager* GetDockedWindowLayoutManager() {
+  aura::Window* active_window = ash::wm::GetActiveWindow();
+  if (active_window) {
+    aura::Window* dock_container = Shell::GetContainer(
+      active_window->GetRootWindow(), kShellWindowId_DockedContainer);
+    DockedWindowLayoutManager* dock_layout =
+      static_cast<DockedWindowLayoutManager*>(
+        dock_container->layout_manager());
+    return dock_layout;
+  }
+  return NULL;
+}
+
+class ScopedPreferredAlignmentResetter {
+ public:
+  ScopedPreferredAlignmentResetter(DockedAlignment dock_alignment,
+                                   DockedWindowLayoutManager* dock_layout)
+      : docked_window_layout_manager_(dock_layout) {
+    docked_window_layout_manager_->set_preferred_alignment(dock_alignment);
+  }
+  ~ScopedPreferredAlignmentResetter() {
+    docked_window_layout_manager_->set_preferred_alignment(
+        DOCKED_ALIGNMENT_NONE);
+  }
+
+ private:
+  DockedWindowLayoutManager* docked_window_layout_manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedPreferredAlignmentResetter);
+};
+
+class ScopedDockedLayoutEventSourceResetter {
+ public:
+  ScopedDockedLayoutEventSourceResetter(DockedWindowLayoutManager* dock_layout)
+      : docked_window_layout_manager_(dock_layout) {
+    docked_window_layout_manager_->set_event_source(
+        DOCKED_ACTION_SOURCE_KEYBOARD);
+  }
+  ~ScopedDockedLayoutEventSourceResetter() {
+    docked_window_layout_manager_->set_event_source(
+        DOCKED_ACTION_SOURCE_UNKNOWN);
+  }
+
+ private:
+  DockedWindowLayoutManager* docked_window_layout_manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedDockedLayoutEventSourceResetter);
+};
+
+void CycleSnapDock(WindowState* window_state, WMEventType event) {
+  DockedWindowLayoutManager* dock_layout = GetDockedWindowLayoutManager();
+  wm::WindowStateType desired_snap_state = event ==
+      WM_EVENT_CYCLE_SNAP_DOCK_LEFT ? wm::WINDOW_STATE_TYPE_LEFT_SNAPPED :
+      wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED;
+  DockedAlignment desired_dock_alignment = event ==
+      WM_EVENT_CYCLE_SNAP_DOCK_LEFT ?
+      DOCKED_ALIGNMENT_LEFT : DOCKED_ALIGNMENT_RIGHT;
+  DockedAlignment current_dock_alignment = dock_layout ?
+      dock_layout->CalculateAlignment() : DOCKED_ALIGNMENT_NONE;
+
+  if (!window_state->IsDocked() ||
+      (current_dock_alignment != DOCKED_ALIGNMENT_NONE &&
+       current_dock_alignment != desired_dock_alignment)) {
+    if (window_state->CanSnap() &&
+        window_state->GetStateType() != desired_snap_state &&
+        window_state->window()->type() != ui::wm::WINDOW_TYPE_PANEL) {
+      const wm::WMEvent event(desired_snap_state ==
+                              wm::WINDOW_STATE_TYPE_LEFT_SNAPPED ?
+                              wm::WM_EVENT_SNAP_LEFT : wm::WM_EVENT_SNAP_RIGHT);
+      window_state->OnWMEvent(&event);
+      return;
+    }
+
+    if (dock_layout &&
+        dock_layout->CanDockWindow(window_state->window(),
+                                   desired_dock_alignment)) {
+      if (window_state->IsDocked()) {
+        dock_layout->MaybeSetDesiredDockedAlignment(desired_dock_alignment);
+        return;
+      }
+
+      ScopedDockedLayoutEventSourceResetter event_source_resetter(dock_layout);
+      ScopedPreferredAlignmentResetter alignmentResetter(desired_dock_alignment,
+                                                         dock_layout);
+      const wm::WMEvent event(wm::WM_EVENT_DOCK);
+      window_state->OnWMEvent(&event);
+      return;
+    }
+  }
+
+  if (window_state->IsDocked() || window_state->IsSnapped()) {
+    ScopedDockedLayoutEventSourceResetter event_source_resetter(dock_layout);
+    window_state->Restore();
+    return;
+  }
+  ::wm::AnimateWindow(window_state->window(),
+                      ::wm::WINDOW_ANIMATION_TYPE_BOUNCE);
+}
+
 }  // namespace;
 
 DefaultState::DefaultState(WindowStateType initial_state_type)
     : state_type_(initial_state_type) {}
 DefaultState::~DefaultState() {}
 
 void DefaultState::OnWMEvent(WindowState* window_state,
                              const WMEvent* event) {
   if (ProcessWorkspaceEvents(window_state, event))
     return;
@@ skipping 33 matching lines @@
       SetBounds(window_state, static_cast<const SetBoundsEvent*>(event));
       return;
     case WM_EVENT_SHOW_INACTIVE:
       next_state_type = WINDOW_STATE_TYPE_INACTIVE;
       break;
     case WM_EVENT_TOGGLE_MAXIMIZE_CAPTION:
     case WM_EVENT_TOGGLE_MAXIMIZE:
     case WM_EVENT_TOGGLE_VERTICAL_MAXIMIZE:
     case WM_EVENT_TOGGLE_HORIZONTAL_MAXIMIZE:
     case WM_EVENT_TOGGLE_FULLSCREEN:
+    case WM_EVENT_CYCLE_SNAP_DOCK_LEFT:
+    case WM_EVENT_CYCLE_SNAP_DOCK_RIGHT:
     case WM_EVENT_CENTER:
       NOTREACHED() << "Compound event should not reach here:" << event;
       return;
     case WM_EVENT_ADDED_TO_WORKSPACE:
     case WM_EVENT_WORKAREA_BOUNDS_CHANGED:
     case WM_EVENT_DISPLAY_BOUNDS_CHANGED:
       NOTREACHED() << "Workspace event should not reach here:" << event;
       return;
   }
 
@@ skipping 131 matching lines @@
         }
 
         window_state->SetRestoreBoundsInParent(restore_bounds);
         window->SetBounds(new_bounds);
       }
       return true;
     }
     case WM_EVENT_TOGGLE_FULLSCREEN:
       ToggleFullScreen(window_state, window_state->delegate());
       return true;
+    case WM_EVENT_CYCLE_SNAP_DOCK_LEFT:
+    case WM_EVENT_CYCLE_SNAP_DOCK_RIGHT:
+      CycleSnapDock(window_state, event->type());
+      return true;
     case WM_EVENT_CENTER:
       CenterWindow(window_state);
       return true;
     case WM_EVENT_NORMAL:
     case WM_EVENT_MAXIMIZE:
     case WM_EVENT_MINIMIZE:
     case WM_EVENT_FULLSCREEN:
     case WM_EVENT_SNAP_LEFT:
     case WM_EVENT_SNAP_RIGHT:
     case WM_EVENT_SET_BOUNDS:
@@ skipping 82 matching lines @@
       window_state->AdjustSnappedBounds(&bounds);
       if (window_state->window()->bounds() != bounds)
         window_state->SetBoundsDirectAnimated(bounds);
       return true;
     }
     case WM_EVENT_TOGGLE_MAXIMIZE_CAPTION:
     case WM_EVENT_TOGGLE_MAXIMIZE:
     case WM_EVENT_TOGGLE_VERTICAL_MAXIMIZE:
     case WM_EVENT_TOGGLE_HORIZONTAL_MAXIMIZE:
     case WM_EVENT_TOGGLE_FULLSCREEN:
+    case WM_EVENT_CYCLE_SNAP_DOCK_LEFT:
+    case WM_EVENT_CYCLE_SNAP_DOCK_RIGHT:
     case WM_EVENT_CENTER:
     case WM_EVENT_NORMAL:
     case WM_EVENT_MAXIMIZE:
     case WM_EVENT_MINIMIZE:
     case WM_EVENT_FULLSCREEN:
     case WM_EVENT_SNAP_LEFT:
     case WM_EVENT_SNAP_RIGHT:
     case WM_EVENT_SET_BOUNDS:
     case WM_EVENT_SHOW_INACTIVE:
     case WM_EVENT_DOCK:
@@ skipping 242 matching lines @@
         ScreenUtil::GetDisplayWorkAreaBoundsInParent(window);
     center_in_parent.ClampToCenteredSize(window->bounds().size());
     window_state->SetBoundsDirectAnimated(center_in_parent);
   }
   // Centering window is treated as if a user moved and resized the window.
   window_state->set_bounds_changed_by_user(true);
 }
 
 }  // namespace wm
 }  // namespace ash