Add window states docked; and docked minimized. Add wm window event to set docked and undocked.

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"
@@ skipping 60 matching lines @@
 DefaultState::~DefaultState() {}
 
 void DefaultState::OnWMEvent(WindowState* window_state,
                              const WMEvent* event) {
   if (ProcessWorkspaceEvents(window_state, event))
     return;
 
   if (ProcessCompoundEvents(window_state, event))
     return;
 
+  WindowStateType current_state_type = window_state->GetStateType();
   WindowStateType next_state_type = WINDOW_STATE_TYPE_NORMAL;
   switch (event->type()) {
     case WM_EVENT_NORMAL:
-      next_state_type = WINDOW_STATE_TYPE_NORMAL;
+      next_state_type =
+        current_state_type == WINDOW_STATE_TYPE_DOCKED_MINIMIZED ?
+        WINDOW_STATE_TYPE_DOCKED : WINDOW_STATE_TYPE_NORMAL;

[varkha, 2014/09/29 18:59:28]

nit: indent 4.

[dtapuska, 2014/09/29 20:59:56]

Done.

       break;
     case WM_EVENT_MAXIMIZE:
       next_state_type = WINDOW_STATE_TYPE_MAXIMIZED;
       break;
     case WM_EVENT_MINIMIZE:
-      next_state_type = WINDOW_STATE_TYPE_MINIMIZED;
+      next_state_type =
+        current_state_type == WINDOW_STATE_TYPE_DOCKED ?
+        WINDOW_STATE_TYPE_DOCKED_MINIMIZED : WINDOW_STATE_TYPE_MINIMIZED;

[varkha, 2014/09/29 18:59:28]

nit: indent 4.

[dtapuska, 2014/09/29 20:59:56]

Done.

       break;
     case WM_EVENT_FULLSCREEN:
       next_state_type = WINDOW_STATE_TYPE_FULLSCREEN;
       break;
     case WM_EVENT_SNAP_LEFT:
       next_state_type = WINDOW_STATE_TYPE_LEFT_SNAPPED;
       break;
     case WM_EVENT_SNAP_RIGHT:
       next_state_type = WINDOW_STATE_TYPE_RIGHT_SNAPPED;
       break;
+    case WM_EVENT_DOCK:
+      next_state_type = WINDOW_STATE_TYPE_DOCKED;
+      break;
     case WM_EVENT_SET_BOUNDS:
       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_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;
   }
 
-  WindowStateType current = window_state->GetStateType();
-
-  if (next_state_type == current && window_state->IsSnapped()) {
+  if (next_state_type == current_state_type && window_state->IsSnapped()) {
     gfx::Rect snapped_bounds = event->type() == WM_EVENT_SNAP_LEFT ?
         GetDefaultLeftSnappedWindowBoundsInParent(window_state->window()) :
         GetDefaultRightSnappedWindowBoundsInParent(window_state->window());
     window_state->SetBoundsDirectAnimated(snapped_bounds);
     return;
   }
 
   EnterToNextState(window_state, next_state_type);
 }
 
@@ skipping 131 matching lines @@
       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:
     case WM_EVENT_SHOW_INACTIVE:
+    case WM_EVENT_DOCK:
       break;
     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;
       break;
   }
   return false;
 }
 
@@ skipping 79 matching lines @@
     case WM_EVENT_TOGGLE_FULLSCREEN:
     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:
       break;
   }
   return false;
 }
 
 // static
 bool DefaultState::SetMaximizedOrFullscreenBounds(WindowState* window_state) {
   DCHECK(!window_state->is_dragged());
   if (window_state->IsMaximized()) {
     window_state->SetBoundsDirect(
@@ skipping 30 matching lines @@
   // Do nothing if  we're already in the same state.
   if (state_type_ == next_state_type)
     return;
 
   WindowStateType previous_state_type = state_type_;
   state_type_ = next_state_type;
 
   window_state->UpdateWindowShowStateFromStateType();
   window_state->NotifyPreStateTypeChange(previous_state_type);
 
-  // This Docked/Snapped hack is due to the issue that IsDocked returns
-  // true for dragging window.  TODO(oshima): Make docked window a state
-  // and remove this hack.
-  if (window_state->window()->parent() &&
-      (window_state->IsSnapped() ||
-       (!window_state->IsDocked() && !IsPanel(window_state->window())))) {
+  if (window_state->window()->parent()) {
     if (!window_state->HasRestoreBounds() &&
         (previous_state_type == WINDOW_STATE_TYPE_DEFAULT ||
          previous_state_type == WINDOW_STATE_TYPE_NORMAL) &&
         !window_state->IsMinimized() &&
         !window_state->IsNormalStateType()) {
       window_state->SaveCurrentBoundsForRestore();
+    } else if (window_state->HasRestoreBounds() &&
+               window_state->IsNormalStateType() &&
+               previous_state_type == WINDOW_STATE_TYPE_DOCKED) {
+      UpdateBoundsFromState(window_state, previous_state_type);
+
     }
 
-    // When restoring from a minimized state, we want to restore to the previous
-    // bounds. However, we want to maintain the restore bounds. (The restore
-    // bounds are set if a user maximized the window in one axis by double
-    // clicking the window border for example).
-    gfx::Rect restore_bounds_in_screen;
-    if (previous_state_type == WINDOW_STATE_TYPE_MINIMIZED &&
-        window_state->IsNormalStateType() &&
-        window_state->HasRestoreBounds() &&
-        !window_state->unminimize_to_restore_bounds()) {
-      restore_bounds_in_screen = window_state->GetRestoreBoundsInScreen();
-      window_state->SaveCurrentBoundsForRestore();
+    // This Docked/Snapped hack is due to the issue that IsDocked returns
+    // true for dragging window.  TODO(oshima): Make docked window a state
+    // and remove this hack.

[varkha, 2014/09/29 18:59:28]

Maybe rephrase a bit now that the docked state is introduced.

[dtapuska, 2014/09/29 20:59:56]

Done.

+    if (window_state->IsSnapped() ||
+        (!window_state->IsDocked() && !IsPanel(window_state->window()))) {
+      // When restoring from a minimized state, we want to restore to the
+      // previous bounds. However, we want to maintain the restore bounds.
+      // (The restore bounds are set if a user maximized the window in one
+      // axis by double clicking the window border for example).
+      gfx::Rect restore_bounds_in_screen;
+      if (previous_state_type == WINDOW_STATE_TYPE_MINIMIZED &&
+          window_state->IsNormalStateType() &&
+          window_state->HasRestoreBounds() &&
+          !window_state->unminimize_to_restore_bounds()) {
+        restore_bounds_in_screen = window_state->GetRestoreBoundsInScreen();
+        window_state->SaveCurrentBoundsForRestore();
+      }
+
+      if (window_state->IsMaximizedOrFullscreen())
+        MoveToDisplayForRestore(window_state);
+
+      UpdateBoundsFromState(window_state, previous_state_type);
+
+      // Normal state should have no restore bounds unless it's
+      // unminimized.
+      if (!restore_bounds_in_screen.IsEmpty())
+        window_state->SetRestoreBoundsInScreen(restore_bounds_in_screen);
+      else if (window_state->IsNormalStateType())
+        window_state->ClearRestoreBounds();
     }
-
-    if (window_state->IsMaximizedOrFullscreen())
-      MoveToDisplayForRestore(window_state);
-
-    UpdateBoundsFromState(window_state, previous_state_type);
-
-    // Normal state should have no restore bounds unless it's
-    // unminimzied.
-    if (!restore_bounds_in_screen.IsEmpty())
-      window_state->SetRestoreBoundsInScreen(restore_bounds_in_screen);
-    else if (window_state->IsNormalStateType())
-      window_state->ClearRestoreBounds();
   }
   window_state->NotifyPostStateTypeChange(previous_state_type);
 }
 
 void DefaultState::ReenterToCurrentState(
     WindowState* window_state,
     WindowState::State* state_in_previous_mode) {
   WindowStateType previous_state_type = state_in_previous_mode->GetType();
   if (previous_state_type == wm::WINDOW_STATE_TYPE_FULLSCREEN) {
     // A state change should not move a window out of full screen since full
@@ skipping 27 matching lines @@
                                          WindowStateType previous_state_type) {
   aura::Window* window = window_state->window();
   gfx::Rect bounds_in_parent;
   switch (state_type_) {
     case WINDOW_STATE_TYPE_LEFT_SNAPPED:
     case WINDOW_STATE_TYPE_RIGHT_SNAPPED:
       bounds_in_parent = state_type_ == WINDOW_STATE_TYPE_LEFT_SNAPPED ?
           GetDefaultLeftSnappedWindowBoundsInParent(window_state->window()) :
           GetDefaultRightSnappedWindowBoundsInParent(window_state->window());
       break;
+    case WINDOW_STATE_TYPE_DOCKED:
     case WINDOW_STATE_TYPE_DEFAULT:
     case WINDOW_STATE_TYPE_NORMAL: {
       gfx::Rect work_area_in_parent =
           ScreenUtil::GetDisplayWorkAreaBoundsInParent(window_state->window());
       if (window_state->HasRestoreBounds()) {
         bounds_in_parent = window_state->GetRestoreBoundsInParent();
         // Check if the |window|'s restored size is bigger than the working area
         // This may happen if a window was resized to maximized bounds or if the
         // display resolution changed while the window was maximized.
         if (previous_state_type == WINDOW_STATE_TYPE_MAXIMIZED &&
@@ skipping 13 matching lines @@
       break;
     }
     case WINDOW_STATE_TYPE_MAXIMIZED:
       bounds_in_parent = ScreenUtil::GetMaximizedWindowBoundsInParent(window);
       break;
 
     case WINDOW_STATE_TYPE_FULLSCREEN:
       bounds_in_parent = ScreenUtil::GetDisplayBoundsInParent(window);
       break;
 
+    case WINDOW_STATE_TYPE_DOCKED_MINIMIZED:
     case WINDOW_STATE_TYPE_MINIMIZED:
       break;
     case WINDOW_STATE_TYPE_INACTIVE:
     case WINDOW_STATE_TYPE_END:
     case WINDOW_STATE_TYPE_AUTO_POSITIONED:
       return;
   }
 
-  if (state_type_ != WINDOW_STATE_TYPE_MINIMIZED) {
+  if (!window_state->IsMinimized()) {
     if (previous_state_type == WINDOW_STATE_TYPE_MINIMIZED ||
+        previous_state_type == WINDOW_STATE_TYPE_DOCKED_MINIMIZED ||

[varkha, 2014/09/29 18:59:28]

nit: consider a variable or function to compare to both minimized states now
that this logic is repeated a few times.

[dtapuska, 2014/09/29 20:59:56]

Done.

         window_state->IsFullscreen()) {
       window_state->SetBoundsDirect(bounds_in_parent);
     } else if (window_state->IsMaximized() ||
                IsMaximizedOrFullscreenWindowStateType(previous_state_type)) {
       window_state->SetBoundsDirectCrossFade(bounds_in_parent);
     } else if (window_state->is_dragged()) {
       // SetBoundsDirectAnimated does not work when the window gets reparented.
       // TODO(oshima): Consider fixing it and reenable the animation.
       window_state->SetBoundsDirect(bounds_in_parent);
     } else {
       window_state->SetBoundsDirectAnimated(bounds_in_parent);
     }
   }
 
   if (window_state->IsMinimized()) {
     // Save the previous show state so that we can correctly restore it.
     window_state->window()->SetProperty(aura::client::kRestoreShowStateKey,
                                         ToWindowShowState(previous_state_type));
     ::wm::SetWindowVisibilityAnimationType(
         window_state->window(), WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE);
 
     // Hide the window.
     window_state->window()->Hide();
     // Activate another window.
     if (window_state->IsActive())
       window_state->Deactivate();
   } else if ((window_state->window()->TargetVisibility() ||
-              previous_state_type == WINDOW_STATE_TYPE_MINIMIZED) &&
+              (previous_state_type == WINDOW_STATE_TYPE_MINIMIZED ||
+               previous_state_type == WINDOW_STATE_TYPE_DOCKED_MINIMIZED)) &&
              !window_state->window()->layer()->visible()) {
     // The layer may be hidden if the window was previously minimized. Make
     // sure it's visible.
     window_state->window()->Show();
-    if (previous_state_type == WINDOW_STATE_TYPE_MINIMIZED &&
+    if ((previous_state_type == WINDOW_STATE_TYPE_MINIMIZED ||
+        previous_state_type == WINDOW_STATE_TYPE_DOCKED_MINIMIZED) &&
         !window_state->IsMaximizedOrFullscreen()) {
       window_state->set_unminimize_to_restore_bounds(false);
     }
   }
 }
 
 // static
 void DefaultState::CenterWindow(WindowState* window_state) {
   if (!window_state->IsNormalOrSnapped())
     return;
@@ skipping 12 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