[ash-md] Fades overview header in and out

ash/common/wm/overview/window_selector_item.h

 // Copyright 2013 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 ASH_COMMON_WM_OVERVIEW_WINDOW_SELECTOR_ITEM_H_
 #define ASH_COMMON_WM_OVERVIEW_WINDOW_SELECTOR_ITEM_H_
 
 #include <memory>
 
 #include "ash/ash_export.h"
 #include "ash/common/wm/overview/scoped_transform_overview_window.h"
 #include "ash/common/wm_window_observer.h"
 #include "base/macros.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/views/controls/button/button.h"
+#include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/button/label_button.h"
 #include "ui/views/widget/widget.h"
 
 namespace views {
 class ImageButton;
 }
 
 namespace wm {
 class Shadow;
 }
@@ skipping 10 matching lines @@
   class OverviewLabelButton : public views::LabelButton {
    public:
     OverviewLabelButton(views::ButtonListener* listener,
                         const base::string16& text);
 
     ~OverviewLabelButton() override;
 
     // Makes sure that text is readable with |background_color|.
     void SetBackgroundColorHint(SkColor background_color);
 
+    // Disconnects the listener so that the listener can go out of scope.
+    void Disconnect() { listener_ = nullptr; }

[bruthig, 2016/09/08 18:32:50]

nit: I find it really odd that Button::listener_ is protected yet everything
seems to use Button::set_listener().  No action requested but it might be better
to use set_listener().

[varkha, 2016/09/09 02:25:25]

There is no Button::set_listener() (but there is one in Checkbox. I can (in a
separate CL of course) add a protected set_listener() to Button, make
|listener_| private and expose set_listener in Checkbox.

+
     void set_padding(const gfx::Insets& padding) { padding_ = padding; }
 
    protected:
     // views::LabelButton:
     gfx::Rect GetChildAreaBounds() override;
 
    private:
     // Padding on all sides to correctly place the text inside the view.
     gfx::Insets padding_;
 
     DISALLOW_COPY_AND_ASSIGN(OverviewLabelButton);
   };
 
+  // An image button with a close window icon.
+  class OverviewCloseButton : public views::ImageButton {
+   public:
+    explicit OverviewCloseButton(views::ButtonListener* listener);
+    ~OverviewCloseButton() override;
+
+    // Disconnects the listener so that the listener can go out of scope.
+    void Disconnect() { listener_ = nullptr; }
+
+   private:
+    gfx::ImageSkia icon_image_;
+
+    DISALLOW_COPY_AND_ASSIGN(OverviewCloseButton);
+  };
+
   WindowSelectorItem(WmWindow* window, WindowSelector* window_selector);
   ~WindowSelectorItem() override;
 
   WmWindow* GetWindow();
 
   // Returns the root window on which this item is shown.
   WmWindow* root_window() { return root_window_; }
 
   // Returns true if |target| is contained in this WindowSelectorItem.
   bool Contains(const WmWindow* target) const;
@@ skipping 36 matching lines @@
   void RecomputeWindowTransforms();
 
   // Sends an accessibility event indicating that this window became selected
   // so that it's highlighted and announced if accessibility features are
   // enabled.
   void SendAccessibleSelectionEvent();
 
   // Closes |transform_window_|.
   void CloseWindow();
 
+  // Hides the original window header and sets shape or mask on a window.
+  // When masks are used, rounded corner |radius| can be specified.
+  // TODO(varkha): remove |radius|.
+  void HideHeaderAndSetShape(int radius);
+
   // Sets if the item is dimmed in the overview. Changing the value will also
   // change the visibility of the transform windows.
   void SetDimmed(bool dimmed);
   bool dimmed() const { return dimmed_; }
 
   const gfx::Rect& target_bounds() const { return target_bounds_; }
   static void set_use_mask(bool use_mask) { use_mask_ = use_mask; }
   static void set_use_shape(bool use_shape) { use_shape_ = use_shape; }
 
   // views::ButtonListener:
   void ButtonPressed(views::Button* sender, const ui::Event& event) override;
 
   // WmWindowObserver:
   void OnWindowDestroying(WmWindow* window) override;
   void OnWindowTitleChanged(WmWindow* window) override;
 
  private:
   class CaptionContainerView;
+  class RoundedContainerView;
   friend class WindowSelectorTest;
 
+  enum HeaderFadeInMode {
+    Enter,
+    Update,
+    Exit,
+  };
+
   // Sets the bounds of this selector's items to |target_bounds| in
   // |root_window_|. The bounds change will be animated as specified
   // by |animation_type|.
   void SetItemBounds(const gfx::Rect& target_bounds,
                      OverviewAnimationType animation_type);
 
   // Changes the opacity of all the windows the item owns.
   void SetOpacity(float opacity);
 
   // Updates the window label bounds.
   void UpdateWindowLabel(const gfx::Rect& window_bounds,
                          OverviewAnimationType animation_type);
 
   // Creates the window label.
   void CreateWindowLabel(const base::string16& title);
 
   // Updates the close button's and title label's bounds. Any change in bounds
   // will be animated from the current bounds to the new bounds as per the
-  // |animation_type|.
-  void UpdateHeaderLayout(OverviewAnimationType animation_type);
+  // |animation_type|. |mode| allows distinguishing the first time update which
+  // allows setting the initial bounds properly.
+  void UpdateHeaderLayout(HeaderFadeInMode mode,
+                          OverviewAnimationType animation_type);
 
   // Animates opacity of the |transform_window_| and its caption to |opacity|
   // using |animation_type|.
   void AnimateOpacity(float opacity, OverviewAnimationType animation_type);
 
   // Updates the close buttons accessibility name.
   void UpdateCloseButtonAccessibilityName();
 
+  // Fades out a window caption when exiting overview mode.
+  void FadeOut(std::unique_ptr<views::Widget> widget);
+
   static bool hide_header() { return use_mask_ || use_shape_; }
 
   // True if the item is being shown in the overview, false if it's being
   // filtered.
   bool dimmed_;
 
   // The root window this item is being displayed on.
   WmWindow* root_window_;
 
   // The contained Window's wrapper.
   ScopedTransformOverviewWindow transform_window_;
 
   // The target bounds this selector item is fit within.
   gfx::Rect target_bounds_;
 
   // True if running SetItemBounds. This prevents recursive calls resulting from
   // the bounds update when calling ::wm::RecreateWindowLayers to copy
   // a window layer for display on another monitor.
   bool in_bounds_update_;
 
+  // True when |this| item is visually selected. Item header is made transparent
+  // when the item is selected.
+  bool selected_;
+
   // Label displaying its name (active tab for tabbed windows).
   // With Material Design this Widget owns |caption_container_view_| and is
   // shown above the |transform_window_|.
   // Otherwise it is shown under the window.
   std::unique_ptr<views::Widget> window_label_;
 
   // Shadow around the item in overview.
   std::unique_ptr<::wm::Shadow> shadow_;
 
-  // Label background widget used to fade in opacity when moving selection.
-  std::unique_ptr<views::Widget> window_label_selector_;
-
   // Container view that owns |window_label_button_view_| and |close_button_|.
   // Only used with Material Design.
   CaptionContainerView* caption_container_view_;
 
   // View for the label below the window or (with material design) above it.
   OverviewLabelButton* window_label_button_view_;
 
   // The close buttons widget container. Not used with Material Design.
   std::unique_ptr<views::Widget> close_button_widget_;
 
   // A close button for the window in this item. Owned by the
   // |caption_container_view_| with Material Design or by |close_button_widget_|
   // otherwise.
-  views::ImageButton* close_button_;
+  OverviewCloseButton* close_button_;
 
   // Pointer to the WindowSelector that owns the WindowGrid containing |this|.
   // Guaranteed to be non-null for the lifetime of |this|.
   WindowSelector* window_selector_;
 
+  // Pointer to a view that covers the original header and has rounded top
+  // corners. This view can have its color and opacity animated.
+  RoundedContainerView* background_view_;
+
   // If true, mask the original window header while in overview and make corners
   // rounded using a mask layer. This has performance implications so it can be
   // disabled when there are many windows.
   static bool use_mask_;
 
   // If true, hide the original window header while in overview using alpha
   // shape. This has performance implications so it can be disabled when there
   // are many windows.
   static bool use_shape_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowSelectorItem);
 };
 
 }  // namespace ash
 
 #endif  // ASH_COMMON_WM_OVERVIEW_WINDOW_SELECTOR_ITEM_H_