athena: Add a minimized state for the home-card.

athena/home/home_card_impl.cc

Index: athena/home/home_card_impl.cc
diff --git a/athena/home/home_card_impl.cc b/athena/home/home_card_impl.cc
index 5edf5de4ff1fd7603c83474b232f6fe00fa962d0..9d9202cc4a5c9ae857f61808c43109f65a2c99f8 100644
--- a/athena/home/home_card_impl.cc
+++ b/athena/home/home_card_impl.cc
@@ -5,13 +5,17 @@
 #include "athena/home/public/home_card.h"
 
 #include "athena/home/app_list_view_delegate.h"
+#include "athena/home/minimized_home.h"
 #include "athena/home/public/app_model_builder.h"
 #include "athena/input/public/accelerator_manager.h"
 #include "athena/screen/public/screen_manager.h"
+#include "athena/wm/public/window_manager.h"
+#include "base/bind.h"
 #include "ui/app_list/search_provider.h"
 #include "ui/app_list/views/app_list_view.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
+#include "ui/views/layout/box_layout.h"
 #include "ui/wm/core/visibility_controller.h"
 #include "ui/wm/core/window_animations.h"
 
@@ -20,10 +24,25 @@ namespace {
 
 HomeCard* instance = NULL;
 
+// Makes sure the homecard is center-aligned horizontally and bottom-aligned
+// vertically.
 class HomeCardLayoutManager : public aura::LayoutManager {
  public:
-  explicit HomeCardLayoutManager(aura::Window* container)
-      : container_(container) {}
+  class Delegate {
+   public:
+    virtual ~Delegate() {}
+
+    virtual int GetHomeCardHeight() const = 0;
+
+    virtual int GetHorizontalMargin() const = 0;

[oshima, 2014/07/16 16:24:31]

How about returning preferred size?

[sadrul, 2014/07/16 16:58:26]

I considered doing that, but that would require the delegate to have to query
the screen-size and apply the margin (if applicable) to decide the width. It
feels better to let the layout-manager take care of that.

[oshima, 2014/07/16 19:10:38]

OK, i wont block CL, but asking home card horizontal margin is also a bit weird.
We probably can revisit this later when we have better window management.

+
+    // TODO(mukai): Remove this when bubble is no longer used for
+    // VISIBLE_CENTERED or VISIBLE_BOTTOM states.
+    virtual bool HasShadow() const = 0;
+  };
+
+  HomeCardLayoutManager(Delegate* delegate, aura::Window* container)
+      : delegate_(delegate), container_(container) {}
   virtual ~HomeCardLayoutManager() {}
 
   void UpdateVirtualKeyboardBounds(const gfx::Rect& bounds) {
@@ -49,37 +68,48 @@ class HomeCardLayoutManager : public aura::LayoutManager {
   }
 
   void Layout() {
-    const int kHomeCardHeight = 150;
-    const int kHomeCardHorizontalMargin = 50;
-    // Currently the home card is provided as a bubble and the bounds has to be
-    // increased to cancel the shadow.
-    // TODO(mukai): stops using the bubble and remove this.
-    const int kHomeCardShadowWidth = 30;
+    int height = delegate_->GetHomeCardHeight();
+    int horiz_margin = delegate_->GetHorizontalMargin();
     if (container_->children().size() < 1)
       return;
+
+    // There should only be a single visible window. Find it.
     aura::Window* home_card = container_->children()[0];
-    if (!home_card->IsVisible())
+    for (size_t i = 1; !home_card->IsVisible() && i <
+         container_->children().size(); ++i) {
+      home_card = container_->children()[i];
+    }

[oshima, 2014/07/16 16:24:31]

can we just pass the window of the home card instead?

[sadrul, 2014/07/16 16:58:26]

Done (introduced HomeCard::GetNativeWindow()).

+    if (!home_card)
       return;
 
     gfx::Rect screen_bounds = home_card->GetRootWindow()->bounds();
     if (!virtual_keyboard_bounds_.IsEmpty())
       screen_bounds.set_height(virtual_keyboard_bounds_.y());
     gfx::Rect card_bounds = screen_bounds;
-    card_bounds.Inset(kHomeCardHorizontalMargin,
-                      screen_bounds.height() - kHomeCardHeight,
-                      kHomeCardHorizontalMargin,
-                      0);
-    card_bounds.Inset(-kHomeCardShadowWidth, -kHomeCardShadowWidth);
+    card_bounds.Inset(horiz_margin, screen_bounds.height() - height,
+                      horiz_margin, 0);
+
+    if (delegate_->HasShadow()) {
+      // Currently the home card is provided as a bubble and the bounds has to
+      // be increased to cancel the shadow.
+      // TODO(mukai): stops using the bubble and remove this.

[oshima, 2014/07/16 16:24:31]

Can't we just disable bubble's shadow using AppListView::set_shadow?

[sadrul, 2014/07/16 16:58:26]

I tried that, but it looks like we still need this piece of code to make the
bubble bottom-aligned with the screen. mukai@ would know more.

[Jun Mukai, 2014/07/16 18:31:56]

That is right, unfortunately it's hard to disable shadows of bubbles.
Eventually I'll remove the dependency on bubble and let athena homecard be a
widget.  Please keep this until then.

+      const int kHomeCardShadowWidth = 30;
+      card_bounds.Inset(-kHomeCardShadowWidth, -kHomeCardShadowWidth);
+    }
     SetChildBoundsDirect(home_card, card_bounds);
   }
 
+  Delegate* delegate_;
   aura::Window* container_;
   gfx::Rect virtual_keyboard_bounds_;
 
   DISALLOW_COPY_AND_ASSIGN(HomeCardLayoutManager);
 };
 
-class HomeCardImpl : public HomeCard, public AcceleratorHandler {
+class HomeCardImpl : public HomeCard,
+                     public AcceleratorHandler,
+                     public HomeCardLayoutManager::Delegate,
+                     public MinimizedHomeDragDelegate {
  public:
   explicit HomeCardImpl(AppModelBuilder* model_builder);
   virtual ~HomeCardImpl();
@@ -111,11 +141,38 @@ class HomeCardImpl : public HomeCard, public AcceleratorHandler {
     return true;
   }
 
+  // HomeCardLayoutManager::Delegate:
+  virtual int GetHomeCardHeight() const OVERRIDE {
+    const int kHomeCardHeight = 150;
+    const int kHomeCardMinimizedHeight = 8;
+    CHECK_NE(HIDDEN, state_);
+    return state_ == VISIBLE_MINIMIZED ? kHomeCardMinimizedHeight :
+                                         kHomeCardHeight;
+  }
+
+  virtual int GetHorizontalMargin() const OVERRIDE {
+    CHECK_NE(HIDDEN, state_);
+    const int kHomeCardHorizontalMargin = 50;
+    return state_ == VISIBLE_MINIMIZED ? 0 : kHomeCardHorizontalMargin;
+  }
+
+  virtual bool HasShadow() const OVERRIDE {
+    CHECK_NE(HIDDEN, state_);
+    return state_ != VISIBLE_MINIMIZED;
+  }
+
+  // MinimizedHomeDragDelegate:
+  virtual void OnDragUpCompleted() OVERRIDE {
+    SetState(VISIBLE_BOTTOM);
+    WindowManager::GetInstance()->ToggleOverview();
+  }
+
   scoped_ptr<AppModelBuilder> model_builder_;
 
   HomeCard::State state_;
 
   views::Widget* home_card_widget_;
+  views::Widget* minimized_widget_;
   AppListViewDelegate* view_delegate_;
   HomeCardLayoutManager* layout_manager_;
 
@@ -128,8 +185,9 @@ class HomeCardImpl : public HomeCard, public AcceleratorHandler {
 
 HomeCardImpl::HomeCardImpl(AppModelBuilder* model_builder)
     : model_builder_(model_builder),
-      state_(HIDDEN),
+      state_(VISIBLE_MINIMIZED),
       home_card_widget_(NULL),
+      minimized_widget_(NULL),
       layout_manager_(NULL) {
   DCHECK(!instance);
   instance = this;
@@ -138,16 +196,25 @@ HomeCardImpl::HomeCardImpl(AppModelBuilder* model_builder)
 HomeCardImpl::~HomeCardImpl() {
   DCHECK(instance);
   home_card_widget_->CloseNow();
+  minimized_widget_->CloseNow();
   view_delegate_ = NULL;
   instance = NULL;
 }
 
 void HomeCardImpl::SetState(HomeCard::State state) {
-  if (state == HIDDEN)
+  // Update |state_| before changing the visibility of the widgets, so that
+  // LayoutManager callbacks get the correct state.
+  state_ = state;
+  if (state == VISIBLE_MINIMIZED) {

[oshima, 2014/07/16 16:24:31]

would you mind using switch instead?

[sadrul, 2014/07/16 16:58:26]

Done.

     home_card_widget_->Hide();
-  else
+    minimized_widget_->Show();
+  } else if (state == HIDDEN) {
+    home_card_widget_->Hide();
+    minimized_widget_->Hide();
+  } else {
     home_card_widget_->Show();
-  state_ = state;
+    minimized_widget_->Hide();
+  }
 }
 
 void HomeCardImpl::RegisterSearchProvider(
@@ -159,6 +226,12 @@ void HomeCardImpl::RegisterSearchProvider(
 
 void HomeCardImpl::UpdateVirtualKeyboardBounds(
     const gfx::Rect& bounds) {
+  if (state_ == VISIBLE_MINIMIZED) {
+    if (bounds.IsEmpty())
+      minimized_widget_->Show();
+    else
+      minimized_widget_->Hide();
+  }
   layout_manager_->UpdateVirtualKeyboardBounds(bounds);
 }
 
@@ -167,7 +240,7 @@ void HomeCardImpl::Init() {
 
   aura::Window* container =
       ScreenManager::Get()->CreateContainer("HomeCardContainer");
-  layout_manager_ = new HomeCardLayoutManager(container);
+  layout_manager_ = new HomeCardLayoutManager(this, container);
   container->SetLayoutManager(layout_manager_);
   wm::SetChildWindowVisibilityChangesAnimated(container);
 
@@ -185,6 +258,10 @@ void HomeCardImpl::Init() {
   // TODO: the initial value might not be visible.
   state_ = VISIBLE_CENTERED;
   view->ShowWhenReady();

[Jun Mukai, 2014/07/16 05:53:58]

Please remove line 258-260.
ShowWhenReady() seems to reschedule showing if it's not ready (due to icon load
or something).  Keeping this is okay right now but might cause weird effect in
the future.

It seems like InitAsBubbleAtFixedLocation() creates Widget, so it's okay to just
remove these lines for now. I'll deal with icon loading issue when necessary.

[sadrul, 2014/07/16 16:58:26]

Done.

+
+  // Start off in the minimized state.
+  minimized_widget_ = CreateMinimizedHome(container, this);
+  SetState(VISIBLE_MINIMIZED);
 }
 
 void HomeCardImpl::InstallAccelerators() {