Added HALF, FULLSCREEN_ALL_APPS, and FULLSCREEN_SEARCH.

ui/app_list/views/app_list_view.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 "ui/app_list/views/app_list_view.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/macros.h"
@@ skipping 43 matching lines @@
 
 // The margin from the edge to the speech UI.
 constexpr int kSpeechUIMargin = 12;
 
 // The height/width of the shelf.
 constexpr int kShelfSize = 48;
 
 // The height of the peeking app list.
 constexpr int kPeekingAppListHeight = 320;
 
+// The height of the half app list.
+constexpr int kHalfAppListHeight = 561;
+
 // The fraction of app list height that the app list must be released at in
 // order to transition to the next state.
 constexpr int kAppListThresholdDenominator = 3;
 
 // The velocity the app list must be dragged in order to transition to the next
 // state, measured in DIPs/event.
 constexpr int kAppListDragVelocityThreshold = 25;
 
+// The DIP distance from the bezel that a drag event must end within to transfer
+// the |app_list_state_|.
+constexpr int kAppListBezelMargin = 50;
+
 // The opacity of the app list background.
 constexpr float kAppListOpacity = 0.8;
 
 // The vertical position for the appearing animation of the speech UI.
 constexpr float kSpeechUIAppearingPosition = 12;
 
 bool IsFullscreenAppListEnabled() {
   // Cache this value to avoid repeated lookup.
   static bool cached_value = features::IsFullscreenAppListEnabled();
   return cached_value;
@@ skipping 127 matching lines @@
     display_observer_.Add(display::Screen::GetScreen());
 }
 
 AppListView::~AppListView() {
   delegate_->GetSpeechUI()->RemoveObserver(this);
   animation_observer_.reset();
   // Remove child views first to ensure no remaining dependencies on delegate_.
   RemoveAllChildViews(true);
 }
 
-void AppListView::Initialize(gfx::NativeView parent, int initial_apps_page) {
+void AppListView::Initialize(gfx::NativeView parent,
+                             int initial_apps_page,
+                             bool is_maximize_mode,
+                             bool is_side_shelf) {
   base::Time start_time = base::Time::Now();
+  is_maximize_mode_ = is_maximize_mode;
+  is_side_shelf_ = is_side_shelf;
   InitContents(parent, initial_apps_page);
   AddAccelerator(ui::Accelerator(ui::VKEY_ESCAPE, ui::EF_NONE));
   set_color(kContentsBackgroundColor);
   set_parent_window(parent);
 
-  if (IsFullscreenAppListEnabled())
+  if (features::IsFullscreenAppListEnabled())
     InitializeFullscreen(parent, initial_apps_page);
   else
     InitializeBubble(parent, initial_apps_page);
 
   InitChildWidgets();
   AddChildView(overlay_view_);
 
   if (IsFullscreenAppListEnabled())
     SetState(app_list_state_);
 
@@ skipping 274 matching lines @@
 
 void AppListView::EndDrag(const gfx::Point& location) {
   // Change the app list state based on where the drag ended. If fling velocity
   // was over the threshold, snap to the next state in the direction of the
   // fling.
   int const new_y_position = location.y() - initial_drag_point_.y() +
                              fullscreen_widget_->GetWindowBoundsInScreen().y();
   if (std::abs(last_fling_velocity_) > kAppListDragVelocityThreshold) {
     // If the user releases drag with velocity over the threshold, snap to
     // the next state, ignoring the drag release position.
-    if (app_list_state_ == FULLSCREEN) {
-      if (last_fling_velocity_ > 0)
-        SetState(PEEKING);
 
+    if (last_fling_velocity_ > 0) {
+      switch (app_list_state_) {
+        case PEEKING:
+        case HALF:
+        case FULLSCREEN_SEARCH:
+          SetState(CLOSED);
+          break;
+        case FULLSCREEN_ALL_APPS:
+          SetState(is_maximize_mode_ || is_side_shelf_ ? CLOSED : PEEKING);
+          break;
+        case CLOSED:
+          NOTREACHED();
+          break;
+      }
     } else {
-      SetState(last_fling_velocity_ > 0 ? CLOSED : FULLSCREEN);
+      switch (app_list_state_) {
+        case FULLSCREEN_ALL_APPS:
+        case FULLSCREEN_SEARCH:
+          SetState(app_list_state_);
+          break;
+        case HALF:
+          SetState(FULLSCREEN_SEARCH);
+          break;
+        case PEEKING:
+          SetState(FULLSCREEN_ALL_APPS);
+          break;
+        case CLOSED:
+          NOTREACHED();
+          break;
+      }
     }
-    last_fling_velocity_ = 0;
   } else {
     int display_height = display::Screen::GetScreen()
                              ->GetDisplayNearestView(parent_window())
                              .work_area()
                              .height();
-    int default_peeking_y = display_height + kShelfSize - kPeekingAppListHeight;
-    // The drag release velocity was too low, so use the release point.
-    int app_list_snap_y =
-        (app_list_state_ == FULLSCREEN) ? 0 : default_peeking_y;
-    // The DIP delta that must be exceeded for the app list to snap to the next
-    // state.
-    int app_list_threshold =
-        (fullscreen_widget_->GetWindowBoundsInScreen().height() + kShelfSize) /
-        kAppListThresholdDenominator;
-    app_list_threshold -=
-        (app_list_state_ == FULLSCREEN ? 0 : kPeekingAppListHeight) /
-        kAppListThresholdDenominator;
+    int app_list_y_for_state = 0;
+    int app_list_height = 0;
+    switch (app_list_state_) {
+      case FULLSCREEN_ALL_APPS:
+      case FULLSCREEN_SEARCH:
+        app_list_y_for_state = 0;
+        app_list_height = display_height;
+        break;
+      case HALF:
+        app_list_y_for_state = display_height - kHalfAppListHeight;
+        app_list_height = kHalfAppListHeight;
+        break;
+      case PEEKING:
+        app_list_y_for_state = display_height - kPeekingAppListHeight;
+        app_list_height = kPeekingAppListHeight;
+        break;
+      case CLOSED:
+        NOTREACHED();
+        break;
+    }
 
-    // If the user releases +/- 1/3 of |app_list_threshold|, snap to the
-    // next state.
-    if (std::abs(app_list_snap_y - new_y_position) < app_list_threshold) {
-      // The drag was not far enough so set the app list bounds to the target
-      // bounds for the current state.
-      SetState(app_list_state_);
-    } else if ((app_list_snap_y + app_list_threshold) < new_y_position) {
-      // The drag was far enough to change states and was a downward drag, so
-      // set the app list bounds to the next state.
-      SetState(app_list_state_ == FULLSCREEN ? PEEKING : CLOSED);
-    } else {
-      // The drag was far enough to change states and was an upward drag, so
-      // set the app list bounds to the next state.
-      SetState(FULLSCREEN);
+    int app_list_threshold = app_list_height / kAppListThresholdDenominator;
+    int drag_delta = app_list_y_for_state - new_y_position;
+    switch (app_list_state_) {
+      case FULLSCREEN_ALL_APPS:
+        if (std::abs(drag_delta) > app_list_threshold)
+          SetState(is_maximize_mode_ || is_side_shelf_ ? CLOSED : PEEKING);
+        else
+          SetState(app_list_state_);
+        break;
+      case FULLSCREEN_SEARCH:
+        if (std::abs(drag_delta) > app_list_threshold)
+          SetState(CLOSED);
+        else
+          SetState(app_list_state_);
+        break;
+      case HALF:
+        if (std::abs(drag_delta) > app_list_threshold) {
+          SetState(drag_delta > 0 ? FULLSCREEN_SEARCH : CLOSED);
+        } else if (location.y() +
+                       fullscreen_widget_->GetWindowBoundsInScreen().y() >=
+                   display_height - kAppListBezelMargin) {
+          // If the user drags to the bezel, close the app list.
+          SetState(CLOSED);
+        } else {
+          SetState(app_list_state_);
+        }
+        break;
+      case PEEKING:
+        if (std::abs(drag_delta) > app_list_threshold) {
+          SetState(drag_delta > 0 ? FULLSCREEN_ALL_APPS : CLOSED);
+        } else if (location.y() +
+                       fullscreen_widget_->GetWindowBoundsInScreen().y() >=
+                   display_height - kAppListBezelMargin) {
+          // If the user drags to the bezel, close the app list.
+          SetState(CLOSED);
+        } else {
+          SetState(app_list_state_);
+        }
+        break;
+      case CLOSED:
+        NOTREACHED();
+        break;
     }
   }
 }
 
+void AppListView::SetStateFromSearchBoxView(bool empty) {
+  switch (app_list_state_) {
+    case PEEKING:
+      if (!empty)
+        SetState(HALF);
+      break;
+    case HALF:
+      if (empty)
+        SetState(PEEKING);
+      break;
+    case FULLSCREEN_SEARCH:
+      if (empty) {
+        SetState(FULLSCREEN_ALL_APPS);
+        app_list_main_view()->contents_view()->SetActiveState(
+            AppListModel::State::STATE_APPS);
+      }
+      break;
+    case FULLSCREEN_ALL_APPS:
+      if (!empty)
+        SetState(FULLSCREEN_SEARCH);
+      break;
+    case CLOSED:
+      NOTREACHED();
+      break;
+  }
+}
+
+void AppListView::OnMaximizeModeChanged(bool started) {
+  is_maximize_mode_ = started;
+  if (is_maximize_mode_ && !is_fullscreen()) {
+    // Set |app_list_state_| to a maximize mode friendly state.
+    SetState(app_list_state_ == PEEKING ? FULLSCREEN_ALL_APPS
+                                        : FULLSCREEN_SEARCH);
+  }
+}
+
 void AppListView::OnBeforeBubbleWidgetInit(views::Widget::InitParams* params,
                                            views::Widget* widget) const {
   if (!params->native_widget) {
     views::ViewsDelegate* views_delegate = views::ViewsDelegate::GetInstance();
     if (views_delegate && !views_delegate->native_widget_factory().is_null()) {
       params->native_widget =
           views_delegate->native_widget_factory().Run(*params, widget);
     }
   }
   // Apply a WM-provided shadow (see ui/wm/core/).
@@ skipping 113 matching lines @@
 }
 
 void AppListView::SchedulePaintInRect(const gfx::Rect& rect) {
   BubbleDialogDelegateView::SchedulePaintInRect(rect);
   if (GetBubbleFrameView())
     GetBubbleFrameView()->SchedulePaint();
 }
 
 void AppListView::SetState(AppListState new_state) {
   gfx::Rect new_widget_bounds = fullscreen_widget_->GetWindowBoundsInScreen();
-  switch (new_state) {
+  AppListState new_state_override;
+  bool state_overridden = false;

[vadimt, 2017/06/13 19:20:31]

You don't need this. Just initialize new_state_override with new_state.

[newcomer, 2017/06/13 20:25:06]

Done.

+  if (is_side_shelf_ || is_maximize_mode_) {
+    // If side shelf or maximize mode are active, all transitions should be
+    // made to the maximize mode/side shelf friendly versions.
+    if (new_state == PEEKING) {
+      new_state_override = FULLSCREEN_ALL_APPS;
+      state_overridden = true;
+    } else if (new_state == HALF) {
+      new_state_override = FULLSCREEN_SEARCH;
+      state_overridden = true;
+    }
+  }
+
+  switch (state_overridden ? new_state_override : new_state) {
     case PEEKING: {
-      int display_height = display::Screen::GetScreen()
-                               ->GetDisplayNearestView(parent_window())
-                               .work_area()
-                               .bottom();
-      int default_peeking_y =
-          display_height + kShelfSize - kPeekingAppListHeight;
-      new_widget_bounds.set_y(default_peeking_y);
+      switch (app_list_state_) {
+        case HALF:
+        case FULLSCREEN_ALL_APPS:
+        case PEEKING: {
+          int display_height = display::Screen::GetScreen()
+                                   ->GetDisplayNearestView(parent_window())
+                                   .work_area()
+                                   .bottom();
+          int peeking_app_list_y = display_height - kPeekingAppListHeight;
+          new_widget_bounds.set_y(peeking_app_list_y);
+          app_list_main_view_->contents_view()->SetActiveState(
+              AppListModel::STATE_START);
+          break;
+        }
+        case FULLSCREEN_SEARCH:
+        case CLOSED:
+          NOTREACHED();
+          break;
+      }
       break;
-    }
-    case FULLSCREEN:
+    } break;
+    case HALF:
+      switch (app_list_state_) {
+        case PEEKING:
+        case HALF: {
+          int display_height = display::Screen::GetScreen()
+                                   ->GetDisplayNearestView(parent_window())
+                                   .work_area()
+                                   .bottom();
+          int half_app_list_y = display_height - kHalfAppListHeight;
+          new_widget_bounds.set_y(half_app_list_y);
+          break;
+        }
+        case FULLSCREEN_SEARCH:
+        case FULLSCREEN_ALL_APPS:
+        case CLOSED:
+          NOTREACHED();
+          break;
+      }
+      break;
+    case FULLSCREEN_ALL_APPS:
+      new_widget_bounds.set_y(0);
+      app_list_main_view_->contents_view()->SetActiveState(
+          AppListModel::STATE_APPS);
+      break;
+    case FULLSCREEN_SEARCH:
       new_widget_bounds.set_y(0);
       break;
     case CLOSED:
       app_list_main_view_->Close();
       delegate_->Dismiss();
       break;
   }
   fullscreen_widget_->SetBounds(new_widget_bounds);
-  app_list_state_ = new_state;
+  app_list_state_ = state_overridden ? new_state_override : new_state;
 }
 
 void AppListView::OnWidgetDestroying(views::Widget* widget) {
   BubbleDialogDelegateView::OnWidgetDestroying(widget);
   if (delegate_ && widget == GetWidget())
     delegate_->ViewClosing();
 }
 
 void AppListView::OnWidgetVisibilityChanged(views::Widget* widget,
                                             bool visible) {
@@ skipping 84 matching lines @@
                        .work_area()
                        .size();
   size.Enlarge(0, kShelfSize);
   fullscreen_widget_->SetSize(size);
 
   // Update the |fullscreen_widget_| bounds to accomodate the new work area.
   SetState(app_list_state_);
 }
 
 }  // namespace app_list