Draggable peeking/fullscreen launcher with transparent background.

ui/app_list/views/app_list_view.h

 // 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.
 
 #ifndef UI_APP_LIST_VIEWS_APP_LIST_VIEW_H_
 #define UI_APP_LIST_VIEWS_APP_LIST_VIEW_H_
 
 #include <memory>
 
 #include "base/callback.h"
 #include "base/macros.h"
+#include "base/scoped_observer.h"
 #include "build/build_config.h"
 #include "ui/app_list/app_list_export.h"
 #include "ui/app_list/speech_ui_model_observer.h"
+#include "ui/display/display_observer.h"
 #include "ui/views/bubble/bubble_dialog_delegate.h"
 #include "ui/views/widget/widget.h"
 
+namespace display {
+class Screen;
+}
+
 namespace app_list {
 class ApplicationDragAndDropHost;
 class AppListMainView;
 class AppListModel;
 class AppListViewDelegate;
 class HideViewAnimationObserver;
 class PaginationModel;
 class SearchBoxView;
 class SpeechView;
 
 namespace test {
 class AppListViewTestApi;
 }
 
 // AppListView is the top-level view and controller of app list UI. It creates
 // and hosts a AppsGridView and passes AppListModel to it for display.
 class APP_LIST_EXPORT AppListView : public views::BubbleDialogDelegateView,
-                                    public SpeechUIModelObserver {
+                                    public SpeechUIModelObserver,
+                                    public display::DisplayObserver {
  public:
+  enum AppListState { INITIAL = 0, PEEKING, FULLSCREEN };

[msw, 2017/06/07 02:31:39]

Comment on this enum and each of its states, the concept of peeking and
fullscreen app list states are new and will be unfamiliar to most readers. Also,
replace INITIAL with CLOSED (or remove INITIAL and initialize |app_list_state_|
to the actual peeking/fullscreen initial state when the view is constructed)?

[newcomer, 2017/06/07 17:21:37]

Done.

+
   // Does not take ownership of |delegate|.
   explicit AppListView(AppListViewDelegate* delegate);
   ~AppListView() override;
 
   // Initializes the widget as a bubble or fullscreen view depending on the
   // presence of a cmd line switch. parent and initial_apps_page are used for
   // both the bubble and fullscreen initialization.
   void Initialize(gfx::NativeView parent, int initial_apps_page);
 
   void SetBubbleArrow(views::BubbleBorder::Arrow arrow);
 
   void MaybeSetAnchorPoint(const gfx::Point& anchor_point);
 
   // If |drag_and_drop_host| is not NULL it will be called upon drag and drop
   // operations outside the application list. This has to be called after
   // Initialize was called since the app list object needs to exist so that
   // it can set the host.
   void SetDragAndDropHostOfCurrentAppList(
       ApplicationDragAndDropHost* drag_and_drop_host);
 
   // Shows the UI when there are no pending icon loads. Otherwise, starts a
   // timer to show the UI when a maximum allowed wait time has expired.
   void ShowWhenReady();
 
   void CloseAppList();

[msw, 2017/06/07 02:31:38]

You could potentially replace this with SetState(CLOSED)

[newcomer, 2017/06/07 17:21:38]

Done.

 
   void UpdateBounds();
 
   // Enables/disables a semi-transparent overlay over the app list (good for
   // hiding the app list when a modal dialog is being shown).
   void SetAppListOverlayVisible(bool visible);
 
   views::Widget* search_box_widget() const { return search_box_widget_; }
 
   // Overridden from views::View:
@@ skipping 10 matching lines @@
   AppListMainView* app_list_main_view() { return app_list_main_view_; }
 
   // Gets the PaginationModel owned by this view's apps grid.
   PaginationModel* GetAppsPaginationModel();
 
   // Overridden from views::View:
   bool AcceleratorPressed(const ui::Accelerator& accelerator) override;
   void Layout() override;
   void SchedulePaintInRect(const gfx::Rect& rect) override;
 
+  // Changes the view to the peeking state or to the fullscreen state.
+  void ToFullscreen();

[msw, 2017/06/07 02:31:39]

Remove these now that we have ChangeState/SetState.

[newcomer, 2017/06/07 17:21:38]

Done.

+  void ToPeeking();
+  void ChangeState(AppListState new_state);

[msw, 2017/06/07 02:31:39]

Rename this SetState

[newcomer, 2017/06/07 17:21:38]

Done.

+
+  bool IsFullscreen() const;

[msw, 2017/06/07 02:31:39]

Change this to |AppListState app_list_state() const { return app_list_state_; }
You can optionally also/instead do |bool is_fullscreen() const { return
app_list_state_ == FULLSCREEN; }

[newcomer, 2017/06/07 17:21:38]

I think having both is a good idea. Thanks!

+
  private:
   friend class test::AppListViewTestApi;
 
   void InitContents(gfx::NativeView parent, int initial_apps_page);
 
   void InitChildWidgets();
 
   // Initializes the widget for fullscreen mode.
   void InitializeFullscreen(gfx::NativeView parent, int initial_apps_page);
 
   // Initializes the widget as a bubble.
   void InitializeBubble(gfx::NativeView parent, int initial_apps_page);
 
+  // Initializes |initial_drag_point_|.
+  void StartDrag(const gfx::Point& location);
+
+  // Updates the bounds of the widget while maintaining the relative position
+  // of the top of the widget and the gesture.
+  void UpdateDrag(const gfx::Point& location);
+
+  // Handles app list state transfers. If the drag was fast enough, ignore the
+  // release position and snap to the next state.
+  void EndDrag(const gfx::Point& location);
+
   // Overridden from views::BubbleDialogDelegateView:
   void OnBeforeBubbleWidgetInit(views::Widget::InitParams* params,
                                 views::Widget* widget) const override;
   int GetDialogButtons() const override;
 
   // Overridden from views::WidgetDelegateView:
   views::View* GetInitiallyFocusedView() override;
   bool WidgetHasHitTestMask() const override;
   void GetWidgetHitTestMask(gfx::Path* mask) const override;
 
+  // Overridden from ui::EventHandler:
+  void OnMouseEvent(ui::MouseEvent* event) override;
+  void OnGestureEvent(ui::GestureEvent* event) override;
+
   // Overridden from views::WidgetObserver:
   void OnWidgetDestroying(views::Widget* widget) override;
   void OnWidgetVisibilityChanged(views::Widget* widget, bool visible) override;
 
   // Overridden from SpeechUIModelObserver:
   void OnSpeechRecognitionStateChanged(
       SpeechRecognitionState new_state) override;
 
+  // Overridden from DisplayObserver:
+  void OnDisplayMetricsChanged(const display::Display& display,
+                               uint32_t changed_metrics) override;
+
   AppListViewDelegate* delegate_;  // Weak. Owned by AppListService.
 
   AppListMainView* app_list_main_view_;
   SpeechView* speech_view_;
+  views::Widget* fullscreen_widget_ = nullptr;  // Owned by AppListView.
 
   views::View* search_box_focus_host_;  // Owned by the views hierarchy.
   views::Widget* search_box_widget_;    // Owned by the app list's widget.
   SearchBoxView* search_box_view_;      // Owned by |search_box_widget_|.
+  // Owned by the app list's widget. Null if the fullscreen app list is not
+  // enabled.
+  views::View* app_list_background_shield_ = nullptr;
+  // The gap between the initial gesture event and the top of the window.
+  gfx::Point initial_drag_point_;
+  // The velocity of the gesture event.
+  float last_fling_velocity_ = 0;
+  // The default y coordinate of the current state of the app list. Changes
+  // based on the app list state and screen orientation.
+  int default_peeking_y_ = 0;

[msw, 2017/06/07 02:31:39]

Remove this, it's no longer used.

[newcomer, 2017/06/07 17:21:38]

Done.

+  bool is_fullscreen_app_list_ = false;

[msw, 2017/06/07 02:31:39]

Remove this, it's no longer used.

[newcomer, 2017/06/07 17:21:38]

Done.

+  // Flag temporarily used to prevent repeated calls to
+  // features::IsFullscreenAppListEnabled.
+  bool is_fullscreen_app_list_enabled_ = false;

[msw, 2017/06/07 02:31:39]

Move this to a file-local function in cc file's anon namespace, like:
bool IsFullscreenAppListEnabled() {
  // Cache this value to avoid repeated lookup.
  static bool cached_value = features::IsFullscreenAppListEnabled();
  return cached_value;
}

[newcomer, 2017/06/07 17:21:38]

Done.

+  // The desktop area, not including the shelf.
+  gfx::Rect display_work_area_bounds_;

[msw, 2017/06/07 02:31:39]

Remove this, it's no longer used.

[newcomer, 2017/06/07 17:21:38]

Done.

+  // The bounds of the app list. The size should never change, only the
+  // position.
+  gfx::Rect fullscreen_widget_bounds_;

[msw, 2017/06/07 02:31:39]

Remove this, it's no longer used.

[newcomer, 2017/06/07 17:21:37]

Done.

+  // The state of the app list, controlled via ChangeState().

[msw, 2017/06/07 02:31:39]

Update ChangeState -> SetState if you accept that rename, or just remove ",
controlled via ChangeState()"

[newcomer, 2017/06/07 17:21:37]

Done.

+  AppListState app_list_state_;

[msw, 2017/06/07 02:31:39]

Initialize this value here or in the constructor.

[newcomer, 2017/06/07 17:21:38]

Initialized in the constructor.

+
+  // An observer that notifies AppListView when the display has changed.
+  ScopedObserver<display::Screen, display::DisplayObserver> display_observer_;
 
   // A semi-transparent white overlay that covers the app list while dialogs are
   // open.
   views::View* overlay_view_;
 
   std::unique_ptr<HideViewAnimationObserver> animation_observer_;
 
   // For UMA and testing. If non-null, triggered when the app list is painted.
   base::Closure next_paint_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(AppListView);
 };
 
 }  // namespace app_list
 
 #endif  // UI_APP_LIST_VIEWS_APP_LIST_VIEW_H_