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

athena/home/home_card_impl.cc

 // Copyright 2014 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 "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"
 
 namespace athena {
 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) {
     virtual_keyboard_bounds_ = bounds;
     Layout();
   }
 
  private:
   // aura::LayoutManager:
   virtual void OnWindowResized() OVERRIDE { Layout(); }
   virtual void OnWindowAddedToLayout(aura::Window* child) OVERRIDE { Layout(); }
   virtual void OnWillRemoveWindowFromLayout(aura::Window* child) OVERRIDE {}
   virtual void OnWindowRemovedFromLayout(aura::Window* child) OVERRIDE {
     Layout();
   }
   virtual void OnChildWindowVisibilityChanged(aura::Window* child,
                                               bool visible) OVERRIDE {
     Layout();
   }
   virtual void SetChildBounds(aura::Window* child,
                               const gfx::Rect& requested_bounds) OVERRIDE {
     SetChildBoundsDirect(child, gfx::Rect(requested_bounds.size()));
   }
 
   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();
 
   void Init();
 
  private:
   enum Command {
     COMMAND_SHOW_HOME_CARD,
   };
@@ skipping 11 matching lines @@
   virtual bool OnAcceleratorFired(int command_id,
                                   const ui::Accelerator& accelerator) OVERRIDE {
     DCHECK_EQ(COMMAND_SHOW_HOME_CARD, command_id);
     if (state_ == HIDDEN)
       SetState(VISIBLE_CENTERED);
     else
       SetState(HIDDEN);
     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_;
 
   // Right now HomeCard allows only one search provider.
   // TODO(mukai): port app-list's SearchController and Mixer.
   scoped_ptr<app_list::SearchProvider> search_provider_;
 
   DISALLOW_COPY_AND_ASSIGN(HomeCardImpl);
 };
 
 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;
 }
 
 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(
     app_list::SearchProvider* search_provider) {
   DCHECK(!search_provider_);
   search_provider_.reset(search_provider);
   view_delegate_->RegisterSearchProvider(search_provider_.get());
 }
 
 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);
 }
 
 void HomeCardImpl::Init() {
   InstallAccelerators();
 
   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);
 
   view_delegate_ = new AppListViewDelegate(model_builder_.get());
   if (search_provider_)
     view_delegate_->RegisterSearchProvider(search_provider_.get());
   app_list::AppListView* view = new app_list::AppListView(view_delegate_);
   view->InitAsBubbleAtFixedLocation(
       container,
       0 /* initial_apps_page */,
       gfx::Point(),
       views::BubbleBorder::FLOAT,
       true /* border_accepts_events */);
   home_card_widget_ = view->GetWidget();
   // 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() {
   const AcceleratorData accelerator_data[] = {
       {TRIGGER_ON_PRESS, ui::VKEY_L, ui::EF_CONTROL_DOWN,
        COMMAND_SHOW_HOME_CARD, AF_NONE},
   };
   AcceleratorManager::Get()->RegisterAccelerators(
       accelerator_data, arraysize(accelerator_data), this);
 }
@@ skipping 14 matching lines @@
   instance = NULL;
 }
 
 // static
 HomeCard* HomeCard::Get() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena