Draggable peeking/fullscreen launcher with transparent background.

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 38 matching lines @@
 #include "ui/wm/core/masked_window_targeter.h"
 #include "ui/wm/core/shadow_types.h"
 
 namespace app_list {
 
 namespace {
 
 // The margin from the edge to the speech UI.
 const int kSpeechUIMargin = 12;
 
+// The height/width of the shelf.
+const int kShelfSize = 48;
+
+// The height of the peeking launcher.
+const int kPeekingLauncherHeight = 320;
+// The fraction of launcher height that the launcher must be released at in
+// order to transition to the next state.
+const int kLauncherThresholdDenominator = 3;
+// The velocity the launcher must be dragged in order to transition to the next
+// state, measured in DIPs/event.
+const int kLauncherDragVelocityThreshold = 25;
+
+const float kLauncherOpacity = 0.8;
+
 // The vertical position for the appearing animation of the speech UI.
 const float kSpeechUIAppearingPosition = 12;
 
 // This view forwards the focus to the search box widget by providing it as a
 // FocusTraversable when a focus search is provided.
 class SearchBoxFocusHost : public views::View {
  public:
   explicit SearchBoxFocusHost(views::Widget* search_box_widget)
       : search_box_widget_(search_box_widget) {}
 
@@ skipping 99 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // AppListView:
 
 AppListView::AppListView(AppListViewDelegate* delegate)
     : delegate_(delegate),
       app_list_main_view_(nullptr),
       speech_view_(nullptr),
       search_box_focus_host_(nullptr),
       search_box_widget_(nullptr),
       search_box_view_(nullptr),
+      display_observer_(this),
       overlay_view_(nullptr),
       animation_observer_(new HideViewAnimationObserver()) {
   CHECK(delegate);
 
   delegate_->GetSpeechUI()->AddObserver(this);
+
+  if (features::IsFullscreenAppListEnabled())
+    display_observer_.Add(display::Screen::GetScreen());
 }
 
 AppListView::~AppListView() {
+  // Remove this instance from the DisplayManager's list of observers.
+  if (features::IsFullscreenAppListEnabled())
+    display_observer_.Remove(display::Screen::GetScreen());
+
   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) {
   base::Time start_time = base::Time::Now();
   InitContents(parent, initial_apps_page);
   AddAccelerator(ui::Accelerator(ui::VKEY_ESCAPE, ui::EF_NONE));
   set_color(kContentsBackgroundColor);
   set_parent_window(parent);
 
   if (features::IsFullscreenAppListEnabled())
     InitializeFullscreen(parent, initial_apps_page);
   else
     InitializeBubble(parent, initial_apps_page);
 
   InitChildWidgets();
   AddChildView(overlay_view_);
+
   if (delegate_)
     delegate_->ViewInitialized();
+
   UMA_HISTOGRAM_TIMES("Apps.AppListCreationTime",
                       base::Time::Now() - start_time);
 }
 
 void AppListView::SetBubbleArrow(views::BubbleBorder::Arrow arrow) {
   GetBubbleFrameView()->bubble_border()->set_arrow(arrow);
   SizeToContents();  // Recalcuates with new border.
   GetBubbleFrameView()->SchedulePaint();
 }
 
@@ skipping 12 matching lines @@
   app_list_main_view_->ShowAppListWhenReady();
 }
 
 void AppListView::CloseAppList() {
   app_list_main_view_->Close();
   delegate_->Dismiss();
 }
 
 void AppListView::UpdateBounds() {
   // if the AppListView is a bubble
-  if (!features::IsFullscreenAppListEnabled())
+  if (!launcher_background_shield_)
     SizeToContents();
 }
 
+void AppListView::UpdateDimensions() {
+  display_work_area_bounds_ = display::Screen::GetScreen()
+                                  ->GetDisplayNearestView(parent_window())
+                                  .work_area();
+  default_peeking_launcher_y_ =
+      display_work_area_bounds_.height() + kShelfSize - kPeekingLauncherHeight;
+}
+
 void AppListView::SetAppListOverlayVisible(bool visible) {
   DCHECK(overlay_view_);
 
   // Display the overlay immediately so we can begin the animation.
   overlay_view_->SetVisible(true);
 
   ui::ScopedLayerAnimationSettings settings(
       overlay_view_->layer()->GetAnimator());
   settings.SetTweenType(gfx::Tween::LINEAR);
 
@@ skipping 69 matching lines @@
       ->pagination_model();
 }
 
 void AppListView::InitContents(gfx::NativeView parent, int initial_apps_page) {
   // TODO(vadimt): Remove ScopedTracker below once crbug.com/440224 and
   // crbug.com/441028 are fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "440224, 441028 AppListView::InitContents"));
 
-  app_list_main_view_ = new AppListMainView(delegate_);
+  if (features::IsFullscreenAppListEnabled()) {
+    // The shield view that colors the background of the launcher and makes it
+    // transparent.
+    launcher_background_shield_ = new views::View;
+    launcher_background_shield_->SetPaintToLayer(ui::LAYER_SOLID_COLOR);
+    launcher_background_shield_->layer()->SetColor(SK_ColorBLACK);
+    launcher_background_shield_->layer()->SetOpacity(kLauncherOpacity);
+    AddChildView(launcher_background_shield_);
+  }
+  app_list_main_view_ = new AppListMainView(delegate_, this);
   AddChildView(app_list_main_view_);
   app_list_main_view_->SetPaintToLayer();
   app_list_main_view_->layer()->SetFillsBoundsOpaquely(false);
   app_list_main_view_->layer()->SetMasksToBounds(true);
   // This will be added to the |search_box_widget_| after the app list widget is
   // initialized.
   search_box_view_ = new SearchBoxView(app_list_main_view_, delegate_);
+  search_box_view_->SetAppListView(this);

[vadimt, 2017/05/26 17:58:55]

Constructor parameter, const field.

[newcomer, 2017/05/26 23:20:22]

Done.

   search_box_view_->SetPaintToLayer();
   search_box_view_->layer()->SetFillsBoundsOpaquely(false);
   search_box_view_->layer()->SetMasksToBounds(true);
 
   // TODO(vadimt): Remove ScopedTracker below once crbug.com/440224 and
   // crbug.com/441028 are fixed.
   tracked_objects::ScopedTracker tracking_profile1(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "440224, 441028 AppListView::InitContents1"));
 
@@ skipping 46 matching lines @@
   // Mouse events on the search box shadow should not be captured.
   aura::Window* window = search_box_widget_->GetNativeWindow();
   window->SetEventTargeter(
       base::MakeUnique<SearchBoxWindowTargeter>(search_box_view_));
 
   app_list_main_view_->contents_view()->Layout();
 }
 
 void AppListView::InitializeFullscreen(gfx::NativeView parent,
                                        int initial_apps_page) {
-  views::Widget* widget = new views::Widget;
+  UpdateDimensions();
+
+  gfx::Rect app_list_overlay_view_bounds(
+      display_work_area_bounds_.x(), default_peeking_launcher_y_,
+      display_work_area_bounds_.width(),
+      display_work_area_bounds_.height() + kShelfSize);
+
+  fullscreen_widget_ = new views::Widget;
   views::Widget::InitParams app_list_overlay_view_params(
       views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
 
+  app_list_overlay_view_params.name = "AppList";
   app_list_overlay_view_params.parent = parent;
   app_list_overlay_view_params.delegate = this;
   app_list_overlay_view_params.opacity =
       views::Widget::InitParams::TRANSLUCENT_WINDOW;
-  app_list_overlay_view_params.bounds =
-      display::Screen::GetScreen()->
-      GetDisplayNearestView(parent).work_area();
-  widget->Init(app_list_overlay_view_params);
-  widget->GetLayer()->SetBackgroundBlur(10);
+  app_list_overlay_view_params.bounds = app_list_overlay_view_bounds;
+  app_list_overlay_view_params.layer_type = ui::LAYER_SOLID_COLOR;
+  fullscreen_widget_->Init(app_list_overlay_view_params);
 
+  fullscreen_widget_bounds_ = fullscreen_widget_->GetWindowBoundsInScreen();
   overlay_view_ = new AppListOverlayView(0 /* no corners */);
+
+  // Launcher + shelf height, used in HandleDrag.
+  launcher_threshold_ =
+      (default_peeking_launcher_y_ + fullscreen_widget_bounds_.height() -
+       fullscreen_widget_bounds_.y()) /
+      kLauncherThresholdDenominator;
 }
 
 void AppListView::InitializeBubble(gfx::NativeView parent,
                                    int initial_apps_page) {
   set_margins(gfx::Insets());
   set_close_on_deactivate(false);
   set_shadow(views::BubbleBorder::NO_ASSETS);
 
   // This creates the app list widget. (Before this, child widgets cannot be
-  // created.)
+  // created.
   views::BubbleDialogDelegateView::CreateBubble(this);
 
   SetBubbleArrow(views::BubbleBorder::FLOAT);
   // We can now create the internal widgets.
 
   aura::Window* window = GetWidget()->GetNativeWindow();
   window->SetEventTargeter(base::MakeUnique<views::BubbleWindowTargeter>(this));
 
   const int kOverlayCornerRadius =
       GetBubbleFrameView()->bubble_border()->GetBorderCornerRadius();
   overlay_view_ = new AppListOverlayView(kOverlayCornerRadius);
   overlay_view_->SetBoundsRect(GetContentsBounds());
 }
 
+void AppListView::HandleDrag(gfx::Point location, ui::EventType type) {
+  switch (type) {
+    case ui::ET_GESTURE_SCROLL_BEGIN:
+    case ui::ET_MOUSE_PRESSED: {
+      // Drag start, grab the initial_drag_separation_ to maintain the relative
+      // position of the top of the widget and the mouse/gesture.
+      initial_drag_separation_ = location.y();
+      fullscreen_widget_bounds_ = fullscreen_widget_->GetWindowBoundsInScreen();
+      break;
+    }
+    case ui::ET_GESTURE_SCROLL_UPDATE:
+    case ui::ET_MOUSE_DRAGGED: {
+      // Drag update, update the bounds of the widget while maintaining the
+      // relative position of the top of the widget and the mouse/gesture.
+      // Block drags north of 0 and recalculate the initial_drag_separation_.
+      int new_y_position = location.y() - initial_drag_separation_ +
+                           fullscreen_widget_bounds_.y();
+      if (new_y_position < 0) {
+        fullscreen_widget_bounds_.set_y(0);
+        initial_drag_separation_ = location.y();
+      } else {
+        fullscreen_widget_bounds_.set_y(new_y_position);
+      }
+      fullscreen_widget_->SetBounds(fullscreen_widget_bounds_);
+      break;
+    }
+
+    case ui::ET_GESTURE_END:
+    case ui::ET_MOUSE_RELEASED: {
+      // Drag completion, either snap to fullscreen or close the App List 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 new_y_position = location.y() - initial_drag_separation_ +
+                           fullscreen_widget_bounds_.y();
+      if (std::abs(last_fling_velocity_) > kLauncherDragVelocityThreshold) {
+        // If the user releases drag with velocity over the threshold, snap to
+        // the next state, ignoring the drag release position.
+        if (is_fullscreen_launcher_) {
+          if (last_fling_velocity_ > 0) {
+            ToPeeking();
+          }
+        } else {
+          if (last_fling_velocity_ > 0) {
+            CloseAppList();
+          } else if (last_fling_velocity_ < 0) {
+            ToFullscreen();
+          }
+        }
+        last_fling_velocity_ = 0;
+      } else {
+        // The drag release velocity was too low, so use the release point.
+        int launcher_snap_y =
+            is_fullscreen_launcher_ ? 0 : default_peeking_launcher_y_;
+        // If the user releases +/- 1/3 of launcher_threshold_ , snap to the
+        // next state.
+        if (std::abs(launcher_snap_y - new_y_position) <
+            (launcher_threshold_)) {
+          // If the drag released to the state above.
+          if (is_fullscreen_launcher_) {
+            ToFullscreen();
+          } else {
+            ToPeeking();
+          }
+        } else if ((launcher_snap_y + (launcher_threshold_)) < new_y_position) {
+          // If the user released to the state below.
+          if (is_fullscreen_launcher_) {
+            ToPeeking();
+          } else {
+            CloseAppList();
+          }
+        } else {
+          // if the user released to the state above, go to the state above.
+          ToFullscreen();
+        }
+      }
+      break;
+    }
+    default:
+      NOTREACHED();
+      break;
+  }
+}
+
 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 13 matching lines @@
   return GetBubbleFrameView() != nullptr;
 }
 
 void AppListView::GetWidgetHitTestMask(gfx::Path* mask) const {
   DCHECK(mask);
   DCHECK(GetBubbleFrameView());
 
   mask->addRect(gfx::RectToSkRect(GetBubbleFrameView()->GetContentsBounds()));
 }
 
+void AppListView::OnMouseEvent(ui::MouseEvent* event) {
+  if (!launcher_background_shield_)
+    return;
+
+  switch (event->type()) {
+    case ui::ET_MOUSE_PRESSED:
+    case ui::ET_MOUSE_DRAGGED:
+    case ui::ET_MOUSE_RELEASED:
+      HandleDrag(event->location(), event->type());
+      event->SetHandled();
+      break;
+    default:
+      break;
+  }
+}
+
+void AppListView::OnGestureEvent(ui::GestureEvent* event) {
+  if (!launcher_background_shield_)
+    return;
+
+  switch (event->type()) {
+    case ui::ET_GESTURE_SCROLL_UPDATE:
+      last_fling_velocity_ = event->details().velocity_y();
+      HandleDrag(event->location(), event->type());
+      event->SetHandled();
+      break;
+    case ui::ET_GESTURE_SCROLL_BEGIN:
+    case ui::ET_GESTURE_END:
+      HandleDrag(event->location(), event->type());
+      event->SetHandled();
+      break;
+    default:
+      break;
+  }
+}
+
 bool AppListView::AcceleratorPressed(const ui::Accelerator& accelerator) {
   DCHECK_EQ(ui::VKEY_ESCAPE, accelerator.key_code());
 
   // If the ContentsView does not handle the back action, then this is the
   // top level, so we close the app list.
   if (!app_list_main_view_->contents_view()->Back()) {
     GetWidget()->Deactivate();
     CloseAppList();
   }
 
   // Don't let DialogClientView handle the accelerator.
   return true;
 }
 
 void AppListView::Layout() {
+  // If the fullscreen feature has been enabled.
+  if (launcher_background_shield_) {
+    UpdateDimensions();
+
+    gfx::Rect recomputed_fullscreen_widget_bounds(
+        display_work_area_bounds_.x(), default_peeking_launcher_y_,
+        display_work_area_bounds_.width(),
+        display_work_area_bounds_.height() + kShelfSize);
+
+    fullscreen_widget_bounds_ = recomputed_fullscreen_widget_bounds;
+
+    if (is_fullscreen_launcher_) {
+      ToFullscreen();
+    } else {
+      ToPeeking();
+    }
+  }
   const gfx::Rect contents_bounds = GetContentsBounds();
 
   // Make sure to layout |app_list_main_view_| and |speech_view_| at the center
   // of the widget.
   gfx::Rect centered_bounds = contents_bounds;
   centered_bounds.ClampToCenteredSize(gfx::Size(
       app_list_main_view_->contents_view()->GetDefaultContentsBounds().width(),
       contents_bounds.height()));
 
   app_list_main_view_->SetBoundsRect(centered_bounds);
 
   if (speech_view_) {
     gfx::Rect speech_bounds = centered_bounds;
     int preferred_height = speech_view_->GetPreferredSize().height();
     speech_bounds.Inset(kSpeechUIMargin, kSpeechUIMargin);
     speech_bounds.set_height(
         std::min(speech_bounds.height(), preferred_height));
     speech_bounds.Inset(-speech_view_->GetInsets());
     speech_view_->SetBoundsRect(speech_bounds);
   }
+  // If the fullscreen feature has been enabled.
+  if (launcher_background_shield_) {
+    app_list_main_view_->contents_view()->Layout();
+    launcher_background_shield_->SetBoundsRect(contents_bounds);
+  }
 }
 
 void AppListView::SchedulePaintInRect(const gfx::Rect& rect) {
   BubbleDialogDelegateView::SchedulePaintInRect(rect);
   if (GetBubbleFrameView())
     GetBubbleFrameView()->SchedulePaint();
 }
 
+void AppListView::ToFullscreen() {
+  fullscreen_widget_bounds_.set_y(0);
+  fullscreen_widget_->SetBounds(fullscreen_widget_bounds_);
+  is_fullscreen_launcher_ = true;
+  launcher_threshold_ = (fullscreen_widget_bounds_.height() + kShelfSize) /
+                        kLauncherThresholdDenominator;
+}
+
+void AppListView::ToPeeking() {
+  fullscreen_widget_bounds_.set_y(default_peeking_launcher_y_);
+  fullscreen_widget_->SetBounds(fullscreen_widget_bounds_);
+  is_fullscreen_launcher_ = false;
+  launcher_threshold_ = (fullscreen_widget_bounds_.height() + kShelfSize -
+                         kPeekingLauncherHeight) /
+                        kLauncherThresholdDenominator;
+}
+
+bool AppListView::IsFullscreen() const {
+  return is_fullscreen_launcher_;
+}
+
 void AppListView::OnWidgetDestroying(views::Widget* widget) {
   BubbleDialogDelegateView::OnWidgetDestroying(widget);
   if (delegate_ && widget == GetWidget())
     delegate_->ViewClosing();
 }
 
 void AppListView::OnWidgetVisibilityChanged(views::Widget* widget,
                                             bool visible) {
   BubbleDialogDelegateView::OnWidgetVisibilityChanged(widget, visible);
 
@@ skipping 64 matching lines @@
   } else {
     app_list_main_view_->SetVisible(true);
     // Refocus the search box. However, if the app list widget does not have
     // focus, it means another window has already taken focus, and we *must not*
     // focus the search box (or we would steal focus back into the app list).
     if (GetWidget()->IsActive())
       search_box_view_->search_box()->RequestFocus();
   }
 }
 
+void AppListView::OnDisplayMetricsChanged(const display::Display& display,
+                                          uint32_t changed_metrics) {
+  Layout();
+}
+
 }  // namespace app_list